Construct a signed SAML2 LogOut request

Question

My aim is to implement the Single Log Out Protocol. First I am understanding how the standar works and how I can fit it in my scenario: ADFS 2.0 as IdP, for me is like a "black box"

What I am doing at the moment is the next:

1. Send an <AuthnRequest> to my IdP

2. IdP asks me for credentials, I provide them and get succesfully login.

3. Get the SessionIndex value form the and constructs a <LogoutRequest>

<samlp:LogoutRequest xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol" xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion" ID="_135ad2fd-b275-4428-b5d6-3ac3361c3a7f" Version="2.0" Destination="https://idphost/adfs/ls/" IssueInstant="2008-06-03T12:59:57Z"><saml:Issuer>myhost</saml:Issuer><NameID Format="urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress" NameQualifier="https://idphost/adfs/ls/">[e-mail]</NameID<samlp:SessionIndex>_0628125f-7f95-42cc-ad8e-fde86ae90bbe</samlp:SessionIndex></samlp:LogoutRequest>

1. Take the above <LogoutRequest> and encode it in Base64

2. Contructs the next string: SAMLRequest=base64encodedRequest&SigAlg=http%3A%2F%2Fwww.w3.org%2F2000%2F09%2Fxmldsig%23rsa-sha1

3. With the above string generates the signature

4. Encode the signature in base64

5. Send the request: https://"https://idphost/adfs/ls/?SAMLRequest=base64encodedRequest&SigAlg=http%3A%2F%2Fwww.w3.org%2F2000%2F09%2Fxmldsig%23rsa-sha1&Signature=base64EncodedSignature

But the IdP is answering me: The verification of the SAML message signature failed.

For signing I am using my private key (2048 bytes), and for verifying it is supposed that the IdP is using my public key (the one that I sent it when I registered my host)

The code for signing the request looks like:

// Retrieve the private key
KeyStore keyStore = KeyStore.getInstance("JKS", "SUN");
FileInputStream stream;
stream = new FileInputStream("/path/to/my/keystore.jks");
keyStore.load(stream, "storepass".toCharArray());
PrivateKey key = (PrivateKey) keyStore.getKey("keyAlias","keyPass".toCharArray());

// Create the signature
Signature signature = Signature.getInstance("SHA1withRSA");
signature.initSign(key);
signature.update("SAMLRequest=jVJda8IwFH2e4H8ofW%2BbVmvboGWCDApusDn2sBdJm1sNtEmXmw7x1y92KDrY2Ov5uueEzJG1TUfXaqd68wIfPaBxDm0jkQ7Mwu21pIqhQCpZC0hNRTfLxzWNfEI7rYyqVONeWf52METQRijpOsVq4W7JoSzjJJnWAEAmwLMMpmRG0jCrYJICIcR13kCjdSxcG%2BA6K9tQSGYGZG9MhzQIGrUT0uPw6VegpV%2FtA8ZrDBq0ZxB7KCQaJo2NICT1yMwjk9cwonFG4%2BTdzceju%2FmpOx3EOu8qYThgGJ3j5sE1fZE%2F2X3FynlQumXm9%2BGhHw6I4F49SCm0TDRLzjWgrXiKee5ZI2oB%2Bj%2Bj8qYX6GvFtdj1cPRryzPJ4Xh%2F2%2Fe736VvRzf2nn24wmoP%2BZbMojSM4tpL6iz2plFVeYyn4NUc0hmDjJQlfCf9cI5HZ%2Fjm4%2BRf&RelayState=null&SigAlg=http%3A%2F%2Fwww.w3.org%2F2000%2F09%2Fxmldsig%23rsa-sha1".getBytes());

String signatureBase64encodedString = (new BASE64Encoder()).encodeBuffer(signature.sign());

Answer 1

As we had many steps to take to finally get SLO successfully implemented on Domino 9.0.1, I decided to write code which will allow using any (future) IdP configuration to run with our Domino servers. I implemented the following strategy:

• Use as much of the information available from an incoming SAML Logout Request as possible
• Identify the IdP configuration in the idpcat.nsf to find corresponding information about the IdP SLO Response to be sent to the IdP Service provider (SAML Server)
• Define the SAML Logout Response in the corresponding IdP configuration in the idpcat.nsf to allow dynamical adaption to new requirements if SAML configuration changes.

As a result, the code reads all fields of the incoming SAML Logout Request into a Parameter Map and decodes and inflates the query string to extract the XML Parameters of the Request into the Parameter Map. As different websites on the domino server can be configured for different IdP service providers to allow SSO connection, I identify the IdP configuration with the corresponding "host name" and read all its fields in the same Parameter Map. For defining an applicable XML Response I decided to write all needed definitions into the Comment of the IdP configuration, which allows to adapt single IdP configurations to use the same code for different IdP providers even if the use different SAML versions. The definitions in the Comment field of the IdP configuration in the idpcat.nsf look like:

SLO Response: /idp/SLO.saml2;

SLO Response XML: "<"urn:LogoutResponse ID="@UUID" Version="#Version" IssueInstant="@ACTUAL_TIME" Destination="SLO_Response" InResponseTo="#ID" xmlns:urn="#xmlns:urn">" "<"urn1:Issuer xmlns:urn1="XML_Parameter1"">"HTTP_HSP_LISTENERURI"<"/urn1:Issuer">" "<"urn:Status">" "<"urn:StatusCode Value="XML_Parameter2"/">" "<"/urn:Status">" "<"/urn:LogoutResponse">";

XML Values: #xmlns:urn=protocol -> assertion&#xmlns:urn=protocol -> status:Success;

Response Parameters: RelayState&SigAlg&Signature;

Signature Type: SHA256withRSA;

KeyStore Type: PKCS12;

KeyStore File: D:\saml_cert.pfx;

KeyStore Password: **********;

Certificate: {xxxxxxxxxx}

The Keys in this definitions are separated from the Values with ": " and the end of the Values is specified with ";" (not the new line) This allows to setup a full parameterization of the SAML response as required from the IdP Service provider in the respective IdP configuration used for the SSO connection. The definitions are specified as follows:

• SLO Response: This is the relative address, where the SLO Response has to be sent to on the respective IdP Server.

• SLO Response XML: This is the text string defining the SLO Response structured in XML format (Use "<" and ">" without "). Strings identifying parameters found in the Parameter Map are exchanged to their respective Value. To make sure that similar parameters are identified correctly the Cookie parameters have a leading "$" and the XML parameters of the Request Query a leading "#". Additionally 2 formulas are provided, where "@UUID" will calculate a random UUID with the correct format for the ID parameter of the XML Response and "@ACTUAL_TIME" will calculate the correct Time Stamp in the Instant format for the IssueInstant parameter of the XML Response.

• XML Values: This text string identifies additional parameters, where basically a known parameter is used, but a part of the parameter value needs to be exchanged to match the required text. The parameters are identified by the string "XML_Paramater" followed by the positon in the string separating each value with "&" in the SLO Response XML text. The text for the XML Values is structured by having the parameter identification followed by "=" and the text to be replaced followed by " -> " and the new text.

• Response Parameters: The response parameters are separated with "&" and will be added to the SLO Response as defined. If a signature is required the parameters SigAlg and Signature are needed in this string and should be placed at the end.

• Signature Type: If Signature is required the type of algorithm used to calculate the signature is specified here.

• KeyStore Type: This is the type of the KeyStore used for the certificate.

• KeyStore File: This is the File where the KeyStore has been saved including the drive and path on the Lotus Notes Server. We used D:\saml_cert.pfx on the Test Server.

• KeyStore Password: This is the password required to open the KeyStore File and the certificates stored therein.

• Certificate: This is the Alias of the Certificate identifying the Certificate in the KeyStore File. If a Certificate is stored in a new KeyStore File to combine several Certificates in one location, the Alias is always changed to a new value, which has to be adapted here.

The code I implemented is a Java Agent with the name "Logout" in the domcfg.nsf, but it could basically be implemented in any database available for the SSO Users and it runs as the server to allow protection of the IdP configurations in the idpcat.nsf with highest security. On the IdP service provider you have to configure the SLO Request for the Domino Server respectively the corresponding website as "https://WEBSITE/domcfg.nsf/Logout?Open&" followed by the SAML Request. If signature is requested by the IdP service provider, you have to store a KeyStore File with the Certificate including the PrivateKey required to sign. The KeyStore File can be managed by using the MMC Snap-In function (see https://msdn.microsoft.com/en-us/library/ms788967(v=vs.110).aspx). It is possible to combine several certificates into one File by the export function, but you have to make sure that you export the private keys into the file by the respective setting in the export wizard.

This is the code for the "Logout" agent, which logs out the user from the domino server and sends the SAML Logout Response to the IdP service provider:

import lotus.domino.*;
import java.io.*;
import java.util.*;
import java.text.*;
import com.ibm.xml.crypto.util.Base64;
import java.util.zip.*;
import java.net.URLEncoder;
import java.security.*;

public class JavaAgent extends AgentBase {
    public void NotesMain() {
        try {
            Session ASession = getSession();
            AgentContext AContext = ASession.getAgentContext();
            DateTime date = ASession.createDateTime("Today 06:00");
            int timezone = date.getTimeZone();

            Database DB = AContext.getCurrentDatabase();
            String DBName = DB.getFileName();
            DBName = DBName.replace("\\", "/").replace(" ", "+");

            //Load PrintWriter to printout values for checking (only to debug)
            //PrintWriter pwdebug = getAgentOutput();
            //pwdebug.flush();

            //Load Data from Logout Request
            Document Doc = AContext.getDocumentContext();
            Vector<?> items = Doc.getItems();
            Map<String, String> Params = new LinkedHashMap<String, String>();
            for (int j=0; j<items.size(); j++) {
                Item item = (Item)items.elementAt(j);
                if (!item.getValueString().isEmpty()) Params.put(item.getName(), item.getValueString());
            }
            String ServerName = Params.get("HTTP_HSP_HTTPS_HOST");
            int pos = ServerName.indexOf(":");
            ServerName = pos > 0 ? ServerName.substring(0, ServerName.indexOf(":")) : ServerName;
            Params.put("ServerName", ServerName);
            Doc.recycle();
            DB.recycle();

            //Load Cookie Variables
            Params = map(Params, Params.get("HTTP_COOKIE"), "$", "; ", "=", false, false);
            //Load Query Variables
            Params = map(Params, Params.get("QUERY_STRING_DECODED"), "", "&", "=", false, false);
            //Decode and Infalte SAML Request
            String RequestUnziped = decode_inflate(Params.get("SAMLRequest"), true);
            //pwdebug.println("Request unziped: " + RequestUnziped);
            //System.out.println("Request unziped: " + RequestUnziped);
            String RequestXMLParams = RequestUnziped.substring(19, RequestUnziped.indexOf("\">"));
            //Load XML Parameters from Request
            Params = map(Params, RequestXMLParams, "#", "\" ", "=\"", false, false);
            //for (Map.Entry<String, String> entry : Params.entrySet()) pwdebug.println(entry.getKey() + " value: " + entry.getValue());
            //for (Map.Entry<String, String> entry : Params.entrySet()) System.out.println(entry.getKey() + " value: " + entry.getValue());
            String Issuer = RequestUnziped.substring(RequestUnziped.indexOf(":Issuer"), RequestUnziped.indexOf("Issuer>"));
            Issuer = Issuer.substring(Issuer.indexOf(">") + 1, Issuer.indexOf("<"));
            Params.put("SLO_Issuer", Issuer);

            //Load Parameters for the Response
            DbDirectory Dir = ASession.getDbDirectory(null);
            Database idpcat = Dir.openDatabase("idpcat.nsf");
            View idpView = idpcat.getView("($IdPConfigs)");
            Document idpDoc = idpView.getDocumentByKey(ServerName, false);
            items = idpDoc.getItems();
            for (int j=0; j<items.size(); j++) {
                Item item = (Item)items.elementAt(j);
                if (!item.getValueString().isEmpty()) Params.put(item.getName(), item.getValueString());
            }
            Params = map(Params, idpDoc.getItemValueString("Comments"), "", ";", ": ", false, false);
            Params.put("SLO_Response", Issuer + Params.get("SLO Response"));
            Params.put("@UUID", "_" + UUID.randomUUID().toString());
            Params.put("@ACTUAL_TIME", actualTime(Params.get("#IssueInstant"), Params.get("#NotOnOrAfter"), timezone));
            //for (Map.Entry<String, String> entry : Params.entrySet()) pwdebug.println(entry.getKey() + " value: " + entry.getValue());
            //for (Map.Entry<String, String> entry : Params.entrySet()) System.out.println(entry.getKey() + " value: " + entry.getValue());
            idpDoc.recycle();
            idpView.recycle();
            idpcat.recycle();
            Dir.recycle();

            //Setup XML Response as defined
            String ResponseString = Params.get("SLO Response XML");
            for (Iterator<String> itRq = Params.keySet().iterator(); itRq.hasNext();) {
                String Key = (String) itRq.next();
                ResponseString = ResponseString.replace(Key, Params.get(Key));
            }
            //pwdebug.println("Response String replaced: " + ResponseString);
            //System.out.println("Response String replaced: " + ResponseString);
            //Load Values to be exchanged in the defined Response
            Map<String, String> RsXMLValues = map(new LinkedHashMap<String, String>(), Params.get("XML Values"), "", "&", "=", true, false);
            //for (Map.Entry<String, String> entry : RsXMLValues.entrySet()) pwdebug.println(entry.getKey() + " value: " + entry.getValue());
            //for (Map.Entry<String, String> entry : RsXMLValues.entrySet()) System.out.println(entry.getKey() + " value: " + entry.getValue());
            //Exchange defined Strings with Values from the Request
            int itc = 0;
            for (Iterator<String> itRXV = RsXMLValues.keySet().iterator(); itRXV.hasNext();) {
                itc = itc + 1;
                String Key = (String) itRXV.next();
                int lock = Key.indexOf(" -> ");
                String KeyRq = lock > 0 ? Key.substring(0, lock) : Key;
                int lockRq = KeyRq.indexOf(" ");
                KeyRq = lockRq > 0 ? KeyRq.substring(0, lockRq) : KeyRq;
                String Parameter = Params.get(KeyRq);
                String Value = RsXMLValues.get(Key);
                if (!Value.isEmpty()) {
                    int locv = Value.indexOf(" -> ");
                    String ValueS = locv > 0 ? Value.substring(0, locv) : Value;
                    String ValueR = locv > 0 && Value.length() > locv + 4 ? Value.substring(locv + 4) : ValueS;
                    Parameter = Parameter.replace(ValueS, ValueR);
                }
                ResponseString = ResponseString.replace(("XML_Parameter" + itc), Parameter);
            }
            //pwdebug.println("Final XML Response String: " + ResponseString);
            //System.out.println("Final XML Response String: " + ResponseString);
            //Deflate and Encode the XML Response
            String ResponseZiped = deflate_encode(ResponseString, Deflater.DEFAULT_COMPRESSION, true);
            //pwdebug.println("Response Ziped: " + ResponseZiped);
            //System.out.println("Response Ziped: " + ResponseZiped);
            //Setup Response URLQuery as defined
            String ResponseEncoded = "SAMLResponse=" + URLEncoder.encode(ResponseZiped, "UTF-8");
            //pwdebug.println("Response to Sign: " + ResponseEncoded);
            //System.out.println("Response to Sign: " + ResponseEncoded);
            //Load Parameters to be added to the Response
            Map<String, String> ResponseParams = map(new LinkedHashMap<String, String>(), Params.get("Response Parameters"), "", "&", "=", false, true);
            //for (Map.Entry<String, String> entry : ResponseParams.entrySet()) pwdebug.println(entry.getKey() + " value: " + entry.getValue());
            //for (Map.Entry<String, String> entry : ResponseParams.entrySet()) System.out.println(entry.getKey() + " value: " + entry.getValue());
            //Add defined Parameters with Values from the Request
            for (Iterator<String> itRP = ResponseParams.keySet().iterator(); itRP.hasNext();) {
                String Key = (String) itRP.next();
                if (Key.contains("Signature")) {
                    //pwdebug.println("Response to Sign: " + ResponseEncoded);
                    //System.out.println("Response to Sign: " + ResponseEncoded);
                    Signature signature = Signature.getInstance(Params.get("Signature Type"));
                    //pwdebug.println("Signature: Initiated");
                    //System.out.println("Signature: Initiated");
                    KeyStore keyStore = KeyStore.getInstance(Params.get("KeyStore Type"));
                    //pwdebug.println("Key Store: Initiated");
                    //System.out.println("Key Store: Initiated");
                    keyStore.load(new FileInputStream(Params.get("KeyStore File")), Params.get("KeyStore Password").toCharArray());
                    //pwdebug.println("Key Store: Loaded");
                    //System.out.println("Key Store: Loaded");
                    PrivateKey key = (PrivateKey) keyStore.getKey (Params.get("Certificate"), Params.get("KeyStore Password").toCharArray());
                    //pwdebug.println("Key Store: Private Key Loaded");
                    //System.out.println("Key Store: Private Key Loaded");
                    signature.initSign(key);
                    //pwdebug.println("Signature: Private Key Initiated");
                    //System.out.println("Signature: Private Key Initiated");
                    signature.update(ResponseEncoded.getBytes("UTF-8"));
                    //pwdebug.println("Signature: Signed");
                    //System.out.println("Signature: Signed");
                    String ResponseSignature = URLEncoder.encode(Base64.encode(signature.sign()), "UTF-8"); 
                    //pwdebug.println("Signature: Signed");
                    //System.out.println("Signature: Signed");
                    ResponseEncoded = ResponseEncoded.concat("&").concat(Key).concat("=").concat(ResponseSignature);
                }
                else ResponseEncoded = ResponseEncoded.concat("&").concat(Key).concat("=").concat(URLEncoder.encode(Params.get(Key), "UTF-8"));
            }
            String ResponseURL = Params.get("SLO_Response").concat("?").concat(ResponseEncoded);
            //pwdebug.println("Final Response URL: " + ResponseURL);
            //pwdebug.close();
            //System.out.println("Final Response URL: " + ResponseURL);

            //Send Logout to Server and redirect to Response to defined Destination
            PrintWriter pwsaml = getAgentOutput();
            pwsaml.flush();
            pwsaml.println("[" + Params.get("HTTP_HSP_LISTENERURI") + "/" + DBName + "?logout&redirectto=" + URLEncoder.encode(ResponseURL, "UTF-8") + "]");
            pwsaml.close();

            //Recycle Agent and Session
            AContext.recycle();
            ASession.recycle();

        } catch(Exception e) {
            PrintWriter pwerror = getAgentOutput();
            pwerror.flush();
            pwerror.println(e);
            System.out.println(e);
            pwerror.close();
        } 
    }

    //Load Maps from Strings to identify Paramteres and Values
    private static Map<String, String> map(Map<String, String> map, String input, String keys, String spliting, String pairing, Boolean keycount, Boolean empty) {
        Map<String, String> output = map.isEmpty() ? new LinkedHashMap<String, String>() : map;
        String[] Pairs = input.split(spliting);
        int kc = 0;
        for (String Pair : Pairs) {
            kc = kc + 1;
            int pos = Pair.indexOf(pairing);
            String Key = pos > 0 ? Pair.substring(0, pos) : Pair;
            if (keycount) Key = Key + " " + kc;
            String Value = pos > 0 && Pair.length() > (pos + pairing.length()) ? Pair.substring(pos + pairing.length()) : "";
            if (!output.containsKey(Key) && (empty || !Value.trim().isEmpty())) output.put((keys + Key).trim(), Value.trim());
        }
        return output;
    }

    //Decode and Inflate to XML
    private static String decode_inflate(String input, Boolean infflag) throws IOException, DataFormatException {
        byte[] inputDecoded = Base64.decode(input.getBytes("UTF-8"));
        Inflater inflater = new Inflater(infflag);
        inflater.setInput(inputDecoded);
        byte[] outputBytes = new byte[1024];
        int infLength = inflater.inflate(outputBytes);
        inflater.end();
        String output = new String(outputBytes, 0, infLength, "UTF-8");
        return output;
    }

    //Deflate and Encode XML
    private static String deflate_encode(String input, int level , Boolean infflag) throws IOException {
        byte[] inputBytes = input.getBytes("UTF-8");
        Deflater deflater = new Deflater(level, infflag);
        deflater.setInput(inputBytes);
        deflater.finish();
        byte[] outputBytes = new byte[1024];
        int defLength = deflater.deflate(outputBytes);
        deflater.end();
        byte[] outputDeflated = new byte[defLength];
        System.arraycopy(outputBytes, 0, outputDeflated, 0, defLength);
        String output = Base64.encode(outputDeflated);
        return output;
    }

    //Define Date and Time Formats
    private static SimpleDateFormat DateFormat = new SimpleDateFormat("yyyy-MM-dd");
    private static SimpleDateFormat TimeFormat = new SimpleDateFormat("HH:mm:ss.SSS");

    //Formated Actual Time
    private static String actualTime(String minTime, String maxTime, int localZone) throws ParseException {
        Date actualtime = new Date();
        long acttime = actualtime.getTime();
        long mintime = resetTime(minTime, localZone);
        long maxtime = resetTime(maxTime, localZone);
        acttime = (acttime > mintime) && (acttime < maxtime) ? acttime: mintime + 1000;
        return formatTime(acttime);
    }

    //Reset timemillis from String as defined
    private static long resetTime(String givenTime, int localZone) throws ParseException {
        Date date = DateFormat.parse(givenTime.substring(0, givenTime.indexOf("T")));
        long days = date.getTime();
        Date time = TimeFormat.parse(givenTime.substring(givenTime.indexOf("T") + 1, givenTime.indexOf("Z")));
        long hours = time.getTime();
        long zonecorr = localZone * 3600000;
        return days + hours - zonecorr;
    }

    //Format timemillis into a String as required
    private static String formatTime(long totalmilliSeconds) {
        long date = 86400000 * (totalmilliSeconds / 86400000);
        long time = totalmilliSeconds % 86400000;
        String dateString = DateFormat.format(date).concat("T");
        String timeString = TimeFormat.format(time).concat("Z");
        return dateString.concat(timeString);
    }

    public static String noCRLF(String input) { 
        String lf = "%0D";
        String cr = "%0A";
        String find = lf;
        int pos = input.indexOf(find);
        StringBuffer output = new StringBuffer();
        while (pos != -1) {
            output.append(input.substring(0, pos));
            input = input.substring(pos + 3, input.length());
            if (find.equals(lf)) find = cr;
            else find = lf;
            pos = input.indexOf(find);
        }
        if (output.toString().equals("")) return input;
        else return output.toString();
    }
}

As you might have recognized, several commented lines can be used for debugging the agent, if the definitions are not correct and do not result in a successful logout. You can easily change those lines by deleting the "//" starting those lines and print out the parameters you would like to see on your screen or send them to the logs.

To initiate SLO on the domino server, I wrote another Java Agent using the same concept. The agent is called startSLO and is located in the same database as the "Logout" agent. The use of this agent can be easily implemented in any of your application by creating buttons opening the relative URL "/domcfg.nsf/startSLO?Open". The "startSLO" agent has the following code.:

import lotus.domino.*;
import java.io.*;

public class JavaAgent extends AgentBase {
    public void NotesMain() {
        try {
            Session ASession = getSession();
            AgentContext AContext = ASession.getAgentContext();

            Database DB = AContext.getCurrentDatabase();
            String DBName = DB.getFileName();
            DBName = DBName.replace("\\", "/").replace(" ", "+");

            //Load Data from Logout Request
            Document Doc = AContext.getDocumentContext();
            String ServerName = Doc.getItemValueString("HTTP_HSP_HTTPS_HOST");
            int pos = ServerName.indexOf(":");
            ServerName = pos > 0 ? ServerName.substring(0, ServerName.indexOf(":")) : ServerName;
            String Query = Doc.getItemValueString("Query_String");
            pos = Query.indexOf("?Open&");
            Query = pos > 0 ? "?" + Query.substring(Query.indexOf("?Open") + 6) : "";
            Doc.recycle();
            DB.recycle();

            //Load Parameters for the Response
            DbDirectory Dir = ASession.getDbDirectory(null);
            Database idpcat = Dir.openDatabase("idpcat.nsf");
            View idpView = idpcat.getView("($IdPConfigs)");
            Document idpDoc = idpView.getDocumentByKey(ServerName, false);
            String SAMLSLO = idpDoc.getItemValueString("SAMLSloUrl");
            idpDoc.recycle();
            idpView.recycle();
            idpcat.recycle();
            Dir.recycle();

            //Send Logout to Server and redirect to Response to defined Destination
            PrintWriter pwsaml = getAgentOutput();
            pwsaml.flush();
            pwsaml.println("[" + SAMLSLO + Query + "]");
            pwsaml.close();

            //Recycle Agent and Session
            AContext.recycle();
            ASession.recycle();

        } catch(Exception e) {
            PrintWriter pwerror = getAgentOutput();
            pwerror.flush();
            pwerror.println(e);
            System.out.println(e);
            pwerror.close();
        } 
    }
}

Answer 2

Finally I got the right recipe:

1. Generate the SAMLRequest value
2. Encode the SAMLRequest value in Base64
3. URL-encode the SAMLRequest value
4. URL-encode the SigAlg value: http://www.w3.org/2000/09/xmldsig#rsa-sha1
5. Feed the algorithm signature (SHA1withRSA) with the SAMLRequest=value&SigAlg=value
6. URL-encode the generated signature

We can perform the steps 2 and 3 with the SAML 2.0 Debugger (https://rnd.feide.no/simplesaml/module.php/saml2debug/debug.php). And for the URL-encoding use the classic w3schools (http://www.w3schools.com/tags/ref_urlencode.asp)

Warning! Ensure that the algorithm for your relying party, in the ADFS2, is setup to SHA1!

Best regards,

Luis

ps: now I have to code a little bit...

pps: You can find the code here: https://github.com/cerndb/wls-cern-sso/tree/master/saml2slo

Answer 3

There's a bug in the ADFS implementation where the error message it gives is backwards. When it says:

SAML request is not signed with expected signature algorithm. SAML request is signed with signature algorithm http://www.w3.org/2001/04/xmldsig-more#rsa-sha256 . Expected signature algorithm is http://www.w3.org/2000/09/xmldsig#rsa-sha1

it actually means that you're using SHA1 and it was expecting SHA256.