1 //-----------------------------------------------------------------------------
2 // Merlok, May 2011, 2012
3 // Many authors, whom made it possible
5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
6 // at your option, any later version. See the LICENSE.txt file for the text of
8 //-----------------------------------------------------------------------------
9 // Work with mifare cards.
10 //-----------------------------------------------------------------------------
12 #include "proxmark3.h"
17 #include "iso14443crc.h"
18 #include "iso14443a.h"
20 #include "mifareutil.h"
22 int MF_DBGLEVEL
= MF_DBG_ALL
;
25 uint8_t* mifare_get_bigbufptr(void) {
26 return (((uint8_t *)BigBuf
) + MIFARE_BUFF_OFFSET
); // was 3560 - tied to other size changes
28 uint8_t* eml_get_bigbufptr_sendbuf(void) {
29 return (((uint8_t *)BigBuf
) + RECV_CMD_OFFSET
);
31 uint8_t* eml_get_bigbufptr_recbuf(void) {
32 return (((uint8_t *)BigBuf
) + MIFARE_BUFF_OFFSET
);
34 uint8_t* eml_get_bigbufptr_cardmem(void) {
35 return (((uint8_t *)BigBuf
) + CARD_MEMORY
);
39 void mf_crypto1_decrypt(struct Crypto1State
*pcs
, uint8_t *data
, int len
){
44 for (i
= 0; i
< len
; i
++)
45 data
[i
] = crypto1_byte(pcs
, 0x00, 0) ^ data
[i
];
48 for (i
= 0; i
< 4; i
++)
49 bt
|= (crypto1_bit(pcs
, 0, 0) ^ BIT(data
[0], i
)) << i
;
56 void mf_crypto1_encrypt(struct Crypto1State
*pcs
, uint8_t *data
, int len
, uint32_t *par
) {
59 uint32_t mltpl
= 1 << (len
- 1); // for len=18 it=0x20000
61 for (i
= 0; i
< len
; i
++) {
63 data
[i
] = crypto1_byte(pcs
, 0x00, 0) ^ data
[i
];
64 *par
= (*par
>> 1) | ( ((filter(pcs
->odd
) ^ oddparity(bt
)) & 0x01) * mltpl
);
69 uint8_t mf_crypto1_encrypt4bit(struct Crypto1State
*pcs
, uint8_t data
) {
73 for (i
= 0; i
< 4; i
++)
74 bt
|= (crypto1_bit(pcs
, 0, 0) ^ BIT(data
, i
)) << i
;
80 int mifare_sendcmd_short(struct Crypto1State
*pcs
, uint8_t crypted
, uint8_t cmd
, uint8_t data
, uint8_t* answer
)
82 return mifare_sendcmd_shortex(pcs
, crypted
, cmd
, data
, answer
, NULL
);
85 int mifare_sendcmd_shortex(struct Crypto1State
*pcs
, uint8_t crypted
, uint8_t cmd
, uint8_t data
, uint8_t* answer
, uint32_t * parptr
)
87 uint8_t dcmd
[4], ecmd
[4];
88 uint32_t pos
, par
, res
;
92 AppendCrc14443a(dcmd
, 2);
94 memcpy(ecmd
, dcmd
, sizeof(dcmd
));
98 for (pos
= 0; pos
< 4; pos
++)
100 ecmd
[pos
] = crypto1_byte(pcs
, 0x00, 0) ^ dcmd
[pos
];
101 par
= (par
>> 1) | ( ((filter(pcs
->odd
) ^ oddparity(dcmd
[pos
])) & 0x01) * 0x08 );
104 ReaderTransmitPar(ecmd
, sizeof(ecmd
), par
);
107 ReaderTransmit(dcmd
, sizeof(dcmd
));
110 int len
= ReaderReceivePar(answer
, &par
);
112 if (parptr
) *parptr
= par
;
114 if (crypted
== CRYPT_ALL
) {
117 for (pos
= 0; pos
< 4; pos
++)
118 res
|= (crypto1_bit(pcs
, 0, 0) ^ BIT(answer
[0], pos
)) << pos
;
123 for (pos
= 0; pos
< len
; pos
++)
125 answer
[pos
] = crypto1_byte(pcs
, 0x00, 0) ^ answer
[pos
];
134 int mifare_classic_auth(struct Crypto1State
*pcs
, uint32_t uid
, uint8_t blockNo
, uint8_t keyType
, uint64_t ui64Key
, uint64_t isNested
)
136 return mifare_classic_authex(pcs
, uid
, blockNo
, keyType
, ui64Key
, isNested
, NULL
);
139 int mifare_classic_authex(struct Crypto1State
*pcs
, uint32_t uid
, uint8_t blockNo
, uint8_t keyType
, uint64_t ui64Key
, uint64_t isNested
, uint32_t * ntptr
)
147 uint32_t nt
, ntpp
; // Supplied tag nonce
149 uint8_t mf_nr_ar
[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
150 uint8_t* receivedAnswer
= mifare_get_bigbufptr();
152 // Transmit MIFARE_CLASSIC_AUTH
153 len
= mifare_sendcmd_short(pcs
, isNested
, 0x60 + (keyType
& 0x01), blockNo
, receivedAnswer
);
154 if (MF_DBGLEVEL
>= 4) Dbprintf("rand nonce len: %x", len
);
155 if (len
!= 4) return 1;
162 // Save the tag nonce (nt)
163 nt
= bytes_to_num(receivedAnswer
, 4);
165 // ----------------------------- crypto1 create
167 crypto1_destroy(pcs
);
169 // Init cipher with key
170 crypto1_create(pcs
, ui64Key
);
172 if (isNested
== AUTH_NESTED
) {
173 // decrypt nt with help of new key
174 nt
= crypto1_word(pcs
, nt
^ uid
, 1) ^ nt
;
176 // Load (plain) uid^nt into the cipher
177 crypto1_word(pcs
, nt
^ uid
, 0);
181 if (!ntptr
&& (MF_DBGLEVEL
>= 3))
182 Dbprintf("auth uid: %08x nt: %08x", uid
, nt
);
189 // Generate (encrypted) nr+parity by loading it into the cipher (Nr)
190 for (pos
= 0; pos
< 4; pos
++)
192 mf_nr_ar
[pos
] = crypto1_byte(pcs
, ar
[pos
], 0) ^ ar
[pos
];
193 par
= (par
>> 1) | ( ((filter(pcs
->odd
) ^ oddparity(ar
[pos
])) & 0x01) * 0x80 );
196 // Skip 32 bits in pseudo random generator
197 nt
= prng_successor(nt
,32);
200 for (pos
= 4; pos
< 8; pos
++)
202 nt
= prng_successor(nt
,8);
203 mf_nr_ar
[pos
] = crypto1_byte(pcs
,0x00,0) ^ (nt
& 0xff);
204 par
= (par
>> 1)| ( ((filter(pcs
->odd
) ^ oddparity(nt
& 0xff)) & 0x01) * 0x80 );
207 // Transmit reader nonce and reader answer
208 ReaderTransmitPar(mf_nr_ar
, sizeof(mf_nr_ar
), par
);
210 // Receive 4 bit answer
211 len
= ReaderReceive(receivedAnswer
);
214 if (MF_DBGLEVEL
>= 1) Dbprintf("Authentication failed. Card timeout.");
218 memcpy(tmp4
, receivedAnswer
, 4);
219 ntpp
= prng_successor(nt
, 32) ^ crypto1_word(pcs
, 0,0);
221 if (ntpp
!= bytes_to_num(tmp4
, 4)) {
222 if (MF_DBGLEVEL
>= 1) Dbprintf("Authentication failed. Error card response.");
229 int mifare_classic_readblock(struct Crypto1State
*pcs
, uint32_t uid
, uint8_t blockNo
, uint8_t *blockData
)
235 uint8_t* receivedAnswer
= mifare_get_bigbufptr();
237 // command MIFARE_CLASSIC_READBLOCK
238 len
= mifare_sendcmd_short(pcs
, 1, 0x30, blockNo
, receivedAnswer
);
240 if (MF_DBGLEVEL
>= 1) Dbprintf("Cmd Error: %02x", receivedAnswer
[0]);
244 if (MF_DBGLEVEL
>= 1) Dbprintf("Cmd Error: card timeout. len: %x", len
);
248 memcpy(bt
, receivedAnswer
+ 16, 2);
249 AppendCrc14443a(receivedAnswer
, 16);
250 if (bt
[0] != receivedAnswer
[16] || bt
[1] != receivedAnswer
[17]) {
251 if (MF_DBGLEVEL
>= 1) Dbprintf("Cmd CRC response error.");
255 memcpy(blockData
, receivedAnswer
, 16);
259 int mifare_classic_writeblock(struct Crypto1State
*pcs
, uint32_t uid
, uint8_t blockNo
, uint8_t *blockData
)
267 uint8_t d_block
[18], d_block_enc
[18];
268 uint8_t* receivedAnswer
= mifare_get_bigbufptr();
270 // command MIFARE_CLASSIC_WRITEBLOCK
271 len
= mifare_sendcmd_short(pcs
, 1, 0xA0, blockNo
, receivedAnswer
);
273 if ((len
!= 1) || (receivedAnswer
[0] != 0x0A)) { // 0x0a - ACK
274 if (MF_DBGLEVEL
>= 1) Dbprintf("Cmd Error: %02x", receivedAnswer
[0]);
278 memcpy(d_block
, blockData
, 16);
279 AppendCrc14443a(d_block
, 16);
283 for (pos
= 0; pos
< 18; pos
++)
285 d_block_enc
[pos
] = crypto1_byte(pcs
, 0x00, 0) ^ d_block
[pos
];
286 par
= (par
>> 1) | ( ((filter(pcs
->odd
) ^ oddparity(d_block
[pos
])) & 0x01) * 0x20000 );
289 ReaderTransmitPar(d_block_enc
, sizeof(d_block_enc
), par
);
291 // Receive the response
292 len
= ReaderReceive(receivedAnswer
);
295 for (i
= 0; i
< 4; i
++)
296 res
|= (crypto1_bit(pcs
, 0, 0) ^ BIT(receivedAnswer
[0], i
)) << i
;
298 if ((len
!= 1) || (res
!= 0x0A)) {
299 if (MF_DBGLEVEL
>= 1) Dbprintf("Cmd send data2 Error: %02x", res
);
306 int mifare_classic_halt(struct Crypto1State
*pcs
, uint32_t uid
)
312 uint8_t* receivedAnswer
= mifare_get_bigbufptr();
314 len
= mifare_sendcmd_short(pcs
, pcs
== NULL
? 0:1, 0x50, 0x00, receivedAnswer
);
316 if (MF_DBGLEVEL
>= 1) Dbprintf("halt error. response len: %x", len
);
323 // work with emulator memory
324 void emlSetMem(uint8_t *data
, int blockNum
, int blocksCount
) {
325 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
327 memcpy(emCARD
+ blockNum
* 16, data
, blocksCount
* 16);
330 void emlGetMem(uint8_t *data
, int blockNum
, int blocksCount
) {
331 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
333 memcpy(data
, emCARD
+ blockNum
* 16, blocksCount
* 16);
336 void emlGetMemBt(uint8_t *data
, int bytePtr
, int byteCount
) {
337 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
339 memcpy(data
, emCARD
+ bytePtr
, byteCount
);
342 int emlCheckValBl(int blockNum
) {
343 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
344 uint8_t* data
= emCARD
+ blockNum
* 16;
346 if ((data
[0] != (data
[4] ^ 0xff)) || (data
[0] != data
[8]) ||
347 (data
[1] != (data
[5] ^ 0xff)) || (data
[1] != data
[9]) ||
348 (data
[2] != (data
[6] ^ 0xff)) || (data
[2] != data
[10]) ||
349 (data
[3] != (data
[7] ^ 0xff)) || (data
[3] != data
[11]) ||
350 (data
[12] != (data
[13] ^ 0xff)) || (data
[12] != data
[14]) ||
351 (data
[12] != (data
[15] ^ 0xff))
357 int emlGetValBl(uint32_t *blReg
, uint8_t *blBlock
, int blockNum
) {
358 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
359 uint8_t* data
= emCARD
+ blockNum
* 16;
361 if (emlCheckValBl(blockNum
)) {
365 memcpy(blReg
, data
, 4);
371 int emlSetValBl(uint32_t blReg
, uint8_t blBlock
, int blockNum
) {
372 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
373 uint8_t* data
= emCARD
+ blockNum
* 16;
375 memcpy(data
+ 0, &blReg
, 4);
376 memcpy(data
+ 8, &blReg
, 4);
377 blReg
= blReg
^ 0xffffffff;
378 memcpy(data
+ 4, &blReg
, 4);
381 data
[13] = blBlock
^ 0xff;
383 data
[15] = blBlock
^ 0xff;
388 uint64_t emlGetKey(int sectorNum
, int keyType
) {
390 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
392 memcpy(key
, emCARD
+ 3 * 16 + sectorNum
* 4 * 16 + keyType
* 10, 6);
393 return bytes_to_num(key
, 6);
396 void emlClearMem(void) {
399 const uint8_t trailer
[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0x80, 0x69, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
400 const uint8_t uid
[] = {0xe6, 0x84, 0x87, 0xf3, 0x16, 0x88, 0x04, 0x00, 0x46, 0x8e, 0x45, 0x55, 0x4d, 0x70, 0x41, 0x04};
401 uint8_t* emCARD
= eml_get_bigbufptr_cardmem();
403 memset(emCARD
, 0, CARD_MEMORY_LEN
);
405 // fill sectors trailer data
406 for(b
= 3; b
< 256; b
<127?(b
+=4):(b
+=16)) {
407 emlSetMem((uint8_t *)trailer
, b
, 1);
411 emlSetMem((uint8_t *)uid
, 0, 1);