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
/** extend_table\r
* using a bit of the keystream extend the table of possible lfsr states\r
*/\r
-static inline void extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in)\r
+static inline void\r
+extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in)\r
{\r
in <<= 24;\r
for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1)\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
-/* int i, ret = 0;\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
*/\r
uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb)\r
{\r
-/* int i;\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
int nonce_distance(uint32_t from, uint32_t to)\r
{\r
uint16_t x, i;\r
- if(!dist) {\r
+ // generate distance lookup table\r
+ if (!dist) {\r
dist = malloc(2 << 16);\r
- if(!dist)\r
- return -1;\r
+ if (!dist) return -1;\r
+ \r
for (x = i = 1; i; ++i) {\r
dist[(x & 0xff) << 8 | x >> 8] = i;\r
x = x >> 1 | (x ^ x >> 2 ^ x >> 3 ^ x >> 5) << 15;\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
* encrypt the NACK which is observed when varying only the 3 last bits of Nr\r
* only correct iff [NR_3] ^ NR_3 does not depend on Nr_3\r
*/\r
-uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)\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
free(odd);\r
free(even);\r
return statelist;\r
-}\r
+}
\ No newline at end of file
projects / proxmark3-svn / blobdiff