mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-08-19 21:03:23 -07:00
fix hf mf sim (#812)
* fix parity encryption (thanks to Eloff, http://www.proxmark.org/forum/viewtopic.php?id=6347) * add support to simulate Mifare Mini, Mifare 2K and Mifare 4K * change to standard LED handling (A: PM is working, B: reader is sending, C: tag is responding, D: HF field is on) * NAK on unknown commands * allow unencrypted HALT * don't display messages during simulation (or we will miss next reader command) * use DMA to receive reader command * switch earlier from send to listen mode * move ADC initializer to iso14443_setup * remove remainders of incomplete Mifare 10Byte UID simulation * show 'short' bytes (7Bits or 8Bits without parity) in 'hf list mf' and 'hf list 14a' * whitespace
This commit is contained in:
pwpiwi
GitHub
parent
bad582468f
commit
a8561e356b
14 changed files with 944 additions and 804 deletions
|
|
@ -25,26 +25,24 @@
|
|||
#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_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
|
||||
|
|
@ -57,11 +55,30 @@
|
|||
#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)
|
||||
| ((sector_trailer[8] >> 2) & 0x02)
|
||||
| ((sector_trailer[8] >> 2) & 0x02)
|
||||
| ((sector_trailer[8] >> 7) & 0x01);
|
||||
switch (action) {
|
||||
case AC_KEYA_READ: {
|
||||
|
|
@ -69,8 +86,8 @@ static bool IsTrailerAccessAllowed(uint8_t blockNo, uint8_t keytype, uint8_t act
|
|||
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: {
|
||||
|
|
@ -79,17 +96,17 @@ static bool IsTrailerAccessAllowed(uint8_t blockNo, uint8_t keytype, uint8_t act
|
|||
}
|
||||
case AC_KEYB_WRITE: {
|
||||
return ((keytype == AUTHKEYA && (AC == 0x00 || AC == 0x04))
|
||||
|| (keytype == AUTHKEYB && (AC == 0x04 || AC == 0x03)));
|
||||
|| (keytype == AUTHKEYB && (AC == 0x04 || AC == 0x03)));
|
||||
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))
|
||||
|| (keytype == AUTHKEYB && (AC == 0x03 || AC == 0x05)));
|
||||
|| (keytype == AUTHKEYB && (AC == 0x03 || AC == 0x05)));
|
||||
break;
|
||||
}
|
||||
default: return false;
|
||||
|
|
@ -129,33 +146,33 @@ static bool IsDataAccessAllowed(uint8_t blockNo, uint8_t keytype, uint8_t action
|
|||
| ((sector_trailer[8] >> 6) & 0x01);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
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))
|
||||
|| (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))
|
||||
|| (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))
|
||||
|| (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x06 || AC == 0x01)));
|
||||
|| (keytype == AUTHKEYB && (AC == 0x00 || AC == 0x06 || AC == 0x01)));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -169,18 +186,18 @@ static bool IsAccessAllowed(uint8_t blockNo, uint8_t keytype, uint8_t action) {
|
|||
}
|
||||
|
||||
|
||||
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
|
||||
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;
|
||||
|
|
@ -189,10 +206,10 @@ static void MifareSimInit(uint8_t flags, uint8_t *datain, tag_response_info_t **
|
|||
*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);
|
||||
|
|
@ -204,37 +221,65 @@ static void MifareSimInit(uint8_t flags, uint8_t *datain, tag_response_info_t **
|
|||
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:
|
||||
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;
|
||||
default:
|
||||
default:
|
||||
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
|
||||
// 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;
|
||||
|
|
@ -262,22 +307,23 @@ static bool HasValidCRC(uint8_t *receivedCmd, uint16_t receivedCmd_len) {
|
|||
|
||||
|
||||
/**
|
||||
*MIFARE 1K simulate.
|
||||
*MIFARE simulate.
|
||||
*
|
||||
*@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_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)
|
||||
*/
|
||||
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;
|
||||
|
|
@ -288,48 +334,47 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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 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 {
|
||||
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();
|
||||
|
||||
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);
|
||||
|
||||
|
|
@ -337,7 +382,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
clear_trace();
|
||||
set_tracing(true);
|
||||
ResetSspClk();
|
||||
|
||||
|
||||
bool finished = false;
|
||||
bool button_pushed = BUTTON_PRESS();
|
||||
int cardSTATE = MFEMUL_NOFIELD;
|
||||
|
|
@ -345,25 +390,28 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
while (!button_pushed && !finished && !usb_poll_validate_length()) {
|
||||
WDT_HIT();
|
||||
|
||||
// find reader field
|
||||
if (cardSTATE == MFEMUL_NOFIELD) {
|
||||
// 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
|
||||
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
|
||||
FpgaDisableTracing();
|
||||
button_pushed = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -371,6 +419,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
// 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);
|
||||
|
|
@ -378,66 +427,68 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
if (flags & FLAG_RANDOM_NONCE) {
|
||||
nonce = prand();
|
||||
}
|
||||
LED_B_OFF();
|
||||
LED_C_OFF();
|
||||
cardSTATE = MFEMUL_SELECT1;
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
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)) {
|
||||
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)) {
|
||||
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]);
|
||||
LED_B_ON();
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
break;
|
||||
} 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;
|
||||
}
|
||||
|
||||
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
|
||||
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) {
|
||||
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_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
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) ;
|
||||
|
|
@ -448,76 +499,92 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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;
|
||||
}
|
||||
|
||||
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));
|
||||
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;
|
||||
}
|
||||
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
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
if(receivedCmd_dec[0] == ISO14443A_CMD_READBLOCK
|
||||
|| receivedCmd_dec[0] == ISO14443A_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) {
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
if (receivedCmd_dec[0] == ISO14443A_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)) {
|
||||
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)) {
|
||||
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)) {
|
||||
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);
|
||||
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);
|
||||
|
|
@ -525,23 +592,33 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (receivedCmd_dec[0] == ISO14443A_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;
|
||||
}
|
||||
|
||||
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));
|
||||
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;
|
||||
|
|
@ -551,31 +628,29 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
cardSTATE = MFEMUL_INTREG_REST;
|
||||
break;
|
||||
}
|
||||
|
||||
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));
|
||||
FpgaDisableTracing();
|
||||
if (MF_DBGLEVEL >= MF_DBG_EXTENDED) Dbprintf("RECV 0x%02x transfer block %d (%02x)",receivedCmd_dec[0], blockNo, blockNo);
|
||||
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;
|
||||
}
|
||||
|
||||
case MFEMUL_AUTH1:{
|
||||
if (receivedCmd_len != 8) {
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -590,7 +665,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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;
|
||||
|
|
@ -618,7 +693,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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;
|
||||
|
|
@ -650,25 +725,28 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
|
||||
// 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
|
||||
cardAUTHKEY = AUTHKEYNONE; // not authenticated
|
||||
cardSTATE_TO_IDLE();
|
||||
cardAUTHKEY = AUTHKEYNONE; // not authenticated
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
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;
|
||||
}
|
||||
|
||||
case MFEMUL_WRITEBL2:{
|
||||
if (receivedCmd_len == 18) {
|
||||
mf_crypto1_decryptEx(pcs, receivedCmd, receivedCmd_len, receivedCmd_dec);
|
||||
|
|
@ -676,73 +754,80 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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)) {
|
||||
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)) {
|
||||
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)) {
|
||||
memcpy(receivedCmd_dec, response, 16); // don't change anything
|
||||
memcpy(receivedCmd_dec, response, 16); // don't change anything
|
||||
}
|
||||
}
|
||||
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_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
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));
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
cardINTREG = cardINTREG + ans;
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
}
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
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));
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
cardINTREG = cardINTREG - ans;
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
}
|
||||
cardINTREG = cardINTREG - ans;
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
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));
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} // end of switch
|
||||
|
||||
FpgaDisableTracing();
|
||||
button_pushed = BUTTON_PRESS();
|
||||
}
|
||||
|
||||
} // end of while
|
||||
|
||||
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",
|
||||
|
|
@ -754,11 +839,11 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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);
|
||||
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
|
||||
|
|
@ -770,10 +855,12 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
}
|
||||
}
|
||||
}
|
||||
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
|
||||
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();
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue