+ Information using STORK for secure authentication
+
+
+
+
The STORK project makes it easier for citizens to access online public services across borders by implementing Europe-wide interoperable cross border platforms for the mutual recognition of national electronic identity (eID) between participating countries.
+
For more information, please consult the STORK website:
+
+
\ No newline at end of file
diff --git a/id/server/auth/src/main/webapp/template_handyBKU.html b/id/server/auth/src/main/webapp/template_handyBKU.html
index 0ad73a6f3..27834cd91 100644
--- a/id/server/auth/src/main/webapp/template_handyBKU.html
+++ b/id/server/auth/src/main/webapp/template_handyBKU.html
@@ -12,7 +12,6 @@
+
AuthComponent/ForeignIdentities/STORK/C-PEPS
+ Unter diesem Konfigurationselement können die Verbindungsparameter zu den jeweiligen C-PEPS (Citizen Country - PEPS) der europäischen Länder, die auch STORK unterstützen, angegeben werden. Für eine erfolgreiche C-PEPS Konfiguration muss der ISO-Country Code des jeweiligen Landes und die dazugehörige C-PEPS URL angegeben werden. In Ausnahmenfällen müssen bei einzelnen C-PEPS länderspezifische Attribute abgefragt werden, dies funktioniert durch zusätzliche Angabe eines <stork:RequestedAttribute> Elements. Die C-PEPS Konfigurationen sind in den der MOA-Release beliegenden Beispielkonfigurationen bereits vorkonfiguriert. Sollte sich an diesen Konfigurationen etwas ändern, werden diese via JoinUp (MOA@JoinUp) bzw. MOA-Mailingliste veröffentlicht. Im Folgenden wird eine Beispielkonfiguration kurz veranschaulicht.
+
+ Details zur Angabe von <stork:RequestedAttribute> bzw. welche Attribute von STORK überhaupt unterstützt werden, wird in der Konfiguration zur Online Application angegeben (hier).
+
+
AuthComponent/ForeignIdentities/STORK/SAMLSigningParameter
+ Dieser Konfigurationseintrag enthält Informationen dazu, mit welchem Zertifikat ausgehende STORK SAML Nachichten signiert werden und welches MOA-SP TrustProfil zur Signaturüberprüfung von empfangenen STORK SAML Nachrichten herangezogen werden soll.
+ In der Konfiguration wird eine Unterscheidung zwischen Signaturerstellungs- und Signaturverifizierungsparameter getroffen:
+
+
<SignatureCreationParameter>
+
+
+
<SignatureVerificationParameter>
+
+
+
+ Der <SignatureCreationParameter> kapselt dabei Informationen, welche zum Signieren von ausgehenden STORK SAML Nachrichten benötigt werden. Im Wesentlichen sind das Informationen zu dem KeyStore, welcher das Schlüsselpaar zum Signieren ausgehender STORK SAML Nachrichten beinhaltet. Der entsprechende Konfigurationseintrag sieht wie folgt aus:
+
+ Die folgenden Werte sind dabei anzugeben bzw. durch echte Werte auszutauschen:
+
+
file_to_keystore: Relativer Pfad zum KeyStore (Java oder PKCS#12), welcher das Schlüsselpaar zum Signieren ausgehender STORK SAML Nachrichten speichert
+
+
+
Keystore Pass: Passwort zum angegebenen KeyStore
+
+
+
signing_key_name: Alias Name des Schlüssels, welcher zum Signieren verwendet werden soll
+
+
+
Key Pass: Passwort zum angegebenen Schlüssel
+
+
+
+ Der <SignatureCreationParameter> kapselt dabei Informationen, die für eine Signaturprüfung von eingehenden STORK SAML Nachrichten benötigt werden. Im Wesentlich ist das die Angabe des MOA-SP TrustProfils, welches die vertrauenswürdigen Zertifikate der europäischen C-PEPS enthält. Der entsprechende Konfigurationseintrag sieht daher wie folgt aus:
+
TrustProfile: Dieser Eintrag gibt jenes TrustProfil von MOA-SP an, welches zur Signaturprüfung von eingehenden STORK SAML Nachrichten herangezogen werden soll. Vorkonfiguriert sind die beiden TrustProfiles C-PEPS (Produktive C-PEPS Zertifikate) und C-PEPS-Test (Test C-PEPS Zertifikate). Sollte es auch hier zu Änderungen kommen, werden diese auch via JoinUp (MOA@JoinUp) bzw. MOA-Mailingliste veröffentlicht.
+
+
+
+
AuthComponent/OnlineMandates
Ab Version 1.5.0 bietet MOA-ID die Möglichkeit der Nutzung von Online-Vollmachten für Anwendungen aus dem öffentlichen Bereich. Hierfür ist ein Online-Vollmachten-Service nötig. Es ist hierzu ein ensprechender ConnectionParameter zu definieren, der die Zugangsdaten zum Online-Vollmachten-Service bereithält (siehe ConnectionParameter). In der Default-Konfiguration ist der Zugang zum Online-Vollmachten-Service bereits aktiviert. Es muss nur noch das Client-Zertifikat für die SSL-Verbinung zum Service angegeben werden. Voraussetzung dafür ist ein Zertifikat von A-Trust bzw. A-CERT mit Verwaltungseigenschaft oder Dienstleistereigenschaft. Wenn ihr MOA-ID Zertifikat diese Voraussetzung erfüllt, können Sie dieses hier angeben.
Hinweis: Um den Online-Vollmachten Modus für eine Online Applikation zu aktivieren, müssen Sie das Vollmachten Profil angeben - siehe hier.
@@ -923,11 +993,93 @@ Hinweis: Um den Online-Vollmachten Modus für eine Online Applikation zu akt
Mit Hilfe dieses Elements werden die Online-Vollmachten für die Online-Applikation aktiviert.
Als Kindelement muss Profiles angegeben werden. Dieses Element beinhaltet eine (Komma-separierte)
Liste von Vollmachten-Profilen, die festlegen mit welchen Vollmachtstypen man sich bei der Online-Applikation anmelden kann.
- Unter https://vollmachten.stammzahlenregister.gv.at/mis/ finden Sie eine Liste der untersttzen Vollmachten-Profile.
+ Unter https://vollmachten.stammzahlenregister.gv.at/mis/ finden Sie eine Liste der unterstützen Vollmachten-Profile.
Hinweis: Hierzu muss auch die Verbindung zum Online-Vollmachten Service konfiguriert werden - siehe hier
+
+
OnlineApplication/AuthComponent/STORK
+
+ Innerhalb dieses Konfigurationsblocks kann angegeben werden, welche zusätzlichen Attribute (neben eIdentifier, givenName, surname und dateOfBirth, welche defaultmäßig requested werden) im Rahmen einer STORK Anmeldung für diese Applikation vom Bürger abgefragt werden sollen. Außerdem kann zu Testzwecken das benötigte Authentifzierungslevel (STORK QAALevel) vom defaultmäßig höchstem Level von 4 für diese Applikation verringert werden.
+ Für ein anderes STORK QAALevel muss folgendes XML Element mit einem Wert zwischen 1 und 4 angegeben werden: <stork:QualityAuthenticationAssuranceLevel>.
+
+ Die zusätzlichen Attribute werden im Element <storkp:RequestedAttributes> gekapselt. Ein entsprechener Konfigurationseintrag könnte folgendermaßen aussehen:
+
+ Bei der Inkludierung von <stork:RequestedAttribute> Elementen sind folgende XML Attribute anzugeben:
+
+
Name: Der Name des entsprechenden STORK Attributes.
+
+
+
isRequired: Gibt durch true oder false an, ob das angefragte Attribut für die Applikation verpflichtend oder nur optional benötigt wird.
+
+
+
NameFormat: Gibt das Format des Attributes an und MUSS den Wert urn:oasis:names:tc:SAML:2.0:attrname-format:uri beinhalten.
+
+
+
Element <stork:AttributeValue>: Dieses Element ist optional und gibt einen Vergleichswert für ein abzufragendes Attribut an. Im Beispiel von isAgeOver wird in der Antwort retourniert, ob die authentifizierte Person älter als das geforderte angegebene Alter ist.
+
+
+
+ Details zu den STORK Attributen können im Anhang zur MOA-ID Spezifikation bzw. in der STORK Spezifikation gefunden werden.
+ Im Wesentlichen kann die folgende Menge an Attributen bzw. Teile daraus für eine Online Applikation angefragt werden:
+
OnlineApplication/ProxyComponent
diff --git a/id/server/doc/moa_id/moa.htm b/id/server/doc/moa_id/moa.htm
index 09fb1c5b6..3284e19cc 100644
--- a/id/server/doc/moa_id/moa.htm
+++ b/id/server/doc/moa_id/moa.htm
@@ -230,6 +230,7 @@ an den Benutzer weitergeleitet und die Anfragen des Benutzers an die OA weiterge
Ab der MOA Release 1.4.7 ist es möglich, dass sich auch ausländische Bürger mittels MOA-ID einloggen können. Hierzu wird eine Verbindung zu einem sogenannten Stammzahlenregister-Gateway aufgebaut, dass basierend auf den Zertifikatsdaten des ausländischen Bürgers eine Eintragung im Ergänzungsregister für natürliche Personen gemäß E-Government Gesetz §6(5) vornimmt. Somit ist es möglich, dass eine Personenbindung ausgestellt werden kann, die in weitere Folge an MOA-ID weitergeleitet wird.
Der Zugang zu diesem Stammzahlenregister-Gateway ist über eine Client-Server Authentifizierung abgesichert. Als Client-Zertifikate werden Zertifikate der Firmen A-Trust bzw. A-CERT, die mit der Verwaltungs- oder Dienstleistereigenschaft versehen sind, akzeptiert.
+
Ab MOA Release 1.5.2 ist es auch möglich, ausländische Bürger über STORK zu authentifizieren. Da auch für diese Art der Authentifizierung eine Kommunikation mit dem Stammzahlenregister-Gateway notwendig ist, gelten die zuvor angeführten Ausführungen auch für STORK.
Online-Vollmachten
diff --git a/id/server/idserverlib/.settings/org.eclipse.jdt.core.prefs b/id/server/idserverlib/.settings/org.eclipse.jdt.core.prefs
index 8bba65ebb..6d046587d 100644
--- a/id/server/idserverlib/.settings/org.eclipse.jdt.core.prefs
+++ b/id/server/idserverlib/.settings/org.eclipse.jdt.core.prefs
@@ -1,7 +1,7 @@
-#Thu Sep 20 14:35:41 CEST 2007
eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4
-org.eclipse.jdt.core.compiler.compliance=1.4
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning
org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning
-org.eclipse.jdt.core.compiler.source=1.4
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/id/server/idserverlib/.settings/org.eclipse.wst.common.component b/id/server/idserverlib/.settings/org.eclipse.wst.common.component
index 87b873d7b..a5eb3d4d8 100644
--- a/id/server/idserverlib/.settings/org.eclipse.wst.common.component
+++ b/id/server/idserverlib/.settings/org.eclipse.wst.common.component
@@ -1,7 +1,7 @@
-
-
-
-
-
-
-
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/id/server/idserverlib/.settings/org.eclipse.wst.common.project.facet.core.xml b/id/server/idserverlib/.settings/org.eclipse.wst.common.project.facet.core.xml
index 30c02fe23..656f15b87 100644
--- a/id/server/idserverlib/.settings/org.eclipse.wst.common.project.facet.core.xml
+++ b/id/server/idserverlib/.settings/org.eclipse.wst.common.project.facet.core.xml
@@ -2,6 +2,6 @@
-
-
+
+
\ No newline at end of file
diff --git a/id/server/idserverlib/pom.xml b/id/server/idserverlib/pom.xml
index 24d9452c2..7fbde1c6a 100644
--- a/id/server/idserverlib/pom.xml
+++ b/id/server/idserverlib/pom.xml
@@ -131,10 +131,23 @@
commons-lang2.6
+
+ MOA.id
+ stork-saml-engine
+ 1.5.2
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+ 1.5
+
+ org.apache.maven.pluginsmaven-jar-plugin
@@ -179,7 +192,7 @@
http://java.sun.com/j2se/1.5.0/docs/api/
http://logging.apache.org/log4j/docs/api/
- 1.4
+ 1.5
diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/AuthenticationServer.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/AuthenticationServer.java
index a58f5fce2..a57ab5262 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/AuthenticationServer.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/AuthenticationServer.java
@@ -29,8 +29,12 @@ import iaik.x509.X509Certificate;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
+import java.io.InputStream;
import java.security.GeneralSecurityException;
import java.security.Principal;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
@@ -41,18 +45,24 @@ import java.util.Map;
import java.util.Set;
import java.util.Vector;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import org.apache.xpath.XPathAPI;
+import org.opensaml.saml2.metadata.RequestedAttribute;
+import org.opensaml.xml.util.Base64;
+import org.opensaml.xml.util.XMLHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import at.gv.egovernment.moa.id.AuthenticationException;
import at.gv.egovernment.moa.id.BuildException;
+import at.gv.egovernment.moa.id.MOAIDException;
import at.gv.egovernment.moa.id.ParseException;
import at.gv.egovernment.moa.id.ServiceException;
import at.gv.egovernment.moa.id.auth.builder.AuthenticationBlockAssertionBuilder;
@@ -83,6 +93,9 @@ import at.gv.egovernment.moa.id.auth.parser.InfoboxReadResponseParser;
import at.gv.egovernment.moa.id.auth.parser.SAMLArtifactParser;
import at.gv.egovernment.moa.id.auth.parser.VerifyXMLSignatureResponseParser;
import at.gv.egovernment.moa.id.auth.servlet.AuthServlet;
+import at.gv.egovernment.moa.id.auth.servlet.PEPSConnectorServlet;
+import at.gv.egovernment.moa.id.auth.stork.STORKAuthnRequestProcessor;
+import at.gv.egovernment.moa.id.auth.stork.STORKException;
import at.gv.egovernment.moa.id.auth.validator.CreateXMLSignatureResponseValidator;
import at.gv.egovernment.moa.id.auth.validator.IdentityLinkValidator;
import at.gv.egovernment.moa.id.auth.validator.InfoboxValidator;
@@ -90,6 +103,9 @@ import at.gv.egovernment.moa.id.auth.validator.ValidateException;
import at.gv.egovernment.moa.id.auth.validator.VerifyXMLSignatureResponseValidator;
import at.gv.egovernment.moa.id.auth.validator.parep.ParepUtils;
import at.gv.egovernment.moa.id.auth.validator.parep.ParepValidator;
+import at.gv.egovernment.moa.id.auth.validator.parep.client.szrgw.CreateIdentityLinkResponse;
+import at.gv.egovernment.moa.id.auth.validator.parep.client.szrgw.SZRGWClient;
+import at.gv.egovernment.moa.id.auth.validator.parep.client.szrgw.SZRGWClientException;
import at.gv.egovernment.moa.id.auth.validator.parep.client.szrgw.SZRGWConstants;
import at.gv.egovernment.moa.id.config.ConfigurationException;
import at.gv.egovernment.moa.id.config.ConfigurationProvider;
@@ -98,6 +114,8 @@ import at.gv.egovernment.moa.id.config.auth.AuthConfigurationProvider;
import at.gv.egovernment.moa.id.config.auth.OAAuthParameter;
import at.gv.egovernment.moa.id.config.auth.VerifyInfoboxParameter;
import at.gv.egovernment.moa.id.config.auth.VerifyInfoboxParameters;
+import at.gv.egovernment.moa.id.config.stork.CPEPS;
+import at.gv.egovernment.moa.id.config.stork.STORKConfig;
import at.gv.egovernment.moa.id.data.AuthenticationData;
import at.gv.egovernment.moa.id.util.HTTPUtils;
import at.gv.egovernment.moa.id.util.MOAIDMessageProvider;
@@ -113,6 +131,15 @@ import at.gv.egovernment.moa.util.DOMUtils;
import at.gv.egovernment.moa.util.DateTimeUtils;
import at.gv.egovernment.moa.util.FileUtils;
import at.gv.egovernment.moa.util.StringUtils;
+import eu.stork.mw.messages.saml.STORKAuthnRequest;
+import eu.stork.vidp.messages.builder.STORKMessagesBuilder;
+import eu.stork.vidp.messages.common.STORKConstants;
+import eu.stork.vidp.messages.exception.SAMLException;
+import eu.stork.vidp.messages.exception.SAMLValidationException;
+import eu.stork.vidp.messages.stork.QualityAuthenticationAssuranceLevel;
+import eu.stork.vidp.messages.stork.RequestedAttributes;
+import eu.stork.vidp.messages.util.SAMLUtil;
+import eu.stork.vidp.messages.util.XMLUtil;
/**
* API for MOA ID Authentication Service. {@link AuthenticationSession} is
@@ -543,16 +570,16 @@ public class AuthenticationServer implements MOAIDAuthConstants {
int b = xmlInfoboxReadResponse.indexOf(se);
if (b != -1) { // no identity link found
Logger
- .info("Es konnte keine Personenbindung auf der Karte gefunden werden. Versuche Anmeldung als auslndische eID.");
+ .info("Es konnte keine Personenbindung auf der Karte gefunden werden. Versuche Anmeldung als ausl�ndische eID.");
return null;
}
- // spezifikationsgemer (SL1.2) Errorcode
+ // spezifikationsgem��er (SL1.2) Errorcode
se = "ErrorCode>4002";
// b = xmlInfoboxReadResponse.contains(se);
b = xmlInfoboxReadResponse.indexOf(se);
if (b != -1) { // Unbekannter Infoboxbezeichner
Logger
- .info("Unbekannter Infoboxbezeichner. Versuche Anmeldung als auslndische eID.");
+ .info("Unbekannter Infoboxbezeichner. Versuche Anmeldung als ausl�ndische eID.");
return null;
}
@@ -1732,7 +1759,7 @@ public class AuthenticationServer implements MOAIDAuthConstants {
// builds authentication data and stores it together with a SAML
// artifact
AuthenticationData authData = buildAuthenticationData(session, vsresp,
- useUTC);
+ useUTC, false);
if (session.getUseMandate()) {
// mandate mode
@@ -2037,17 +2064,7 @@ public class AuthenticationServer implements MOAIDAuthConstants {
AuthenticationSession session = getSession(sessionID);
// AuthConfigurationProvider authConf =
// AuthConfigurationProvider.getInstance();
- try {
- String serializedAssertion = DOMUtils.serializeNode(session
- .getIdentityLink().getSamlAssertion());
- session.setAuthBlock(serializedAssertion);
- } catch (TransformerException e) {
- throw new ParseException("parser.04", new Object[] {
- REQ_VERIFY_AUTH_BLOCK, PARAM_XMLRESPONSE });
- } catch (IOException e) {
- throw new ParseException("parser.04", new Object[] {
- REQ_VERIFY_AUTH_BLOCK, PARAM_XMLRESPONSE });
- }
+
// post processing of the infoboxes
Iterator iter = session.getInfoboxValidatorIterator();
boolean formpending = false;
@@ -2097,7 +2114,7 @@ public class AuthenticationServer implements MOAIDAuthConstants {
boolean useCondition = oaParam.getUseCondition();
int conditionLength = oaParam.getConditionLength();
AuthenticationData authData = buildAuthenticationData(session, vsresp,
- useUTC);
+ useUTC, true);
String samlAssertion = new AuthenticationDataAssertionBuilder().build(
authData, session.getAssertionPrPerson(), session
@@ -2141,6 +2158,9 @@ public class AuthenticationServer implements MOAIDAuthConstants {
* authentication session
* @param verifyXMLSigResp
* VerifyXMLSignatureResponse from MOA-SP
+ * @param useUTC uses correct UTC time format
+ * @param useUTC indicates that authenticated citizen is a foreigner
+ * @param isForeigner indicates whether Austrian (false) or foreigner (true) authenticates
* @return AuthenticationData object
* @throws ConfigurationException
* while accessing configuration data
@@ -2149,7 +2169,7 @@ public class AuthenticationServer implements MOAIDAuthConstants {
*/
private AuthenticationData buildAuthenticationData(
AuthenticationSession session,
- VerifyXMLSignatureResponse verifyXMLSigResp, boolean useUTC)
+ VerifyXMLSignatureResponse verifyXMLSigResp, boolean useUTC, boolean isForeigner)
throws ConfigurationException, BuildException {
IdentityLink identityLink = session.getIdentityLink();
@@ -2196,21 +2216,44 @@ public class AuthenticationServer implements MOAIDAuthConstants {
}
}
authData.setSignerCertificate(signerCertificateBase64);
- if (businessService) {
- authData.setWBPK(identityLink.getIdentificationValue());
+ if(!isForeigner) {
+ //we have Austrian citizen
+ if (businessService) {
+ authData.setWBPK(identityLink.getIdentificationValue());
+ } else {
+ authData.setBPK(identityLink.getIdentificationValue());
+
+ // BZ.., calculation of bPK already before sending AUTHBlock
+ /*
+ * if(identityLink.getIdentificationType().equals(Constants.
+ * URN_PREFIX_BASEID)) { // only compute bPK if online
+ * application is a public service and we have the Stammzahl
+ * String bpkBase64 = new BPKBuilder().buildBPK(
+ * identityLink.getIdentificationValue(), session.getTarget());
+ * authData.setBPK(bpkBase64); }
+ */
+
+ }
} else {
- authData.setBPK(identityLink.getIdentificationValue());
-
- // BZ.., calculation of bPK already before sending AUTHBlock
- /*
- * if(identityLink.getIdentificationType().equals(Constants.
- * URN_PREFIX_BASEID)) { // only compute bPK if online
- * application is a public service and we have the Stammzahl
- * String bpkBase64 = new BPKBuilder().buildBPK(
- * identityLink.getIdentificationValue(), session.getTarget());
- * authData.setBPK(bpkBase64); }
- */
-
+ //we have foreigner, thus we have to calculate bPK and wbPK now (after receiving identity link from SZR-GW
+ if (businessService) {
+ //since we have foreigner, wbPK is not calculated in BKU
+ if(identityLink.getIdentificationType().equals(Constants.URN_PREFIX_BASEID)) {
+ String wbpkBase64 = new BPKBuilder().buildWBPK(identityLink.getIdentificationValue(), session.getDomainIdentifier());
+ authData.setWBPK(wbpkBase64);
+ }
+
+ } else {
+
+ if(identityLink.getIdentificationType().equals(Constants.URN_PREFIX_BASEID)) {
+ // only compute bPK if online application is a public service and we have the Stammzahl
+ String bpkBase64 = new BPKBuilder().buildBPK(identityLink.getIdentificationValue(), session.getTarget());
+ authData.setBPK(bpkBase64);
+ }
+
+
+ }
+
}
String ilAssertion = oaParam.getProvideIdentityLink() ? identityLink
.getSerializedSamlAssertion()
@@ -2227,8 +2270,7 @@ public class AuthenticationServer implements MOAIDAuthConstants {
session.setAssertionBusinessService(businessService);
session.setAssertionIlAssertion(ilAssertion);
session.setAssertionPrPerson(prPerson);
- session
- .setAssertionSignerCertificateBase64(signerCertificateBase64);
+ session.setAssertionSignerCertificateBase64(signerCertificateBase64);
return authData;
@@ -2482,4 +2524,288 @@ public class AuthenticationServer implements MOAIDAuthConstants {
return value;
}
+
+ /**
+ * Does the request to the SZR-GW
+ * @param signature XMLDSIG signature
+ * @return Identity link assertion
+ * @throws SZRGWClientException
+ */
+ public CreateIdentityLinkResponse getIdentityLink(String PEPSIdentifier, String PEPSFirstname, String PEPSFamilyname, String PEPSDateOfBirth, Element signature) throws SZRGWClientException {
+
+ SZRGWClient client = new SZRGWClient();
+
+ try {
+ AuthConfigurationProvider authConf = AuthConfigurationProvider.getInstance();
+ ConnectionParameter connectionParameters = authConf.getForeignIDConnectionParameter();
+
+ client.setAddress(connectionParameters.getUrl());
+ if (connectionParameters.getUrl().toLowerCase().startsWith("https:")) {
+ Logger.debug("Initialisiere SSL Verbindung");
+ try {
+ client.setSSLSocketFactory(SSLUtils.getSSLSocketFactory(AuthConfigurationProvider.getInstance(), connectionParameters));
+ } catch (IOException e) {
+ Logger.error("Could not initialize SSL Factory", e);
+ throw new SZRGWClientException("Could not initialize SSL Factory");
+ } catch (GeneralSecurityException e) {
+ Logger.error("Could not initialize SSL Factory", e);
+ throw new SZRGWClientException("Could not initialize SSL Factory");
+ } catch (PKIException e) {
+ Logger.error("Could not initialize SSL Factory", e);
+ throw new SZRGWClientException("Could not initialize SSL Factory");
+ }
+ }
+ Logger.info("Starte Kommunikation mit dem Stammzahlenregister Gateway(" + connectionParameters.getUrl() + ")...");
+ }
+ catch (ConfigurationException e) {
+ Logger.warn(e);
+ Logger.warn(MOAIDMessageProvider.getInstance().getMessage("config.12", null ));
+ }
+
+ // create request
+ CreateIdentityLinkResponse response = null;
+ Element request = null;
+ try {
+ Document doc = client.buildGetIdentityLinkRequest(PEPSIdentifier, PEPSFirstname, PEPSFamilyname, PEPSDateOfBirth, signature);
+ request = doc.getDocumentElement();
+
+ // send request
+ response = client.createIdentityLinkResponse(request);
+ } catch (SZRGWClientException e) {
+ // give him a second try - Nach dem Starten des Tomcat wird beim ersten Mal das Client-Zertifikat offenbar vom HTTPClient nicht mitgeschickt.
+ try {
+ response = client.createIdentityLinkResponse(request);
+ }
+ catch (SZRGWClientException e1) {
+ throw new SZRGWClientException(e1);
+ }
+ }
+
+
+ return response;
+
+ }
+
+ /**
+ * Starts a MOA-ID authentication process using STORK
+ * @param req HttpServletRequest
+ * @param resp HttpServletResponse
+ * @param ccc Citizen country code
+ * @param oaURL URL of the online application
+ * @param target Target parameter
+ * @param targetFriendlyName Friendly Name of Target
+ * @param authURL Authentication URL
+ * @param sourceID SourceID parameter
+ * @throws MOAIDException
+ * @throws AuthenticationException
+ * @throws WrongParametersException
+ * @throws ConfigurationException
+ */
+ public static void startSTORKAuthentication(
+ HttpServletRequest req,
+ HttpServletResponse resp,
+ String ccc,
+ String oaURL,
+ String target,
+ String targetFriendlyName,
+ String authURL,
+ String sourceID) throws MOAIDException, AuthenticationException, WrongParametersException, ConfigurationException {
+
+ //read configuration paramters of OA
+ OAAuthParameter oaParam = AuthConfigurationProvider.getInstance().getOnlineApplicationParameter(oaURL);
+ if (oaParam == null)
+ throw new AuthenticationException("auth.00", new Object[] { oaURL });
+
+ if (!oaParam.getBusinessService()) {
+ if (StringUtils.isEmpty(target))
+ throw new WrongParametersException("StartAuthentication", PARAM_TARGET, "auth.05");
+ } else {
+ target = null;
+ }
+
+ //create MOA session
+ AuthenticationSession moaSession = newSession();
+ Logger.info("MOASession " + moaSession.getSessionID() + " angelegt");
+ moaSession.setTarget(target);
+ moaSession.setTargetFriendlyName(targetFriendlyName);
+ moaSession.setOAURLRequested(oaURL);
+ moaSession.setPublicOAURLPrefix(oaParam.getPublicURLPrefix());
+ moaSession.setAuthURL(authURL);
+ moaSession.setBusinessService(oaParam.getBusinessService());
+ moaSession.setDomainIdentifier(oaParam.getIdentityLinkDomainIdentifier());
+ if (sourceID != null)
+ moaSession.setSourceID(sourceID);
+
+ //Start of STORK Processing
+ STORKConfig storkConfig = AuthConfigurationProvider.getInstance().getStorkConfig();
+
+ CPEPS cpeps = storkConfig.getCPEPS(ccc);
+
+ Logger.debug("Preparing to assemble STORK AuthnRequest witht the following values:");
+ String destination = cpeps.getPepsURL().toExternalForm();
+ Logger.debug("C-PEPS URL: " + destination);
+
+ String acsURL = HTTPUtils.getBaseURL(req) + PEPSConnectorServlet.PEPSCONNECTOR_SERVLET_URL_PATTERN;
+ Logger.debug("MOA Assertion Consumer URL (PEPSConnctor): " + acsURL);
+
+ String providerName= oaParam.getFriendlyName();
+ String issuerValue = HTTPUtils.getBaseURL(req);
+ Logger.debug("Issuer value: " + issuerValue);
+
+ QualityAuthenticationAssuranceLevel qaaLevel = STORKMessagesBuilder.buildQualityAuthenticationAssuranceLevel(oaParam.getQaaLevel().getValue());
+ Logger.debug("QAALevel: " + qaaLevel.getValue());
+
+ RequestedAttributes requestedAttributes;
+
+ requestedAttributes = oaParam.getRequestedAttributes();
+ requestedAttributes.detach();
+ List reqAttributeList = new ArrayList();
+ List oaReqAttributeList = new ArrayList(oaParam.getRequestedAttributes().getRequestedAttributes());
+ //check if country specific attributes must be additionally requested
+ if (!cpeps.getCountrySpecificRequestedAttributes().isEmpty()) {
+ //add country specific attributes to be requested (Hierarchy: default oa attributes > country specific attributes > oa specific attributes
+ Logger.debug("We have addtional country specific attributes to be requested from the C-PEPS of country: " + ccc);
+ Logger.debug("The following attributes are requested for this specific country:");
+ List countrySpecificReqAttributeList = new ArrayList(cpeps.getCountrySpecificRequestedAttributes());
+ for (RequestedAttribute csReqAttr : countrySpecificReqAttributeList) {
+ csReqAttr.detach();
+ if (!STORKConstants.DEFAULT_STORK_REQUESTED_ATTRIBUTE_SET.contains(csReqAttr.getName())) {
+ //this country specific attribute does not override default attribute
+ if (SAMLUtil.containsAttribute(oaReqAttributeList, csReqAttr.getName())) {
+ //the same attribute is requested for OA, applying hierachy
+ //remove oa attribute
+ oaReqAttributeList.remove(SAMLUtil.getAttribute(oaReqAttributeList, csReqAttr.getName()));
+ //add country specific attribute instead
+ Logger.debug("Requested Attribute (" + csReqAttr.getName() + ") is also requested by OA but we use Country Specific value instead");
+ }
+ oaReqAttributeList.add(csReqAttr);
+ Logger.debug("Country specific requested attribute: " + csReqAttr.getName() + ", isRequired: " + csReqAttr.isRequired());
+ } else {
+ Logger.debug("Country specific requested attribute: " + csReqAttr.getName() + ", isRequired: " + csReqAttr.isRequired() + " tries to overwrite default requested and required attributes, hence we skip it.");
+ }
+
+ }
+ reqAttributeList.addAll(oaReqAttributeList);
+ } else {
+ //no country specific requested attributes
+ reqAttributeList.addAll(oaReqAttributeList);
+ }
+
+ reqAttributeList = (List) SAMLUtil.releaseDOM(reqAttributeList);
+ requestedAttributes = STORKMessagesBuilder.buildRequestedAttributes(reqAttributeList);
+
+ if (Logger.isDebugEnabled()) {
+ Logger.debug("The following attributes are requested for this OA:");
+ for (RequestedAttribute logReqAttr : reqAttributeList) {
+ Logger.debug("OA specific requested attribute: " + logReqAttr.getName() + ", isRequired: " + logReqAttr.isRequired());
+
+ }
+ }
+
+ String spSector = StringUtils.isEmpty(target) ? "Business" : target;
+ String spInstitution = StringUtils.isEmpty(oaParam.getFriendlyName()) ? "UNKNOWN" : oaParam.getFriendlyName();
+ String spApplication = spInstitution;
+ String spCountry = "AT";
+
+ String textToBeSigned =
+ CreateXMLSignatureRequestBuilder.buildForeignIDTextToBeSigned("wie im Signaturzertifikat (as in my signature certificate)", oaParam, moaSession);
+
+ //generate AuthnRquest
+ STORKAuthnRequest storkAuthnRequest = STORKAuthnRequestProcessor.generateSTORKAuthnRequest(
+ destination,
+ acsURL,
+ providerName,
+ issuerValue,
+ qaaLevel,
+ requestedAttributes,
+ spSector,
+ spInstitution,
+ spApplication,
+ spCountry,
+ textToBeSigned,
+ "application/xhtml+xml");
+
+ Logger.debug("STORK AuthnRequest succesfully assembled.");
+
+ //sign AuthnRequest
+ String keyStorePath = storkConfig.getSignatureCreationParameter().getKeyStorePath();
+ String keyStorePassword = storkConfig.getSignatureCreationParameter().getKeyStorePassword();
+ String keyName = storkConfig.getSignatureCreationParameter().getKeyName();
+ String keyPassword = storkConfig.getSignatureCreationParameter().getKeyPassword();
+
+ Logger.debug("Starting signing process of STORK AuthnRequest.");
+ Logger.trace("Using the following Keystore and Key for that:");
+ Logger.trace("KeyStore: " + keyStorePath);
+ Logger.trace("KeyName: " + keyName);
+
+ try {
+ storkAuthnRequest = STORKAuthnRequestProcessor.signSTORKAuthnRequest(storkAuthnRequest, keyStorePath, keyStorePassword, keyName, keyPassword);
+ } catch (SAMLException e) {
+ Logger.error("Could not sign STORK SAML AuthnRequest.", e);
+ throw new MOAIDException("stork.00", null);
+ }
+
+ Logger.info("STORK AuthnRequest successfully signed!");
+
+ //validate AuthnRequest
+ try {
+ STORKAuthnRequestProcessor.validateSTORKAuthnRequest(storkAuthnRequest);
+ } catch (SAMLValidationException e) {
+ Logger.error("STORK SAML AuthnRequest not valid.", e);
+ throw new MOAIDException("stork.01", null);
+ }
+
+ Logger.debug("STORK AuthnRequest successfully internally validated.");
+
+ //send
+ moaSession.setStorkAuthnRequest(storkAuthnRequest);
+ HttpSession httpSession = req.getSession();
+ httpSession.setAttribute("MOA-Session-ID", moaSession.getSessionID());
+
+ Logger.debug("Preparing to send STORK AuthnRequest.");
+
+ try {
+ STORKAuthnRequestProcessor.sendSTORKAuthnRequest(req, resp, storkAuthnRequest);
+ } catch (Exception e) {
+ Logger.error("Error sending STORK SAML AuthnRequest.", e);
+ httpSession.invalidate();
+ throw new MOAIDException("stork.02", new Object[] { destination });
+ }
+
+ Logger.info("STORK AuthnRequest successfully sent to: " + storkAuthnRequest.getDestination());
+ Logger.debug("STORKAuthnRequest sent (pretty print): ");
+ Logger.debug(XMLHelper.prettyPrintXML(storkAuthnRequest.getDOM()));
+ Logger.trace("STORKAuthnRequest sent (original): ");
+ Logger.trace(XMLUtil.printXML(storkAuthnRequest.getDOM()));
+
+ }
+
+ /**
+ * Extracts an X509 Certificate out of an XML signagture element
+ * @param signedXML XML signature element
+ * @return X509Certificate
+ * @throws CertificateException
+ */
+ public static X509Certificate getCertificateFromXML(Element signedXML) throws CertificateException {
+
+ NodeList nList = signedXML.getElementsByTagNameNS(Constants.DSIG_NS_URI, "X509Certificate");
+
+ String base64CertString = XMLUtil.getFirstTextValueFromNodeList(nList);
+
+ if (StringUtils.isEmpty(base64CertString)) {
+ String msg = "XML does not contain a X509Certificate element.";
+ Logger.error(msg);
+ throw new CertificateException(msg);
+ }
+
+ InputStream is = new ByteArrayInputStream(Base64.decode(base64CertString));
+
+ CertificateFactory cf;
+ X509Certificate cert = null;
+ cf = CertificateFactory.getInstance("X.509");
+ cert = (X509Certificate)cf.generateCertificate(is);
+
+ return cert;
+ }
+
}
diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/MOAIDAuthConstants.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/MOAIDAuthConstants.java
index f3be98ef0..7d5835f20 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/MOAIDAuthConstants.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/MOAIDAuthConstants.java
@@ -47,6 +47,8 @@ public interface MOAIDAuthConstants {
public static final String PARAM_SOURCEID = "sourceID";
/** servlet parameter "BKUSelectionTemplate" */
public static final String PARAM_BKUTEMPLATE = "BKUSelectionTemplate";
+ /** servlet parameter "CCC (Citizen Country Code)" */
+ public static final String PARAM_CCC = "CCC";
/** servlet parameter "BKUSelectionTemplate" */
public static final String PARAM_INPUT_PROCESSOR_SIGN_TEMPLATE = "InputProcessorSignTemplate";
/** default BKU URL */
diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/BPKBuilder.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/BPKBuilder.java
index b6ba5871d..fa9789530 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/BPKBuilder.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/BPKBuilder.java
@@ -56,7 +56,7 @@ public class BPKBuilder {
target.length() == 0))
{
throw new BuildException("builder.00",
- new Object[] {"BPK", "Unvollstndige Parameterangaben: identificationValue=" +
+ new Object[] {"BPK", "Unvollständige Parameterangaben: identificationValue=" +
identificationValue + ",target=" + target});
}
String basisbegriff = identificationValue + "+" + Constants.URN_PREFIX_CDID + "+" + target;
@@ -86,7 +86,7 @@ public class BPKBuilder {
registerAndOrdNr.length() == 0))
{
throw new BuildException("builder.00",
- new Object[] {"wbPK", "Unvollstndige Parameterangaben: identificationValue=" +
+ new Object[] {"wbPK", "Unvollständige Parameterangaben: identificationValue=" +
identificationValue + ",Register+Registernummer=" + registerAndOrdNr});
}
String basisbegriff = identificationValue + "+" + Constants.URN_PREFIX_WBPK + "+" + registerAndOrdNr;
diff --git a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/CreateXMLSignatureRequestBuilder.java b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/CreateXMLSignatureRequestBuilder.java
index 9c696f245..2da7db2b2 100644
--- a/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/CreateXMLSignatureRequestBuilder.java
+++ b/id/server/idserverlib/src/main/java/at/gv/egovernment/moa/id/auth/builder/CreateXMLSignatureRequestBuilder.java
@@ -129,7 +129,31 @@ public class CreateXMLSignatureRequestBuilder implements Constants {
* @return String representation of <CreateXMLSignatureRequest>
*/
public String buildForeignID(String subject, OAAuthParameter oaParam, AuthenticationSession session) {
+
+ String request = "";
+ request += "";
+ request += "SecureSignatureKeypair";
+ request += "";
+ request += "";
+ request += "";
+
+ request += buildForeignIDTextToBeSigned(subject, oaParam, session);
+ request += "";
+ request += "";
+ request += "";
+ request += "";
+ request += "application/xhtml+xml";
+ request += "";
+ request += "";
+ request += "";
+ request += "";
+
+ return request;
+ }
+
+ public static String buildForeignIDTextToBeSigned(String subject, OAAuthParameter oaParam, AuthenticationSession session) {
+
String target = session.getTarget();
String sectorName = TargetToSectorNameMapper.getSectorNameViaTarget(target);
@@ -137,14 +161,9 @@ public class CreateXMLSignatureRequestBuilder implements Constants {
String date = DateTimeUtils.buildDate(cal);
String time = DateTimeUtils.buildTime(cal);
- String request = "";
- request += "";
- request += "SecureSignatureKeypair";
- request += "";
- request += "";
- request += "";
-
- request += "";
+ String request = "";
+ request += ""; //application/xhtml+xml text/html
+ //request += "";
request += "";
request += "Signatur der Anmeldedaten";
request += "