Rename the CORRUPT command to TRANSFORM, as it does that now.

4 files changed, 72 insertions, 72 deletions

diff --git a/src/cz/crcs/ectester/applet/ECKeyGenerator.java b/src/cz/crcs/ectester/applet/ECKeyGenerator.java
index 244bdba..9150248 100644
--- a/src/cz/crcs/ectester/applet/ECKeyGenerator.java
+++ b/src/cz/crcs/ectester/applet/ECKeyGenerator.java
@@ -139,38 +139,38 @@ public class ECKeyGenerator {
 
     /**
      * @param keypair
-     * @param corruptParams
-     * @param corruption
+     * @param params
+     * @param transformation
      * @param buffer
      * @param offset
      * @return
      */
-    public short corruptCurve(KeyPair keypair, short corruptParams, short corruption, byte[] buffer, short offset) {
-        return corruptCurve(keypair, EC_Consts.KEY_BOTH, corruptParams, corruption, buffer, offset);
+    public short transformCurve(KeyPair keypair, short params, short transformation, byte[] buffer, short offset) {
+        return transformCurve(keypair, EC_Consts.KEY_BOTH, params, transformation, buffer, offset);
     }
 
     /**
      * @param keypair
      * @param key
-     * @param corruptParams
-     * @param corruption
+     * @param params
+     * @param transformation
      * @param buffer
      * @param offset
      * @return
      */
-    public short corruptCurve(KeyPair keypair, byte key, short corruptParams, short corruption, byte[] buffer, short offset) {
+    public short transformCurve(KeyPair keypair, byte key, short params, short transformation, byte[] buffer, short offset) {
         sw = ISO7816.SW_NO_ERROR;
-        if (corruptParams == EC_Consts.PARAMETERS_NONE) {
+        if (params == EC_Consts.PARAMETERS_NONE) {
             return sw;
         }
 
         //go through param bit by bit, and invalidate all selected params
         short paramMask = EC_Consts.PARAMETER_FP;
         while (paramMask <= EC_Consts.PARAMETER_S) {
-            short masked = (short) (paramMask & corruptParams);
+            short masked = (short) (paramMask & params);
             if (masked != 0) {
                 short length = exportParameter(keypair, key, masked, buffer, offset);
-                length = EC_Consts.corruptParameter(corruption, buffer, offset, length);
+                length = EC_Consts.transformParameter(transformation, buffer, offset, length);
                 sw = setParameter(keypair, key, masked, buffer, offset, length);
                 if (sw != ISO7816.SW_NO_ERROR) break;
             }
diff --git a/src/cz/crcs/ectester/applet/ECKeyTester.java b/src/cz/crcs/ectester/applet/ECKeyTester.java
index 36515ef..27bb9e1 100644
--- a/src/cz/crcs/ectester/applet/ECKeyTester.java
+++ b/src/cz/crcs/ectester/applet/ECKeyTester.java
@@ -52,10 +52,10 @@ public class ECKeyTester {
      * @param pubkeyOffset offset into pubkeyBuffer that can be used for the public key
      * @param outputBuffer buffer to be used for the secret output
      * @param outputOffset offset into the outputBuffer
-     * @param corruption   (EC_Consts.CORRUPTION_* | ...)
+     * @param transformation   (EC_Consts.TRANSFORMATION_* | ...)
      * @return derived secret length
      **/
-    public short testKA(KeyPair privatePair, KeyPair publicPair, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset, short corruption) {
+    public short testKA(KeyPair privatePair, KeyPair publicPair, byte[] pubkeyBuffer, short pubkeyOffset, byte[] outputBuffer, short outputOffset, short transformation) {
         short length = 0;
         try {
             sw = AppletUtil.kaCheck(ecKeyAgreement);
@@ -64,7 +64,7 @@ public class ECKeyTester {
             short pubkeyLength = ((ECPublicKey) publicPair.getPublic()).getW(pubkeyBuffer, pubkeyOffset);
             ecKeyAgreement.init(privatePair.getPrivate());
 
-            pubkeyLength = EC_Consts.corruptParameter(corruption, pubkeyBuffer, pubkeyOffset, pubkeyLength);
+            pubkeyLength = EC_Consts.transformParameter(transformation, pubkeyBuffer, pubkeyOffset, pubkeyLength);
             length = ecKeyAgreement.generateSecret(pubkeyBuffer, pubkeyOffset, pubkeyLength, outputBuffer, outputOffset);
         } catch (CardRuntimeException ce) {
             sw = ce.getReason();
@@ -79,17 +79,17 @@ public class ECKeyTester {
      * @param pubkeyLength
      * @param outpuBuffer
      * @param outputOffset
-     * @param corruption
+     * @param transformation
      * @return
      */
-    public short testKA_direct(KeyPair privatePair, byte[] pubkey, short pubkeyOffset, short pubkeyLength, byte[] outpuBuffer, short outputOffset, short corruption) {
+    public short testKA_direct(KeyPair privatePair, byte[] pubkey, short pubkeyOffset, short pubkeyLength, byte[] outpuBuffer, short outputOffset, short transformation) {
         short length = 0;
         try {
             sw = AppletUtil.kaCheck(ecKeyAgreement);
             sw = AppletUtil.keypairCheck(privatePair);
 
             ecKeyAgreement.init(privatePair.getPrivate());
-            pubkeyLength = EC_Consts.corruptParameter(corruption, pubkey, pubkeyOffset, pubkeyLength);
+            pubkeyLength = EC_Consts.transformParameter(transformation, pubkey, pubkeyOffset, pubkeyLength);
             length = ecKeyAgreement.generateSecret(pubkey, pubkeyOffset, pubkeyLength, outpuBuffer, outputOffset);
         } catch (CardRuntimeException ce) {
             sw = ce.getReason();
diff --git a/src/cz/crcs/ectester/applet/ECTesterApplet.java b/src/cz/crcs/ectester/applet/ECTesterApplet.java
index e34e52c..18c4d1f 100644
--- a/src/cz/crcs/ectester/applet/ECTesterApplet.java
+++ b/src/cz/crcs/ectester/applet/ECTesterApplet.java
@@ -45,7 +45,7 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
     public static final byte INS_ALLOCATE = (byte) 0x5a;
     public static final byte INS_CLEAR = (byte) 0x5b;
     public static final byte INS_SET = (byte) 0x5c;
-    public static final byte INS_CORRUPT = (byte) 0x5d;
+    public static final byte INS_TRANSFORM = (byte) 0x5d;
     public static final byte INS_GENERATE = (byte) 0x5e;
     public static final byte INS_EXPORT = (byte) 0x5f;
     public static final byte INS_ECDH = (byte) 0x70;
@@ -185,8 +185,8 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
                     case INS_SET:
                         length = insSet(apdu);
                         break;
-                    case INS_CORRUPT:
-                        length = insCorrupt(apdu);
+                    case INS_TRANSFORM:
+                        length = insTransform(apdu);
                         break;
                     case INS_GENERATE:
                         length = insGenerate(apdu);
@@ -344,29 +344,29 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
     }
 
     /**
-     * Corrupts curve paramaters of local and remote keyPairs.
-     * returns corruptCurve SWs
+     * Transforms curve paramaters of local and remote keyPairs.
+     * returns transformCurve SWs
      *
      * @param apdu P1 = byte keyPair (KEYPAIR_* | ...)
      *             P2 = byte key (EC_Consts.KEY_* | ...)
      *             DATA = short params (EC_Consts.PARAMETER_* | ...)
-     *             short corruption (EC_Consts.CORRUPTION_* || ...)
+     *             short transformation (EC_Consts.TRANSFORMATION_* || ...)
      * @return length of response
      */
-    private short insCorrupt(APDU apdu) {
+    private short insTransform(APDU apdu) {
         byte keyPair = apduArray[ISO7816.OFFSET_P1];
         byte key = apduArray[ISO7816.OFFSET_P2];
         short cdata = apdu.getOffsetCdata();
         short params = Util.getShort(apduArray, cdata);
-        short corruption = Util.getShort(apduArray, (short) (cdata + 2));
+        short transformation = Util.getShort(apduArray, (short) (cdata + 2));
 
         short len = 0;
         if ((keyPair & KEYPAIR_LOCAL) != 0) {
-            len += corrupt(localKeypair, key, params, corruption, apdu.getBuffer(), (short) 0);
+            len += transform(localKeypair, key, params, transformation, apdu.getBuffer(), (short) 0);
         }
 
         if ((keyPair & KEYPAIR_REMOTE) != 0) {
-            len += corrupt(remoteKeypair, key, params, corruption, apdu.getBuffer(), len);
+            len += transform(remoteKeypair, key, params, transformation, apdu.getBuffer(), len);
         }
 
         return len;
@@ -429,7 +429,7 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
      * @param apdu P1   = byte pubkey (KEYPAIR_*)
      *             P2   = byte privkey (KEYPAIR_*)
      *             DATA = byte export (EXPORT_TRUE || EXPORT_FALSE)
-     *             short corruption (EC_Consts.CORRUPTION_* | ...)
+     *             short transformation (EC_Consts.TRANSFORMATION_* | ...)
      *             byte type (EC_Consts.KA_* | ...)
      * @return length of response
      */
@@ -438,10 +438,10 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
         byte privkey = apduArray[ISO7816.OFFSET_P2];
         short cdata = apdu.getOffsetCdata();
         byte export = apduArray[cdata];
-        short corruption = Util.getShort(apduArray, (short) (cdata + 1));
+        short transformation = Util.getShort(apduArray, (short) (cdata + 1));
         byte type = apduArray[(short) (cdata + 3)];
 
-        return ecdh(pubkey, privkey, export, corruption, type, apdu.getBuffer(), (short) 0);
+        return ecdh(pubkey, privkey, export, transformation, type, apdu.getBuffer(), (short) 0);
     }
 
     /**
@@ -449,7 +449,7 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
      *
      * @param apdu P1   = byte privkey (KEYPAIR_*)
      *             P2   = byte export (EXPORT_TRUE || EXPORT_FALSE)
-     *             DATA = short corruption (EC_Consts.CORRUPTION_* | ...)
+     *             DATA = short transformation (EC_Consts.TRANSFORMATION_* | ...)
      *             byte type (EC_Consts.KA_* | ...)
      *             short length
      *             byte[] pubkey
@@ -459,11 +459,11 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
         byte privkey = apduArray[ISO7816.OFFSET_P1];
         byte export = apduArray[ISO7816.OFFSET_P2];
         short cdata = apdu.getOffsetCdata();
-        short corruption = Util.getShort(apduArray, cdata);
+        short transformation = Util.getShort(apduArray, cdata);
         byte type = apduArray[(short) (cdata + 2)];
         short length = Util.getShort(apduArray, (short) (cdata + 3));
 
-        return ecdh_direct(privkey, export, corruption, type, (short) (cdata + 5), length, apdu.getBuffer(), (short) 0);
+        return ecdh_direct(privkey, export, transformation, type, (short) (cdata + 5), length, apdu.getBuffer(), (short) 0);
     }
 
     /**
@@ -576,16 +576,16 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
     }
 
     /**
-     * @param keyPair    KeyPair to corrupt
-     * @param key        key to corrupt (EC_Consts.KEY_* | ...)
-     * @param params     parameters to corrupt (EC_Consts.PARAMETER_* | ...)
-     * @param corruption corruption type (EC_Consts.CORRUPTION_*)
+     * @param keyPair    KeyPair to transform
+     * @param key        key to transform (EC_Consts.KEY_* | ...)
+     * @param params     parameters to transform (EC_Consts.PARAMETER_* | ...)
+     * @param transformation transformation type (EC_Consts.TRANSFORMATION_*)
      * @param outBuffer  buffer to output sw to
      * @param outOffset  output offset in buffer
      * @return length of data written to the buffer
      */
-    private short corrupt(KeyPair keyPair, byte key, short params, short corruption, byte[] outBuffer, short outOffset) {
-        short sw = keyGenerator.corruptCurve(keyPair, key, params, corruption, ramArray, (short) 0);
+    private short transform(KeyPair keyPair, byte key, short params, short transformation, byte[] outBuffer, short outOffset) {
+        short sw = keyGenerator.transformCurve(keyPair, key, params, transformation, ramArray, (short) 0);
         Util.setShort(outBuffer, outOffset, sw);
         return 2;
     }
@@ -635,13 +635,13 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
      * @param pubkey     keyPair to use for public key, (KEYPAIR_LOCAL || KEYPAIR_REMOTE)
      * @param privkey    keyPair to use for private key, (KEYPAIR_LOCAL || KEYPAIR_REMOTE)
      * @param export     whether to export ECDH secret
-     * @param corruption whether to invalidate the pubkey before ECDH
+     * @param transformation whether to transform the pubkey before ECDH
      * @param type       KeyAgreement type to test
      * @param outBuffer  buffer to write sw to, and export ECDH secret {@code if(export == EXPORT_TRUE)}
      * @param outOffset  output offset in buffer
      * @return length of data written to the buffer
      */
-    private short ecdh(byte pubkey, byte privkey, byte export, short corruption, byte type, byte[] outBuffer, short outOffset) {
+    private short ecdh(byte pubkey, byte privkey, byte export, short transformation, byte type, byte[] outBuffer, short outOffset) {
         short length = 0;
 
         KeyPair pub = ((pubkey & KEYPAIR_LOCAL) != 0) ? localKeypair : remoteKeypair;
@@ -649,11 +649,11 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
 
         short secretLength = 0;
         if (keyTester.getKaType() == type) {
-            secretLength = keyTester.testKA(priv, pub, ramArray, (short) 0, ramArray2, (short) 0, corruption);
+            secretLength = keyTester.testKA(priv, pub, ramArray, (short) 0, ramArray2, (short) 0, transformation);
         } else {
             short allocateSW = keyTester.allocateKA(type);
             if (allocateSW == ISO7816.SW_NO_ERROR) {
-                secretLength = keyTester.testKA(priv, pub, ramArray, (short) 0, ramArray2, (short) 0, corruption);
+                secretLength = keyTester.testKA(priv, pub, ramArray, (short) 0, ramArray2, (short) 0, transformation);
             }
         }
         Util.setShort(outBuffer, outOffset, keyTester.getSW());
@@ -669,18 +669,18 @@ public class ECTesterApplet extends Applet implements ExtendedLength {
         return length;
     }
 
-    private short ecdh_direct(byte privkey, byte export, short corruption, byte type, short keyOffset, short keyLength, byte[] outBuffer, short outOffset) {
+    private short ecdh_direct(byte privkey, byte export, short transformation, byte type, short keyOffset, short keyLength, byte[] outBuffer, short outOffset) {
         short length = 0;
 
         KeyPair priv = ((privkey & KEYPAIR_LOCAL) != 0) ? localKeypair : remoteKeypair;
 
         short secretLength = 0;
         if (keyTester.getKaType() == type) {
-            secretLength = keyTester.testKA_direct(priv, apduArray, keyOffset, keyLength, ramArray2, (short) 0, corruption);
+            secretLength = keyTester.testKA_direct(priv, apduArray, keyOffset, keyLength, ramArray2, (short) 0, transformation);
         } else {
             short allocateSW = keyTester.allocateKA(type);
             if (allocateSW == ISO7816.SW_NO_ERROR) {
-                secretLength = keyTester.testKA_direct(priv, apduArray, keyOffset, keyLength, ramArray2, (short) 0, corruption);
+                secretLength = keyTester.testKA_direct(priv, apduArray, keyOffset, keyLength, ramArray2, (short) 0, transformation);
             }
         }
 
diff --git a/src/cz/crcs/ectester/applet/EC_Consts.java b/src/cz/crcs/ectester/applet/EC_Consts.java
index 008269a..5b3c74c 100644
--- a/src/cz/crcs/ectester/applet/EC_Consts.java
+++ b/src/cz/crcs/ectester/applet/EC_Consts.java
@@ -981,17 +981,17 @@ public class EC_Consts {
     public static final short EC571_F2M_K = 2;
 
 
-    // getCorruptCurveParameter PARAMETER_CORRUPTION TYPES
-    public static final short CORRUPTION_NONE = (short) 0x00;
-    public static final short CORRUPTION_FIXED = (short) 0x01;
-    public static final short CORRUPTION_FULLRANDOM = (short) 0x02;
-    public static final short CORRUPTION_ONEBYTERANDOM = (short) 0x04;
-    public static final short CORRUPTION_ZERO = (short) 0x08;
-    public static final short CORRUPTION_ONE = (short) 0x10;
-    public static final short CORRUPTION_MAX = (short) 0x20;
-    public static final short CORRUPTION_INCREMENT = (short) 0x40;
-    public static final short CORRUPTION_INFINITY = (short) 0x80;
-    public static final short CORRUPTION_COMPRESS = (short) 0x0100;
+    // transformParameter TRANSFORMATION types
+    public static final short TRANSFORMATION_NONE = (short) 0x00;
+    public static final short TRANSFORMATION_FIXED = (short) 0x01;
+    public static final short TRANSFORMATION_FULLRANDOM = (short) 0x02;
+    public static final short TRANSFORMATION_ONEBYTERANDOM = (short) 0x04;
+    public static final short TRANSFORMATION_ZERO = (short) 0x08;
+    public static final short TRANSFORMATION_ONE = (short) 0x10;
+    public static final short TRANSFORMATION_MAX = (short) 0x20;
+    public static final short TRANSFORMATION_INCREMENT = (short) 0x40;
+    public static final short TRANSFORMATION_INFINITY = (short) 0x80;
+    public static final short TRANSFORMATION_COMPRESS = (short) 0x0100;
 
     // toX962 FORM types
     public static final byte X962_UNCOMPRESSED = (byte) 0x00;
@@ -1307,27 +1307,27 @@ public class EC_Consts {
         return length;
     }
 
-    public static short corruptParameter(short corruption, byte[] buffer, short offset, short length) {
-        if (corruption == CORRUPTION_NONE) {
+    public static short transformParameter(short transformation, byte[] buffer, short offset, short length) {
+        if (transformation == TRANSFORMATION_NONE) {
             return length;
         }
 
-        short corruptionMask = CORRUPTION_FIXED;
-        while (corruptionMask <= CORRUPTION_COMPRESS) {
-            short corruptionPart = (short) (corruptionMask & corruption);
-            switch (corruptionPart) {
+        short transformationMask = TRANSFORMATION_FIXED;
+        while (transformationMask <= TRANSFORMATION_COMPRESS) {
+            short transformationPart = (short) (transformationMask & transformation);
+            switch (transformationPart) {
                 case (short) 0:
                     break;
-                case CORRUPTION_FIXED:
+                case TRANSFORMATION_FIXED:
                     if (length >= 1) {
                         buffer[offset] = (byte) 0xcc;
                         buffer[(short) (offset + length - 1)] = (byte) 0xcc;
                     }
                     break;
-                case CORRUPTION_FULLRANDOM:
+                case TRANSFORMATION_FULLRANDOM:
                     randomData.generateData(buffer, offset, length);
                     break;
-                case CORRUPTION_ONEBYTERANDOM:
+                case TRANSFORMATION_ONEBYTERANDOM:
                     short first = Util.getShort(buffer, (short) 0); // save first two bytes
 
                     randomData.generateData(buffer, (short) 0, (short) 2); // generate position
@@ -1345,17 +1345,17 @@ public class EC_Consts {
                         randomData.generateData(buffer, rngPos, (short) 1);
                     } while (original == buffer[rngPos]);
                     break;
-                case CORRUPTION_ZERO:
+                case TRANSFORMATION_ZERO:
                     Util.arrayFillNonAtomic(buffer, offset, length, (byte) 0);
                     break;
-                case CORRUPTION_ONE:
+                case TRANSFORMATION_ONE:
                     Util.arrayFillNonAtomic(buffer, offset, length, (byte) 0);
                     buffer[(short) (offset + length)] = (byte) 1;
                     break;
-                case CORRUPTION_MAX:
+                case TRANSFORMATION_MAX:
                     Util.arrayFillNonAtomic(buffer, offset, length, (byte) 1);
                     break;
-                case CORRUPTION_INCREMENT:
+                case TRANSFORMATION_INCREMENT:
                     short index = (short) (offset + length - 1);
                     byte value;
                     do {
@@ -1363,11 +1363,11 @@ public class EC_Consts {
                         buffer[index--] = ++value;
                     } while (value == (byte) 0 && index >= offset);
                     break;
-                case CORRUPTION_INFINITY:
+                case TRANSFORMATION_INFINITY:
                     Util.arrayFillNonAtomic(buffer, offset, length, (byte) 0);
                     length = 1;
                     break;
-                case CORRUPTION_COMPRESS:
+                case TRANSFORMATION_COMPRESS:
                     if ((short) (length % 2) != 1) {
                         // an uncompressed point should have odd length (since 1 byte type, + 2 * coords)
                         ISOException.throwIt(ISO7816.SW_FUNC_NOT_SUPPORTED);
@@ -1387,7 +1387,7 @@ public class EC_Consts {
                 default:
                     ISOException.throwIt(ISO7816.SW_FUNC_NOT_SUPPORTED);
             }
-            corruptionMask = (short) (corruptionMask << 1);
+            transformationMask = (short) (transformationMask << 1);
         }
         return length;
     }