Javacard applet to subtract two hexadecimal array of byte - javacard

Question

I'm try to write a javacard applet that need to add/sub two array of bytes.
the addition was success but the subtraction fail in some cases ("when there is a borrow from the procceding byte").
Can you check my code and improve it to work better?
package phase1;
import javacard.framework.APDU;
import javacard.framework.Applet;
import javacard.framework.ISO7816;
import javacard.framework.ISOException;
import javacard.framework.Util;
import javacard.security.CryptoException;
public class keygen extends Applet {
public static final short _0 = 0;
public final static byte[] one = {(byte) 0xff, (byte) 0xff, (byte) 0xff,(byte) 0xff,(byte) 0xff,(byte) 0xff};
byte [] G = {(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x11};
private keygen() {
}
public static void install(byte bArray[], short bOffset, byte bLength)throws ISOException {
try{
new keygen().register();
} catch (Exception e) {
ISOException.throwIt((short) 0x8888);
}
}
public void process(APDU apdu) throws ISOException {
// TODO Auto-generated method stub
if (selectingApplet()) return;
//short sendlen = 0;
byte[] buf = apdu.getBuffer();
byte ins = buf[ISO7816.OFFSET_INS];
byte [] val = new byte [(short) G.length];
short i;
short len = (short) G.length ;
short Alen = (short) (len - 1);
short b = (short) 0 ;
byte[] Z = new byte [(short) len];
byte[] y = new byte [(short) 2];
try{
switch (ins){
case (byte) 0x01: //0x0F
{
Z = addarray (G , one);
apdu.setOutgoing();
buf = Z;
apdu.setOutgoingLength(len);
apdu.sendBytesLong(Z, (short) 0,len);
break;
}
case (byte) 0x02: //0x0F
{ //Z = new byte [(short) 7];
Z = subarray1 (G , one);
apdu.setOutgoing();
buf= Z;
apdu.setOutgoingLength(len);
apdu.sendBytesLong(Z, (short) 0,len);
break;
}
default:
ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
}
}catch (CryptoException e) {
ISOException.throwIt(((CryptoException) e).getReason());
}
}
private byte [] addarray (byte [] Arr1, byte [] Arr2 )
{
short i;
short [] X = new short [(short) 6];
short len = (short) Arr1.length ;
short Alen = (short) (len - 1);
byte [] AddArr = new byte [len];
short R = (short) 0;
byte[] Z = new byte [(short) 2];
for (i = Alen; i >= 0 ; i--)
{
X[i] = (short) ((Arr1[i] & 0xFF) + (Arr2[i]&0xff) + R);
Util.setShort(Z, (short) 0, (short) X[i]);
AddArr[i] = (byte) Z[1];
R = (short) (Z[0]);
}
return AddArr;
}
private byte [] subarray1 (byte [] Arr1, byte [] Arr2)
{
short i;
byte [] X = new byte [(short) 6];
short len = (short) Arr1.length ;
short Alen = (short) (len - 1);
byte [] SubArr = new byte [len];
short R = (short) 0;
byte[] Z = new byte [(short) 2];
for (i = Alen; i > 0 ; i--)
{
X[i] = (byte) (Arr1[i] - Arr2[i] - (byte) R );
Util.setShort(Z, (short) 0, (short) X[i]);
SubArr[i] = (byte) Z[1];
R = (short) (Z[0] );
}
return SubArr;
}
}

Answer 1

There is an optional class in Java Card API named bigIntNumber. If your card doesn't implemented it, I share its source code with you:
/**
* Class BigIntNumber provides addition, subtraction and comparison functions
* for unsigned integers represented in byte array format in bug endian order.
*
*/
public class BigIntNumber {
/**
* Add two unsigned integers represented in array A and B. The sum stored in
* array C
*
* #param A the left operand
* #param AOff the starting position in array A.
* #param B the right operand.
* #param BOff the starting position in array B.
* #param C the result of (A+B)
* #param COff the starting position in array C.
* #param len the number of bytes in the operands as well in the computed
* result. this parameter can not be a negative number.
* #return false if the result overflows. if overflows occurs, the sum would
* be the true mathematical result with the most significant bytes discarded
* to fit into array C of the specified length.
* #throws ArrayOuutOfBoundException if array access out of bound.
*/
public static boolean add(byte[] A, byte AOff, byte[] B, byte BOff, byte[] C, byte COff, byte len) {
short result = 0;
for (len = (byte) (len - 1); len >= 0; len--) {
// add two unsigned bytes and the carry from the
// previous byte computation.
result = (short) (getUnsignedByte(A, AOff, len) + getUnsignedByte(B, BOff, len) + result);
// store the result in byte array C
C[(byte) (len + COff)] = (byte) result;
// has a carry?
if (result > 0x00FF) {
result = 1;
result = (short) (result + 0x100);
} else {
result = 0;
}
}
//produce overflow in the sum.
if (result == 1) {
return false;
}
return true;
}
/**
* Subtract two unsigned integers represented in array A and B. The sum stored in
* array C
*
* #param A the left operand
* #param AOff the starting position in array A.
* #param B the right operand.
* #param BOff the starting position in array B.
* #param C the result of (A-B)
* #param COff the starting position in array C.
* #param len the number of bytes in the operands as well in the computed
* result. this parameter can not be a negative number.
* #return false if the result underflows. if underflows occurs, the sum would
* be the mathematical result of A + ~B + 1.
* #throws ArrayOuutOfBoundException if array access out of bound.
*/
public static boolean subtract(byte[] A, byte AOff, byte[] B, byte BOff, byte[] C, byte COff, byte len) {
byte borrow = 0;
short result;
for (len = (byte) (len - 1); len >= 0; len--) {
// subtract one unsigned byte from the other.
// also subtract the borrow from the previous byte computation.
result = (short) (getUnsignedByte(A, AOff, len) - getUnsignedByte(B, BOff, len) - borrow);
// need to borrow?
if (result < 0) {
borrow = 1;
result = (short) (result + 0x100);
} else {
borrow = 0;
}
// store the result in C
C[(byte) (len + COff)] = (byte) result;
}
// is the result underflow?
if (borrow == 1) {
return false;
}
return true;
}
/**
* Compare two unsigned integers represented in array A and B. The sum stored in
* array C
*
* #param A the left operand
* #param AOff the starting position in array A.
* #param B the right operand.
* #param BOff the starting position in array B.
* #param C the result of (A-B)
* #param COff the starting position in array C.
* #param len the number of bytes in the operands as well in the computed
* result. this parameter can not be a negative number.
* #return the result of comparison as below:
* 0 if identical
* 1 if the left operand is bigger than the right operand
* -1 if the left operand is smaller than the right operand
* #throws ArrayOuutOfBoundException if array access out of bound.
*/
public static byte compare(byte[] A, byte AOff, byte[] B, byte BOff, byte len) {
byte count = (byte) 0;
for (; count < len; count++) {
short C = getUnsignedByte(A, AOff, count);
short D = getUnsignedByte(A, AOff, count);
if (C < D) {
return -1;
}
if (C > D) {
return 1;
}
}
return 0;
}
/**
*
* Get the unsigned byte at the index (AOff + count)
*/
private static short getUnsignedByte(byte[] A, byte AOff, byte count) {
return (short) (A[(short) (count + AOff)] & 0x00FF);
}
}
And this is a sample applet that I wroto to show you how does the above class methods work:
package phase1;
import javacard.framework.APDU;
import javacard.framework.Applet;
import javacard.framework.ISO7816;
import javacard.framework.ISOException;
import javacard.framework.Util;
import static phase1.BigIntNumber.*;
public class TestBigInt extends Applet {
// Defining global arrays for Operands A and B.
// LenA and LenB are defined to check if equal length of A and B are going
// to add, compare or subtract or not. Len of operands musb be equal between 1 byte to 8 bytes.
public static byte[] OpA = new byte[8];
public static byte[] OpB = new byte[8];
public static byte[] result = new byte[8];
public static byte lenA;
public static byte lenB;
// Defining supported INS valuse for APDU Command.
public static final byte INS_INIT_OPERAND = (byte) 0x10;
public static final byte INS_ADD = (byte) 0x20;
public static final byte INS_SUBTRACT = (byte) 0x30;
public static final byte INS_COMPARE = (byte) 0x40;
// P1 parameter in the APDU command
public static final byte OPERAND_A = 0x01;
public static final byte OPERAND_B = 0x02;
// Defining Exception Status Words
public static short SW_NOT_EQUAL_LENGTH = (short) 0x6910;
public static short SW_OVERFLOW_OCCURS = (short) 0x6911;
public static short SW_UNDERFLOW_OCCURS = (short) 0x6912;
private TestBigInt() {
}
public static void install(byte bArray[], short bOffset, byte bLength) throws ISOException {
new TestBigInt().register();
}
public void process(APDU apdu) throws ISOException {
if (selectingApplet()) {
return;
}
byte[] buf = apdu.getBuffer();
switch (buf[ISO7816.OFFSET_INS]) {
case INS_INIT_OPERAND:
apdu.setIncomingAndReceive();
if (buf[ISO7816.OFFSET_LC] > (byte) 0x08) {
ISOException.throwIt(ISO7816.SW_WRONG_LENGTH);
}
if (buf[ISO7816.OFFSET_P1] == OPERAND_A) {
Util.arrayCopyNonAtomic(buf, ISO7816.OFFSET_CDATA, OpA, (short) 0x00, buf[ISO7816.OFFSET_LC]);
lenA = buf[ISO7816.OFFSET_LC];
} else if (buf[ISO7816.OFFSET_P1] == OPERAND_B) {
Util.arrayCopyNonAtomic(buf, ISO7816.OFFSET_CDATA, OpB, (short) 0x00, buf[ISO7816.OFFSET_LC]);
lenB = buf[ISO7816.OFFSET_LC];
} else {
ISOException.throwIt(ISO7816.SW_WRONG_P1P2);
}
break;
case INS_ADD:
if (lenA != lenB) {
ISOException.throwIt(SW_NOT_EQUAL_LENGTH);
}
if (add(OpA, (byte) 0x00, OpB, (byte) 0x00, result, (byte) 0x00, lenA)) {
apdu.sendBytesLong(result, (short) 0x00, (short) lenA);
} else {
ISOException.throwIt(SW_OVERFLOW_OCCURS);
}
break;
case INS_SUBTRACT:
if (lenA != lenB) {
ISOException.throwIt(SW_NOT_EQUAL_LENGTH);
}
if (subtract(OpA, (byte) 0x00, OpB, (byte) 0x00, result, (byte) 0x00, lenA)) {
apdu.sendBytesLong(result, (short) 0x00, (short) lenA);
} else {
ISOException.throwIt(SW_UNDERFLOW_OCCURS);
}
break;
case INS_COMPARE:
// ...
break;
default:
ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
}
}
}
It seems works fine:
Connect successful.
Download Cap begin...
Download Cap successful.
Install Applet begin...
Install Applet successful.
Select Applet begin...
Select Applet successful.
Send: 00 10 01 00 07 11 22 33 44 55 66 77 00 //Initilizing Operand A
Recv: 90 00
Time used: 21.000 ms
Send: 00 10 02 00 07 11 22 33 44 55 66 77 00 //Initlizing Operand B
Recv: 90 00
Time used: 19.000 ms
Send: 00 20 00 00 00 // Compute A+B
Recv: 22 44 66 88 AA CC EE 90 00
Time used: 67.000 ms
Send: 00 30 00 00 00 // Compute A-B
Recv: 00 00 00 00 00 00 00 90 00
Time used: 73.000 ms
Send: 00 10 02 00 07 00 00 44 44 44 44 44 00 // Changing Operand B
Recv: 90 00
Time used: 14.000 ms
Send: 00 20 00 00 00 // Compute A+B again
Recv: 11 22 77 88 99 AA BB 90 00
Time used: 66.000 ms
Send: 00 30 00 00 00 // Compute A-B
Recv: 11 21 EF 00 11 22 33 90 00
Time used: 71.000 ms
Sorry, I didn't checked your code. Just two simple hint:
1- Try to don't use dynamic fields in methods. Java Card doesn't support automatic garbage collection, so the memory that you assign to a field dynamically (i.e. using new keyword), will not reclaimed automatically until calling requestObjectDeletion() method (and it's optional too!) :)
2- 0x8888 is not a standard status world in the ISO7816-4 standard and some smart cards has problem with non-standard status words. Try to choose 6XXX (60XX is also non-standard value) or 9XXX for status words.