#include "mifare.h"\r
#include "mfkey.h"\r
#include "hardnested/hardnested_bf_core.h"\r
+#include "cliparser/cliparser.h"\r
+#include "cmdhf14a.h"\r
+#include "mifare4.h"\r
\r
#define NESTED_SECTOR_RETRY 10 // how often we try mfested() until we give up\r
\r
uint8_t isOK = resp.arg[0] & 0xff;\r
uint8_t *data = resp.d.asBytes;\r
\r
- if (isOK)\r
+ if (isOK) {\r
PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 16));\r
- else\r
+ } else {\r
PrintAndLog("isOk:%02x", isOK);\r
+ return 1;\r
+ }\r
+\r
+ if (mfIsSectorTrailer(blockNo) && (data[6] || data[7] || data[8])) {\r
+ PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+ int bln = mfFirstBlockOfSector(mfSectorNum(blockNo));\r
+ int blinc = (mfNumBlocksPerSector(mfSectorNum(blockNo)) > 4) ? 5 : 1;\r
+ for (int i = 0; i < 4; i++) {\r
+ PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &data[6]));\r
+ bln += blinc;\r
+ }\r
+ PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&data[9], 1));\r
+ }\r
} else {\r
PrintAndLog("Command execute timeout");\r
+ return 2;\r
}\r
\r
return 0;\r
PrintAndLog("data : %s", sprint_hex(data + i * 16, 16));\r
}\r
PrintAndLog("trailer: %s", sprint_hex(data + (sectorNo<32?3:15) * 16, 16));\r
+ \r
+ PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+ int bln = mfFirstBlockOfSector(sectorNo);\r
+ int blinc = (mfNumBlocksPerSector(sectorNo) > 4) ? 5 : 1;\r
+ for (i = 0; i < 4; i++) {\r
+ PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &(data + (sectorNo<32?3:15) * 16)[6]));\r
+ bln += blinc;\r
+ }\r
+ PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&(data + (sectorNo<32?3:15) * 16)[9], 1));\r
}\r
} else {\r
PrintAndLog("Command execute timeout");\r
{\r
uint8_t sectorNo, blockNo;\r
\r
- uint8_t keyA[40][6];\r
- uint8_t keyB[40][6];\r
+ uint8_t keys[2][40][6];\r
uint8_t rights[40][4];\r
uint8_t carddata[256][16];\r
uint8_t numSectors = 16;\r
char cmdp = param_getchar(Cmd, 0);\r
numSectors = ParamCardSizeSectors(cmdp);\r
\r
- if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r
- PrintAndLog("Usage: hf mf dump [card memory]");\r
+ if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {\r
+ PrintAndLog("Usage: hf mf dump [card memory] [k|m]");\r
PrintAndLog(" [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
+ PrintAndLog(" k: Always try using both Key A and Key B for each sector, even if access bits would prohibit it");\r
+ PrintAndLog(" m: When missing access bits or keys, replace that block with NULL");\r
PrintAndLog("");\r
PrintAndLog("Samples: hf mf dump");\r
PrintAndLog(" hf mf dump 4");\r
+ PrintAndLog(" hf mf dump 4 m");\r
return 0;\r
}\r
\r
+ char opts = param_getchar(Cmd, 1);\r
+ bool useBothKeysAlways = false;\r
+ if (opts == 'k' || opts == 'K') useBothKeysAlways = true;\r
+ bool nullMissingKeys = false;\r
+ if (opts == 'm' || opts == 'M') nullMissingKeys = true;\r
+\r
if ((fin = fopen("dumpkeys.bin","rb")) == NULL) {\r
PrintAndLog("Could not find file dumpkeys.bin");\r
return 1;\r
}\r
\r
- // Read keys A from file\r
- for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
- size_t bytes_read = fread(keyA[sectorNo], 1, 6, fin);\r
- if (bytes_read != 6) {\r
- PrintAndLog("File reading error.");\r
- fclose(fin);\r
- return 2;\r
- }\r
- }\r
-\r
- // Read keys B from file\r
- for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
- size_t bytes_read = fread(keyB[sectorNo], 1, 6, fin);\r
- if (bytes_read != 6) {\r
- PrintAndLog("File reading error.");\r
- fclose(fin);\r
- return 2;\r
- }\r
+ // Read keys from file\r
+ for (int group=0; group<=1; group++) {\r
+ for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
+ size_t bytes_read = fread(keys[group][sectorNo], 1, 6, fin);\r
+ if (bytes_read != 6) {\r
+ PrintAndLog("File reading error.");\r
+ fclose(fin);\r
+ return 2;\r
+ }\r
+ } \r
}\r
\r
fclose(fin);\r
for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
for (tries = 0; tries < 3; tries++) {\r
UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 0, 0}};\r
- memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+ // At least the Access Conditions can always be read with key A.\r
+ memcpy(c.d.asBytes, keys[0][sectorNo], 6);\r
SendCommand(&c);\r
\r
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
for (tries = 0; tries < 3; tries++) {\r
if (blockNo == NumBlocksPerSector(sectorNo) - 1) { // sector trailer. At least the Access Conditions can always be read with key A.\r
UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
- memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+ memcpy(c.d.asBytes, keys[0][sectorNo], 6);\r
SendCommand(&c);\r
received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+ } else if (useBothKeysAlways) {\r
+ // Always try both keys, even if access conditions wouldn't work.\r
+ for (int k=0; k<=1; k++) {\r
+ UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 1, 0}};\r
+ memcpy(c.d.asBytes, keys[k][sectorNo], 6);\r
+ SendCommand(&c);\r
+ received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+\r
+ // Don't try the other one on success.\r
+ if (resp.arg[0] & 0xff) break;\r
+ }\r
} else { // data block. Check if it can be read with key A or key B\r
uint8_t data_area = sectorNo<32?blockNo:blockNo/5;\r
if ((rights[sectorNo][data_area] == 0x03) || (rights[sectorNo][data_area] == 0x05)) { // only key B would work\r
UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 1, 0}};\r
- memcpy(c.d.asBytes, keyB[sectorNo], 6);\r
+ memcpy(c.d.asBytes, keys[1][sectorNo], 6);\r
SendCommand(&c);\r
received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
} else if (rights[sectorNo][data_area] == 0x07) { // no key would work\r
- isOK = false;\r
PrintAndLog("Access rights do not allow reading of sector %2d block %3d", sectorNo, blockNo);\r
- tries = 2;\r
+ if (nullMissingKeys) {\r
+ memset(resp.d.asBytes, 0, 16);\r
+ resp.arg[0] = 1;\r
+ PrintAndLog(" ... filling the block with NULL");\r
+ received = true;\r
+ } else {\r
+ isOK = false;\r
+ tries = 2;\r
+ }\r
} else { // key A would work\r
UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
- memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+ memcpy(c.d.asBytes, keys[0][sectorNo], 6);\r
SendCommand(&c);\r
received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
}\r
isOK = resp.arg[0] & 0xff;\r
uint8_t *data = resp.d.asBytes;\r
if (blockNo == NumBlocksPerSector(sectorNo) - 1) { // sector trailer. Fill in the keys.\r
- data[0] = (keyA[sectorNo][0]);\r
- data[1] = (keyA[sectorNo][1]);\r
- data[2] = (keyA[sectorNo][2]);\r
- data[3] = (keyA[sectorNo][3]);\r
- data[4] = (keyA[sectorNo][4]);\r
- data[5] = (keyA[sectorNo][5]);\r
- data[10] = (keyB[sectorNo][0]);\r
- data[11] = (keyB[sectorNo][1]);\r
- data[12] = (keyB[sectorNo][2]);\r
- data[13] = (keyB[sectorNo][3]);\r
- data[14] = (keyB[sectorNo][4]);\r
- data[15] = (keyB[sectorNo][5]);\r
+ memcpy(data, keys[0][sectorNo], 6);\r
+ memcpy(data + 10, keys[1][sectorNo], 6);\r
}\r
if (isOK) {\r
memcpy(carddata[FirstBlockOfSector(sectorNo) + blockNo], data, 16);\r
//----------------------------------------------\r
\r
static void parseParamTDS(const char *Cmd, const uint8_t indx, bool *paramT, bool *paramD, uint8_t *timeout) {\r
- char ctmp3[3] = {0};\r
+ char ctmp3[4] = {0};\r
int len = param_getlength(Cmd, indx);\r
if (len > 0 && len < 4){\r
param_getstr(Cmd, indx, ctmp3, sizeof(ctmp3));\r
blockNo = i * 4;\r
keyType = j;\r
num_to_bytes(e_sector[i].Key[j], 6, key);\r
- \r
keyFound = true;\r
break;\r
}\r
// Can't found a key....\r
if (!keyFound) {\r
PrintAndLog("Can't found any of the known keys.");\r
+ free(e_sector);\r
return 4;\r
}\r
PrintAndLog("--auto key. block no:%3d, key type:%c key:%s", blockNo, keyType?'B':'A', sprint_hex(key, 6));\r
PrintAndLog("Usage: hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t|d|s|ss] [<key (12 hex symbols)>] [<dic (*.dic)>]");\r
PrintAndLog(" * - all sectors");\r
PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");\r
- PrintAndLog("d - write keys to binary file\n");\r
- PrintAndLog("t - write keys to emulator memory");\r
- PrintAndLog("s - slow execute. timeout 1ms");\r
- PrintAndLog("ss- very slow execute. timeout 5ms");\r
+ PrintAndLog("d - write keys to binary file\n");\r
+ PrintAndLog("t - write keys to emulator memory");\r
+ PrintAndLog("s - slow execute. timeout 1ms");\r
+ PrintAndLog("ss - very slow execute. timeout 5ms");\r
PrintAndLog(" sample: hf mf chk 0 A 1234567890ab keys.dic");\r
PrintAndLog(" hf mf chk *1 ? t");\r
PrintAndLog(" hf mf chk *1 ? d");\r
int keycnt = 0;\r
char ctmp = 0x00;\r
int clen = 0;\r
- char ctmp3[3] = {0x00};\r
uint8_t blockNo = 0;\r
uint8_t SectorsCnt = 0;\r
uint8_t keyType = 0;\r
uint64_t key64 = 0;\r
- uint32_t timeout14a = 0; // timeout in us\r
+ // timeout in units. (ms * 106)/10 or us*0.0106\r
+ uint8_t btimeout14a = MF_CHKKEYS_DEFTIMEOUT; // fast by default\r
bool param3InUse = false;\r
\r
- int transferToEml = 0;\r
- int createDumpFile = 0;\r
+ bool transferToEml = 0;\r
+ bool createDumpFile = 0;\r
\r
sector_t *e_sector = NULL;\r
\r
};\r
}\r
\r
- // transfer to emulator & create dump file\r
- ctmp = param_getchar(Cmd, 2);\r
- clen = param_getlength(Cmd, 2);\r
- if (clen == 1 && (ctmp == 't' || ctmp == 'T')) transferToEml = 1;\r
- if (clen == 1 && (ctmp == 'd' || ctmp == 'D')) createDumpFile = 1;\r
- \r
- param3InUse = transferToEml | createDumpFile;\r
+ parseParamTDS(Cmd, 2, &transferToEml, &createDumpFile, &btimeout14a);\r
\r
- timeout14a = 500; // fast by default\r
- // double parameters - ts, ds\r
- clen = param_getlength(Cmd, 2);\r
- if (clen == 2 || clen == 3){\r
- param_getstr(Cmd, 2, ctmp3, sizeof(ctmp3));\r
- ctmp = ctmp3[1];\r
- }\r
- //parse\r
- if (ctmp == 's' || ctmp == 'S') {\r
- timeout14a = 1000; // slow\r
- if (!param3InUse && clen == 2 && (ctmp3[1] == 's' || ctmp3[1] == 'S')) {\r
- timeout14a = 5000; // very slow\r
- }\r
- if (param3InUse && clen == 3 && (ctmp3[2] == 's' || ctmp3[2] == 'S')) {\r
- timeout14a = 5000; // very slow\r
- }\r
- param3InUse = true;\r
- }\r
+ param3InUse = transferToEml | createDumpFile | (btimeout14a != MF_CHKKEYS_DEFTIMEOUT);\r
\r
+ PrintAndLog("--chk keys. sectors:%2d, block no:%3d, key type:%c, eml:%c, dmp=%c checktimeout=%d us", \r
+ SectorsCnt, blockNo, keyType?'B':'A', transferToEml?'y':'n', createDumpFile?'y':'n', ((int)btimeout14a * 10000) / 106);\r
+ \r
for (i = param3InUse; param_getchar(Cmd, 2 + i); i++) {\r
if (!param_gethex(Cmd, 2 + i, keyBlock + 6 * keycnt, 12)) {\r
if ( stKeyBlock - keycnt < 2) {\r
\r
// initialize storage for found keys\r
e_sector = calloc(SectorsCnt, sizeof(sector_t));\r
- if (e_sector == NULL) return 1;\r
+ if (e_sector == NULL) {\r
+ free(keyBlock);\r
+ return 1;\r
+ }\r
for (uint8_t keyAB = 0; keyAB < 2; keyAB++) {\r
for (uint16_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {\r
e_sector[sectorNo].Key[keyAB] = 0xffffffffffff;\r
for (uint32_t c = 0; c < keycnt; c += max_keys) {\r
\r
uint32_t size = keycnt-c > max_keys ? max_keys : keycnt-c;\r
- res = mfCheckKeysSec(SectorsCnt, keyType, timeout14a * 1.06 / 100, true, size, &keyBlock[6 * c], e_sector); // timeout is (ms * 106)/10 or us*0.0106\r
+ res = mfCheckKeysSec(SectorsCnt, keyType, btimeout14a, true, size, &keyBlock[6 * c], e_sector); // timeout is (ms * 106)/10 or us*0.0106\r
\r
if (res != 1) {\r
if (!res) {\r
}\r
\r
PrintAndLog("block data:%s", sprint_hex(memBlock, 16));\r
+ \r
+ if (mfIsSectorTrailer(blockNo)) {\r
+ PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+ PrintAndLogEx(NORMAL, "Key A: %s", sprint_hex_inrow(memBlock, 6));\r
+ PrintAndLogEx(NORMAL, "Key B: %s", sprint_hex_inrow(&memBlock[10], 6));\r
+ int bln = mfFirstBlockOfSector(mfSectorNum(blockNo));\r
+ int blinc = (mfNumBlocksPerSector(mfSectorNum(blockNo)) > 4) ? 5 : 1;\r
+ for (int i = 0; i < 4; i++) {\r
+ PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &memBlock[6]));\r
+ bln += blinc;\r
+ }\r
+ PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&memBlock[9], 1));\r
+ }\r
+ \r
return 0;\r
}\r
\r
}\r
\r
PrintAndLog("block %3d data:%s", baseblock + i, sprint_hex(memBlock, 16));\r
+ \r
+ if (mfIsSectorTrailer(baseblock + i)) {\r
+ PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+ PrintAndLogEx(NORMAL, "Key A: %s", sprint_hex_inrow(memBlock, 6));\r
+ PrintAndLogEx(NORMAL, "Key B: %s", sprint_hex_inrow(&memBlock[10], 6));\r
+ int bln = baseblock;\r
+ int blinc = (mfNumBlocksPerSector(sectorNo) > 4) ? 5 : 1;\r
+ for (int i = 0; i < 4; i++) {\r
+ PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &memBlock[6]));\r
+ bln += blinc;\r
+ }\r
+ PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&memBlock[9], 1));\r
+ }\r
}\r
return 0;\r
}\r
return tryDecryptWord(param_get32ex(Cmd,0,0,16),param_get32ex(Cmd,1,0,16),param_get32ex(Cmd,2,0,16),data,len/2);\r
}\r
\r
+int CmdHF14AMfAuth4(const char *cmd) {\r
+ uint8_t keyn[20] = {0};\r
+ int keynlen = 0;\r
+ uint8_t key[16] = {0};\r
+ int keylen = 0;\r
+\r
+ CLIParserInit("hf mf auth4", \r
+ "Executes AES authentication command in ISO14443-4", \r
+ "Usage:\n\thf mf auth4 4000 000102030405060708090a0b0c0d0e0f -> executes authentication\n"\r
+ "\thf mf auth4 9003 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -> executes authentication\n");\r
+\r
+ void* argtable[] = {\r
+ arg_param_begin,\r
+ arg_str1(NULL, NULL, "<Key Num (HEX 2 bytes)>", NULL),\r
+ arg_str1(NULL, NULL, "<Key Value (HEX 16 bytes)>", NULL),\r
+ arg_param_end\r
+ };\r
+ CLIExecWithReturn(cmd, argtable, true);\r
+ \r
+ CLIGetHexWithReturn(1, keyn, &keynlen);\r
+ CLIGetHexWithReturn(2, key, &keylen);\r
+ CLIParserFree();\r
+ \r
+ if (keynlen != 2) {\r
+ PrintAndLog("ERROR: <Key Num> must be 2 bytes long instead of: %d", keynlen);\r
+ return 1;\r
+ }\r
+ \r
+ if (keylen != 16) {\r
+ PrintAndLog("ERROR: <Key Value> must be 16 bytes long instead of: %d", keylen);\r
+ return 1;\r
+ }\r
+\r
+ return MifareAuth4(NULL, keyn, key, true, false, true);\r
+}\r
+\r
static command_t CommandTable[] =\r
{\r
{"help", CmdHelp, 1, "This help"},\r
{"dump", CmdHF14AMfDump, 0, "Dump MIFARE classic tag to binary file"},\r
{"restore", CmdHF14AMfRestore, 0, "Restore MIFARE classic binary file to BLANK tag"},\r
{"wrbl", CmdHF14AMfWrBl, 0, "Write MIFARE classic block"},\r
+ {"auth4", CmdHF14AMfAuth4, 0, "ISO14443-4 AES authentication"},\r
{"chk", CmdHF14AMfChk, 0, "Test block keys"},\r
{"mifare", CmdHF14AMifare, 0, "Read parity error messages."},\r
{"hardnested", CmdHF14AMfNestedHard, 0, "Nested attack for hardened Mifare cards"},\r
\r
int CmdHFMF(const char *Cmd)\r
{\r
- // flush\r
- WaitForResponseTimeout(CMD_ACK,NULL,100);\r
-\r
- CmdsParse(CommandTable, Cmd);\r
- return 0;\r
+ (void)WaitForResponseTimeout(CMD_ACK,NULL,100);\r
+ CmdsParse(CommandTable, Cmd);\r
+ return 0;\r
}\r
\r
int CmdHelp(const char *Cmd)\r
projects / proxmark3-svn / blobdiff