Changeset 3080

Timestamp:

12/18/06 21:58:16 (2 years ago)

Author:

aj

Message:

update to latest muscle code.

Location:

trunk/src/libopensc

Files:

• card-muscle.c (modified) (5 diffs)
• muscle-filesystem.h (modified) (1 diff)
• muscle.c (modified) (27 diffs)
• muscle.h (modified) (2 diffs)

trunk/src/libopensc/card-muscle.c

@@ -460 +460 @@
         priv->fs->udata = card;
         priv->fs->listFile = _listFile;
+
+        card->cla = 0xB0;
         
         card->flags |= SC_CARD_FLAG_ONBOARD_KEY_GEN;
@@ -515 +517 @@
 {
         muscle_private_t* priv = MUSCLE_DATA(card);
+        const int bufferLength = MSC_MAX_PIN_COMMAND_LENGTH;
+        u8 buffer[bufferLength];
         switch(cmd->cmd) {
         case SC_PIN_CMD_VERIFY:
@@ -521 +525 @@
                         sc_apdu_t apdu;
                         int r;
-                        msc_verify_pin_apdu(card, &apdu, cmd->pin_reference, cmd->pin1.data, cmd->pin1.len);
+                        msc_verify_pin_apdu(card, &apdu, buffer, bufferLength, cmd->pin_reference, cmd->pin1.data, cmd->pin1.len);
                         cmd->apdu = &apdu;
                         cmd->pin1.offset = 5;
@@ -541 +545 @@
                 case SC_AC_CHV: {
                         sc_apdu_t apdu;
-                        msc_change_pin_apdu(card, &apdu, cmd->pin_reference, cmd->pin1.data, cmd->pin1.len, cmd->pin2.data, cmd->pin2.len);
+                        msc_change_pin_apdu(card, &apdu, buffer, bufferLength, cmd->pin_reference, cmd->pin1.data, cmd->pin1.len, cmd->pin2.data, cmd->pin2.len);
                         cmd->apdu = &apdu;
                         return iso_pin_cmd(card, cmd, tries_left);
@@ -557 +561 @@
                 case SC_AC_CHV: {
                         sc_apdu_t apdu;
-                        msc_unblock_pin_apdu(card, &apdu, cmd->pin_reference, cmd->pin1.data, cmd->pin1.len);
+                        msc_unblock_pin_apdu(card, &apdu, buffer, bufferLength, cmd->pin_reference, cmd->pin1.data, cmd->pin1.len);
                         cmd->apdu = &apdu;
                         return iso_pin_cmd(card, cmd, tries_left);

trunk/src/libopensc/muscle-filesystem.h

@@ -29 +29 @@
         u8 id[4];
 } msc_id;
-
 
 typedef struct mscfs_file {

trunk/src/libopensc/muscle.c

@@ -23 +23 @@
 #include <string.h>
 
-#define MSC_MAX_WRITE_UNIT 255
-#define MSC_MAX_READ_UNIT 246
-
-#define MSC_MAX_CRYPTINIT_DATA (255 - 5)
-#define MSC_MAX_CRYPTPROCESS_DATA (255 - 3)
-
 #define MSC_RSA_PUBLIC          0x01
 #define MSC_RSA_PRIVATE         0x02
@@ -51 +45 @@
 
         sc_format_apdu(card, &apdu, SC_APDU_CASE_2, 0x58, next, 0x00);
-        apdu.cla = 0xB0;
         apdu.le = 14;
         apdu.resplen = 14;
@@ -125 +118 @@
         int r;
         size_t i;
-        for(i = 0; i < dataLength; i += MSC_MAX_WRITE_UNIT) {
-                r = msc_partial_read_object(card, objectId, offset + i, data + i, MIN(dataLength - i, MSC_MAX_WRITE_UNIT));
+        size_t max_read_unit = MSC_MAX_READ;
+
+        for(i = 0; i < dataLength; i += max_read_unit) {
+                r = msc_partial_read_object(card, objectId, offset + i, data + i, MIN(dataLength - i, max_read_unit));
                 SC_TEST_RET(card->ctx, r, "Error in partial object read");
         }
@@ -134 +129 @@
 int msc_zero_object(sc_card_t *card, msc_id objectId, size_t dataLength)
 {
-        u8 zeroBuffer[MSC_MAX_WRITE_UNIT];
+        u8 zeroBuffer[MSC_MAX_APDU];
         size_t i;
-        memset(zeroBuffer, 0, MSC_MAX_WRITE_UNIT);
-        for(i = 0; i < dataLength; i += MSC_MAX_WRITE_UNIT) {
-                int r = msc_partial_update_object(card, objectId, i, zeroBuffer, MIN(dataLength - i, MSC_MAX_WRITE_UNIT));
+        size_t max_write_unit = MSC_MAX_SEND - 9; /* - 9 for object ID+length */
+
+        memset(zeroBuffer, 0, max_write_unit);
+        for(i = 0; i < dataLength; i += max_write_unit) {
+                int r = msc_partial_update_object(card, objectId, i, zeroBuffer, MIN(dataLength - i, max_write_unit));
                 SC_TEST_RET(card->ctx, r, "Error in zeroing file update");
         }
@@ -182 +179 @@
 }
 
-/* Update up to 246 bytes */
+/* Update up to MSC_MAX_READ - 9 bytes */
 int msc_partial_update_object(sc_card_t *card, msc_id objectId, int offset, const u8 *data, size_t dataLength)
 {
-        u8 buffer[256];
+        u8 buffer[MSC_MAX_APDU];
         sc_apdu_t apdu;
         int r;
@@ -225 +222 @@
         int r;
         size_t i;
-        for(i = 0; i < dataLength; i += MSC_MAX_READ_UNIT) {
-                r = msc_partial_update_object(card, objectId, offset + i, data + i, MIN(dataLength - i, MSC_MAX_READ_UNIT));
+        size_t max_write_unit = MSC_MAX_SEND - 9;
+        for(i = 0; i < dataLength; i += max_write_unit) {
+                r = msc_partial_update_object(card, objectId, offset + i, data + i, MIN(dataLength - i, max_write_unit));
                 SC_TEST_RET(card->ctx, r, "Error in partial object update");
         }
@@ -279 +277 @@
 }
 
+/* Truncate the nulls at the end of a PIN, useful in padding is unnecessarily added */
+static void truncatePinNulls(const u8* pin, int *pinLength) {
+        for(; *pinLength > 0; (*pinLength)--) {
+                if(pin[*pinLength - 1]) break;
+        }
+}
+
 int msc_verify_pin(sc_card_t *card, int pinNumber, const u8 *pinValue, int pinLength, int *tries)
 {
@@ -284 +289 @@
         int r;
 
-        msc_verify_pin_apdu(card, &apdu, pinNumber, pinValue, pinLength);
+        const int bufferLength = MSC_MAX_PIN_LENGTH;
+        u8 buffer[bufferLength];
+        assert(pinLength <= MSC_MAX_PIN_LENGTH);
+
+        msc_verify_pin_apdu(card, &apdu, buffer, bufferLength, pinNumber, pinValue, pinLength);
         if(tries)
                 *tries = -1;
@@ -305 +314 @@
 
 /* USE ISO_VERIFY due to tries return */
-void msc_verify_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, int pinNumber, const u8 *pinValue, int pinLength)
-{
-        /* FORCE PIN TO END AFTER LAST NULL */
-        for(; pinLength > 0; pinLength--) {
-                if(pinValue[pinLength - 1]) break;
-        }
+void msc_verify_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, u8* buffer, size_t bufferLength, int pinNumber, const u8 *pinValue, int pinLength)
+{
+        assert(buffer);
+        assert(bufferLength >= pinLength);
+        assert(pinLength <= MSC_MAX_PIN_LENGTH);
+
+        truncatePinNulls(pinValue, &pinLength);
+
+        memcpy(buffer, pinValue, pinLength);
         sc_format_apdu(card, apdu, SC_APDU_CASE_3_SHORT, 0x42, pinNumber, 0);
         apdu->lc = pinLength;
-        apdu->data = pinValue;
+        apdu->data = buffer;
         apdu->datalen = pinLength;
 }
@@ -321 +333 @@
         sc_apdu_t apdu;
         int r;
-
-        msc_unblock_pin_apdu(card, &apdu, pinNumber, pukValue, pukLength);
+        const int bufferLength = MSC_MAX_PIN_LENGTH;
+        u8 buffer[bufferLength];
+
+        assert(pukLength <= MSC_MAX_PIN_LENGTH);
+
+        msc_unblock_pin_apdu(card, &apdu, buffer, bufferLength, pinNumber, pukValue, pukLength);
         if(tries)
                 *tries = -1;
@@ -342 +358 @@
 }
 
-void msc_unblock_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, int pinNumber, const u8 *pukValue, int pukLength)
-{
+void msc_unblock_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, u8* buffer, size_t bufferLength, int pinNumber, const u8 *pukValue, int pukLength)
+{
+        assert(buffer);
+        assert(bufferLength >= pukLength);
+        assert(pukLength <= MSC_MAX_PIN_LENGTH);
+
+        truncatePinNulls(pukValue, &pukLength);
+
+        memcpy(buffer, pukValue, pukLength);
         sc_format_apdu(card, apdu, SC_APDU_CASE_3_SHORT, 0x46, pinNumber, 0);
         apdu->lc = pukLength;
-        apdu->data = pukValue;
+        apdu->data = buffer;
         apdu->datalen = pukLength;
 }
@@ -354 +377 @@
         sc_apdu_t apdu;
         int r;
-
-        msc_change_pin_apdu(card, &apdu, pinNumber, pinValue, pinLength, newPin, newPinLength);
+        const int bufferLength = (MSC_MAX_PIN_LENGTH + 1) * 2;
+        u8 buffer[bufferLength];
+
+        msc_change_pin_apdu(card, &apdu, buffer, bufferLength, pinNumber, pinValue, pinLength, newPin, newPinLength);
         if(tries)
                 *tries = -1;
@@ -376 +401 @@
 
 /* USE ISO_VERIFY due to tries return */
-void msc_change_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, int pinNumber, const u8 *pinValue, int pinLength, const u8 *newPin, int newPinLength)
-{
-        u8 pinData[512]; /* Absolute max size 255 * 2 + 2 */
-        u8 *ptr = pinData;
+void msc_change_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, u8* buffer, size_t bufferLength, int pinNumber, const u8 *pinValue, int pinLength, const u8 *newPin, int newPinLength)
+{
+        u8 *ptr;
+        assert(pinLength <= MSC_MAX_PIN_LENGTH);
+        assert(newPinLength <= MSC_MAX_PIN_LENGTH);
+        assert(buffer);
+        assert(bufferLength >= pinLength + newPinLength + 2);
+
+        truncatePinNulls(pinValue, &pinLength);
+        truncatePinNulls(newPin, &newPinLength);
+
+        ptr = buffer;
 
         sc_format_apdu(card, apdu, SC_APDU_CASE_3_SHORT, 0x44, pinNumber, 0);
@@ -392 +425 @@
         apdu->lc = pinLength + newPinLength + 2;
         apdu->datalen = apdu->lc;
-        apdu->data = pinData;
+        apdu->data = buffer;
 }
 
@@ -401 +434 @@
         u8 *buffer, *ptr;
         
-        location = (dataLength < 255) ? 1 : 2; /* 1 == APDU, 2 == (seed in 0xFFFFFFFE, out in 0xFFFFFFFF) */
+        location = (dataLength < MSC_MAX_READ) ? 1 : 2; /* 1 == APDU, 2 == (seed in 0xFFFFFFFE, out in 0xFFFFFFFF) */
         cse = (location == 1) ? SC_APDU_CASE_4_SHORT : SC_APDU_CASE_3_SHORT;
         len = seedLength + 4;
-
-        assert(seedLength < 251);
-        assert(dataLength < 255); /* Output buffer doesn't seem to operate as desired.... nobody can read/delete */
+        
+        assert(seedLength < MSC_MAX_SEND - 4);
+        assert(dataLength < MSC_MAX_READ - 9); /* Output buffer doesn't seem to operate as desired.... nobody can read/delete */
         
         buffer = malloc(len);
@@ -476 +509 @@
 {
         sc_apdu_t apdu;
-        u8 buffer[256];
+        u8 buffer[16]; /* Keypair payload length */
         u8 *ptr = buffer;
         int r;
@@ -570 +603 @@
         if(r < 0) SC_FUNC_RETURN(card->ctx, 0, r);
         
-        /* Read keyType, keySize, and what should be the modulus size */        
+        /* Read keyType, keySize, and what should be the modulus size */
         r = msc_read_object(card, inputId, fileLocation, buffer, 5);
         fileLocation += 5;
@@ -617 +650 @@
 {
         sc_apdu_t apdu;
-        u8 buffer[255];
+        u8 buffer[MSC_MAX_APDU];
         u8 *ptr;
         int r;
 
-        u8 outputBuffer[255];
+        u8 outputBuffer[MSC_MAX_APDU];
         sc_format_apdu(card, &apdu, SC_APDU_CASE_4_SHORT, 0x36, keyLocation, 0x01); /* Init */
         apdu.data = buffer;
@@ -645 +678 @@
                  *outputDataLength = receivedData;
                 *outputDataLength = 0;
-                assert(receivedData <= 255);
+                assert(receivedData <= MSC_MAX_APDU);
                 memcpy(outputData, outputBuffer + 2, receivedData);
                 return 0;
@@ -669 +702 @@
 {
         sc_apdu_t apdu;
-        u8 buffer[255];
-        u8 outputBuffer[255];
+        u8 buffer[MSC_MAX_APDU];
+        u8 outputBuffer[MSC_MAX_APDU];
         u8 *ptr;
         int r;
+
+        if(dataLength > MSC_MAX_SEND - 3)
+                return SC_ERROR_INVALID_ARGUMENTS;
 
         sc_format_apdu(card, &apdu, SC_APDU_CASE_4_SHORT, 0x36, keyLocation, 0x02); /* Process */
@@ -683 +719 @@
         memset(outputBuffer, 0, sizeof(outputBuffer));
         apdu.resp = outputBuffer;
-        apdu.resplen = 255;
+        apdu.resplen = MSC_MAX_READ;
         apdu.le = dataLength;
         ptr = buffer;
@@ -697 +733 @@
                  *outputDataLength = receivedData;
                 *outputDataLength = 0;
-                assert(receivedData <= 255);
+                assert(receivedData <= MSC_MAX_APDU);
                 memcpy(outputData, outputBuffer + 2, receivedData);
                 return 0;
@@ -721 +757 @@
 {
         sc_apdu_t apdu;
-        u8 buffer[255];
-        u8 outputBuffer[255];
+        u8 buffer[MSC_MAX_APDU];
+        u8 outputBuffer[MSC_MAX_APDU];
         u8 *ptr;
         int r;
@@ -734 +770 @@
         memset(outputBuffer, 0, sizeof(outputBuffer));
         apdu.resp = outputBuffer;
-        apdu.resplen = 255;
-        apdu.le = 255;
+        apdu.resplen = MSC_MAX_READ;
+        apdu.le = MSC_MAX_READ;
         ptr = buffer;
         *ptr = 0x01; ptr++; /* DATA LOCATION: APDU */
@@ -747 +783 @@
                 short receivedData = outputBuffer[0] << 8 | outputBuffer[1];
                 *outputDataLength = receivedData;
-                assert(receivedData <= 255);
+                assert(receivedData <= MSC_MAX_APDU);
                 memcpy(outputData, outputBuffer + 2, receivedData);
                 return 0;
@@ -794 +830 @@
         inPtr += toSend;
         outPtr += received;
-        while(left > MSC_MAX_CRYPTPROCESS_DATA) {
-                toSend = MIN(left, MSC_MAX_CRYPTINIT_DATA);
+        while(left > (MSC_MAX_SEND - 5)) {
+                toSend = MIN(left, (MSC_MAX_SEND - 5));
                 r = msc_compute_crypt_process(card,
                         keyLocation,
@@ -807 +843 @@
                 outPtr += received;
         }
-        toSend = MIN(left, MSC_MAX_CRYPTINIT_DATA);
+        toSend = MIN(left, (MSC_MAX_SEND - 5));
         r = msc_compute_crypt_final(card,
                 keyLocation,

trunk/src/libopensc/muscle.h

@@ -29 +29 @@
 #include "muscle-filesystem.h"
 
+#define MSC_MAX_APDU 256 /* Max APDU send/recv, used for stack allocation */
+#define MSC_MAX_PIN_LENGTH 8
+#define MSC_MAX_PIN_COMMAND_LENGTH ((1 + MSC_MAX_PIN_LENGTH) * 2)
+
+/* Currently max size handled by muscle driver is 255 ... */
+#define MSC_MAX_READ (MIN(card->reader->driver->max_recv_size,255))
+#define MSC_MAX_SEND (MIN(card->reader->driver->max_send_size,255))
+
 int msc_list_objects(sc_card_t* card, u8 next, mscfs_file_t* file);
 int msc_partial_read_object(sc_card_t *card, msc_id objectId, int offset, u8 *data, size_t dataLength);
@@ -41 +49 @@
 
 int msc_verify_pin(sc_card_t *card, int pinNumber, const u8 *pinValue, int pinLength, int *tries);
-void msc_verify_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, int pinNumber, const u8 *pinValue, int pinLength);
+void msc_verify_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, u8* buffer, size_t bufferLength, int pinNumber, const u8 *pinValue, int pinLength);
 int msc_unblock_pin(sc_card_t *card, int pinNumber, const u8 *pukValue, int pukLength, int *tries);
-void msc_unblock_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, int pinNumber, const u8 *pukValue, int pukLength);
+void msc_unblock_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, u8* buffer, size_t bufferLength, int pinNumber, const u8 *pukValue, int pukLength);
 int msc_change_pin(sc_card_t *card, int pinNumber, const u8 *pinValue, int pinLength, const u8 *newPin, int newPinLength, int *tries);
-void msc_change_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, int pinNumber, const u8 *pinValue, int pinLength, const u8 *newPin, int newPinLength);
+void msc_change_pin_apdu(sc_card_t *card, sc_apdu_t *apdu, u8* buffer, size_t bufferLength, int pinNumber, const u8 *pinValue, int pinLength, const u8 *newPin, int newPinLength);
 
 int msc_get_challenge(sc_card_t *card, short dataLength, short seedLength, u8 *seedData, u8* outputData);