5 files changed, 102 insertions, 78 deletions

diff --git a/src/applets/ECKeyGenerator.java b/src/applets/ECKeyGenerator.java
index 28b3ed3..e9bdfa6 100644
--- a/src/applets/ECKeyGenerator.java
+++ b/src/applets/ECKeyGenerator.java
@@ -1,6 +1,7 @@
 package applets;
 
 import javacard.framework.ISO7816;
+import javacard.framework.ISOException;
 import javacard.framework.Util;
 import javacard.security.CryptoException;
 import javacard.security.ECPrivateKey;
@@ -16,17 +17,18 @@ public class ECKeyGenerator {
     private ECPrivateKey ecPrivateKey = null;
     private ECPublicKey ecPublicKey = null;
 
-    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 static final byte KEY_PUBLIC = 0x01;
+    public static final byte KEY_PRIVATE = 0x02;
+    public static final byte KEY_BOTH = KEY_PUBLIC | KEY_PRIVATE;
 
 
-    public short allocatePair(byte algorithm, short keyLength) {
+    //TODO: add something like allocateGenerate, or modify allocate to auto-generate a key-pair if it returns null key references after allocating
+    public short allocatePair(byte keyClass, short keyLength) {
         short result = ISO7816.SW_NO_ERROR;
         try {
-            ecKeyPair = new KeyPair(algorithm, keyLength);
-            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate();
+            ecKeyPair = new KeyPair(keyClass, keyLength);
             ecPublicKey = (ECPublicKey) ecKeyPair.getPublic();
+            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate();
         } catch (CryptoException ce) {
             result = ce.getReason();
         } catch (Exception e) {
@@ -36,15 +38,15 @@ public class ECKeyGenerator {
     }
 
     public boolean isAllocated() {
-        return ecKeyPair != null && ecPrivateKey != null && ecPublicKey != null;
+        return ecKeyPair != null;
     }
 
     public short generatePair() {
         short result = ISO7816.SW_NO_ERROR;
         try {
             ecKeyPair.genKeyPair();
-            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate();
             ecPublicKey = (ECPublicKey) ecKeyPair.getPublic();
+            ecPrivateKey = (ECPrivateKey) ecKeyPair.getPrivate();
         } catch (CryptoException ce) {
             result = ce.getReason();
         } catch (Exception e) {
@@ -63,18 +65,20 @@ public class ECKeyGenerator {
         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);
+            sw = setParameter(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);
+            sw = setParameter(KEY_BOTH, EC_Consts.PARAMETER_F2M, buffer, offset, length);
         }
         if (sw != ISO7816.SW_NO_ERROR) return sw;
 
         //go through all params
-        for (byte param = EC_Consts.PARAMETER_A; param <= EC_Consts.PARAMETER_K; param = (byte)(param << 1)) {
+        byte param = EC_Consts.PARAMETER_A;
+        while (param > 0) {
             length = EC_Consts.getCurveParameter(curve, param, buffer, offset);
-            sw = setExternalParameter(KEY_BOTH, param, buffer, offset, length);
+            sw = setParameter(KEY_BOTH, param, buffer, offset, length);
             if (sw != ISO7816.SW_NO_ERROR) break;
+            param = (byte) (param << 1);
         }
         return sw;
     }
@@ -89,68 +93,76 @@ public class ECKeyGenerator {
 
         //go through param bit by bit, and invalidate all selected params
         byte paramMask = 0x01;
-        while (paramMask <= EC_Consts.PARAMETER_K) {
-            byte masked = (byte)(paramMask & param);
-            if (masked != 0){
+        while (paramMask > 0) {
+            byte masked = (byte) (paramMask & param);
+            if (masked != 0) {
                 short length = EC_Consts.getCorruptCurveParameter(curve, masked, buffer, offset, corruptionType);
-                sw = setExternalParameter(key, masked, buffer, offset, length);
+                sw = setParameter(key, masked, buffer, offset, length);
                 if (sw != ISO7816.SW_NO_ERROR) return sw;
             }
-            paramMask = (byte)(paramMask << 1);
+            paramMask = (byte) (paramMask << 1);
         }
         return sw;
     }
 
-    public short setExternalParameter(byte key, byte param, byte[] data, short offset, short length) {
+    public short setParameter(byte key, byte param, byte[] data, short offset, short length) {
         short result = ISO7816.SW_NO_ERROR;
         try {
             switch (param) {
-                case EC_Consts.PARAMETER_FP:
-                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldFP(data, offset, length);
+                case EC_Consts.PARAMETER_FP: {
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setFieldFP(data, offset, length);
+                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldFP(data, offset, length);
                     break;
-                case EC_Consts.PARAMETER_F2M:
+                }
+                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);
+                        if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldF2M(i);
                     } 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);
+                        if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setFieldF2M(i1, i2, i3);
                     } else {
                         result = ISO7816.SW_UNKNOWN;
                     }
                     break;
-                case EC_Consts.PARAMETER_A:
-                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setA(data, offset, length);
+                }
+                case EC_Consts.PARAMETER_A: {
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setA(data, offset, length);
+                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setA(data, offset, length);
                     break;
-                case EC_Consts.PARAMETER_B:
-                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setB(data, offset, length);
+                }
+                case EC_Consts.PARAMETER_B: {
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setB(data, offset, length);
+                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setB(data, offset, length);
                     break;
-                case EC_Consts.PARAMETER_G:
-                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setG(data, offset, length);
+                }
+                case EC_Consts.PARAMETER_G: {
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setG(data, offset, length);
+                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setG(data, offset, length);
                     break;
-                case EC_Consts.PARAMETER_R:
-                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setR(data, offset, length);
+                }
+                case EC_Consts.PARAMETER_R: {
                     if ((key & KEY_PUBLIC) != 0) ecPublicKey.setR(data, offset, length);
+                    if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setR(data, offset, length);
                     break;
-                case EC_Consts.PARAMETER_K:
+                }
+                case EC_Consts.PARAMETER_K: {
                     if (length != 2) {
                         result = ISO7816.SW_UNKNOWN;
                     } else {
-                        short k = Util.makeShort(data[offset], data[(short) (offset + 1)]);
-                        if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setK(k);
+                        short k = Util.getShort(data, offset);
                         if ((key & KEY_PUBLIC) != 0) ecPublicKey.setK(k);
+                        if ((key & KEY_PRIVATE) != 0) ecPrivateKey.setK(k);
                     }
                     break;
-                default:
-                    result = ISO7816.SW_UNKNOWN;
+                }
+                default: {
+                    ISOException.throwIt(ISO7816.SW_FUNC_NOT_SUPPORTED);
+                }
             }
         } catch (CryptoException ce) {
             result = ce.getReason();
@@ -160,35 +172,35 @@ public class ECKeyGenerator {
         return result;
     }
 
-    public short setExternalCurve(byte key, byte keyClass, byte[] buffer, short offset, short fieldLength, short aLength, short bLength, short gxLength, short gyLength, short rLength){
+    public short setExternalCurve(byte key, byte keyClass, byte[] buffer, short offset, short fieldLength, short aLength, short bLength, short gxLength, short gyLength, short rLength) {
         short sw = ISO7816.SW_NO_ERROR;
         if (keyClass == KeyPair.ALG_EC_FP) {
-            sw = setExternalParameter(key, EC_Consts.PARAMETER_FP, buffer, offset, fieldLength);
+            sw = setParameter(key, EC_Consts.PARAMETER_FP, buffer, offset, fieldLength);
         } else if (keyClass == KeyPair.ALG_EC_F2M) {
-            sw = setExternalParameter(key, EC_Consts.PARAMETER_F2M, buffer, offset, fieldLength);
+            sw = setParameter(key, EC_Consts.PARAMETER_F2M, buffer, offset, fieldLength);
         }
         if (sw != ISO7816.SW_NO_ERROR) return sw;
 
         offset += fieldLength;
 
         //go through all params
-        sw = setExternalParameter(key, EC_Consts.PARAMETER_A, buffer, offset, aLength);
+        sw = setParameter(key, EC_Consts.PARAMETER_A, buffer, offset, aLength);
         if (sw != ISO7816.SW_NO_ERROR) return sw;
         offset += aLength;
-        sw = setExternalParameter(key, EC_Consts.PARAMETER_B, buffer, offset, bLength);
+        sw = setParameter(key, EC_Consts.PARAMETER_B, buffer, offset, bLength);
         if (sw != ISO7816.SW_NO_ERROR) return sw;
         offset += bLength;
 
-        sw = setExternalParameter(key, EC_Consts.PARAMETER_G, buffer, offset, (short) (gxLength + gyLength));
+        sw = setParameter(key, EC_Consts.PARAMETER_G, buffer, offset, (short) (gxLength + gyLength));
         if (sw != ISO7816.SW_NO_ERROR) return sw;
         offset += gxLength + gyLength;
 
 
-        sw = setExternalParameter(key, EC_Consts.PARAMETER_R, buffer, offset, aLength);
+        sw = setParameter(key, EC_Consts.PARAMETER_R, buffer, offset, aLength);
         if (sw != ISO7816.SW_NO_ERROR) return sw;
         offset += rLength;
 
-        sw = setExternalParameter(key, EC_Consts.PARAMETER_K, buffer, offset, (short) 2);
+        sw = setParameter(key, EC_Consts.PARAMETER_K, buffer, offset, (short) 2);
         return sw;
     }
 
@@ -226,7 +238,7 @@ public class ECKeyGenerator {
                     length = 2;
                     break;
                 default:
-                    length = -1;
+                    ISOException.throwIt(ISO7816.SW_FUNC_NOT_SUPPORTED);
             }
         } catch (CryptoException ce) {
             length = -1;
diff --git a/src/applets/ECKeyTester.java b/src/applets/ECKeyTester.java
index 1031b06..d6ff6c1 100644
--- a/src/applets/ECKeyTester.java
+++ b/src/applets/ECKeyTester.java
@@ -91,13 +91,13 @@ public class ECKeyTester {
      *          exception reason otherwise
      **/
     public short testECDH_validPoint(ECPrivateKey privateKey, ECPublicKey publicKey, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset) {
-        publicKey.getW(pubkeyBuffer, pubkeyOffset);
-        return testDH_validPoint(ecdhKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, (short) pubkeyBuffer.length, outputBuffer, outputOffset);
+        short length = publicKey.getW(pubkeyBuffer, pubkeyOffset);
+        return testDH_validPoint(ecdhKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, length, outputBuffer, outputOffset);
     }
 
     public short testECDH_invalidPoint(ECPrivateKey privateKey, ECPublicKey publicKey, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset) {
-        publicKey.getW(pubkeyBuffer, pubkeyOffset);
-        return testDH_invalidPoint(ecdhKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, (short) pubkeyBuffer.length, outputBuffer, outputOffset);
+        short length = publicKey.getW(pubkeyBuffer, pubkeyOffset);
+        return testDH_invalidPoint(ecdhKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, length, outputBuffer, outputOffset);
     }
 
 
@@ -115,13 +115,13 @@ public class ECKeyTester {
      *          exception reason otherwise
      */
     public short testECDHC_validPoint(ECPrivateKey privateKey, ECPublicKey publicKey, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset) {
-        publicKey.getW(pubkeyBuffer, pubkeyOffset);
-        return testDH_validPoint(ecdhcKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, (short) pubkeyBuffer.length, outputBuffer, outputOffset);
+        short length = publicKey.getW(pubkeyBuffer, pubkeyOffset);
+        return testDH_validPoint(ecdhcKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, length, outputBuffer, outputOffset);
     }
 
     public short testECDHC_invalidPoint(ECPrivateKey privateKey, ECPublicKey publicKey, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset) {
-        publicKey.getW(pubkeyBuffer, pubkeyOffset);
-        return testDH_invalidPoint(ecdhcKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, (short) pubkeyBuffer.length, outputBuffer, outputOffset);
+        short length = publicKey.getW(pubkeyBuffer, pubkeyOffset);
+        return testDH_invalidPoint(ecdhcKeyAgreement, privateKey, pubkeyBuffer, pubkeyOffset, length, outputBuffer, outputOffset);
     }
 
     /**
diff --git a/src/applets/EC_Consts.java b/src/applets/EC_Consts.java
index e39570a..d5f23d1 100644
--- a/src/applets/EC_Consts.java
+++ b/src/applets/EC_Consts.java
@@ -70,7 +70,7 @@ public class EC_Consts {
     // cofactor of G
     public static final short EC128_FP_K = 1;
 
-    // secp160r1 
+    // secp160r1
     public static final byte[] EC160_FP_P = new byte[]{
             (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
             (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
@@ -1108,32 +1108,32 @@ public class EC_Consts {
         switch (param) {
             case PARAMETER_FP:
                 if (alg == KeyPair.ALG_EC_FP) {
-                    length = Util.arrayCopyNonAtomic(outputBuffer, outputOffset, EC_FP_P, (short) 0, (short) EC_FP_P.length);
+                    length = Util.arrayCopyNonAtomic(EC_FP_P, (short) 0, outputBuffer, outputOffset, (short) EC_FP_P.length);
                 }
                 break;
             case PARAMETER_F2M:
                 if (alg == KeyPair.ALG_EC_F2M) {
-                    length = Util.arrayCopyNonAtomic(outputBuffer, outputOffset, EC_F2M_F2M, (short) 0, (short) EC_F2M_F2M.length);
+                    length = Util.arrayCopyNonAtomic(EC_F2M_F2M, (short) 0, outputBuffer, outputOffset,  (short) EC_F2M_F2M.length);
                 }
                 break;
             case PARAMETER_A:
-                length = Util.arrayCopyNonAtomic(outputBuffer, outputOffset, EC_A, (short) 0, (short) EC_A.length);
+                length = Util.arrayCopyNonAtomic(EC_A, (short) 0, outputBuffer, outputOffset,  (short) EC_A.length);
                 break;
             case PARAMETER_B:
-                length = Util.arrayCopyNonAtomic(outputBuffer, outputOffset, EC_B, (short) 0, (short) EC_B.length);
+                length = Util.arrayCopyNonAtomic(EC_B, (short) 0, outputBuffer, outputOffset,  (short) EC_B.length);
                 break;
             case PARAMETER_G:
                 length = decompressG(outputBuffer, outputOffset, EC_G_X, (short) 0, (short) EC_G_X.length, EC_G_Y, (short) 0, (short) EC_G_Y.length);
                 break;
             case PARAMETER_R:
-                length = Util.arrayCopyNonAtomic(outputBuffer, outputOffset, EC_R, (short) 0, (short) EC_R.length);
+                length = Util.arrayCopyNonAtomic(EC_R, (short) 0, outputBuffer, outputOffset, (short) EC_R.length);
                 break;
             case PARAMETER_K:
                 length = 2;
                 Util.setShort(outputBuffer, outputOffset, EC_K);
                 break;
             default:
-                length = -1;
+                ISOException.throwIt(ISO7816.SW_FUNC_NOT_SUPPORTED);
         }
         return length;
     }
@@ -1169,9 +1169,9 @@ public class EC_Consts {
                 rngPos %= length; // make < param length
 
                 byte original = outputBuffer[rngPos];
-                while (original != outputBuffer[rngPos]) {
+                do {
                     m_random.generateData(outputBuffer, rngPos, (short) 1);
-                }
+                } while (original == outputBuffer[rngPos]);
                 break;
             case CORRUPTION_ZERO:
                 Util.arrayFillNonAtomic(outputBuffer, outputOffset, length, (byte) 0);
@@ -1181,6 +1181,16 @@ public class EC_Consts {
                 break;
             default:
                 ISOException.throwIt(ISO7816.SW_FUNC_NOT_SUPPORTED);
+            /* //TODO implement CORRUPT_B_LASTBYTEINCREMENT somehow
+                    case CORRUPT_B_LASTBYTEINCREMENT:
+                        m_ramArray2[(short) (m_lenB - 1)] += 1;
+                        // Make sure its not the valid byte again
+                        if (m_ramArray[(short) (m_lenB - 1)] == m_ramArray2[(short) (m_lenB - 1)]) {
+                            m_ramArray2[(short) (m_lenB - 1)] += 1; // if yes, increment once more
+                        }
+                        break;
+                }
+                */
         }
         return length;
     }
@@ -1193,10 +1203,11 @@ public class EC_Consts {
         short size = 1;
         size += gxLength;
         size += gyLength;
+
         short offset = outputOffset;
+        outputBuffer[offset] = 0x04;
         offset += 1;
 
-        outputBuffer[offset] = 0x04;
         offset = Util.arrayCopyNonAtomic(gx, gxOffset, outputBuffer, offset, gxLength);
         Util.arrayCopyNonAtomic(gy, gyOffset, outputBuffer, offset, gyLength);
         return size;
diff --git a/src/applets/SimpleECCApplet.java b/src/applets/SimpleECCApplet.java
index 3b5b514..404bf00 100644
--- a/src/applets/SimpleECCApplet.java
+++ b/src/applets/SimpleECCApplet.java
@@ -8,7 +8,7 @@ import javacard.framework.*;
 import javacard.security.*;
 
 
-public class SimpleECCApplet extends javacard.framework.Applet {
+public class SimpleECCApplet extends Applet {
 
     // MAIN INSTRUCTION CLASS
     final static byte CLA_SIMPLEECCAPPLET = (byte) 0xB0;
@@ -297,7 +297,7 @@ public class SimpleECCApplet extends javacard.framework.Applet {
             ecPubKey = ecKeyGenerator.getPublicKey();
             ecPrivKey = ecKeyGenerator.getPrivateKey();
             if (sw == ISO7816.SW_NO_ERROR) {
-                sw = ecKeyTester.testECDH_validPoint(ecPrivKey, ecPubKey, m_ramArray, (short) 0, m_ramArray2, (short) 1);
+                sw = ecKeyTester.testECDH_validPoint(ecPrivKey, ecPubKey, m_ramArray, (short) 0, m_ramArray2, (short) 0);
             }
         }
         Util.setShort(buffer, bufferOffset, sw);
@@ -427,7 +427,7 @@ public class SimpleECCApplet extends javacard.framework.Applet {
             return (short) (outputOffset - startOffset);
         }
 
-        // setExternalParam -> forall in {field, a, b, g, r, k}
+        // setExternalCurve
         buffer[outputOffset] = ECTEST_SET_EXTERNALCURVE;
         outputOffset++;
         sw = ecKeyGenerator.setExternalCurve(ECKeyGenerator.KEY_BOTH, keyClass, buffer, bufferOffset, fieldLength, aLength, bLength, gxLength, gyLength, rLength);
@@ -598,10 +598,18 @@ public class SimpleECCApplet extends javacard.framework.Applet {
             } else {
                 testFlags = 0;
             }
+
+            if (ecPubKey == null || ecPrivKey == null) {
+                ecKeyGenerator.generatePair();
+                ecPrivKey = ecKeyGenerator.getPrivateKey();
+                ecPubKey = ecKeyGenerator.getPublicKey();
+            }
         }
         Util.setShort(buffer, bufferOffset, sw);
         bufferOffset += 2;
 
+
+
         //
         // 2. Set invalid custom curve (many times)
         //
@@ -620,6 +628,8 @@ public class SimpleECCApplet extends javacard.framework.Applet {
                     bufferOffset = startOffset;
                 }
 
+                ecPubKey.getB(m_ramArray2, (short) 0); //store valid B
+
                 // set invalid curve
                 buffer[bufferOffset] = ECTEST_SET_INVALIDCURVE;
                 bufferOffset++;
@@ -631,23 +641,13 @@ public class SimpleECCApplet extends javacard.framework.Applet {
                 // CORRUPTION_ONEBYTERANDOM = 0x04, one random byte randomly changed
                 // CORRUPTION_ZERO = 0x05, parameter competely zero
                 // CORRUPTION_ONE = 0x06, parameter completely one
-                sw = ecKeyGenerator.setCustomInvalidCurve(keyClass, keyClass, ECKeyGenerator.KEY_PUBLIC, EC_Consts.PARAMETER_B, corruptionType, m_ramArray, (short) 0);
+                sw = ecKeyGenerator.setCustomInvalidCurve(keyClass, keyLen, ECKeyGenerator.KEY_BOTH, EC_Consts.PARAMETER_B, corruptionType, m_ramArray, (short) 0);
                 Util.setShort(buffer, bufferOffset, sw);
                 bufferOffset += 2;
                 if (sw != ISO7816.SW_NO_ERROR) {
                     // if we reach this line, we are interested in value of B that caused incorrect response
                     break; // stop execution, return B
                 }
-                /* //TODO implement CORRUPT_B_LASTBYTEINCREMENT somehow
-                    case CORRUPT_B_LASTBYTEINCREMENT:
-                        m_ramArray2[(short) (m_lenB - 1)] += 1;
-                        // Make sure its not the valid byte again
-                        if (m_ramArray[(short) (m_lenB - 1)] == m_ramArray2[(short) (m_lenB - 1)]) {
-                            m_ramArray2[(short) (m_lenB - 1)] += 1; // if yes, increment once more
-                        }
-                        break;
-                }
-                */
 
                 // Gen key pair with invalid curve
 
@@ -668,6 +668,7 @@ public class SimpleECCApplet extends javacard.framework.Applet {
 
                     sw = ecKeyTester.testECDH_validPoint(ecPrivKey, ecPubKey, m_ramArray, (short) 0, m_ramArray2, (short) 0);
                     m_lenB = ecPubKey.getB(m_ramArray2, (short) 0); //store B
+                    //TODO: note, according to the previous version of this method, sw should get appended to the buffer only if sw != SW_NO_ERROR
                     Util.setShort(buffer, bufferOffset, sw);
                     bufferOffset += 2;
                     break; //stop execution, return B
diff --git a/src/simpleapdu/SimpleAPDU.java b/src/simpleapdu/SimpleAPDU.java
index 7401509..ead8fb7 100644
--- a/src/simpleapdu/SimpleAPDU.java
+++ b/src/simpleapdu/SimpleAPDU.java
@@ -106,7 +106,7 @@ public class SimpleAPDU {
             if (cardManager.ConnectToCard()) {
 
                 testSupportECAll(cardManager);
-
+                //
                 // Test setting invalid parameter B of curve   
                 byte[] testAPDU = Arrays.clone(TESTECSUPPORTALL_FP_KEYGEN_INVALIDCURVEB);
                 //testFPkeyGen_setCorruptionType(testAPDU, SimpleECCApplet.CORRUPT_B_LASTBYTEINCREMENT);