/** Process the WRITE BINARY Instruction (0xD0). ISO7816-4 Section 7.2.4 */
private void processWriteBinary(APDU apdu) throws ISOException {
if (state != STATE_INITIAL) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
short offset = 0;
short ef = -1;
if ((byte) (p1 & MASK_SFI) == MASK_SFI) {
byte sfi = (byte) (p1 | ~MASK_SFI);
if (sfi >= 0x1F) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
ef = fileSystem.findCurrentSFI(sfi);
if (ef == -1) {
ISOException.throwIt(SW_FILE_NOT_FOUND);
}
ef = fileSystem.fileStructure[ef];
offset = unsigned(p2);
} else {
ef = fileSystem.getCurrentIndex();
if (fileSystem.getFile(ef) == null) {
ISOException.throwIt(SW_COMMAND_NOT_ALLOWED);
}
offset = Util.makeShort(p1, p2);
}
byte[] file = fileSystem.getFile(ef);
short lc = unsigned(buf[OFFSET_LC]);
if ((short) (offset + lc) > file.length) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
Util.arrayCopyNonAtomic(buf, OFFSET_CDATA, file, offset, lc);
}
/**
* Generate an assymetric RSA key pair according to ISO7816-8, Section 5.1. We only support RSA
* 1024 bit at the moment, and return data in simple TLV data objects, tags 81 and 82.
*
* <p>Successful MSE command has to be performed prior to this one.
*/
private void processGenerateAssymetricKeyPair(APDU apdu) {
// This is only valid in state initial (at the moment)
if (state != STATE_INITIAL) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
if (p1 != (byte) 0x80 || p2 != (byte) 0x00) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
if (currentPrivateKey[0] == null) {
ISOException.throwIt(SW_CONDITIONS_NOT_SATISFIED);
}
KeyPair pair = new KeyPair(tempKeyPublic, (RSAPrivateCrtKey) currentPrivateKey[0]);
pair.genKeyPair();
// Sanity check, the KeyPair class should regenerate the keys "in place".
if (pair.getPrivate() != currentPrivateKey[0] || pair.getPublic() != tempKeyPublic) {
ISOException.throwIt(SW_DATA_INVALID);
}
apdu.setOutgoing();
short len = (short) 0;
short offset = 0;
buf[offset++] = (byte) 0x81;
len = tempKeyPublic.getModulus(buf, (short) (offset + 2));
buf[offset++] = (byte) 0x81;
buf[offset++] = (byte) len;
offset += len;
buf[offset++] = (byte) 0x82;
len = tempKeyPublic.getExponent(buf, (short) (offset + 1));
buf[offset++] = (byte) len;
offset += len;
apdu.setOutgoingLength(offset);
apdu.sendBytes((short) 0, offset);
}
public void process(APDU apdu) {
byte[] buffer = apdu.getBuffer();
if (apdu.isISOInterindustryCLA()) {
if (buffer[ISO7816.OFFSET_INS] == (byte) (0xA4)) {
return;
} else {
ISOException.throwIt(ISO7816.SW_CLA_NOT_SUPPORTED);
}
}
switch (buffer[ISO7816.OFFSET_INS]) {
case VALIDATEKEY:
validateKey(apdu);
return;
case TIMETICK:
timeTick(apdu);
return;
case SETCONNECTION:
setConnection();
return;
case RESETCONNECTION:
resetConnection();
return;
default:
ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
}
}
/** Process the INTERNAL AUTHENTICATE instruction (0x88) ISO 7816-4 Section 7.5.2 */
private void processInternalAuthenticate(APDU apdu) {
if (state != STATE_PERSONALISED) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
if (!pin.isValidated()) {
ISOException.throwIt(SW_SECURITY_STATUS_NOT_SATISFIED);
}
byte[] buf = apdu.getBuffer();
short lc = unsigned(buf[OFFSET_LC]);
if (lc == 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
RSAPrivateCrtKey privateKey = (RSAPrivateCrtKey) currentPrivateKey[0];
byte alg = tmp[TMP_SIGNALG_OFFSET];
if (privateKey != authKeyPrivate || alg != ALG_AUTH_DEC_RSA) {
ISOException.throwIt(SW_WRONG_DATA);
}
short offset = OFFSET_CDATA;
short maxLength = (short) ((short) (privateKey.getSize() / 8) - 11);
if (lc > maxLength) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
pkcs1Cipher.init(privateKey, Cipher.MODE_ENCRYPT);
short len = pkcs1Cipher.doFinal(buf, offset, lc, tmp, TMP_OFFSET);
Util.arrayCopyNonAtomic(tmp, TMP_OFFSET, buf, (short) 0, len);
apdu.setOutgoingAndSend((short) 0, len);
}
private void processSetHistoricalBytes(APDU apdu) {
if (state != STATE_INITIAL) {
ISOException.throwIt(SW_CONDITIONS_NOT_SATISFIED);
}
byte[] buf = apdu.getBuffer();
byte lc = buf[OFFSET_LC];
if (lc <= 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
// Was GPSystem
OPSystem.setATRHistBytes(buf, OFFSET_CDATA, lc);
}
/**
* Process the READ BINARY instruction (0xB0) ISO7816-4 Section 7.2.3
*
* <p>We handle only the INS == 0xB0 case.
*/
private void processReadBinary(APDU apdu) {
if (state != STATE_PERSONALISED) {
ISOException.throwIt(SW_CONDITIONS_NOT_SATISFIED);
}
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
short offset = 0;
short ef = -1;
if ((byte) (p1 & MASK_SFI) == MASK_SFI) {
byte sfi = (byte) (p1 & ~MASK_SFI);
if (sfi >= 0x1F) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
ef = fileSystem.findCurrentSFI(sfi);
if (ef == -1) {
ISOException.throwIt(SW_FILE_NOT_FOUND);
}
ef = fileSystem.fileStructure[ef];
offset = unsigned(p2);
} else {
ef = fileSystem.getCurrentIndex();
if (fileSystem.getFile(ef) == null) {
ISOException.throwIt(SW_COMMAND_NOT_ALLOWED);
}
offset = Util.makeShort(p1, p2);
}
byte[] file = fileSystem.getFile(ef);
if (offset > file.length) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
if (fileSystem.getPerm(ef) == FileSystem.PERM_PIN && !pin.isValidated()) {
ISOException.throwIt(SW_SECURITY_STATUS_NOT_SATISFIED);
}
short le = apdu.setOutgoing();
if (le == 0 || le == 256) {
le = (short) (file.length - offset);
if (le > 256) le = 256;
}
boolean eof = false;
if ((short) (file.length - offset) < le) {
le = (short) (file.length - offset);
eof = true;
}
apdu.setOutgoingLength(le);
apdu.sendBytesLong(file, offset, le);
if (eof) {
ISOException.throwIt(SW_END_OF_FILE);
}
}
/**
* Process the CHANGE REFERENCE DATA instruction (0x24) ISO7816-4 Section 7.5.7
*
* <p>We have two options here: (a) in a procudction state we can set the PUC with this, (b) in
* the distribution state and operational state we change the PIN
*/
private void processChangeReferenceData(APDU apdu) {
byte[] buf = apdu.getBuffer();
short lc = unsigned(buf[OFFSET_LC]);
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
if (state > STATE_INITIAL) {
// We are changing the PIN, PUC has to be provided
// check that P1 is 0x00: verification data (puc) followed by new reference data (pin)
if (p1 != 0x00 || p2 != (byte) 0x00) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
short pinSize = (short) (lc - PUC_SIZE);
if (pinSize < MIN_PIN_SIZE || pinSize > MAX_PIN_SIZE) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
short offset = (short) (OFFSET_CDATA + PUC_SIZE);
for (short i = 0; i < pinSize; i++) {
byte b = buf[(short) (offset + i)];
if (b < (byte) 0x30 || b > (byte) 0x39) {
ISOException.throwIt(SW_WRONG_DATA);
}
}
// Pad the pin with 0x00 to overwrite any garbage, e.g. le
Util.arrayFillNonAtomic(
buf, (short) (offset + pinSize), (short) (MAX_PIN_SIZE - pinSize), (byte) 0x00);
if (!puc.check(buf, OFFSET_CDATA, PUC_SIZE)) {
ISOException.throwIt((short) (SW_PIN_INCORRECT_TRIES_LEFT | puc.getTriesRemaining()));
}
pin.update(buf, offset, MAX_PIN_SIZE);
pin.resetAndUnblock();
if (state == STATE_PREPERSONALISED) {
state = STATE_PERSONALISED;
}
} else {
// State is production, we set the puc
if (p1 != 0x01 || p2 != 0x00) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
if (lc != PUC_SIZE) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
puc.update(buf, OFFSET_CDATA, (byte) lc);
puc.resetAndUnblock();
}
}
/** Process the PSO COMPUTE DIGITAL SIGNATURE instruction (0x2A) ISO 7816-8 Section 5.4 */
private void processComputeDigitalSignature(APDU apdu) {
pin.reset();
byte[] buf = apdu.getBuffer();
short lc = unsigned(buf[OFFSET_LC]);
if (lc == 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
RSAPrivateCrtKey privateKey = (RSAPrivateCrtKey) currentPrivateKey[0];
byte alg = tmp[TMP_SIGNALG_OFFSET];
if (privateKey != signKeyPrivate
|| (alg != ALG_SIGN_RSA_PKCS1_SHA1
&& alg != ALG_SIGN_RSA_PKCS1_SHA256
&& alg != ALG_SIGN_RSA_PSS
&& alg != ALG_SIGN_RSA_PKCS1_SHA1MD5)) {
ISOException.throwIt(SW_WRONG_DATA);
}
short offset = OFFSET_CDATA;
short expectedLength = 0;
if (alg == ALG_SIGN_RSA_PKCS1_SHA256) {
expectedLength = (short) (SHA256_LEN + 17);
} else if (alg == ALG_SIGN_RSA_PKCS1_SHA1) {
expectedLength = (short) (SHA1_LEN + 13);
} else if (alg == ALG_SIGN_RSA_PSS) {
expectedLength = SHA1_LEN;
} else if (alg == ALG_SIGN_RSA_PKCS1_SHA1MD5) {
expectedLength = SHA1MD5_LEN;
}
if (lc != expectedLength) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
short sigLen = 0;
if (alg == ALG_SIGN_RSA_PKCS1_SHA1
|| alg == ALG_SIGN_RSA_PKCS1_SHA256
|| alg == ALG_SIGN_RSA_PKCS1_SHA1MD5) {
pkcs1Cipher.init(privateKey, Cipher.MODE_ENCRYPT);
sigLen = pkcs1Cipher.doFinal(buf, offset, lc, tmp, TMP_OFFSET);
Util.arrayCopyNonAtomic(tmp, TMP_OFFSET, buf, (short) 0, sigLen);
} else {
short emLen = (short) (privateKey.getSize() / 8);
pssPad(buf, offset, lc, tmp, TMP_OFFSET, emLen, signKeyFirstModulusByte);
nopadCipher.init(privateKey, Cipher.MODE_ENCRYPT);
sigLen = nopadCipher.doFinal(tmp, (short) 0, emLen, buf, (short) 0);
}
apdu.setOutgoingAndSend((short) 0, sigLen);
}
/** Process the GET CHALLENGE instruction (0x84) ISO 7816-4, Section 7.5.3 */
private void processGetChallenge(APDU apdu) {
if (state != STATE_PERSONALISED) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
byte[] buf = apdu.getBuffer();
if (buf[OFFSET_P1] != 0x00 || buf[OFFSET_P2] != 0x00) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
short le = apdu.setOutgoing();
if (le == 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setOutgoingLength(le);
rd.generateData(buf, (short) 0, le);
apdu.sendBytes((short) 0, le);
}
private void processSetState(APDU apdu) throws ISOException {
if (state == STATE_PERSONALISED) {
ISOException.throwIt(SW_CONDITIONS_NOT_SATISFIED);
}
byte p2 = apdu.getBuffer()[OFFSET_P2];
if (p2 != STATE_INITIAL && p2 != STATE_PREPERSONALISED) {
ISOException.throwIt(SW_WRONG_DATA);
}
state = p2;
}
// Connection management methods
private void timeTick(APDU apdu) {
// Updates the area code according to the passed parameter.
byte[] buffer = apdu.getBuffer();
byte numBytes = (byte) (buffer[ISO7816.OFFSET_LC]);
byte byteRead = (byte) (apdu.setIncomingAndReceive());
if ((numBytes != 2) || (byteRead != 2)) ISOException.throwIt(ISO7816.SW_WRONG_LENGTH);
// get area code
short newAreaCode =
(short)
((short) (buffer[ISO7816.OFFSET_CDATA] << (short) 8)
| (short) (buffer[ISO7816.OFFSET_CDATA + 1] & 0x00FF));
if (newAreaCode != INACTIVE_AREA) {
activeAreaCode[0] = newAreaCode;
} else {
resetConnection();
ISOException.throwIt(SW_NO_NETWORK);
}
short connectionType = apdu.getProtocol();
byte b = apdu.getCLAChannel();
boolean contactless = false;
if ((connectionType & 0xf0) == 0x80 // APDU.PROTOCOL_MEDIA_CONTACTLESS_TYPE_A
|| (connectionType & 0xf0) == 0x90) { // APDU.PROTOCOL_MEDIA_CONTACTLESS_TYPE_B ){
contactless = true;
}
// If a connection is active, the user account is debited.
// If user runs out of credits, the connection is terminated.
if (connectionStatus[0] == CONNECTION_INUSE) {
if (AccountAccessor.getAccount() == null) {
ISOException.throwIt(SW_NO_ACCOUNT);
}
if (AccountAccessor.getAccount().debit(activeAreaCode[0], contactless) == false) {
resetConnection();
ISOException.throwIt(SW_NEGATIVE_BALANCE);
}
}
}
public void process(APDU apdu) {
byte[] buf = apdu.getBuffer();
byte cla = buf[OFFSET_CLA];
byte ins = buf[OFFSET_INS];
// No secure messaging for the PKI applet
if ((byte) (cla & CLA_SM) == CLA_SM) {
ISOException.throwIt(SW_SECURE_MESSAGING_NOT_SUPPORTED);
}
// Only PSO can be chained
if (!(cla == CLA_ISO7816 || (cla == CLA_CHAIN && ins == INS_PSO))) {
ISOException.throwIt(SW_CLA_NOT_SUPPORTED);
}
switch (ins) {
case INS_SELECT:
processSelectFile(apdu);
break;
case INS_READBINARY:
processReadBinary(apdu);
break;
case INS_WRITEBINARY:
processWriteBinary(apdu);
break;
case INS_VERIFY:
processVerify(apdu);
break;
case INS_CHANGEREFERENCEDATA:
processChangeReferenceData(apdu);
break;
case INS_PUTDATA:
processPutData(apdu);
break;
case INS_GENERATE_KEY_PAIR:
processGenerateAssymetricKeyPair(apdu);
break;
case INS_CREATEFILE:
processCreateFile(apdu);
break;
case INS_GETCHALLENGE:
processGetChallenge(apdu);
break;
case INS_MSE:
processManageSecurityEnvironment(apdu);
break;
case INS_PSO:
processPerformSecurityOperation(apdu);
break;
case INS_INTERNALAUTHENTICATE:
processInternalAuthenticate(apdu);
break;
default:
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
}
private void processCreateFile(APDU apdu) {
if (state != STATE_INITIAL) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
byte[] buf = apdu.getBuffer();
short lc = unsigned(buf[OFFSET_LC]);
apdu.setIncomingAndReceive();
if (lc != 5) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
short offset = OFFSET_CDATA;
short id = Util.getShort(buf, offset);
offset += 2;
short len = Util.getShort(buf, offset);
offset += 2;
byte perm = buf[offset];
if (!fileSystem.createFile(id, len, perm)) {
ISOException.throwIt(SW_WRONG_DATA);
}
}
/** Process the VERIFY instruction (0x20) ISO7816-4 Section 7.5.6 */
private void processVerify(APDU apdu) {
if (state != STATE_PERSONALISED) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
byte[] buf = apdu.getBuffer();
if (buf[OFFSET_P1] != 0x00 || buf[OFFSET_P2] != 0x00) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
short lc = unsigned(buf[OFFSET_LC]);
if (lc < MIN_PIN_SIZE || lc > MAX_PIN_SIZE) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
// Pad the PIN to overwrite any possible garbage in the APDU (e.g. Le)
Util.arrayFillNonAtomic(
buf, (short) (OFFSET_CDATA + lc), (short) (MAX_PIN_SIZE - lc), (byte) 0x00);
if (!pin.check(buf, OFFSET_CDATA, MAX_PIN_SIZE)) {
ISOException.throwIt((short) (SW_PIN_INCORRECT_TRIES_LEFT | pin.getTriesRemaining()));
}
}
// Check that the key sent is valid
private void validateKey(APDU apdu) {
// fake key test
byte[] buffer = apdu.getBuffer();
// process extended length apdu
short testKey =
(short)
((short) (buffer[ISO7816.OFFSET_EXT_CDATA] << (short) 8)
| (short) (buffer[ISO7816.OFFSET_EXT_CDATA + 3] & 0x00FF));
if (testKey != (short) 3) ISOException.throwIt(SW_INVALID_KEY);
return;
// System.out.println("here here");
}
private void processCreateFileSystemStructure(APDU apdu) {
if (state != STATE_INITIAL) {
ISOException.throwIt(SW_CONDITIONS_NOT_SATISFIED);
}
byte[] buf = apdu.getBuffer();
short lc = unsigned(buf[OFFSET_LC]);
apdu.setIncomingAndReceive();
// Hack:
// Search for a non-existing file,
// if the structure is correct, then only the FileNotFoundException would be
// thrown.
try {
fileSystem.searchId(
buf, OFFSET_CDATA, OFFSET_CDATA, (short) (OFFSET_CDATA + lc), (short) 0x0000);
ISOException.throwIt(SW_WRONG_DATA);
} catch (FileNotFoundException e) {
} catch (ArrayIndexOutOfBoundsException aioobe) {
ISOException.throwIt(SW_WRONG_DATA);
}
fileSystem.fileStructure = new byte[lc];
Util.arrayCopy(buf, OFFSET_CDATA, fileSystem.fileStructure, (short) 0, lc);
}
/** Process the PUT DATA instruction (0xDA) P1 and P2 are custom */
private void processPutData(APDU apdu) {
byte p1 = apdu.getBuffer()[OFFSET_P1];
if (p1 >= (byte) 0x61 && p1 <= (byte) 0x66) {
processSetupKey(apdu);
} else if (p1 == (byte) 0x67) {
processSetHistoricalBytes(apdu);
} else if (p1 == (byte) 0x68) {
processSetState(apdu);
} else if (p1 == (byte) 0x69) {
processCreateFileSystemStructure(apdu);
} else {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
}
/** Process the PERFORM SECURITY OPERATION instruction (0x2A). ISO 7816-8 Section 5.2 */
private void processPerformSecurityOperation(APDU apdu) {
if (state != STATE_PERSONALISED) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
if (!pin.isValidated()) {
ISOException.throwIt(SW_SECURITY_STATUS_NOT_SATISFIED);
}
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
if (p1 == (byte) 0x80 && (p2 == (byte) 0x82 || p2 == (byte) 0x84 || p2 == (byte) 0x86)) {
processDecipher(apdu);
} else if (p1 == (byte) 0x9E && p2 == (byte) 0x9A) {
processComputeDigitalSignature(apdu);
} else {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
}
/**
* Processes an incoming APDU.
*
* @see APDU
* @param apdu the incoming APDU
* @exception ISOException with the response bytes per ISO 7816-4
*/
public void process(APDU apdu) {
byte buffer[] = apdu.getBuffer();
short bytesRead = apdu.setIncomingAndReceive();
short echoOffset = (short) 0;
while (bytesRead > 0) {
Util.arrayCopyNonAtomic(buffer, ISO7816.OFFSET_CDATA, echoBytes, echoOffset, bytesRead);
echoOffset += bytesRead;
bytesRead = apdu.receiveBytes(ISO7816.OFFSET_CDATA);
}
apdu.setOutgoing();
apdu.setOutgoingLength((short) (echoOffset + 5));
// echo header
apdu.sendBytes((short) 0, (short) 5);
// echo data
apdu.sendBytesLong(echoBytes, (short) 0, echoOffset);
}
// Simpler send method that assumes that APDU.buffer is updated with the output and sent instead.
// Saves resources, but needs some checks on the
// size of the incoming buffer
private void sendBuff(APDU apdu) {
apdu.setOutgoingAndSend((short) 0, size);
}
private void processSetupKey(APDU apdu) throws ISOException {
if (state != STATE_INITIAL) {
ISOException.throwIt(SW_CONDITIONS_NOT_SATISFIED);
}
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
short lc = unsigned(buf[OFFSET_LC]);
apdu.setIncomingAndReceive();
if (p1 == (byte) 0x61 || p1 == (byte) 0x62 || p1 == (byte) 0x63) {
if (lc > 16) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
byte[] keyId = null;
if (p1 == (byte) 0x61) {
keyId = authKeyId;
} else if (p1 == (byte) 0x62) {
keyId = signKeyId;
} else if (p1 == (byte) 0x63) {
keyId = decKeyId;
}
Util.arrayCopy(buf, OFFSET_CDATA, keyId, (short) 1, lc);
keyId[0] = (byte) lc;
return;
}
RSAPrivateCrtKey privKey = null;
if (p1 == (byte) 0x64) {
privKey = authKeyPrivate;
} else if (p1 == (byte) 0x65) {
privKey = signKeyPrivate;
} else if (p1 == (byte) 0x66) {
privKey = decKeyPrivate;
} else {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
try {
switch (p2) {
case (byte) 0x81: // Modulus, ignore, but record the first byte if key is sign key
if (privKey == signKeyPrivate) {
signKeyFirstModulusByte = buf[OFFSET_CDATA];
}
break;
case (byte) 0x82: // Exponent, ignore
break;
case (byte) 0x83:
privKey.setP(buf, OFFSET_CDATA, lc);
break;
case (byte) 0x84:
privKey.setQ(buf, OFFSET_CDATA, lc);
break;
case (byte) 0x85:
privKey.setDP1(buf, OFFSET_CDATA, lc);
break;
case (byte) 0x86:
privKey.setDQ1(buf, OFFSET_CDATA, lc);
break;
case (byte) 0x87:
privKey.setPQ(buf, OFFSET_CDATA, lc);
break;
default:
}
} catch (Exception e) {
ISOException.throwIt(SW_WRONG_DATA);
}
}
/** Process the SELECT (file) instruction (0xA4) ISO7816-4 Section 7.1.1 */
private void processSelectFile(APDU apdu) {
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
// byte p2 = buf[OFFSET_P2];
short lc = unsigned(buf[OFFSET_LC]);
if (p1 == 0x04) {
// Select the AID of the applet
// do heavy verification, just for the fun of it ;)
if (lc != (short) 0x0C) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
if (Util.arrayCompare(buf, OFFSET_CDATA, myAID, (short) 0, lc) != 0) {
ISOException.throwIt(SW_WRONG_DATA);
}
return;
}
short id = 0;
switch (p1) {
case (byte) 0x00:
// Direct selection of MF, DF, or EF:
if (lc != 0 && lc != 2) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
if (lc > 0) {
apdu.setIncomingAndReceive();
id = Util.makeShort(buf[OFFSET_CDATA], buf[(short) (OFFSET_CDATA + 1)]);
} else {
id = FileSystem.MASTER_FILE_ID;
}
if (!fileSystem.selectEntryAbsolute(id)) {
ISOException.throwIt(SW_FILE_NOT_FOUND);
}
break;
case (byte) 0x01:
case (byte) 0x02:
// Select the child under the current DF,
// p1 0x01 DF identifier in data field
// p1 0x02 EF identifier in data field
if (lc != 2) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
id = Util.makeShort(buf[OFFSET_CDATA], buf[(short) (OFFSET_CDATA + 1)]);
if (!fileSystem.selectEntryUnderCurrent(id, p1 == (byte) 0x02)) {
ISOException.throwIt(SW_FILE_NOT_FOUND);
}
break;
case (byte) 0x03:
// Select the parent of the current DF
// no command data
if (lc != 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
if (!fileSystem.selectEntryParent()) {
ISOException.throwIt(SW_FILE_NOT_FOUND);
}
break;
case (byte) 0x08:
case (byte) 0x09:
// Select by path
// p1 0x08 from MF
// p1 0x09 from current DF
// data field: the path without the head
if (lc == 0 || (short) (lc % 2) != 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
if (!fileSystem.selectEntryByPath(buf, OFFSET_CDATA, lc, p1 == (byte) 0x08)) {
ISOException.throwIt(SW_FILE_NOT_FOUND);
}
break;
default:
ISOException.throwIt(SW_INCORRECT_P1P2);
}
}
/**
* Process the MANAGE SECURITY ENVIRONMENT instruction (0x22). ISO7816-4, Section 7.5.11
*
* <p>This command can be also used to prepare key generation. In this case the algorithm
* indication is not required, in fact, should not be present. Note that the key identifiers
* should be already set up with put data before that.
*/
private void processManageSecurityEnvironment(APDU apdu) {
boolean forKeyGeneration = false;
if (state == STATE_INITIAL) {
forKeyGeneration = true;
} else if (state == STATE_PREPERSONALISED) {
ISOException.throwIt(SW_INS_NOT_SUPPORTED);
}
pin.reset();
byte[] buf = apdu.getBuffer();
byte p1 = buf[OFFSET_P1];
byte p2 = buf[OFFSET_P2];
// P1 should be:
// (a) 0x40: computation, decipherment, internal authentication, ...
// (b) 0x01: set
if (p1 != (byte) 0x41) {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
byte[] expectedKeyId = null;
// P2 should be one of the following, see ISO7816-4 Table 79
if (p2 == (byte) 0xa4) {
expectedKeyId = authKeyId;
} else if (p2 == (byte) 0xb6) {
expectedKeyId = signKeyId;
} else if (p2 == (byte) 0xB8) {
expectedKeyId = decKeyId;
} else {
ISOException.throwIt(SW_INCORRECT_P1P2);
}
short lc = unsigned(buf[OFFSET_LC]);
if (lc == 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
short offset = OFFSET_CDATA;
lc += OFFSET_CDATA;
// Tag for the private key:
short len = checkDataObject(buf, offset, lc, (byte) 0x84);
offset += 2;
if (len != expectedKeyId[0]) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
if (Util.arrayCompare(buf, offset, expectedKeyId, (short) 1, len) != 0) {
ISOException.throwIt(SW_KEY_NOT_FOUND);
}
offset += len;
// Algorithm identfier tag
if (!forKeyGeneration) {
if (offset >= lc) {
ISOException.throwIt(SW_WRONG_DATA);
}
len = checkDataObject(buf, offset, lc, (byte) 0x80);
offset += 2;
if (len != 1) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
byte sAlg = buf[offset++];
if (offset != lc) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
if (sAlg < ALG_AUTH_DEC_RSA || sAlg > ALG_SIGN_RSA_PKCS1_SHA1MD5) {
ISOException.throwIt(SW_WRONG_DATA);
}
tmp[TMP_SIGNALG_OFFSET] = sAlg;
} else {
if (offset != lc) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
}
if (expectedKeyId == authKeyId) {
currentPrivateKey[0] = authKeyPrivate;
} else if (expectedKeyId == signKeyId) {
currentPrivateKey[0] = signKeyPrivate;
} else if (expectedKeyId == decKeyId) {
currentPrivateKey[0] = decKeyPrivate;
}
}
// Common method that sets the size of the output to the global variable size and sends the
// content of the global variable output
private void send(APDU apdu) {
apdu.setOutgoing();
apdu.setOutgoingLength(size);
apdu.sendBytesLong(output, (short) 0, size);
}
/** Process the PSO DECIPHER instruction. ISO 7816-8 Section 5.10 */
private void processDecipher(APDU apdu) {
byte[] buf = apdu.getBuffer();
byte cla = buf[OFFSET_CLA];
boolean chain = ((byte) (cla & CLA_CHAIN) == CLA_CHAIN);
short lc = unsigned(buf[OFFSET_LC]);
// We need at least 1 byte of data to feed into the cipher,
// so that a progression is made
if (lc == 0) {
ISOException.throwIt(SW_WRONG_LENGTH);
}
apdu.setIncomingAndReceive();
short offset = OFFSET_CDATA;
// The first in chain, intialized and check:
if (tmp[TMP_DECSEQ_OFFSET] == (byte) 0x00) {
RSAPrivateCrtKey key = (RSAPrivateCrtKey) currentPrivateKey[0];
if (key == null) {
ISOException.throwIt(SW_KEY_NOT_FOUND);
}
byte alg = tmp[TMP_SIGNALG_OFFSET];
if (key != decKeyPrivate || alg != ALG_AUTH_DEC_RSA) {
ISOException.throwIt(SW_WRONG_DATA);
}
pkcs1Cipher.init(key, Cipher.MODE_DECRYPT);
tmp[TMP_DECSEQ_OFFSET]++;
expectedDecipherDataLength[0] = (short) (key.getSize() / 8);
}
short decipheredLen = 0;
try {
decipheredLen =
pkcs1Cipher.update(buf, offset, lc, tmp, (short) (TMP_OFFSET + decipheredLen));
} catch (CryptoException ce) {
ISOException.throwIt(SW_WRONG_DATA);
}
expectedDecipherDataLength[0] -= lc;
offset += lc;
// Data still to come:
if (expectedDecipherDataLength[0] != 0 && !chain) {
ISOException.throwIt(SW_WRONG_DATA);
}
// No more data:
if (expectedDecipherDataLength[0] == 0 && chain) {
ISOException.throwIt(SW_LAST_COMMAND_EXPECTED);
}
if (chain) {
// It should also be the case the deciphereLen == 0, check?
return;
}
pin.reset();
tmp[TMP_DECSEQ_OFFSET] = 0x00;
try {
decipheredLen =
pkcs1Cipher.doFinal(buf, offset, (short) 0, tmp, (short) (TMP_OFFSET + decipheredLen));
} catch (CryptoException ce) {
ISOException.throwIt(SW_WRONG_DATA);
}
Util.arrayCopyNonAtomic(tmp, TMP_OFFSET, buf, (short) 0, decipheredLen);
apdu.setOutgoingAndSend((short) 0, decipheredLen);
}
public void process(APDU apdu) {
// Good practice: Return 9000 on SELECT
if (selectingApplet()) {
return;
}
byte[] buff = apdu.getBuffer();
// Get the incoming APDU
// Util.arrayCopy(apdu.getBuffer(),(short) 0, buff,(short) 0,(short) apdu.getBuffer().length);//
// apdu.getBuffer();
// Check the CLA
/*
if(buff[ISO7816.OFFSET_CLA]!=CLA){
ISOException.throwIt(ISO7816.SW_CLA_NOT_SUPPORTED);
}
*/
// Switch on the instruction code INS
switch (buff[ISO7816.OFFSET_INS]) {
// Create a test signature using test
case SEND_TEST_SIGNATURE:
// Sign the test byte and get the signature size
size = sig.sign(test, (short) 0, (short) test.length, output, (short) 0);
break;
// return modulus of public key
case SEND_PUB_MOD:
// Retrieve the modulus, store it in the output byte array and set the output length
size = k.getModulus(output, (short) 0);
break;
// return exponent of public key
case SEND_PUB_EXP:
// Retrieve the public exponent, store it in the output byte array and set the output
// length
size = k.getExponent(output, (short) 0);
break;
// return exponent of private key given correct pin authentication
case SEND_PRV_EXP:
// Check that the user is authenticated (correct command 0x80 0x03 0x01 0x00 0x04 0x00 0x00
// 0x00 0x00 0x00)
if (buff[ISO7816.OFFSET_P1] == ((byte) 0x01)) {
if (buff[ISO7816.OFFSET_LC] != (byte) 0x00) {
if (pin.check(buff, (short) (ISO7816.OFFSET_LC + 1), buff[ISO7816.OFFSET_LC])) {
size = k2.getExponent(output, (short) 0);
pin.reset();
} else {
// wrong pin (system should have taken care of decrementing the counter and checking
// boundary conditions)
ISOException.throwIt(ISO7816.SW_WRONG_DATA);
}
} else {
ISOException.throwIt(ISO7816.SW_CONDITIONS_NOT_SATISFIED); // no pin was sent
}
} else {
ISOException.throwIt(ISO7816.SW_INCORRECT_P1P2); // wrong command code
}
// Retrieve the private exponent, store it in the output byte array and set the output
// length
size = k2.getExponent(output, (short) 0);
break;
// return size of signature and modulus for testing purposes (they should be the same)
case (byte) SEND_KEY_LENGTH:
shortToByteArray(keysize);
size = (short) 2;
Util.arrayCopy(buff, (short) 0, output, (short) 0, size);
break;
// Sign arbitrary text sent to card
case (byte) SIGN_INPUT_DATA:
size = (short) buff[ISO7816.OFFSET_LC];
size = sig.sign(buff, (short) (ISO7816.OFFSET_LC + 1), size, output, (short) 0);
break;
// return the modulus of public keywith a random value sent from the host
case (byte) SEND_AUTHENTICATED_PUB_EXP:
// Find the size of the random value
size = (short) buff[ISO7816.OFFSET_LC];
// If the current key is 2048 bit =256 bytes we need a big array to store all data to sign
// TODO limit the size of the input value and do some checks on it
bigArray =
JCSystem.makeTransientByteArray((short) (size + keysize), JCSystem.CLEAR_ON_RESET);
// Update the signature object with that value
Util.arrayCopy(buff, (short) (ISO7816.OFFSET_LC + 1), bigArray, (short) 0, size);
k.getModulus(bigArray, (short) (size));
// Util.arrayCopy(buff, (short) 0, bigArray, (short) (ISO7816.OFFSET_LC+size+1), len);
size = sig.sign(bigArray, (short) 0, (short) bigArray.length, output, (short) 0);
break;
case (byte) 0x07:
size = (short) 2;
output[0] = (byte) 0x09;
output[1] = (byte) 0x08;
break;
case (byte) 0x08:
short length = 256;
// short length = (short) buff.length;
size = (short) length;
// output[0]=(byte) 0x08;
// output[1]=(byte) 0x08;
for (short i = 0; i < length; i++) {
output[i] = (byte) buff[i];
}
break;
default:
// good practice: If you don't know the INStruction, say so:
ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
}
send(apdu);
}
