X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/b13fa4448f517b46e917c5145050f434d6df24d5..3d83b58b50a328b2bedd63cb102158a8c43c07ef:/client/mifarehost.c
diff --git a/client/mifarehost.c b/client/mifarehost.c
index 03951e2d..6716f7eb 100644
--- a/client/mifarehost.c
+++ b/client/mifarehost.c
@@ -26,8 +26,6 @@ int compar_int(const void * a, const void * b) {
else return -1;
}
-
-
// Compare 16 Bits out of cryptostate
int Compare16Bits(const void * a, const void * b) {
if ((*(uint64_t*)b & 0x00ff000000ff0000) == (*(uint64_t*)a & 0x00ff000000ff0000)) return 0;
@@ -35,17 +33,16 @@ int Compare16Bits(const void * a, const void * b) {
else return -1;
}
-
typedef
struct {
union {
struct Crypto1State *slhead;
uint64_t *keyhead;
- };
+ } head;
union {
struct Crypto1State *sltail;
uint64_t *keytail;
- };
+ } tail;
uint32_t len;
uint32_t uid;
uint32_t blockNo;
@@ -61,25 +58,20 @@ void* nested_worker_thread(void *arg)
struct Crypto1State *p1;
StateList_t *statelist = arg;
- statelist->slhead = lfsr_recovery32(statelist->ks1, statelist->nt ^ statelist->uid);
- for (p1 = statelist->slhead; *(uint64_t *)p1 != 0; p1++);
- statelist->len = p1 - statelist->slhead;
- statelist->sltail = --p1;
- qsort(statelist->slhead, statelist->len, sizeof(uint64_t), Compare16Bits);
+ statelist->head.slhead = lfsr_recovery32(statelist->ks1, statelist->nt ^ statelist->uid);
+ for (p1 = statelist->head.slhead; *(uint64_t *)p1 != 0; p1++);
+ statelist->len = p1 - statelist->head.slhead;
+ statelist->tail.sltail = --p1;
+ qsort(statelist->head.slhead, statelist->len, sizeof(uint64_t), Compare16Bits);
- return statelist->slhead;
+ return statelist->head.slhead;
}
-
-
-
int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t * resultKey, bool calibrate)
{
uint16_t i, len;
uint32_t uid;
UsbCommand resp;
-
-
StateList_t statelists[2];
struct Crypto1State *p1, *p2, *p3, *p4;
@@ -122,27 +114,27 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo
// wait for threads to terminate:
for (i = 0; i < 2; i++) {
- pthread_join(thread_id[i], (void*)&statelists[i].slhead);
+ pthread_join(thread_id[i], (void*)&statelists[i].head.slhead);
}
// the first 16 Bits of the cryptostate already contain part of our key.
// Create the intersection of the two lists based on these 16 Bits and
// roll back the cryptostate
- p1 = p3 = statelists[0].slhead;
- p2 = p4 = statelists[1].slhead;
- while (p1 <= statelists[0].sltail && p2 <= statelists[1].sltail) {
+ p1 = p3 = statelists[0].head.slhead;
+ p2 = p4 = statelists[1].head.slhead;
+ while (p1 <= statelists[0].tail.sltail && p2 <= statelists[1].tail.sltail) {
if (Compare16Bits(p1, p2) == 0) {
struct Crypto1State savestate, *savep = &savestate;
savestate = *p1;
- while(Compare16Bits(p1, savep) == 0 && p1 <= statelists[0].sltail) {
+ while(Compare16Bits(p1, savep) == 0 && p1 <= statelists[0].tail.sltail) {
*p3 = *p1;
lfsr_rollback_word(p3, statelists[0].nt ^ statelists[0].uid, 0);
p3++;
p1++;
}
savestate = *p2;
- while(Compare16Bits(p2, savep) == 0 && p2 <= statelists[1].sltail) {
+ while(Compare16Bits(p2, savep) == 0 && p2 <= statelists[1].tail.sltail) {
*p4 = *p2;
lfsr_rollback_word(p4, statelists[1].nt ^ statelists[1].uid, 0);
p4++;
@@ -156,20 +148,20 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo
}
p3->even = 0; p3->odd = 0;
p4->even = 0; p4->odd = 0;
- statelists[0].len = p3 - statelists[0].slhead;
- statelists[1].len = p4 - statelists[1].slhead;
- statelists[0].sltail=--p3;
- statelists[1].sltail=--p4;
+ statelists[0].len = p3 - statelists[0].head.slhead;
+ statelists[1].len = p4 - statelists[1].head.slhead;
+ statelists[0].tail.sltail=--p3;
+ statelists[1].tail.sltail=--p4;
// the statelists now contain possible keys. The key we are searching for must be in the
// intersection of both lists. Create the intersection:
- qsort(statelists[0].keyhead, statelists[0].len, sizeof(uint64_t), compar_int);
- qsort(statelists[1].keyhead, statelists[1].len, sizeof(uint64_t), compar_int);
+ qsort(statelists[0].head.keyhead, statelists[0].len, sizeof(uint64_t), compar_int);
+ qsort(statelists[1].head.keyhead, statelists[1].len, sizeof(uint64_t), compar_int);
uint64_t *p5, *p6, *p7;
- p5 = p7 = statelists[0].keyhead;
- p6 = statelists[1].keyhead;
- while (p5 <= statelists[0].keytail && p6 <= statelists[1].keytail) {
+ p5 = p7 = statelists[0].head.keyhead;
+ p6 = statelists[1].head.keyhead;
+ while (p5 <= statelists[0].tail.keytail && p6 <= statelists[1].tail.keytail) {
if (compar_int(p5, p6) == 0) {
*p7++ = *p5++;
p6++;
@@ -179,15 +171,15 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo
while (compar_int(p5, p6) == 1) p6++;
}
}
- statelists[0].len = p7 - statelists[0].keyhead;
- statelists[0].keytail=--p7;
+ statelists[0].len = p7 - statelists[0].head.keyhead;
+ statelists[0].tail.keytail=--p7;
memset(resultKey, 0, 6);
// The list may still contain several key candidates. Test each of them with mfCheckKeys
for (i = 0; i < statelists[0].len; i++) {
uint8_t keyBlock[6];
uint64_t key64;
- crypto1_get_lfsr(statelists[0].slhead + i, &key64);
+ crypto1_get_lfsr(statelists[0].head.slhead + i, &key64);
num_to_bytes(key64, 6, keyBlock);
key64 = 0;
if (!mfCheckKeys(statelists[0].blockNo, statelists[0].keyType, 1, keyBlock, &key64)) {
@@ -196,8 +188,8 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo
}
}
- free(statelists[0].slhead);
- free(statelists[1].slhead);
+ free(statelists[0].head.slhead);
+ free(statelists[1].head.slhead);
return 0;
}
@@ -223,7 +215,7 @@ int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) {
UsbCommand c = {CMD_MIFARE_EML_MEMGET, {blockNum, blocksCount, 0}};
SendCommand(&c);
- UsbCommand resp;
+ UsbCommand resp;
if (!WaitForResponseTimeout(CMD_ACK,&resp,1500)) return 1;
memcpy(data, resp.d.asBytes, blocksCount * 16);
return 0;
@@ -238,31 +230,48 @@ int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
// "MAGIC" CARD
-int mfCSetUID(uint8_t *uid, uint8_t *oldUID, int wantWipe) {
- uint8_t block0[16];
- memset(block0, 0, 16);
+int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID, bool wantWipe) {
+ uint8_t oldblock0[16] = {0x00};
+ uint8_t block0[16] = {0x00};
+
+ int old = mfCGetBlock(0, oldblock0, CSETBLOCK_SINGLE_OPER);
+ if (old == 0) {
+ memcpy(block0, oldblock0, 16);
+ PrintAndLog("old block 0: %s", sprint_hex(block0,16));
+ } else {
+ PrintAndLog("Couldn't get old data. Will write over the last bytes of Block 0.");
+ }
+
+ // fill in the new values
+ // UID
memcpy(block0, uid, 4);
- block0[4] = block0[0]^block0[1]^block0[2]^block0[3]; // Mifare UID BCC
- // mifare classic SAK(byte 5) and ATQA(byte 6 and 7)
- block0[5] = 0x88;
- block0[6] = 0x04;
- block0[7] = 0x00;
-
+ // Mifare UID BCC
+ block0[4] = block0[0]^block0[1]^block0[2]^block0[3];
+ // mifare classic SAK(byte 5) and ATQA(byte 6 and 7, reversed)
+ if (sak!=NULL)
+ block0[5]=sak[0];
+ if (atqa!=NULL) {
+ block0[6]=atqa[1];
+ block0[7]=atqa[0];
+ }
+ PrintAndLog("new block 0: %s", sprint_hex(block0,16));
return mfCSetBlock(0, block0, oldUID, wantWipe, CSETBLOCK_SINGLE_OPER);
}
-int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, int wantWipe, uint8_t params) {
- uint8_t isOK = 0;
+int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, bool wantWipe, uint8_t params) {
- UsbCommand c = {CMD_MIFARE_EML_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
+ uint8_t isOK = 0;
+ UsbCommand c = {CMD_MIFARE_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
memcpy(c.d.asBytes, data, 16);
SendCommand(&c);
- UsbCommand resp;
+ UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
isOK = resp.arg[0] & 0xff;
- if (uid != NULL) memcpy(uid, resp.d.asBytes, 4);
- if (!isOK) return 2;
+ if (uid != NULL)
+ memcpy(uid, resp.d.asBytes, 4);
+ if (!isOK)
+ return 2;
} else {
PrintAndLog("Command execute timeout");
return 1;
@@ -273,7 +282,7 @@ int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, int wantWipe, uint
int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) {
uint8_t isOK = 0;
- UsbCommand c = {CMD_MIFARE_EML_CGETBLOCK, {params, 0, blockNo}};
+ UsbCommand c = {CMD_MIFARE_CGETBLOCK, {params, 0, blockNo}};
SendCommand(&c);
UsbCommand resp;
@@ -294,9 +303,9 @@ int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) {
static uint8_t trailerAccessBytes[4] = {0x08, 0x77, 0x8F, 0x00};
// variables
-char logHexFileName[200] = {0x00};
+char logHexFileName[FILE_PATH_SIZE] = {0x00};
static uint8_t traceCard[4096] = {0x00};
-static char traceFileName[20];
+static char traceFileName[FILE_PATH_SIZE] = {0x00};
static int traceState = TRACE_IDLE;
static uint8_t traceCurBlock = 0;
static uint8_t traceCurKey = 0;
@@ -310,12 +319,9 @@ uint32_t ks3;
uint32_t uid; // serial number
uint32_t nt; // tag challenge
-uint32_t nt_par;
uint32_t nr_enc; // encrypted reader challenge
uint32_t ar_enc; // encrypted reader response
-uint32_t nr_ar_par;
uint32_t at_enc; // encrypted tag response
-uint32_t at_par;
int isTraceCardEmpty(void) {
return ((traceCard[0] == 0) && (traceCard[1] == 0) && (traceCard[2] == 0) && (traceCard[3] == 0));
@@ -334,29 +340,39 @@ int isBlockTrailer(int blockN) {
int loadTraceCard(uint8_t *tuid) {
FILE * f;
- char buf[64];
- uint8_t buf8[64];
+ char buf[64] = {0x00};
+ uint8_t buf8[64] = {0x00};
int i, blockNum;
- if (!isTraceCardEmpty()) saveTraceCard();
+ if (!isTraceCardEmpty())
+ saveTraceCard();
+
memset(traceCard, 0x00, 4096);
memcpy(traceCard, tuid + 3, 4);
+
FillFileNameByUID(traceFileName, tuid, ".eml", 7);
f = fopen(traceFileName, "r");
- if (!f) return 1;
+ if (!f) {
+ fclose(f);
+ return 1;
+ }
blockNum = 0;
+
while(!feof(f)){
+
memset(buf, 0, sizeof(buf));
if (fgets(buf, sizeof(buf), f) == NULL) {
PrintAndLog("File reading error.");
+ fclose(f);
return 2;
}
if (strlen(buf) < 32){
if (feof(f)) break;
PrintAndLog("File content error. Block data must include 32 HEX symbols");
+ fclose(f);
return 2;
}
for (i = 0; i < 32; i += 2)
@@ -377,22 +393,30 @@ int saveTraceCard(void) {
if ((!strlen(traceFileName)) || (isTraceCardEmpty())) return 0;
f = fopen(traceFileName, "w+");
+ if ( !f ) {
+ fclose(f);
+ return 1;
+ }
+
for (int i = 0; i < 64; i++) { // blocks
for (int j = 0; j < 16; j++) // bytes
fprintf(f, "%02x", *(traceCard + i * 16 + j));
fprintf(f,"\n");
}
fclose(f);
-
return 0;
}
int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile) {
- if (traceCrypto1) crypto1_destroy(traceCrypto1);
+ if (traceCrypto1)
+ crypto1_destroy(traceCrypto1);
+
traceCrypto1 = NULL;
- if (wantSaveToEmlFile) loadTraceCard(tuid);
+ if (wantSaveToEmlFile)
+ loadTraceCard(tuid);
+
traceCard[4] = traceCard[0] ^ traceCard[1] ^ traceCard[2] ^ traceCard[3];
traceCard[5] = sak;
memcpy(&traceCard[6], atqa, 2);
@@ -422,7 +446,7 @@ void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len, bool i
}
-int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEmlFile) {
+int mfTraceDecode(uint8_t *data_src, int len, bool wantSaveToEmlFile) {
uint8_t data[64];
if (traceState == TRACE_ERROR) return 1;
@@ -449,7 +473,7 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
}
// AUTHENTICATION
- if ((len ==4) && ((data[0] == 0x60) || (data[0] == 0x61))) {
+ if ((len == 4) && ((data[0] == 0x60) || (data[0] == 0x61))) {
traceState = TRACE_AUTH1;
traceCurBlock = data[1];
traceCurKey = data[0] == 60 ? 1:0;
@@ -497,7 +521,7 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
break;
case TRACE_WRITE_OK:
- if ((len == 1) && (data[0] = 0x0a)) {
+ if ((len == 1) && (data[0] == 0x0a)) {
traceState = TRACE_WRITE_DATA;
return 0;
@@ -523,9 +547,7 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
case TRACE_AUTH1:
if (len == 4) {
traceState = TRACE_AUTH2;
-
nt = bytes_to_num(data, 4);
- nt_par = parity;
return 0;
} else {
traceState = TRACE_ERROR;
@@ -539,7 +561,6 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
nr_enc = bytes_to_num(data, 4);
ar_enc = bytes_to_num(data + 4, 4);
- nr_ar_par = parity;
return 0;
} else {
traceState = TRACE_ERROR;
@@ -552,26 +573,16 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
traceState = TRACE_IDLE;
at_enc = bytes_to_num(data, 4);
- at_par = parity;
// decode key here)
- if (!traceCrypto1) {
- ks2 = ar_enc ^ prng_successor(nt, 64);
- ks3 = at_enc ^ prng_successor(nt, 96);
- revstate = lfsr_recovery64(ks2, ks3);
- lfsr_rollback_word(revstate, 0, 0);
- lfsr_rollback_word(revstate, 0, 0);
- lfsr_rollback_word(revstate, nr_enc, 1);
- lfsr_rollback_word(revstate, uid ^ nt, 0);
- }else{
- ks2 = ar_enc ^ prng_successor(nt, 64);
- ks3 = at_enc ^ prng_successor(nt, 96);
- revstate = lfsr_recovery64(ks2, ks3);
- lfsr_rollback_word(revstate, 0, 0);
- lfsr_rollback_word(revstate, 0, 0);
- lfsr_rollback_word(revstate, nr_enc, 1);
- lfsr_rollback_word(revstate, uid ^ nt, 0);
- }
+ ks2 = ar_enc ^ prng_successor(nt, 64);
+ ks3 = at_enc ^ prng_successor(nt, 96);
+ revstate = lfsr_recovery64(ks2, ks3);
+ lfsr_rollback_word(revstate, 0, 0);
+ lfsr_rollback_word(revstate, 0, 0);
+ lfsr_rollback_word(revstate, nr_enc, 1);
+ lfsr_rollback_word(revstate, uid ^ nt, 0);
+
crypto1_get_lfsr(revstate, &lfsr);
printf("key> %x%x\n", (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF));
AddLogUint64(logHexFileName, "key> ", lfsr);