]> git.zerfleddert.de Git - proxmark3-svn/blame - armsrc/mifareutil.c
improved GetAPDUCode()
[proxmark3-svn] / armsrc / mifareutil.c
CommitLineData
20f9a2a1 1//-----------------------------------------------------------------------------\r
b62a5a84 2// Merlok, May 2011, 2012\r
8f51ddb0 3// Many authors, whom made it possible\r
20f9a2a1
M
4//\r
5// This code is licensed to you under the terms of the GNU GPL, version 2 or,\r
6// at your option, any later version. See the LICENSE.txt file for the text of\r
7// the license.\r
8//-----------------------------------------------------------------------------\r
8f51ddb0 9// Work with mifare cards.\r
20f9a2a1
M
10//-----------------------------------------------------------------------------\r
11\r
930763e8 12#include <string.h>\r
33443e7c 13#include "mifareutil.h"\r
20f9a2a1
M
14#include "proxmark3.h"\r
15#include "apps.h"\r
16#include "util.h"\r
1f065e1d 17#include "parity.h"\r
20f9a2a1
M
18\r
19#include "iso14443crc.h"\r
20#include "iso14443a.h"\r
33443e7c 21#include "crapto1/crapto1.h"\r
930763e8 22#include "polarssl/des.h"\r
20f9a2a1 23\r
f397b5cc
M
24int MF_DBGLEVEL = MF_DBG_ALL;\r
25\r
8f51ddb0 26// crypto1 helpers\r
6e49717b 27void mf_crypto1_decryptEx(struct Crypto1State *pcs, uint8_t *data_in, int len, uint8_t *data_out){\r
8f51ddb0
M
28 uint8_t bt = 0;\r
29 int i;\r
30 \r
31 if (len != 1) {\r
32 for (i = 0; i < len; i++)\r
6e49717b 33 data_out[i] = crypto1_byte(pcs, 0x00, 0) ^ data_in[i];\r
8f51ddb0
M
34 } else {\r
35 bt = 0;\r
36 for (i = 0; i < 4; i++)\r
6e49717b 37 bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data_in[0], i)) << i;\r
8f51ddb0 38 \r
6e49717b 39 data_out[0] = bt;\r
8f51ddb0
M
40 }\r
41 return;\r
42}\r
43\r
6e49717b 44void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len){\r
45 mf_crypto1_decryptEx(pcs, data, len, data);\r
46}\r
47\r
6a1f2d82 48void mf_crypto1_encrypt(struct Crypto1State *pcs, uint8_t *data, uint16_t len, uint8_t *par) {\r
8f51ddb0
M
49 uint8_t bt = 0;\r
50 int i;\r
6a1f2d82 51 par[0] = 0;\r
3fe4ff4f 52 \r
8f51ddb0
M
53 for (i = 0; i < len; i++) {\r
54 bt = data[i];\r
55 data[i] = crypto1_byte(pcs, 0x00, 0) ^ data[i];\r
3fe4ff4f 56 if((i&0x0007) == 0) \r
57 par[i>>3] = 0;\r
1f065e1d 58 par[i>>3] |= (((filter(pcs->odd) ^ oddparity8(bt)) & 0x01)<<(7-(i&0x0007)));\r
8f51ddb0
M
59 } \r
60 return;\r
61}\r
62\r
63uint8_t mf_crypto1_encrypt4bit(struct Crypto1State *pcs, uint8_t data) {\r
64 uint8_t bt = 0;\r
65 int i;\r
66\r
67 for (i = 0; i < 4; i++)\r
68 bt |= (crypto1_bit(pcs, 0, 0) ^ BIT(data, i)) << i;\r
69 \r
70 return bt;\r
20f9a2a1
M
71}\r
72\r
4973f23d 73// send X byte basic commands\r
74int mifare_sendcmd(uint8_t cmd, uint8_t* data, uint8_t data_size, uint8_t* answer, uint8_t *answer_parity, uint32_t *timing)\r
f168b263 75{\r
4973f23d 76 uint8_t dcmd[data_size+3];\r
77 dcmd[0] = cmd;\r
78 memcpy(dcmd+1,data,data_size);\r
79 AppendCrc14443a(dcmd, data_size+1);\r
80 ReaderTransmit(dcmd, sizeof(dcmd), timing);\r
f168b263 81 int len = ReaderReceive(answer, answer_parity);\r
82 if(!len) {\r
4973f23d 83 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("%02X Cmd failed. Card timeout.", cmd);\r
84 len = ReaderReceive(answer,answer_parity);\r
85 //return 0;\r
86 }\r
a631936e 87 return len;\r
88}\r
89\r
4973f23d 90// send 2 byte commands\r
e35031d2 91int mifare_sendcmd_short(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd, uint8_t data, uint8_t *answer, uint8_t *answer_parity, uint32_t *timing)\r
f168b263 92{\r
93 uint8_t dcmd[4], ecmd[4];\r
6a1f2d82 94 uint16_t pos, res;\r
95 uint8_t par[1]; // 1 Byte parity is enough here\r
20f9a2a1
M
96 dcmd[0] = cmd;\r
97 dcmd[1] = data;\r
98 AppendCrc14443a(dcmd, 2);\r
99 \r
100 memcpy(ecmd, dcmd, sizeof(dcmd));\r
101 \r
102 if (crypted) {\r
6a1f2d82 103 par[0] = 0;\r
20f9a2a1
M
104 for (pos = 0; pos < 4; pos++)\r
105 {\r
106 ecmd[pos] = crypto1_byte(pcs, 0x00, 0) ^ dcmd[pos];\r
1f065e1d 107 par[0] |= (((filter(pcs->odd) ^ oddparity8(dcmd[pos])) & 0x01) << (7-pos));\r
20f9a2a1
M
108 } \r
109\r
9492e0b0 110 ReaderTransmitPar(ecmd, sizeof(ecmd), par, timing);\r
20f9a2a1
M
111\r
112 } else {\r
9492e0b0 113 ReaderTransmit(dcmd, sizeof(dcmd), timing);\r
20f9a2a1
M
114 }\r
115\r
6a1f2d82 116 int len = ReaderReceive(answer, par);\r
117 \r
118 if (answer_parity) *answer_parity = par[0];\r
f89c7050 119 \r
4abe4f58 120 if (crypted == CRYPT_ALL) {\r
20f9a2a1
M
121 if (len == 1) {\r
122 res = 0;\r
123 for (pos = 0; pos < 4; pos++)\r
124 res |= (crypto1_bit(pcs, 0, 0) ^ BIT(answer[0], pos)) << pos;\r
125 \r
126 answer[0] = res;\r
127 \r
128 } else {\r
129 for (pos = 0; pos < len; pos++)\r
130 {\r
131 answer[pos] = crypto1_byte(pcs, 0x00, 0) ^ answer[pos];\r
132 }\r
133 }\r
134 }\r
135 \r
136 return len;\r
137}\r
138\r
787b5bd8 139// mifare classic commands\r
6a1f2d82 140int mifare_classic_auth(struct Crypto1State *pcs, uint32_t uid, uint8_t blockNo, uint8_t keyType, uint64_t ui64Key, uint8_t isNested) \r
f89c7050 141{\r
9492e0b0 142 return mifare_classic_authex(pcs, uid, blockNo, keyType, ui64Key, isNested, NULL, NULL);\r
f89c7050
M
143}\r
144\r
6a1f2d82 145int mifare_classic_authex(struct Crypto1State *pcs, uint32_t uid, uint8_t blockNo, uint8_t keyType, uint64_t ui64Key, uint8_t isNested, uint32_t *ntptr, uint32_t *timing) \r
20f9a2a1
M
146{\r
147 // variables\r
4abe4f58 148 int len; \r
20f9a2a1
M
149 uint32_t pos;\r
150 uint8_t tmp4[4];\r
3fe4ff4f 151 uint8_t par[1] = {0x00};\r
6a1f2d82 152 byte_t nr[4];\r
20f9a2a1
M
153 uint32_t nt, ntpp; // Supplied tag nonce\r
154 \r
155 uint8_t mf_nr_ar[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };\r
f71f4deb 156 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
157 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
6a1f2d82 158 \r
4abe4f58 159 // Transmit MIFARE_CLASSIC_AUTH\r
6a1f2d82 160 len = mifare_sendcmd_short(pcs, isNested, 0x60 + (keyType & 0x01), blockNo, receivedAnswer, receivedAnswerPar, timing);\r
161 if (MF_DBGLEVEL >= 4) Dbprintf("rand tag nonce len: %x", len); \r
4abe4f58 162 if (len != 4) return 1;\r
20f9a2a1 163 \r
6a1f2d82 164 // "random" reader nonce:\r
165 nr[0] = 0x55;\r
166 nr[1] = 0x41;\r
167 nr[2] = 0x49;\r
168 nr[3] = 0x92; \r
20f9a2a1
M
169 \r
170 // Save the tag nonce (nt)\r
171 nt = bytes_to_num(receivedAnswer, 4);\r
20f9a2a1
M
172\r
173 // ----------------------------- crypto1 create\r
4abe4f58
M
174 if (isNested)\r
175 crypto1_destroy(pcs);\r
176\r
177 // Init cipher with key\r
20f9a2a1
M
178 crypto1_create(pcs, ui64Key);\r
179\r
4abe4f58
M
180 if (isNested == AUTH_NESTED) {\r
181 // decrypt nt with help of new key \r
182 nt = crypto1_word(pcs, nt ^ uid, 1) ^ nt;\r
183 } else {\r
184 // Load (plain) uid^nt into the cipher\r
185 crypto1_word(pcs, nt ^ uid, 0);\r
186 }\r
187\r
188 // some statistic\r
f397b5cc 189 if (!ntptr && (MF_DBGLEVEL >= 3))\r
f89c7050
M
190 Dbprintf("auth uid: %08x nt: %08x", uid, nt); \r
191 \r
192 // save Nt\r
193 if (ntptr)\r
194 *ntptr = nt;\r
20f9a2a1 195\r
4abe4f58 196 // Generate (encrypted) nr+parity by loading it into the cipher (Nr)\r
6a1f2d82 197 par[0] = 0;\r
4abe4f58
M
198 for (pos = 0; pos < 4; pos++)\r
199 {\r
6a1f2d82 200 mf_nr_ar[pos] = crypto1_byte(pcs, nr[pos], 0) ^ nr[pos];\r
1f065e1d 201 par[0] |= (((filter(pcs->odd) ^ oddparity8(nr[pos])) & 0x01) << (7-pos));\r
4abe4f58 202 } \r
20f9a2a1 203 \r
4abe4f58
M
204 // Skip 32 bits in pseudo random generator\r
205 nt = prng_successor(nt,32);\r
20f9a2a1
M
206\r
207 // ar+parity\r
4abe4f58
M
208 for (pos = 4; pos < 8; pos++)\r
209 {\r
20f9a2a1 210 nt = prng_successor(nt,8);\r
4abe4f58 211 mf_nr_ar[pos] = crypto1_byte(pcs,0x00,0) ^ (nt & 0xff);\r
1f065e1d 212 par[0] |= (((filter(pcs->odd) ^ oddparity8(nt)) & 0x01) << (7-pos));\r
4abe4f58 213 } \r
20f9a2a1 214 \r
4abe4f58 215 // Transmit reader nonce and reader answer\r
9492e0b0 216 ReaderTransmitPar(mf_nr_ar, sizeof(mf_nr_ar), par, NULL);\r
20f9a2a1 217\r
6a1f2d82 218 // Receive 4 byte tag answer\r
219 len = ReaderReceive(receivedAnswer, receivedAnswerPar);\r
4abe4f58
M
220 if (!len)\r
221 {\r
f397b5cc 222 if (MF_DBGLEVEL >= 1) Dbprintf("Authentication failed. Card timeout.");\r
20f9a2a1 223 return 2;\r
4abe4f58 224 }\r
20f9a2a1 225 \r
4abe4f58 226 memcpy(tmp4, receivedAnswer, 4);\r
20f9a2a1
M
227 ntpp = prng_successor(nt, 32) ^ crypto1_word(pcs, 0,0);\r
228 \r
229 if (ntpp != bytes_to_num(tmp4, 4)) {\r
f397b5cc 230 if (MF_DBGLEVEL >= 1) Dbprintf("Authentication failed. Error card response.");\r
20f9a2a1
M
231 return 3;\r
232 }\r
233\r
234 return 0;\r
235}\r
236\r
237int mifare_classic_readblock(struct Crypto1State *pcs, uint32_t uid, uint8_t blockNo, uint8_t *blockData) \r
238{\r
239 // variables\r
4abe4f58 240 int len; \r
20f9a2a1
M
241 uint8_t bt[2];\r
242 \r
f71f4deb 243 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
244 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
20f9a2a1 245 \r
4abe4f58 246 // command MIFARE_CLASSIC_READBLOCK\r
6a1f2d82 247 len = mifare_sendcmd_short(pcs, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL);\r
20f9a2a1 248 if (len == 1) {\r
f397b5cc 249 if (MF_DBGLEVEL >= 1) Dbprintf("Cmd Error: %02x", receivedAnswer[0]); \r
20f9a2a1
M
250 return 1;\r
251 }\r
252 if (len != 18) {\r
f397b5cc 253 if (MF_DBGLEVEL >= 1) Dbprintf("Cmd Error: card timeout. len: %x", len); \r
20f9a2a1
M
254 return 2;\r
255 }\r
256\r
257 memcpy(bt, receivedAnswer + 16, 2);\r
4abe4f58 258 AppendCrc14443a(receivedAnswer, 16);\r
20f9a2a1 259 if (bt[0] != receivedAnswer[16] || bt[1] != receivedAnswer[17]) {\r
f397b5cc 260 if (MF_DBGLEVEL >= 1) Dbprintf("Cmd CRC response error."); \r
20f9a2a1
M
261 return 3;\r
262 }\r
263 \r
264 memcpy(blockData, receivedAnswer, 16);\r
f168b263 265 return 0;\r
266}\r
267\r
a631936e 268// mifare ultralight commands\r
8258f409 269int mifare_ul_ev1_auth(uint8_t *keybytes, uint8_t *pack){\r
cceabb79 270\r
271 uint16_t len;\r
8258f409 272 uint8_t resp[4];\r
273 uint8_t respPar[1];\r
274 uint8_t key[4] = {0x00};\r
275 memcpy(key, keybytes, 4);\r
276\r
e35031d2 277 if (MF_DBGLEVEL >= MF_DBG_EXTENDED)\r
278 Dbprintf("EV1 Auth : %02x%02x%02x%02x", key[0], key[1], key[2], key[3]);\r
4973f23d 279 len = mifare_sendcmd(0x1B, key, sizeof(key), resp, respPar, NULL);\r
280 //len = mifare_sendcmd_short_mfuev1auth(NULL, 0, 0x1B, key, resp, respPar, NULL);\r
cceabb79 281 if (len != 4) {\r
8258f409 282 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd Error: %02x %u", resp[0], len);\r
9d87eb66 283 return 0;\r
cceabb79 284 }\r
8258f409 285\r
286 if (MF_DBGLEVEL >= MF_DBG_EXTENDED)\r
287 Dbprintf("Auth Resp: %02x%02x%02x%02x", resp[0],resp[1],resp[2],resp[3]);\r
288\r
289 memcpy(pack, resp, 4);\r
9d87eb66 290 return 1;\r
cceabb79 291}\r
292\r
8258f409 293int mifare_ultra_auth(uint8_t *keybytes){\r
294\r
295 /// 3des2k\r
296\r
930763e8 297 des3_context ctx = { 0x00 };\r
8258f409 298 uint8_t random_a[8] = {1,1,1,1,1,1,1,1};\r
299 uint8_t random_b[8] = {0x00};\r
300 uint8_t enc_random_b[8] = {0x00};\r
301 uint8_t rnd_ab[16] = {0x00};\r
302 uint8_t IV[8] = {0x00};\r
303 uint8_t key[16] = {0x00};\r
304 memcpy(key, keybytes, 16);\r
a631936e 305\r
306 uint16_t len;\r
8258f409 307 uint8_t resp[19] = {0x00};\r
308 uint8_t respPar[3] = {0,0,0};\r
309\r
310 // REQUEST AUTHENTICATION\r
311 len = mifare_sendcmd_short(NULL, 1, 0x1A, 0x00, resp, respPar ,NULL);\r
f168b263 312 if (len != 11) {\r
8258f409 313 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd Error: %02x", resp[0]);\r
9d87eb66 314 return 0;\r
a631936e 315 }\r
a631936e 316\r
8258f409 317 // tag nonce.\r
318 memcpy(enc_random_b,resp+1,8);\r
319\r
320 // decrypt nonce.\r
930763e8 321 // tdes_2key_dec(random_b, enc_random_b, sizeof(random_b), key, IV );\r
322 des3_set2key_dec(&ctx, key);\r
323 des3_crypt_cbc(&ctx // des3_context\r
324 , DES_DECRYPT // int mode\r
325 , sizeof(random_b) // length\r
326 , IV // iv[8]\r
327 , enc_random_b // input\r
328 , random_b // output\r
329 );\r
330\r
8258f409 331 rol(random_b,8);\r
332 memcpy(rnd_ab ,random_a,8);\r
333 memcpy(rnd_ab+8,random_b,8);\r
334\r
a631936e 335 if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {\r
8258f409 336 Dbprintf("enc_B: %02x %02x %02x %02x %02x %02x %02x %02x",\r
337 enc_random_b[0],enc_random_b[1],enc_random_b[2],enc_random_b[3],enc_random_b[4],enc_random_b[5],enc_random_b[6],enc_random_b[7]);\r
a631936e 338\r
8258f409 339 Dbprintf(" B: %02x %02x %02x %02x %02x %02x %02x %02x",\r
340 random_b[0],random_b[1],random_b[2],random_b[3],random_b[4],random_b[5],random_b[6],random_b[7]);\r
a631936e 341\r
8258f409 342 Dbprintf("rnd_ab: %02x %02x %02x %02x %02x %02x %02x %02x",\r
343 rnd_ab[0],rnd_ab[1],rnd_ab[2],rnd_ab[3],rnd_ab[4],rnd_ab[5],rnd_ab[6],rnd_ab[7]);\r
344\r
345 Dbprintf("rnd_ab: %02x %02x %02x %02x %02x %02x %02x %02x",\r
346 rnd_ab[8],rnd_ab[9],rnd_ab[10],rnd_ab[11],rnd_ab[12],rnd_ab[13],rnd_ab[14],rnd_ab[15] );\r
347 }\r
348\r
349 // encrypt out, in, length, key, iv\r
930763e8 350 //tdes_2key_enc(rnd_ab, rnd_ab, sizeof(rnd_ab), key, enc_random_b);\r
351 des3_set2key_enc(&ctx, key);\r
352 des3_crypt_cbc(&ctx // des3_context\r
353 , DES_ENCRYPT // int mode\r
354 , sizeof(rnd_ab) // length\r
355 , enc_random_b // iv[8]\r
356 , rnd_ab // input\r
357 , rnd_ab // output\r
358 );\r
359\r
4973f23d 360 //len = mifare_sendcmd_short_mfucauth(NULL, 1, 0xAF, rnd_ab, resp, respPar, NULL);\r
361 len = mifare_sendcmd(0xAF, rnd_ab, sizeof(rnd_ab), resp, respPar, NULL);\r
f168b263 362 if (len != 11) {\r
8258f409 363 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd Error: %02x", resp[0]);\r
9d87eb66 364 return 0;\r
a631936e 365 }\r
8258f409 366\r
367 uint8_t enc_resp[8] = { 0,0,0,0,0,0,0,0 };\r
368 uint8_t resp_random_a[8] = { 0,0,0,0,0,0,0,0 };\r
369 memcpy(enc_resp, resp+1, 8);\r
370\r
371 // decrypt out, in, length, key, iv \r
930763e8 372 // tdes_2key_dec(resp_random_a, enc_resp, 8, key, enc_random_b);\r
373 des3_set2key_dec(&ctx, key);\r
374 des3_crypt_cbc(&ctx // des3_context\r
375 , DES_DECRYPT // int mode\r
376 , 8 // length\r
377 , enc_random_b // iv[8]\r
378 , enc_resp // input\r
379 , resp_random_a // output\r
380 );\r
8258f409 381 if ( memcmp(resp_random_a, random_a, 8) != 0 ) {\r
382 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("failed authentication");\r
9d87eb66 383 return 0;\r
8258f409 384 }\r
385\r
a631936e 386 if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {\r
8258f409 387 Dbprintf("e_AB: %02x %02x %02x %02x %02x %02x %02x %02x", \r
388 rnd_ab[0],rnd_ab[1],rnd_ab[2],rnd_ab[3],\r
389 rnd_ab[4],rnd_ab[5],rnd_ab[6],rnd_ab[7]);\r
390\r
391 Dbprintf("e_AB: %02x %02x %02x %02x %02x %02x %02x %02x",\r
392 rnd_ab[8],rnd_ab[9],rnd_ab[10],rnd_ab[11],\r
393 rnd_ab[12],rnd_ab[13],rnd_ab[14],rnd_ab[15]);\r
394\r
395 Dbprintf("a: %02x %02x %02x %02x %02x %02x %02x %02x",\r
396 random_a[0],random_a[1],random_a[2],random_a[3],\r
397 random_a[4],random_a[5],random_a[6],random_a[7]);\r
398\r
399 Dbprintf("b: %02x %02x %02x %02x %02x %02x %02x %02x",\r
400 resp_random_a[0],resp_random_a[1],resp_random_a[2],resp_random_a[3],\r
401 resp_random_a[4],resp_random_a[5],resp_random_a[6],resp_random_a[7]);\r
a631936e 402 }\r
9d87eb66 403 return 1;\r
a631936e 404}\r
405\r
f168b263 406int mifare_ultra_readblock(uint8_t blockNo, uint8_t *blockData)\r
407{\r
408 uint16_t len;\r
409 uint8_t bt[2];\r
410 uint8_t receivedAnswer[MAX_FRAME_SIZE];\r
411 uint8_t receivedAnswerPar[MAX_PARITY_SIZE];\r
3fe4ff4f 412 \r
4973f23d 413\r
f168b263 414 len = mifare_sendcmd_short(NULL, 1, 0x30, blockNo, receivedAnswer, receivedAnswerPar, NULL);\r
415 if (len == 1) {\r
416 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd Error: %02x", receivedAnswer[0]);\r
417 return 1;\r
418 }\r
419 if (len != 18) {\r
420 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd Error: card timeout. len: %x", len);\r
421 return 2;\r
422 }\r
423 \r
424 memcpy(bt, receivedAnswer + 16, 2);\r
425 AppendCrc14443a(receivedAnswer, 16);\r
426 if (bt[0] != receivedAnswer[16] || bt[1] != receivedAnswer[17]) {\r
427 if (MF_DBGLEVEL >= MF_DBG_ERROR) Dbprintf("Cmd CRC response error.");\r
428 return 3;\r
429 }\r
430 \r
431 memcpy(blockData, receivedAnswer, 14);\r
432 return 0;\r
433}\r
434\r
f168b263 435int mifare_classic_writeblock(struct Crypto1State *pcs, uint32_t uid, uint8_t blockNo, uint8_t *blockData) \r
436{\r
437 // variables\r
3fe4ff4f 438 uint16_t len, i; \r
20f9a2a1 439 uint32_t pos;\r
6a1f2d82 440 uint8_t par[3] = {0}; // enough for 18 Bytes to send\r
4abe4f58 441 byte_t res;\r
20f9a2a1
M
442 \r
443 uint8_t d_block[18], d_block_enc[18];\r
f71f4deb 444 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
445 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
20f9a2a1 446 \r
4abe4f58 447 // command MIFARE_CLASSIC_WRITEBLOCK\r
6a1f2d82 448 len = mifare_sendcmd_short(pcs, 1, 0xA0, blockNo, receivedAnswer, receivedAnswerPar, NULL);\r
20f9a2a1
M
449\r
450 if ((len != 1) || (receivedAnswer[0] != 0x0A)) { // 0x0a - ACK\r
f397b5cc 451 if (MF_DBGLEVEL >= 1) Dbprintf("Cmd Error: %02x", receivedAnswer[0]); \r
20f9a2a1
M
452 return 1;\r
453 }\r
454 \r
455 memcpy(d_block, blockData, 16);\r
456 AppendCrc14443a(d_block, 16);\r
457 \r
458 // crypto\r
4abe4f58
M
459 for (pos = 0; pos < 18; pos++)\r
460 {\r
461 d_block_enc[pos] = crypto1_byte(pcs, 0x00, 0) ^ d_block[pos];\r
1f065e1d 462 par[pos>>3] |= (((filter(pcs->odd) ^ oddparity8(d_block[pos])) & 0x01) << (7 - (pos&0x0007)));\r
4abe4f58 463 } \r
20f9a2a1 464\r
9492e0b0 465 ReaderTransmitPar(d_block_enc, sizeof(d_block_enc), par, NULL);\r
20f9a2a1 466\r
4abe4f58 467 // Receive the response\r
6a1f2d82 468 len = ReaderReceive(receivedAnswer, receivedAnswerPar); \r
20f9a2a1
M
469\r
470 res = 0;\r
471 for (i = 0; i < 4; i++)\r
472 res |= (crypto1_bit(pcs, 0, 0) ^ BIT(receivedAnswer[0], i)) << i;\r
473\r
474 if ((len != 1) || (res != 0x0A)) {\r
f397b5cc 475 if (MF_DBGLEVEL >= 1) Dbprintf("Cmd send data2 Error: %02x", res); \r
20f9a2a1
M
476 return 2;\r
477 }\r
478 \r
f168b263 479 return 0;\r
480}\r
481\r
4973f23d 482/* // command not needed, but left for future testing\r
483int mifare_ultra_writeblock_compat(uint8_t blockNo, uint8_t *blockData) \r
f168b263 484{\r
485 uint16_t len;\r
486 uint8_t par[3] = {0}; // enough for 18 parity bits\r
487 uint8_t d_block[18] = {0x00};\r
488 uint8_t receivedAnswer[MAX_FRAME_SIZE];\r
489 uint8_t receivedAnswerPar[MAX_PARITY_SIZE];\r
490\r
f168b263 491 len = mifare_sendcmd_short(NULL, true, 0xA0, blockNo, receivedAnswer, receivedAnswerPar, NULL);\r
492\r
493 if ((len != 1) || (receivedAnswer[0] != 0x0A)) { // 0x0a - ACK\r
787b5bd8 494 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
f168b263 495 Dbprintf("Cmd Addr Error: %02x", receivedAnswer[0]);\r
496 return 1;\r
497 }\r
498\r
499 memcpy(d_block, blockData, 16);\r
500 AppendCrc14443a(d_block, 16);\r
501\r
502 ReaderTransmitPar(d_block, sizeof(d_block), par, NULL);\r
503\r
504 len = ReaderReceive(receivedAnswer, receivedAnswerPar);\r
505\r
506 if ((len != 1) || (receivedAnswer[0] != 0x0A)) { // 0x0a - ACK\r
787b5bd8 507 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
f168b263 508 Dbprintf("Cmd Data Error: %02x %d", receivedAnswer[0],len);\r
509 return 2;\r
510 }\r
511 return 0;\r
512}\r
4973f23d 513*/\r
f168b263 514\r
4973f23d 515int mifare_ultra_writeblock(uint8_t blockNo, uint8_t *blockData)\r
f168b263 516{\r
517 uint16_t len;\r
4973f23d 518 uint8_t d_block[5] = {0x00};\r
f71f4deb 519 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
520 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
f168b263 521\r
522 // command MIFARE_CLASSIC_WRITEBLOCK\r
523 d_block[0]= blockNo;\r
524 memcpy(d_block+1,blockData,4);\r
4973f23d 525 //AppendCrc14443a(d_block, 6);\r
f168b263 526\r
4973f23d 527 len = mifare_sendcmd(0xA2, d_block, sizeof(d_block), receivedAnswer, receivedAnswerPar, NULL);\r
f168b263 528\r
529 if (receivedAnswer[0] != 0x0A) { // 0x0a - ACK\r
787b5bd8 530 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
f168b263 531 Dbprintf("Cmd Send Error: %02x %d", receivedAnswer[0],len);\r
532 return 1;\r
533 }\r
534 return 0;\r
535}\r
536\r
537int mifare_classic_halt(struct Crypto1State *pcs, uint32_t uid) \r
538{\r
6a1f2d82 539 uint16_t len; \r
f71f4deb 540 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
541 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
20f9a2a1 542\r
6a1f2d82 543 len = mifare_sendcmd_short(pcs, pcs == NULL ? false:true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL);\r
4abe4f58 544 if (len != 0) {\r
787b5bd8 545 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
546 Dbprintf("halt error. response len: %x", len); \r
20f9a2a1
M
547 return 1;\r
548 }\r
549\r
f168b263 550 return 0;\r
551}\r
552\r
553int mifare_ultra_halt()\r
554{\r
555 uint16_t len;\r
f71f4deb 556 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
557 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
f168b263 558 \r
559 len = mifare_sendcmd_short(NULL, true, 0x50, 0x00, receivedAnswer, receivedAnswerPar, NULL);\r
560 if (len != 0) {\r
787b5bd8 561 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
f168b263 562 Dbprintf("halt error. response len: %x", len);\r
563 return 1;\r
564 }\r
565 return 0;\r
566}\r
567\r
baeaf579 568\r
569// Mifare Memory Structure: up to 32 Sectors with 4 blocks each (1k and 2k cards),\r
570// plus evtl. 8 sectors with 16 blocks each (4k cards)\r
571uint8_t NumBlocksPerSector(uint8_t sectorNo) \r
572{\r
573 if (sectorNo < 32) \r
574 return 4;\r
575 else\r
576 return 16;\r
577}\r
578\r
579uint8_t FirstBlockOfSector(uint8_t sectorNo) \r
580{\r
581 if (sectorNo < 32)\r
582 return sectorNo * 4;\r
583 else\r
584 return 32*4 + (sectorNo - 32) * 16;\r
585 \r
586}\r
587\r
588\r
f168b263 589// work with emulator memory\r
590void emlSetMem(uint8_t *data, int blockNum, int blocksCount) {\r
591 uint8_t* emCARD = BigBuf_get_EM_addr();\r
8f51ddb0
M
592 memcpy(emCARD + blockNum * 16, data, blocksCount * 16);\r
593}\r
594\r
595void emlGetMem(uint8_t *data, int blockNum, int blocksCount) {\r
f71f4deb 596 uint8_t* emCARD = BigBuf_get_EM_addr();\r
8f51ddb0
M
597 memcpy(data, emCARD + blockNum * 16, blocksCount * 16);\r
598}\r
599\r
600void emlGetMemBt(uint8_t *data, int bytePtr, int byteCount) {\r
f71f4deb 601 uint8_t* emCARD = BigBuf_get_EM_addr();\r
8f51ddb0
M
602 memcpy(data, emCARD + bytePtr, byteCount);\r
603}\r
604\r
0014cb46 605int emlCheckValBl(int blockNum) {\r
f71f4deb 606 uint8_t* emCARD = BigBuf_get_EM_addr();\r
0014cb46
M
607 uint8_t* data = emCARD + blockNum * 16;\r
608\r
609 if ((data[0] != (data[4] ^ 0xff)) || (data[0] != data[8]) ||\r
610 (data[1] != (data[5] ^ 0xff)) || (data[1] != data[9]) ||\r
611 (data[2] != (data[6] ^ 0xff)) || (data[2] != data[10]) ||\r
612 (data[3] != (data[7] ^ 0xff)) || (data[3] != data[11]) ||\r
613 (data[12] != (data[13] ^ 0xff)) || (data[12] != data[14]) ||\r
614 (data[12] != (data[15] ^ 0xff))\r
615 ) \r
616 return 1;\r
617 return 0;\r
618}\r
619\r
620int emlGetValBl(uint32_t *blReg, uint8_t *blBlock, int blockNum) {\r
f71f4deb 621 uint8_t* emCARD = BigBuf_get_EM_addr();\r
0014cb46
M
622 uint8_t* data = emCARD + blockNum * 16;\r
623 \r
624 if (emlCheckValBl(blockNum)) {\r
625 return 1;\r
626 }\r
627 \r
628 memcpy(blReg, data, 4);\r
629 *blBlock = data[12];\r
0014cb46
M
630 return 0;\r
631}\r
632\r
633int emlSetValBl(uint32_t blReg, uint8_t blBlock, int blockNum) {\r
f71f4deb 634 uint8_t* emCARD = BigBuf_get_EM_addr();\r
0014cb46
M
635 uint8_t* data = emCARD + blockNum * 16;\r
636 \r
637 memcpy(data + 0, &blReg, 4);\r
638 memcpy(data + 8, &blReg, 4);\r
639 blReg = blReg ^ 0xffffffff;\r
640 memcpy(data + 4, &blReg, 4);\r
641 \r
642 data[12] = blBlock;\r
643 data[13] = blBlock ^ 0xff;\r
644 data[14] = blBlock;\r
645 data[15] = blBlock ^ 0xff;\r
646 \r
647 return 0;\r
648}\r
649\r
8556b852
M
650uint64_t emlGetKey(int sectorNum, int keyType) {\r
651 uint8_t key[6];\r
f71f4deb 652 uint8_t* emCARD = BigBuf_get_EM_addr();\r
8556b852 653 \r
baeaf579 654 memcpy(key, emCARD + 16 * (FirstBlockOfSector(sectorNum) + NumBlocksPerSector(sectorNum) - 1) + keyType * 10, 6);\r
8556b852
M
655 return bytes_to_num(key, 6);\r
656}\r
657\r
8f51ddb0 658void emlClearMem(void) {\r
aea4d766 659 int b;\r
8f51ddb0
M
660 \r
661 const uint8_t trailer[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x80, 0x69, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
8f51ddb0 662 const uint8_t uid[] = {0xe6, 0x84, 0x87, 0xf3, 0x16, 0x88, 0x04, 0x00, 0x46, 0x8e, 0x45, 0x55, 0x4d, 0x70, 0x41, 0x04};\r
f71f4deb 663 uint8_t* emCARD = BigBuf_get_EM_addr();\r
aea4d766 664 \r
6a1f2d82 665 memset(emCARD, 0, CARD_MEMORY_SIZE);\r
aea4d766 666 \r
667 // fill sectors trailer data\r
668 for(b = 3; b < 256; b<127?(b+=4):(b+=16)) {\r
669 emlSetMem((uint8_t *)trailer, b , 1);\r
670 } \r
8f51ddb0
M
671\r
672 // uid\r
673 emlSetMem((uint8_t *)uid, 0, 1);\r
674 return;\r
675}\r
c8b6da22 676\r
677\r
678// Mifare desfire commands\r
679int mifare_sendcmd_special(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd, uint8_t* data, uint8_t* answer, uint8_t *answer_parity, uint32_t *timing)\r
680{\r
681 uint8_t dcmd[5] = {0x00};\r
682 dcmd[0] = cmd;\r
683 memcpy(dcmd+1,data,2);\r
684 AppendCrc14443a(dcmd, 3);\r
685 \r
686 ReaderTransmit(dcmd, sizeof(dcmd), NULL);\r
687 int len = ReaderReceive(answer, answer_parity);\r
688 if(!len) {\r
689 if (MF_DBGLEVEL >= MF_DBG_ERROR) \r
690 Dbprintf("Authentication failed. Card timeout.");\r
691 return 1;\r
692 }\r
693 return len;\r
694}\r
695\r
696int mifare_sendcmd_special2(struct Crypto1State *pcs, uint8_t crypted, uint8_t cmd, uint8_t* data, uint8_t* answer,uint8_t *answer_parity, uint32_t *timing)\r
697{\r
698 uint8_t dcmd[20] = {0x00};\r
699 dcmd[0] = cmd;\r
700 memcpy(dcmd+1,data,17);\r
701 AppendCrc14443a(dcmd, 18);\r
702\r
703 ReaderTransmit(dcmd, sizeof(dcmd), NULL);\r
704 int len = ReaderReceive(answer, answer_parity);\r
705 if(!len){\r
706 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
707 Dbprintf("Authentication failed. Card timeout.");\r
708 return 1;\r
709 }\r
710 return len;\r
711}\r
712\r
713int mifare_desfire_des_auth1(uint32_t uid, uint8_t *blockData){\r
714\r
715 int len;\r
716 // load key, keynumber\r
717 uint8_t data[2]={0x0a, 0x00};\r
29250969 718 uint8_t receivedAnswer[MAX_FRAME_SIZE];\r
719 uint8_t receivedAnswerPar[MAX_PARITY_SIZE];\r
c8b6da22 720 \r
721 len = mifare_sendcmd_special(NULL, 1, 0x02, data, receivedAnswer,receivedAnswerPar,NULL);\r
722 if (len == 1) {\r
723 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
724 Dbprintf("Cmd Error: %02x", receivedAnswer[0]);\r
725 return 1;\r
726 }\r
727 \r
728 if (len == 12) {\r
729 if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {\r
730 Dbprintf("Auth1 Resp: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",\r
731 receivedAnswer[0],receivedAnswer[1],receivedAnswer[2],receivedAnswer[3],receivedAnswer[4],\r
732 receivedAnswer[5],receivedAnswer[6],receivedAnswer[7],receivedAnswer[8],receivedAnswer[9],\r
733 receivedAnswer[10],receivedAnswer[11]);\r
734 }\r
735 memcpy(blockData, receivedAnswer, 12);\r
736 return 0;\r
737 }\r
738 return 1;\r
739}\r
740\r
741int mifare_desfire_des_auth2(uint32_t uid, uint8_t *key, uint8_t *blockData){\r
742\r
743 int len;\r
744 uint8_t data[17] = {0x00};\r
745 data[0] = 0xAF;\r
746 memcpy(data+1,key,16);\r
747 \r
f71f4deb 748 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];\r
749 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];\r
c8b6da22 750 \r
751 len = mifare_sendcmd_special2(NULL, 1, 0x03, data, receivedAnswer, receivedAnswerPar ,NULL);\r
752 \r
753 if ((receivedAnswer[0] == 0x03) && (receivedAnswer[1] == 0xae)) {\r
754 if (MF_DBGLEVEL >= MF_DBG_ERROR)\r
755 Dbprintf("Auth Error: %02x %02x", receivedAnswer[0], receivedAnswer[1]);\r
756 return 1;\r
757 }\r
758 \r
759 if (len == 12){\r
760 if (MF_DBGLEVEL >= MF_DBG_EXTENDED) {\r
761 Dbprintf("Auth2 Resp: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",\r
762 receivedAnswer[0],receivedAnswer[1],receivedAnswer[2],receivedAnswer[3],receivedAnswer[4],\r
763 receivedAnswer[5],receivedAnswer[6],receivedAnswer[7],receivedAnswer[8],receivedAnswer[9],\r
764 receivedAnswer[10],receivedAnswer[11]);\r
765 }\r
766 memcpy(blockData, receivedAnswer, 12);\r
767 return 0;\r
768 }\r
769 return 1;\r
f168b263 770}\r
275d9e61
OM
771\r
772//-----------------------------------------------------------------------------\r
773// MIFARE check keys\r
774//\r
775//-----------------------------------------------------------------------------\r
776// one key check\r
777int MifareChkBlockKey(uint8_t *uid, uint32_t *cuid, uint8_t *cascade_levels, uint64_t ui64Key, uint8_t blockNo, uint8_t keyType, uint8_t debugLevel) {\r
778\r
779 struct Crypto1State mpcs = {0, 0};\r
780 struct Crypto1State *pcs;\r
781 pcs = &mpcs;\r
782\r
783 // Iceman: use piwi's faster nonce collecting part in hardnested.\r
784 if (*cascade_levels == 0) { // need a full select cycle to get the uid first\r
785 iso14a_card_select_t card_info;\r
786 if(!iso14443a_select_card(uid, &card_info, cuid, true, 0, true)) {\r
787 if (debugLevel >= 1) Dbprintf("ChkKeys: Can't select card");\r
788 return 1;\r
789 }\r
790 switch (card_info.uidlen) {\r
791 case 4 : *cascade_levels = 1; break;\r
792 case 7 : *cascade_levels = 2; break;\r
793 case 10: *cascade_levels = 3; break;\r
794 default: break;\r
795 }\r
796 } else { // no need for anticollision. We can directly select the card\r
797 if(!iso14443a_select_card(uid, NULL, NULL, false, *cascade_levels, true)) {\r
798 if (debugLevel >= 1) Dbprintf("ChkKeys: Can't select card (UID) lvl=%d", *cascade_levels);\r
799 return 1;\r
800 }\r
801 }\r
802 \r
803 if(mifare_classic_auth(pcs, *cuid, blockNo, keyType, ui64Key, AUTH_FIRST)) {\r
804// SpinDelayUs(AUTHENTICATION_TIMEOUT); // it not needs because mifare_classic_auth have timeout from iso14a_set_timeout()\r
805 return 2;\r
806 } else {\r
807/* // let it be here. it like halt command, but maybe it will work in some strange cases\r
808 uint8_t dummy_answer = 0;\r
809 ReaderTransmit(&dummy_answer, 1, NULL);\r
810 int timeout = GetCountSspClk() + AUTHENTICATION_TIMEOUT; \r
811 // wait for the card to become ready again\r
812 while(GetCountSspClk() < timeout) {};\r
813*/\r
814 // it needs after success authentication\r
815 mifare_classic_halt(pcs, *cuid);\r
816 }\r
817 \r
818 return 0;\r
819}\r
820\r
821// multi key check\r
822int MifareChkBlockKeys(uint8_t *keys, uint8_t keyCount, uint8_t blockNo, uint8_t keyType, uint8_t debugLevel) {\r
823 uint8_t uid[10];\r
824 uint32_t cuid = 0;\r
825 uint8_t cascade_levels = 0;\r
826 uint64_t ui64Key = 0;\r
827\r
828 int retryCount = 0;\r
829 for (uint8_t i = 0; i < keyCount; i++) {\r
830\r
831 // Allow button press / usb cmd to interrupt device\r
832 if (BUTTON_PRESS() && !usb_poll_validate_length()) { \r
833 Dbprintf("ChkKeys: Cancel operation. Exit...");\r
834 return -2;\r
835 }\r
836\r
837 ui64Key = bytes_to_num(keys + i * 6, 6);\r
838 int res = MifareChkBlockKey(uid, &cuid, &cascade_levels, ui64Key, blockNo, keyType, debugLevel);\r
839 \r
840 // can't select\r
841 if (res == 1) {\r
842 retryCount++;\r
843 if (retryCount >= 5) {\r
844 Dbprintf("ChkKeys: block=%d key=%d. Can't select. Exit...", blockNo, keyType);\r
845 return -1;\r
846 }\r
847 --i; // try the same key once again\r
848\r
849 SpinDelay(20);\r
850// Dbprintf("ChkKeys: block=%d key=%d. Try the same key once again...", blockNo, keyType);\r
851 continue;\r
852 }\r
853 \r
854 // can't authenticate\r
855 if (res == 2) {\r
856 retryCount = 0;\r
857 continue; // can't auth. wrong key.\r
858 }\r
859\r
860 return i + 1;\r
861 }\r
862 \r
863 return 0;\r
864}\r
865\r
866// multisector multikey check\r
867int MifareMultisectorChk(uint8_t *keys, uint8_t keyCount, uint8_t SectorCount, uint8_t keyType, uint8_t debugLevel, TKeyIndex *keyIndex) {\r
868 int res = 0;\r
869 \r
870// int clk = GetCountSspClk();\r
871\r
872 for(int sc = 0; sc < SectorCount; sc++){\r
873 WDT_HIT();\r
874\r
875 int keyAB = keyType;\r
876 do {\r
877 res = MifareChkBlockKeys(keys, keyCount, FirstBlockOfSector(sc), keyAB & 0x01, debugLevel);\r
878 if (res < 0){\r
879 return res;\r
880 }\r
881 if (res > 0){\r
882 (*keyIndex)[keyAB & 0x01][sc] = res;\r
883 }\r
884 } while(--keyAB > 0);\r
885 }\r
886 \r
887// Dbprintf("%d %d", GetCountSspClk() - clk, (GetCountSspClk() - clk)/(SectorCount*keyCount*(keyType==2?2:1)));\r
888 \r
889 return 0;\r
890}\r
891\r
892\r
Impressum, Datenschutz