git.zerfleddert.de Git - proxmark3-svn/blobdiff

#include "fpgaloader.h"

#include "proxmark3.h"

#include "usb_cdc.h"

#include "fpgaloader.h"

#include "proxmark3.h"

#include "usb_cdc.h"

-#include "cmd.h"

#include "protocols.h"

#include "apps.h"

//mifare emulator states

#include "protocols.h"

#include "apps.h"

//mifare emulator states

-#define MFEMUL_NOFIELD 0

-#define MFEMUL_IDLE 1

-#define MFEMUL_SELECT1 2

-#define MFEMUL_SELECT2 3

-#define MFEMUL_SELECT3 4

-#define MFEMUL_AUTH1 5

-#define MFEMUL_AUTH2 6

-#define MFEMUL_WORK 7

-#define MFEMUL_WRITEBL2 8

-#define MFEMUL_INTREG_INC 9

-#define MFEMUL_INTREG_DEC 10

-#define MFEMUL_INTREG_REST 11

-#define MFEMUL_HALTED 12

-

-#define cardSTATE_TO_IDLE() { cardSTATE = MFEMUL_IDLE; LED_B_OFF(); LED_C_OFF(); }

+#define MFEMUL_NOFIELD 0

+#define MFEMUL_IDLE 1

+#define MFEMUL_SELECT1 2

+#define MFEMUL_SELECT2 3

+#define MFEMUL_SELECT3 4

+#define MFEMUL_AUTH1 5

+#define MFEMUL_AUTH2 6

+#define MFEMUL_WORK 7

+#define MFEMUL_WRITEBL2 8

+#define MFEMUL_INTREG_INC 9

+#define MFEMUL_INTREG_DEC 10

+#define MFEMUL_INTREG_REST 11

+#define MFEMUL_HALTED 12

#define AC_DATA_READ 0

#define AC_DATA_WRITE 1

#define AC_DATA_READ 0

#define AC_DATA_WRITE 1

-#define AC_DATA_INC 2

-#define AC_DATA_DEC_TRANS_REST 3

+#define AC_DATA_INC 2

+#define AC_DATA_DEC_TRANS_REST 3

#define AC_KEYA_READ 0

#define AC_KEYA_WRITE 1

#define AC_KEYB_READ 2

#define AC_KEYA_READ 0

#define AC_KEYA_WRITE 1

#define AC_KEYB_READ 2

#define AUTHKEYNONE 0xff

+static int ParamCardSizeBlocks(const char c) {

+ int numBlocks = 16 * 4;

+ switch (c) {

+ case '0' : numBlocks = 5 * 4; break;

+ case '2' : numBlocks = 32 * 4; break;

+ case '4' : numBlocks = 32 * 4 + 8 * 16; break;

+ default: numBlocks = 16 * 4;

+ }

+ return numBlocks;

+}

+

+static uint8_t BlockToSector(int block_num) {

+ if (block_num < 32 * 4) { // 4 blocks per sector

+ return (block_num / 4);

+ } else { // 16 blocks per sector

+ return 32 + (block_num - 32 * 4) / 16;

+ }

+}

+

static bool IsTrailerAccessAllowed(uint8_t blockNo, uint8_t keytype, uint8_t action) {

uint8_t sector_trailer[16];

emlGetMem(sector_trailer, blockNo, 1);

uint8_t AC = ((sector_trailer[7] >> 5) & 0x04)

static bool IsTrailerAccessAllowed(uint8_t blockNo, uint8_t keytype, uint8_t action) {

uint8_t sector_trailer[16];

emlGetMem(sector_trailer, blockNo, 1);

uint8_t AC = ((sector_trailer[7] >> 5) & 0x04)

- | ((sector_trailer[8] >> 2) & 0x02)

+ | ((sector_trailer[8] >> 2) & 0x02)

| ((sector_trailer[8] >> 7) & 0x01);

switch (action) {

case AC_KEYA_READ: {

| ((sector_trailer[8] >> 7) & 0x01);

switch (action) {

case AC_KEYA_READ: {

break;

}

case AC_KEYA_WRITE: {

break;

}

case AC_KEYA_WRITE: {

- return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x01))

- || (keytype == AUTHKEYB && (AC == 0x04 || AC == 0x03)));

+ return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x01))

+ || (keytype == AUTHKEYB && (AC == 0x04 || AC == 0x03)));

break;

}

case AC_KEYB_READ: {

break;

}

case AC_KEYB_READ: {

break;

}

case AC_KEYB_WRITE: {

break;

}

case AC_KEYB_WRITE: {

- return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x04))

- || (keytype == AUTHKEYB && (AC == 0x04 || AC == 0x03)));

+ return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x01))

+ || (keytype == AUTHKEYB && (AC == 0x04 || AC == 0x03)));

break;

}

case AC_AC_READ: {

return ((keytype == AUTHKEYA)

break;

}

case AC_AC_READ: {

return ((keytype == AUTHKEYA)

- || (keytype == AUTHKEYB && !(AC == 0x00 || AC == 0x02 || AC == 0x01)));

+ || (keytype == AUTHKEYB && !(AC == 0x00 || AC == 0x02 || AC == 0x01)));

break;

}

case AC_AC_WRITE: {

return ((keytype == AUTHKEYA && (AC == 0x01))

break;

}

case AC_AC_WRITE: {

return ((keytype == AUTHKEYA && (AC == 0x01))

- || (keytype == AUTHKEYB && (AC == 0x03 || AC == 0x05)));

+ || (keytype == AUTHKEYB && (AC == 0x03 || AC == 0x05)));

break;

}

default: return false;

break;

}

default: return false;

| ((sector_trailer[8] >> 6) & 0x01);

break;

}

| ((sector_trailer[8] >> 6) & 0x01);

break;

}

- default:

+ default:

return false;

}

return false;

}

-

+

switch (action) {

case AC_DATA_READ: {

return ((keytype == AUTHKEYA && !(AC == 0x03 || AC == 0x05 || AC == 0x07))

switch (action) {

case AC_DATA_READ: {

return ((keytype == AUTHKEYA && !(AC == 0x03 || AC == 0x05 || AC == 0x07))

- || (keytype == AUTHKEYB && !(AC == 0x07)));

+ || (keytype == AUTHKEYB && !(AC == 0x07)));

break;

}

case AC_DATA_WRITE: {

return ((keytype == AUTHKEYA && (AC == 0x00))

break;

}

case AC_DATA_WRITE: {

return ((keytype == AUTHKEYA && (AC == 0x00))

- || (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x04 || AC == 0x06 || AC == 0x03)));

+ || (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x04 || AC == 0x06 || AC == 0x03)));

break;

}

case AC_DATA_INC: {

return ((keytype == AUTHKEYA && (AC == 0x00))

break;

}

case AC_DATA_INC: {

return ((keytype == AUTHKEYA && (AC == 0x00))

- || (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x06)));

+ || (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x06)));

break;

}

case AC_DATA_DEC_TRANS_REST: {

return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x06 || AC == 0x01))

break;

}

case AC_DATA_DEC_TRANS_REST: {

return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x06 || AC == 0x01))

- || (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x06 || AC == 0x01)));

+ || (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x06 || AC == 0x01)));

break;

}

break;

}

-

+

return false;

}

return false;

}

-static void MifareSimInit(uint8_t flags, uint8_t *datain, tag_response_info_t **responses, uint32_t *cuid, uint8_t *uid_len) {

+static void MifareSimInit(uint8_t flags, uint8_t *datain, tag_response_info_t **responses, uint32_t *cuid, uint8_t *uid_len, uint8_t cardsize) {

- #define TAG_RESPONSE_COUNT 5 // number of precompiled responses

- static uint8_t rATQA[] = {0x04, 0x00}; // indicate Mifare classic 1k 4Byte UID

- static uint8_t rUIDBCC1[] = {0x00, 0x00, 0x00, 0x00, 0x00}; // UID 1st cascade level

- static uint8_t rUIDBCC2[] = {0x00, 0x00, 0x00, 0x00, 0x00}; // UID 2nd cascade level

- static uint8_t rSAKfinal[]= {0x08, 0xb6, 0xdd}; // mifare 1k indicated

- static uint8_t rSAK1[] = {0x04, 0xda, 0x17}; // indicate UID not finished

+ #define TAG_RESPONSE_COUNT 5 // number of precompiled responses

+ static uint8_t rATQA[] = {0x00, 0x00};

+ static uint8_t rUIDBCC1[] = {0x00, 0x00, 0x00, 0x00, 0x00}; // UID 1st cascade level

+ static uint8_t rUIDBCC2[] = {0x00, 0x00, 0x00, 0x00, 0x00}; // UID 2nd cascade level

+ static uint8_t rSAKfinal[]= {0x00, 0x00, 0x00}; // SAK after UID complete

+ static uint8_t rSAK1[] = {0x00, 0x00, 0x00}; // indicate UID not finished

*uid_len = 4;

// UID can be set from emulator memory or incoming data and can be 4 or 7 bytes long

*uid_len = 4;

// UID can be set from emulator memory or incoming data and can be 4 or 7 bytes long

- if (flags & FLAG_4B_UID_IN_DATA) { // get UID from datain

+ if (flags & FLAG_4B_UID_IN_DATA) { // get UID from datain

memcpy(rUIDBCC1, datain, 4);

} else if (flags & FLAG_7B_UID_IN_DATA) {

rUIDBCC1[0] = 0x88;

memcpy(rUIDBCC1, datain, 4);

} else if (flags & FLAG_7B_UID_IN_DATA) {

rUIDBCC1[0] = 0x88;

*uid_len = 7;

} else {

uint8_t probable_atqa;

*uid_len = 7;

} else {

uint8_t probable_atqa;

- emlGetMemBt(&probable_atqa, 7, 1); // get UID from emul memory - weak guess at length

- if (probable_atqa == 0x00) { // ---------- 4BUID

+ emlGetMemBt(&probable_atqa, 7, 1); // get UID from emul memory - weak guess at length

+ if (probable_atqa == 0x00) { // ---------- 4BUID

emlGetMemBt(rUIDBCC1, 0, 4);

- } else { // ---------- 7BUID

+ } else { // ---------- 7BUID

rUIDBCC1[0] = 0x88;

emlGetMemBt(rUIDBCC1+1, 0, 3);

emlGetMemBt(rUIDBCC2, 3, 4);

rUIDBCC1[0] = 0x88;

emlGetMemBt(rUIDBCC1+1, 0, 3);

emlGetMemBt(rUIDBCC2, 3, 4);

case 4:

*cuid = bytes_to_num(rUIDBCC1, 4);

rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];

case 4:

*cuid = bytes_to_num(rUIDBCC1, 4);

rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];

- if (MF_DBGLEVEL >= 2) {

- Dbprintf("4B UID: %02x%02x%02x%02x",

- rUIDBCC1[0], rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3] );

+ if (MF_DBGLEVEL >= MF_DBG_INFO) {

+ Dbprintf("4B UID: %02x%02x%02x%02x",

+ rUIDBCC1[0], rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3] );

}

break;

case 7:

}

break;

case 7:

- rATQA[0] |= 0x40;

*cuid = bytes_to_num(rUIDBCC2, 4);

- rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];

- rUIDBCC2[4] = rUIDBCC2[0] ^ rUIDBCC2[1] ^ rUIDBCC2[2] ^ rUIDBCC2[3];

- if (MF_DBGLEVEL >= 2) {

+ rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];

+ rUIDBCC2[4] = rUIDBCC2[0] ^ rUIDBCC2[1] ^ rUIDBCC2[2] ^ rUIDBCC2[3];

+ if (MF_DBGLEVEL >= MF_DBG_INFO) {

Dbprintf("7B UID: %02x %02x %02x %02x %02x %02x %02x",

rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3], rUIDBCC2[0], rUIDBCC2[1], rUIDBCC2[2], rUIDBCC2[3] );

}

break;

Dbprintf("7B UID: %02x %02x %02x %02x %02x %02x %02x",

rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3], rUIDBCC2[0], rUIDBCC2[1], rUIDBCC2[2], rUIDBCC2[3] );

}

break;

- default:

+ default:

break;

}

break;

}

-

+

+ // set SAK based on cardsize

+ switch (cardsize) {

+ case '0': rSAKfinal[0] = 0x09; break; // Mifare Mini

+ case '2': rSAKfinal[0] = 0x10; break; // Mifare 2K

+ case '4': rSAKfinal[0] = 0x18; break; // Mifare 4K

+ default: rSAKfinal[0] = 0x08; // Mifare 1K

+ }

+ ComputeCrc14443(CRC_14443_A, rSAKfinal, 1, rSAKfinal + 1, rSAKfinal + 2);

+ if (MF_DBGLEVEL >= MF_DBG_INFO) {

+ Dbprintf("SAK: %02x", rSAKfinal[0]);

+ }

+

+ // set SAK for incomplete UID

+ rSAK1[0] = 0x04; // Bit 3 indicates incomplete UID

+ ComputeCrc14443(CRC_14443_A, rSAK1, 1, rSAK1 + 1, rSAK1 + 2);

+

+ // set ATQA based on cardsize and UIDlen

+ if (cardsize == '4') {

+ rATQA[0] = 0x02;

+ } else {

+ rATQA[0] = 0x04;

+ }

+ if (*uid_len == 7) {

+ rATQA[0] |= 0x40;

+ }

+ if (MF_DBGLEVEL >= MF_DBG_INFO) {

+ Dbprintf("ATQA: %02x %02x", rATQA[1], rATQA[0]);

+ }

+

static tag_response_info_t responses_init[TAG_RESPONSE_COUNT] = {

- { .response = rATQA, .response_n = sizeof(rATQA) }, // Answer to request - respond with card type

- { .response = rUIDBCC1, .response_n = sizeof(rUIDBCC1) }, // Anticollision cascade1 - respond with first part of uid

- { .response = rUIDBCC2, .response_n = sizeof(rUIDBCC2) }, // Anticollision cascade2 - respond with 2nd part of uid

- { .response = rSAKfinal, .response_n = sizeof(rSAKfinal) }, // Acknowledge select - last cascade

- { .response = rSAK1, .response_n = sizeof(rSAK1) } // Acknowledge select - previous cascades

+ { .response = rATQA, .response_n = sizeof(rATQA) }, // Answer to request - respond with card type

+ { .response = rUIDBCC1, .response_n = sizeof(rUIDBCC1) }, // Anticollision cascade1 - respond with first part of uid

+ { .response = rUIDBCC2, .response_n = sizeof(rUIDBCC2) }, // Anticollision cascade2 - respond with 2nd part of uid

+ { .response = rSAKfinal, .response_n = sizeof(rSAKfinal) }, // Acknowledge select - last cascade

+ { .response = rSAK1, .response_n = sizeof(rSAK1) } // Acknowledge select - previous cascades

};

// Prepare ("precompile") the responses of the anticollision phase. There will be not enough time to do this at the moment the reader sends its REQA or SELECT

};

// Prepare ("precompile") the responses of the anticollision phase. There will be not enough time to do this at the moment the reader sends its REQA or SELECT

- // There are 7 predefined responses with a total of 18 bytes data to transmit. Coded responses need one byte per bit to transfer (data, parity, start, stop, correction)

+ // There are 5 predefined responses with a total of 18 bytes data to transmit. Coded responses need one byte per bit to transfer (data, parity, start, stop, correction)

// 18 * 8 data bits, 18 * 1 parity bits, 5 start bits, 5 stop bits, 5 correction bits -> need 177 bytes buffer

- #define ALLOCATED_TAG_MODULATION_BUFFER_SIZE 177 // number of bytes required for precompiled responses

+ #define ALLOCATED_TAG_MODULATION_BUFFER_SIZE 177 // number of bytes required for precompiled responses

uint8_t *free_buffer_pointer = BigBuf_malloc(ALLOCATED_TAG_MODULATION_BUFFER_SIZE);

size_t free_buffer_size = ALLOCATED_TAG_MODULATION_BUFFER_SIZE;

uint8_t *free_buffer_pointer = BigBuf_malloc(ALLOCATED_TAG_MODULATION_BUFFER_SIZE);

size_t free_buffer_size = ALLOCATED_TAG_MODULATION_BUFFER_SIZE;

/**

- *MIFARE 1K simulate.

+ *MIFARE simulate.

*

*@param flags :

*

*@param flags :

- * FLAG_INTERACTIVE - In interactive mode, we are expected to finish the operation with an ACK

+ * FLAG_INTERACTIVE - In interactive mode, we are expected to finish the operation with an ACK

* FLAG_4B_UID_IN_DATA - means that there is a 4-byte UID in the data-section, we're expected to use that

* FLAG_7B_UID_IN_DATA - means that there is a 7-byte UID in the data-section, we're expected to use that

* FLAG_4B_UID_IN_DATA - means that there is a 4-byte UID in the data-section, we're expected to use that

* FLAG_7B_UID_IN_DATA - means that there is a 7-byte UID in the data-section, we're expected to use that

- * FLAG_10B_UID_IN_DATA - use 10-byte UID in the data-section not finished

- * FLAG_NR_AR_ATTACK - means we should collect NR_AR responses for bruteforcing later

+ * FLAG_NR_AR_ATTACK - means we should collect NR_AR responses for bruteforcing later

* FLAG_RANDOM_NONCE - means we should generate some pseudo-random nonce data (only allows moebius attack)

*@param exitAfterNReads, exit simulation after n blocks have been read, 0 is infinite ...

* (unless reader attack mode enabled then it runs util it gets enough nonces to recover all keys attmpted)

*/

* FLAG_RANDOM_NONCE - means we should generate some pseudo-random nonce data (only allows moebius attack)

*@param exitAfterNReads, exit simulation after n blocks have been read, 0 is infinite ...

* (unless reader attack mode enabled then it runs util it gets enough nonces to recover all keys attmpted)

*/

-void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *datain)

+void MifareSim(uint8_t flags, uint8_t exitAfterNReads, uint8_t cardsize, uint8_t *datain)

{

+ LED_A_ON();

+

tag_response_info_t *responses;

- uint8_t uid_len = 4;

+ uint8_t uid_len = 4;

uint32_t cuid = 0;

uint8_t cardWRBL = 0;

uint8_t cardAUTHSC = 0;

uint32_t cuid = 0;

uint8_t cardWRBL = 0;

uint8_t cardAUTHSC = 0;

uint32_t cardINTREG = 0;

uint8_t cardINTBLOCK = 0;

struct Crypto1State mpcs = {0, 0};

uint32_t cardINTREG = 0;

uint8_t cardINTBLOCK = 0;

struct Crypto1State mpcs = {0, 0};

- struct Crypto1State *pcs;

- pcs = &mpcs;

- uint32_t numReads = 0;//Counts numer of times reader reads a block

+ struct Crypto1State *pcs = &mpcs;

+ uint32_t numReads = 0; //Counts numer of times reader reads a block

uint8_t receivedCmd[MAX_MIFARE_FRAME_SIZE];

uint8_t receivedCmd_dec[MAX_MIFARE_FRAME_SIZE];

uint8_t receivedCmd_par[MAX_MIFARE_PARITY_SIZE];

uint16_t receivedCmd_len;

uint8_t response[MAX_MIFARE_FRAME_SIZE];

uint8_t response_par[MAX_MIFARE_PARITY_SIZE];

uint8_t receivedCmd[MAX_MIFARE_FRAME_SIZE];

uint8_t receivedCmd_dec[MAX_MIFARE_FRAME_SIZE];

uint8_t receivedCmd_par[MAX_MIFARE_PARITY_SIZE];

uint16_t receivedCmd_len;

uint8_t response[MAX_MIFARE_FRAME_SIZE];

uint8_t response_par[MAX_MIFARE_PARITY_SIZE];

-

- uint8_t rAUTH_NT[] = {0x01, 0x02, 0x03, 0x04};

- uint8_t rAUTH_AT[] = {0x00, 0x00, 0x00, 0x00};

-

- //Here, we collect UID,sector,keytype,NT,AR,NR,NT2,AR2,NR2

+ uint8_t fixed_nonce[] = {0x01, 0x02, 0x03, 0x04};

+

+ int num_blocks = ParamCardSizeBlocks(cardsize);

+

+ // Here we collect UID, sector, keytype, NT, AR, NR, NT2, AR2, NR2

// This will be used in the reader-only attack.

- //allow collecting up to 7 sets of nonces to allow recovery of up to 7 keys

+ // allow collecting up to 7 sets of nonces to allow recovery of up to 7 keys

#define ATTACK_KEY_COUNT 7 // keep same as define in cmdhfmf.c -> readerAttack() (Cannot be more than 7)

- nonces_t ar_nr_resp[ATTACK_KEY_COUNT*2]; //*2 for 2 separate attack types (nml, moebius) 36 * 7 * 2 bytes = 504 bytes

+ nonces_t ar_nr_resp[ATTACK_KEY_COUNT*2]; // *2 for 2 separate attack types (nml, moebius) 36 * 7 * 2 bytes = 504 bytes

memset(ar_nr_resp, 0x00, sizeof(ar_nr_resp));

- uint8_t ar_nr_collected[ATTACK_KEY_COUNT*2]; //*2 for 2nd attack type (moebius)

+ uint8_t ar_nr_collected[ATTACK_KEY_COUNT*2]; // *2 for 2nd attack type (moebius)

memset(ar_nr_collected, 0x00, sizeof(ar_nr_collected));

- uint8_t nonce1_count = 0;

- uint8_t nonce2_count = 0;

- uint8_t moebius_n_count = 0;

+ uint8_t nonce1_count = 0;

+ uint8_t nonce2_count = 0;

+ uint8_t moebius_n_count = 0;

bool gettingMoebius = false;

- uint8_t mM = 0; //moebius_modifier for collection storage

+ uint8_t mM = 0; // moebius_modifier for collection storage

// Authenticate response - nonce

uint32_t nonce;

if (flags & FLAG_RANDOM_NONCE) {

nonce = prand();

} else {

// Authenticate response - nonce

uint32_t nonce;

if (flags & FLAG_RANDOM_NONCE) {

nonce = prand();

} else {

- nonce = bytes_to_num(rAUTH_NT, 4);

+ nonce = bytes_to_num(fixed_nonce, 4);

}

// free eventually allocated BigBuf memory but keep Emulator Memory

BigBuf_free_keep_EM();

}

// free eventually allocated BigBuf memory but keep Emulator Memory

BigBuf_free_keep_EM();

- MifareSimInit(flags, datain, &responses, &cuid, &uid_len);

-

+ MifareSimInit(flags, datain, &responses, &cuid, &uid_len, cardsize);

+

// We need to listen to the high-frequency, peak-detected path.

iso14443a_setup(FPGA_HF_ISO14443A_TAGSIM_LISTEN);

// We need to listen to the high-frequency, peak-detected path.

iso14443a_setup(FPGA_HF_ISO14443A_TAGSIM_LISTEN);

clear_trace();

set_tracing(true);

ResetSspClk();

clear_trace();

set_tracing(true);

ResetSspClk();

-

+

bool finished = false;

bool button_pushed = BUTTON_PRESS();

int cardSTATE = MFEMUL_NOFIELD;

bool finished = false;

bool button_pushed = BUTTON_PRESS();

int cardSTATE = MFEMUL_NOFIELD;

while (!button_pushed && !finished && !usb_poll_validate_length()) {

WDT_HIT();

while (!button_pushed && !finished && !usb_poll_validate_length()) {

WDT_HIT();

- // find reader field

if (cardSTATE == MFEMUL_NOFIELD) {

- int vHf = (MAX_ADC_HF_VOLTAGE * AvgAdc(ADC_CHAN_HF)) >> 10;

+ // wait for reader HF field

+ int vHf = (MAX_ADC_HF_VOLTAGE_LOW * AvgAdc(ADC_CHAN_HF_LOW)) >> 10;

if (vHf > MF_MINFIELDV) {

- LED_A_ON();

- cardSTATE_TO_IDLE();

+ LED_D_ON();

+ cardSTATE = MFEMUL_IDLE;

}

button_pushed = BUTTON_PRESS();

continue;

}

//Now, get data

}

button_pushed = BUTTON_PRESS();

continue;

}

//Now, get data

+ FpgaEnableTracing();

int res = EmGetCmd(receivedCmd, &receivedCmd_len, receivedCmd_par);

-

- if (res == 2) { //Field is off!

- LEDsoff();

+

+ if (res == 2) { // Reader has dropped the HF field. Power off.

+ FpgaDisableTracing();

+ LED_D_OFF();

cardSTATE = MFEMUL_NOFIELD;

continue;

} else if (res == 1) { // button pressed

cardSTATE = MFEMUL_NOFIELD;

continue;

} else if (res == 1) { // button pressed

+ FpgaDisableTracing();

button_pushed = true;

break;

}

button_pushed = true;

break;

}

// WUPA in HALTED state or REQA or WUPA in any other state

if (receivedCmd_len == 1 && ((receivedCmd[0] == ISO14443A_CMD_REQA && cardSTATE != MFEMUL_HALTED) || receivedCmd[0] == ISO14443A_CMD_WUPA)) {

EmSendPrecompiledCmd(&responses[ATQA]);

// WUPA in HALTED state or REQA or WUPA in any other state

if (receivedCmd_len == 1 && ((receivedCmd[0] == ISO14443A_CMD_REQA && cardSTATE != MFEMUL_HALTED) || receivedCmd[0] == ISO14443A_CMD_WUPA)) {

EmSendPrecompiledCmd(&responses[ATQA]);

+ FpgaDisableTracing();

// init crypto block

crypto1_destroy(pcs);

// init crypto block

crypto1_destroy(pcs);

if (flags & FLAG_RANDOM_NONCE) {

nonce = prand();

}

if (flags & FLAG_RANDOM_NONCE) {

nonce = prand();

}

- LED_B_OFF();

- LED_C_OFF();

cardSTATE = MFEMUL_SELECT1;

continue;

}

cardSTATE = MFEMUL_SELECT1;

continue;

}

-

+

switch (cardSTATE) {

case MFEMUL_NOFIELD:

case MFEMUL_HALTED:

case MFEMUL_IDLE:{

break;

}

switch (cardSTATE) {

case MFEMUL_NOFIELD:

case MFEMUL_HALTED:

case MFEMUL_IDLE:{

break;

}

+

case MFEMUL_SELECT1:{

// select all - 0x93 0x20

if (receivedCmd_len == 2 && (receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && receivedCmd[1] == 0x20)) {

case MFEMUL_SELECT1:{

// select all - 0x93 0x20

if (receivedCmd_len == 2 && (receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && receivedCmd[1] == 0x20)) {

- if (MF_DBGLEVEL >= 4) Dbprintf("SELECT ALL CL1 received");

EmSendPrecompiledCmd(&responses[UIDBCC1]);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("SELECT ALL CL1 received");

break;

}

// select card - 0x93 0x70 ...

if (receivedCmd_len == 9 &&

(receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], responses[UIDBCC1].response, 4) == 0)) {

break;

}

// select card - 0x93 0x70 ...

if (receivedCmd_len == 9 &&

(receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], responses[UIDBCC1].response, 4) == 0)) {

- if (MF_DBGLEVEL >= 4) Dbprintf("SELECT CL1 %02x%02x%02x%02x received",receivedCmd[2],receivedCmd[3],receivedCmd[4],receivedCmd[5]);

if (uid_len == 4) {

EmSendPrecompiledCmd(&responses[SAKfinal]);

if (uid_len == 4) {

EmSendPrecompiledCmd(&responses[SAKfinal]);

- LED_B_ON();

cardSTATE = MFEMUL_WORK;

- break;

} else if (uid_len == 7) {

EmSendPrecompiledCmd(&responses[SAK1]);

} else if (uid_len == 7) {

EmSendPrecompiledCmd(&responses[SAK1]);

- cardSTATE = MFEMUL_SELECT2;

- break;

+ cardSTATE = MFEMUL_SELECT2;

}

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("SELECT CL1 %02x%02x%02x%02x received",receivedCmd[2],receivedCmd[3],receivedCmd[4],receivedCmd[5]);

+ break;

}

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

+

case MFEMUL_SELECT2:{

// select all cl2 - 0x95 0x20

if (receivedCmd_len == 2 && (receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && receivedCmd[1] == 0x20)) {

case MFEMUL_SELECT2:{

// select all cl2 - 0x95 0x20

if (receivedCmd_len == 2 && (receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && receivedCmd[1] == 0x20)) {

- if (MF_DBGLEVEL >= 4) Dbprintf("SELECT ALL CL2 received");

EmSendPrecompiledCmd(&responses[UIDBCC2]);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("SELECT ALL CL2 received");

break;

}

// select cl2 card - 0x95 0x70 xxxxxxxxxxxx

break;

}

// select cl2 card - 0x95 0x70 xxxxxxxxxxxx

- if (receivedCmd_len == 9 &&

+ if (receivedCmd_len == 9 &&

(receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], responses[UIDBCC2].response, 4) == 0)) {

if (uid_len == 7) {

(receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], responses[UIDBCC2].response, 4) == 0)) {

if (uid_len == 7) {

- if (MF_DBGLEVEL >= 4) Dbprintf("SELECT CL2 %02x%02x%02x%02x received",receivedCmd[2],receivedCmd[3],receivedCmd[4],receivedCmd[5]);

EmSendPrecompiledCmd(&responses[SAKfinal]);

- LED_B_ON();

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("SELECT CL2 %02x%02x%02x%02x received",receivedCmd[2],receivedCmd[3],receivedCmd[4],receivedCmd[5]);

cardSTATE = MFEMUL_WORK;

break;

}

cardSTATE = MFEMUL_WORK;

break;

}

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

+

case MFEMUL_WORK:{

- if (receivedCmd_len != 4) { // all commands must have exactly 4 bytes

+ if (receivedCmd_len != 4) { // all commands must have exactly 4 bytes

break;

}

bool encrypted_data = (cardAUTHKEY != AUTHKEYNONE) ;

break;

}

bool encrypted_data = (cardAUTHKEY != AUTHKEYNONE) ;

memcpy(receivedCmd_dec, receivedCmd, receivedCmd_len);

}

if (!HasValidCRC(receivedCmd_dec, receivedCmd_len)) { // all commands must have a valid CRC

memcpy(receivedCmd_dec, receivedCmd, receivedCmd_len);

}

if (!HasValidCRC(receivedCmd_dec, receivedCmd_len)) { // all commands must have a valid CRC

- EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

+ EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_TR));

break;

}

break;

}

+

if (receivedCmd_dec[0] == MIFARE_AUTH_KEYA || receivedCmd_dec[0] == MIFARE_AUTH_KEYB) {

// if authenticating to a block that shouldn't exist - as long as we are not doing the reader attack

if (receivedCmd_dec[0] == MIFARE_AUTH_KEYA || receivedCmd_dec[0] == MIFARE_AUTH_KEYB) {

// if authenticating to a block that shouldn't exist - as long as we are not doing the reader attack

- if (receivedCmd_dec[1] >= 16 * 4 && !(flags & FLAG_NR_AR_ATTACK)) {

+ if (receivedCmd_dec[1] >= num_blocks && !(flags & FLAG_NR_AR_ATTACK)) {

//is this the correct response to an auth on a out of range block? marshmellow

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

//is this the correct response to an auth on a out of range block? marshmellow

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

- if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate (0x%02x) on out of range block: %d (0x%02x), nacking",receivedCmd_dec[0],receivedCmd_dec[1],receivedCmd_dec[1]);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Reader tried to operate (0x%02x) on out of range block: %d (0x%02x), nacking", receivedCmd_dec[0], receivedCmd_dec[1], receivedCmd_dec[1]);

break;

}

break;

}

- cardAUTHSC = receivedCmd_dec[1] / 4; // received block num

+ cardAUTHSC = BlockToSector(receivedCmd_dec[1]); // received block num

cardAUTHKEY = receivedCmd_dec[0] & 0x01;

crypto1_destroy(pcs);//Added by martin

crypto1_create(pcs, emlGetKey(cardAUTHSC, cardAUTHKEY));

if (!encrypted_data) { // first authentication

cardAUTHKEY = receivedCmd_dec[0] & 0x01;

crypto1_destroy(pcs);//Added by martin

crypto1_create(pcs, emlGetKey(cardAUTHSC, cardAUTHKEY));

if (!encrypted_data) { // first authentication

- if (MF_DBGLEVEL >= 4) Dbprintf("Reader authenticating for block %d (0x%02x) with key %d",receivedCmd_dec[1], receivedCmd_dec[1], cardAUTHKEY);

- crypto1_word(pcs, cuid ^ nonce, 0);//Update crypto state

- num_to_bytes(nonce, 4, rAUTH_AT); // Send nonce

+ crypto1_word(pcs, cuid ^ nonce, 0); // Update crypto state

+ num_to_bytes(nonce, 4, response); // Send unencrypted nonce

+ EmSendCmd(response, sizeof(nonce));

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Reader authenticating for block %d (0x%02x) with key %d", receivedCmd_dec[1], receivedCmd_dec[1], cardAUTHKEY);

} else { // nested authentication

- if (MF_DBGLEVEL >= 4) Dbprintf("Reader doing nested authentication for block %d (0x%02x) with key %d", receivedCmd_dec[1], receivedCmd_dec[1], cardAUTHKEY);

- ans = nonce ^ crypto1_word(pcs, cuid ^ nonce, 0);

- num_to_bytes(ans, 4, rAUTH_AT);

+ num_to_bytes(nonce, sizeof(nonce), response);

+ uint8_t pcs_in[4] = {0};

+ num_to_bytes(cuid ^ nonce, sizeof(nonce), pcs_in);

+ mf_crypto1_encryptEx(pcs, response, pcs_in, sizeof(nonce), response_par);

+ EmSendCmdPar(response, sizeof(nonce), response_par); // send encrypted nonce

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Reader doing nested authentication for block %d (0x%02x) with key %d", receivedCmd_dec[1], receivedCmd_dec[1], cardAUTHKEY);

}

- EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));

cardSTATE = MFEMUL_AUTH1;

break;

}

cardSTATE = MFEMUL_AUTH1;

break;

}

- if (!encrypted_data) { // all other commands must be encrypted (authenticated)

+

+ // halt can be sent encrypted or in clear

+ if (receivedCmd_dec[0] == ISO14443A_CMD_HALT && receivedCmd_dec[1] == 0x00) {

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("--> HALTED.");

+ cardSTATE = MFEMUL_HALTED;

break;

}

break;

}

- if(receivedCmd_dec[0] == ISO14443A_CMD_READBLOCK

- || receivedCmd_dec[0] == ISO14443A_CMD_WRITEBLOCK

+

+ if(receivedCmd_dec[0] == MIFARE_CMD_READBLOCK

+ || receivedCmd_dec[0] == MIFARE_CMD_WRITEBLOCK

|| receivedCmd_dec[0] == MIFARE_CMD_INC

|| receivedCmd_dec[0] == MIFARE_CMD_DEC

|| receivedCmd_dec[0] == MIFARE_CMD_RESTORE

|| receivedCmd_dec[0] == MIFARE_CMD_TRANSFER) {

|| receivedCmd_dec[0] == MIFARE_CMD_INC

|| receivedCmd_dec[0] == MIFARE_CMD_DEC

|| receivedCmd_dec[0] == MIFARE_CMD_RESTORE

|| receivedCmd_dec[0] == MIFARE_CMD_TRANSFER) {

- if (receivedCmd_dec[1] >= 16 * 4) {

+ if (receivedCmd_dec[1] >= num_blocks) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

- if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate (0x%02x) on out of range block: %d (0x%02x), nacking",receivedCmd_dec[0],receivedCmd_dec[1],receivedCmd_dec[1]);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Reader tried to operate (0x%02x) on out of range block: %d (0x%02x), nacking",receivedCmd_dec[0],receivedCmd_dec[1],receivedCmd_dec[1]);

break;

}

break;

}

- if (receivedCmd_dec[1] / 4 != cardAUTHSC) {

+ if (BlockToSector(receivedCmd_dec[1]) != cardAUTHSC) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

- if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate (0x%02x) on block (0x%02x) not authenticated for (0x%02x), nacking",receivedCmd_dec[0],receivedCmd_dec[1],cardAUTHSC);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Reader tried to operate (0x%02x) on block (0x%02x) not authenticated for (0x%02x), nacking",receivedCmd_dec[0],receivedCmd_dec[1],cardAUTHSC);

break;

}

break;

}

- if (receivedCmd_dec[0] == ISO14443A_CMD_READBLOCK) {

+

+ if (receivedCmd_dec[0] == MIFARE_CMD_READBLOCK) {

uint8_t blockNo = receivedCmd_dec[1];

- if (MF_DBGLEVEL >= 4) {

- Dbprintf("Reader reading block %d (0x%02x)", blockNo, blockNo);

- }

emlGetMem(response, blockNo, 1);

if (IsSectorTrailer(blockNo)) {

emlGetMem(response, blockNo, 1);

if (IsSectorTrailer(blockNo)) {

- memset(response, 0x00, 6); // keyA can never be read

+ memset(response, 0x00, 6); // keyA can never be read

if (!IsAccessAllowed(blockNo, cardAUTHKEY, AC_KEYB_READ)) {

- memset(response+10, 0x00, 6); // keyB cannot be read

+ memset(response+10, 0x00, 6); // keyB cannot be read

}

if (!IsAccessAllowed(blockNo, cardAUTHKEY, AC_AC_READ)) {

}

if (!IsAccessAllowed(blockNo, cardAUTHKEY, AC_AC_READ)) {

- memset(response+6, 0x00, 4); // AC bits cannot be read

+ memset(response+6, 0x00, 4); // AC bits cannot be read

}

} else {

if (!IsAccessAllowed(blockNo, cardAUTHKEY, AC_DATA_READ)) {

}

} else {

if (!IsAccessAllowed(blockNo, cardAUTHKEY, AC_DATA_READ)) {

- memset(response, 0x00, 16); // datablock cannot be read

+ memset(response, 0x00, 16); // datablock cannot be read

}

AppendCrc14443a(response, 16);

mf_crypto1_encrypt(pcs, response, 18, response_par);

EmSendCmdPar(response, 18, response_par);

}

AppendCrc14443a(response, 16);

mf_crypto1_encrypt(pcs, response, 18, response_par);

EmSendCmdPar(response, 18, response_par);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {

+ Dbprintf("Reader reading block %d (0x%02x)", blockNo, blockNo);

+ }

numReads++;

if(exitAfterNReads > 0 && numReads == exitAfterNReads) {

Dbprintf("%d reads done, exiting", numReads);

numReads++;

if(exitAfterNReads > 0 && numReads == exitAfterNReads) {

Dbprintf("%d reads done, exiting", numReads);

}

break;

}

break;

}

- if (receivedCmd_dec[0] == ISO14443A_CMD_WRITEBLOCK) {

+

+ if (receivedCmd_dec[0] == MIFARE_CMD_WRITEBLOCK) {

uint8_t blockNo = receivedCmd_dec[1];

- if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0xA0 write block %d (%02x)", blockNo, blockNo);

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("RECV 0xA0 write block %d (%02x)", blockNo, blockNo);

cardWRBL = blockNo;

cardSTATE = MFEMUL_WRITEBL2;

break;

}

cardWRBL = blockNo;

cardSTATE = MFEMUL_WRITEBL2;

break;

}

+

if (receivedCmd_dec[0] == MIFARE_CMD_INC || receivedCmd_dec[0] == MIFARE_CMD_DEC || receivedCmd_dec[0] == MIFARE_CMD_RESTORE) {

uint8_t blockNo = receivedCmd_dec[1];

if (receivedCmd_dec[0] == MIFARE_CMD_INC || receivedCmd_dec[0] == MIFARE_CMD_DEC || receivedCmd_dec[0] == MIFARE_CMD_RESTORE) {

uint8_t blockNo = receivedCmd_dec[1];

- if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0x%02x inc(0xC1)/dec(0xC0)/restore(0xC2) block %d (%02x)",receivedCmd_dec[0], blockNo, blockNo);

if (emlCheckValBl(blockNo)) {

- if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate on block, but emlCheckValBl failed, nacking");

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {

+ Dbprintf("RECV 0x%02x inc(0xC1)/dec(0xC0)/restore(0xC2) block %d (%02x)",receivedCmd_dec[0], blockNo, blockNo);

+ }

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Reader tried to operate on block, but emlCheckValBl failed, nacking");

break;

}

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));

break;

}

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {

+ Dbprintf("RECV 0x%02x inc(0xC1)/dec(0xC0)/restore(0xC2) block %d (%02x)",receivedCmd_dec[0], blockNo, blockNo);

+ }

cardWRBL = blockNo;

if (receivedCmd_dec[0] == MIFARE_CMD_INC)

cardSTATE = MFEMUL_INTREG_INC;

cardWRBL = blockNo;

if (receivedCmd_dec[0] == MIFARE_CMD_INC)

cardSTATE = MFEMUL_INTREG_INC;

cardSTATE = MFEMUL_INTREG_REST;

break;

}

cardSTATE = MFEMUL_INTREG_REST;

break;

}

+

if (receivedCmd_dec[0] == MIFARE_CMD_TRANSFER) {

uint8_t blockNo = receivedCmd_dec[1];

if (receivedCmd_dec[0] == MIFARE_CMD_TRANSFER) {

uint8_t blockNo = receivedCmd_dec[1];

- if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0x%02x transfer block %d (%02x)",receivedCmd_dec[0], blockNo, blockNo);

if (emlSetValBl(cardINTREG, cardINTBLOCK, receivedCmd_dec[1]))

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

else

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));

if (emlSetValBl(cardINTREG, cardINTBLOCK, receivedCmd_dec[1]))

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

else

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("RECV 0x%02x transfer block %d (%02x)",receivedCmd_dec[0], blockNo, blockNo);

break;

}

break;

}

- // halt

- if (receivedCmd_dec[0] == ISO14443A_CMD_HALT && receivedCmd_dec[1] == 0x00) {

- if (MF_DBGLEVEL >= 4) Dbprintf("--> HALTED.");

- LED_B_OFF();

- LED_C_OFF();

- cardSTATE = MFEMUL_HALTED;

- break;

- }

+

// command not allowed

- if (MF_DBGLEVEL >= 4) Dbprintf("Received command not allowed, nacking");

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("Received command not allowed, nacking");

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

+

case MFEMUL_AUTH1:{

if (receivedCmd_len != 8) {

case MFEMUL_AUTH1:{

if (receivedCmd_len != 8) {

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

if (ar_nr_collected[i+mM] < 2) {

// if we haven't already collected 2 nonces for this sector

if (ar_nr_resp[ar_nr_collected[i+mM]].ar != ar) {

if (ar_nr_collected[i+mM] < 2) {

// if we haven't already collected 2 nonces for this sector

if (ar_nr_resp[ar_nr_collected[i+mM]].ar != ar) {

- // Avoid duplicates... probably not necessary, ar should vary.

+ // Avoid duplicates... probably not necessary, ar should vary.

if (ar_nr_collected[i+mM]==0) {

// first nonce collect

ar_nr_resp[i+mM].cuid = cuid;

if (ar_nr_collected[i+mM]==0) {

// first nonce collect

ar_nr_resp[i+mM].cuid = cuid;

if ( nonce2_count == nonce1_count ) {

// done collecting std test switch to moebius

// first finish incrementing last sample

if ( nonce2_count == nonce1_count ) {

// done collecting std test switch to moebius

// first finish incrementing last sample

- ar_nr_collected[i+mM]++;

+ ar_nr_collected[i+mM]++;

// switch to moebius collection

gettingMoebius = true;

mM = ATTACK_KEY_COUNT;

// switch to moebius collection

gettingMoebius = true;

mM = ATTACK_KEY_COUNT;

// test if auth OK

if (cardRr != prng_successor(nonce, 64)){

// test if auth OK

if (cardRr != prng_successor(nonce, 64)){

- if (MF_DBGLEVEL >= 2) Dbprintf("AUTH FAILED for sector %d with key %c. cardRr=%08x, succ=%08x",

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("AUTH FAILED for sector %d with key %c. cardRr=%08x, succ=%08x",

cardAUTHSC, cardAUTHKEY == AUTHKEYA ? 'A' : 'B',

cardRr, prng_successor(nonce, 64));

// Shouldn't we respond anything here?

// Right now, we don't nack or anything, which causes the

// reader to do a WUPA after a while. /Martin

// -- which is the correct response. /piwi

cardAUTHSC, cardAUTHKEY == AUTHKEYA ? 'A' : 'B',

cardRr, prng_successor(nonce, 64));

// Shouldn't we respond anything here?

// Right now, we don't nack or anything, which causes the

// reader to do a WUPA after a while. /Martin

// -- which is the correct response. /piwi

- cardAUTHKEY = AUTHKEYNONE; // not authenticated

- cardSTATE_TO_IDLE();

+ cardAUTHKEY = AUTHKEYNONE; // not authenticated

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

- ans = prng_successor(nonce, 96) ^ crypto1_word(pcs, 0, 0);

- num_to_bytes(ans, 4, rAUTH_AT);

- EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));

- if (MF_DBGLEVEL >= 4) Dbprintf("AUTH COMPLETED for sector %d with key %c.", cardAUTHSC, cardAUTHKEY == AUTHKEYA ? 'A' : 'B');

- LED_C_ON();

+ ans = prng_successor(nonce, 96);

+ num_to_bytes(ans, 4, response);

+ mf_crypto1_encrypt(pcs, response, 4, response_par);

+ EmSendCmdPar(response, 4, response_par);

+ FpgaDisableTracing();

+ if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("AUTH COMPLETED for sector %d with key %c.", cardAUTHSC, cardAUTHKEY == AUTHKEYA ? 'A' : 'B');

cardSTATE = MFEMUL_WORK;

break;

}

cardSTATE = MFEMUL_WORK;

break;

}

+

case MFEMUL_WRITEBL2:{

if (receivedCmd_len == 18) {

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, receivedCmd_dec);

case MFEMUL_WRITEBL2:{

if (receivedCmd_len == 18) {

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, receivedCmd_dec);

if (IsSectorTrailer(cardWRBL)) {

emlGetMem(response, cardWRBL, 1);

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_KEYA_WRITE)) {

if (IsSectorTrailer(cardWRBL)) {

emlGetMem(response, cardWRBL, 1);

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_KEYA_WRITE)) {

- memcpy(receivedCmd_dec, response, 6); // don't change KeyA

+ memcpy(receivedCmd_dec, response, 6); // don't change KeyA

}

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_KEYB_WRITE)) {

}

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_KEYB_WRITE)) {

- memcpy(receivedCmd_dec+10, response+10, 6); // don't change KeyA

+ memcpy(receivedCmd_dec+10, response+10, 6); // don't change KeyA

}

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_AC_WRITE)) {

}

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_AC_WRITE)) {

- memcpy(receivedCmd_dec+6, response+6, 4); // don't change AC bits

+ memcpy(receivedCmd_dec+6, response+6, 4); // don't change AC bits

}

} else {

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_DATA_WRITE)) {

}

} else {

if (!IsAccessAllowed(cardWRBL, cardAUTHKEY, AC_DATA_WRITE)) {

- memcpy(receivedCmd_dec, response, 16); // don't change anything

+ memcpy(receivedCmd_dec, response, 16); // don't change anything

}

emlSetMem(receivedCmd_dec, cardWRBL, 1);

}

emlSetMem(receivedCmd_dec, cardWRBL, 1);

- EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK)); // always ACK?

+ EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK)); // always ACK?

cardSTATE = MFEMUL_WORK;

break;

}

cardSTATE = MFEMUL_WORK;

break;

}

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

+

case MFEMUL_INTREG_INC:{

if (receivedCmd_len == 6) {

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, (uint8_t*)&ans);

if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

case MFEMUL_INTREG_INC:{

if (receivedCmd_len == 6) {

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, (uint8_t*)&ans);

if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

cardINTREG = cardINTREG + ans;

break;

}

cardINTREG = cardINTREG + ans;

+ cardSTATE = MFEMUL_WORK;

}

- cardSTATE = MFEMUL_WORK;

break;

}

break;

}

+

case MFEMUL_INTREG_DEC:{

if (receivedCmd_len == 6) {

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, (uint8_t*)&ans);

if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

case MFEMUL_INTREG_DEC:{

if (receivedCmd_len == 6) {

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, (uint8_t*)&ans);

if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

break;

}

+ cardINTREG = cardINTREG - ans;

+ cardSTATE = MFEMUL_WORK;

}

- cardINTREG = cardINTREG - ans;

- cardSTATE = MFEMUL_WORK;

break;

}

break;

}

+

case MFEMUL_INTREG_REST:{

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, (uint8_t*)&ans);

if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

case MFEMUL_INTREG_REST:{

mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, (uint8_t*)&ans);

if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {

EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));

- cardSTATE_TO_IDLE();

+ cardSTATE = MFEMUL_IDLE;

break;

}

cardSTATE = MFEMUL_WORK;

break;

}

break;

}

cardSTATE = MFEMUL_WORK;

break;

}

- }

+

+ } // end of switch

+

+ FpgaDisableTracing();

button_pushed = BUTTON_PRESS();

- }

+

+ } // end of while

FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);

LEDsoff();

FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);

LEDsoff();

- if(flags & FLAG_NR_AR_ATTACK && MF_DBGLEVEL >= 1) {

- for ( uint8_t i = 0; i < ATTACK_KEY_COUNT; i++) {

+ if(flags & FLAG_NR_AR_ATTACK && MF_DBGLEVEL >= MF_DBG_INFO) {

+ for ( uint8_t i = 0; i < ATTACK_KEY_COUNT; i++) {

if (ar_nr_collected[i] == 2) {

Dbprintf("Collected two pairs of AR/NR which can be used to extract %s from reader for sector %d:", (i<ATTACK_KEY_COUNT/2) ? "keyA" : "keyB", ar_nr_resp[i].sector);

Dbprintf("../tools/mfkey/mfkey32 %08x %08x %08x %08x %08x %08x",

if (ar_nr_collected[i] == 2) {

Dbprintf("Collected two pairs of AR/NR which can be used to extract %s from reader for sector %d:", (i<ATTACK_KEY_COUNT/2) ? "keyA" : "keyB", ar_nr_resp[i].sector);

Dbprintf("../tools/mfkey/mfkey32 %08x %08x %08x %08x %08x %08x",

ar_nr_resp[i].ar2 //AR2

);

}

ar_nr_resp[i].ar2 //AR2

);

}

- }

- for ( uint8_t i = ATTACK_KEY_COUNT; i < ATTACK_KEY_COUNT*2; i++) {

+ }

+ for ( uint8_t i = ATTACK_KEY_COUNT; i < ATTACK_KEY_COUNT*2; i++) {

if (ar_nr_collected[i] == 2) {

Dbprintf("Collected two pairs of AR/NR which can be used to extract %s from reader for sector %d:", (i<ATTACK_KEY_COUNT/2) ? "keyA" : "keyB", ar_nr_resp[i].sector);

if (ar_nr_collected[i] == 2) {

Dbprintf("Collected two pairs of AR/NR which can be used to extract %s from reader for sector %d:", (i<ATTACK_KEY_COUNT/2) ? "keyA" : "keyB", ar_nr_resp[i].sector);

- Dbprintf("../tools/mfkey/mfkey32v2 %08x %08x %08x %08x %08x %08x %08x",

+ Dbprintf("../tools/mfkey/mfkey32 %08x %08x %08x %08x %08x %08x %08x",

ar_nr_resp[i].cuid, //UID

ar_nr_resp[i].nonce, //NT

ar_nr_resp[i].nr, //NR1

ar_nr_resp[i].cuid, //UID

ar_nr_resp[i].nonce, //NT

ar_nr_resp[i].nr, //NR1

}

- if (MF_DBGLEVEL >= 1) Dbprintf("Emulator stopped. Tracing: %d trace length: %d ", get_tracing(), BigBuf_get_traceLen());

+ if (MF_DBGLEVEL >= MF_DBG_INFO) Dbprintf("Emulator stopped. Tracing: %d trace length: %d ", get_tracing(), BigBuf_get_traceLen());

if(flags & FLAG_INTERACTIVE) { // Interactive mode flag, means we need to send ACK

//Send the collected ar_nr in the response

if(flags & FLAG_INTERACTIVE) { // Interactive mode flag, means we need to send ACK

//Send the collected ar_nr in the response

- cmd_send(CMD_ACK,CMD_SIMULATE_MIFARE_CARD,button_pushed,0,&ar_nr_resp,sizeof(ar_nr_resp));

+ cmd_send(CMD_ACK, CMD_SIMULATE_MIFARE_CARD, button_pushed, 0, &ar_nr_resp, sizeof(ar_nr_resp));

}

+

+ LED_A_OFF();

}