Java tutorial
/* * Licensed under the EUPL, Version 1.1 or as soon they will be approved by * the European Commission - subsequent versions of the EUPL (the "Licence"); * You may not use this work except in compliance with the Licence. You may * obtain a copy of the Licence at: * * http://www.osor.eu/eupl/european-union-public-licence-eupl-v.1.1 * * Unless required by applicable law or agreed to in writing, software * distributed under the Licence is distributed on an "AS IS" basis, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * Licence for the specific language governing permissions and limitations under * the Licence. */ package eu.stork.peps.auth.engine; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import javax.xml.namespace.QName; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import org.apache.commons.lang.StringUtils; import org.joda.time.DateTime; import org.opensaml.Configuration; import org.opensaml.common.SAMLVersion; import org.opensaml.common.impl.SecureRandomIdentifierGenerator; import org.opensaml.saml2.common.Extensions; import org.opensaml.saml2.common.impl.ExtensionsBuilder; import org.opensaml.saml2.core.Assertion; import org.opensaml.saml2.core.Attribute; import org.opensaml.saml2.core.AttributeValue; import org.opensaml.saml2.core.AuthnContext; import org.opensaml.saml2.core.AuthnRequest; import org.opensaml.saml2.core.AuthnStatement; import org.opensaml.saml2.core.Issuer; import org.opensaml.saml2.core.LogoutRequest; import org.opensaml.saml2.core.LogoutResponse; import org.opensaml.saml2.core.NameID; import org.opensaml.saml2.core.Response; import org.opensaml.saml2.core.Status; import org.opensaml.saml2.core.StatusCode; import org.opensaml.saml2.core.StatusMessage; import org.opensaml.saml2.core.Subject; import org.opensaml.saml2.core.SubjectConfirmation; import org.opensaml.saml2.core.SubjectConfirmationData; import org.opensaml.saml2.core.SubjectLocality; import org.opensaml.saml2.core.impl.AssertionBuilder; import org.opensaml.xml.XMLObject; import org.opensaml.xml.schema.XSAny; import org.opensaml.xml.signature.KeyInfo; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.xml.sax.SAXException; import eu.stork.peps.auth.engine.core.CustomAttributeQuery; import eu.stork.peps.auth.engine.core.QAAAttribute; import eu.stork.peps.auth.engine.core.RequestedAttribute; import eu.stork.peps.auth.engine.core.SAMLCore; import eu.stork.peps.auth.engine.core.SPApplication; import eu.stork.peps.auth.engine.core.SPCountry; import eu.stork.peps.auth.engine.core.SPInstitution; import eu.stork.peps.auth.engine.core.SPSector; import eu.stork.peps.auth.engine.core.impl.CustomAttributeQueryBuilder; import eu.stork.peps.exceptions.STORKSAMLEngineException; import eu.stork.peps.exceptions.STORKSAMLEngineRuntimeException; /** * The Class SAMLEngineUtils. * * @author fjquevedo * @author iinigo * */ public final class SAMLEngineUtils { /** The Constant UTF_8. */ public static final String UTF_8 = "UTF-8"; /** The Constant SHA_512. */ public static final String SHA_512 = "SHA-512"; /** The generator. */ private static SecureRandomIdentifierGenerator generator; /** The Constant LOG. */ private static final Logger LOG = LoggerFactory.getLogger(SAMLEngineUtils.class.getName()); /** * Method that generates a random value according to NCName grammar. * * NCName ::= NCNameStartChar NCNameChar* NCNameChar ::= NameChar - ':' * NCNameStartChar ::= Letter | '_' NameStartChar ::= ":" | [A-Z] | "_" | * [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | * [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | * [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF] * NameChar ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | * [#x203F-#x2040] Name ::= NameStartChar (NameChar)* Letter ::= BaseChar | * Ideographic BaseChar ::= [#x0041-#x005A] | [#x0061-#x007A] | * [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x00FF] | [#x0100-#x0131] | * [#x0134-#x013E] | [#x0141-#x0148] | [#x014A-#x017E] | [#x0180-#x01C3] | * [#x01CD-#x01F0] | [#x01F4-#x01F5] | [#x01FA-#x0217] | [#x0250-#x02A8] | * [#x02BB-#x02C1] | #x0386 | [#x0388-#x038A] | #x038C | [#x038E-#x03A1] | * [#x03A3-#x03CE] | [#x03D0-#x03D6] | #x03DA | #x03DC | #x03DE | #x03E0 | * [#x03E2-#x03F3] | [#x0401-#x040C] | [#x040E-#x044F] | [#x0451-#x045C] | * [#x045E-#x0481] | [#x0490-#x04C4] | [#x04C7-#x04C8] | [#x04CB-#x04CC] | * [#x04D0-#x04EB] | [#x04EE-#x04F5] | [#x04F8-#x04F9] | [#x0531-#x0556] | * #x0559 | [#x0561-#x0586] | [#x05D0-#x05EA] | [#x05F0-#x05F2] | * [#x0621-#x063A] | [#x0641-#x064A] | [#x0671-#x06B7] | [#x06BA-#x06BE] | * [#x06C0-#x06CE] | [#x06D0-#x06D3] | #x06D5 | [#x06E5-#x06E6] | * [#x0905-#x0939] | #x093D | [#x0958-#x0961] | [#x0985-#x098C] | * [#x098F-#x0990] | [#x0993-#x09A8] | [#x09AA-#x09B0] | #x09B2 | * [#x09B6-#x09B9] | [#x09DC-#x09DD] | [#x09DF-#x09E1] | [#x09F0-#x09F1] | * [#x0A05-#x0A0A] | [#x0A0F-#x0A10] | [#x0A13-#x0A28] | [#x0A2A-#x0A30] | * [#x0A32-#x0A33] | [#x0A35-#x0A36] | [#x0A38-#x0A39] | [#x0A59-#x0A5C] | * #x0A5E | [#x0A72-#x0A74] | [#x0A85-#x0A8B] | #x0A8D | [#x0A8F-#x0A91] | * [#x0A93-#x0AA8] | [#x0AAA-#x0AB0] | [#x0AB2-#x0AB3] | [#x0AB5-#x0AB9] | * #x0ABD | #x0AE0 | [#x0B05-#x0B0C] | [#x0B0F-#x0B10] | [#x0B13-#x0B28] | * [#x0B2A-#x0B30] | [#x0B32-#x0B33] | [#x0B36-#x0B39] | #x0B3D | * [#x0B5C-#x0B5D] | [#x0B5F-#x0B61] | [#x0B85-#x0B8A] | [#x0B8E-#x0B90] | * [#x0B92-#x0B95] | [#x0B99-#x0B9A] | #x0B9C | [#x0B9E-#x0B9F] | * [#x0BA3-#x0BA4] | [#x0BA8-#x0BAA] | [#x0BAE-#x0BB5] | [#x0BB7-#x0BB9] | * [#x0C05-#x0C0C] | [#x0C0E-#x0C10] | [#x0C12-#x0C28] | [#x0C2A-#x0C33] | * [#x0C35-#x0C39] | [#x0C60-#x0C61] | [#x0C85-#x0C8C] | [#x0C8E-#x0C90] | * [#x0C92-#x0CA8] | [#x0CAA-#x0CB3] | [#x0CB5-#x0CB9] | #x0CDE | * [#x0CE0-#x0CE1] | [#x0D05-#x0D0C] | [#x0D0E-#x0D10] | [#x0D12-#x0D28] | * [#x0D2A-#x0D39] | [#x0D60-#x0D61] | [#x0E01-#x0E2E] | #x0E30 | * [#x0E32-#x0E33] | [#x0E40-#x0E45] | [#x0E81-#x0E82] | #x0E84 | * [#x0E87-#x0E88] | #x0E8A | #x0E8D | [#x0E94-#x0E97] | [#x0E99-#x0E9F] | * [#x0EA1-#x0EA3] | #x0EA5 | #x0EA7 | [#x0EAA-#x0EAB] | [#x0EAD-#x0EAE] | * #x0EB0 | [#x0EB2-#x0EB3] | #x0EBD | [#x0EC0-#x0EC4] | [#x0F40-#x0F47] | * [#x0F49-#x0F69] | [#x10A0-#x10C5] | [#x10D0-#x10F6] | #x1100 | * [#x1102-#x1103] | [#x1105-#x1107] | #x1109 | [#x110B-#x110C] | * [#x110E-#x1112] | #x113C | #x113E | #x1140 | #x114C | #x114E | #x1150 | * [#x1154-#x1155] | #x1159 | [#x115F-#x1161] | #x1163 | #x1165 | #x1167 | * #x1169 | [#x116D-#x116E] | [#x1172-#x1173] | #x1175 | #x119E | #x11A8 | * #x11AB | [#x11AE-#x11AF] | [#x11B7-#x11B8] | #x11BA | [#x11BC-#x11C2] | * #x11EB | #x11F0 | #x11F9 | [#x1E00-#x1E9B] | [#x1EA0-#x1EF9] | * [#x1F00-#x1F15] | [#x1F18-#x1F1D] | [#x1F20-#x1F45] | [#x1F48-#x1F4D] | * [#x1F50-#x1F57] | #x1F59 | #x1F5B | #x1F5D | [#x1F5F-#x1F7D] | * [#x1F80-#x1FB4] | [#x1FB6-#x1FBC] | #x1FBE | [#x1FC2-#x1FC4] | * [#x1FC6-#x1FCC] | [#x1FD0-#x1FD3] | [#x1FD6-#x1FDB] | [#x1FE0-#x1FEC] | * [#x1FF2-#x1FF4] | [#x1FF6-#x1FFC] | #x2126 | [#x212A-#x212B] | #x212E | * [#x2180-#x2182] | [#x3041-#x3094] | [#x30A1-#x30FA] | [#x3105-#x312C] | * [#xAC00-#xD7A3] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | * [#x3021-#x3029] * * @return Random ID value */ //Initialization of a generator of identifiers for all token SAML. static { loadRandomIdentifierGenerator(); } /** * Load random identifier generator. * *@throws STORKSAMLEngineRuntimeException the STORKSAML engine runtime exception */ private static void loadRandomIdentifierGenerator() { try { generator = new SecureRandomIdentifierGenerator(); } catch (NoSuchAlgorithmException ex) { LOG.error("Error init SecureRandomIdentifierGenerator", ex); throw new STORKSAMLEngineRuntimeException(ex); } } /** * Creates the SAML object. * * @param qname the QName * * @return the XML object */ public static XMLObject createSamlObject(final QName qname) { if (qname.toString().endsWith(CustomAttributeQuery.DEFAULT_ELEMENT_LOCAL_NAME)) { CustomAttributeQueryBuilder builder = new CustomAttributeQueryBuilder(); return builder.buildObject(qname); } else { return Configuration.getBuilderFactory().getBuilder(qname).buildObject(qname); } } /** * Creates the SAML object. * * @param qname the quality name * @param qname1 the qname1 * * @return the xML object */ public static XMLObject createSamlObject(final QName qname, final QName qname1) { return Configuration.getBuilderFactory().getBuilder(qname1).buildObject(qname, qname1); } /** * Encode value with an specific algorithm. * * @param value the value * @param alg the algorithm * * @return the string * * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static String encode(final String value, final String alg) throws STORKSAMLEngineException { LOG.debug("Encode value with " + alg + " algorithm."); byte[] buffer; final StringBuffer hash = new StringBuffer(""); try { buffer = value.getBytes(UTF_8); MessageDigest msgDig; msgDig = MessageDigest.getInstance(alg); msgDig.update(buffer); final byte[] digest = msgDig.digest(); final int signedByte = 0xff; for (byte aux : digest) { final int byt = aux & signedByte; if (Integer.toHexString(byt).length() == 1) { hash.append('0'); } hash.append(Integer.toHexString(byt)); } } catch (UnsupportedEncodingException e1) { LOG.error("UnsupportedEncodingException: " + UTF_8); throw new STORKSAMLEngineException(e1); } catch (NoSuchAlgorithmException e) { LOG.error("NoSuchAlgorithmException: " + alg); throw new STORKSAMLEngineException(e); } return hash.toString(); } /** * Generate assertion. * * @param version the version * @param identifier the identifier * @param issueInstant the issue instant * @param issuer the issuer * * @return the assertion */ public static Assertion generateAssertion(final SAMLVersion version, final String identifier, final DateTime issueInstant, final Issuer issuer) { final AssertionBuilder assertionBuilder = new AssertionBuilder(); final Assertion assertion = assertionBuilder.buildObject(); assertion.setVersion(version); assertion.setID(identifier); assertion.setIssueInstant(issueInstant); // <saml:Issuer> assertion.setIssuer(issuer); return assertion; } /** * Generate authentication statement. * * @param authnInstant the authentication instant * @param authnContext the authentication context * * @return the authentication statement */ public static AuthnStatement generateAthnStatement(final DateTime authnInstant, final AuthnContext authnContext) { // <saml:AuthnStatement> final AuthnStatement authnStatement = (AuthnStatement) SAMLEngineUtils .createSamlObject(AuthnStatement.DEFAULT_ELEMENT_NAME); authnStatement.setAuthnInstant(authnInstant); authnStatement.setAuthnContext(authnContext); return authnStatement; } /** * Generate attribute from a list of values. * * @param name the name of the attribute. * @param status the status of the parameter: "Available", "NotAvailable" or * "Withheld". * @param values the value of the attribute. * @param isHashing the is hashing with "SHA-512" algorithm. * @return the attribute * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static Attribute generateAttrComplex(final String name, final String status, final Map<String, String> values, final boolean isHashing) throws STORKSAMLEngineException { LOG.debug("Generate attribute complex: " + name); final Attribute attribute = (Attribute) SAMLEngineUtils.createSamlObject(Attribute.DEFAULT_ELEMENT_NAME); attribute.setName(name); attribute.setNameFormat(Attribute.URI_REFERENCE); attribute.getUnknownAttributes().put( new QName(SAMLCore.STORK10_NS.getValue(), "AttributeStatus", SAMLCore.STORK10_PREFIX.getValue()), status); if (!values.isEmpty()) { LOG.debug("Add attribute values."); // Create an attribute that contains all XSAny elements. final XSAny attrValue = (XSAny) SAMLEngineUtils.createSamlObject(AttributeValue.DEFAULT_ELEMENT_NAME, XSAny.TYPE_NAME); final Iterator<Entry<String, String>> iterator = values.entrySet().iterator(); while (iterator.hasNext()) { final Map.Entry<String, String> pairs = iterator.next(); final String value = pairs.getValue(); if (StringUtils.isNotBlank(value)) { // Create the attribute statement final XSAny attrValueSimple = (XSAny) SAMLEngineUtils .createSamlObject(new QName(SAMLCore.STORK10_NS.getValue(), pairs.getKey().toString(), SAMLCore.STORK10_PREFIX.getValue()), XSAny.TYPE_NAME); // if it's necessary encode the information. if (isHashing) { attrValueSimple.setTextContent(encode(value, SHA_512)); } else { attrValueSimple.setTextContent(value); } attrValue.getUnknownXMLObjects().add(attrValueSimple); attribute.getAttributeValues().add(attrValue); } } } return attribute; } /** * Generate extension. * * @return the extensions */ public static Extensions generateExtension() { final ExtensionsBuilder extensionsBuilder = new ExtensionsBuilder(); return extensionsBuilder.buildObject("urn:oasis:names:tc:SAML:2.0:protocol", "Extensions", "saml2p"); } /** * Generate issuer. * * @return the issuer */ public static Issuer generateIssuer() { return (Issuer) SAMLEngineUtils.createSamlObject(Issuer.DEFAULT_ELEMENT_NAME); } /** * Generate key info. * * @return the key info */ public static KeyInfo generateKeyInfo() { return (KeyInfo) SAMLEngineUtils.createSamlObject(KeyInfo.DEFAULT_ELEMENT_NAME); } /** * Generate name id. * * @return the name id */ public static NameID generateNameID() { return (NameID) SAMLEngineUtils.createSamlObject(NameID.DEFAULT_ELEMENT_NAME); } /** * Generate name id. * * @param nameQualifier the name qualifier * @param format the format * @param spNameQualifier the sP name qualifier * * @return the name id */ public static NameID generateNameID(final String nameQualifier, final String format, final String spNameQualifier) { // <saml:NameID> final NameID nameId = (NameID) Configuration.getBuilderFactory().getBuilder(NameID.DEFAULT_ELEMENT_NAME) .buildObject(NameID.DEFAULT_ELEMENT_NAME); // optional nameId.setNameQualifier(nameQualifier); // optional nameId.setFormat(format); // optional nameId.setSPNameQualifier(spNameQualifier); return nameId; } /** * Generate NCName. * * @return the string */ public static String generateNCName() { return generator.generateIdentifier(); } /** * Generate the quality authentication assurance level. * * @param qaal the level of quality authentication assurance. * * @return the quality authentication assurance attribute * * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static QAAAttribute generateQAAAttribute(final int qaal) throws STORKSAMLEngineException { LOG.debug("Generate QAAAttribute."); final QAAAttribute qaaAttribute = (QAAAttribute) SAMLEngineUtils .createSamlObject(QAAAttribute.DEF_ELEMENT_NAME); qaaAttribute.setQaaLevel(String.valueOf(qaal)); return qaaAttribute; } /** * Generate requested attribute. * * @param name the name * @param friendlyName the friendly name * @param isRequired the is required * @param value the value * * @return the requested attribute */ public static RequestedAttribute generateReqAuthnAttributeSimple(final String name, final String friendlyName, final String isRequired, final List<String> value) { LOG.debug("Generate the requested attribute."); final RequestedAttribute requested = (RequestedAttribute) SAMLEngineUtils .createSamlObject(RequestedAttribute.DEF_ELEMENT_NAME); requested.setName(name); requested.setNameFormat(RequestedAttribute.URI_REFERENCE); requested.setFriendlyName(friendlyName); requested.setIsRequired(isRequired); // The value is optional in an authentication request. if (!value.isEmpty()) { for (int nextValue = 0; nextValue < value.size(); nextValue++) { final String valor = value.get(nextValue); if (StringUtils.isNotBlank(valor)) { if (!name.equals("http://www.stork.gov.eu/1.0/signedDoc")) { // Create the attribute statement final XSAny attrValue = (XSAny) SAMLEngineUtils .createSamlObject(new QName(SAMLCore.STORK10_NS.getValue(), "AttributeValue", SAMLCore.STORK10_PREFIX.getValue()), XSAny.TYPE_NAME); attrValue.setTextContent(valor.trim()); requested.getAttributeValues().add(attrValue); } else { DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); domFactory.setNamespaceAware(true); Document document = null; DocumentBuilder builder; // Parse the signedDoc value into an XML DOM Document try { builder = domFactory.newDocumentBuilder(); InputStream is; is = new ByteArrayInputStream(valor.trim().getBytes(UTF_8)); document = builder.parse(is); is.close(); } catch (SAXException e1) { LOG.error("SAX Error while parsing signModule attribute", e1); throw new STORKSAMLEngineRuntimeException(e1); } catch (ParserConfigurationException e2) { LOG.error("Parser Configuration Error while parsing signModule attribute", e2); throw new STORKSAMLEngineRuntimeException(e2); } catch (UnsupportedEncodingException e3) { LOG.error("Unsupported encoding Error while parsing signModule attribute", e3); throw new STORKSAMLEngineRuntimeException(e3); } catch (IOException e4) { LOG.error("IO Error while parsing signModule attribute", e4); throw new STORKSAMLEngineRuntimeException(e4); } // Create the XML statement(this will be overwritten with the previous DOM structure) final XSAny xmlValue = (XSAny) SAMLEngineUtils .createSamlObject(new QName(SAMLCore.STORK10_NS.getValue(), "XMLValue", SAMLCore.STORK10_PREFIX.getValue()), XSAny.TYPE_NAME); //Set the signedDoc XML content to this element xmlValue.setDOM(document.getDocumentElement()); // Create the attribute statement final XSAny attrValue = (XSAny) SAMLEngineUtils .createSamlObject(new QName(SAMLCore.STORK10_NS.getValue(), "AttributeValue", SAMLCore.STORK10_PREFIX.getValue()), XSAny.TYPE_NAME); //Add previous signedDocXML to the AttributeValue Element attrValue.getUnknownXMLObjects().add(xmlValue); requested.getAttributeValues().add(attrValue); } } } } return requested; } /** * Generate response. * * @param version the version * @param identifier the identifier * @param issueInstant the issue instant * @param status the status * * @return the response */ public static Response generateResponse(final SAMLVersion version, final String identifier, final DateTime issueInstant, final Status status) { final Response response = (Response) SAMLEngineUtils.createSamlObject(Response.DEFAULT_ELEMENT_NAME); response.setID(identifier); response.setIssueInstant(issueInstant); response.setStatus(status); return response; } /** * Method that generates a SAML Authentication Request basing on the * provided information. * * @param identifier the identifier * @param version the version * @param issueInstant the issue instant * * @return the authentication request */ public static AuthnRequest generateSAMLAuthnRequest(final String identifier, final SAMLVersion version, final DateTime issueInstant) { LOG.debug("Generate basic authentication request."); final AuthnRequest authnRequest = (AuthnRequest) SAMLEngineUtils .createSamlObject(AuthnRequest.DEFAULT_ELEMENT_NAME); authnRequest.setID(identifier); authnRequest.setVersion(version); authnRequest.setIssueInstant(issueInstant); return authnRequest; } public static CustomAttributeQuery generateSAMLAttrQueryRequest(final String identifier, final SAMLVersion version, final DateTime issueInstant) { LOG.debug("Generate attribute query request."); final CustomAttributeQuery attrQueryRequest = (CustomAttributeQuery) SAMLEngineUtils .createSamlObject(CustomAttributeQuery.DEFAULT_ELEMENT_NAME); attrQueryRequest.setID(identifier); attrQueryRequest.setVersion(version); attrQueryRequest.setIssueInstant(issueInstant); return attrQueryRequest; } public static LogoutRequest generateSAMLLogoutRequest(final String identifier, final SAMLVersion version, final DateTime issueInstant) { LOG.debug("Generate logout request."); final LogoutRequest logoutRequest = (LogoutRequest) SAMLEngineUtils .createSamlObject(LogoutRequest.DEFAULT_ELEMENT_NAME); logoutRequest.setID(identifier); logoutRequest.setVersion(version); logoutRequest.setIssueInstant(issueInstant); return logoutRequest; } public static LogoutResponse generateSAMLLogoutResponse(final String identifier, final SAMLVersion version, final DateTime issueInstant, final Status status, final String inResponseTo) { LOG.debug("Generate logout response."); final LogoutResponse logoutResponse = (LogoutResponse) SAMLEngineUtils .createSamlObject(LogoutResponse.DEFAULT_ELEMENT_NAME); logoutResponse.setInResponseTo(inResponseTo); logoutResponse.setStatus(status); logoutResponse.setID(identifier); logoutResponse.setVersion(version); logoutResponse.setIssueInstant(issueInstant); return logoutResponse; } /** * Generate service provider application. * * @param spApplication the service provider application * * @return the sP application * * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static SPApplication generateSPApplication(final String spApplication) throws STORKSAMLEngineException { LOG.debug("Generate SPApplication."); final SPApplication applicationAttr = (SPApplication) SAMLEngineUtils .createSamlObject(SPApplication.DEF_ELEMENT_NAME); applicationAttr.setSPApplication(spApplication); return applicationAttr; } /** * Generate service provider country. * * @param spCountry the service provider country * * @return the service provider country * * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static SPCountry generateSPCountry(final String spCountry) throws STORKSAMLEngineException { LOG.debug("Generate SPApplication."); final SPCountry countryAttribute = (SPCountry) SAMLEngineUtils.createSamlObject(SPCountry.DEF_ELEMENT_NAME); countryAttribute.setSPCountry(spCountry); return countryAttribute; } /** * Generate service provider institution. * * @param spInstitution the service provider institution * * @return the service provider institution * * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static SPInstitution generateSPInstitution(final String spInstitution) throws STORKSAMLEngineException { LOG.debug("Generate SPInstitution."); final SPInstitution institutionAttr = (SPInstitution) SAMLEngineUtils .createSamlObject(SPInstitution.DEF_ELEMENT_NAME); institutionAttr.setSPInstitution(spInstitution); return institutionAttr; } /** * Generate service provider sector. * * @param spSector the service provider sector * * @return the service provider sector * * @throws STORKSAMLEngineException the STORKSAML engine exception */ public static SPSector generateSPSector(final String spSector) throws STORKSAMLEngineException { LOG.debug("Generate SPSector."); final SPSector sectorAttribute = (SPSector) SAMLEngineUtils.createSamlObject(SPSector.DEF_ELEMENT_NAME); sectorAttribute.setSPSector(spSector); return sectorAttribute; } /** * Generate status. * * @param statusCode the status code * * @return the status */ public static Status generateStatus(final StatusCode statusCode) { final Status status = (Status) SAMLEngineUtils.createSamlObject(Status.DEFAULT_ELEMENT_NAME); status.setStatusCode(statusCode); return status; } /** * Generate status code. * * @param value the value * * @return the status code */ public static StatusCode generateStatusCode(final String value) { final StatusCode statusCode = (StatusCode) SAMLEngineUtils .createSamlObject(StatusCode.DEFAULT_ELEMENT_NAME); statusCode.setValue(value); return statusCode; } /** * Generate status message. * * @param message the message * * @return the status message */ public static StatusMessage generateStatusMessage(final String message) { final StatusMessage statusMessage = (StatusMessage) SAMLEngineUtils .createSamlObject(StatusMessage.DEFAULT_ELEMENT_NAME); statusMessage.setMessage(message); return statusMessage; } /** * Generate subject. * * @return the subject */ public static Subject generateSubject() { return (Subject) SAMLEngineUtils.createSamlObject(Subject.DEFAULT_ELEMENT_NAME); } /** * Generate subject confirmation. * * @param method the method * @param data the data * * @return the subject confirmation */ public static SubjectConfirmation generateSubjectConfirmation(final String method, final SubjectConfirmationData data) { final SubjectConfirmation subjectConf = (SubjectConfirmation) Configuration.getBuilderFactory() .getBuilder(SubjectConfirmation.DEFAULT_ELEMENT_NAME) .buildObject(SubjectConfirmation.DEFAULT_ELEMENT_NAME); subjectConf.setMethod(method); subjectConf.setSubjectConfirmationData(data); return subjectConf; } /** * Generate subject confirmation data. * * @param notOnOrAfter the not on or after * @param recipient the recipient * @param inResponseTo the in response to * * @return the subject confirmation data */ public static SubjectConfirmationData generateSubjectConfirmationData(final DateTime notOnOrAfter, final String recipient, final String inResponseTo) { final SubjectConfirmationData subjectConfData = (SubjectConfirmationData) SAMLEngineUtils .createSamlObject(SubjectConfirmationData.DEFAULT_ELEMENT_NAME); subjectConfData.setNotOnOrAfter(notOnOrAfter); subjectConfData.setRecipient(recipient); subjectConfData.setInResponseTo(inResponseTo); return subjectConfData; } /** * Generate subject locality. * * @param address the address * * @return the subject locality */ public static SubjectLocality generateSubjectLocality(final String address) { final SubjectLocality subjectLocality = (SubjectLocality) SAMLEngineUtils .createSamlObject(SubjectLocality.DEFAULT_ELEMENT_NAME); subjectLocality.setAddress(address); return subjectLocality; } /** * Method that returns the current time. * * @return the current time */ public static DateTime getCurrentTime() { return new DateTime(); } /** * Instantiates a new SAML engine utilities. */ private SAMLEngineUtils() { } }