]> git.zerfleddert.de Git - proxmark3-svn/blob - client/cmdhfmfhard.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
FIX: this should remove some warnings while compiling on linux and when running Travi...
[proxmark3-svn] / client / cmdhfmfhard.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2015 piwi
3 //
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
6 // the license.
7 //-----------------------------------------------------------------------------
8 // Implements a card only attack based on crypto text (encrypted nonces
9 // received during a nested authentication) only. Unlike other card only
10 // attacks this doesn't rely on implementation errors but only on the
11 // inherent weaknesses of the crypto1 cypher. Described in
12 // Carlo Meijer, Roel Verdult, "Ciphertext-only Cryptanalysis on Hardened
13 // Mifare Classic Cards" in Proceedings of the 22nd ACM SIGSAC Conference on
14 // Computer and Communications Security, 2015
15 //-----------------------------------------------------------------------------
16
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <pthread.h>
21 #include <locale.h>
22 #include <math.h>
23 #include "proxmark3.h"
24 #include "cmdmain.h"
25 #include "ui.h"
26 #include "util.h"
27 #include "nonce2key/crapto1.h"
28 #include "parity.h"
29
30 // uint32_t test_state_odd = 0;
31 // uint32_t test_state_even = 0;
32
33 #define CONFIDENCE_THRESHOLD 0.95 // Collect nonces until we are certain enough that the following brute force is successfull
34 #define GOOD_BYTES_REQUIRED 30
35
36
37 static const float p_K[257] = { // the probability that a random nonce has a Sum Property == K
38 0.0290, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
39 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
40 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
41 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
42 0.0083, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
43 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
44 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
45 0.0006, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
46 0.0339, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
47 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
48 0.0048, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
49 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
50 0.0934, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
51 0.0119, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
52 0.0489, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
53 0.0602, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
54 0.4180, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
55 0.0602, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
56 0.0489, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
57 0.0119, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
58 0.0934, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
59 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
60 0.0048, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
61 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
62 0.0339, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
63 0.0006, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
64 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
65 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
66 0.0083, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
67 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
68 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
69 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
70 0.0290 };
71
72
73 typedef struct noncelistentry {
74 uint32_t nonce_enc;
75 uint8_t par_enc;
76 void *next;
77 } noncelistentry_t;
78
79 typedef struct noncelist {
80 uint16_t num;
81 uint16_t Sum;
82 uint16_t Sum8_guess;
83 uint8_t BitFlip[2];
84 float Sum8_prob;
85 bool updated;
86 noncelistentry_t *first;
87 float score1, score2;
88 } noncelist_t;
89
90
91 static uint32_t cuid;
92 static noncelist_t nonces[256];
93 static uint8_t best_first_bytes[256];
94 static uint16_t first_byte_Sum = 0;
95 static uint16_t first_byte_num = 0;
96 static uint16_t num_good_first_bytes = 0;
97 static uint64_t maximum_states = 0;
98 static uint64_t known_target_key;
99 static bool write_stats = false;
100 static FILE *fstats = NULL;
101
102
103 typedef enum {
104 EVEN_STATE = 0,
105 ODD_STATE = 1
106 } odd_even_t;
107
108 #define STATELIST_INDEX_WIDTH 16
109 #define STATELIST_INDEX_SIZE (1<<STATELIST_INDEX_WIDTH)
110
111 typedef struct {
112 uint32_t *states[2];
113 uint32_t len[2];
114 uint32_t *index[2][STATELIST_INDEX_SIZE];
115 } partial_indexed_statelist_t;
116
117 typedef struct {
118 uint32_t *states[2];
119 uint32_t len[2];
120 void* next;
121 } statelist_t;
122
123
124 static partial_indexed_statelist_t partial_statelist[17];
125 static partial_indexed_statelist_t statelist_bitflip;
126
127 static statelist_t *candidates = NULL;
128
129
130 static int add_nonce(uint32_t nonce_enc, uint8_t par_enc)
131 {
132 uint8_t first_byte = nonce_enc >> 24;
133 noncelistentry_t *p1 = nonces[first_byte].first;
134 noncelistentry_t *p2 = NULL;
135
136 if (p1 == NULL) { // first nonce with this 1st byte
137 first_byte_num++;
138 first_byte_Sum += evenparity32((nonce_enc & 0xff000000) | (par_enc & 0x08));
139 // printf("Adding nonce 0x%08x, par_enc 0x%02x, parity(0x%08x) = %d\n",
140 // nonce_enc,
141 // par_enc,
142 // (nonce_enc & 0xff000000) | (par_enc & 0x08) |0x01,
143 // parity((nonce_enc & 0xff000000) | (par_enc & 0x08));
144 }
145
146 while (p1 != NULL && (p1->nonce_enc & 0x00ff0000) < (nonce_enc & 0x00ff0000)) {
147 p2 = p1;
148 p1 = p1->next;
149 }
150
151 if (p1 == NULL) { // need to add at the end of the list
152 if (p2 == NULL) { // list is empty yet. Add first entry.
153 p2 = nonces[first_byte].first = malloc(sizeof(noncelistentry_t));
154 } else { // add new entry at end of existing list.
155 p2 = p2->next = malloc(sizeof(noncelistentry_t));
156 }
157 } else if ((p1->nonce_enc & 0x00ff0000) != (nonce_enc & 0x00ff0000)) { // found distinct 2nd byte. Need to insert.
158 if (p2 == NULL) { // need to insert at start of list
159 p2 = nonces[first_byte].first = malloc(sizeof(noncelistentry_t));
160 } else {
161 p2 = p2->next = malloc(sizeof(noncelistentry_t));
162 }
163 } else { // we have seen this 2nd byte before. Nothing to add or insert.
164 return (0);
165 }
166
167 // add or insert new data
168 p2->next = p1;
169 p2->nonce_enc = nonce_enc;
170 p2->par_enc = par_enc;
171
172 nonces[first_byte].num++;
173 nonces[first_byte].Sum += evenparity32((nonce_enc & 0x00ff0000) | (par_enc & 0x04));
174 nonces[first_byte].updated = true; // indicates that we need to recalculate the Sum(a8) probability for this first byte
175
176 return (1); // new nonce added
177 }
178
179
180 static void init_nonce_memory(void)
181 {
182 for (uint16_t i = 0; i < 256; i++) {
183 nonces[i].num = 0;
184 nonces[i].Sum = 0;
185 nonces[i].Sum8_guess = 0;
186 nonces[i].Sum8_prob = 0.0;
187 nonces[i].updated = true;
188 nonces[i].first = NULL;
189 }
190 first_byte_num = 0;
191 first_byte_Sum = 0;
192 num_good_first_bytes = 0;
193 }
194
195
196 static void free_nonce_list(noncelistentry_t *p)
197 {
198 if (p == NULL) {
199 return;
200 } else {
201 free_nonce_list(p->next);
202 free(p);
203 }
204 }
205
206
207 static void free_nonces_memory(void)
208 {
209 for (uint16_t i = 0; i < 256; i++) {
210 free_nonce_list(nonces[i].first);
211 }
212 }
213
214
215 static uint16_t PartialSumProperty(uint32_t state, odd_even_t odd_even)
216 {
217 uint16_t sum = 0;
218 for (uint16_t j = 0; j < 16; j++) {
219 uint32_t st = state;
220 uint16_t part_sum = 0;
221 if (odd_even == ODD_STATE) {
222 for (uint16_t i = 0; i < 5; i++) {
223 part_sum ^= filter(st);
224 st = (st << 1) | ((j >> (3-i)) & 0x01) ;
225 }
226 part_sum ^= 1; // XOR 1 cancelled out for the other 8 bits
227 } else {
228 for (uint16_t i = 0; i < 4; i++) {
229 st = (st << 1) | ((j >> (3-i)) & 0x01) ;
230 part_sum ^= filter(st);
231 }
232 }
233 sum += part_sum;
234 }
235 return sum;
236 }
237
238
239 // static uint16_t SumProperty(struct Crypto1State *s)
240 // {
241 // uint16_t sum_odd = PartialSumProperty(s->odd, ODD_STATE);
242 // uint16_t sum_even = PartialSumProperty(s->even, EVEN_STATE);
243 // return (sum_odd*(16-sum_even) + (16-sum_odd)*sum_even);
244 // }
245
246
247 static double p_hypergeometric(uint16_t N, uint16_t K, uint16_t n, uint16_t k)
248 {
249 // for efficient computation we are using the recursive definition
250 // (K-k+1) * (n-k+1)
251 // P(X=k) = P(X=k-1) * --------------------
252 // k * (N-K-n+k)
253 // and
254 // (N-K)*(N-K-1)*...*(N-K-n+1)
255 // P(X=0) = -----------------------------
256 // N*(N-1)*...*(N-n+1)
257
258 if (n-k > N-K || k > K) return 0.0; // avoids log(x<=0) in calculation below
259 if (k == 0) {
260 // use logarithms to avoid overflow with huge factorials (double type can only hold 170!)
261 double log_result = 0.0;
262 for (int16_t i = N-K; i >= N-K-n+1; i--) {
263 log_result += log(i);
264 }
265 for (int16_t i = N; i >= N-n+1; i--) {
266 log_result -= log(i);
267 }
268 return exp(log_result);
269 } else {
270 if (n-k == N-K) { // special case. The published recursion below would fail with a divide by zero exception
271 double log_result = 0.0;
272 for (int16_t i = k+1; i <= n; i++) {
273 log_result += log(i);
274 }
275 for (int16_t i = K+1; i <= N; i++) {
276 log_result -= log(i);
277 }
278 return exp(log_result);
279 } else { // recursion
280 return (p_hypergeometric(N, K, n, k-1) * (K-k+1) * (n-k+1) / (k * (N-K-n+k)));
281 }
282 }
283 }
284
285
286 static float sum_probability(uint16_t K, uint16_t n, uint16_t k)
287 {
288 const uint16_t N = 256;
289
290 if (k > K || p_K[K] == 0.0) return 0.0;
291
292 double p_T_is_k_when_S_is_K = p_hypergeometric(N, K, n, k);
293 double p_S_is_K = p_K[K];
294 double p_T_is_k = 0;
295 for (uint16_t i = 0; i <= 256; i++) {
296 if (p_K[i] != 0.0) {
297 p_T_is_k += p_K[i] * p_hypergeometric(N, i, n, k);
298 }
299 }
300 return(p_T_is_k_when_S_is_K * p_S_is_K / p_T_is_k);
301 }
302
303
304
305
306 static inline uint_fast8_t common_bits(uint_fast8_t bytes_diff)
307 {
308 static const uint_fast8_t common_bits_LUT[256] = {
309 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
310 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
311 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
312 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
313 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
314 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
315 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
316 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
317 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
318 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
319 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
320 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
321 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
322 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
323 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
324 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
325 };
326
327 return common_bits_LUT[bytes_diff];
328 }
329
330
331 static void Tests()
332 {
333 // printf("Tests: Partial Statelist sizes\n");
334 // for (uint16_t i = 0; i <= 16; i+=2) {
335 // printf("Partial State List Odd [%2d] has %8d entries\n", i, partial_statelist[i].len[ODD_STATE]);
336 // }
337 // for (uint16_t i = 0; i <= 16; i+=2) {
338 // printf("Partial State List Even [%2d] has %8d entries\n", i, partial_statelist[i].len[EVEN_STATE]);
339 // }
340
341 // #define NUM_STATISTICS 100000
342 // uint32_t statistics_odd[17];
343 // uint64_t statistics[257];
344 // uint32_t statistics_even[17];
345 // struct Crypto1State cs;
346 // time_t time1 = clock();
347
348 // for (uint16_t i = 0; i < 257; i++) {
349 // statistics[i] = 0;
350 // }
351 // for (uint16_t i = 0; i < 17; i++) {
352 // statistics_odd[i] = 0;
353 // statistics_even[i] = 0;
354 // }
355
356 // for (uint64_t i = 0; i < NUM_STATISTICS; i++) {
357 // cs.odd = (rand() & 0xfff) << 12 | (rand() & 0xfff);
358 // cs.even = (rand() & 0xfff) << 12 | (rand() & 0xfff);
359 // uint16_t sum_property = SumProperty(&cs);
360 // statistics[sum_property] += 1;
361 // sum_property = PartialSumProperty(cs.even, EVEN_STATE);
362 // statistics_even[sum_property]++;
363 // sum_property = PartialSumProperty(cs.odd, ODD_STATE);
364 // statistics_odd[sum_property]++;
365 // if (i%(NUM_STATISTICS/100) == 0) printf(".");
366 // }
367
368 // printf("\nTests: Calculated %d Sum properties in %0.3f seconds (%0.0f calcs/second)\n", NUM_STATISTICS, ((float)clock() - time1)/CLOCKS_PER_SEC, NUM_STATISTICS/((float)clock() - time1)*CLOCKS_PER_SEC);
369 // for (uint16_t i = 0; i < 257; i++) {
370 // if (statistics[i] != 0) {
371 // printf("probability[%3d] = %0.5f\n", i, (float)statistics[i]/NUM_STATISTICS);
372 // }
373 // }
374 // for (uint16_t i = 0; i <= 16; i++) {
375 // if (statistics_odd[i] != 0) {
376 // printf("probability odd [%2d] = %0.5f\n", i, (float)statistics_odd[i]/NUM_STATISTICS);
377 // }
378 // }
379 // for (uint16_t i = 0; i <= 16; i++) {
380 // if (statistics_odd[i] != 0) {
381 // printf("probability even [%2d] = %0.5f\n", i, (float)statistics_even[i]/NUM_STATISTICS);
382 // }
383 // }
384
385 // printf("Tests: Sum Probabilities based on Partial Sums\n");
386 // for (uint16_t i = 0; i < 257; i++) {
387 // statistics[i] = 0;
388 // }
389 // uint64_t num_states = 0;
390 // for (uint16_t oddsum = 0; oddsum <= 16; oddsum += 2) {
391 // for (uint16_t evensum = 0; evensum <= 16; evensum += 2) {
392 // uint16_t sum = oddsum*(16-evensum) + (16-oddsum)*evensum;
393 // statistics[sum] += (uint64_t)partial_statelist[oddsum].len[ODD_STATE] * partial_statelist[evensum].len[EVEN_STATE] * (1<<8);
394 // num_states += (uint64_t)partial_statelist[oddsum].len[ODD_STATE] * partial_statelist[evensum].len[EVEN_STATE] * (1<<8);
395 // }
396 // }
397 // printf("num_states = %lld, expected %lld\n", num_states, (1LL<<48));
398 // for (uint16_t i = 0; i < 257; i++) {
399 // if (statistics[i] != 0) {
400 // printf("probability[%3d] = %0.5f\n", i, (float)statistics[i]/num_states);
401 // }
402 // }
403
404 // printf("\nTests: Hypergeometric Probability for selected parameters\n");
405 // printf("p_hypergeometric(256, 206, 255, 206) = %0.8f\n", p_hypergeometric(256, 206, 255, 206));
406 // printf("p_hypergeometric(256, 206, 255, 205) = %0.8f\n", p_hypergeometric(256, 206, 255, 205));
407 // printf("p_hypergeometric(256, 156, 1, 1) = %0.8f\n", p_hypergeometric(256, 156, 1, 1));
408 // printf("p_hypergeometric(256, 156, 1, 0) = %0.8f\n", p_hypergeometric(256, 156, 1, 0));
409 // printf("p_hypergeometric(256, 1, 1, 1) = %0.8f\n", p_hypergeometric(256, 1, 1, 1));
410 // printf("p_hypergeometric(256, 1, 1, 0) = %0.8f\n", p_hypergeometric(256, 1, 1, 0));
411
412 // struct Crypto1State *pcs;
413 // pcs = crypto1_create(0xffffffffffff);
414 // printf("\nTests: for key = 0xffffffffffff:\nSum(a0) = %d\nodd_state = 0x%06x\neven_state = 0x%06x\n",
415 // SumProperty(pcs), pcs->odd & 0x00ffffff, pcs->even & 0x00ffffff);
416 // crypto1_byte(pcs, (cuid >> 24) ^ best_first_bytes[0], true);
417 // printf("After adding best first byte 0x%02x:\nSum(a8) = %d\nodd_state = 0x%06x\neven_state = 0x%06x\n",
418 // best_first_bytes[0],
419 // SumProperty(pcs),
420 // pcs->odd & 0x00ffffff, pcs->even & 0x00ffffff);
421 // //test_state_odd = pcs->odd & 0x00ffffff;
422 // //test_state_even = pcs->even & 0x00ffffff;
423 // crypto1_destroy(pcs);
424 // pcs = crypto1_create(0xa0a1a2a3a4a5);
425 // printf("Tests: for key = 0xa0a1a2a3a4a5:\nSum(a0) = %d\nodd_state = 0x%06x\neven_state = 0x%06x\n",
426 // SumProperty(pcs), pcs->odd & 0x00ffffff, pcs->even & 0x00ffffff);
427 // crypto1_byte(pcs, (cuid >> 24) ^ best_first_bytes[0], true);
428 // printf("After adding best first byte 0x%02x:\nSum(a8) = %d\nodd_state = 0x%06x\neven_state = 0x%06x\n",
429 // best_first_bytes[0],
430 // SumProperty(pcs),
431 // pcs->odd & 0x00ffffff, pcs->even & 0x00ffffff);
432 // //test_state_odd = pcs->odd & 0x00ffffff;
433 // //test_state_even = pcs->even & 0x00ffffff;
434 // crypto1_destroy(pcs);
435 // pcs = crypto1_create(0xa6b9aa97b955);
436 // printf("Tests: for key = 0xa6b9aa97b955:\nSum(a0) = %d\nodd_state = 0x%06x\neven_state = 0x%06x\n",
437 // SumProperty(pcs), pcs->odd & 0x00ffffff, pcs->even & 0x00ffffff);
438 // crypto1_byte(pcs, (cuid >> 24) ^ best_first_bytes[0], true);
439 // printf("After adding best first byte 0x%02x:\nSum(a8) = %d\nodd_state = 0x%06x\neven_state = 0x%06x\n",
440 // best_first_bytes[0],
441 // SumProperty(pcs),
442 // pcs->odd & 0x00ffffff, pcs->even & 0x00ffffff);
443 //test_state_odd = pcs->odd & 0x00ffffff;
444 //test_state_even = pcs->even & 0x00ffffff;
445 // crypto1_destroy(pcs);
446
447
448
449 // printf("\nTests: number of states with BitFlipProperty: %d, (= %1.3f%% of total states)\n", statelist_bitflip.len[0], 100.0 * statelist_bitflip.len[0] / (1<<20));
450
451 printf("\nTests: Actual BitFlipProperties odd/even:\n");
452 for (uint16_t i = 0; i < 256; i++) {
453 printf("[%02x]:%c ", i, nonces[i].BitFlip[ODD_STATE]?'o':nonces[i].BitFlip[EVEN_STATE]?'e':' ');
454 if (i % 8 == 7) {
455 printf("\n");
456 }
457 }
458
459 printf("\nTests: Sorted First Bytes:\n");
460 for (uint16_t i = 0; i < 256; i++) {
461 uint8_t best_byte = best_first_bytes[i];
462 printf("#%03d Byte: %02x, n = %3d, k = %3d, Sum(a8): %3d, Confidence: %5.1f%%, Bitflip: %c\n",
463 //printf("#%03d Byte: %02x, n = %3d, k = %3d, Sum(a8): %3d, Confidence: %5.1f%%, Bitflip: %c, score1: %1.5f, score2: %1.0f\n",
464 i, best_byte,
465 nonces[best_byte].num,
466 nonces[best_byte].Sum,
467 nonces[best_byte].Sum8_guess,
468 nonces[best_byte].Sum8_prob * 100,
469 nonces[best_byte].BitFlip[ODD_STATE]?'o':nonces[best_byte].BitFlip[EVEN_STATE]?'e':' '
470 //nonces[best_byte].score1,
471 //nonces[best_byte].score2
472 );
473 }
474
475 // printf("\nTests: parity performance\n");
476 // time_t time1p = clock();
477 // uint32_t par_sum = 0;
478 // for (uint32_t i = 0; i < 100000000; i++) {
479 // par_sum += parity(i);
480 // }
481 // printf("parsum oldparity = %d, time = %1.5fsec\n", par_sum, (float)(clock() - time1p)/CLOCKS_PER_SEC);
482
483 // time1p = clock();
484 // par_sum = 0;
485 // for (uint32_t i = 0; i < 100000000; i++) {
486 // par_sum += evenparity32(i);
487 // }
488 // printf("parsum newparity = %d, time = %1.5fsec\n", par_sum, (float)(clock() - time1p)/CLOCKS_PER_SEC);
489
490
491 }
492
493
494 static void sort_best_first_bytes(void)
495 {
496 // sort based on probability for correct guess
497 for (uint16_t i = 0; i < 256; i++ ) {
498 uint16_t j = 0;
499 float prob1 = nonces[i].Sum8_prob;
500 float prob2 = nonces[best_first_bytes[0]].Sum8_prob;
501 while (prob1 < prob2 && j < i) {
502 prob2 = nonces[best_first_bytes[++j]].Sum8_prob;
503 }
504 if (j < i) {
505 for (uint16_t k = i; k > j; k--) {
506 best_first_bytes[k] = best_first_bytes[k-1];
507 }
508 }
509 best_first_bytes[j] = i;
510 }
511
512 // determine how many are above the CONFIDENCE_THRESHOLD
513 uint16_t num_good_nonces = 0;
514 for (uint16_t i = 0; i < 256; i++) {
515 if (nonces[best_first_bytes[i]].Sum8_prob >= CONFIDENCE_THRESHOLD) {
516 ++num_good_nonces;
517 }
518 }
519
520 uint16_t best_first_byte = 0;
521
522 // select the best possible first byte based on number of common bits with all {b'}
523 // uint16_t max_common_bits = 0;
524 // for (uint16_t i = 0; i < num_good_nonces; i++) {
525 // uint16_t sum_common_bits = 0;
526 // for (uint16_t j = 0; j < num_good_nonces; j++) {
527 // if (i != j) {
528 // sum_common_bits += common_bits(best_first_bytes[i],best_first_bytes[j]);
529 // }
530 // }
531 // if (sum_common_bits > max_common_bits) {
532 // max_common_bits = sum_common_bits;
533 // best_first_byte = i;
534 // }
535 // }
536
537 // select best possible first byte {b} based on least likely sum/bitflip property
538 float min_p_K = 1.0;
539 for (uint16_t i = 0; i < num_good_nonces; i++ ) {
540 uint16_t sum8 = nonces[best_first_bytes[i]].Sum8_guess;
541 float bitflip_prob = 1.0;
542 if (nonces[best_first_bytes[i]].BitFlip[ODD_STATE] || nonces[best_first_bytes[i]].BitFlip[EVEN_STATE]) {
543 bitflip_prob = 0.09375;
544 }
545 nonces[best_first_bytes[i]].score1 = p_K[sum8] * bitflip_prob;
546 if (p_K[sum8] * bitflip_prob <= min_p_K) {
547 min_p_K = p_K[sum8] * bitflip_prob;
548 }
549 }
550
551
552 // use number of commmon bits as a tie breaker
553 uint16_t max_common_bits = 0;
554 for (uint16_t i = 0; i < num_good_nonces; i++) {
555 float bitflip_prob = 1.0;
556 if (nonces[best_first_bytes[i]].BitFlip[ODD_STATE] || nonces[best_first_bytes[i]].BitFlip[EVEN_STATE]) {
557 bitflip_prob = 0.09375;
558 }
559 if (p_K[nonces[best_first_bytes[i]].Sum8_guess] * bitflip_prob == min_p_K) {
560 uint16_t sum_common_bits = 0;
561 for (uint16_t j = 0; j < num_good_nonces; j++) {
562 sum_common_bits += common_bits(best_first_bytes[i] ^ best_first_bytes[j]);
563 }
564 nonces[best_first_bytes[i]].score2 = sum_common_bits;
565 if (sum_common_bits > max_common_bits) {
566 max_common_bits = sum_common_bits;
567 best_first_byte = i;
568 }
569 }
570 }
571
572 // swap best possible first byte to the pole position
573 uint16_t temp = best_first_bytes[0];
574 best_first_bytes[0] = best_first_bytes[best_first_byte];
575 best_first_bytes[best_first_byte] = temp;
576
577 }
578
579
580 static uint16_t estimate_second_byte_sum(void)
581 {
582
583 for (uint16_t first_byte = 0; first_byte < 256; first_byte++) {
584 float Sum8_prob = 0.0;
585 uint16_t Sum8 = 0;
586 if (nonces[first_byte].updated) {
587 for (uint16_t sum = 0; sum <= 256; sum++) {
588 float prob = sum_probability(sum, nonces[first_byte].num, nonces[first_byte].Sum);
589 if (prob > Sum8_prob) {
590 Sum8_prob = prob;
591 Sum8 = sum;
592 }
593 }
594 nonces[first_byte].Sum8_guess = Sum8;
595 nonces[first_byte].Sum8_prob = Sum8_prob;
596 nonces[first_byte].updated = false;
597 }
598 }
599
600 sort_best_first_bytes();
601
602 uint16_t num_good_nonces = 0;
603 for (uint16_t i = 0; i < 256; i++) {
604 if (nonces[best_first_bytes[i]].Sum8_prob >= CONFIDENCE_THRESHOLD) {
605 ++num_good_nonces;
606 }
607 }
608
609 return num_good_nonces;
610 }
611
612
613 static int read_nonce_file(void)
614 {
615 FILE *fnonces = NULL;
616 uint8_t trgBlockNo;
617 uint8_t trgKeyType;
618 uint8_t read_buf[9];
619 uint32_t nt_enc1, nt_enc2;
620 uint8_t par_enc;
621 int total_num_nonces = 0;
622
623 if ((fnonces = fopen("nonces.bin","rb")) == NULL) {
624 PrintAndLog("Could not open file nonces.bin");
625 return 1;
626 }
627
628 PrintAndLog("Reading nonces from file nonces.bin...");
629 if (fread(read_buf, 1, 6, fnonces) == 0) {
630 PrintAndLog("File reading error.");
631 fclose(fnonces);
632 return 1;
633 }
634 cuid = bytes_to_num(read_buf, 4);
635 trgBlockNo = bytes_to_num(read_buf+4, 1);
636 trgKeyType = bytes_to_num(read_buf+5, 1);
637
638 while (fread(read_buf, 1, 9, fnonces) == 9) {
639 nt_enc1 = bytes_to_num(read_buf, 4);
640 nt_enc2 = bytes_to_num(read_buf+4, 4);
641 par_enc = bytes_to_num(read_buf+8, 1);
642 //printf("Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc1, par_enc >> 4);
643 //printf("Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc2, par_enc & 0x0f);
644 add_nonce(nt_enc1, par_enc >> 4);
645 add_nonce(nt_enc2, par_enc & 0x0f);
646 total_num_nonces += 2;
647 }
648 fclose(fnonces);
649 PrintAndLog("Read %d nonces from file. cuid=%08x, Block=%d, Keytype=%c", total_num_nonces, cuid, trgBlockNo, trgKeyType==0?'A':'B');
650
651 return 0;
652 }
653
654
655 static void Check_for_FilterFlipProperties(void)
656 {
657 printf("Checking for Filter Flip Properties...\n");
658
659 uint16_t num_bitflips = 0;
660
661 for (uint16_t i = 0; i < 256; i++) {
662 nonces[i].BitFlip[ODD_STATE] = false;
663 nonces[i].BitFlip[EVEN_STATE] = false;
664 }
665
666 for (uint16_t i = 0; i < 256; i++) {
667 uint8_t parity1 = (nonces[i].first->par_enc) >> 3; // parity of first byte
668 uint8_t parity2_odd = (nonces[i^0x80].first->par_enc) >> 3; // XOR 0x80 = last bit flipped
669 uint8_t parity2_even = (nonces[i^0x40].first->par_enc) >> 3; // XOR 0x40 = second last bit flipped
670
671 if (parity1 == parity2_odd) { // has Bit Flip Property for odd bits
672 nonces[i].BitFlip[ODD_STATE] = true;
673 num_bitflips++;
674 } else if (parity1 == parity2_even) { // has Bit Flip Property for even bits
675 nonces[i].BitFlip[EVEN_STATE] = true;
676 num_bitflips++;
677 }
678 }
679
680 if (write_stats) {
681 fprintf(fstats, "%d;", num_bitflips);
682 }
683 }
684
685
686 static void simulate_MFplus_RNG(uint32_t test_cuid, uint64_t test_key, uint32_t *nt_enc, uint8_t *par_enc)
687 {
688 struct Crypto1State sim_cs;
689
690 // init cryptostate with key:
691 for(int8_t i = 47; i > 0; i -= 2) {
692 sim_cs.odd = sim_cs.odd << 1 | BIT(test_key, (i - 1) ^ 7);
693 sim_cs.even = sim_cs.even << 1 | BIT(test_key, i ^ 7);
694 }
695
696 *par_enc = 0;
697 uint32_t nt = (rand() & 0xff) << 24 | (rand() & 0xff) << 16 | (rand() & 0xff) << 8 | (rand() & 0xff);
698 for (int8_t byte_pos = 3; byte_pos >= 0; byte_pos--) {
699 uint8_t nt_byte_dec = (nt >> (8*byte_pos)) & 0xff;
700 uint8_t nt_byte_enc = crypto1_byte(&sim_cs, nt_byte_dec ^ (test_cuid >> (8*byte_pos)), false) ^ nt_byte_dec; // encode the nonce byte
701 *nt_enc = (*nt_enc << 8) | nt_byte_enc;
702 uint8_t ks_par = filter(sim_cs.odd); // the keystream bit to encode/decode the parity bit
703 uint8_t nt_byte_par_enc = ks_par ^ oddparity8(nt_byte_dec); // determine the nt byte's parity and encode it
704 *par_enc = (*par_enc << 1) | nt_byte_par_enc;
705 }
706
707 }
708
709
710 static void simulate_acquire_nonces()
711 {
712 clock_t time1 = clock();
713 bool filter_flip_checked = false;
714 uint32_t total_num_nonces = 0;
715 uint32_t next_fivehundred = 500;
716 uint32_t total_added_nonces = 0;
717
718 cuid = (rand() & 0xff) << 24 | (rand() & 0xff) << 16 | (rand() & 0xff) << 8 | (rand() & 0xff);
719 known_target_key = ((uint64_t)rand() & 0xfff) << 36 | ((uint64_t)rand() & 0xfff) << 24 | ((uint64_t)rand() & 0xfff) << 12 | ((uint64_t)rand() & 0xfff);
720
721 printf("Simulating nonce acquisition for target key %012"llx", cuid %08x ...\n", known_target_key, cuid);
722 fprintf(fstats, "%012"llx";%08x;", known_target_key, cuid);
723
724 do {
725 uint32_t nt_enc = 0;
726 uint8_t par_enc = 0;
727
728 simulate_MFplus_RNG(cuid, known_target_key, &nt_enc, &par_enc);
729 //printf("Simulated RNG: nt_enc1: %08x, nt_enc2: %08x, par_enc: %02x\n", nt_enc1, nt_enc2, par_enc);
730 total_added_nonces += add_nonce(nt_enc, par_enc);
731 total_num_nonces++;
732
733 if (first_byte_num == 256 ) {
734 // printf("first_byte_num = %d, first_byte_Sum = %d\n", first_byte_num, first_byte_Sum);
735 if (!filter_flip_checked) {
736 Check_for_FilterFlipProperties();
737 filter_flip_checked = true;
738 }
739 num_good_first_bytes = estimate_second_byte_sum();
740 if (total_num_nonces > next_fivehundred) {
741 next_fivehundred = (total_num_nonces/500+1) * 500;
742 printf("Acquired %5d nonces (%5d with distinct bytes 0 and 1). Number of bytes with probability for correctly guessed Sum(a8) > %1.1f%%: %d\n",
743 total_num_nonces,
744 total_added_nonces,
745 CONFIDENCE_THRESHOLD * 100.0,
746 num_good_first_bytes);
747 }
748 }
749
750 } while (num_good_first_bytes < GOOD_BYTES_REQUIRED);
751
752 PrintAndLog("Acquired a total of %d nonces in %1.1f seconds (%0.0f nonces/minute)",
753 total_num_nonces,
754 ((float)clock()-time1)/CLOCKS_PER_SEC,
755 total_num_nonces*60.0*CLOCKS_PER_SEC/((float)clock()-time1));
756
757 fprintf(fstats, "%d;%d;%d;%1.2f;", total_num_nonces, total_added_nonces, num_good_first_bytes, CONFIDENCE_THRESHOLD);
758
759 }
760
761
762 static int acquire_nonces(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, bool nonce_file_write, bool slow)
763 {
764 clock_t time1 = clock();
765 bool initialize = true;
766 bool field_off = false;
767 bool finished = false;
768 bool filter_flip_checked = false;
769 uint32_t flags = 0;
770 uint8_t write_buf[9];
771 uint32_t total_num_nonces = 0;
772 uint32_t next_fivehundred = 500;
773 uint32_t total_added_nonces = 0;
774 FILE *fnonces = NULL;
775 UsbCommand resp;
776
777 printf("Acquiring nonces...\n");
778
779 clearCommandBuffer();
780
781 do {
782 flags = 0;
783 flags |= initialize ? 0x0001 : 0;
784 flags |= slow ? 0x0002 : 0;
785 flags |= field_off ? 0x0004 : 0;
786 UsbCommand c = {CMD_MIFARE_ACQUIRE_ENCRYPTED_NONCES, {blockNo + keyType * 0x100, trgBlockNo + trgKeyType * 0x100, flags}};
787 memcpy(c.d.asBytes, key, 6);
788
789 SendCommand(&c);
790
791 if (field_off) finished = true;
792
793 if (initialize) {
794 if (!WaitForResponseTimeout(CMD_ACK, &resp, 3000)) return 1;
795 if (resp.arg[0]) return resp.arg[0]; // error during nested_hard
796
797 cuid = resp.arg[1];
798 // PrintAndLog("Acquiring nonces for CUID 0x%08x", cuid);
799 if (nonce_file_write && fnonces == NULL) {
800 if ((fnonces = fopen("nonces.bin","wb")) == NULL) {
801 PrintAndLog("Could not create file nonces.bin");
802 return 3;
803 }
804 PrintAndLog("Writing acquired nonces to binary file nonces.bin");
805 num_to_bytes(cuid, 4, write_buf);
806 fwrite(write_buf, 1, 4, fnonces);
807 fwrite(&trgBlockNo, 1, 1, fnonces);
808 fwrite(&trgKeyType, 1, 1, fnonces);
809 }
810 }
811
812 if (!initialize) {
813 uint32_t nt_enc1, nt_enc2;
814 uint8_t par_enc;
815 uint16_t num_acquired_nonces = resp.arg[2];
816 uint8_t *bufp = resp.d.asBytes;
817 for (uint16_t i = 0; i < num_acquired_nonces; i+=2) {
818 nt_enc1 = bytes_to_num(bufp, 4);
819 nt_enc2 = bytes_to_num(bufp+4, 4);
820 par_enc = bytes_to_num(bufp+8, 1);
821
822 //printf("Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc1, par_enc >> 4);
823 total_added_nonces += add_nonce(nt_enc1, par_enc >> 4);
824 //printf("Encrypted nonce: %08x, encrypted_parity: %02x\n", nt_enc2, par_enc & 0x0f);
825 total_added_nonces += add_nonce(nt_enc2, par_enc & 0x0f);
826
827
828 if (nonce_file_write) {
829 fwrite(bufp, 1, 9, fnonces);
830 }
831
832 bufp += 9;
833 }
834
835 total_num_nonces += num_acquired_nonces;
836 }
837
838 if (first_byte_num == 256 ) {
839 // printf("first_byte_num = %d, first_byte_Sum = %d\n", first_byte_num, first_byte_Sum);
840 if (!filter_flip_checked) {
841 Check_for_FilterFlipProperties();
842 filter_flip_checked = true;
843 }
844 num_good_first_bytes = estimate_second_byte_sum();
845 if (total_num_nonces > next_fivehundred) {
846 next_fivehundred = (total_num_nonces/500+1) * 500;
847 printf("Acquired %5d nonces (%5d with distinct bytes 0 and 1). Number of bytes with probability for correctly guessed Sum(a8) > %1.1f%%: %d\n",
848 total_num_nonces,
849 total_added_nonces,
850 CONFIDENCE_THRESHOLD * 100.0,
851 num_good_first_bytes);
852 }
853 if (num_good_first_bytes >= GOOD_BYTES_REQUIRED) {
854 field_off = true; // switch off field with next SendCommand and then finish
855 }
856 }
857
858 if (!initialize) {
859 if (!WaitForResponseTimeout(CMD_ACK, &resp, 3000)) return 1;
860 if (resp.arg[0]) return resp.arg[0]; // error during nested_hard
861 }
862
863 initialize = false;
864
865 } while (!finished);
866
867
868 if (nonce_file_write) {
869 fclose(fnonces);
870 }
871
872 PrintAndLog("Acquired a total of %d nonces in %1.1f seconds (%0.0f nonces/minute)",
873 total_num_nonces,
874 ((float)clock()-time1)/CLOCKS_PER_SEC,
875 total_num_nonces*60.0*CLOCKS_PER_SEC/((float)clock()-time1));
876
877 return 0;
878 }
879
880
881 static int init_partial_statelists(void)
882 {
883 const uint32_t sizes_odd[17] = { 126757, 0, 18387, 0, 74241, 0, 181737, 0, 248801, 0, 182033, 0, 73421, 0, 17607, 0, 125601 };
884 const uint32_t sizes_even[17] = { 125723, 0, 17867, 0, 74305, 0, 178707, 0, 248801, 0, 185063, 0, 73356, 0, 18127, 0, 126634 };
885
886 printf("Allocating memory for partial statelists...\n");
887 for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
888 for (uint16_t i = 0; i <= 16; i+=2) {
889 partial_statelist[i].len[odd_even] = 0;
890 uint32_t num_of_states = odd_even == ODD_STATE ? sizes_odd[i] : sizes_even[i];
891 partial_statelist[i].states[odd_even] = malloc(sizeof(uint32_t) * num_of_states);
892 if (partial_statelist[i].states[odd_even] == NULL) {
893 PrintAndLog("Cannot allocate enough memory. Aborting");
894 return 4;
895 }
896 for (uint32_t j = 0; j < STATELIST_INDEX_SIZE; j++) {
897 partial_statelist[i].index[odd_even][j] = NULL;
898 }
899 }
900 }
901
902 printf("Generating partial statelists...\n");
903 for (odd_even_t odd_even = EVEN_STATE; odd_even <= ODD_STATE; odd_even++) {
904 uint32_t index = -1;
905 uint32_t num_of_states = 1<<20;
906 for (uint32_t state = 0; state < num_of_states; state++) {
907 uint16_t sum_property = PartialSumProperty(state, odd_even);
908 uint32_t *p = partial_statelist[sum_property].states[odd_even];
909 p += partial_statelist[sum_property].len[odd_even];
910 *p = state;
911 partial_statelist[sum_property].len[odd_even]++;
912 uint32_t index_mask = (STATELIST_INDEX_SIZE-1) << (20-STATELIST_INDEX_WIDTH);
913 if ((state & index_mask) != index) {
914 index = state & index_mask;
915 }
916 if (partial_statelist[sum_property].index[odd_even][index >> (20-STATELIST_INDEX_WIDTH)] == NULL) {
917 partial_statelist[sum_property].index[odd_even][index >> (20-STATELIST_INDEX_WIDTH)] = p;
918 }
919 }
920 // add End Of List markers
921 for (uint16_t i = 0; i <= 16; i += 2) {
922 uint32_t *p = partial_statelist[i].states[odd_even];
923 p += partial_statelist[i].len[odd_even];
924 *p = 0xffffffff;
925 }
926 }
927
928 return 0;
929 }
930
931
932 static void init_BitFlip_statelist(void)
933 {
934 printf("Generating bitflip statelist...\n");
935 uint32_t *p = statelist_bitflip.states[0] = malloc(sizeof(uint32_t) * 1<<20);
936 uint32_t index = -1;
937 uint32_t index_mask = (STATELIST_INDEX_SIZE-1) << (20-STATELIST_INDEX_WIDTH);
938 for (uint32_t state = 0; state < (1 << 20); state++) {
939 if (filter(state) != filter(state^1)) {
940 if ((state & index_mask) != index) {
941 index = state & index_mask;
942 }
943 if (statelist_bitflip.index[0][index >> (20-STATELIST_INDEX_WIDTH)] == NULL) {
944 statelist_bitflip.index[0][index >> (20-STATELIST_INDEX_WIDTH)] = p;
945 }
946 *p++ = state;
947 }
948 }
949 // set len and add End Of List marker
950 statelist_bitflip.len[0] = p - statelist_bitflip.states[0];
951 *p = 0xffffffff;
952 statelist_bitflip.states[0] = realloc(statelist_bitflip.states[0], sizeof(uint32_t) * (statelist_bitflip.len[0] + 1));
953 }
954
955
956 static inline uint32_t *find_first_state(uint32_t state, uint32_t mask, partial_indexed_statelist_t *sl, odd_even_t odd_even)
957 {
958 uint32_t *p = sl->index[odd_even][(state & mask) >> (20-STATELIST_INDEX_WIDTH)]; // first Bits as index
959
960 if (p == NULL) return NULL;
961 while (*p < (state & mask)) p++;
962 if (*p == 0xffffffff) return NULL; // reached end of list, no match
963 if ((*p & mask) == (state & mask)) return p; // found a match.
964 return NULL; // no match
965 }
966
967
968 static inline bool /*__attribute__((always_inline))*/ invariant_holds(uint_fast8_t byte_diff, uint_fast32_t state1, uint_fast32_t state2, uint_fast8_t bit, uint_fast8_t state_bit)
969 {
970 uint_fast8_t j_1_bit_mask = 0x01 << (bit-1);
971 uint_fast8_t bit_diff = byte_diff & j_1_bit_mask; // difference of (j-1)th bit
972 uint_fast8_t filter_diff = filter(state1 >> (4-state_bit)) ^ filter(state2 >> (4-state_bit)); // difference in filter function
973 uint_fast8_t mask_y12_y13 = 0xc0 >> state_bit;
974 uint_fast8_t state_bits_diff = (state1 ^ state2) & mask_y12_y13; // difference in state bits 12 and 13
975 uint_fast8_t all_diff = evenparity8(bit_diff ^ state_bits_diff ^ filter_diff); // use parity function to XOR all bits
976 return !all_diff;
977 }
978
979
980 static inline bool /*__attribute__((always_inline))*/ invalid_state(uint_fast8_t byte_diff, uint_fast32_t state1, uint_fast32_t state2, uint_fast8_t bit, uint_fast8_t state_bit)
981 {
982 uint_fast8_t j_bit_mask = 0x01 << bit;
983 uint_fast8_t bit_diff = byte_diff & j_bit_mask; // difference of jth bit
984 uint_fast8_t mask_y13_y16 = 0x48 >> state_bit;
985 uint_fast8_t state_bits_diff = (state1 ^ state2) & mask_y13_y16; // difference in state bits 13 and 16
986 uint_fast8_t all_diff = evenparity8(bit_diff ^ state_bits_diff); // use parity function to XOR all bits
987 return all_diff;
988 }
989
990
991 static inline bool remaining_bits_match(uint_fast8_t num_common_bits, uint_fast8_t byte_diff, uint_fast32_t state1, uint_fast32_t state2, odd_even_t odd_even)
992 {
993 if (odd_even) {
994 // odd bits
995 switch (num_common_bits) {
996 case 0: if (!invariant_holds(byte_diff, state1, state2, 1, 0)) return true;
997 case 1: if (invalid_state(byte_diff, state1, state2, 1, 0)) return false;
998 case 2: if (!invariant_holds(byte_diff, state1, state2, 3, 1)) return true;
999 case 3: if (invalid_state(byte_diff, state1, state2, 3, 1)) return false;
1000 case 4: if (!invariant_holds(byte_diff, state1, state2, 5, 2)) return true;
1001 case 5: if (invalid_state(byte_diff, state1, state2, 5, 2)) return false;
1002 case 6: if (!invariant_holds(byte_diff, state1, state2, 7, 3)) return true;
1003 case 7: if (invalid_state(byte_diff, state1, state2, 7, 3)) return false;
1004 }
1005 } else {
1006 // even bits
1007 switch (num_common_bits) {
1008 case 0: if (invalid_state(byte_diff, state1, state2, 0, 0)) return false;
1009 case 1: if (!invariant_holds(byte_diff, state1, state2, 2, 1)) return true;
1010 case 2: if (invalid_state(byte_diff, state1, state2, 2, 1)) return false;
1011 case 3: if (!invariant_holds(byte_diff, state1, state2, 4, 2)) return true;
1012 case 4: if (invalid_state(byte_diff, state1, state2, 4, 2)) return false;
1013 case 5: if (!invariant_holds(byte_diff, state1, state2, 6, 3)) return true;
1014 case 6: if (invalid_state(byte_diff, state1, state2, 6, 3)) return false;
1015 }
1016 }
1017
1018 return true; // valid state
1019 }
1020
1021
1022 static bool all_other_first_bytes_match(uint32_t state, odd_even_t odd_even)
1023 {
1024 for (uint16_t i = 1; i < num_good_first_bytes; i++) {
1025 uint16_t sum_a8 = nonces[best_first_bytes[i]].Sum8_guess;
1026 uint_fast8_t bytes_diff = best_first_bytes[0] ^ best_first_bytes[i];
1027 uint_fast8_t j = common_bits(bytes_diff);
1028 uint32_t mask = 0xfffffff0;
1029 if (odd_even == ODD_STATE) {
1030 mask >>= j/2;
1031 } else {
1032 mask >>= (j+1)/2;
1033 }
1034 mask &= 0x000fffff;
1035 //printf("bytes 0x%02x and 0x%02x: %d common bits, mask = 0x%08x, state = 0x%08x, sum_a8 = %d", best_first_bytes[0], best_first_bytes[i], j, mask, state, sum_a8);
1036 bool found_match = false;
1037 for (uint16_t r = 0; r <= 16 && !found_match; r += 2) {
1038 for (uint16_t s = 0; s <= 16 && !found_match; s += 2) {
1039 if (r*(16-s) + (16-r)*s == sum_a8) {
1040 //printf("Checking byte 0x%02x for partial sum (%s) %d\n", best_first_bytes[i], odd_even==ODD_STATE?"odd":"even", odd_even==ODD_STATE?r:s);
1041 uint16_t part_sum_a8 = (odd_even == ODD_STATE) ? r : s;
1042 uint32_t *p = find_first_state(state, mask, &partial_statelist[part_sum_a8], odd_even);
1043 if (p != NULL) {
1044 while ((state & mask) == (*p & mask) && (*p != 0xffffffff)) {
1045 if (remaining_bits_match(j, bytes_diff, state, (state&0x00fffff0) | *p, odd_even)) {
1046 found_match = true;
1047 // if ((odd_even == ODD_STATE && state == test_state_odd)
1048 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1049 // printf("all_other_first_bytes_match(): %s test state: remaining bits matched. Bytes = %02x, %02x, Common Bits=%d, mask=0x%08x, PartSum(a8)=%d\n",
1050 // odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j, mask, part_sum_a8);
1051 // }
1052 break;
1053 } else {
1054 // if ((odd_even == ODD_STATE && state == test_state_odd)
1055 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1056 // printf("all_other_first_bytes_match(): %s test state: remaining bits didn't match. Bytes = %02x, %02x, Common Bits=%d, mask=0x%08x, PartSum(a8)=%d\n",
1057 // odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j, mask, part_sum_a8);
1058 // }
1059 }
1060 p++;
1061 }
1062 } else {
1063 // if ((odd_even == ODD_STATE && state == test_state_odd)
1064 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1065 // printf("all_other_first_bytes_match(): %s test state: couldn't find a matching state. Bytes = %02x, %02x, Common Bits=%d, mask=0x%08x, PartSum(a8)=%d\n",
1066 // odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j, mask, part_sum_a8);
1067 // }
1068 }
1069 }
1070 }
1071 }
1072
1073 if (!found_match) {
1074 // if ((odd_even == ODD_STATE && state == test_state_odd)
1075 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1076 // printf("all_other_first_bytes_match(): %s test state: Eliminated. Bytes = %02x, %02x, Common Bits = %d\n", odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j);
1077 // }
1078 return false;
1079 }
1080 }
1081
1082 return true;
1083 }
1084
1085
1086 static bool all_bit_flips_match(uint32_t state, odd_even_t odd_even)
1087 {
1088 for (uint16_t i = 0; i < 256; i++) {
1089 if (nonces[i].BitFlip[odd_even] && i != best_first_bytes[0]) {
1090 uint_fast8_t bytes_diff = best_first_bytes[0] ^ i;
1091 uint_fast8_t j = common_bits(bytes_diff);
1092 uint32_t mask = 0xfffffff0;
1093 if (odd_even == ODD_STATE) {
1094 mask >>= j/2;
1095 } else {
1096 mask >>= (j+1)/2;
1097 }
1098 mask &= 0x000fffff;
1099 //printf("bytes 0x%02x and 0x%02x: %d common bits, mask = 0x%08x, state = 0x%08x, sum_a8 = %d", best_first_bytes[0], best_first_bytes[i], j, mask, state, sum_a8);
1100 bool found_match = false;
1101 uint32_t *p = find_first_state(state, mask, &statelist_bitflip, 0);
1102 if (p != NULL) {
1103 while ((state & mask) == (*p & mask) && (*p != 0xffffffff)) {
1104 if (remaining_bits_match(j, bytes_diff, state, (state&0x00fffff0) | *p, odd_even)) {
1105 found_match = true;
1106 // if ((odd_even == ODD_STATE && state == test_state_odd)
1107 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1108 // printf("all_other_first_bytes_match(): %s test state: remaining bits matched. Bytes = %02x, %02x, Common Bits=%d, mask=0x%08x, PartSum(a8)=%d\n",
1109 // odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j, mask, part_sum_a8);
1110 // }
1111 break;
1112 } else {
1113 // if ((odd_even == ODD_STATE && state == test_state_odd)
1114 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1115 // printf("all_other_first_bytes_match(): %s test state: remaining bits didn't match. Bytes = %02x, %02x, Common Bits=%d, mask=0x%08x, PartSum(a8)=%d\n",
1116 // odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j, mask, part_sum_a8);
1117 // }
1118 }
1119 p++;
1120 }
1121 } else {
1122 // if ((odd_even == ODD_STATE && state == test_state_odd)
1123 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1124 // printf("all_other_first_bytes_match(): %s test state: couldn't find a matching state. Bytes = %02x, %02x, Common Bits=%d, mask=0x%08x, PartSum(a8)=%d\n",
1125 // odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j, mask, part_sum_a8);
1126 // }
1127 }
1128 if (!found_match) {
1129 // if ((odd_even == ODD_STATE && state == test_state_odd)
1130 // || (odd_even == EVEN_STATE && state == test_state_even)) {
1131 // printf("all_other_first_bytes_match(): %s test state: Eliminated. Bytes = %02x, %02x, Common Bits = %d\n", odd_even==ODD_STATE?"odd":"even", best_first_bytes[0], best_first_bytes[i], j);
1132 // }
1133 return false;
1134 }
1135 }
1136
1137 }
1138
1139 return true;
1140 }
1141
1142
1143 static struct sl_cache_entry {
1144 uint32_t *sl;
1145 uint32_t len;
1146 } sl_cache[17][17][2];
1147
1148
1149 static void init_statelist_cache(void)
1150 {
1151 for (uint16_t i = 0; i < 17; i+=2) {
1152 for (uint16_t j = 0; j < 17; j+=2) {
1153 for (uint16_t k = 0; k < 2; k++) {
1154 sl_cache[i][j][k].sl = NULL;
1155 sl_cache[i][j][k].len = 0;
1156 }
1157 }
1158 }
1159 }
1160
1161
1162 static int add_matching_states(statelist_t *candidates, uint16_t part_sum_a0, uint16_t part_sum_a8, odd_even_t odd_even)
1163 {
1164 uint32_t worstcase_size = 1<<20;
1165
1166 // check cache for existing results
1167 if (sl_cache[part_sum_a0][part_sum_a8][odd_even].sl != NULL) {
1168 candidates->states[odd_even] = sl_cache[part_sum_a0][part_sum_a8][odd_even].sl;
1169 candidates->len[odd_even] = sl_cache[part_sum_a0][part_sum_a8][odd_even].len;
1170 return 0;
1171 }
1172
1173 candidates->states[odd_even] = (uint32_t *)malloc(sizeof(uint32_t) * worstcase_size);
1174 if (candidates->states[odd_even] == NULL) {
1175 PrintAndLog("Out of memory error.\n");
1176 return 4;
1177 }
1178 uint32_t *add_p = candidates->states[odd_even];
1179 for (uint32_t *p1 = partial_statelist[part_sum_a0].states[odd_even]; *p1 != 0xffffffff; p1++) {
1180 uint32_t search_mask = 0x000ffff0;
1181 uint32_t *p2 = find_first_state((*p1 << 4), search_mask, &partial_statelist[part_sum_a8], odd_even);
1182 if (p2 != NULL) {
1183 while (((*p1 << 4) & search_mask) == (*p2 & search_mask) && *p2 != 0xffffffff) {
1184 if ((nonces[best_first_bytes[0]].BitFlip[odd_even] && find_first_state((*p1 << 4) | *p2, 0x000fffff, &statelist_bitflip, 0))
1185 || !nonces[best_first_bytes[0]].BitFlip[odd_even]) {
1186 if (all_other_first_bytes_match((*p1 << 4) | *p2, odd_even)) {
1187 if (all_bit_flips_match((*p1 << 4) | *p2, odd_even)) {
1188 *add_p++ = (*p1 << 4) | *p2;
1189 }
1190 }
1191 }
1192 p2++;
1193 }
1194 }
1195 }
1196
1197 // set end of list marker and len
1198 *add_p = 0xffffffff;
1199 candidates->len[odd_even] = add_p - candidates->states[odd_even];
1200
1201 candidates->states[odd_even] = realloc(candidates->states[odd_even], sizeof(uint32_t) * (candidates->len[odd_even] + 1));
1202
1203 sl_cache[part_sum_a0][part_sum_a8][odd_even].sl = candidates->states[odd_even];
1204 sl_cache[part_sum_a0][part_sum_a8][odd_even].len = candidates->len[odd_even];
1205
1206 return 0;
1207 }
1208
1209
1210 static statelist_t *add_more_candidates(statelist_t *current_candidates)
1211 {
1212 statelist_t *new_candidates = NULL;
1213 if (current_candidates == NULL) {
1214 if (candidates == NULL) {
1215 candidates = (statelist_t *)malloc(sizeof(statelist_t));
1216 }
1217 new_candidates = candidates;
1218 } else {
1219 new_candidates = current_candidates->next = (statelist_t *)malloc(sizeof(statelist_t));
1220 }
1221 new_candidates->next = NULL;
1222 new_candidates->len[ODD_STATE] = 0;
1223 new_candidates->len[EVEN_STATE] = 0;
1224 new_candidates->states[ODD_STATE] = NULL;
1225 new_candidates->states[EVEN_STATE] = NULL;
1226 return new_candidates;
1227 }
1228
1229
1230 static void TestIfKeyExists(uint64_t key)
1231 {
1232 struct Crypto1State *pcs;
1233 pcs = crypto1_create(key);
1234 crypto1_byte(pcs, (cuid >> 24) ^ best_first_bytes[0], true);
1235
1236 uint32_t state_odd = pcs->odd & 0x00ffffff;
1237 uint32_t state_even = pcs->even & 0x00ffffff;
1238 //printf("Tests: searching for key %llx after first byte 0x%02x (state_odd = 0x%06x, state_even = 0x%06x) ...\n", key, best_first_bytes[0], state_odd, state_even);
1239
1240 uint64_t count = 0;
1241 for (statelist_t *p = candidates; p != NULL; p = p->next) {
1242 bool found_odd = false;
1243 bool found_even = false;
1244 uint32_t *p_odd = p->states[ODD_STATE];
1245 uint32_t *p_even = p->states[EVEN_STATE];
1246 while (*p_odd != 0xffffffff) {
1247 if ((*p_odd & 0x00ffffff) == state_odd) {
1248 found_odd = true;
1249 break;
1250 }
1251 p_odd++;
1252 }
1253 while (*p_even != 0xffffffff) {
1254 if ((*p_even & 0x00ffffff) == state_even) {
1255 found_even = true;
1256 }
1257 p_even++;
1258 }
1259 count += (p_odd - p->states[ODD_STATE]) * (p_even - p->states[EVEN_STATE]);
1260 if (found_odd && found_even) {
1261 PrintAndLog("Key Found after testing %lld (2^%1.1f) out of %lld (2^%1.1f) keys. A brute force would have taken approx %lld minutes.",
1262 count, log(count)/log(2),
1263 maximum_states, log(maximum_states)/log(2),
1264 (count>>23)/60);
1265 if (write_stats) {
1266 fprintf(fstats, "1\n");
1267 }
1268 crypto1_destroy(pcs);
1269 return;
1270 }
1271 }
1272
1273 printf("Key NOT found!\n");
1274 if (write_stats) {
1275 fprintf(fstats, "0\n");
1276 }
1277 crypto1_destroy(pcs);
1278 }
1279
1280
1281 static void generate_candidates(uint16_t sum_a0, uint16_t sum_a8)
1282 {
1283 printf("Generating crypto1 state candidates... \n");
1284
1285 statelist_t *current_candidates = NULL;
1286 // estimate maximum candidate states
1287 maximum_states = 0;
1288 for (uint16_t sum_odd = 0; sum_odd <= 16; sum_odd += 2) {
1289 for (uint16_t sum_even = 0; sum_even <= 16; sum_even += 2) {
1290 if (sum_odd*(16-sum_even) + (16-sum_odd)*sum_even == sum_a0) {
1291 maximum_states += (uint64_t)partial_statelist[sum_odd].len[ODD_STATE] * partial_statelist[sum_even].len[EVEN_STATE] * (1<<8);
1292 }
1293 }
1294 }
1295 printf("Number of possible keys with Sum(a0) = %d: %ll (2^%1.1f)\n", sum_a0, maximum_states, log(maximum_states)/log(2.0));
1296
1297 init_statelist_cache();
1298
1299 for (uint16_t p = 0; p <= 16; p += 2) {
1300 for (uint16_t q = 0; q <= 16; q += 2) {
1301 if (p*(16-q) + (16-p)*q == sum_a0) {
1302 printf("Reducing Partial Statelists (p,q) = (%d,%d) with lengths %d, %d\n",
1303 p, q, partial_statelist[p].len[ODD_STATE], partial_statelist[q].len[EVEN_STATE]);
1304 for (uint16_t r = 0; r <= 16; r += 2) {
1305 for (uint16_t s = 0; s <= 16; s += 2) {
1306 if (r*(16-s) + (16-r)*s == sum_a8) {
1307 current_candidates = add_more_candidates(current_candidates);
1308 // check for the smallest partial statelist. Try this first - it might give 0 candidates
1309 // and eliminate the need to calculate the other part
1310 if (MIN(partial_statelist[p].len[ODD_STATE], partial_statelist[r].len[ODD_STATE])
1311 < MIN(partial_statelist[q].len[EVEN_STATE], partial_statelist[s].len[EVEN_STATE])) {
1312 add_matching_states(current_candidates, p, r, ODD_STATE);
1313 if(current_candidates->len[ODD_STATE]) {
1314 add_matching_states(current_candidates, q, s, EVEN_STATE);
1315 } else {
1316 current_candidates->len[EVEN_STATE] = 0;
1317 uint32_t *p = current_candidates->states[EVEN_STATE] = malloc(sizeof(uint32_t));
1318 *p = 0xffffffff;
1319 }
1320 } else {
1321 add_matching_states(current_candidates, q, s, EVEN_STATE);
1322 if(current_candidates->len[EVEN_STATE]) {
1323 add_matching_states(current_candidates, p, r, ODD_STATE);
1324 } else {
1325 current_candidates->len[ODD_STATE] = 0;
1326 uint32_t *p = current_candidates->states[ODD_STATE] = malloc(sizeof(uint32_t));
1327 *p = 0xffffffff;
1328 }
1329 }
1330 printf("Odd state candidates: %6d (2^%0.1f)\n", current_candidates->len[ODD_STATE], log(current_candidates->len[ODD_STATE])/log(2));
1331 printf("Even state candidates: %6d (2^%0.1f)\n", current_candidates->len[EVEN_STATE], log(current_candidates->len[EVEN_STATE])/log(2));
1332 }
1333 }
1334 }
1335 }
1336 }
1337 }
1338
1339
1340 maximum_states = 0;
1341 for (statelist_t *sl = candidates; sl != NULL; sl = sl->next) {
1342 maximum_states += (uint64_t)sl->len[ODD_STATE] * sl->len[EVEN_STATE];
1343 }
1344 printf("Number of remaining possible keys: %ll (2^%1.1f)\n", maximum_states, log(maximum_states)/log(2.0));
1345 if (write_stats) {
1346 if (maximum_states != 0) {
1347 fprintf(fstats, "%1.1f;", log(maximum_states)/log(2.0));
1348 } else {
1349 fprintf(fstats, "%1.1f;", 0.0);
1350 }
1351 }
1352 }
1353
1354
1355 static void free_candidates_memory(statelist_t *sl)
1356 {
1357 if (sl == NULL) {
1358 return;
1359 } else {
1360 free_candidates_memory(sl->next);
1361 free(sl);
1362 }
1363 }
1364
1365
1366 static void free_statelist_cache(void)
1367 {
1368 for (uint16_t i = 0; i < 17; i+=2) {
1369 for (uint16_t j = 0; j < 17; j+=2) {
1370 for (uint16_t k = 0; k < 2; k++) {
1371 free(sl_cache[i][j][k].sl);
1372 }
1373 }
1374 }
1375 }
1376
1377
1378 static void brute_force(void)
1379 {
1380 if (known_target_key != -1) {
1381 PrintAndLog("Looking for known target key in remaining key space...");
1382 TestIfKeyExists(known_target_key);
1383 } else {
1384 PrintAndLog("Brute Force phase is not implemented.");
1385 }
1386
1387 }
1388
1389
1390 int mfnestedhard(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t *trgkey, bool nonce_file_read, bool nonce_file_write, bool slow, int tests)
1391 {
1392 // initialize Random number generator
1393 time_t t;
1394 srand((unsigned) time(&t));
1395
1396 if (trgkey != NULL) {
1397 known_target_key = bytes_to_num(trgkey, 6);
1398 } else {
1399 known_target_key = -1;
1400 }
1401
1402 init_partial_statelists();
1403 init_BitFlip_statelist();
1404 write_stats = false;
1405
1406 if (tests) {
1407 // set the correct locale for the stats printing
1408 setlocale(LC_ALL, "");
1409 write_stats = true;
1410 if ((fstats = fopen("hardnested_stats.txt","a")) == NULL) {
1411 PrintAndLog("Could not create/open file hardnested_stats.txt");
1412 return 3;
1413 }
1414 for (uint32_t i = 0; i < tests; i++) {
1415 init_nonce_memory();
1416 simulate_acquire_nonces();
1417 Tests();
1418 printf("Sum(a0) = %d\n", first_byte_Sum);
1419 fprintf(fstats, "%d;", first_byte_Sum);
1420 generate_candidates(first_byte_Sum, nonces[best_first_bytes[0]].Sum8_guess);
1421 brute_force();
1422 free_nonces_memory();
1423 free_statelist_cache();
1424 free_candidates_memory(candidates);
1425 candidates = NULL;
1426 }
1427 fclose(fstats);
1428 } else {
1429 init_nonce_memory();
1430 if (nonce_file_read) { // use pre-acquired data from file nonces.bin
1431 if (read_nonce_file() != 0) {
1432 return 3;
1433 }
1434 Check_for_FilterFlipProperties();
1435 num_good_first_bytes = MIN(estimate_second_byte_sum(), GOOD_BYTES_REQUIRED);
1436 } else { // acquire nonces.
1437 uint16_t is_OK = acquire_nonces(blockNo, keyType, key, trgBlockNo, trgKeyType, nonce_file_write, slow);
1438 if (is_OK != 0) {
1439 return is_OK;
1440 }
1441 }
1442
1443 Tests();
1444
1445 PrintAndLog("");
1446 PrintAndLog("Sum(a0) = %d", first_byte_Sum);
1447 // PrintAndLog("Best 10 first bytes: %02x, %02x, %02x, %02x, %02x, %02x, %02x, %02x, %02x, %02x",
1448 // best_first_bytes[0],
1449 // best_first_bytes[1],
1450 // best_first_bytes[2],
1451 // best_first_bytes[3],
1452 // best_first_bytes[4],
1453 // best_first_bytes[5],
1454 // best_first_bytes[6],
1455 // best_first_bytes[7],
1456 // best_first_bytes[8],
1457 // best_first_bytes[9] );
1458 PrintAndLog("Number of first bytes with confidence > %2.1f%%: %d", CONFIDENCE_THRESHOLD*100.0, num_good_first_bytes);
1459
1460 time_t start_time = clock();
1461 generate_candidates(first_byte_Sum, nonces[best_first_bytes[0]].Sum8_guess);
1462 PrintAndLog("Time for generating key candidates list: %1.0f seconds", (float)(clock() - start_time)/CLOCKS_PER_SEC);
1463
1464 brute_force();
1465 free_nonces_memory();
1466 free_statelist_cache();
1467 free_candidates_memory(candidates);
1468 candidates = NULL;
1469 }
1470
1471 return 0;
1472 }
1473
1474
Proxmark3 GIT tracking
Impressum, Datenschutz