X-Git-Url: http://cvs.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/df007486f5119620e09930b030c29b62e67bb0b4..793c30125088b0e8e4cf3548cb852ac71efd505c:/client/cmdhfmf.c
diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index 1988fa16..0ea171af 100644
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -31,6 +31,8 @@ int usage_hf14_mf1ksim(void){
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)");
+ PrintAndLog(" e (Optional) Fill simulator keys from what we crack");
+ PrintAndLog(" v (Optional) Show maths used for cracking reader. Useful for debugging.");
PrintAndLog("samples:");
PrintAndLog(" hf mf sim u 0a0a0a0a");
PrintAndLog(" hf mf sim u 11223344556677");
@@ -125,6 +127,21 @@ int usage_hf14_chk(void){
PrintAndLog(" hf mf chk *1 ? d -- target all blocks, all keys, 1K, write to file");
return 0;
}
+int usage_hf14_keybrute(void){
+ PrintAndLog("J_Run's 2nd phase of multiple sector nested authentication key recovery");
+ PrintAndLog("You have a known 4 last bytes of a key recovered with mf_nonce_brute tool.");
+ PrintAndLog("First 2 bytes of key will be bruteforced");
+ PrintAndLog("");
+ PrintAndLog("Usage: hf mf keybrute [h] <block number> <A|B> <key>");
+ PrintAndLog("options:");
+ PrintAndLog(" h this help");
+ PrintAndLog(" <block number> target block number");
+ PrintAndLog(" <A|B> target key type");
+ PrintAndLog(" <key> candidate key from mf_nonce_brute tool");
+ PrintAndLog("samples:");
+ PrintAndLog(" hf mf keybrute 1 A 000011223344");
+ return 0;
+}
int CmdHF14AMifare(const char *Cmd) {
uint32_t uid = 0;
@@ -197,18 +214,22 @@ start:
}
}
printf("\n");
+ // error
+ if (isOK != 1) return 1;
- // par == 0
- if (isOK == -1 && par_list == 0) {
- if (!nonce2key_ex(uid, nt, nr, ks_list, &r_key) ){
+ if (par_list == 0 && ks_list != 0) {
+ // this special attack when parities is zero, uses checkkeys. Which now with block/keytype option also needs.
+ // but it uses 0|1 instead of 0x60|0x61...
+ if (nonce2key_ex(blockNo, keytype - 0x60 , uid, nt, nr, ks_list, &r_key) ){
+ PrintAndLog("Trying again with a different reader nonce...");
+ c.arg[0] = false;
+ goto start;
+ } else {
PrintAndLog("Found valid key: %012"llx" \n", r_key);
goto END;
}
}
-
- // error
- if (isOK != 1) return 1;
-
+
// execute original function from util nonce2key
if (nonce2key(uid, nt, nr, par_list, ks_list, &r_key)) {
isOK = 2;
@@ -217,6 +238,16 @@ start:
c.arg[0] = false;
goto start;
} else {
+
+ // nonce2key found a candidate key. Lets verify it.
+ uint8_t keyblock[] = {0,0,0,0,0,0};
+ num_to_bytes(r_key, 6, keyblock);
+ uint64_t key64 = 0;
+ int res = mfCheckKeys(blockNo, keytype - 0x60 , false, 1, keyblock, &key64);
+ if ( res > 0 ) {
+ PrintAndLog("Candidate Key found (%012"llx") - Test authentication failed. [%d] Restarting darkside attack", r_key, res);
+ goto start;
+ }
PrintAndLog("Found valid key: %012"llx" \n", r_key);
}
END:
@@ -443,6 +474,7 @@ int CmdHF14AMfDump(const char *Cmd) {
if ( bytes_read == 0) {
PrintAndLog("File reading error.");
fclose(fin);
+ fin = NULL;
return 2;
}
}
@@ -453,12 +485,14 @@ int CmdHF14AMfDump(const char *Cmd) {
if ( bytes_read == 0) {
PrintAndLog("File reading error.");
fclose(fin);
+ fin = NULL;
return 2;
}
}
fclose(fin);
-
+ fin = NULL;
+
PrintAndLog("|-----------------------------------------|");
PrintAndLog("|------ Reading sector access bits...-----|");
PrintAndLog("|-----------------------------------------|");
@@ -564,6 +598,7 @@ int CmdHF14AMfDump(const char *Cmd) {
uint16_t numblocks = FirstBlockOfSector(numSectors - 1) + NumBlocksPerSector(numSectors - 1);
fwrite(carddata, 1, 16*numblocks, fout);
fclose(fout);
+ fout = NULL;
PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks);
}
@@ -612,6 +647,7 @@ int CmdHF14AMfRestore(const char *Cmd) {
if ( bytes_read == 0) {
PrintAndLog("File reading error (dumpkeys.bin).");
fclose(fkeys);
+ fkeys = NULL;
return 2;
}
}
@@ -621,6 +657,7 @@ int CmdHF14AMfRestore(const char *Cmd) {
if ( bytes_read == 0) {
PrintAndLog("File reading error (dumpkeys.bin).");
fclose(fkeys);
+ fkeys = NULL;
return 2;
}
}
@@ -641,6 +678,7 @@ int CmdHF14AMfRestore(const char *Cmd) {
if ( bytes_read == 0) {
PrintAndLog("File reading error (dumpdata.bin).");
fclose(fdump);
+ fdump = NULL;
return 2;
}
@@ -676,6 +714,7 @@ int CmdHF14AMfRestore(const char *Cmd) {
}
fclose(fdump);
+ fdump = NULL;
return 0;
}
@@ -1018,7 +1057,8 @@ int CmdHF14AMfNestedHard(const char *Cmd) {
slow ? "Yes" : "No",
tests);
- int16_t isOK = mfnestedhard(blockNo, keyType, key, trgBlockNo, trgKeyType, know_target_key?trgkey:NULL, nonce_file_read, nonce_file_write, slow, tests);
+ uint64_t foundkey = 0;
+ int16_t isOK = mfnestedhard(blockNo, keyType, key, trgBlockNo, trgKeyType, know_target_key ? trgkey : NULL, nonce_file_read, nonce_file_write, slow, tests, &foundkey);
if (isOK) {
switch (isOK) {
@@ -1323,10 +1363,10 @@ int CmdHF14AMfChk(const char *Cmd) {
#define ATTACK_KEY_COUNT 8
sector *k_sector = NULL;
uint8_t k_sectorsCount = 16;
-void readerAttack(nonces_t data[], bool setEmulatorMem) {
+void readerAttack(nonces_t data[], bool setEmulatorMem, bool verbose) {
// initialize storage for found keys
- if (k_sector == NULL);
+ if (k_sector == NULL)
k_sector = calloc(k_sectorsCount, sizeof(sector));
if (k_sector == NULL)
return;
@@ -1344,8 +1384,10 @@ void readerAttack(nonces_t data[], bool setEmulatorMem) {
printf("enter reader attack\n");
for (uint8_t i = 0; i < ATTACK_KEY_COUNT; ++i) {
if (data[i].ar2 > 0) {
-
- if (tryMfk32(data[i], &key)) {
+
+ // We can probably skip this, mfkey32v2 is more reliable.
+#ifdef HFMF_TRYMFK32
+ if (tryMfk32(data[i], &key, verbose)) {
PrintAndLog("Found Key%s for sector %02d: [%012"llx"]"
, (data[i].keytype) ? "B" : "A"
, data[i].sector
@@ -1360,22 +1402,43 @@ void readerAttack(nonces_t data[], bool setEmulatorMem) {
uint8_t memBlock[16] = {0,0,0,0,0,0, 0xff, 0x0F, 0x80, 0x69, 0,0,0,0,0,0};
num_to_bytes( k_sector[i].Key[0], 6, memBlock);
num_to_bytes( k_sector[i].Key[1], 6, memBlock+10);
- mfEmlSetMem( memBlock, i*4 + 3, 1);
PrintAndLog("Setting Emulator Memory Block %02d: [%s]"
- , i*4 + 3
+ , ((data[i].sector)*4) + 3
, sprint_hex( memBlock, sizeof(memBlock))
);
+ mfEmlSetMem( memBlock, ((data[i].sector)*4) + 3, 1);
}
- break;
+ continue;
}
+#endif
//moebius attack
- // if (tryMfk32_moebius(data[i+ATTACK_KEY_COUNT], &key)) {
- // PrintAndLog("M-Found Key%s for sector %02d: [%012"llx"]"
- // ,(data[i+ATTACK_KEY_COUNT].keytype) ? "B" : "A"
- // , data[i+ATTACK_KEY_COUNT].sector
- // , key
- // );
- // }
+ if (tryMfk32_moebius(data[i+ATTACK_KEY_COUNT], &key, verbose)) {
+ uint8_t sectorNum = data[i+ATTACK_KEY_COUNT].sector;
+ uint8_t keyType = data[i+ATTACK_KEY_COUNT].keytype;
+
+ PrintAndLog("M-Found Key%s for sector %02d: [%012"llx"]"
+ , keyType ? "B" : "A"
+ , sectorNum
+ , key
+ );
+
+ k_sector[sectorNum].Key[keyType] = key;
+ k_sector[sectorNum].foundKey[keyType] = TRUE;
+
+ //set emulator memory for keys
+ if (setEmulatorMem) {
+ uint8_t memBlock[16] = {0,0,0,0,0,0, 0xff, 0x0F, 0x80, 0x69, 0,0,0,0,0,0};
+ num_to_bytes( k_sector[sectorNum].Key[0], 6, memBlock);
+ num_to_bytes( k_sector[sectorNum].Key[1], 6, memBlock+10);
+ PrintAndLog("Setting Emulator Memory Block %02d: [%s]"
+ , (sectorNum*4) + 3
+ , sprint_hex( memBlock, sizeof(memBlock))
+ );
+ mfEmlSetMem( memBlock, (sectorNum*4) + 3, 1);
+ }
+ continue;
+ }
+
}
}
}
@@ -1385,11 +1448,14 @@ int CmdHF14AMf1kSim(const char *Cmd) {
uint8_t uid[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
uint8_t exitAfterNReads = 0;
uint8_t flags = (FLAG_UID_IN_EMUL | FLAG_4B_UID_IN_DATA);
- int uidlen = 0;
+ int uidlen = 0;
bool setEmulatorMem = false;
uint8_t cmdp = 0;
bool errors = false;
+ // If set to true, we should show our workings when doing NR_AR_ATTACK.
+ bool verbose = false;
+
while(param_getchar(Cmd, cmdp) != 0x00) {
switch(param_getchar(Cmd, cmdp)) {
case 'e':
@@ -1421,6 +1487,11 @@ int CmdHF14AMf1kSim(const char *Cmd) {
}
cmdp +=2;
break;
+ case 'v':
+ case 'V':
+ verbose = true;
+ cmdp++;
+ break;
case 'x':
case 'X':
flags |= FLAG_NR_AR_ATTACK;
@@ -1460,12 +1531,13 @@ int CmdHF14AMf1kSim(const char *Cmd) {
if ( (resp.arg[0] & 0xffff) != CMD_SIMULATE_MIFARE_CARD ) break;
memcpy( data, resp.d.asBytes, sizeof(data) );
- readerAttack(data, setEmulatorMem);
+ readerAttack(data, setEmulatorMem, verbose);
}
if (k_sector != NULL) {
printKeyTable(k_sectorsCount, k_sector );
free(k_sector);
+ k_sector = NULL;
}
}
return 0;
@@ -1639,6 +1711,43 @@ int CmdHF14AMfDbg(const char *Cmd) {
return 0;
}
+int CmdHF14AMfKeyBrute(const char *Cmd) {
+
+ uint8_t blockNo = 0, keytype = 0;
+ uint8_t key[6] = {0, 0, 0, 0, 0, 0};
+ uint64_t foundkey = 0;
+
+ char cmdp = param_getchar(Cmd, 0);
+ if ( cmdp == 'H' || cmdp == 'h') return usage_hf14_keybrute();
+
+ // block number
+ blockNo = param_get8(Cmd, 0);
+
+ // keytype
+ cmdp = param_getchar(Cmd, 1);
+ if (cmdp == 'B' || cmdp == 'b') keytype = 1;
+
+ // key
+ if (param_gethex(Cmd, 2, key, 12)) return usage_hf14_keybrute();
+
+ clock_t t1 = clock();
+ time_t start, end;
+ time(&start);
+
+ if (mfKeyBrute( blockNo, keytype, key, &foundkey))
+ PrintAndLog("Found valid key: %012"llx" \n", foundkey);
+ else
+ PrintAndLog("Key not found");
+
+ t1 = clock() - t1;
+ time(&end);
+ unsigned long elapsed_time = difftime(end, start);
+ if ( t1 > 0 )
+ PrintAndLog("\nTime in keybrute: %.0f ticks %u seconds\n", (float)t1, elapsed_time);
+
+ return 0;
+}
+
void printKeyTable( uint8_t sectorscnt, sector *e_sector ){
PrintAndLog("|---|----------------|---|----------------|---|");
PrintAndLog("|sec|key A |res|key B |res|");
@@ -2379,10 +2488,11 @@ static command_t CommandTable[] = {
{"dump", CmdHF14AMfDump, 0, "Dump MIFARE classic tag to binary file"},
{"restore", CmdHF14AMfRestore, 0, "Restore MIFARE classic binary file to BLANK tag"},
{"wrbl", CmdHF14AMfWrBl, 0, "Write MIFARE classic block"},
- {"chk", CmdHF14AMfChk, 0, "Test block keys"},
- {"mifare", CmdHF14AMifare, 0, "Read parity error messages."},
- {"nested", CmdHF14AMfNested, 0, "Test nested authentication"},
+ {"chk", CmdHF14AMfChk, 0, "Check keys"},
+ {"mifare", CmdHF14AMifare, 0, "Darkside attack. read parity error messages."},
+ {"nested", CmdHF14AMfNested, 0, "Nested attack. Test nested authentication"},
{"hardnested", CmdHF14AMfNestedHard, 0, "Nested attack for hardened Mifare cards"},
+ {"keybrute", CmdHF14AMfKeyBrute, 0, "J_Run's 2nd phase of multiple sector nested authentication key recovery"},
{"sniff", CmdHF14AMfSniff, 0, "Sniff card-reader communication"},
{"sim", CmdHF14AMf1kSim, 0, "Simulate MIFARE card"},
{"eclr", CmdHF14AMfEClear, 0, "Clear simulator memory block"},