mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-08-19 21:03:23 -07:00
fix hf mf sim
* 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) * whitespace
This commit is contained in:
pwpiwi
parent
ba778bc3c4
commit
02e47adfb8
10 changed files with 292 additions and 180 deletions
|
|
@ -39,6 +39,7 @@ static uint8_t *emulator_memory = NULL;
|
|||
static uint32_t traceLen = 0;
|
||||
static bool tracing = true;
|
||||
|
||||
|
||||
// get the address of BigBuf
|
||||
uint8_t *BigBuf_get_addr(void)
|
||||
{
|
||||
|
|
@ -63,6 +64,8 @@ void BigBuf_Clear(void)
|
|||
{
|
||||
BigBuf_Clear_ext(true);
|
||||
}
|
||||
|
||||
|
||||
// clear ALL of BigBuf
|
||||
void BigBuf_Clear_ext(bool verbose)
|
||||
{
|
||||
|
|
@ -70,10 +73,13 @@ void BigBuf_Clear_ext(bool verbose)
|
|||
if (verbose)
|
||||
Dbprintf("Buffer cleared (%i bytes)", BIGBUF_SIZE);
|
||||
}
|
||||
|
||||
|
||||
void BigBuf_Clear_EM(void){
|
||||
memset(BigBuf_get_EM_addr(), 0, CARD_MEMORY_SIZE);
|
||||
}
|
||||
|
||||
|
||||
void BigBuf_Clear_keep_EM(void)
|
||||
{
|
||||
memset(BigBuf, 0, BigBuf_hi);
|
||||
|
|
@ -128,18 +134,22 @@ uint16_t BigBuf_max_traceLen(void)
|
|||
return BigBuf_hi;
|
||||
}
|
||||
|
||||
|
||||
void clear_trace() {
|
||||
traceLen = 0;
|
||||
}
|
||||
|
||||
|
||||
void set_tracing(bool enable) {
|
||||
tracing = enable;
|
||||
}
|
||||
|
||||
|
||||
bool get_tracing(void) {
|
||||
return tracing;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the number of bytes traced
|
||||
* @return
|
||||
|
|
@ -149,6 +159,7 @@ uint16_t BigBuf_get_traceLen(void)
|
|||
return traceLen;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
This is a function to store traces. All protocols can use this generic tracer-function.
|
||||
The traces produced by calling this function can be fetched on the client-side
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@
|
|||
#include "lfsampling.h"
|
||||
#include "BigBuf.h"
|
||||
#include "mifareutil.h"
|
||||
#include "mifaresim.h"
|
||||
#include "pcf7931.h"
|
||||
#include "i2c.h"
|
||||
#include "hfsnoop.h"
|
||||
|
|
@ -1249,7 +1250,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
|
|||
MifareChkKeys(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
|
||||
break;
|
||||
case CMD_SIMULATE_MIFARE_CARD:
|
||||
Mifare1ksim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
|
||||
MifareSim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
|
||||
break;
|
||||
|
||||
// emulator
|
||||
|
|
|
|||
|
|
@ -119,7 +119,6 @@ void MifareUWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t *datain);
|
|||
void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain);
|
||||
void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *datain);
|
||||
void MifareChkKeys(uint16_t arg0, uint16_t arg1, uint8_t arg2, uint8_t *datain);
|
||||
void Mifare1ksim(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain);
|
||||
void MifareSetDbgLvl(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain);
|
||||
void MifareEMemClr(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain);
|
||||
void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain);
|
||||
|
|
|
|||
|
|
@ -1264,6 +1264,7 @@ static void PrepareDelayedTransfer(uint16_t delay)
|
|||
//-------------------------------------------------------------------------------------
|
||||
static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing)
|
||||
{
|
||||
LED_B_ON();
|
||||
LED_D_ON();
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
|
||||
|
||||
|
|
@ -1299,6 +1300,7 @@ static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing
|
|||
}
|
||||
|
||||
NextTransferTime = MAX(NextTransferTime, LastTimeProxToAirStart + REQUEST_GUARD_TIME);
|
||||
LED_B_OFF();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1420,8 +1422,6 @@ int EmGetCmd(uint8_t *received, uint16_t *len, uint8_t *parity)
|
|||
|
||||
// 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
|
||||
LED_D_OFF();
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_LISTEN);
|
||||
|
||||
for(;;) {
|
||||
|
|
@ -1463,12 +1463,13 @@ int EmGetCmd(uint8_t *received, uint16_t *len, uint8_t *parity)
|
|||
|
||||
static int EmSendCmd14443aRaw(uint8_t *resp, uint16_t respLen)
|
||||
{
|
||||
LED_C_ON();
|
||||
|
||||
uint8_t b;
|
||||
uint16_t i = 0;
|
||||
bool correctionNeeded;
|
||||
|
||||
// Modulate Manchester
|
||||
LED_D_OFF();
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_MOD);
|
||||
|
||||
// include correction bit if necessary
|
||||
|
|
@ -1516,6 +1517,7 @@ static int EmSendCmd14443aRaw(uint8_t *resp, uint16_t respLen)
|
|||
}
|
||||
}
|
||||
|
||||
LED_C_OFF();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1762,7 +1764,7 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
|
|||
|
||||
// OK we will select at least at cascade 1, lets see if first byte of UID was 0x88 in
|
||||
// which case we need to make a cascade 2 request and select - this is a long UID
|
||||
// While the UID is not complete, the 3nd bit (from the right) is set in the SAK.
|
||||
// While the UID is not complete, the 3rd bit (from the right) is set in the SAK.
|
||||
for(; sak & 0x04; cascade_level++) {
|
||||
// SELECT_* (L1: 0x93, L2: 0x95, L3: 0x97)
|
||||
sel_uid[0] = sel_all[0] = 0x93 + cascade_level * 2;
|
||||
|
|
|
|||
|
|
@ -39,8 +39,6 @@
|
|||
#define MFEMUL_INTREG_REST 11
|
||||
#define MFEMUL_HALTED 12
|
||||
|
||||
#define cardSTATE_TO_IDLE() { cardSTATE = MFEMUL_IDLE; LED_B_OFF(); LED_C_OFF(); }
|
||||
|
||||
#define AC_DATA_READ 0
|
||||
#define AC_DATA_WRITE 1
|
||||
#define AC_DATA_INC 2
|
||||
|
|
@ -57,6 +55,25 @@
|
|||
#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);
|
||||
|
|
@ -169,14 +186,14 @@ 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 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[]= {0x08, 0xb6, 0xdd}; // mifare 1k indicated
|
||||
static uint8_t rSAK1[] = {0x04, 0xda, 0x17}; // indicate UID not finished
|
||||
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
|
||||
|
|
@ -210,7 +227,6 @@ static void MifareSimInit(uint8_t flags, uint8_t *datain, tag_response_info_t **
|
|||
}
|
||||
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];
|
||||
|
|
@ -223,6 +239,35 @@ static void MifareSimInit(uint8_t flags, uint8_t *datain, tag_response_info_t **
|
|||
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 >= 2) {
|
||||
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 >= 2) {
|
||||
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
|
||||
|
|
@ -262,7 +307,7 @@ 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
|
||||
|
|
@ -274,8 +319,10 @@ static bool HasValidCRC(uint8_t *receivedCmd, uint16_t receivedCmd_len) {
|
|||
*@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;
|
||||
uint32_t cuid = 0;
|
||||
|
|
@ -301,7 +348,9 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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
|
||||
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
|
||||
|
|
@ -328,7 +377,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
// 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);
|
||||
|
|
@ -349,18 +398,19 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
if (cardSTATE == MFEMUL_NOFIELD) {
|
||||
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;
|
||||
}
|
||||
|
||||
FpgaEnableTracing();
|
||||
//Now, get data
|
||||
int res = EmGetCmd(receivedCmd, &receivedCmd_len, receivedCmd_par);
|
||||
|
||||
if (res == 2) { //Field is off!
|
||||
LEDsoff();
|
||||
LED_D_OFF();
|
||||
cardSTATE = MFEMUL_NOFIELD;
|
||||
continue;
|
||||
} else if (res == 1) { // button pressed
|
||||
|
|
@ -371,6 +421,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,8 +429,6 @@ 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;
|
||||
}
|
||||
|
|
@ -395,6 +444,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
break;
|
||||
}
|
||||
// select card - 0x93 0x70 ...
|
||||
|
|
@ -403,16 +453,17 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
break;
|
||||
} else if (uid_len == 7) {
|
||||
EmSendPrecompiledCmd(&responses[SAK1]);
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_SELECT2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
case MFEMUL_SELECT2:{
|
||||
|
|
@ -420,6 +471,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
break;
|
||||
}
|
||||
// select cl2 card - 0x95 0x70 xxxxxxxxxxxx
|
||||
|
|
@ -428,16 +480,17 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
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
|
||||
FpgaDisableTracing();
|
||||
break;
|
||||
}
|
||||
bool encrypted_data = (cardAUTHKEY != AUTHKEYNONE) ;
|
||||
|
|
@ -448,35 +501,43 @@ 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));
|
||||
FpgaDisableTracing();
|
||||
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));
|
||||
FpgaDisableTracing();
|
||||
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]);
|
||||
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
|
||||
num_to_bytes(nonce, 4, rAUTH_AT); // Send unencrypted nonce
|
||||
EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));
|
||||
} 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
|
||||
}
|
||||
EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_AUTH1;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!encrypted_data) { // all other commands must be encrypted (authenticated)
|
||||
FpgaDisableTracing();
|
||||
break;
|
||||
}
|
||||
if(receivedCmd_dec[0] == ISO14443A_CMD_READBLOCK
|
||||
|
|
@ -485,13 +546,15 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
|| 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));
|
||||
FpgaDisableTracing();
|
||||
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]);
|
||||
break;
|
||||
}
|
||||
if (receivedCmd_dec[1] / 4 != cardAUTHSC) {
|
||||
if (BlockToSector(receivedCmd_dec[1]) != cardAUTHSC) {
|
||||
EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
|
||||
FpgaDisableTracing();
|
||||
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);
|
||||
break;
|
||||
}
|
||||
|
|
@ -518,6 +581,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
AppendCrc14443a(response, 16);
|
||||
mf_crypto1_encrypt(pcs, response, 18, response_par);
|
||||
EmSendCmdPar(response, 18, response_par);
|
||||
FpgaDisableTracing();
|
||||
numReads++;
|
||||
if(exitAfterNReads > 0 && numReads == exitAfterNReads) {
|
||||
Dbprintf("%d reads done, exiting", numReads);
|
||||
|
|
@ -529,6 +593,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
cardWRBL = blockNo;
|
||||
cardSTATE = MFEMUL_WRITEBL2;
|
||||
break;
|
||||
|
|
@ -539,9 +604,11 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
break;
|
||||
}
|
||||
EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
|
||||
FpgaDisableTracing();
|
||||
cardWRBL = blockNo;
|
||||
if (receivedCmd_dec[0] == MIFARE_CMD_INC)
|
||||
cardSTATE = MFEMUL_INTREG_INC;
|
||||
|
|
@ -558,13 +625,12 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
|
||||
else
|
||||
EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
|
||||
FpgaDisableTracing();
|
||||
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;
|
||||
}
|
||||
|
|
@ -575,7 +641,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
}
|
||||
case MFEMUL_AUTH1:{
|
||||
if (receivedCmd_len != 8) {
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -658,14 +724,15 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
// reader to do a WUPA after a while. /Martin
|
||||
// -- which is the correct response. /piwi
|
||||
cardAUTHKEY = AUTHKEYNONE; // not authenticated
|
||||
cardSTATE_TO_IDLE();
|
||||
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));
|
||||
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 >= 4) Dbprintf("AUTH COMPLETED for sector %d with key %c.", cardAUTHSC, cardAUTHKEY == AUTHKEYA ? 'A' : 'B');
|
||||
LED_C_ON();
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
break;
|
||||
}
|
||||
|
|
@ -691,11 +758,12 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
}
|
||||
emlSetMem(receivedCmd_dec, cardWRBL, 1);
|
||||
EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK)); // always ACK?
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
break;
|
||||
}
|
||||
}
|
||||
cardSTATE_TO_IDLE();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
case MFEMUL_INTREG_INC:{
|
||||
|
|
@ -703,7 +771,8 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
cardINTREG = cardINTREG + ans;
|
||||
|
|
@ -716,7 +785,8 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -728,7 +798,8 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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();
|
||||
FpgaDisableTracing();
|
||||
cardSTATE = MFEMUL_IDLE;
|
||||
break;
|
||||
}
|
||||
cardSTATE = MFEMUL_WORK;
|
||||
|
|
@ -758,7 +829,7 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
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
|
||||
|
|
@ -776,4 +847,6 @@ void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *
|
|||
//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));
|
||||
}
|
||||
|
||||
LED_A_OFF();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,6 @@
|
|||
|
||||
#include <stdint.h>
|
||||
|
||||
extern void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *datain);
|
||||
extern void MifareSim(uint8_t flags, uint8_t exitAfterNReads, uint8_t cardsize, uint8_t *datain);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -47,14 +47,14 @@ void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len){
|
|||
mf_crypto1_decryptEx(pcs, data, len, data);
|
||||
}
|
||||
|
||||
void mf_crypto1_encrypt(struct Crypto1State *pcs, uint8_t *data, uint16_t len, uint8_t *par) {
|
||||
void mf_crypto1_encryptEx(struct Crypto1State *pcs, uint8_t *data, uint8_t *in, uint16_t len, uint8_t *par) {
|
||||
uint8_t bt = 0;
|
||||
int i;
|
||||
par[0] = 0;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
bt = data[i];
|
||||
data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i];
|
||||
data[i] = crypto1_byte(pcs, in==NULL?0x00:in[i], 0) ^ data[i];
|
||||
if((i&0x0007) == 0)
|
||||
par[i>>3] = 0;
|
||||
par[i>>3] |= (((filter(pcs->odd) ^ oddparity8(bt)) & 0x01)<<(7-(i&0x0007)));
|
||||
|
|
@ -62,6 +62,10 @@ void mf_crypto1_encrypt(struct Crypto1State *pcs, uint8_t *data, uint16_t len, u
|
|||
return;
|
||||
}
|
||||
|
||||
void mf_crypto1_encrypt(struct Crypto1State *pcs, uint8_t *data, uint16_t len, uint8_t *par) {
|
||||
mf_crypto1_encryptEx(pcs, data, NULL, len, par);
|
||||
}
|
||||
|
||||
uint8_t mf_crypto1_encrypt4bit(struct Crypto1State *pcs, uint8_t data) {
|
||||
uint8_t bt = 0;
|
||||
int i;
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ int mifare_desfire_des_auth2(uint32_t uid, uint8_t *key, uint8_t *blockData);
|
|||
void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *receivedCmd, int len);
|
||||
void mf_crypto1_decryptEx(struct Crypto1State *pcs, uint8_t *data_in, int len, uint8_t *data_out);
|
||||
void mf_crypto1_encrypt(struct Crypto1State *pcs, uint8_t *data, uint16_t len, uint8_t *par);
|
||||
void mf_crypto1_encryptEx(struct Crypto1State *pcs, uint8_t *data, uint8_t *in, uint16_t len, uint8_t *par);
|
||||
uint8_t mf_crypto1_encrypt4bit(struct Crypto1State *pcs, uint8_t data);
|
||||
|
||||
// Mifare memory structure
|
||||
|
|
|
|||
|
|
@ -254,14 +254,14 @@ uint8_t NumBlocksPerSector(uint8_t sectorNo)
|
|||
}
|
||||
|
||||
static int ParamCardSizeSectors(const char c) {
|
||||
int numBlocks = 16;
|
||||
int numSectors = 16;
|
||||
switch (c) {
|
||||
case '0' : numBlocks = 5; break;
|
||||
case '2' : numBlocks = 32; break;
|
||||
case '4' : numBlocks = 40; break;
|
||||
default: numBlocks = 16;
|
||||
case '0' : numSectors = 5; break;
|
||||
case '2' : numSectors = 32; break;
|
||||
case '4' : numSectors = 40; break;
|
||||
default: numSectors = 16;
|
||||
}
|
||||
return numBlocks;
|
||||
return numSectors;
|
||||
}
|
||||
|
||||
static int ParamCardSizeBlocks(const char c) {
|
||||
|
|
@ -1421,11 +1421,12 @@ void readerAttack(nonces_t ar_resp[], bool setEmulatorMem, bool doStandardAttack
|
|||
}*/
|
||||
}
|
||||
|
||||
int usage_hf14_mf1ksim(void) {
|
||||
PrintAndLog("Usage: hf mf sim h u <uid (8, 14, or 20 hex symbols)> n <numreads> i x");
|
||||
int usage_hf14_mfsim(void) {
|
||||
PrintAndLog("Usage: hf mf sim [h] [*<card memory>] [u <uid (8, 14, or 20 hex symbols)>] [n <numreads>] [i] [x]");
|
||||
PrintAndLog("options:");
|
||||
PrintAndLog(" h this help");
|
||||
PrintAndLog(" u (Optional) UID 4,7 or 10 bytes. If not specified, the UID 4B from emulator memory will be used");
|
||||
PrintAndLog(" h (Optional) this help");
|
||||
PrintAndLog(" card memory: 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other, default> - 1K");
|
||||
PrintAndLog(" u (Optional) UID 4 or 7 bytes. If not specified, the UID 4B from emulator memory will be used");
|
||||
PrintAndLog(" n (Optional) Automatically exit simulation after <numreads> blocks have been read by reader. 0 = infinite");
|
||||
PrintAndLog(" i (Optional) Interactive, means that console will not be returned until simulation finishes or is aborted");
|
||||
PrintAndLog(" x (Optional) Crack, performs the 'reader attack', nr/ar attack against a legitimate reader, fishes out the key(s)");
|
||||
|
|
@ -1434,21 +1435,20 @@ int usage_hf14_mf1ksim(void) {
|
|||
PrintAndLog(" r (Optional) Generate random nonces instead of sequential nonces. Standard reader attack won't work with this option, only moebius attack works.");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" hf mf sim u 0a0a0a0a");
|
||||
PrintAndLog(" hf mf sim *4");
|
||||
PrintAndLog(" hf mf sim u 11223344556677");
|
||||
PrintAndLog(" hf mf sim u 112233445566778899AA");
|
||||
PrintAndLog(" hf mf sim f uids.txt");
|
||||
PrintAndLog(" hf mf sim u 0a0a0a0a e");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdHF14AMf1kSim(const char *Cmd) {
|
||||
int CmdHF14AMfSim(const char *Cmd) {
|
||||
UsbCommand resp;
|
||||
uint8_t uid[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
uint8_t exitAfterNReads = 0;
|
||||
uint8_t flags = 0;
|
||||
int uidlen = 0;
|
||||
uint8_t pnr = 0;
|
||||
bool setEmulatorMem = false;
|
||||
bool attackFromFile = false;
|
||||
FILE *f;
|
||||
|
|
@ -1459,9 +1459,21 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
|
||||
uint8_t cmdp = 0;
|
||||
bool errors = false;
|
||||
uint8_t cardsize = '1';
|
||||
|
||||
while(param_getchar(Cmd, cmdp) != 0x00) {
|
||||
switch(param_getchar(Cmd, cmdp)) {
|
||||
case '*':
|
||||
cardsize = param_getchar(Cmd + 1, cmdp);
|
||||
switch(cardsize) {
|
||||
case '0':
|
||||
case '1':
|
||||
case '2':
|
||||
case '4': break;
|
||||
default: cardsize = '1';
|
||||
}
|
||||
cmdp++;
|
||||
break;
|
||||
case 'e':
|
||||
case 'E':
|
||||
setEmulatorMem = true;
|
||||
|
|
@ -1485,7 +1497,7 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
break;
|
||||
case 'h':
|
||||
case 'H':
|
||||
return usage_hf14_mf1ksim();
|
||||
return usage_hf14_mfsim();
|
||||
case 'i':
|
||||
case 'I':
|
||||
flags |= FLAG_INTERACTIVE;
|
||||
|
|
@ -1493,7 +1505,7 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
break;
|
||||
case 'n':
|
||||
case 'N':
|
||||
exitAfterNReads = param_get8(Cmd, pnr+1);
|
||||
exitAfterNReads = param_get8(Cmd, cmdp+1);
|
||||
cmdp += 2;
|
||||
break;
|
||||
case 'r':
|
||||
|
|
@ -1505,10 +1517,9 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
case 'U':
|
||||
param_gethex_ex(Cmd, cmdp+1, uid, &uidlen);
|
||||
switch(uidlen) {
|
||||
case 20: flags = FLAG_10B_UID_IN_DATA; break; //not complete
|
||||
case 14: flags = FLAG_7B_UID_IN_DATA; break;
|
||||
case 8: flags = FLAG_4B_UID_IN_DATA; break;
|
||||
default: return usage_hf14_mf1ksim();
|
||||
default: return usage_hf14_mfsim();
|
||||
}
|
||||
cmdp += 2;
|
||||
break;
|
||||
|
|
@ -1525,7 +1536,7 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
if(errors) break;
|
||||
}
|
||||
//Validations
|
||||
if(errors) return usage_hf14_mf1ksim();
|
||||
if(errors) return usage_hf14_mfsim();
|
||||
|
||||
//get uid from file
|
||||
if (attackFromFile) {
|
||||
|
|
@ -1565,13 +1576,18 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
sscanf(&buf[i], "%02x", (unsigned int *)&uid[i / 2]);
|
||||
}
|
||||
|
||||
PrintAndLog("mf 1k sim uid: %s, numreads:%d, flags:%d (0x%02x) - press button to abort",
|
||||
PrintAndLog("mf sim cardsize: %s, uid: %s, numreads:%d, flags:%d (0x%02x) - press button to abort",
|
||||
cardsize == '0' ? "Mini" :
|
||||
cardsize == '2' ? "2K" :
|
||||
cardsize == '4' ? "4K" : "1K",
|
||||
flags & FLAG_4B_UID_IN_DATA ? sprint_hex(uid,4):
|
||||
flags & FLAG_7B_UID_IN_DATA ? sprint_hex(uid,7):
|
||||
flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A"
|
||||
, exitAfterNReads, flags, flags);
|
||||
flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A",
|
||||
exitAfterNReads,
|
||||
flags,
|
||||
flags);
|
||||
|
||||
UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};
|
||||
UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads, cardsize}};
|
||||
memcpy(c.d.asBytes, uid, sizeof(uid));
|
||||
clearCommandBuffer();
|
||||
SendCommand(&c);
|
||||
|
|
@ -1595,13 +1611,18 @@ int CmdHF14AMf1kSim(const char *Cmd) {
|
|||
fclose(f);
|
||||
} else { //not from file
|
||||
|
||||
PrintAndLog("mf 1k sim uid: %s, numreads:%d, flags:%d (0x%02x) ",
|
||||
PrintAndLog("mf sim cardsize: %s, uid: %s, numreads:%d, flags:%d (0x%02x) ",
|
||||
cardsize == '0' ? "Mini" :
|
||||
cardsize == '2' ? "2K" :
|
||||
cardsize == '4' ? "4K" : "1K",
|
||||
flags & FLAG_4B_UID_IN_DATA ? sprint_hex(uid,4):
|
||||
flags & FLAG_7B_UID_IN_DATA ? sprint_hex(uid,7):
|
||||
flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A"
|
||||
, exitAfterNReads, flags, flags);
|
||||
flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A",
|
||||
exitAfterNReads,
|
||||
flags,
|
||||
flags);
|
||||
|
||||
UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};
|
||||
UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads, cardsize}};
|
||||
memcpy(c.d.asBytes, uid, sizeof(uid));
|
||||
clearCommandBuffer();
|
||||
SendCommand(&c);
|
||||
|
|
@ -2925,8 +2946,8 @@ static command_t CommandTable[] =
|
|||
{"hardnested", CmdHF14AMfNestedHard, 0, "Nested attack for hardened Mifare cards"},
|
||||
{"nested", CmdHF14AMfNested, 0, "Test nested authentication"},
|
||||
{"sniff", CmdHF14AMfSniff, 0, "Sniff card-reader communication"},
|
||||
{"sim", CmdHF14AMf1kSim, 0, "Simulate MIFARE card"},
|
||||
{"eclr", CmdHF14AMfEClear, 0, "Clear simulator memory block"},
|
||||
{"sim", CmdHF14AMfSim, 0, "Simulate MIFARE card"},
|
||||
{"eclr", CmdHF14AMfEClear, 0, "Clear simulator memory"},
|
||||
{"eget", CmdHF14AMfEGet, 0, "Get simulator memory block"},
|
||||
{"eset", CmdHF14AMfESet, 0, "Set simulator memory block"},
|
||||
{"eload", CmdHF14AMfELoad, 0, "Load from file emul dump"},
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue