depau/mfoc-always-skip-probes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Format source code with "make style"

Browse source
This commit is contained in:
Romuald Conty 2013-01-20 15:36:59 +01:00
parent 2596aeac80
commit 6048309a13
5 changed files with 1221 additions and 1209 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

164
src/crapto1.c
View file

@ -25,30 +25,30 @@ static uint8_t filterlut[1 << 20];
static void __attribute__((constructor)) fill_lut(void) static void __attribute__((constructor)) fill_lut(void)
{ {
uint32_t i; uint32_t i;
for(i = 0; i < 1 << 20; ++i) for (i = 0; i < 1 << 20; ++i)
filterlut[i] = filter(i); filterlut[i] = filter(i);
} }
#define filter(x) (filterlut[(x) & 0xfffff]) #define filter(x) (filterlut[(x) & 0xfffff])
#endif #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) if (it > rit)
return; return;
while(it < rit) while (it < rit)
if(*it <= *start) if (*it <= *start)
++it; ++it;
else if(*rit > *start) else if (*rit > *start)
--rit; --rit;
else else
*it ^= (*it ^= *rit, *rit ^= *it); *it ^= (*it ^= *rit, *rit ^= *it);
if(*rit >= *start) if (*rit >= *start)
--rit; --rit;
if(rit != start) if (rit != start)
*rit ^= (*rit ^= *start, *start ^= *rit); *rit ^= (*rit ^= *start, *start ^= *rit);
quicksort(start, rit - 1); quicksort(start, rit - 1);
@ -57,12 +57,12 @@ static void quicksort(uint32_t* const start, uint32_t* const stop)
/** binsearch /** binsearch
* Binary search for the first occurence of *stop's MSB in sorted [start,stop] * 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) binsearch(uint32_t *start, uint32_t *stop)
{ {
uint32_t mid, val = *stop & 0xff000000; uint32_t mid, val = *stop & 0xff000000;
while(start != stop) while (start != stop)
if(start[mid = (stop - start) >> 1] > val) if (start[mid = (stop - start) >> 1] > val)
stop = &start[mid]; stop = &start[mid];
else else
start += mid + 1; start += mid + 1;
@ -90,12 +90,12 @@ static inline void
extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in) extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in)
{ {
in <<= 24; in <<= 24;
for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1) for (*tbl <<= 1; tbl <= *end; *++tbl <<= 1)
if(filter(*tbl) ^ filter(*tbl | 1)) { if (filter(*tbl) ^ filter(*tbl | 1)) {
*tbl |= filter(*tbl) ^ bit; *tbl |= filter(*tbl) ^ bit;
update_contribution(tbl, m1, m2); update_contribution(tbl, m1, m2);
*tbl ^= in; *tbl ^= in;
} else if(filter(*tbl) == bit) { } else if (filter(*tbl) == bit) {
*++*end = tbl[1]; *++*end = tbl[1];
tbl[1] = tbl[0] | 1; tbl[1] = tbl[0] | 1;
update_contribution(tbl, m1, m2); update_contribution(tbl, m1, m2);
@ -111,10 +111,10 @@ extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in
static inline void static inline void
extend_table_simple(uint32_t *tbl, uint32_t **end, int bit) extend_table_simple(uint32_t *tbl, uint32_t **end, int bit)
{ {
for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1) for (*tbl <<= 1; tbl <= *end; *++tbl <<= 1)
if(filter(*tbl) ^ filter(*tbl | 1)) { if (filter(*tbl) ^ filter(*tbl | 1)) {
*tbl |= filter(*tbl) ^ bit; *tbl |= filter(*tbl) ^ bit;
} else if(filter(*tbl) == bit) { } else if (filter(*tbl) == bit) {
*++*end = *++tbl; *++*end = *++tbl;
*tbl = tbl[-1] | 1; *tbl = tbl[-1] | 1;
} else } else
@ -123,17 +123,16 @@ extend_table_simple(uint32_t *tbl, uint32_t **end, int bit)
/** recover /** recover
* recursively narrow down the search space, 4 bits of keystream at a time * 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, 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, uint32_t *e_head, uint32_t *e_tail, uint32_t eks, int rem,
struct Crypto1State *sl, uint32_t in) struct Crypto1State *sl, uint32_t in) {
{
uint32_t *o, *e, i; uint32_t *o, *e, i;
if(rem == -1) { if (rem == -1) {
for(e = e_head; e <= e_tail; ++e) { for (e = e_head; e <= e_tail; ++e) {
*e = *e << 1 ^ parity(*e & LF_POLY_EVEN) ^ !!(in & 4); *e = *e << 1 ^ parity(*e & LF_POLY_EVEN) ^ !!(in & 4);
for(o = o_head; o <= o_tail; ++o, ++sl) { for (o = o_head; o <= o_tail; ++o, ++sl) {
sl->even = *o; sl->even = *o;
sl->odd = *e ^ parity(*o & LF_POLY_ODD); sl->odd = *e ^ parity(*o & LF_POLY_ODD);
sl[1].odd = sl[1].even = 0; sl[1].odd = sl[1].even = 0;
@ -142,29 +141,28 @@ recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
return sl; return sl;
} }
for(i = 0; i < 4 && rem--; i++) { for (i = 0; i < 4 && rem--; i++) {
extend_table(o_head, &o_tail, (oks >>= 1) & 1, extend_table(o_head, &o_tail, (oks >>= 1) & 1,
LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0); LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0);
if(o_head > o_tail) if (o_head > o_tail)
return sl; return sl;
extend_table(e_head, &e_tail, (eks >>= 1) & 1, extend_table(e_head, &e_tail, (eks >>= 1) & 1,
LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, (in >>= 2) & 3); LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, (in >>= 2) & 3);
if(e_head > e_tail) if (e_head > e_tail)
return sl; return sl;
} }
quicksort(o_head, o_tail); quicksort(o_head, o_tail);
quicksort(e_head, e_tail); quicksort(e_head, e_tail);
while(o_tail >= o_head && e_tail >= e_head) while (o_tail >= o_head && e_tail >= e_head)
if(((*o_tail ^ *e_tail) >> 24) == 0) { if (((*o_tail ^ *e_tail) >> 24) == 0) {
o_tail = binsearch(o_head, o = o_tail); o_tail = binsearch(o_head, o = o_tail);
e_tail = binsearch(e_head, e = e_tail); e_tail = binsearch(e_head, e = e_tail);
sl = recover(o_tail--, o, oks, sl = recover(o_tail--, o, oks,
e_tail--, e, eks, rem, sl, in); e_tail--, e, eks, rem, sl, in);
} } else if (*o_tail > *e_tail)
else if(*o_tail > *e_tail)
o_tail = binsearch(o_head, o_tail) - 1; o_tail = binsearch(o_head, o_tail) - 1;
else else
e_tail = binsearch(e_head, e_tail) - 1; e_tail = binsearch(e_head, e_tail) - 1;
@ -176,34 +174,33 @@ recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
* additionally you can use the in parameter to specify the value * additionally you can use the in parameter to specify the value
* that was fed into the lfsr at the time the keystream was generated * 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 *lfsr_recovery32(uint32_t ks2, uint32_t in) {
{
struct Crypto1State *statelist; struct Crypto1State *statelist;
uint32_t *odd_head = 0, *odd_tail = 0, oks = 0; uint32_t *odd_head = 0, *odd_tail = 0, oks = 0;
uint32_t *even_head = 0, *even_tail = 0, eks = 0; uint32_t *even_head = 0, *even_tail = 0, eks = 0;
int i; int i;
for(i = 31; i >= 0; i -= 2) for (i = 31; i >= 0; i -= 2)
oks = oks << 1 | BEBIT(ks2, i); oks = oks << 1 | BEBIT(ks2, i);
for(i = 30; i >= 0; i -= 2) for (i = 30; i >= 0; i -= 2)
eks = eks << 1 | BEBIT(ks2, i); eks = eks << 1 | BEBIT(ks2, i);
odd_head = odd_tail = malloc(sizeof(uint32_t) << 21); odd_head = odd_tail = malloc(sizeof(uint32_t) << 21);
even_head = even_tail = malloc(sizeof(uint32_t) << 21); even_head = even_tail = malloc(sizeof(uint32_t) << 21);
statelist = malloc(sizeof(struct Crypto1State) << 18); statelist = malloc(sizeof(struct Crypto1State) << 18);
if(!odd_tail-- || !even_tail-- || !statelist) if (!odd_tail-- || !even_tail-- || !statelist)
goto out; goto out;
statelist->odd = statelist->even = 0; statelist->odd = statelist->even = 0;
for(i = 1 << 20; i >= 0; --i) { for (i = 1 << 20; i >= 0; --i) {
if(filter(i) == (oks & 1)) if (filter(i) == (oks & 1))
*++odd_tail = i; *++odd_tail = i;
if(filter(i) == (eks & 1)) if (filter(i) == (eks & 1))
*++even_tail = i; *++even_tail = i;
} }
for(i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
extend_table_simple(odd_head, &odd_tail, (oks >>= 1) & 1); extend_table_simple(odd_head, &odd_tail, (oks >>= 1) & 1);
extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1); extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1);
} }
@ -220,29 +217,32 @@ out:
static const uint32_t S1[] = { 0x62141, 0x310A0, 0x18850, 0x0C428, 0x06214, static const uint32_t S1[] = { 0x62141, 0x310A0, 0x18850, 0x0C428, 0x06214,
0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83, 0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83,
0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA}; 0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA
};
static const uint32_t S2[] = { 0x3A557B00, 0x5D2ABD80, 0x2E955EC0, 0x174AAF60, static const uint32_t S2[] = { 0x3A557B00, 0x5D2ABD80, 0x2E955EC0, 0x174AAF60,
0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8, 0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8,
0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20, 0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20,
0x7EC7EE90, 0x7F63F748, 0x79117020}; 0x7EC7EE90, 0x7F63F748, 0x79117020
};
static const uint32_t T1[] = { static const uint32_t T1[] = {
0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66, 0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66,
0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B, 0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B,
0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615, 0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615,
0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C}; 0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C
};
static const uint32_t T2[] = { 0x3C88B810, 0x5E445C08, 0x2982A580, 0x14C152C0, static const uint32_t T2[] = { 0x3C88B810, 0x5E445C08, 0x2982A580, 0x14C152C0,
0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268, 0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268,
0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0, 0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0,
0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0, 0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0,
0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950, 0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950,
0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0}; 0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0
};
static const uint32_t C1[] = { 0x846B5, 0x4235A, 0x211AD}; static const uint32_t C1[] = { 0x846B5, 0x4235A, 0x211AD};
static const uint32_t C2[] = { 0x1A822E0, 0x21A822E0, 0x21A822E0}; static const uint32_t C2[] = { 0x1A822E0, 0x21A822E0, 0x21A822E0};
/** Reverse 64 bits of keystream into possible cipher states /** Reverse 64 bits of keystream into possible cipher states
* Variation mentioned in the paper. Somewhat optimized version * Variation mentioned in the paper. Somewhat optimized version
*/ */
struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3) struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3) {
{
struct Crypto1State *statelist, *sl; struct Crypto1State *statelist, *sl;
uint8_t oks[32], eks[32], hi[32]; uint8_t oks[32], eks[32], hi[32];
uint32_t low = 0, win = 0; uint32_t low = 0, win = 0;
@ -250,50 +250,50 @@ struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3)
int i, j; int i, j;
sl = statelist = malloc(sizeof(struct Crypto1State) << 4); sl = statelist = malloc(sizeof(struct Crypto1State) << 4);
if(!sl) if (!sl)
return 0; return 0;
sl->odd = sl->even = 0; sl->odd = sl->even = 0;
for(i = 30; i >= 0; i -= 2) { for (i = 30; i >= 0; i -= 2) {
oks[i >> 1] = BIT(ks2, i ^ 24); oks[i >> 1] = BIT(ks2, i ^ 24);
oks[16 + (i >> 1)] = BIT(ks3, i ^ 24); oks[16 + (i >> 1)] = BIT(ks3, i ^ 24);
} }
for(i = 31; i >= 0; i -= 2) { for (i = 31; i >= 0; i -= 2) {
eks[i >> 1] = BIT(ks2, i ^ 24); eks[i >> 1] = BIT(ks2, i ^ 24);
eks[16 + (i >> 1)] = BIT(ks3, i ^ 24); eks[16 + (i >> 1)] = BIT(ks3, i ^ 24);
} }
for(i = 0xfffff; i >= 0; --i) { for (i = 0xfffff; i >= 0; --i) {
if (filter(i) != oks[0]) if (filter(i) != oks[0])
continue; continue;
*(tail = table) = i; *(tail = table) = i;
for(j = 1; tail >= table && j < 29; ++j) for (j = 1; tail >= table && j < 29; ++j)
extend_table_simple(table, &tail, oks[j]); extend_table_simple(table, &tail, oks[j]);
if(tail < table) if (tail < table)
continue; continue;
for(j = 0; j < 19; ++j) for (j = 0; j < 19; ++j)
low = low << 1 | parity(i & S1[j]); low = low << 1 | parity(i & S1[j]);
for(j = 0; j < 32; ++j) for (j = 0; j < 32; ++j)
hi[j] = parity(i & T1[j]); hi[j] = parity(i & T1[j]);
for(; tail >= table; --tail) { for (; tail >= table; --tail) {
for(j = 0; j < 3; ++j) { for (j = 0; j < 3; ++j) {
*tail = *tail << 1; *tail = *tail << 1;
*tail |= parity((i & C1[j]) ^ (*tail & C2[j])); *tail |= parity((i & C1[j]) ^(*tail & C2[j]));
if(filter(*tail) != oks[29 + j]) if (filter(*tail) != oks[29 + j])
goto continue2; goto continue2;
} }
for(j = 0; j < 19; ++j) for (j = 0; j < 19; ++j)
win = win << 1 | parity(*tail & S2[j]); win = win << 1 | parity(*tail & S2[j]);
win ^= low; win ^= low;
for(j = 0; j < 32; ++j) { for (j = 0; j < 32; ++j) {
win = win << 1 ^ hi[j] ^ parity(*tail & T2[j]); win = win << 1 ^ hi[j] ^ parity(*tail & T2[j]);
if(filter(win) != eks[j]) if (filter(win) != eks[j])
goto continue2; goto continue2;
} }
@ -302,7 +302,8 @@ struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3)
sl->even = win; sl->even = win;
++sl; ++sl;
sl->odd = sl->even = 0; sl->odd = sl->even = 0;
continue2:; continue2:
;
} }
} }
return statelist; return statelist;
@ -363,9 +364,9 @@ static uint16_t *dist = 0;
int nonce_distance(uint32_t from, uint32_t to) int nonce_distance(uint32_t from, uint32_t to)
{ {
uint16_t x, i; uint16_t x, i;
if(!dist) { if (!dist) {
dist = malloc(2 << 16); dist = malloc(2 << 16);
if(!dist) if (!dist)
return -1; return -1;
for (x = i = 1; i; ++i) { for (x = i = 1; i; ++i) {
dist[(x & 0xff) << 8 | x >> 8] = i; dist[(x & 0xff) << 8 | x >> 8] = i;
@ -378,7 +379,8 @@ int nonce_distance(uint32_t from, uint32_t to)
static uint32_t fastfwd[2][8] = { static uint32_t fastfwd[2][8] = {
{ 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB}, { 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB},
{ 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}}; { 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}
};
/** lfsr_prefix_ks /** lfsr_prefix_ks
@ -395,17 +397,17 @@ uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)
uint32_t c, entry, *candidates = malloc(4 << 21); uint32_t c, entry, *candidates = malloc(4 << 21);
int i, size = (1 << 21) - 1; int i, size = (1 << 21) - 1;
if(!candidates) if (!candidates)
return 0; return 0;
for(i = 0; i <= size; ++i) for (i = 0; i <= size; ++i)
candidates[i] = i; candidates[i] = i;
for(c = 0; c < 8; ++c) for (c = 0; c < 8; ++c)
for(i = 0;i <= size; ++i) { for (i = 0; i <= size; ++i) {
entry = candidates[i] ^ fastfwd[isodd][c]; entry = candidates[i] ^ fastfwd[isodd][c];
if(filter(entry >> 1) != BIT(ks[c], isodd) || if (filter(entry >> 1) != BIT(ks[c], isodd) ||
filter(entry) != BIT(ks[c], isodd + 2)) filter(entry) != BIT(ks[c], isodd + 2))
candidates[i--] = candidates[size--]; candidates[i--] = candidates[size--];
} }
@ -418,13 +420,12 @@ uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)
/** check_pfx_parity /** check_pfx_parity
* helper function which eliminates possible secret states using parity bits * 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], 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 odd, uint32_t even, struct Crypto1State *sl) {
{
uint32_t ks1, nr, ks2, rr, ks3, c, good = 1; uint32_t ks1, nr, ks2, rr, ks3, c, good = 1;
for(c = 0; good && c < 8; ++c) { for (c = 0; good && c < 8; ++c) {
sl->odd = odd ^ fastfwd[1][c]; sl->odd = odd ^ fastfwd[1][c];
sl->even = even ^ fastfwd[0][c]; sl->even = even ^ fastfwd[0][c];
@ -435,7 +436,7 @@ check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
ks2 = lfsr_rollback_word(sl, 0, 0); ks2 = lfsr_rollback_word(sl, 0, 0);
ks1 = lfsr_rollback_word(sl, prefix | c << 5, 1); ks1 = lfsr_rollback_word(sl, prefix | c << 5, 1);
nr = ks1 ^ (prefix | c << 5); nr = ks1 ^(prefix | c << 5);
rr = ks2 ^ rresp; rr = ks2 ^ rresp;
good &= parity(nr & 0x000000ff) ^ parities[c][3] ^ BIT(ks2, 24); good &= parity(nr & 0x000000ff) ^ parities[c][3] ^ BIT(ks2, 24);
@ -449,7 +450,7 @@ check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
} }
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 /** lfsr_common_prefix
* Implentation of the common prefix attack. * Implentation of the common prefix attack.
@ -460,9 +461,8 @@ 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 * It returns a zero terminated list of possible cipher states after the
* tag nonce was fed in * tag nonce was fed in
*/ */
struct Crypto1State* struct Crypto1State *
lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]) lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]) {
{
struct Crypto1State *statelist, *s; struct Crypto1State *statelist, *s;
uint32_t *odd, *even, *o, *e, top; uint32_t *odd, *even, *o, *e, top;
@ -470,16 +470,16 @@ lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8])
even = lfsr_prefix_ks(ks, 0); even = lfsr_prefix_ks(ks, 0);
s = statelist = malloc((sizeof *statelist) << 20); s = statelist = malloc((sizeof *statelist) << 20);
if(!s || !odd || !even) { if (!s || !odd || !even) {
free(odd); free(odd);
free(even); free(even);
free(statelist); free(statelist);
return 0; return 0;
} }
for(o = odd; *o + 1; ++o) for (o = odd; *o + 1; ++o)
for(e = even; *e + 1; ++e) for (e = even; *e + 1; ++e)
for(top = 0; top < 64; ++top) { for (top = 0; top < 64; ++top) {
*o += 1 << 21; *o += 1 << 21;
*e += (!(top & 7) + 1) << 21; *e += (!(top & 7) + 1) << 21;
s = check_pfx_parity(pfx, rr, par, *o, *e, s); s = check_pfx_parity(pfx, rr, par, *o, *e, s);

42
src/crapto1.h
View file

@ -24,21 +24,21 @@
extern "C" { extern "C" {
#endif #endif
struct Crypto1State {uint32_t odd, even;}; struct Crypto1State {uint32_t odd, even;};
struct Crypto1State* crypto1_create(uint64_t); struct Crypto1State *crypto1_create(uint64_t);
void crypto1_destroy(struct Crypto1State*); void crypto1_destroy(struct Crypto1State *);
void crypto1_get_lfsr(struct Crypto1State*, uint64_t*); void crypto1_get_lfsr(struct Crypto1State *, uint64_t *);
uint8_t crypto1_bit(struct Crypto1State*, uint8_t, int); uint8_t crypto1_bit(struct Crypto1State *, uint8_t, int);
uint8_t crypto1_byte(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 crypto1_word(struct Crypto1State *, uint32_t, int);
uint32_t prng_successor(uint32_t x, uint32_t n); uint32_t prng_successor(uint32_t x, uint32_t n);
struct Crypto1State* lfsr_recovery32(uint32_t ks2, uint32_t in); struct Crypto1State *lfsr_recovery32(uint32_t ks2, uint32_t in);
struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3); struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3);
void lfsr_rollback(struct Crypto1State* s, uint32_t in, int fb); void lfsr_rollback(struct Crypto1State *s, uint32_t in, int fb);
uint32_t lfsr_rollback_word(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); int nonce_distance(uint32_t from, uint32_t to);
#define FOREACH_VALID_NONCE(N, FILTER, FSIZE)\ #define FOREACH_VALID_NONCE(N, FILTER, FSIZE)\
uint32_t __n = 0,__M = 0, N = 0;\ uint32_t __n = 0,__M = 0, N = 0;\
int __i;\ int __i;\
@ -54,26 +54,26 @@ int nonce_distance(uint32_t from, uint32_t to);
#define LF_POLY_EVEN (0x870804) #define LF_POLY_EVEN (0x870804)
#define BIT(x, n) ((x) >> (n) & 1) #define BIT(x, n) ((x) >> (n) & 1)
#define BEBIT(x, n) BIT(x, (n) ^ 24) #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__ #if !defined __i386__ || !defined __GNUC__
x ^= x >> 16; x ^= x >> 16;
x ^= x >> 8; x ^= x >> 8;
x ^= x >> 4; x ^= x >> 4;
return BIT(0x6996, x & 0xf); return BIT(0x6996, x & 0xf);
#else #else
asm( "movl %1, %%eax\n" asm("movl %1, %%eax\n"
"mov %%ax, %%cx\n" "mov %%ax, %%cx\n"
"shrl $0x10, %%eax\n" "shrl $0x10, %%eax\n"
"xor %%ax, %%cx\n" "xor %%ax, %%cx\n"
"xor %%ch, %%cl\n" "xor %%ch, %%cl\n"
"setpo %%al\n" "setpo %%al\n"
"movzx %%al, %0\n": "=r"(x) : "r"(x): "eax","ecx"); "movzx %%al, %0\n": "=r"(x) : "r"(x): "eax", "ecx");
return x; return x;
#endif #endif
} }
static inline int filter(uint32_t const x) static inline int filter(uint32_t const x)
{ {
uint32_t f; uint32_t f;
f = 0xf22c0 >> (x & 0xf) & 16; f = 0xf22c0 >> (x & 0xf) & 16;
@ -82,7 +82,7 @@ static inline int filter(uint32_t const x)
f |= 0x1e458 >> (x >> 12 & 0xf) & 2; f |= 0x1e458 >> (x >> 12 & 0xf) & 2;
f |= 0x0d938 >> (x >> 16 & 0xf) & 1; f |= 0x0d938 >> (x >> 16 & 0xf) & 1;
return BIT(0xEC57E80A, f); return BIT(0xEC57E80A, f);
} }
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

9
src/crypto1.c
View file

@ -23,12 +23,11 @@
#define SWAPENDIAN(x)\ #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 *crypto1_create(uint64_t key) {
{
struct Crypto1State *s = malloc(sizeof(*s)); struct Crypto1State *s = malloc(sizeof(*s));
int i; int i;
for(i = 47;s && i > 0; i -= 2) { for (i = 47; s && i > 0; i -= 2) {
s->odd = s->odd << 1 | BIT(key, (i - 1) ^ 7); s->odd = s->odd << 1 | BIT(key, (i - 1) ^ 7);
s->even = s->even << 1 | BIT(key, i ^ 7); s->even = s->even << 1 | BIT(key, i ^ 7);
} }
@ -41,7 +40,7 @@ void crypto1_destroy(struct Crypto1State *state)
void crypto1_get_lfsr(struct Crypto1State *state, uint64_t *lfsr) void crypto1_get_lfsr(struct Crypto1State *state, uint64_t *lfsr)
{ {
int i; int i;
for(*lfsr = 0, i = 23; i >= 0; --i) { for (*lfsr = 0, i = 23; i >= 0; --i) {
*lfsr = *lfsr << 1 | BIT(state->odd, i ^ 3); *lfsr = *lfsr << 1 | BIT(state->odd, i ^ 3);
*lfsr = *lfsr << 1 | BIT(state->even, i ^ 3); *lfsr = *lfsr << 1 | BIT(state->even, i ^ 3);
} }
@ -86,7 +85,7 @@ uint32_t crypto1_word(struct Crypto1State *s, uint32_t in, int is_encrypted)
uint32_t prng_successor(uint32_t x, uint32_t n) uint32_t prng_successor(uint32_t x, uint32_t n)
{ {
SWAPENDIAN(x); SWAPENDIAN(x);
while(n--) while (n--)
x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31; x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31;
return SWAPENDIAN(x); return SWAPENDIAN(x);

293
src/mfoc.c
View file

@ -52,7 +52,8 @@
nfc_context *context; nfc_context *context;
int main(int argc, char * const argv[]) { int main(int argc, char *const argv[])
{
const nfc_modulation nm = { const nfc_modulation nm = {
.nmt = NMT_ISO14443A, .nmt = NMT_ISO14443A,
.nbr = NBR_106, .nbr = NBR_106,
@ -73,7 +74,7 @@ int main(int argc, char * const argv[]) {
bool skip = false; bool skip = false;
// Next default key specified as option (-k) // Next default key specified as option (-k)
uint8_t * defKeys = NULL, *p; uint8_t *defKeys = NULL, *p;
size_t defKeys_len = 0; size_t defKeys_len = 0;
// Array with default Mifare Classic keys // Array with default Mifare Classic keys
@ -117,18 +118,17 @@ int main(int argc, char * const argv[]) {
case 'P': case 'P':
// Number of probes // Number of probes
if (!(probes = atoi(optarg)) || probes < 1) { if (!(probes = atoi(optarg)) || probes < 1) {
ERR ("The number of probes must be a positive number"); ERR("The number of probes must be a positive number");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// fprintf(stdout, "Number of probes: %d\n", probes); // fprintf(stdout, "Number of probes: %d\n", probes);
break; break;
case 'T': case 'T': {
{
int res; int res;
// Nonce tolerance range // Nonce tolerance range
if (((res = atoi(optarg)) < 0)) { if (((res = atoi(optarg)) < 0)) {
ERR ("The nonce distances range must be a zero or a positive number"); ERR("The nonce distances range must be a zero or a positive number");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
d.tolerance = (uint32_t)res; d.tolerance = (uint32_t)res;
// fprintf(stdout, "Tolerance number: %d\n", probes); // fprintf(stdout, "Tolerance number: %d\n", probes);
@ -138,13 +138,13 @@ int main(int argc, char * const argv[]) {
// Add this key to the default keys // Add this key to the default keys
p = realloc(defKeys, defKeys_len + 6); p = realloc(defKeys, defKeys_len + 6);
if (!p) { if (!p) {
ERR ("Cannot allocate memory for defKeys"); ERR("Cannot allocate memory for defKeys");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
defKeys = p; defKeys = p;
memset(defKeys+defKeys_len, 0, 6); memset(defKeys + defKeys_len, 0, 6);
num_to_bytes(strtoll(optarg, NULL, 16), 6, defKeys+defKeys_len); 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)); 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; defKeys_len = defKeys_len + 6;
break; break;
@ -152,7 +152,7 @@ int main(int argc, char * const argv[]) {
// File output // File output
if (!(pfDump = fopen(optarg, "wb"))) { if (!(pfDump = fopen(optarg, "wb"))) {
fprintf(stderr, "Cannot open: %s, exiting\n", optarg); fprintf(stderr, "Cannot open: %s, exiting\n", optarg);
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// fprintf(stdout, "Output file: %s\n", optarg); // fprintf(stdout, "Output file: %s\n", optarg);
break; break;
@ -166,51 +166,51 @@ int main(int argc, char * const argv[]) {
} }
if (!pfDump) { if (!pfDump) {
ERR ("parameter -O is mandatory"); ERR("parameter -O is mandatory");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Initialize reader/tag structures // Initialize reader/tag structures
mf_init(&r); mf_init(&r);
if (nfc_initiator_init (r.pdi) < 0) { if (nfc_initiator_init(r.pdi) < 0) {
nfc_perror (r.pdi, "nfc_initiator_init"); nfc_perror(r.pdi, "nfc_initiator_init");
goto error; goto error;
} }
// Drop the field for a while, so can be reset // Drop the field for a while, so can be reset
if (nfc_device_set_property_bool(r.pdi, NP_ACTIVATE_FIELD, true) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_ACTIVATE_FIELD, true) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool activate field"); nfc_perror(r.pdi, "nfc_device_set_property_bool activate field");
goto error; goto error;
} }
// Let the reader only try once to find a tag // Let the reader only try once to find a tag
if (nfc_device_set_property_bool(r.pdi, NP_INFINITE_SELECT, false) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_INFINITE_SELECT, false) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool infinite select"); nfc_perror(r.pdi, "nfc_device_set_property_bool infinite select");
goto error; goto error;
} }
// Configure the CRC and Parity settings // Configure the CRC and Parity settings
if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool crc"); nfc_perror(r.pdi, "nfc_device_set_property_bool crc");
goto error; goto error;
} }
if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool parity"); nfc_perror(r.pdi, "nfc_device_set_property_bool parity");
goto error; goto error;
} }
/* /*
// wait for tag to appear // 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); 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)); // mf_select_tag(r.pdi, &(t.nt));
if (nfc_initiator_select_passive_target (r.pdi, nm, NULL, 0, &t.nt) < 0) { if (nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) < 0) {
nfc_perror (r.pdi, "nfc_initiator_select_passive_target"); nfc_perror(r.pdi, "nfc_initiator_select_passive_target");
goto error; goto error;
} }
// Test if a compatible MIFARE tag is used // Test if a compatible MIFARE tag is used
if ((t.nt.nti.nai.btSak & 0x08) == 0) { if ((t.nt.nti.nai.btSak & 0x08) == 0) {
ERR ("only Mifare Classic is supported"); ERR("only Mifare Classic is supported");
goto error; goto error;
} }
@ -223,15 +223,15 @@ int main(int argc, char * const argv[]) {
t.sectors = (void *) calloc(t.num_sectors, sizeof(sector)); t.sectors = (void *) calloc(t.num_sectors, sizeof(sector));
if (t.sectors == NULL) { if (t.sectors == NULL) {
ERR ("Cannot allocate memory for t.sectors"); ERR("Cannot allocate memory for t.sectors");
goto error; goto error;
} }
if ((pk = (void *) malloc(sizeof(pKeys))) == NULL) { if ((pk = (void *) malloc(sizeof(pKeys))) == NULL) {
ERR ("Cannot allocate memory for pk"); ERR("Cannot allocate memory for pk");
goto error; goto error;
} }
if ((bk = (void *) malloc(sizeof(bKeys))) == NULL) { if ((bk = (void *) malloc(sizeof(bKeys))) == NULL) {
ERR ("Cannot allocate memory for bk"); ERR("Cannot allocate memory for bk");
goto error; goto error;
} else { } else {
bk->brokenKeys = NULL; bk->brokenKeys = NULL;
@ -240,7 +240,7 @@ int main(int argc, char * const argv[]) {
d.distances = (void *) calloc(d.num_distances, sizeof(uint32_t)); d.distances = (void *) calloc(d.num_distances, sizeof(uint32_t));
if (d.distances == NULL) { if (d.distances == NULL) {
ERR ("Cannot allocate memory for t.distances"); ERR("Cannot allocate memory for t.distances");
goto error; goto error;
} }
@ -249,13 +249,13 @@ int main(int argc, char * const argv[]) {
t.sectors[s].foundKeyA = t.sectors[s].foundKeyB = false; 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 // Try to authenticate to all sectors with default keys
// Set the authentication information (uid) // Set the authentication information (uid)
memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid)); 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) // Iterate over all keys (n = number of keys)
n = sizeof(defaultKeys)/sizeof(defaultKeys[0]); n = sizeof(defaultKeys) / sizeof(defaultKeys[0]);
size_t defKey_bytes_todo = defKeys_len; size_t defKey_bytes_todo = defKeys_len;
key = 0; key = 0;
while (key < n) { while (key < n) {
@ -274,7 +274,7 @@ int main(int argc, char * const argv[]) {
if (trailer_block(block)) { if (trailer_block(block)) {
if (!t.sectors[i].foundKeyA) { if (!t.sectors[i].foundKeyA) {
mc = MC_AUTH_A; mc = MC_AUTH_A;
if (!nfc_initiator_mifare_cmd(r.pdi,mc,block,&mp)) { if (!nfc_initiator_mifare_cmd(r.pdi, mc, block, &mp)) {
// fprintf(stdout, "!!Error: AUTH [Key A:%012llx] sector %02x t_block %02x\n", // fprintf(stdout, "!!Error: AUTH [Key A:%012llx] sector %02x t_block %02x\n",
// bytes_to_num(mp.mpa.abtKey, 6), i, block); // bytes_to_num(mp.mpa.abtKey, 6), i, block);
mf_anticollision(t, r); mf_anticollision(t, r);
@ -286,7 +286,7 @@ int main(int argc, char * const argv[]) {
} }
if (!t.sectors[i].foundKeyB) { if (!t.sectors[i].foundKeyB) {
mc = MC_AUTH_B; mc = MC_AUTH_B;
if (!nfc_initiator_mifare_cmd(r.pdi,mc,block,&mp)) { if (!nfc_initiator_mifare_cmd(r.pdi, mc, block, &mp)) {
// fprintf(stdout, "!!Error: AUTH [Key B:%012llx] sector %02x t_block %02x\n", // fprintf(stdout, "!!Error: AUTH [Key B:%012llx] sector %02x t_block %02x\n",
// bytes_to_num(mp.mpa.abtKey, 6), i, block); // bytes_to_num(mp.mpa.abtKey, 6), i, block);
mf_anticollision(t, r); mf_anticollision(t, r);
@ -340,7 +340,7 @@ int main(int argc, char * const argv[]) {
for (uint32_t o = 0; o < bk->size; o++) { for (uint32_t o = 0; o < bk->size; o++) {
num_to_bytes(bk->brokenKeys[o], 6, mp.mpa.abtKey); num_to_bytes(bk->brokenKeys[o], 6, mp.mpa.abtKey);
mc = dumpKeysA ? 0x60 : 0x61; mc = dumpKeysA ? 0x60 : 0x61;
if (!nfc_initiator_mifare_cmd(r.pdi,mc,t.sectors[j].trailer,&mp)) { 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", // 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); // bytes_to_num(mp.mpa.abtKey, 6), j, t.sectors[j].trailer, o);
mf_anticollision(t, r); mf_anticollision(t, r);
@ -395,7 +395,7 @@ int main(int argc, char * const argv[]) {
// Set required authetication method // Set required authetication method
num_to_bytes(ck[i].key, 6, mp.mpa.abtKey); num_to_bytes(ck[i].key, 6, mp.mpa.abtKey);
mc = dumpKeysA ? 0x60 : 0x61; mc = dumpKeysA ? 0x60 : 0x61;
if (!nfc_initiator_mifare_cmd(r.pdi,mc,t.sectors[j].trailer,&mp)) { 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", // 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); // bytes_to_num(mp.mpa.abtKey, 6), j, t.sectors[j].trailer);
mf_anticollision(t, r); mf_anticollision(t, r);
@ -403,7 +403,7 @@ int main(int argc, char * const argv[]) {
// Save all information about successfull authentization // Save all information about successfull authentization
bk->size++; bk->size++;
bk->brokenKeys = (uint64_t *) realloc((void *)bk->brokenKeys, bk->size * sizeof(uint64_t)); 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); bk->brokenKeys[bk->size - 1] = bytes_to_num(mp.mpa.abtKey, 6);
if (dumpKeysA) { if (dumpKeysA) {
memcpy(t.sectors[j].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey)); memcpy(t.sectors[j].KeyA, mp.mpa.abtKey, sizeof(mp.mpa.abtKey));
t.sectors[j].foundKeyA = true; t.sectors[j].foundKeyA = true;
@ -427,7 +427,7 @@ int main(int argc, char * const argv[]) {
} }
// We haven't found any key, exiting // We haven't found any key, exiting
if ((dumpKeysA && !t.sectors[j].foundKeyA) || (!dumpKeysA && !t.sectors[j].foundKeyB)) { if ((dumpKeysA && !t.sectors[j].foundKeyA) || (!dumpKeysA && !t.sectors[j].foundKeyB)) {
ERR ("No success, maybe you should increase the probes"); ERR("No success, maybe you should increase the probes");
goto error; goto error;
} }
} }
@ -492,10 +492,10 @@ int main(int argc, char * const argv[]) {
} }
if (trailer_block(block)) { if (trailer_block(block)) {
// Copy the keys over from our key dump and store the retrieved access bits // 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.abtKeyA, t.sectors[i].KeyA, 6);
memcpy(mtDump.amb[block].mbt.abtKeyB,t.sectors[i].KeyB,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); 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); } 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)); memcpy(mp.mpa.abtAuthUid, t.nt.nti.nai.abtUid + t.nt.nti.nai.szUidLen - 4, sizeof(mp.mpa.abtAuthUid));
} }
@ -518,14 +518,15 @@ int main(int argc, char * const argv[]) {
// Disconnect device and exit // Disconnect device and exit
nfc_close(r.pdi); nfc_close(r.pdi);
nfc_exit(context); nfc_exit(context);
exit (EXIT_SUCCESS); exit(EXIT_SUCCESS);
error: error:
nfc_close(r.pdi); nfc_close(r.pdi);
nfc_exit(context); nfc_exit(context);
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
void usage(FILE * stream, int errno) { void usage(FILE *stream, int errno)
{
fprintf(stream, "Usage: mfoc [-h] [-k key]... [-P probnum] [-T tolerance] [-O output]\n"); fprintf(stream, "Usage: mfoc [-h] [-k key]... [-P probnum] [-T tolerance] [-O output]\n");
fprintf(stream, "\n"); fprintf(stream, "\n");
fprintf(stream, " h print this help and exit\n"); fprintf(stream, " h print this help and exit\n");
@ -547,58 +548,61 @@ void usage(FILE * stream, int errno) {
exit(errno); exit(errno);
} }
void mf_init(mfreader *r) { void mf_init(mfreader *r)
{
// Connect to the first NFC device // Connect to the first NFC device
nfc_init(&context); nfc_init(&context);
r->pdi = nfc_open(context, NULL); r->pdi = nfc_open(context, NULL);
if (!r->pdi) { if (!r->pdi) {
printf ("No NFC device found.\n"); printf("No NFC device found.\n");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} }
void mf_configure(nfc_device* pdi) { void mf_configure(nfc_device *pdi)
if (nfc_initiator_init (pdi) < 0) { {
nfc_perror (pdi, "nfc_initiator_init"); if (nfc_initiator_init(pdi) < 0) {
exit (EXIT_FAILURE); nfc_perror(pdi, "nfc_initiator_init");
exit(EXIT_FAILURE);
} }
// Drop the field for a while, so can be reset // Drop the field for a while, so can be reset
if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, false) < 0) { if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, false) < 0) {
nfc_perror (pdi, "nfc_device_set_property_bool activate field"); nfc_perror(pdi, "nfc_device_set_property_bool activate field");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Let the reader only try once to find a tag // Let the reader only try once to find a tag
if (nfc_device_set_property_bool(pdi, NP_INFINITE_SELECT, false) < 0) { if (nfc_device_set_property_bool(pdi, NP_INFINITE_SELECT, false) < 0) {
nfc_perror (pdi, "nfc_device_set_property_bool infinite select"); nfc_perror(pdi, "nfc_device_set_property_bool infinite select");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Configure the CRC and Parity settings // Configure the CRC and Parity settings
if (nfc_device_set_property_bool(pdi, NP_HANDLE_CRC, true) < 0) { if (nfc_device_set_property_bool(pdi, NP_HANDLE_CRC, true) < 0) {
nfc_perror (pdi, "nfc_device_set_property_bool crc"); nfc_perror(pdi, "nfc_device_set_property_bool crc");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (nfc_device_set_property_bool(pdi, NP_HANDLE_PARITY, true) < 0) { if (nfc_device_set_property_bool(pdi, NP_HANDLE_PARITY, true) < 0) {
nfc_perror (pdi, "nfc_device_set_property_bool parity"); nfc_perror(pdi, "nfc_device_set_property_bool parity");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Enable the field so more power consuming cards can power themselves up // Enable the field so more power consuming cards can power themselves up
if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, true) < 0) { if (nfc_device_set_property_bool(pdi, NP_ACTIVATE_FIELD, true) < 0) {
nfc_perror (pdi, "nfc_device_set_property_bool activate field"); nfc_perror(pdi, "nfc_device_set_property_bool activate field");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} }
void mf_select_tag(nfc_device* pdi, nfc_target* pnt) { void mf_select_tag(nfc_device *pdi, nfc_target *pnt)
{
// Poll for a ISO14443A (MIFARE) tag // Poll for a ISO14443A (MIFARE) tag
const nfc_modulation nm = { const nfc_modulation nm = {
.nmt = NMT_ISO14443A, .nmt = NMT_ISO14443A,
.nbr = NBR_106, .nbr = NBR_106,
}; };
if (nfc_initiator_select_passive_target(pdi, nm, NULL, 0, pnt) < 0) { if (nfc_initiator_select_passive_target(pdi, nm, NULL, 0, pnt) < 0) {
ERR ("Unable to connect to the MIFARE Classic tag"); ERR("Unable to connect to the MIFARE Classic tag");
nfc_close(pdi); nfc_close(pdi);
nfc_exit(context); nfc_exit(context);
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} }
@ -609,7 +613,8 @@ int trailer_block(uint32_t block)
} }
// Return position of sector if it is encrypted with the default key otherwise exit.. // Return position of sector if it is encrypted with the default key otherwise exit..
int find_exploit_sector(mftag t) { int find_exploit_sector(mftag t)
{
int i; int i;
bool interesting = false; bool interesting = false;
@ -629,39 +634,41 @@ int find_exploit_sector(mftag t) {
return i; return i;
} }
} }
ERR ("\n\nNo sector encrypted with the default key has been found, exiting.."); ERR("\n\nNo sector encrypted with the default key has been found, exiting..");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
void mf_anticollision(mftag t, mfreader r) { void mf_anticollision(mftag t, mfreader r)
{
const nfc_modulation nm = { const nfc_modulation nm = {
.nmt = NMT_ISO14443A, .nmt = NMT_ISO14443A,
.nbr = NBR_106, .nbr = NBR_106,
}; };
if (nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) < 0) { if (nfc_initiator_select_passive_target(r.pdi, nm, NULL, 0, &t.nt) < 0) {
nfc_perror (r.pdi, "nfc_initiator_select_passive_target"); nfc_perror(r.pdi, "nfc_initiator_select_passive_target");
ERR ("Tag has been removed"); ERR("Tag has been removed");
exit (EXIT_FAILURE); 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) { 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 *pcs;
struct Crypto1State* revstate_start; struct Crypto1State *revstate;
struct Crypto1State *revstate_start;
uint64_t lfsr; uint64_t lfsr;
// Possible key counter, just continue with a previous "session" // Possible key counter, just continue with a previous "session"
uint32_t kcount = pk->size; uint32_t kcount = pk->size;
uint8_t Nr[4] = { 0x00,0x00,0x00,0x00 }; // Reader nonce uint8_t Nr[4] = { 0x00, 0x00, 0x00, 0x00 }; // Reader nonce
uint8_t Auth[4] = { 0x00, t.sectors[e_sector].trailer, 0x00, 0x00 }; 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 AuthEnc[4] = { 0x00, t.sectors[e_sector].trailer, 0x00, 0x00 };
uint8_t AuthEncPar[8] = { 0x00,0x00,0x00,0x00,0x00,0x00,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 ArEnc[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t ArEncPar[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 Rx[MAX_FRAME_LEN]; // Tag response
uint8_t RxPar[MAX_FRAME_LEN]; // Tag response uint8_t RxPar[MAX_FRAME_LEN]; // Tag response
@ -672,21 +679,21 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// Prepare AUTH command // Prepare AUTH command
Auth[0] = (t.sectors[e_sector].foundKeyA) ? 0x60 : 0x61; Auth[0] = (t.sectors[e_sector].foundKeyA) ? 0x60 : 0x61;
iso14443a_crc_append (Auth,2); iso14443a_crc_append(Auth, 2);
// fprintf(stdout, "\nAuth command:\t"); // fprintf(stdout, "\nAuth command:\t");
// print_hex(Auth, 4); // print_hex(Auth, 4);
// We need full control over the CRC // We need full control over the CRC
if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, false) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, false) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool crc"); nfc_perror(r.pdi, "nfc_device_set_property_bool crc");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Request plain tag-nonce // Request plain tag-nonce
// TODO: Set NP_EASY_FRAMING option only once if possible // TODO: Set NP_EASY_FRAMING option only once if possible
if (nfc_device_set_property_bool (r.pdi, NP_EASY_FRAMING, false) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_EASY_FRAMING, false) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool framing"); nfc_perror(r.pdi, "nfc_device_set_property_bool framing");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (nfc_initiator_transceive_bytes(r.pdi, Auth, 4, Rx, sizeof(Rx), 0) < 0) { if (nfc_initiator_transceive_bytes(r.pdi, Auth, 4, Rx, sizeof(Rx), 0) < 0) {
@ -694,9 +701,9 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (nfc_device_set_property_bool (r.pdi, NP_EASY_FRAMING, true) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_EASY_FRAMING, true) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool"); nfc_perror(r.pdi, "nfc_device_set_property_bool");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// print_hex(Rx, 4); // print_hex(Rx, 4);
@ -726,14 +733,14 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// Get the next random byte // Get the next random byte
Nt = prng_successor(Nt, 8); Nt = prng_successor(Nt, 8);
// Encrypt the reader-answer (Nt' = suc2(Nt)) // Encrypt the reader-answer (Nt' = suc2(Nt))
ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ (Nt&0xff); ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^(Nt & 0xff);
ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt); ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt);
} }
// Finally we want to send arbitrary parity bits // Finally we want to send arbitrary parity bits
if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, false) < 0) { if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, false) < 0) {
nfc_perror (r.pdi, "nfc_device_set_property_bool parity"); nfc_perror(r.pdi, "nfc_device_set_property_bool parity");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Transmit reader-answer // Transmit reader-answer
@ -741,8 +748,8 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// print_hex_par(ArEnc, 64, ArEncPar); // print_hex_par(ArEnc, 64, ArEncPar);
int res; int res;
if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) { if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) {
ERR ("Reader-answer transfer error, exiting.."); ERR("Reader-answer transfer error, exiting..");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Now print the answer from the tag // Now print the answer from the tag
@ -751,9 +758,9 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// Decrypt the tag answer and verify that suc3(Nt) is At // Decrypt the tag answer and verify that suc3(Nt) is At
Nt = prng_successor(Nt, 32); Nt = prng_successor(Nt, 32);
if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt&0xFFFFFFFF))) { if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt & 0xFFFFFFFF))) {
ERR ("[At] is not Suc3(Nt), something is wrong, exiting.."); ERR("[At] is not Suc3(Nt), something is wrong, exiting..");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// fprintf(stdout, "Authentication completed.\n\n"); // fprintf(stdout, "Authentication completed.\n\n");
@ -763,7 +770,7 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// fprintf(stdout, "Nested Auth number: %x: ,", m); // fprintf(stdout, "Nested Auth number: %x: ,", m);
// Encrypt Auth command with the current keystream // Encrypt Auth command with the current keystream
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
AuthEnc[i] = crypto1_byte(pcs,0x00,0) ^ Auth[i]; AuthEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ Auth[i];
// Encrypt the parity bits with the 4 plaintext bytes // Encrypt the parity bits with the 4 plaintext bytes
AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]); AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]);
} }
@ -771,7 +778,7 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// Sending the encrypted Auth command // Sending the encrypted Auth command
if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) { if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) {
fprintf(stdout, "Error requesting encrypted tag-nonce\n"); fprintf(stdout, "Error requesting encrypted tag-nonce\n");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Decrypt the encrypted auth // Decrypt the encrypted auth
@ -794,18 +801,18 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
Nt = prng_successor(NtLast, 32); Nt = prng_successor(NtLast, 32);
for (i = 4; i < 8; i++) { for (i = 4; i < 8; i++) {
Nt = prng_successor(Nt, 8); Nt = prng_successor(Nt, 8);
ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ (Nt&0xFF); ArEnc[i] = crypto1_byte(pcs, 0x00, 0) ^(Nt & 0xFF);
ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt); ArEncPar[i] = filter(pcs->odd) ^ oddparity(Nt);
} }
nfc_device_set_property_bool(r.pdi,NP_HANDLE_PARITY,false); 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)) { if (((res = nfc_initiator_transceive_bits(r.pdi, ArEnc, 64, ArEncPar, Rx, sizeof(Rx), RxPar)) < 0) || (res != 32)) {
ERR ("Reader-answer transfer error, exiting.."); ERR("Reader-answer transfer error, exiting..");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
Nt = prng_successor(Nt, 32); Nt = prng_successor(Nt, 32);
if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt&0xFFFFFFFF))) { if (!((crypto1_word(pcs, 0x00, 0) ^ bytes_to_num(Rx, 4)) == (Nt & 0xFFFFFFFF))) {
ERR ("[At] is not Suc3(Nt), something is wrong, exiting.."); ERR("[At] is not Suc3(Nt), something is wrong, exiting..");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} // Next auth probe } // Next auth probe
@ -819,28 +826,28 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// Again, prepare the Auth command with MC_AUTH_A, recover the block and CRC // Again, prepare the Auth command with MC_AUTH_A, recover the block and CRC
Auth[0] = dumpKeysA ? 0x60 : 0x61; Auth[0] = dumpKeysA ? 0x60 : 0x61;
Auth[1] = a_sector; Auth[1] = a_sector;
iso14443a_crc_append (Auth,2); iso14443a_crc_append(Auth, 2);
// Encryption of the Auth command, sending the Auth command // Encryption of the Auth command, sending the Auth command
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
AuthEnc[i] = crypto1_byte(pcs,0x00,0) ^ Auth[i]; AuthEnc[i] = crypto1_byte(pcs, 0x00, 0) ^ Auth[i];
// Encrypt the parity bits with the 4 plaintext bytes // Encrypt the parity bits with the 4 plaintext bytes
AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]); AuthEncPar[i] = filter(pcs->odd) ^ oddparity(Auth[i]);
} }
if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) { if (nfc_initiator_transceive_bits(r.pdi, AuthEnc, 32, AuthEncPar, Rx, sizeof(Rx), RxPar) < 0) {
ERR ("while requesting encrypted tag-nonce"); ERR("while requesting encrypted tag-nonce");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Finally we want to send arbitrary parity bits // Finally we want to send arbitrary parity bits
if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_PARITY, true) < 0) { 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"); nfc_perror(r.pdi, "nfc_device_set_property_bool parity restore M");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (nfc_device_set_property_bool(r.pdi, NP_HANDLE_CRC, true) < 0) { 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"); nfc_perror(r.pdi, "nfc_device_set_property_bool crc restore M");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
// Save the encrypted nonce // Save the encrypted nonce
@ -853,8 +860,8 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// Iterate over Nt-x, Nt+x // Iterate over Nt-x, Nt+x
// fprintf(stdout, "Iterate from %d to %d\n", d->median-TOLERANCE, d->median+TOLERANCE); // fprintf(stdout, "Iterate from %d to %d\n", d->median-TOLERANCE, d->median+TOLERANCE);
NtProbe = prng_successor(Nt, d->median-d->tolerance); NtProbe = prng_successor(Nt, d->median - d->tolerance);
for (m = d->median-d->tolerance; m <= d->median+d->tolerance; m +=2) { for (m = d->median - d->tolerance; m <= d->median + d->tolerance; m += 2) {
// Try to recover the keystream1 // Try to recover the keystream1
Ks1 = NtEnc ^ NtProbe; Ks1 = NtEnc ^ NtProbe;
@ -876,8 +883,8 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
// fprintf(stdout, "New chunk by %d, sizeof %lu\n", kcount, pk->size * sizeof(uint64_t)); // 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)); pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t));
if (pk->possibleKeys == NULL) { if (pk->possibleKeys == NULL) {
ERR ("Memory allocation error for pk->possibleKeys"); ERR("Memory allocation error for pk->possibleKeys");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} }
pk->possibleKeys[kcount] = lfsr; pk->possibleKeys[kcount] = lfsr;
@ -892,8 +899,8 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
if (kcount != 0) { if (kcount != 0) {
pk->size = --kcount; pk->size = --kcount;
if ((pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t))) == NULL) { if ((pk->possibleKeys = (uint64_t *) realloc((void *)pk->possibleKeys, pk->size * sizeof(uint64_t))) == NULL) {
ERR ("Memory allocation error for pk->possibleKeys"); ERR("Memory allocation error for pk->possibleKeys");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
} }
} }
@ -902,7 +909,8 @@ int mf_enhanced_auth(int e_sector, int a_sector, mftag t, mfreader r, denonce *d
} }
// Return the median value from the nonce distances array // Return the median value from the nonce distances array
uint32_t median(denonce d) { uint32_t median(denonce d)
{
int middle = (int) d.num_distances / 2; int middle = (int) d.num_distances / 2;
qsort(d.distances, d.num_distances, sizeof(uint32_t), compar_int); qsort(d.distances, d.num_distances, sizeof(uint32_t), compar_int);
@ -911,40 +919,43 @@ uint32_t median(denonce d) {
return d.distances[middle]; return d.distances[middle];
} else { } else {
// Even number of elements, return the smaller value // Even number of elements, return the smaller value
return (uint32_t) (d.distances[middle-1]); return (uint32_t)(d.distances[middle - 1]);
} }
} }
int compar_int(const void * a, const void * b) { int compar_int(const void *a, const void *b)
return (*(uint64_t*)b - *(uint64_t*)a); {
return (*(uint64_t *)b - * (uint64_t *)a);
} }
// Compare countKeys structure // Compare countKeys structure
int compar_special_int(const void * a, const void * b) { int compar_special_int(const void *a, const void *b)
{
return (((countKeys *)b)->count - ((countKeys *)a)->count); return (((countKeys *)b)->count - ((countKeys *)a)->count);
} }
countKeys * uniqsort(uint64_t * possibleKeys, uint32_t size) { countKeys *uniqsort(uint64_t *possibleKeys, uint32_t size)
{
unsigned int i, j = 0; unsigned int i, j = 0;
int count = 0; int count = 0;
countKeys *our_counts; 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)); our_counts = calloc(size, sizeof(countKeys));
if (our_counts == NULL) { if (our_counts == NULL) {
ERR ("Memory allocation error for our_counts"); ERR("Memory allocation error for our_counts");
exit (EXIT_FAILURE); exit(EXIT_FAILURE);
} }
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
if (possibleKeys[i+1] == possibleKeys[i]) { if (possibleKeys[i + 1] == possibleKeys[i]) {
count++; count++;
} else { } else {
our_counts[j].key = possibleKeys[i]; our_counts[j].key = possibleKeys[i];
our_counts[j].count = count; our_counts[j].count = count;
j++; j++;
count=0; count = 0;
} }
} }
qsort(our_counts, j, sizeof(countKeys), compar_special_int); qsort(our_counts, j, sizeof(countKeys), compar_special_int);
@ -953,23 +964,25 @@ countKeys * uniqsort(uint64_t * possibleKeys, uint32_t size) {
// Return 1 if the nonce is invalid else return 0 // 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) { 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))) & \ return ((odd_parity((Nt >> 24) & 0xFF) == ((parity[0]) ^ odd_parity((NtEnc >> 24) & 0xFF) ^ BIT(Ks1, 16))) & \
(odd_parity((Nt >> 8) & 0xFF) == ((parity[2]) ^ odd_parity((NtEnc >> 8) & 0xFF) ^ BIT(Ks1,0)))) ? 1 : 0; (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) { void num_to_bytes(uint64_t n, uint32_t len, uint8_t *dest)
{
while (len--) { while (len--) {
dest[len] = (uint8_t) n; dest[len] = (uint8_t) n;
n >>= 8; n >>= 8;
} }
} }
long long unsigned int bytes_to_num(uint8_t* src, uint32_t len) { long long unsigned int bytes_to_num(uint8_t *src, uint32_t len)
{
uint64_t num = 0; uint64_t num = 0;
while (len--) while (len--) {
{
num = (num << 8) | (*src); num = (num << 8) | (*src);
src++; src++;
} }

20
src/mfoc.h
View file

@ -41,7 +41,7 @@ typedef struct {
typedef struct { typedef struct {
nfc_target nt; nfc_target nt;
sector * sectors; // Allocate later, we do not know the number of sectors yet sector *sectors; // Allocate later, we do not know the number of sectors yet
sector e_sector; // Exploit sector sector e_sector; // Exploit sector
uint8_t num_sectors; uint8_t num_sectors;
uint8_t num_blocks; uint8_t num_blocks;
@ -69,18 +69,18 @@ typedef struct {
} countKeys; } countKeys;
void usage(FILE * stream, int errno); void usage(FILE *stream, int errno);
void mf_init(mfreader *r); void mf_init(mfreader *r);
void mf_configure(nfc_device* pdi); void mf_configure(nfc_device *pdi);
void mf_select_tag(nfc_device* pdi, nfc_target* pnt); void mf_select_tag(nfc_device *pdi, nfc_target *pnt);
int trailer_block(uint32_t block); int trailer_block(uint32_t block);
int find_exploit_sector(mftag t); int find_exploit_sector(mftag t);
void mf_anticollision(mftag t, mfreader r); 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); 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); uint32_t median(denonce d);
int compar_int(const void * a, const void * b); 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 valid_nonce(uint32_t Nt, uint32_t NtEnc, uint32_t Ks1, uint8_t *parity);
int compar_special_int(const void * a, const void * b); int compar_special_int(const void *a, const void *b);
countKeys * uniqsort(uint64_t *possibleKeys, uint32_t size); countKeys *uniqsort(uint64_t *possibleKeys, uint32_t size);
void num_to_bytes(uint64_t n, uint32_t len, uint8_t* dest); 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); long long unsigned int bytes_to_num(uint8_t *src, uint32_t len);