Foundation, Inc., 51 Franklin Street, Fifth Floor,\r
Boston, MA 02110-1301, US$\r
\r
- Copyright (C) 2008-2008 bla <blapost@gmail.com>\r
+ Copyright (C) 2008-2014 bla <blapost@gmail.com>\r
*/\r
#include "crapto1.h"\r
#include <stdlib.h>\r
static uint8_t filterlut[1 << 20];\r
static void __attribute__((constructor)) fill_lut()\r
{\r
- uint32_t i;\r
- for(i = 0; i < 1 << 20; ++i)\r
- filterlut[i] = filter(i);\r
+ uint32_t i;\r
+ for(i = 0; i < 1 << 20; ++i)\r
+ filterlut[i] = filter(i);\r
}\r
#define filter(x) (filterlut[(x) & 0xfffff])\r
#endif\r
\r
static void quicksort(uint32_t* const start, uint32_t* const stop)\r
{\r
- uint32_t *it = start + 1, *rit = stop;\r
- uint32_t tmp;\r
+ uint32_t *it = start + 1, *rit = stop, t;\r
\r
if(it > rit)\r
return;\r
++it;\r
else if(*rit > *start)\r
--rit;\r
- else {\r
- tmp = *it;\r
- *it = *rit;\r
- *rit = tmp;\r
- }\r
+ else\r
+ t = *it, *it = *rit, *rit = t;\r
\r
if(*rit >= *start)\r
--rit;\r
- if(rit != start) {\r
- tmp = *rit;\r
- *rit = *start;\r
- *start = tmp;\r
- }\r
+ if(rit != start)\r
+ t = *rit, *rit = *start, *start = t;\r
\r
quicksort(start, rit - 1);\r
quicksort(rit + 1, stop);\r
uint32_t *even_head = 0, *even_tail = 0, eks = 0;\r
int i;\r
\r
+ // split the keystream into an odd and even part\r
for(i = 31; i >= 0; i -= 2)\r
oks = oks << 1 | BEBIT(ks2, i);\r
for(i = 30; i >= 0; i -= 2)\r
\r
statelist->odd = statelist->even = 0;\r
\r
+ // initialize statelists: add all possible states which would result into the rightmost 2 bits of the keystream\r
for(i = 1 << 20; i >= 0; --i) {\r
if(filter(i) == (oks & 1))\r
*++odd_tail = i;\r
*++even_tail = i;\r
}\r
\r
+ // extend the statelists. Look at the next 8 Bits of the keystream (4 Bit each odd and even):\r
for(i = 0; i < 4; i++) {\r
extend_table_simple(odd_head, &odd_tail, (oks >>= 1) & 1);\r
extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1);\r
}\r
\r
+ // the statelists now contain all states which could have generated the last 10 Bits of the keystream.\r
+ // 22 bits to go to recover 32 bits in total. From now on, we need to take the "in"\r
+ // parameter into account.\r
in = (in >> 16 & 0xff) | (in << 16) | (in & 0xff00);\r
recover(odd_head, odd_tail, oks,\r
even_head, even_tail, eks, 11, statelist, in << 1);\r
{\r
int out;\r
uint8_t ret;\r
- uint32_t tmp;\r
+ uint32_t t;\r
\r
s->odd &= 0xffffff;\r
- tmp = s->odd;\r
- s->odd = s->even;\r
- s->even = tmp;\r
+ t = s->odd, s->odd = s->even, s->even = t;\r
\r
out = s->even & 1;\r
out ^= LF_POLY_EVEN & (s->even >>= 1);\r
*/\r
uint8_t lfsr_rollback_byte(struct Crypto1State *s, uint32_t in, int fb)\r
{\r
+ /*\r
int i, ret = 0;\r
for (i = 7; i >= 0; --i)\r
ret |= lfsr_rollback_bit(s, BIT(in, i), fb) << i;\r
+*/\r
+// unfold loop 20160112\r
+ uint8_t ret = 0;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 7), fb) << 7;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 6), fb) << 6;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 5), fb) << 5;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 4), fb) << 4;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 3), fb) << 3;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 2), fb) << 2;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 1), fb) << 1;\r
+ ret |= lfsr_rollback_bit(s, BIT(in, 0), fb) << 0;\r
return ret;\r
}\r
/** lfsr_rollback_word\r
*/\r
uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb)\r
{\r
+ /*\r
int i;\r
uint32_t ret = 0;\r
for (i = 31; i >= 0; --i)\r
ret |= lfsr_rollback_bit(s, BEBIT(in, i), fb) << (i ^ 24);\r
+*/\r
+// unfold loop 20160112\r
+ uint32_t ret = 0;\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 31), fb) << (31 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 30), fb) << (30 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 29), fb) << (29 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 28), fb) << (28 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 27), fb) << (27 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 26), fb) << (26 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 25), fb) << (25 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 24), fb) << (24 ^ 24);\r
+\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 23), fb) << (23 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 22), fb) << (22 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 21), fb) << (21 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 20), fb) << (20 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 19), fb) << (19 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 18), fb) << (18 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 17), fb) << (17 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 16), fb) << (16 ^ 24);\r
+\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 15), fb) << (15 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 14), fb) << (14 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 13), fb) << (13 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 12), fb) << (12 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 11), fb) << (11 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 10), fb) << (10 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 9), fb) << (9 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 8), fb) << (8 ^ 24);\r
+\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 7), fb) << (7 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 6), fb) << (6 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 5), fb) << (5 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 4), fb) << (4 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 3), fb) << (3 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 2), fb) << (2 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 1), fb) << (1 ^ 24);\r
+ ret |= lfsr_rollback_bit(s, BEBIT(in, 0), fb) << (0 ^ 24);\r
return ret;\r
}\r
\r
static uint32_t fastfwd[2][8] = {\r
{ 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB},\r
{ 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}};\r
+\r
+\r
/** lfsr_prefix_ks\r
*\r
* Is an exported helper function from the common prefix attack\r
*/\r
uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)\r
{\r
- uint32_t c, entry, *candidates = malloc(4 << 10);\r
- int i, size = 0, good;\r
-\r
- if(!candidates)\r
- return 0;\r
+ uint32_t *candidates = malloc(4 << 10);\r
+ if(!candidates) return 0;\r
+ \r
+ uint32_t c, entry;\r
+ int size = 0, i, good;\r
\r
for(i = 0; i < 1 << 21; ++i) {\r
for(c = 0, good = 1; good && c < 8; ++c) {\r
/** check_pfx_parity\r
* helper function which eliminates possible secret states using parity bits\r
*/\r
-static struct Crypto1State*\r
-check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],\r
- uint32_t odd, uint32_t even, struct Crypto1State* sl)\r
+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)\r
{\r
uint32_t ks1, nr, ks2, rr, ks3, c, good = 1;\r
\r
return sl + good;\r
}\r
\r
-\r
/** lfsr_common_prefix\r
* Implentation of the common prefix attack.\r
+ * Requires the 28 bit constant prefix used as reader nonce (pfx)\r
+ * The reader response used (rr)\r
+ * The keystream used to encrypt the observed NACK's (ks)\r
+ * The parity bits (par)\r
+ * It returns a zero terminated list of possible cipher states after the\r
+ * tag nonce was fed in\r
*/\r
-struct Crypto1State*\r
-lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8])\r
+struct Crypto1State* lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8])\r
{\r
struct Crypto1State *statelist, *s;\r
uint32_t *odd, *even, *o, *e, top;\r
odd = lfsr_prefix_ks(ks, 1);\r
even = lfsr_prefix_ks(ks, 0);\r
\r
- s = statelist = malloc((sizeof *statelist) << 20);\r
+ s = statelist = malloc((sizeof *statelist) << 21);\r
if(!s || !odd || !even) {\r
free(statelist);\r
statelist = 0;\r
- goto out;\r
+ goto out;\r
}\r
\r
for(o = odd; *o + 1; ++o)\r
free(odd);\r
free(even);\r
return statelist;\r
-}\r
+}
\ No newline at end of file
projects / proxmark3-svn / blobdiff