fix hf iclass sim

* sim 2: add responses to read(1) (Config) and read(5) (AIA)
* sim 2/3: don't restrict CC to 00 bytes only
* sim 3: add responding to read block commands
* sim 2/3: add responding to READ_CHECK_KC
* fix sizes of pre-encoded tag answers
* change default card challenge
* remove commented code
* use #defines instead of numerical constants for simulation modes
* some reformatting

diff --git a/armsrc/iclass.c b/armsrc/iclass.c
index 5d7375a7bd8ad982778ad41046925570e9fa33e0..23d407f7669dc4749062b79402883f64fcd269cf 100644 (file)
--- a/armsrc/iclass.c
+++ b/armsrc/iclass.c
@@ -391,8 +391,7 @@ static RAMFUNC int ManchesterDecoding(int v) {
                        Demod.shiftReg = 0;
                        Demod.samples = 0;
                        if (Demod.posCount) {
                        Demod.shiftReg = 0;
                        Demod.samples = 0;
                        if (Demod.posCount) {

-                               //if (trigger) LED_A_OFF();  // Not useful in this case...
-                               switch(Demod.syncBit) {
+                               switch (Demod.syncBit) {

                                        case 0x08: Demod.samples = 3; break;
                                        case 0x04: Demod.samples = 2; break;
                                        case 0x02: Demod.samples = 1; break;
                                        case 0x08: Demod.samples = 3; break;
                                        case 0x04: Demod.samples = 2; break;
                                        case 0x02: Demod.samples = 1; break;


@@ -414,12 +413,13 @@ static RAMFUNC int ManchesterDecoding(int v) {
 
                }
        } else {
 
                }
        } else {

+               // state is DEMOD is in SYNC from here on.

                modulation = bit & Demod.syncBit;
                modulation |= ((bit << 1) ^ ((Demod.buffer & 0x08) >> 3)) & Demod.syncBit;
 
                Demod.samples += 4;
 
                modulation = bit & Demod.syncBit;
                modulation |= ((bit << 1) ^ ((Demod.buffer & 0x08) >> 3)) & Demod.syncBit;
 
                Demod.samples += 4;
 

-               if (Demod.posCount==0) {
+               if (Demod.posCount == 0) {

                        Demod.posCount = 1;
                        if (modulation) {
                                Demod.sub = SUB_FIRST_HALF;
                        Demod.posCount = 1;
                        if (modulation) {
                                Demod.sub = SUB_FIRST_HALF;


@@ -428,14 +428,6 @@ static RAMFUNC int ManchesterDecoding(int v) {
                        }
                } else {
                        Demod.posCount = 0;
                        }
                } else {
                        Demod.posCount = 0;

-                       /*(modulation && (Demod.sub == SUB_FIRST_HALF)) {
-                               if (Demod.state!=DEMOD_ERROR_WAIT) {
-                                       Demod.state = DEMOD_ERROR_WAIT;
-                                       Demod.output[Demod.len] = 0xaa;
-                                       error = 0x01;
-                               }
-                       }*/
-                       //else if (modulation) {

                        if (modulation) {
                                if (Demod.sub == SUB_FIRST_HALF) {
                                        Demod.sub = SUB_BOTH;
                        if (modulation) {
                                if (Demod.sub == SUB_FIRST_HALF) {
                                        Demod.sub = SUB_BOTH;


@@ -447,23 +439,16 @@ static RAMFUNC int ManchesterDecoding(int v) {
                                        Demod.output[Demod.len] = 0x0f;
                                        Demod.len++;
                                        Demod.state = DEMOD_UNSYNCD;
                                        Demod.output[Demod.len] = 0x0f;
                                        Demod.len++;
                                        Demod.state = DEMOD_UNSYNCD;

-//                  error = 0x0f;

                                        return true;
                                } else {
                                        Demod.state = DEMOD_ERROR_WAIT;
                                        error = 0x33;
                                }
                                        return true;
                                } else {
                                        Demod.state = DEMOD_ERROR_WAIT;
                                        error = 0x33;
                                }

-                               /*if (Demod.state!=DEMOD_ERROR_WAIT) {
-                                       Demod.state = DEMOD_ERROR_WAIT;
-                                       Demod.output[Demod.len] = 0xaa;
-                                       error = 0x01;
-                               }*/

                        }
 
                        switch(Demod.state) {
                                case DEMOD_START_OF_COMMUNICATION:
                                        if (Demod.sub == SUB_BOTH) {
                        }
 
                        switch(Demod.state) {
                                case DEMOD_START_OF_COMMUNICATION:
                                        if (Demod.sub == SUB_BOTH) {

-                                               //Demod.state = DEMOD_MANCHESTER_D;

                                                Demod.state = DEMOD_START_OF_COMMUNICATION2;
                                                Demod.posCount = 1;
                                                Demod.sub = SUB_NONE;
                                                Demod.state = DEMOD_START_OF_COMMUNICATION2;
                                                Demod.posCount = 1;
                                                Demod.sub = SUB_NONE;


@@ -484,10 +469,7 @@ static RAMFUNC int ManchesterDecoding(int v) {
                                        break;
                                case DEMOD_START_OF_COMMUNICATION3:
                                        if (Demod.sub == SUB_SECOND_HALF) {
                                        break;
                                case DEMOD_START_OF_COMMUNICATION3:
                                        if (Demod.sub == SUB_SECOND_HALF) {

-//                      Demod.state = DEMOD_MANCHESTER_D;

                                                Demod.state = DEMOD_SOF_COMPLETE;
                                                Demod.state = DEMOD_SOF_COMPLETE;

-                                               //Demod.output[Demod.len] = Demod.syncBit & 0xFF;
-                                               //Demod.len++;

                                        } else {
                                                Demod.output[Demod.len] = 0xab;
                                                Demod.state = DEMOD_ERROR_WAIT;
                                        } else {
                                                Demod.output[Demod.len] = 0xab;
                                                Demod.state = DEMOD_ERROR_WAIT;


@@ -543,16 +525,6 @@ static RAMFUNC int ManchesterDecoding(int v) {
                                        break;
                        }
 
                                        break;
                        }
 

-                       /*if (Demod.bitCount>=9) {
-                               Demod.output[Demod.len] = Demod.shiftReg & 0xff;
-                               Demod.len++;
-
-                               Demod.parityBits <<= 1;
-                               Demod.parityBits ^= ((Demod.shiftReg >> 8) & 0x01);
-
-                               Demod.bitCount = 0;
-                               Demod.shiftReg = 0;
-                       }*/

                        if (Demod.bitCount >= 8) {
                                Demod.shiftReg >>= 1;
                                Demod.output[Demod.len] = (Demod.shiftReg & 0xff);
                        if (Demod.bitCount >= 8) {
                                Demod.shiftReg >>= 1;
                                Demod.output[Demod.len] = (Demod.shiftReg & 0xff);


@@ -787,8 +759,7 @@ void rotateCSN(uint8_t* originalCSN, uint8_t* rotatedCSN) {
 // Stop when button is pressed
 // Or return true when command is captured
 //-----------------------------------------------------------------------------
 // Stop when button is pressed
 // Or return true when command is captured
 //-----------------------------------------------------------------------------

-static int GetIClassCommandFromReader(uint8_t *received, int *len, int maxLen)
-{
+static int GetIClassCommandFromReader(uint8_t *received, int *len, int maxLen) {

        // Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen
        // only, since we are receiving, not transmitting).
        // Signal field is off with the appropriate LED
        // Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen
        // only, since we are receiving, not transmitting).
        // Signal field is off with the appropriate LED


@@ -825,7 +796,7 @@ static uint8_t encode4Bits(const uint8_t b) {
        //         The columns are
        //               1 - Bit value to send
        //               2 - Reversed (big-endian)
        //         The columns are
        //               1 - Bit value to send
        //               2 - Reversed (big-endian)

-       //               3 - Encoded
+       //               3 - Manchester Encoded

        //               4 - Hex values
 
        switch(c){
        //               4 - Hex values
 
        switch(c){


@@ -935,20 +906,19 @@ static int SendIClassAnswer(uint8_t *resp, int respLen, int delay) {
 
        AT91C_BASE_SSC->SSC_THR = 0x00;
        FpgaSetupSsc(FPGA_MAJOR_MODE_HF_SIMULATOR);
 
        AT91C_BASE_SSC->SSC_THR = 0x00;
        FpgaSetupSsc(FPGA_MAJOR_MODE_HF_SIMULATOR);

-       while (!BUTTON_PRESS()) {
+       while (true) {

                if ((AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY)){
                if ((AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY)){

-                       b = AT91C_BASE_SSC->SSC_RHR; (void) b;
+                       b = AT91C_BASE_SSC->SSC_RHR;
+                       (void) b;

                }
                if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)){
                        b = 0x00;
                        if (d < delay) {
                }
                if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)){
                        b = 0x00;
                        if (d < delay) {

+                               // send 0x00 byte (causing a 2048/13,56MHz = 151us delay)

                                d++;
                                d++;

-                       }
-                       else {
+                       } else {

                                if (i < respLen) {
                                        b = resp[i];
                                if (i < respLen) {
                                        b = resp[i];

-                                       //Hack
-                                       //b = 0xAC;

                                }
                                i++;
                        }
                                }
                                i++;
                        }


@@ -957,15 +927,13 @@ static int SendIClassAnswer(uint8_t *resp, int respLen, int delay) {
 
 //      if (i > respLen +4) break;
                if (i > respLen + 1) break;
 
 //      if (i > respLen +4) break;
                if (i > respLen + 1) break;

+               // send 2 more 0x00 bytes (causing a 302us delay)

        }
 
        return 0;
 }
 
 
        }
 
        return 0;
 }
 
 

-#define MODE_SIM_CSN        0
-#define MODE_EXIT_AFTER_MAC 1
-#define MODE_FULLSIM        2

 
 /**
  * @brief Does the actual simulation
 
 /**
  * @brief Does the actual simulation


@@ -973,14 +941,16 @@ static int SendIClassAnswer(uint8_t *resp, int respLen, int delay) {
  * @param breakAfterMacReceived if true, returns after reader MAC has been received.
  */
 int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
  * @param breakAfterMacReceived if true, returns after reader MAC has been received.
  */
 int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {

+

        // free eventually allocated BigBuf memory
        BigBuf_free_keep_EM();
 
        State cipher_state;
        // free eventually allocated BigBuf memory
        BigBuf_free_keep_EM();
 
        State cipher_state;

-//  State cipher_state_reserve;
-       uint8_t *csn = BigBuf_get_EM_addr();
-       uint8_t *emulator = csn;
-       uint8_t sof_data[] = { 0x0F} ;
+
+       uint8_t *emulator = BigBuf_get_EM_addr();
+       uint8_t *csn = emulator;
+       uint8_t sof_data[] = { 0x0F } ;
+

        // CSN followed by two CRC bytes
        uint8_t anticoll_data[10] = { 0 };
        uint8_t csn_data[10] = { 0 };
        // CSN followed by two CRC bytes
        uint8_t anticoll_data[10] = { 0 };
        uint8_t csn_data[10] = { 0 };


@@ -991,21 +961,26 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
        rotateCSN(csn_data, anticoll_data);
 
        // Compute CRC on both CSNs
        rotateCSN(csn_data, anticoll_data);
 
        // Compute CRC on both CSNs

-       ComputeCrc14443(CRC_ICLASS, anticoll_data, 8, &anticoll_data[8], &anticoll_data[9]);
-       ComputeCrc14443(CRC_ICLASS, csn_data, 8, &csn_data[8], &csn_data[9]);
+       AppendCrc(anticoll_data, 8);
+       AppendCrc(csn_data, 8);

 
        uint8_t diversified_key[8] = { 0 };
        // e-Purse
 
        uint8_t diversified_key[8] = { 0 };
        // e-Purse

-       uint8_t card_challenge_data[8] = { 0x00 };
-       if (simulationMode == MODE_FULLSIM) {
-               //The diversified key should be stored on block 3
-               //Get the diversified key from emulator memory
-               memcpy(diversified_key, emulator + (8*3), 8);
-               //Card challenge, a.k.a e-purse is on block 2
+       uint8_t card_challenge_data[8] = { 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+       //uint8_t card_challenge_data[8] = { 0 };
+       if (simulationMode == ICLASS_SIM_MODE_FULL) {
+               // The diversified key should be stored on block 3
+               // Get the diversified key from emulator memory
+               memcpy(diversified_key, emulator + (8 * 3), 8);
+               // Card challenge, a.k.a e-purse is on block 2

                memcpy(card_challenge_data, emulator + (8 * 2), 8);
                memcpy(card_challenge_data, emulator + (8 * 2), 8);

-               //Precalculate the cipher state, feeding it the CC
+               // Precalculate the cipher state, feeding it the CC

                cipher_state = opt_doTagMAC_1(card_challenge_data, diversified_key);
        }
                cipher_state = opt_doTagMAC_1(card_challenge_data, diversified_key);
        }

+       // save card challenge for sim2,4 attack
+       if (reader_mac_buf != NULL) {
+               memcpy(reader_mac_buf, card_challenge_data, 8);
+       }

 
        int exitLoop = 0;
        // Reader 0a
 
        int exitLoop = 0;
        // Reader 0a


@@ -1026,19 +1001,31 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
 
        // Anticollision CSN (rotated CSN)
        // 22: Takes 2 bytes for SOF/EOF and 10 * 2 = 20 bytes (2 bytes/byte)
 
        // Anticollision CSN (rotated CSN)
        // 22: Takes 2 bytes for SOF/EOF and 10 * 2 = 20 bytes (2 bytes/byte)

-       uint8_t *resp_anticoll = BigBuf_malloc(28);
+       uint8_t *resp_anticoll = BigBuf_malloc(22);

        int resp_anticoll_len;
 
        int resp_anticoll_len;
 

-       // CSN
+       // CSN (block 0)

        // 22: Takes 2 bytes for SOF/EOF and 10 * 2 = 20 bytes (2 bytes/byte)
        // 22: Takes 2 bytes for SOF/EOF and 10 * 2 = 20 bytes (2 bytes/byte)

-       uint8_t *resp_csn = BigBuf_malloc(30);
+       uint8_t *resp_csn = BigBuf_malloc(22);

        int resp_csn_len;
 
        int resp_csn_len;
 

-       // e-Purse
+       // configuration (block 1) picopass 2ks
+       uint8_t *resp_conf = BigBuf_malloc(22);
+       int resp_conf_len;
+       uint8_t conf_data[10] = {0x12, 0xFF, 0xFF, 0xFF, 0x7F, 0x1F, 0xFF, 0x3C, 0x00, 0x00};
+       AppendCrc(conf_data, 8);
+
+       // e-Purse (block 2)

        // 18: Takes 2 bytes for SOF/EOF and 8 * 2 = 16 bytes (2 bytes/bit)
        // 18: Takes 2 bytes for SOF/EOF and 8 * 2 = 16 bytes (2 bytes/bit)

-       uint8_t *resp_cc = BigBuf_malloc(20);
+       uint8_t *resp_cc = BigBuf_malloc(18);

        int resp_cc_len;
 
        int resp_cc_len;
 

+       // Application Issuer Area (block 5)
+       uint8_t *resp_aia = BigBuf_malloc(22);
+       int resp_aia_len;
+       uint8_t aia_data[10] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00};
+       AppendCrc(aia_data, 8);
+

        uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
        int len;
 
        uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
        int len;
 


@@ -1055,25 +1042,30 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
        memcpy(resp_anticoll, ToSend, ToSendMax);
        resp_anticoll_len = ToSendMax;
 
        memcpy(resp_anticoll, ToSend, ToSendMax);
        resp_anticoll_len = ToSendMax;
 

-       // CSN
+       // CSN (block 0)

        CodeIClassTagAnswer(csn_data, sizeof(csn_data));
        memcpy(resp_csn, ToSend, ToSendMax);
        resp_csn_len = ToSendMax;
 
        CodeIClassTagAnswer(csn_data, sizeof(csn_data));
        memcpy(resp_csn, ToSend, ToSendMax);
        resp_csn_len = ToSendMax;
 

-       // e-Purse
+       // Configuration (block 1)
+       CodeIClassTagAnswer(conf_data, sizeof(conf_data));
+       memcpy(resp_conf, ToSend, ToSendMax);
+       resp_conf_len = ToSendMax;
+
+       // e-Purse (block 2)

        CodeIClassTagAnswer(card_challenge_data, sizeof(card_challenge_data));
        CodeIClassTagAnswer(card_challenge_data, sizeof(card_challenge_data));

-       memcpy(resp_cc, ToSend, ToSendMax); resp_cc_len = ToSendMax;
+       memcpy(resp_cc, ToSend, ToSendMax);
+       resp_cc_len = ToSendMax;
+
+       // Application Issuer Area (block 5)
+       CodeIClassTagAnswer(aia_data, sizeof(aia_data));
+       memcpy(resp_aia, ToSend, ToSendMax);
+       resp_aia_len = ToSendMax;

 
        //This is used for responding to READ-block commands or other data which is dynamically generated
 
        //This is used for responding to READ-block commands or other data which is dynamically generated

-       //First the 'trace'-data, not encoded for FPGA
-       uint8_t *data_generic_trace = BigBuf_malloc(8 + 2);//8 bytes data + 2byte CRC is max tag answer
-       //Then storage for the modulated data
-       //Each bit is doubled when modulated for FPGA, and we also have SOF and EOF (2 bytes)
-       uint8_t *data_response = BigBuf_malloc( (8+2) * 2 + 2);
+       uint8_t *data_generic_trace = BigBuf_malloc(8 + 2); // 8 bytes data + 2byte CRC is max tag answer
+       uint8_t *data_response = BigBuf_malloc( (8 + 2) * 2 + 2);

 
 

-       // Start from off (no field generated)
-       //FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
-       //SpinDelay(200);

        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_LISTEN);
        SpinDelay(100);
        StartCountSspClk();
        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_LISTEN);
        SpinDelay(100);
        StartCountSspClk();


@@ -1081,8 +1073,6 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
        FpgaSetupSsc(FPGA_MAJOR_MODE_HF_ISO14443A);
 
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
        FpgaSetupSsc(FPGA_MAJOR_MODE_HF_ISO14443A);
 

-       // To control where we are in the protocol
-       int cmdsRecvd = 0;

        uint32_t time_0 = GetCountSspClk();
        uint32_t t2r_time =0;
        uint32_t r2t_time =0;
        uint32_t time_0 = GetCountSspClk();
        uint32_t t2r_time =0;
        uint32_t r2t_time =0;


@@ -1091,6 +1081,7 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
        bool buttonPressed = false;
        uint8_t response_delay = 1;
        while (!exitLoop) {
        bool buttonPressed = false;
        uint8_t response_delay = 1;
        while (!exitLoop) {

+               WDT_HIT();

                response_delay = 1;
                LED_B_OFF();
                //Signal tracer
                response_delay = 1;
                LED_B_OFF();
                //Signal tracer


@@ -1105,41 +1096,95 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
                //Signal tracer
                LED_C_ON();
 
                //Signal tracer
                LED_C_ON();
 

-               // Okay, look at the command now.
+               // Now look at the reader command and provide appropriate responses
+               // default is no response:
+               modulated_response = NULL;
+               modulated_response_size = 0;
+               trace_data = NULL;
+               trace_data_size = 0;

                if (receivedCmd[0] == ICLASS_CMD_ACTALL) {
                        // Reader in anticollission phase
                        modulated_response = resp_sof;
                if (receivedCmd[0] == ICLASS_CMD_ACTALL) {
                        // Reader in anticollission phase
                        modulated_response = resp_sof;

-                       modulated_response_size = resp_sof_Len; //order = 1;
+                       modulated_response_size = resp_sof_Len;

                        trace_data = sof_data;
                        trace_data_size = sizeof(sof_data);
                        trace_data = sof_data;
                        trace_data_size = sizeof(sof_data);

-               } else if (receivedCmd[0] == ICLASS_CMD_READ_OR_IDENTIFY && len == 1) {
+
+               } else if (receivedCmd[0] == ICLASS_CMD_READ_OR_IDENTIFY && len == 1) { // identify

                        // Reader asks for anticollission CSN
                        modulated_response = resp_anticoll;
                        // Reader asks for anticollission CSN
                        modulated_response = resp_anticoll;

-                       modulated_response_size = resp_anticoll_len; //order = 2;
+                       modulated_response_size = resp_anticoll_len;

                        trace_data = anticoll_data;
                        trace_data_size = sizeof(anticoll_data);
                        //DbpString("Reader requests anticollission CSN:");
                        trace_data = anticoll_data;
                        trace_data_size = sizeof(anticoll_data);
                        //DbpString("Reader requests anticollission CSN:");

+
+               } else if (receivedCmd[0] == ICLASS_CMD_READ_OR_IDENTIFY && len == 4) { // read block
+                       uint16_t blockNo = receivedCmd[1];
+                       if (simulationMode != ICLASS_SIM_MODE_FULL) {
+                               // provide defaults for blocks 0, 1, 2, 5
+                               switch (blockNo) {
+                                       case 0: // csn (block 00)
+                                               modulated_response = resp_csn;
+                                               modulated_response_size = resp_csn_len;
+                                               trace_data = csn_data;
+                                               trace_data_size = sizeof(csn_data);
+                                               break;
+                                       case 1: // configuration (block 01)
+                                               modulated_response = resp_conf;
+                                               modulated_response_size = resp_conf_len;
+                                               trace_data = conf_data;
+                                               trace_data_size = sizeof(conf_data);
+                                               break;
+                                       case 2: // e-purse (block 02)
+                                               modulated_response = resp_cc;
+                                               modulated_response_size = resp_cc_len;
+                                               trace_data = card_challenge_data;
+                                               trace_data_size = sizeof(card_challenge_data);
+                                               // set epurse of sim2,4 attack
+                                               if (reader_mac_buf != NULL) {
+                                                       memcpy(reader_mac_buf, card_challenge_data, 8);
+                                               }
+                                               break;
+                                       case 5: // Application Issuer Area (block 05)
+                                               modulated_response = resp_aia;
+                                               modulated_response_size = resp_aia_len;
+                                               trace_data = aia_data;
+                                               trace_data_size = sizeof(aia_data);
+                                               break;
+                                       // default: don't respond
+                               }
+                       } else { // use data from emulator memory
+                               memcpy(data_generic_trace, emulator + (receivedCmd[1] << 3), 8);
+                               AppendCrc(data_generic_trace, 8);
+                               trace_data = data_generic_trace;
+                               trace_data_size = 10;
+                               CodeIClassTagAnswer(trace_data, trace_data_size);
+                               memcpy(data_response, ToSend, ToSendMax);
+                               modulated_response = data_response;
+                               modulated_response_size = ToSendMax;
+                       }
+

                } else if (receivedCmd[0] == ICLASS_CMD_SELECT) {
                        // Reader selects anticollission CSN.
                        // Tag sends the corresponding real CSN
                        modulated_response = resp_csn;
                } else if (receivedCmd[0] == ICLASS_CMD_SELECT) {
                        // Reader selects anticollission CSN.
                        // Tag sends the corresponding real CSN
                        modulated_response = resp_csn;

-                       modulated_response_size = resp_csn_len; //order = 3;
+                       modulated_response_size = resp_csn_len;

                        trace_data = csn_data;
                        trace_data_size = sizeof(csn_data);
                        trace_data = csn_data;
                        trace_data_size = sizeof(csn_data);

-                       //DbpString("Reader selects anticollission CSN:");
-               } else if (receivedCmd[0] == ICLASS_CMD_READCHECK_KD) {
-                       // Read e-purse (88 02)
+
+               } else if (receivedCmd[0] == ICLASS_CMD_READCHECK_KD
+                                       || receivedCmd[0] == ICLASS_CMD_READCHECK_KC) {
+                       // Read e-purse (88 02 || 18 02)

                        modulated_response = resp_cc;
                        modulated_response = resp_cc;

-                       modulated_response_size = resp_cc_len; //order = 4;
+                       modulated_response_size = resp_cc_len;

                        trace_data = card_challenge_data;
                        trace_data_size = sizeof(card_challenge_data);
                        LED_B_ON();
                        trace_data = card_challenge_data;
                        trace_data_size = sizeof(card_challenge_data);
                        LED_B_ON();

+

                } else if (receivedCmd[0] == ICLASS_CMD_CHECK) {
                        // Reader random and reader MAC!!!
                } else if (receivedCmd[0] == ICLASS_CMD_CHECK) {
                        // Reader random and reader MAC!!!

-                       if (simulationMode == MODE_FULLSIM) {
+                       if (simulationMode == ICLASS_SIM_MODE_FULL) {

                                //NR, from reader, is in receivedCmd +1
                                opt_doTagMAC_2(cipher_state, receivedCmd+1, data_generic_trace, diversified_key);
                                //NR, from reader, is in receivedCmd +1
                                opt_doTagMAC_2(cipher_state, receivedCmd+1, data_generic_trace, diversified_key);

-

                                trace_data = data_generic_trace;
                                trace_data_size = 4;
                                CodeIClassTagAnswer(trace_data, trace_data_size);
                                trace_data = data_generic_trace;
                                trace_data_size = 4;
                                CodeIClassTagAnswer(trace_data, trace_data_size);


@@ -1148,13 +1193,9 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
                                modulated_response_size = ToSendMax;
                                response_delay = 0; //We need to hurry here... (but maybe not too much... ??)
                                //exitLoop = true;
                                modulated_response_size = ToSendMax;
                                response_delay = 0; //We need to hurry here... (but maybe not too much... ??)
                                //exitLoop = true;

-                       } else {    //Not fullsim, we don't respond
+                       } else { // Not fullsim, we don't respond

                                // We do not know what to answer, so lets keep quiet
                                // We do not know what to answer, so lets keep quiet

-                               modulated_response = resp_sof;
-                               modulated_response_size = 0;
-                               trace_data = NULL;
-                               trace_data_size = 0;
-                               if (simulationMode == MODE_EXIT_AFTER_MAC) {
+                               if (simulationMode == ICLASS_SIM_MODE_EXIT_AFTER_MAC) {

                                        // dbprintf:ing ...
                                        Dbprintf("CSN: %02x %02x %02x %02x %02x %02x %02x %02x"
                                                           ,csn[0],csn[1],csn[2],csn[3],csn[4],csn[5],csn[6],csn[7]);
                                        // dbprintf:ing ...
                                        Dbprintf("CSN: %02x %02x %02x %02x %02x %02x %02x %02x"
                                                           ,csn[0],csn[1],csn[2],csn[3],csn[4],csn[5],csn[6],csn[7]);


@@ -1163,7 +1204,8 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
                                                        receivedCmd[3], receivedCmd[4], receivedCmd[5],
                                                        receivedCmd[6], receivedCmd[7], receivedCmd[8]);
                                        if (reader_mac_buf != NULL) {
                                                        receivedCmd[3], receivedCmd[4], receivedCmd[5],
                                                        receivedCmd[6], receivedCmd[7], receivedCmd[8]);
                                        if (reader_mac_buf != NULL) {

-                                               memcpy(reader_mac_buf, receivedCmd+1, 8);
+                                               // save NR and MAC for sim 2,4
+                                               memcpy(reader_mac_buf + 8, receivedCmd + 1, 8);

                                        }
                                        exitLoop = true;
                                }
                                        }
                                        exitLoop = true;
                                }


@@ -1172,30 +1214,18 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
                } else if (receivedCmd[0] == ICLASS_CMD_HALT && len == 1) {
                        // Reader ends the session
                        modulated_response = resp_sof;
                } else if (receivedCmd[0] == ICLASS_CMD_HALT && len == 1) {
                        // Reader ends the session
                        modulated_response = resp_sof;

-                       modulated_response_size = 0; //order = 0;
+                       modulated_response_size = 0;

                        trace_data = NULL;
                        trace_data_size = 0;
                        trace_data = NULL;
                        trace_data_size = 0;

-               } else if (simulationMode == MODE_FULLSIM && receivedCmd[0] == ICLASS_CMD_READ_OR_IDENTIFY && len == 4) {
-                       //Read block
-                       uint16_t blk = receivedCmd[1];
-                       //Take the data...
-                       memcpy(data_generic_trace, emulator + (blk << 3), 8);
-                       //Add crc
-                       AppendCrc(data_generic_trace, 8);
-                       trace_data = data_generic_trace;
-                       trace_data_size = 10;
-                       CodeIClassTagAnswer(trace_data, trace_data_size);
-                       memcpy(data_response, ToSend, ToSendMax);
-                       modulated_response = data_response;
-                       modulated_response_size = ToSendMax;
-               } else if (receivedCmd[0] == ICLASS_CMD_UPDATE && simulationMode == MODE_FULLSIM) {
-                       //Probably the reader wants to update the nonce. Let's just ignore that for now.
+
+               } else if (receivedCmd[0] == ICLASS_CMD_UPDATE && simulationMode == ICLASS_SIM_MODE_FULL) {
+                       // Probably the reader wants to update the nonce. Let's just ignore that for now.

                        // OBS! If this is implemented, don't forget to regenerate the cipher_state
                        // OBS! If this is implemented, don't forget to regenerate the cipher_state

-                       //We're expected to respond with the data+crc, exactly what's already in the receivedcmd
-                       //receivedcmd is now UPDATE 1b | ADDRESS 1b| DATA 8b| Signature 4b or CRC 2b|
+                       // We're expected to respond with the data+crc, exactly what's already in the receivedCmd
+                       // receivedCmd is now UPDATE 1b | ADDRESS 1b | DATA 8b | Signature 4b or CRC 2b

 
                        //Take the data...
 
                        //Take the data...

-                       memcpy(data_generic_trace, receivedCmd+2, 8);
+                       memcpy(data_generic_trace, receivedCmd + 2, 8);

                        //Add crc
                        AppendCrc(data_generic_trace, 8);
                        trace_data = data_generic_trace;
                        //Add crc
                        AppendCrc(data_generic_trace, 8);
                        trace_data = data_generic_trace;


@@ -1204,35 +1234,23 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
                        memcpy(data_response, ToSend, ToSendMax);
                        modulated_response = data_response;
                        modulated_response_size = ToSendMax;
                        memcpy(data_response, ToSend, ToSendMax);
                        modulated_response = data_response;
                        modulated_response_size = ToSendMax;

+

                } else if (receivedCmd[0] == ICLASS_CMD_PAGESEL) {
                } else if (receivedCmd[0] == ICLASS_CMD_PAGESEL) {

-                       //Pagesel
-                       //Pagesel enables to select a page in the selected chip memory and return its configuration block
-                       //Chips with a single page will not answer to this command
+                       // Pagesel
+                       // Pagesel enables to select a page in the selected chip memory and return its configuration block
+                       // Chips with a single page will not answer to this command

                        // It appears we're fine ignoring this.
                        // It appears we're fine ignoring this.

-                       //Otherwise, we should answer 8bytes (block) + 2bytes CRC
+                       // Otherwise, we should answer 8bytes (block) + 2bytes CRC
+

                } else {
                        //#db# Unknown command received from reader (len=5): 26 1 0 f6 a 44 44 44 44
                        // Never seen this command before
                } else {
                        //#db# Unknown command received from reader (len=5): 26 1 0 f6 a 44 44 44 44
                        // Never seen this command before

-                       Dbprintf("Unknown command received from reader (len=%d): %x %x %x %x %x %x %x %x %x",
-                       len,
-                       receivedCmd[0], receivedCmd[1], receivedCmd[2],
-                       receivedCmd[3], receivedCmd[4], receivedCmd[5],
-                       receivedCmd[6], receivedCmd[7], receivedCmd[8]);
+                       print_result("Unhandled command received from reader ", receivedCmd, len);

                        // Do not respond
                        // Do not respond

-                       modulated_response = resp_sof;
-                       modulated_response_size = 0; //order = 0;
-                       trace_data = NULL;
-                       trace_data_size = 0;

                }
 
                }
 

-               if (cmdsRecvd >  100) {
-                       //DbpString("100 commands later...");
-                       //break;
-               } else {
-                       cmdsRecvd++;
-               }

                /**
                /**

-               A legit tag has about 380us delay between reader EOT and tag SOF.
+               A legit tag has about 330us delay between reader EOT and tag SOF.

                **/
                if (modulated_response_size > 0) {
                        SendIClassAnswer(modulated_response, modulated_response_size, response_delay);
                **/
                if (modulated_response_size > 0) {
                        SendIClassAnswer(modulated_response, modulated_response_size, response_delay);


@@ -1253,7 +1271,6 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
                }
        }
 
                }
        }
 

-       //Dbprintf("%x", cmdsRecvd);

        LED_A_OFF();
        LED_B_OFF();
        LED_C_OFF();
        LED_A_OFF();
        LED_B_OFF();
        LED_C_OFF();


@@ -1280,6 +1297,7 @@ int doIClassSimulation(int simulationMode, uint8_t *reader_mac_buf) {
 void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain) {
        uint32_t simType = arg0;
        uint32_t numberOfCSNS = arg1;
 void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain) {
        uint32_t simType = arg0;
        uint32_t numberOfCSNS = arg1;

+

        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
 
        // Enable and clear the trace
        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
 
        // Enable and clear the trace


@@ -1288,35 +1306,35 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
        //Use the emulator memory for SIM
        uint8_t *emulator = BigBuf_get_EM_addr();
 
        //Use the emulator memory for SIM
        uint8_t *emulator = BigBuf_get_EM_addr();
 

-       if (simType == 0) {
+       if (simType == ICLASS_SIM_MODE_CSN) {

                // Use the CSN from commandline
                memcpy(emulator, datain, 8);
                // Use the CSN from commandline
                memcpy(emulator, datain, 8);

-               doIClassSimulation(MODE_SIM_CSN,NULL);
-       } else if (simType == 1) {
+               doIClassSimulation(ICLASS_SIM_MODE_CSN, NULL);
+       } else if (simType == ICLASS_SIM_MODE_CSN_DEFAULT) {

                //Default CSN
                uint8_t csn_crc[] = { 0x03, 0x1f, 0xec, 0x8a, 0xf7, 0xff, 0x12, 0xe0, 0x00, 0x00 };
                // Use the CSN from commandline
                memcpy(emulator, csn_crc, 8);
                //Default CSN
                uint8_t csn_crc[] = { 0x03, 0x1f, 0xec, 0x8a, 0xf7, 0xff, 0x12, 0xe0, 0x00, 0x00 };
                // Use the CSN from commandline
                memcpy(emulator, csn_crc, 8);

-               doIClassSimulation(MODE_SIM_CSN,NULL);
-       } else if (simType == 2) {
+               doIClassSimulation(ICLASS_SIM_MODE_CSN, NULL);
+       } else if (simType == ICLASS_SIM_MODE_READER_ATTACK) {

                uint8_t mac_responses[USB_CMD_DATA_SIZE] = { 0 };
                Dbprintf("Going into attack mode, %d CSNS sent", numberOfCSNS);
                // In this mode, a number of csns are within datain. We'll simulate each one, one at a time
                uint8_t mac_responses[USB_CMD_DATA_SIZE] = { 0 };
                Dbprintf("Going into attack mode, %d CSNS sent", numberOfCSNS);
                // In this mode, a number of csns are within datain. We'll simulate each one, one at a time

-               // in order to collect MAC's from the reader. This can later be used in an offlne-attack
+               // in order to collect MAC's from the reader. This can later be used in an offline-attack

                // in order to obtain the keys, as in the "dismantling iclass"-paper.
                // in order to obtain the keys, as in the "dismantling iclass"-paper.

-               int i = 0;
-               for ( ; i < numberOfCSNS && i*8+8 < USB_CMD_DATA_SIZE; i++) {
-                       // The usb data is 512 bytes, fitting 65 8-byte CSNs in there.
+               int i;
+               for (i = 0; i < numberOfCSNS && i*16+16 <= USB_CMD_DATA_SIZE; i++) {
+                       // The usb data is 512 bytes, fitting 32 responses (8 byte CC + 4 Byte NR + 4 Byte MAC = 16 Byte response).

                        memcpy(emulator, datain+(i*8), 8);
                        memcpy(emulator, datain+(i*8), 8);

-                       if (doIClassSimulation(MODE_EXIT_AFTER_MAC,mac_responses+i*8)) {
-                               cmd_send(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i, 0, mac_responses, i*8);
-                               return; // Button pressed
+                       if (doIClassSimulation(ICLASS_SIM_MODE_EXIT_AFTER_MAC, mac_responses+i*16)) {
+                                // Button pressed
+                                break;

                        }
                }
                        }
                }

-               cmd_send(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i, 0, mac_responses, i*8);
-       } else if (simType == 3) {
+               cmd_send(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i, 0, mac_responses, i*16);
+       } else if (simType == ICLASS_SIM_MODE_FULL) {

                //This is 'full sim' mode, where we use the emulator storage for data.
                //This is 'full sim' mode, where we use the emulator storage for data.

-               doIClassSimulation(MODE_FULLSIM, NULL);
+               doIClassSimulation(ICLASS_SIM_MODE_FULL, NULL);

        } else {
                // We may want a mode here where we hardcode the csns to use (from proxclone).
                // That will speed things up a little, but not required just yet.
        } else {
                // We may want a mode here where we hardcode the csns to use (from proxclone).
                // That will speed things up a little, but not required just yet.


@@ -1683,10 +1701,10 @@ void ReaderIClass(uint8_t arg0) {
                // 0 : CSN
                // 1 : Configuration
                // 2 : e-purse
                // 0 : CSN
                // 1 : Configuration
                // 2 : e-purse

-               // (3,4 write-only, kc and kd)
-               // 5 Application issuer area
-               //
-               //Then we can 'ship' back the 8 * 6 bytes of data,
+               // 3 : kd / debit / aa2 (write-only)
+               // 4 : kc / credit / aa1 (write-only)
+               // 5 : AIA, Application issuer area
+               //Then we can 'ship' back the 6 * 8 bytes of data,

                // with 0xFF:s in block 3 and 4.
 
                LED_B_ON();
                // with 0xFF:s in block 3 and 4.
 
                LED_B_ON();

diff --git a/client/cmdhficlass.c b/client/cmdhficlass.c
index a2e3175461ac89b251a6068a90b2d0591c3d1d5d..ee0dd16eda99a1856978f6f0a220d99702050bc1 100644 (file)
--- a/client/cmdhficlass.c
+++ b/client/cmdhficlass.c
@@ -110,28 +110,20 @@ int CmdHFiClassSim(const char *Cmd) {
        }
        simType = param_get8ex(Cmd, 0, 0, 10);
 
        }
        simType = param_get8ex(Cmd, 0, 0, 10);
 

-       if(simType == 0)
-       {
+       if (simType == ICLASS_SIM_MODE_CSN) {

                if (param_gethex(Cmd, 1, CSN, 16)) {
                        PrintAndLog("A CSN should consist of 16 HEX symbols");
                        return usage_hf_iclass_sim();
                }
                if (param_gethex(Cmd, 1, CSN, 16)) {
                        PrintAndLog("A CSN should consist of 16 HEX symbols");
                        return usage_hf_iclass_sim();
                }

-

                PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
        }
                PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
        }

-       if(simType > 3)
-       {
-               PrintAndLog("Undefined simptype %d", simType);
-               return usage_hf_iclass_sim();
-       }

 
 

-       uint8_t numberOfCSNs=0;
-       if(simType == 2)
-       {
-               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,NUM_CSNS}};
+       uint8_t numberOfCSNs = 0;
+       if (simType == ICLASS_SIM_MODE_READER_ATTACK) {
+               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType, NUM_CSNS}};

                UsbCommand resp = {0};
 
                UsbCommand resp = {0};
 

-               uint8_t csns[8*NUM_CSNS] = {
+               uint8_t csns[8 * NUM_CSNS] = {

                        0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0,


@@ -148,7 +140,7 @@ int CmdHFiClassSim(const char *Cmd) {
                        0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
 
                        0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
 

-               memcpy(c.d.asBytes, csns, 8*NUM_CSNS);
+               memcpy(c.d.asBytes, csns, 8 * NUM_CSNS);

 
                SendCommand(&c);
                if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
 
                SendCommand(&c);
                if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {


@@ -157,9 +149,9 @@ int CmdHFiClassSim(const char *Cmd) {
                }
 
                uint8_t num_mac_responses  = resp.arg[1];
                }
 
                uint8_t num_mac_responses  = resp.arg[1];

-               PrintAndLog("Mac responses: %d MACs obtained (should be %d)", num_mac_responses,NUM_CSNS);
+               PrintAndLog("Mac responses: %d MACs obtained (should be %d)", num_mac_responses, NUM_CSNS);

 
 

-               size_t datalen = NUM_CSNS*24;
+               size_t datalen = NUM_CSNS * 24;

                /*
                 * Now, time to dump to file. We'll use this format:
                 * <8-byte CSN><8-byte CC><4 byte NR><4 byte MAC>....
                /*
                 * Now, time to dump to file. We'll use this format:
                 * <8-byte CSN><8-byte CC><4 byte NR><4 byte MAC>....


@@ -167,28 +159,29 @@ int CmdHFiClassSim(const char *Cmd) {
                 * 8 * 24 bytes.
                 *
                 * The returndata from the pm3 is on the following format
                 * 8 * 24 bytes.
                 *
                 * The returndata from the pm3 is on the following format

-                * <4 byte NR><4 byte MAC>
-                * CC are all zeroes, CSN is the same as was sent in
+                * <8 byte CC><4 byte NR><4 byte MAC>
+                * CSN is the same as was sent in

                 **/
                void* dump = malloc(datalen);
                 **/
                void* dump = malloc(datalen);

-               memset(dump,0,datalen);//<-- Need zeroes for the CC-field
-               uint8_t i = 0;
-               for(i = 0 ; i < NUM_CSNS ; i++)
-               {
-                       memcpy(dump+i*24, csns+i*8,8); //CSN
-                       //8 zero bytes here...
+               for(int i = 0; i < NUM_CSNS; i++) {
+                       memcpy(dump + i*24, csns+i*8, 8); //CSN
+            //copy CC from response
+            memcpy(dump + i*24 + 8, resp.d.asBytes + i*16, 8);

                        //Then comes NR_MAC (eight bytes from the response)
                        //Then comes NR_MAC (eight bytes from the response)

-                       memcpy(dump+i*24+16,resp.d.asBytes+i*8,8);
-
+                       memcpy(dump + i*24 + 16, resp.d.asBytes + i*16 + 8, 8);

                }
                /** Now, save to dumpfile **/
                saveFile("iclass_mac_attack", "bin", dump,datalen);
                free(dump);
                }
                /** Now, save to dumpfile **/
                saveFile("iclass_mac_attack", "bin", dump,datalen);
                free(dump);

-       }else
-       {
-               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,numberOfCSNs}};
+
+       } else if (simType == ICLASS_SIM_MODE_CSN || simType == ICLASS_SIM_MODE_CSN_DEFAULT) {
+               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType, numberOfCSNs}};

                memcpy(c.d.asBytes, CSN, 8);
                SendCommand(&c);
                memcpy(c.d.asBytes, CSN, 8);
                SendCommand(&c);

+
+       } else {
+               PrintAndLog("Undefined simtype %d", simType);
+               return usage_hf_iclass_sim();

        }
 
        return 0;
        }
 
        return 0;


@@ -1265,24 +1258,18 @@ int CmdHFiClass_loclass(const char *Cmd) {
                return 0;
        }
        char fileName[255] = {0};
                return 0;
        }
        char fileName[255] = {0};

-       if(opt == 'f')
-       {
-               if(param_getstr(Cmd, 1, fileName, sizeof(fileName)) > 0)
-               {
+       if(opt == 'f') {
+               if(param_getstr(Cmd, 1, fileName, sizeof(fileName)) > 0) {

                        return bruteforceFileNoKeys(fileName);
                        return bruteforceFileNoKeys(fileName);

-               }else
-               {
+               } else {

                        PrintAndLog("You must specify a filename");
                }
                        PrintAndLog("You must specify a filename");
                }

-       }
-       else if(opt == 't')
-       {
+       } else if(opt == 't') {

                int errors = testCipherUtils();
                errors += testMAC();
                errors += doKeyTests(0);
                errors += testElite();
                int errors = testCipherUtils();
                errors += testMAC();
                errors += doKeyTests(0);
                errors += testElite();

-               if(errors)
-               {
+               if(errors) {

                        prnlog("OBS! There were errors!!!");
                }
                return errors;
                        prnlog("OBS! There were errors!!!");
                }
                return errors;

diff --git a/client/loclass/cipher.c b/client/loclass/cipher.c
index 3b146b109b520fc05eec44c4d06aaffdfdee2205..03275a4f893cecd5a37d8e8603b7de7ef5d96442 100644 (file)
--- a/client/loclass/cipher.c
+++ b/client/loclass/cipher.c
@@ -240,6 +240,7 @@ void doMAC(uint8_t *cc_nr_p, uint8_t *div_key_p, uint8_t mac[4])
        //free(cc_nr);
        return;
 }
        //free(cc_nr);
        return;
 }

+

 void doMAC_N(uint8_t *address_data_p, uint8_t address_data_size, uint8_t *div_key_p, uint8_t mac[4])
 {
        uint8_t *address_data;
 void doMAC_N(uint8_t *address_data_p, uint8_t address_data_size, uint8_t *div_key_p, uint8_t mac[4])
 {
        uint8_t *address_data;

diff --git a/client/loclass/elite_crack.c b/client/loclass/elite_crack.c
index 0cd00830654438a776d75fdb7532b4d111b94d95..21a67f54c85ab26b8a604e9b89629f9385b65522 100644 (file)
--- a/client/loclass/elite_crack.c
+++ b/client/loclass/elite_crack.c
@@ -333,16 +333,14 @@ int bruteforceItem(dumpdata item, uint16_t keytable[])
         * Only the lower eight bits correspond to the (hopefully cracked) key-value.
         **/
        uint8_t bytes_to_recover[3] = {0};
         * Only the lower eight bits correspond to the (hopefully cracked) key-value.
         **/
        uint8_t bytes_to_recover[3] = {0};

-       uint8_t numbytes_to_recover = 0 ;
-       int i;
-       for(i =0 ; i < 8 ; i++)
-       {
-               if(keytable[key_index[i]] & (CRACKED | BEING_CRACKED)) continue;
+       uint8_t numbytes_to_recover = 0;
+
+       for(int i = 0; i < 8; i++) {
+               if (keytable[key_index[i]] & (CRACKED | BEING_CRACKED)) continue;

                bytes_to_recover[numbytes_to_recover++] = key_index[i];
                keytable[key_index[i]] |= BEING_CRACKED;
 
                bytes_to_recover[numbytes_to_recover++] = key_index[i];
                keytable[key_index[i]] |= BEING_CRACKED;
 

-               if(numbytes_to_recover > 3)
-               {
+               if(numbytes_to_recover > 3) {

                        prnlog("The CSN requires > 3 byte bruteforce, not supported");
                        printvar("CSN", item.csn,8);
                        printvar("HASH1", key_index,8);
                        prnlog("The CSN requires > 3 byte bruteforce, not supported");
                        printvar("CSN", item.csn,8);
                        printvar("HASH1", key_index,8);


@@ -370,15 +368,14 @@ int bruteforceItem(dumpdata item, uint16_t keytable[])
 
        uint32_t endmask =  1 << 8*numbytes_to_recover;
 
 
        uint32_t endmask =  1 << 8*numbytes_to_recover;
 

-       for(i =0 ; i < numbytes_to_recover && numbytes_to_recover > 1; i++)
+       for (int i = 0; i < numbytes_to_recover && numbytes_to_recover > 1; i++) {

                prnlog("Bruteforcing byte %d", bytes_to_recover[i]);
                prnlog("Bruteforcing byte %d", bytes_to_recover[i]);

+       }

 
 

-       while(!found && !(brute & endmask))
-       {
+       while(!found && !(brute & endmask)) {

 
                //Update the keytable with the brute-values
 
                //Update the keytable with the brute-values

-               for(i =0 ; i < numbytes_to_recover; i++)
-               {
+               for (int i = 0; i < numbytes_to_recover; i++) {

                        keytable[bytes_to_recover[i]] &= 0xFF00;
                        keytable[bytes_to_recover[i]] |= (brute >> (i*8) & 0xFF);
                }
                        keytable[bytes_to_recover[i]] &= 0xFF00;
                        keytable[bytes_to_recover[i]] |= (brute >> (i*8) & 0xFF);
                }


@@ -394,42 +391,34 @@ int bruteforceItem(dumpdata item, uint16_t keytable[])
                //Diversify
                diversifyKey(item.csn, key_sel_p, div_key);
                //Calc mac
                //Diversify
                diversifyKey(item.csn, key_sel_p, div_key);
                //Calc mac

-               doMAC(item.cc_nr, div_key,calculated_MAC);
+               doMAC(item.cc_nr, div_key, calculated_MAC);

 
 

-               if(memcmp(calculated_MAC, item.mac, 4) == 0)
-               {
-                       for(i =0 ; i < numbytes_to_recover; i++)
-                               prnlog("=> %d: 0x%02x", bytes_to_recover[i],0xFF & keytable[bytes_to_recover[i]]);
+               if (memcmp(calculated_MAC, item.mac, 4) == 0) {
+                       for (int i =0 ; i < numbytes_to_recover; i++)
+                               prnlog("=> %d: 0x%02x", bytes_to_recover[i], 0xFF & keytable[bytes_to_recover[i]]);

                        found = true;
                        break;
                }
                brute++;
                        found = true;
                        break;
                }
                brute++;

-               if((brute & 0xFFFF) == 0)
-               {
+               if ((brute & 0xFFFF) == 0) {

                        printf("%d",(brute >> 16) & 0xFF);
                        fflush(stdout);
                }
        }
                        printf("%d",(brute >> 16) & 0xFF);
                        fflush(stdout);
                }
        }

-       if(! found)
-       {
+       if (! found) {

                prnlog("Failed to recover %d bytes using the following CSN",numbytes_to_recover);
                printvar("CSN",item.csn,8);
                errors++;
                //Before we exit, reset the 'BEING_CRACKED' to zero
                prnlog("Failed to recover %d bytes using the following CSN",numbytes_to_recover);
                printvar("CSN",item.csn,8);
                errors++;
                //Before we exit, reset the 'BEING_CRACKED' to zero

-               for(i =0 ; i < numbytes_to_recover; i++)
-               {
+               for (int i = 0; i < numbytes_to_recover; i++) {

                        keytable[bytes_to_recover[i]]  &= 0xFF;
                        keytable[bytes_to_recover[i]]  |= CRACK_FAILED;
                }
                        keytable[bytes_to_recover[i]]  &= 0xFF;
                        keytable[bytes_to_recover[i]]  |= CRACK_FAILED;
                }

-
-       }else
-       {
-               for(i =0 ; i < numbytes_to_recover; i++)
-               {
+       } else {
+               for (int i = 0 ;i < numbytes_to_recover; i++) {

                        keytable[bytes_to_recover[i]]  &= 0xFF;
                        keytable[bytes_to_recover[i]]  |= CRACKED;
                }
                        keytable[bytes_to_recover[i]]  &= 0xFF;
                        keytable[bytes_to_recover[i]]  |= CRACKED;
                }

-

        }
        return errors;
 }
        }
        return errors;
 }


@@ -516,7 +505,7 @@ int bruteforceDump(uint8_t dump[], size_t dumpsize, uint16_t keytable[])
 
        dumpdata* attack = (dumpdata* ) malloc(itemsize);
 
 
        dumpdata* attack = (dumpdata* ) malloc(itemsize);
 

-       for(i = 0 ; i * itemsize < dumpsize ; i++ )
+       for (i = 0 ; i * itemsize < dumpsize ; i++ )

        {
                memcpy(attack,dump+i*itemsize, itemsize);
                errors += bruteforceItem(*attack, keytable);
        {
                memcpy(attack,dump+i*itemsize, itemsize);
                errors += bruteforceItem(*attack, keytable);

diff --git a/include/usb_cmd.h b/include/usb_cmd.h
index 1bc5e5ba72ab151ed13d0bdc7f6ae0f571058258..934b0924030aacf8208e12fa05ed9e649fafe133 100644 (file)
--- a/include/usb_cmd.h
+++ b/include/usb_cmd.h
@@ -228,7 +228,7 @@ typedef struct{
 #define CMD_UNKNOWN                                                       0xFFFF
 
 
 #define CMD_UNKNOWN                                                       0xFFFF
 
 

-//Mifare simulation flags
+// Mifare simulation flags

 #define FLAG_INTERACTIVE                (1<<0)
 #define FLAG_4B_UID_IN_DATA             (1<<1)
 #define FLAG_7B_UID_IN_DATA             (1<<2)
 #define FLAG_INTERACTIVE                (1<<0)
 #define FLAG_4B_UID_IN_DATA             (1<<1)
 #define FLAG_7B_UID_IN_DATA             (1<<2)


@@ -236,7 +236,7 @@ typedef struct{
 #define FLAG_RANDOM_NONCE               (1<<5)
 
 
 #define FLAG_RANDOM_NONCE               (1<<5)
 
 

-//Iclass reader flags
+// iCLASS reader flags

 #define FLAG_ICLASS_READER_ONLY_ONCE    0x01
 #define FLAG_ICLASS_READER_CC           0x02
 #define FLAG_ICLASS_READER_CSN          0x04
 #define FLAG_ICLASS_READER_ONLY_ONCE    0x01
 #define FLAG_ICLASS_READER_CC           0x02
 #define FLAG_ICLASS_READER_CSN          0x04


@@ -245,8 +245,16 @@ typedef struct{
 #define FLAG_ICLASS_READER_ONE_TRY      0x20
 #define FLAG_ICLASS_READER_CEDITKEY     0x40
 
 #define FLAG_ICLASS_READER_ONE_TRY      0x20
 #define FLAG_ICLASS_READER_CEDITKEY     0x40
 

+// iCLASS simulation modes
+#define ICLASS_SIM_MODE_CSN                   0
+#define ICLASS_SIM_MODE_CSN_DEFAULT           1
+#define ICLASS_SIM_MODE_READER_ATTACK         2
+#define ICLASS_SIM_MODE_FULL                  3
+#define ICLASS_SIM_MODE_READER_ATTACK_KEYROLL 4
+#define ICLASS_SIM_MODE_EXIT_AFTER_MAC        5  // note: device internal only

 
 

-//hw tune args
+
+// hw tune args

 #define FLAG_TUNE_LF   1
 #define FLAG_TUNE_HF   2
 #define FLAG_TUNE_ALL  3
 #define FLAG_TUNE_LF   1
 #define FLAG_TUNE_HF   2
 #define FLAG_TUNE_ALL  3