Updated SMCC to support non-blocking PIN entry. Added SV-Personendaten infobox implementation.

git-svn-id: https://joinup.ec.europa.eu/svn/mocca/trunk@248 8a26b1a7-26f0-462f-b9ef-d0e30c41f5a4

4 files changed, 385 insertions, 38 deletions

diff --git a/bkucommon/src/main/java/at/gv/egiz/bku/binding/DataUrlConnectionImpl.java b/bkucommon/src/main/java/at/gv/egiz/bku/binding/DataUrlConnectionImpl.java
index 408330cc..57d89c89 100644
--- a/bkucommon/src/main/java/at/gv/egiz/bku/binding/DataUrlConnectionImpl.java
+++ b/bkucommon/src/main/java/at/gv/egiz/bku/binding/DataUrlConnectionImpl.java
@@ -100,6 +100,7 @@ public class DataUrlConnectionImpl implements DataUrlConnectionSPI {
       }
       if (hostnameVerifier != null) {
         log.debug("Setting custom hostname verifier");
+        https.setHostnameVerifier(hostnameVerifier);
       }
     } else {
       log.trace("No secure connection with: "+url+ " class="+connection.getClass());
diff --git a/bkucommon/src/main/java/at/gv/egiz/bku/binding/LegacyDataUrlConnectionImpl.java b/bkucommon/src/main/java/at/gv/egiz/bku/binding/LegacyDataUrlConnectionImpl.java
index ef8034aa..452c45e5 100644
--- a/bkucommon/src/main/java/at/gv/egiz/bku/binding/LegacyDataUrlConnectionImpl.java
+++ b/bkucommon/src/main/java/at/gv/egiz/bku/binding/LegacyDataUrlConnectionImpl.java
@@ -80,6 +80,7 @@ public class LegacyDataUrlConnectionImpl implements DataUrlConnectionSPI {
       }
       if (hostnameVerifier != null) {
         log.debug("Setting custom hostname verifier");
+        https.setHostnameVerifier(hostnameVerifier);
       }
     }
     connection.setDoOutput(true);
@@ -229,6 +230,8 @@ public class LegacyDataUrlConnectionImpl implements DataUrlConnectionSPI {
   public DataUrlConnectionSPI newInstance() {
     DataUrlConnectionSPI uc = new LegacyDataUrlConnectionImpl();
     uc.setConfiguration(config);
+    uc.setSSLSocketFactory(sslSocketFactory);
+    uc.setHostnameVerifier(hostnameVerifier);
     return uc;
   }
 
diff --git a/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/AbstractAssocArrayInfobox.java b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/AbstractAssocArrayInfobox.java
index e49ed6c0..e7f96c06 100644
--- a/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/AbstractAssocArrayInfobox.java
+++ b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/AbstractAssocArrayInfobox.java
@@ -16,12 +16,17 @@
  */
 package at.gv.egiz.bku.slcommands.impl;
 
+import java.io.ByteArrayOutputStream;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Pattern;
 
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -36,6 +41,7 @@ import at.buergerkarte.namespaces.securitylayer._1.InfoboxReadParamsAssocArrayTy
 import at.buergerkarte.namespaces.securitylayer._1.InfoboxReadParamsAssocArrayType.ReadValue;
 import at.gv.egiz.bku.slcommands.InfoboxReadResult;
 import at.gv.egiz.bku.slcommands.SLCommandContext;
+import at.gv.egiz.bku.slcommands.SLCommandFactory;
 import at.gv.egiz.bku.slexceptions.SLCommandException;
 
 /**
@@ -54,7 +60,7 @@ public abstract class AbstractAssocArrayInfobox extends AbstractInfoboxImpl
   /**
    * The search string pattern.
    */
-  public static final String SEARCH_STRING_PATTERN = ".&&[^/](/.&&[^/])*";
+  public static final String SEARCH_STRING_PATTERN = "(.&&[^/])+(/.&&[^/])*";
   
   /**
    * @return the keys available in this infobox.
@@ -93,6 +99,11 @@ public abstract class AbstractAssocArrayInfobox extends AbstractInfoboxImpl
       return Arrays.asList(getKeys());
     }
     
+    if (!searchString.contains("*")) {
+      Arrays.asList(getKeys()).contains(searchString);
+      return Collections.singletonList(searchString);
+    }
+    
     if (Pattern.matches(SEARCH_STRING_PATTERN, searchString)) {
       
 //      for (int i = 0; i < searchString.length(); i++) {
@@ -160,15 +171,10 @@ public abstract class AbstractAssocArrayInfobox extends AbstractInfoboxImpl
   protected InfoboxReadResult readPairs(ReadPairs readPairs, SLCommandContext cmdCtx) throws SLCommandException {
     
     if (readPairs.isValuesAreXMLEntities() && !isValuesAreXMLEntities()) {
-      log.info("Got valuesAreXMLEntities=" + readPairs + " but infobox type is binary.");
+      log.info("Got valuesAreXMLEntities=" + readPairs.isValuesAreXMLEntities() + " but infobox type is binary.");
       throw new SLCommandException(4010);
     }
     
-    if (!readPairs.isValuesAreXMLEntities() && isValuesAreXMLEntities()) {
-      log.info("Got valuesAreXMLEntities=" + readPairs + " but infobox type is XML.");
-      throw new SLCommandException(4010);
-    }
-
     List<String> selectedKeys = selectKeys(readPairs.getSearchString());
     
     if (readPairs.isUserMakesUnique() && selectedKeys.size() > 1) {
@@ -177,26 +183,10 @@ public abstract class AbstractAssocArrayInfobox extends AbstractInfoboxImpl
       throw new SLCommandException(4010);
     }
     
-    ObjectFactory objectFactory = new ObjectFactory();
-
-    InfoboxReadDataAssocArrayType infoboxReadDataAssocArrayType = objectFactory.createInfoboxReadDataAssocArrayType();
-
-    Map<String, Object> values = getValues(selectedKeys, cmdCtx);
-    for (String key : selectedKeys) {
-      InfoboxAssocArrayPairType infoboxAssocArrayPairType = objectFactory.createInfoboxAssocArrayPairType();
-      infoboxAssocArrayPairType.setKey(key);
-      Object value = values.get(key);
-      if (value instanceof byte[]) {
-        infoboxAssocArrayPairType.setBase64Content((byte[]) value);
-      } else {
-        infoboxAssocArrayPairType.setXMLContent((XMLContentType) value);
-      }
-      infoboxReadDataAssocArrayType.getPair().add(infoboxAssocArrayPairType);
-    }
-    
-    return new InfoboxReadResultImpl(infoboxReadDataAssocArrayType);
+    return new InfoboxReadResultImpl(marshallPairs(selectedKeys, getValues(
+        selectedKeys, cmdCtx), readPairs.isValuesAreXMLEntities()));
   }
-
+  
   /**
    * Read the value specified by <code>readPairs</code>.
    * 
@@ -213,12 +203,7 @@ public abstract class AbstractAssocArrayInfobox extends AbstractInfoboxImpl
   protected InfoboxReadResult readValue(ReadValue readValue, SLCommandContext cmdCtx) throws SLCommandException {
     
     if (readValue.isValueIsXMLEntity() && !isValuesAreXMLEntities()) {
-      log.info("Got valuesAreXMLEntities=" + readValue + " but infobox type is binary.");
-      throw new SLCommandException(4010);
-    }
-    
-    if (!readValue.isValueIsXMLEntity() && isValuesAreXMLEntities()) {
-      log.info("Got valuesAreXMLEntities=" + readValue + " but infobox type is XML.");
+      log.info("Got valuesAreXMLEntities=" + readValue.isValueIsXMLEntity() + " but infobox type is binary.");
       throw new SLCommandException(4010);
     }
     
@@ -230,24 +215,59 @@ public abstract class AbstractAssocArrayInfobox extends AbstractInfoboxImpl
       selectedKeys = Collections.emptyList();
     }
     
+    return new InfoboxReadResultImpl(marshallPairs(selectedKeys, getValues(
+        selectedKeys, cmdCtx), readValue.isValueIsXMLEntity()));
+    
+  }
+  
+  protected InfoboxReadDataAssocArrayType marshallPairs(List<String> selectedKeys, Map<String, Object> values, boolean areXMLEntities) throws SLCommandException {
+    
     ObjectFactory objectFactory = new ObjectFactory();
-
+    
     InfoboxReadDataAssocArrayType infoboxReadDataAssocArrayType = objectFactory.createInfoboxReadDataAssocArrayType();
     
-    Map<String, Object> values = getValues(selectedKeys, cmdCtx);
     for (String key : selectedKeys) {
       InfoboxAssocArrayPairType infoboxAssocArrayPairType = objectFactory.createInfoboxAssocArrayPairType();
       infoboxAssocArrayPairType.setKey(key);
+     
       Object value = values.get(key);
-      if (value instanceof byte[]) {
-        infoboxAssocArrayPairType.setBase64Content((byte[]) value);
+      if (areXMLEntities) {
+        if (value instanceof byte[]) {
+          log.info("Got valuesAreXMLEntities=" + areXMLEntities + " but infobox type is binary.");
+          throw new SLCommandException(4122);
+        } else {
+          XMLContentType contentType = objectFactory.createXMLContentType();
+          contentType.getContent().add(value);
+          infoboxAssocArrayPairType.setXMLContent(contentType);
+        }
       } else {
-        infoboxAssocArrayPairType.setXMLContent((XMLContentType) value);
+        infoboxAssocArrayPairType.setBase64Content((value instanceof byte[]) ? (byte[]) value : marshallValue(value));
       }
+      
       infoboxReadDataAssocArrayType.getPair().add(infoboxAssocArrayPairType);
     }
+
+    return infoboxReadDataAssocArrayType;
     
-    return new InfoboxReadResultImpl(infoboxReadDataAssocArrayType);
+  }
+
+  protected byte[] marshallValue(Object jaxbElement) throws SLCommandException {
+    SLCommandFactory commandFactory = SLCommandFactory.getInstance();
+    JAXBContext jaxbContext = commandFactory.getJaxbContext();
+    
+    ByteArrayOutputStream result;
+    try {
+      Marshaller marshaller = jaxbContext.createMarshaller();
+      
+      result = new ByteArrayOutputStream();
+      marshaller.marshal(jaxbElement, result);
+    } catch (JAXBException e) {
+      log.info("Failed to marshall infobox content.", e);
+      throw new SLCommandException(4122);
+    }
+    
+    return result.toByteArray();
+  
   }
 
   @Override
diff --git a/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SVPersonendatenInfoboxImpl.java b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SVPersonendatenInfoboxImpl.java
new file mode 100644
index 00000000..7e204632
--- /dev/null
+++ b/bkucommon/src/main/java/at/gv/egiz/bku/slcommands/impl/SVPersonendatenInfoboxImpl.java
@@ -0,0 +1,323 @@
+/*
+* Copyright 2008 Federal Chancellery Austria and
+* Graz University of Technology
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package at.gv.egiz.bku.slcommands.impl;
+
+import iaik.asn1.ASN;
+import iaik.asn1.ASN1Object;
+import iaik.asn1.CodingException;
+import iaik.asn1.DerCoder;
+import iaik.asn1.NumericString;
+import iaik.asn1.OCTET_STRING;
+import iaik.asn1.ObjectID;
+import iaik.asn1.SEQUENCE;
+import iaik.asn1.SET;
+import iaik.asn1.UNKNOWN;
+import iaik.asn1.structures.ChoiceOfTime;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import at.buergerkarte.namespaces.cardchannel.AttributeList;
+import at.buergerkarte.namespaces.cardchannel.AttributeType;
+import at.buergerkarte.namespaces.cardchannel.ObjectFactory;
+import at.gv.egiz.bku.slcommands.SLCommandContext;
+import at.gv.egiz.bku.slexceptions.SLCommandException;
+import at.gv.egiz.bku.slexceptions.SLExceptionMessages;
+import at.gv.egiz.stal.InfoboxReadRequest;
+import at.gv.egiz.stal.InfoboxReadResponse;
+import at.gv.egiz.stal.STALRequest;
+
+/**
+ * An implementation of the {@link Infobox} <em>Certificates</em> as 
+ * specified in Security Layer 1.2. 
+ * 
+ * @author mcentner
+ */
+public class SVPersonendatenInfoboxImpl extends AbstractAssocArrayInfobox {
+  
+  /**
+   * Logging facility.
+   */
+  private static Log log = LogFactory.getLog(SVPersonendatenInfoboxImpl.class);
+
+  public static final String EHIC = "EHIC";
+  
+  public static final String GRUNDDATEN = "Grunddaten";
+  
+  public static final String STATUS = "Status";
+  
+  public static final String SV_PERSONENBINDUNG = "SV-Personenbindung";
+  
+  /**
+   * The valid keys.
+   */
+  public static final String[] KEYS = new String[] {
+    GRUNDDATEN, EHIC, STATUS, SV_PERSONENBINDUNG
+  };
+
+  @Override
+  public String getIdentifier() {
+    return "SV-Personendaten";
+  }
+
+  @Override
+  public String[] getKeys() {
+    return KEYS;
+  }
+
+  @Override
+  public boolean isValuesAreXMLEntities() {
+    return true;
+  }
+
+  @Override
+  public Map<String, Object> getValues(List<String> keys, SLCommandContext cmdCtx) throws SLCommandException {
+    
+    STALHelper stalHelper = new STALHelper(cmdCtx.getSTAL());
+    
+    if (keys != null && !keys.isEmpty()) {
+      
+      List<STALRequest> stalRequests = new ArrayList<STALRequest>();
+
+      // get values
+      InfoboxReadRequest infoboxReadRequest;
+      for (int i = 0; i < keys.size(); i++) {
+        infoboxReadRequest = new InfoboxReadRequest();
+        infoboxReadRequest.setInfoboxIdentifier(keys.get(i));
+        stalRequests.add(infoboxReadRequest);
+      }
+
+      stalHelper.transmitSTALRequest(stalRequests);
+
+      Map<String, Object> values = new HashMap<String, Object>();
+
+      try {
+        for (int i = 0; i < keys.size(); i++) {
+          
+          String key = keys.get(i);
+          InfoboxReadResponse nextResponse = (InfoboxReadResponse) stalHelper.nextResponse(InfoboxReadResponse.class);
+
+          
+          ObjectFactory objectFactory = new ObjectFactory();
+          
+          if (EHIC.equals(key)) {
+            AttributeList attributeList = createAttributeList(nextResponse.getInfoboxValue());
+            values.put(key, objectFactory.createEHIC(attributeList));
+          } else if (GRUNDDATEN.equals(key)) {
+            AttributeList attributeList = createAttributeList(nextResponse.getInfoboxValue());
+            values.put(key, objectFactory.createGrunddaten(attributeList));
+          } else if (SV_PERSONENBINDUNG.equals(key)) {
+            values.put(key, objectFactory.createSVPersonenbindung(nextResponse.getInfoboxValue()));
+          } else if (STATUS.equals(key)) {
+            AttributeList attributeList = createAttributeListFromRecords(nextResponse.getInfoboxValue());
+            values.put(key, objectFactory.createStatus(attributeList));
+          }
+          
+        }
+      } catch (CodingException e) {
+        log.info("Failed to decode '" + getIdentifier() + "' infobox.", e);
+        throw new SLCommandException(4000,
+            SLExceptionMessages.EC4000_UNCLASSIFIED_INFOBOX_INVALID,
+            new Object[] { "IdentityLink" });
+
+      }
+      
+      return values;
+      
+    } else {
+      
+      return new HashMap<String, Object>();
+      
+    }
+    
+    
+  }
+  
+  public static AttributeList createAttributeList(byte[] infoboxValue) throws CodingException {
+    
+    ObjectFactory objectFactory = new ObjectFactory();
+    
+    ASN1Object asn1 = DerCoder.decode(infoboxValue);
+    
+    AttributeList attributeList = objectFactory.createAttributeList();
+    List<AttributeType> attributes = attributeList.getAttribute();
+    
+    if (asn1.isA(ASN.SEQUENCE)) {
+      for (int i = 0; i < ((SEQUENCE) asn1).countComponents(); i++) {
+
+        AttributeType attributeType = objectFactory.createAttributeType();
+
+        if (asn1.getComponentAt(i).isA(ASN.SEQUENCE)) {
+          SEQUENCE attribute = (SEQUENCE) asn1.getComponentAt(i);
+          if (attribute.getComponentAt(0).isA(ASN.ObjectID)) {
+            ObjectID objectId = (ObjectID) attribute.getComponentAt(0);
+            attributeType.setOid("urn:oid:" + objectId.getID());
+          }
+          if (attribute.getComponentAt(1).isA(ASN.SET)) {
+            SET values = (SET) attribute.getComponentAt(1);
+            for (int j = 0; j < values.countComponents(); j++) {
+              setAttributeValue(attributeType, values.getComponentAt(j));
+            }
+          }
+        }
+        
+        attributes.add(attributeType);
+        
+      }
+      
+    }
+    
+    return attributeList;
+    
+  }
+  
+  public static AttributeList createAttributeListFromRecords(byte[] infoboxValue) throws CodingException {
+    
+    ObjectFactory objectFactory = new ObjectFactory();
+
+    AttributeList attributeList = objectFactory.createAttributeList();
+    List<AttributeType> attributes = attributeList.getAttribute();
+
+    byte[] records = infoboxValue;
+    
+    while (records != null && records.length > 0) {
+
+      int length;
+      
+      if (records[0] != 0x00) {
+        
+        ASN1Object asn1 = DerCoder.decode(records);
+
+        AttributeType attributeType = objectFactory.createAttributeType();
+
+        if (asn1.isA(ASN.SEQUENCE)) {
+          SEQUENCE attribute = (SEQUENCE) asn1;
+          if (attribute.getComponentAt(0).isA(ASN.ObjectID)) {
+            ObjectID objectId = (ObjectID) attribute.getComponentAt(0);
+            attributeType.setOid("urn:oid:" + objectId.getID());
+          }
+          if (attribute.getComponentAt(1).isA(ASN.SET)) {
+            SET values = (SET) attribute.getComponentAt(1);
+            for (int j = 0; j < values.countComponents(); j++) {
+              setAttributeValue(attributeType, values.getComponentAt(j));
+            }
+          }
+        }
+        
+        attributes.add(attributeType);
+
+        length = DerCoder.encode(asn1).length;
+
+      } else {
+        length = 1;
+      }
+      
+      if (length < records.length) {
+        records = Arrays.copyOfRange(records, length + 1, records.length);
+      } else {
+        records = null;
+      }
+      
+    }
+      
+    return attributeList;
+    
+  }
+  
+  private static void setAttributeValue(AttributeType attributeType, ASN1Object value) {
+    
+    if (value.isA(ASN.OCTET_STRING)) {
+      
+      try {
+        byte[] octets = ((OCTET_STRING) value).getWholeValue();
+        attributeType.setLatin1String(new String(octets, Charset.forName("ISO-8859-1")));
+      } catch (IOException e) {
+        log.info("Failed to set Latin1String.", e);
+      }
+      
+    } else if (value.isA(ASN.NumericString)) {
+      
+      attributeType.setNumericString((String) ((NumericString) value).getValue());
+      
+    } else if (value.isA(ASN.GeneralizedTime)) {
+      
+      try {
+        ChoiceOfTime choiceOfTime = new ChoiceOfTime(value);
+        
+        GregorianCalendar gregorianCalendar = new GregorianCalendar();
+        gregorianCalendar.setTimeZone(TimeZone.getTimeZone("UTC"));
+        gregorianCalendar.setTime(choiceOfTime.getDate());
+
+        DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
+        XMLGregorianCalendar xmlGregorianCalendar = datatypeFactory.newXMLGregorianCalendar(gregorianCalendar);
+        xmlGregorianCalendar.setTimezone(0);
+        
+        attributeType.setGeneralizedTime(xmlGregorianCalendar);
+      } catch (Exception e) {
+        log.info("Failed to set GeneralizedTime.", e);
+      }
+      
+    } else if (value.isA(ASN.INTEGER)) {
+      
+      attributeType.setInteger((BigInteger) value.getValue());
+      
+    } else if (value.isA(ASN.UTF8String)) {
+      
+      attributeType.setUTF8String((String) value.getValue());
+      
+    } else if (value.isA(ASN.PrintableString)) {
+      
+      attributeType.setPrintableString((String) value.getValue());
+      
+    } else if (value.isA(ASN.UNKNOWN)) {
+      
+      byte[] bytes = (byte[]) ((UNKNOWN) value).getValue();
+      
+      try {
+        BigInteger bigInteger = new BigInteger(bytes);
+        String string = bigInteger.toString(16);
+        
+        Date date = new SimpleDateFormat("yyyyMMdd").parse(string);
+        attributeType.setDate(new SimpleDateFormat("yyyy-MM-dd").format(date));
+      } catch (Exception e) {
+        log.info("Failed to set Date.", e);
+      }
+    }
+    
+  }
+
+    
+    
+  
+
+}