1 files changed, 92 insertions, 51 deletions

diff --git a/src/applets/ECKeyGenerator.java b/src/applets/ECKeyGenerator.java
index ff2193c..c7155de 100644
--- a/src/applets/ECKeyGenerator.java
+++ b/src/applets/ECKeyGenerator.java
@@ -16,26 +16,17 @@ public class ECKeyGenerator {
     private ECPrivateKey ecPrivateKey = null;
     private ECPublicKey ecPublicKey = null;
 
-    public static final byte PARAMETER_FP = 1;
-    public static final byte PARAMETER_F2M_ONE = 2;
-    public static final byte PARAMETER_F2M_THREE = 3;
-    public static final byte PARAMETER_A = 4;
-    public static final byte PARAMETER_B = 5;
-    public static final byte PARAMETER_G = 6;
-    public static final byte PARAMETER_R = 7;
-    public static final byte PARAMETER_K = 8;
-
-    private static final byte PARAMETER_S = 9; //private key
-    private static final byte PARAMETER_W = 10;//public key
-
     public static final byte KEY_PUBLIC = 0x1;
     public static final byte KEY_PRIVATE = 0x2;
     public static final byte KEY_BOTH = KEY_PUBLIC & KEY_PRIVATE;
 
+
     public short allocatePair(byte algorithm, short keyLength) {
         short result = ISO7816.SW_NO_ERROR;
         try {
             ecKeyPair = new KeyPair(algorithm, keyLength);
+            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate();
+            ecPublicKey = (ECPublicKey) ecKeyPair.getPublic();
         } catch (CryptoException ce) {
             result = ce.getReason();
         } catch (Exception e) {
@@ -44,7 +35,7 @@ public class ECKeyGenerator {
         return result;
     }
 
-    public boolean isAlocated() {
+    public boolean isAllocated() {
         return ecKeyPair != null && ecPrivateKey != null && ecPublicKey != null;
     }
 
@@ -52,7 +43,7 @@ public class ECKeyGenerator {
         short result = ISO7816.SW_NO_ERROR;
         try {
             ecKeyPair.genKeyPair();
-            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate(); //TODO, do I want to keep private and pubkey separate from the keypair?
+            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate();
             ecPublicKey = (ECPublicKey) ecKeyPair.getPublic();
         } catch (CryptoException ce) {
             result = ce.getReason();
@@ -62,61 +53,84 @@ public class ECKeyGenerator {
         return result;
     }
 
-    public short setCustomCurve(byte keyClass, short keyLength) {
-        //TODO
-        return 0;
+    public short setCustomCurve(byte keyClass, short keyLength, byte[] buffer, short offset) {
+        return setCustomCurve(EC_Consts.getCurve(keyClass, keyLength), buffer, offset);
+    }
+
+    public short setCustomCurve(byte curve, byte[] buffer, short offset) {
+        byte alg = EC_Consts.getCurveType(curve);
+        short sw = ISO7816.SW_NO_ERROR;
+        short length;
+        if (alg == KeyPair.ALG_EC_FP) {
+            length = EC_Consts.getCurveParameter(curve, EC_Consts.PARAMETER_FP, buffer, offset);
+            sw = setExternalParameter(KEY_BOTH, EC_Consts.PARAMETER_FP, buffer, offset, length);
+        } else if (alg == KeyPair.ALG_EC_F2M) {
+            length = EC_Consts.getCurveParameter(curve, EC_Consts.PARAMETER_F2M, buffer, offset);
+            sw = setExternalParameter(KEY_BOTH, EC_Consts.PARAMETER_F2M, buffer, offset, length);
+        }
+        if (sw != ISO7816.SW_NO_ERROR) return sw;
+
+        for (byte param = EC_Consts.PARAMETER_A; param < EC_Consts.PARAMETER_K; ++param) {
+            length = EC_Consts.getCurveParameter(curve, param, buffer, offset);
+            sw = setExternalParameter(KEY_BOTH, param, buffer, offset, length);
+            if (sw != ISO7816.SW_NO_ERROR) break;
+        }
+        return sw;
     }
 
-    public short setCustomCurve(byte curve) {
-        //TODO
-        return 0;
+    public short setCustomInvalidCurve(short keyClass, short keyLength, byte key, byte param, short corruptionType, byte[] buffer, short offset) {
+        return setCustomInvalidCurve(EC_Consts.getCurve(keyClass, keyLength), key, param, corruptionType, buffer, offset);
+    }
+
+    public short setCustomInvalidCurve(byte curve, byte key, byte param, short corruptionType, byte[] buffer, short offset) {
+        short sw = setCustomCurve(curve, buffer, offset);
+        if (sw != ISO7816.SW_NO_ERROR) return sw;
+
+        short length = EC_Consts.getCorruptCurveParameter(curve, param, buffer, offset, corruptionType);
+        sw = setExternalParameter(key, param, buffer, offset, length);
+        return sw;
     }
 
     public short setExternalParameter(byte key, byte param, byte[] data, short offset, short length) {
         short result = ISO7816.SW_NO_ERROR;
         try {
             switch (param) {
-                case PARAMETER_FP:
+                case EC_Consts.PARAMETER_FP:
                     if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldFP(data, offset, length);
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setFieldFP(data, offset, length);
                     break;
-                case PARAMETER_F2M_ONE:
-                    if (length != 2) {
-                        result = ISO7816.SW_UNKNOWN;
-                    } else {
+                case EC_Consts.PARAMETER_F2M:
+                    if (length == 2) {
                         short i = Util.makeShort(data[offset], data[(short) (offset + 1)]);
                         if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldF2M(i);
                         if ((key & KEY_PUBLIC) != 0) ecPublicKey.setFieldF2M(i);
-                    }
-                    break;
-                case PARAMETER_F2M_THREE:
-                    if (length != 6) {
-                        result = ISO7816.SW_UNKNOWN;
-                    } else {
+                    } else if (length == 6) {
                         short i1 = Util.makeShort(data[offset], data[(short) (offset + 1)]);
                         short i2 = Util.makeShort(data[(short) (offset + 2)], data[(short) (offset + 3)]);
                         short i3 = Util.makeShort(data[(short) (offset + 4)], data[(short) (offset + 5)]);
                         if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldF2M(i1, i2, i3);
                         if ((key & KEY_PUBLIC) != 0) ecPublicKey.setFieldF2M(i1, i2, i3);
+                    } else {
+                        result = ISO7816.SW_UNKNOWN;
                     }
                     break;
-                case PARAMETER_A:
+                case EC_Consts.PARAMETER_A:
                     if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setA(data, offset, length);
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setA(data, offset, length);
                     break;
-                case PARAMETER_B:
+                case EC_Consts.PARAMETER_B:
                     if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setB(data, offset, length);
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setB(data, offset, length);
                     break;
-                case PARAMETER_G:
+                case EC_Consts.PARAMETER_G:
                     if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setG(data, offset, length);
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setG(data, offset, length);
                     break;
-                case PARAMETER_R:
+                case EC_Consts.PARAMETER_R:
                     if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setR(data, offset, length);
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setR(data, offset, length);
                     break;
-                case PARAMETER_K:
+                case EC_Consts.PARAMETER_K:
                     if (length != 2) {
                         result = ISO7816.SW_UNKNOWN;
                     } else {
@@ -125,10 +139,10 @@ public class ECKeyGenerator {
                         if ((key & KEY_PUBLIC) != 0) ecPublicKey.setK(k);
                     }
                     break;
-                case PARAMETER_S:
+                case EC_Consts.PARAMETER_S:
                     if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setS(data, offset, length);
                     break;
-                case PARAMETER_W:
+                case EC_Consts.PARAMETER_W:
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setW(data, offset, length);
                     break;
                 default:
@@ -142,27 +156,54 @@ public class ECKeyGenerator {
         return result;
     }
 
-    public short exportParameter(byte key, byte param, byte[] outputBuffer, short outputOffset) {
+    public short exportParameter(byte key, short param, byte[] outputBuffer, short outputOffset) {
         if (key == KEY_BOTH) {
-            return ISO7816.SW_UNKNOWN;
-        }
-        short result = ISO7816.SW_NO_ERROR;
+            return -1;
+        }//TODO: change error handling.
+        short length = 0;
         try {
-            switch(param){
-                case PARAMETER_FP:
-
+            switch (param) {
+                case EC_Consts.PARAMETER_FP:
+                case EC_Consts.PARAMETER_F2M:
+                    if ((key & KEY_PUBLIC) != 0) length = ecPublicKey.getField(outputBuffer, outputOffset);
+                    if ((key & KEY_PRIVATE) != 0) length = ecPrivateKey.getField(outputBuffer, outputOffset);
+                    break;
+                case EC_Consts.PARAMETER_A:
+                    if ((key & KEY_PUBLIC) != 0) length = ecPublicKey.getA(outputBuffer, outputOffset);
+                    if ((key & KEY_PRIVATE) != 0) length = ecPrivateKey.getA(outputBuffer, outputOffset);
+                    break;
+                case EC_Consts.PARAMETER_B:
+                    if ((key & KEY_PUBLIC) != 0) length = ecPublicKey.getB(outputBuffer, outputOffset);
+                    if ((key & KEY_PRIVATE) != 0) length = ecPrivateKey.getB(outputBuffer, outputOffset);
+                    break;
+                case EC_Consts.PARAMETER_G:
+                    if ((key & KEY_PUBLIC) != 0) length = ecPublicKey.getG(outputBuffer, outputOffset);
+                    if ((key & KEY_PRIVATE) != 0) length = ecPrivateKey.getG(outputBuffer, outputOffset);
+                    break;
+                case EC_Consts.PARAMETER_R:
+                    if ((key & KEY_PUBLIC) != 0) length = ecPublicKey.getR(outputBuffer, outputOffset);
+                    if ((key & KEY_PRIVATE) != 0) length = ecPrivateKey.getR(outputBuffer, outputOffset);
+                    break;
+                case EC_Consts.PARAMETER_K:
+                    if ((key & KEY_PUBLIC) != 0) Util.setShort(outputBuffer, outputOffset, ecPublicKey.getK());
+                    if ((key & KEY_PRIVATE) != 0) Util.setShort(outputBuffer, outputOffset, ecPrivateKey.getK());
+                    length = 2;
+                    break;
+                case EC_Consts.PARAMETER_S:
+                    if ((key & KEY_PRIVATE) != 0) length = ecPrivateKey.getS(outputBuffer, outputOffset);
+                    break;
+                case EC_Consts.PARAMETER_W:
+                    if ((key & KEY_PUBLIC) != 0) length = ecPublicKey.getW(outputBuffer, outputOffset);
                     break;
-
                 default:
-
+                    length = -1;
             }
         } catch (CryptoException ce) {
-
+            length = -1;
         } catch (Exception e) {
-
+            length = -1;
         }
-        //TODO
-        return result;
+        return length;
     }
 
     public ECPrivateKey getPrivateKey() {