//-----------------------------------------------------------------------------\r
\r
#include "cmdhfmf.h"\r
+#include "proxmark3.h"\r
\r
static int CmdHelp(const char *Cmd);\r
\r
-\r
int CmdHF14AMifare(const char *Cmd)\r
{\r
uint32_t uid = 0;\r
return 0;\r
}\r
\r
+int CmdHF14AMfDump1k(const char *Cmd)\r
+{\r
+ int i, j;\r
+ \r
+ uint8_t keyType = 0;\r
+ uint8_t c[3][4];\r
+ uint8_t keyA[16][6];\r
+ uint8_t keyB[16][6];\r
+ uint8_t rights[16][4];\r
+ \r
+ uint8_t isOK = 0;\r
+ uint8_t *data = NULL;\r
+\r
+ FILE *fin;\r
+ FILE *fout;\r
+ \r
+ UsbCommand *resp;\r
+ \r
+ if ((fin = fopen("dumpkeys.bin","rb")) == NULL) {\r
+ PrintAndLog("Could not find file keys.bin");\r
+ return 1;\r
+ }\r
+ \r
+ if ((fout = fopen("dumpdata.bin","wb")) == NULL) { \r
+ PrintAndLog("Could not create file name dump.bin");\r
+ return 1;\r
+ }\r
+ \r
+ // Read key file\r
+ \r
+ for (i=0 ; i<16 ; i++) {\r
+ fread ( keyA[i], 1, 6, fin );\r
+ }\r
+ for (i=0 ; i<16 ; i++) {\r
+ fread ( keyB[i], 1, 6, fin );\r
+ }\r
+ \r
+ // Read access rights to sectors\r
+ \r
+ PrintAndLog("|-----------------------------------------|");\r
+ PrintAndLog("|------ Reading sector access bits...-----|");\r
+ PrintAndLog("|-----------------------------------------|");\r
+ \r
+ for (i = 0 ; i < 16 ; i++) {\r
+ UsbCommand c = {CMD_MIFARE_READBL, {4*i + 3, 0, 0}};\r
+ memcpy(c.d.asBytes, keyA[i], 6);\r
+ SendCommand(&c);\r
+ resp = WaitForResponseTimeout(CMD_ACK, 1500);\r
+\r
+ if (resp != NULL) {\r
+ uint8_t isOK = resp->arg[0] & 0xff;\r
+ uint8_t *data = resp->d.asBytes;\r
+ if (isOK){\r
+ rights[i][0] = ((data[7] & 0x10)>>4) | ((data[8] & 0x1)<<1) | ((data[8] & 0x10)>>2);\r
+ rights[i][1] = ((data[7] & 0x20)>>5) | ((data[8] & 0x2)<<0) | ((data[8] & 0x20)>>3);\r
+ rights[i][2] = ((data[7] & 0x40)>>6) | ((data[8] & 0x4)>>1) | ((data[8] & 0x40)>>4);\r
+ rights[i][3] = ((data[7] & 0x80)>>7) | ((data[8] & 0x8)>>2) | ((data[8] & 0x80)>>5);\r
+ }\r
+ else{\r
+ PrintAndLog("Could not get access rights for block %d", i);\r
+ }\r
+ }\r
+ else {\r
+ PrintAndLog("Command execute timeout");\r
+ }\r
+ }\r
+ \r
+ // Read blocks and print to file\r
+ \r
+ PrintAndLog("|-----------------------------------------|");\r
+ PrintAndLog("|----- Dumping all blocks to file... -----|");\r
+ PrintAndLog("|-----------------------------------------|");\r
+ \r
+ for (i=0 ; i<16 ; i++) {\r
+ for (j=0 ; j<4 ; j++) {\r
+ \r
+ if (j == 3){\r
+ UsbCommand c = {CMD_MIFARE_READBL, {i*4 + j, 0, 0}};\r
+ memcpy(c.d.asBytes, keyA[i], 6);\r
+ SendCommand(&c);\r
+ resp = WaitForResponseTimeout(CMD_ACK, 1500);\r
+ }\r
+ else{\r
+ if ((rights[i][j] == 6) | (rights[i][j] == 5)) {\r
+ UsbCommand c = {CMD_MIFARE_READBL, {i*4+j, 1, 0}};\r
+ memcpy(c.d.asBytes, keyB[i], 6);\r
+ SendCommand(&c);\r
+ resp = WaitForResponseTimeout(CMD_ACK, 1500);\r
+ }\r
+ else if (rights[i][j] == 7) {\r
+ PrintAndLog("Access rights do not allow reading of sector %d block %d",i,j);\r
+ }\r
+ else {\r
+ UsbCommand c = {CMD_MIFARE_READBL, {i*4+j, 0, 0}};\r
+ memcpy(c.d.asBytes, keyA[i], 6);\r
+ SendCommand(&c);\r
+ resp = WaitForResponseTimeout(CMD_ACK, 1500);\r
+ }\r
+ }\r
+\r
+ if (resp != NULL) {\r
+ uint8_t isOK = resp->arg[0] & 0xff;\r
+ uint8_t *data = resp->d.asBytes;\r
+ if (isOK) {\r
+ fwrite ( data, 1, 16, fout );\r
+ }\r
+ else {\r
+ PrintAndLog("Could not get access rights for block %d", i);\r
+ }\r
+ }\r
+ else {\r
+ PrintAndLog("Command execute timeout");\r
+ }\r
+ }\r
+ }\r
+ \r
+ fclose(fin);\r
+ fclose(fout);\r
+ \r
+ return 0;\r
+}\r
+\r
+int CmdHF14AMfRestore1k(const char *Cmd)\r
+{\r
+\r
+ int i,j;\r
+ uint8_t keyType = 0;\r
+ uint8_t key[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};\r
+ uint8_t bldata[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
+ uint8_t keyA[16][6];\r
+ uint8_t keyB[16][6];\r
+ \r
+ FILE *fdump;\r
+ FILE *fkeys;\r
+ \r
+ if ((fdump = fopen("dumpdata.bin","rb")) == NULL) {\r
+ PrintAndLog("Could not find file dump.bin");\r
+ return 1;\r
+ }\r
+ if ((fkeys = fopen("dumpkeys.bin","rb")) == NULL) {\r
+ PrintAndLog("Could not find file keys.bin");\r
+ return 1;\r
+ }\r
+ \r
+ for (i=0 ; i<16 ; i++) {\r
+ fread(keyA[i], 1, 6, fkeys);\r
+ }\r
+ for (i=0 ; i<16 ; i++) {\r
+ fread(keyB[i], 1, 6, fkeys);\r
+ }\r
+ \r
+ PrintAndLog("going...");\r
+\r
+ for (i=0 ; i<16 ; i++) {\r
+ for( j=0 ; j<4 ; j++) {\r
+ UsbCommand c = {CMD_MIFARE_WRITEBL, {i*4 + j, keyType, 0}};\r
+ memcpy(c.d.asBytes, key, 6);\r
+ \r
+ fread(bldata, 1, 16, fdump);\r
+ \r
+ if (j == 3) {\r
+ bldata[0] = (keyA[i][0]);\r
+ bldata[1] = (keyA[i][1]);\r
+ bldata[2] = (keyA[i][2]);\r
+ bldata[3] = (keyA[i][3]);\r
+ bldata[4] = (keyA[i][4]);\r
+ bldata[5] = (keyA[i][5]);\r
+ bldata[10] = (keyB[i][0]);\r
+ bldata[11] = (keyB[i][1]);\r
+ bldata[12] = (keyB[i][2]);\r
+ bldata[13] = (keyB[i][3]);\r
+ bldata[14] = (keyB[i][4]);\r
+ bldata[15] = (keyB[i][5]);\r
+ } \r
+ \r
+ PrintAndLog("writing to block %2d: %s confirm?", i*4+j, sprint_hex(bldata, 16));\r
+ \r
+ memcpy(c.d.asBytes + 10, bldata, 16);\r
+ SendCommand(&c);\r
+ UsbCommand *resp = WaitForResponseTimeout(CMD_ACK, 1500);\r
+\r
+ if (resp != NULL) {\r
+ uint8_t isOK = resp->arg[0] & 0xff;\r
+ PrintAndLog("isOk:%02x", isOK);\r
+ } else {\r
+ PrintAndLog("Command execute timeout");\r
+ }\r
+ }\r
+ }\r
+ \r
+ fclose(fdump);\r
+ fclose(fkeys);\r
+ return 0;\r
+}\r
+\r
int CmdHF14AMfNested(const char *Cmd)\r
{\r
int i, j, res, iterations;\r
uint8_t key[6] = {0, 0, 0, 0, 0, 0};\r
uint8_t keyBlock[16 * 6];\r
uint64_t key64 = 0;\r
+ int transferToEml = 0;\r
+ \r
+ int createDumpFile = 0;\r
+ FILE *fkeys;\r
\r
char cmdp, ctmp;\r
\r
if (strlen(Cmd)<3) {\r
PrintAndLog("Usage:");\r
- PrintAndLog(" all sectors: hf mf nested <card memory> <block number> <key A/B> <key (12 hex symbols)>");\r
+ PrintAndLog(" all sectors: hf mf nested <card memory> <block number> <key A/B> <key (12 hex symbols)> [t,d]");\r
PrintAndLog(" one sector: hf mf nested o <block number> <key A/B> <key (12 hex symbols)>");\r
- PrintAndLog(" <target block number> <target key A/B>");\r
+ PrintAndLog(" <target block number> <target key A/B> [t]");\r
PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");\r
+ PrintAndLog("t - transfer keys into emulator memory");\r
+ PrintAndLog("d - write keys to binary file");\r
PrintAndLog(" ");\r
PrintAndLog(" sample1: hf mf nested 1 0 A FFFFFFFFFFFF ");\r
+ PrintAndLog(" sample1: hf mf nested 1 0 A FFFFFFFFFFFF t ");\r
+ PrintAndLog(" sample1: hf mf nested 1 0 A FFFFFFFFFFFF d ");\r
PrintAndLog(" sample2: hf mf nested o 0 A FFFFFFFFFFFF 4 A");\r
return 0;\r
} \r
return 1;\r
}\r
\r
- if (cmdp =='o' || cmdp == 'O') {\r
+ if (cmdp == 'o' || cmdp == 'O') {\r
cmdp = 'o';\r
trgBlockNo = param_get8(Cmd, 4);\r
ctmp = param_getchar(Cmd, 5);\r
default: SectorsCnt = 16;\r
}\r
}\r
+\r
+ ctmp = param_getchar(Cmd, 4);\r
+ if (ctmp == 't' || ctmp == 'T') transferToEml = 1;\r
+ ctmp = param_getchar(Cmd, 6);\r
+ transferToEml |= (ctmp == 't' || ctmp == 'T');\r
+ createDumpFile |= (ctmp == 'd' || ctmp == 'D');\r
\r
- PrintAndLog("--block no:%02x key type:%02x key:%s ", blockNo, keyType, sprint_hex(key, 6));\r
+ PrintAndLog("--block no:%02x key type:%02x key:%s etrans:%d", blockNo, keyType, sprint_hex(key, 6), transferToEml);\r
if (cmdp == 'o')\r
PrintAndLog("--target block no:%02x target key type:%02x ", trgBlockNo, trgKeyType);\r
\r
res = mfCheckKeys(trgBlockNo, trgKeyType, 8, keyBlock, &key64);\r
if (res)\r
res = mfCheckKeys(trgBlockNo, trgKeyType, 8, &keyBlock[6 * 8], &key64);\r
- if (!res)\r
+ if (!res) {\r
PrintAndLog("Found valid key:%012llx", key64);\r
- else\r
+\r
+ // transfer key to the emulator\r
+ if (transferToEml) {\r
+ mfEmlGetMem(keyBlock, (trgBlockNo / 4) * 4 + 3, 1);\r
+ \r
+ if (!trgKeyType)\r
+ num_to_bytes(key64, 6, keyBlock);\r
+ else\r
+ num_to_bytes(key64, 6, &keyBlock[10]);\r
+ mfEmlSetMem(keyBlock, (trgBlockNo / 4) * 4 + 3, 1); \r
+ }\r
+ } else {\r
PrintAndLog("No valid key found");\r
+ }\r
} else // ------------------------------------ multiple sectors working\r
{\r
blDiff = blockNo % 4;\r
}\r
PrintAndLog("|---|----------------|---|----------------|---|");\r
\r
+ // transfer them to the emulator\r
+ if (transferToEml) {\r
+ for (i = 0; i < SectorsCnt; i++) {\r
+ mfEmlGetMem(keyBlock, i * 4 + 3, 1);\r
+ if (e_sector[i].foundKey[0])\r
+ num_to_bytes(e_sector[i].Key[0], 6, keyBlock);\r
+ if (e_sector[i].foundKey[1])\r
+ num_to_bytes(e_sector[i].Key[1], 6, &keyBlock[10]);\r
+ mfEmlSetMem(keyBlock, i * 4 + 3, 1);\r
+ } \r
+ }\r
+ \r
+ if (createDumpFile) {\r
+ if ((fkeys = fopen("dumpkeys.bin","wb")) == NULL) { \r
+ PrintAndLog("Could not create file keys.bin");\r
+ free(e_sector);\r
+ return 1;\r
+ }\r
+ for(i=0; i<16; i++) {\r
+ fwrite ( e_sector[i].Key, sizeof(e_sector[i].Key[0]), 1, fkeys );\r
+ }\r
+ for(i=0; i<16; i++) {\r
+ fwrite ( e_sector[i].Key, sizeof(e_sector[i].Key[1]), 1, fkeys );\r
+ }\r
+ fclose(fkeys);\r
+ }\r
+ \r
free(e_sector);\r
}\r
\r
\r
if (strlen(Cmd)<3) {\r
PrintAndLog("Usage: hf mf chk <block number> <key A/B> [<key (12 hex symbols)>]");\r
- PrintAndLog(" sample: hf mf chk 0 A FFFFFFFFFFFF a0a1a2a3a4a5 b01b2b3b4b5 ");\r
+ PrintAndLog(" sample: hf mf chk 0 A FFFFFFFFFFFF a0a1a2a3a4a5 b0b1b2b3b4b5 ");\r
return 0;\r
} \r
\r
\r
int CmdHF14AMfDbg(const char *Cmd)\r
{\r
- if (strlen(Cmd) < 1) {\r
+ int dbgMode = param_get32ex(Cmd, 0, 0, 10);\r
+ if (dbgMode > 4) {\r
+ PrintAndLog("Max debud mode parameter is 4 \n");\r
+ }\r
+\r
+ if (strlen(Cmd) < 1 || !param_getchar(Cmd, 0) || dbgMode > 4) {\r
PrintAndLog("Usage: hf mf dbg <debug level>");\r
PrintAndLog(" 0 - no debug messages");\r
PrintAndLog(" 1 - error messages");\r
return 0;\r
} \r
\r
- PrintAndLog("No code here (");\r
+ UsbCommand c = {CMD_MIFARE_SET_DBGMODE, {dbgMode, 0, 0}};\r
+ SendCommand(&c);\r
+\r
return 0;\r
}\r
\r
int CmdHF14AMfEGet(const char *Cmd)\r
{\r
- PrintAndLog("No code here (");\r
+ uint8_t blockNo = 0;\r
+ uint8_t data[3 * 16];\r
+ int i;\r
+\r
+ if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
+ PrintAndLog("Usage: hf mf eget <block number>");\r
+ PrintAndLog(" sample: hf mf eget 0 ");\r
+ return 0;\r
+ } \r
+ \r
+ blockNo = param_get8(Cmd, 0);\r
+ if (blockNo >= 16 * 4) {\r
+ PrintAndLog("Block number must be in [0..63] as in MIFARE classic.");\r
+ return 1;\r
+ }\r
+\r
+ PrintAndLog(" ");\r
+ if (!mfEmlGetMem(data, blockNo, 3)) {\r
+ for (i = 0; i < 3; i++) {\r
+ PrintAndLog("data[%d]:%s", blockNo + i, sprint_hex(data + i * 16, 16));\r
+ }\r
+ } else {\r
+ PrintAndLog("Command execute timeout");\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+int CmdHF14AMfEClear(const char *Cmd)\r
+{\r
+ if (param_getchar(Cmd, 0) == 'h') {\r
+ PrintAndLog("Usage: hf mf eclr");\r
+ PrintAndLog("It set card emulator memory to empty data blocks and key A/B FFFFFFFFFFFF \n");\r
+ return 0;\r
+ } \r
+\r
+ UsbCommand c = {CMD_MIFARE_EML_MEMCLR, {0, 0, 0}};\r
+ SendCommand(&c);\r
return 0;\r
}\r
\r
int CmdHF14AMfESet(const char *Cmd)\r
{\r
- PrintAndLog("No code here (");\r
+ uint8_t memBlock[16];\r
+ uint8_t blockNo = 0;\r
+\r
+ memset(memBlock, 0x00, sizeof(memBlock));\r
+\r
+ if (strlen(Cmd) < 3 || param_getchar(Cmd, 0) == 'h') {\r
+ PrintAndLog("Usage: hf mf eset <block number> <block data (32 hex symbols)>");\r
+ PrintAndLog(" sample: hf mf eset 1 000102030405060708090a0b0c0d0e0f ");\r
+ return 0;\r
+ } \r
+ \r
+ blockNo = param_get8(Cmd, 0);\r
+ if (blockNo >= 16 * 4) {\r
+ PrintAndLog("Block number must be in [0..63] as in MIFARE classic.");\r
+ return 1;\r
+ }\r
+ \r
+ if (param_gethex(Cmd, 1, memBlock, 32)) {\r
+ PrintAndLog("block data must include 32 HEX symbols");\r
+ return 1;\r
+ }\r
+ \r
+ // 1 - blocks count\r
+ UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNo, 1, 0}};\r
+ memcpy(c.d.asBytes, memBlock, 16);\r
+ SendCommand(&c);\r
return 0;\r
}\r
\r
int CmdHF14AMfELoad(const char *Cmd)\r
{\r
- PrintAndLog("No code here (");\r
+ FILE * f;\r
+ char filename[20];\r
+ char * fnameptr = filename;\r
+ char buf[64];\r
+ uint8_t buf8[64];\r
+ int i, len, blockNum;\r
+ \r
+ memset(filename, 0, sizeof(filename));\r
+ memset(buf, 0, sizeof(buf));\r
+\r
+ if (param_getchar(Cmd, 0) == 'h') {\r
+ PrintAndLog("It loads emul dump from the file `filename.eml`");\r
+ PrintAndLog("Usage: hf mf eload <file name w/o `.eml`>");\r
+ PrintAndLog(" sample: hf mf eload filename");\r
+ return 0;\r
+ } \r
+\r
+ len = strlen(Cmd);\r
+ if (len > 14) len = 14;\r
+ \r
+ if (len < 1) {\r
+ }\r
+\r
+ memcpy(filename, Cmd, len);\r
+ fnameptr += len;\r
+\r
+ sprintf(fnameptr, ".eml"); \r
+ \r
+ // open file\r
+ f = fopen(filename, "r");\r
+ if (f == NULL) {\r
+ PrintAndLog("File not found or locked.");\r
+ return 1;\r
+ }\r
+ \r
+ blockNum = 0;\r
+ while(!feof(f)){\r
+ memset(buf, 0, sizeof(buf));\r
+ fgets(buf, sizeof(buf), f);\r
+ if (strlen(buf) < 32){\r
+ PrintAndLog("File content error. Block data must include 32 HEX symbols");\r
+ return 2;\r
+ }\r
+ for (i = 0; i < 32; i += 2)\r
+ sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r
+// PrintAndLog("data[%02d]:%s", blockNum, sprint_hex(buf8, 16));\r
+\r
+ if (mfEmlSetMem(buf8, blockNum, 1)) {\r
+ PrintAndLog("Cant set emul block: %d", blockNum);\r
+ return 3;\r
+ }\r
+ blockNum++;\r
+ \r
+ if (blockNum >= 16 * 4) break;\r
+ }\r
+ fclose(f);\r
+ \r
+ if (blockNum != 16 * 4){\r
+ PrintAndLog("File content error. There must be 64 blocks");\r
+ return 4;\r
+ }\r
+ PrintAndLog("Loaded from file: %s", filename);\r
return 0;\r
}\r
\r
int CmdHF14AMfESave(const char *Cmd)\r
{\r
- PrintAndLog("No code here (");\r
+ FILE * f;\r
+ char filename[20];\r
+ char * fnameptr = filename;\r
+ uint8_t buf[64];\r
+ int i, j, len;\r
+ \r
+ memset(filename, 0, sizeof(filename));\r
+ memset(buf, 0, sizeof(buf));\r
+\r
+ if (param_getchar(Cmd, 0) == 'h') {\r
+ PrintAndLog("It saves emul dump into the file `filename.eml` or `cardID.eml`");\r
+ PrintAndLog("Usage: hf mf esave [file name w/o `.eml`]");\r
+ PrintAndLog(" sample: hf mf esave ");\r
+ PrintAndLog(" hf mf esave filename");\r
+ return 0;\r
+ } \r
+\r
+ len = strlen(Cmd);\r
+ if (len > 14) len = 14;\r
+ \r
+ if (len < 1) {\r
+ // get filename\r
+ if (mfEmlGetMem(buf, 0, 1)) {\r
+ PrintAndLog("Cant get block: %d", 0);\r
+ return 1;\r
+ }\r
+ for (j = 0; j < 7; j++, fnameptr += 2)\r
+ sprintf(fnameptr, "%02x", buf[j]); \r
+ } else {\r
+ memcpy(filename, Cmd, len);\r
+ fnameptr += len;\r
+ }\r
+\r
+ sprintf(fnameptr, ".eml"); \r
+ \r
+ // open file\r
+ f = fopen(filename, "w+");\r
+\r
+ // put hex\r
+ for (i = 0; i < 16 * 4; i++) {\r
+ if (mfEmlGetMem(buf, i, 1)) {\r
+ PrintAndLog("Cant get block: %d", i);\r
+ break;\r
+ }\r
+ for (j = 0; j < 16; j++)\r
+ fprintf(f, "%02x", buf[j]); \r
+ fprintf(f,"\n");\r
+ }\r
+ fclose(f);\r
+ \r
+ PrintAndLog("Saved to file: %s", filename);\r
+ \r
return 0;\r
}\r
\r
-static command_t CommandTable[] = \r
+int CmdHF14AMfECFill(const char *Cmd)\r
+{\r
+ uint8_t keyType = 0;\r
+\r
+ if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
+ PrintAndLog("Usage: hf mf efill <key A/B>");\r
+ PrintAndLog("sample: hf mf efill A");\r
+ PrintAndLog("Card data blocks transfers to card emulator memory.");\r
+ PrintAndLog("Keys must be laid in the simulator memory. \n");\r
+ return 0;\r
+ } \r
+\r
+ char ctmp = param_getchar(Cmd, 0);\r
+ if (ctmp == 0x00) {\r
+ PrintAndLog("Key type must be A or B");\r
+ return 1;\r
+ }\r
+ if (ctmp != 'A' && ctmp != 'a') keyType = 1;\r
+\r
+ UsbCommand c = {CMD_MIFARE_EML_CARDLOAD, {0, keyType, 0}};\r
+ SendCommand(&c);\r
+ return 0;\r
+}\r
+\r
+int CmdHF14AMfEKeyPrn(const char *Cmd)\r
+{\r
+ int i;\r
+ uint8_t data[16];\r
+ uint64_t keyA, keyB;\r
+ \r
+ PrintAndLog("|---|----------------|----------------|");\r
+ PrintAndLog("|sec|key A |key B |");\r
+ PrintAndLog("|---|----------------|----------------|");\r
+ for (i = 0; i < 16; i++) {\r
+ if (mfEmlGetMem(data, i * 4 + 3, 1)) {\r
+ PrintAndLog("error get block %d", i * 4 + 3);\r
+ break;\r
+ }\r
+ keyA = bytes_to_num(data, 6);\r
+ keyB = bytes_to_num(data + 10, 6);\r
+ PrintAndLog("|%03d| %012llx | %012llx |", i, keyA, keyB);\r
+ }\r
+ PrintAndLog("|---|----------------|----------------|");\r
+ \r
+ return 0;\r
+}\r
+\r
+static command_t CommandTable[] =\r
{\r
- {"help", CmdHelp, 1, "This help"},\r
- {"dbg", CmdHF14AMfDbg, 0, "Set default debug mode"},\r
+ {"help", CmdHelp, 1, "This help"},\r
+ {"dbg", CmdHF14AMfDbg, 0, "Set default debug mode"},\r
{"rdbl", CmdHF14AMfRdBl, 0, "Read MIFARE classic block"},\r
{"rdsc", CmdHF14AMfRdSc, 0, "Read MIFARE classic sector"},\r
+ {"dump1k", CmdHF14AMfDump1k, 0, "Dump MIFARE classic tag to binary file"},\r
+ {"restore1k", CmdHF14AMfRestore1k, 0, "Restore MIFARE classic binary file to BLANK tag"},\r
{"wrbl", CmdHF14AMfWrBl, 0, "Write MIFARE classic block"},\r
- {"chk", CmdHF14AMfChk, 0, "Test block up to 8 keys"},\r
+ {"chk", CmdHF14AMfChk, 0, "Test block up to 8 keys"},\r
{"mifare", CmdHF14AMifare, 0, "Read parity error messages. param - <used card nonce>"},\r
{"nested", CmdHF14AMfNested, 0, "Test nested authentication"},\r
- {"sim", CmdHF14AMf1kSim, 0, "Simulate MIFARE 1k card"},\r
- {"eget", CmdHF14AMfEGet, 0, "Set simulator memory block"},\r
- {"eset", CmdHF14AMfESet, 0, "Get simulator memory block"},\r
+ {"sim", CmdHF14AMf1kSim, 0, "Simulate MIFARE 1k card"},\r
+ {"eclr", CmdHF14AMfEClear, 0, "Clear simulator memory block"},\r
+ {"eget", CmdHF14AMfEGet, 0, "Get simulator memory block"},\r
+ {"eset", CmdHF14AMfESet, 0, "Set simulator memory block"},\r
{"eload", CmdHF14AMfELoad, 0, "Load from file emul dump"},\r
{"esave", CmdHF14AMfESave, 0, "Save to file emul dump"},\r
+ {"ecfill", CmdHF14AMfECFill, 0, "Fill simulator memory with help of keys from simulator"},\r
+ {"ekeyprn", CmdHF14AMfEKeyPrn, 0, "Print keys from simulator memory"},\r
{NULL, NULL, 0, NULL}\r
};\r
\r
projects / proxmark3-svn / blobdiff