aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/applets/ECKeyGenerator.java102
-rw-r--r--src/applets/ECKeyTester.java16
-rw-r--r--src/applets/EC_Consts.java31
-rw-r--r--src/applets/SimpleECCApplet.java29
-rw-r--r--src/simpleapdu/SimpleAPDU.java2
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);
generated by cgit v1.2.3-70-g09d2 (git 2.51.2) at 2025-11-08 15:58:46 +0000