hf mf mifare:
[proxmark3-svn] / armsrc / iso14443a.c
CommitLineData
15c4dc5a 1//-----------------------------------------------------------------------------
b62a5a84 2// Merlok - June 2011, 2012
15c4dc5a 3// Gerhard de Koning Gans - May 2008
534983d7 4// Hagen Fritsch - June 2010
bd20f8f4 5//
6// This code is licensed to you under the terms of the GNU GPL, version 2 or,
7// at your option, any later version. See the LICENSE.txt file for the text of
8// the license.
15c4dc5a 9//-----------------------------------------------------------------------------
bd20f8f4 10// Routines to support ISO 14443 type A.
11//-----------------------------------------------------------------------------
12
e30c654b 13#include "proxmark3.h"
15c4dc5a 14#include "apps.h"
f7e3ed82 15#include "util.h"
9ab7a6c7 16#include "string.h"
902cb3c0 17#include "cmd.h"
9ab7a6c7 18
15c4dc5a 19#include "iso14443crc.h"
534983d7 20#include "iso14443a.h"
20f9a2a1
M
21#include "crapto1.h"
22#include "mifareutil.h"
3000dc4e 23#include "BigBuf.h"
534983d7 24static uint32_t iso14a_timeout;
1e262141 25int rsamples = 0;
1e262141 26uint8_t trigger = 0;
b0127e65 27// the block number for the ISO14443-4 PCB
28static uint8_t iso14_pcb_blocknum = 0;
15c4dc5a 29
7bc95e2e 30//
31// ISO14443 timing:
32//
33// minimum time between the start bits of consecutive transfers from reader to tag: 7000 carrier (13.56Mhz) cycles
34#define REQUEST_GUARD_TIME (7000/16 + 1)
35// minimum time between last modulation of tag and next start bit from reader to tag: 1172 carrier cycles
36#define FRAME_DELAY_TIME_PICC_TO_PCD (1172/16 + 1)
37// bool LastCommandWasRequest = FALSE;
38
39//
40// Total delays including SSC-Transfers between ARM and FPGA. These are in carrier clock cycles (1/13,56MHz)
41//
d714d3ef 42// When the PM acts as reader and is receiving tag data, it takes
43// 3 ticks delay in the AD converter
44// 16 ticks until the modulation detector completes and sets curbit
45// 8 ticks until bit_to_arm is assigned from curbit
46// 8*16 ticks for the transfer from FPGA to ARM
7bc95e2e 47// 4*16 ticks until we measure the time
48// - 8*16 ticks because we measure the time of the previous transfer
d714d3ef 49#define DELAY_AIR2ARM_AS_READER (3 + 16 + 8 + 8*16 + 4*16 - 8*16)
7bc95e2e 50
51// When the PM acts as a reader and is sending, it takes
52// 4*16 ticks until we can write data to the sending hold register
53// 8*16 ticks until the SHR is transferred to the Sending Shift Register
54// 8 ticks until the first transfer starts
55// 8 ticks later the FPGA samples the data
56// 1 tick to assign mod_sig_coil
57#define DELAY_ARM2AIR_AS_READER (4*16 + 8*16 + 8 + 8 + 1)
58
59// When the PM acts as tag and is receiving it takes
d714d3ef 60// 2 ticks delay in the RF part (for the first falling edge),
7bc95e2e 61// 3 ticks for the A/D conversion,
62// 8 ticks on average until the start of the SSC transfer,
63// 8 ticks until the SSC samples the first data
64// 7*16 ticks to complete the transfer from FPGA to ARM
65// 8 ticks until the next ssp_clk rising edge
d714d3ef 66// 4*16 ticks until we measure the time
7bc95e2e 67// - 8*16 ticks because we measure the time of the previous transfer
d714d3ef 68#define DELAY_AIR2ARM_AS_TAG (2 + 3 + 8 + 8 + 7*16 + 8 + 4*16 - 8*16)
7bc95e2e 69
70// The FPGA will report its internal sending delay in
71uint16_t FpgaSendQueueDelay;
72// the 5 first bits are the number of bits buffered in mod_sig_buf
73// the last three bits are the remaining ticks/2 after the mod_sig_buf shift
74#define DELAY_FPGA_QUEUE (FpgaSendQueueDelay<<1)
75
76// When the PM acts as tag and is sending, it takes
d714d3ef 77// 4*16 ticks until we can write data to the sending hold register
7bc95e2e 78// 8*16 ticks until the SHR is transferred to the Sending Shift Register
79// 8 ticks until the first transfer starts
80// 8 ticks later the FPGA samples the data
81// + a varying number of ticks in the FPGA Delay Queue (mod_sig_buf)
82// + 1 tick to assign mod_sig_coil
d714d3ef 83#define DELAY_ARM2AIR_AS_TAG (4*16 + 8*16 + 8 + 8 + DELAY_FPGA_QUEUE + 1)
7bc95e2e 84
85// When the PM acts as sniffer and is receiving tag data, it takes
86// 3 ticks A/D conversion
d714d3ef 87// 14 ticks to complete the modulation detection
88// 8 ticks (on average) until the result is stored in to_arm
7bc95e2e 89// + the delays in transferring data - which is the same for
90// sniffing reader and tag data and therefore not relevant
d714d3ef 91#define DELAY_TAG_AIR2ARM_AS_SNIFFER (3 + 14 + 8)
7bc95e2e 92
d714d3ef 93// When the PM acts as sniffer and is receiving reader data, it takes
94// 2 ticks delay in analogue RF receiver (for the falling edge of the
95// start bit, which marks the start of the communication)
7bc95e2e 96// 3 ticks A/D conversion
d714d3ef 97// 8 ticks on average until the data is stored in to_arm.
7bc95e2e 98// + the delays in transferring data - which is the same for
99// sniffing reader and tag data and therefore not relevant
d714d3ef 100#define DELAY_READER_AIR2ARM_AS_SNIFFER (2 + 3 + 8)
7bc95e2e 101
102//variables used for timing purposes:
103//these are in ssp_clk cycles:
6a1f2d82 104static uint32_t NextTransferTime;
105static uint32_t LastTimeProxToAirStart;
106static uint32_t LastProxToAirDuration;
7bc95e2e 107
108
109
8f51ddb0 110// CARD TO READER - manchester
72934aa3 111// Sequence D: 11110000 modulation with subcarrier during first half
112// Sequence E: 00001111 modulation with subcarrier during second half
113// Sequence F: 00000000 no modulation with subcarrier
8f51ddb0 114// READER TO CARD - miller
72934aa3 115// Sequence X: 00001100 drop after half a period
116// Sequence Y: 00000000 no drop
117// Sequence Z: 11000000 drop at start
118#define SEC_D 0xf0
119#define SEC_E 0x0f
120#define SEC_F 0x00
121#define SEC_X 0x0c
122#define SEC_Y 0x00
123#define SEC_Z 0xc0
15c4dc5a 124
1e262141 125const uint8_t OddByteParity[256] = {
15c4dc5a 126 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
127 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
128 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
129 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
130 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
131 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
132 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
133 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
134 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
135 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
136 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
137 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
138 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
139 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
140 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
141 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
142};
143
19a700a8 144
902cb3c0 145void iso14a_set_trigger(bool enable) {
534983d7 146 trigger = enable;
147}
148
d19929cb 149
b0127e65 150void iso14a_set_timeout(uint32_t timeout) {
151 iso14a_timeout = timeout;
19a700a8 152 if(MF_DBGLEVEL >= 3) Dbprintf("ISO14443A Timeout set to %ld (%dms)", iso14a_timeout, iso14a_timeout / 106);
b0127e65 153}
8556b852 154
19a700a8 155
156void iso14a_set_ATS_timeout(uint8_t *ats) {
157
158 uint8_t tb1;
159 uint8_t fwi;
160 uint32_t fwt;
161
162 if (ats[0] > 1) { // there is a format byte T0
163 if ((ats[1] & 0x20) == 0x20) { // there is an interface byte TB(1)
164 if ((ats[1] & 0x10) == 0x10) { // there is an interface byte TA(1) preceding TB(1)
165 tb1 = ats[3];
166 } else {
167 tb1 = ats[2];
168 }
169 fwi = (tb1 & 0xf0) >> 4; // frame waiting indicator (FWI)
170 fwt = 256 * 16 * (1 << fwi); // frame waiting time (FWT) in 1/fc
171
172 iso14a_set_timeout(fwt/(8*16));
173 }
174 }
175}
176
177
15c4dc5a 178//-----------------------------------------------------------------------------
179// Generate the parity value for a byte sequence
e30c654b 180//
15c4dc5a 181//-----------------------------------------------------------------------------
20f9a2a1
M
182byte_t oddparity (const byte_t bt)
183{
5f6d6c90 184 return OddByteParity[bt];
20f9a2a1
M
185}
186
6a1f2d82 187void GetParity(const uint8_t *pbtCmd, uint16_t iLen, uint8_t *par)
15c4dc5a 188{
6a1f2d82 189 uint16_t paritybit_cnt = 0;
190 uint16_t paritybyte_cnt = 0;
191 uint8_t parityBits = 0;
192
193 for (uint16_t i = 0; i < iLen; i++) {
194 // Generate the parity bits
195 parityBits |= ((OddByteParity[pbtCmd[i]]) << (7-paritybit_cnt));
196 if (paritybit_cnt == 7) {
197 par[paritybyte_cnt] = parityBits; // save 8 Bits parity
198 parityBits = 0; // and advance to next Parity Byte
199 paritybyte_cnt++;
200 paritybit_cnt = 0;
201 } else {
202 paritybit_cnt++;
203 }
5f6d6c90 204 }
6a1f2d82 205
206 // save remaining parity bits
207 par[paritybyte_cnt] = parityBits;
208
15c4dc5a 209}
210
534983d7 211void AppendCrc14443a(uint8_t* data, int len)
15c4dc5a 212{
5f6d6c90 213 ComputeCrc14443(CRC_14443_A,data,len,data+len,data+len+1);
15c4dc5a 214}
215
7bc95e2e 216//=============================================================================
217// ISO 14443 Type A - Miller decoder
218//=============================================================================
219// Basics:
220// This decoder is used when the PM3 acts as a tag.
221// The reader will generate "pauses" by temporarily switching of the field.
222// At the PM3 antenna we will therefore measure a modulated antenna voltage.
223// The FPGA does a comparison with a threshold and would deliver e.g.:
224// ........ 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 .......
225// The Miller decoder needs to identify the following sequences:
226// 2 (or 3) ticks pause followed by 6 (or 5) ticks unmodulated: pause at beginning - Sequence Z ("start of communication" or a "0")
227// 8 ticks without a modulation: no pause - Sequence Y (a "0" or "end of communication" or "no information")
228// 4 ticks unmodulated followed by 2 (or 3) ticks pause: pause in second half - Sequence X (a "1")
229// Note 1: the bitstream may start at any time. We therefore need to sync.
230// Note 2: the interpretation of Sequence Y and Z depends on the preceding sequence.
15c4dc5a 231//-----------------------------------------------------------------------------
b62a5a84 232static tUart Uart;
15c4dc5a 233
d7aa3739 234// Lookup-Table to decide if 4 raw bits are a modulation.
235// We accept two or three consecutive "0" in any position with the rest "1"
236const bool Mod_Miller_LUT[] = {
237 TRUE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE,
238 TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE
239};
240#define IsMillerModulationNibble1(b) (Mod_Miller_LUT[(b & 0x00F0) >> 4])
241#define IsMillerModulationNibble2(b) (Mod_Miller_LUT[(b & 0x000F)])
242
7bc95e2e 243void UartReset()
15c4dc5a 244{
7bc95e2e 245 Uart.state = STATE_UNSYNCD;
246 Uart.bitCount = 0;
247 Uart.len = 0; // number of decoded data bytes
6a1f2d82 248 Uart.parityLen = 0; // number of decoded parity bytes
7bc95e2e 249 Uart.shiftReg = 0; // shiftreg to hold decoded data bits
6a1f2d82 250 Uart.parityBits = 0; // holds 8 parity bits
7bc95e2e 251 Uart.twoBits = 0x0000; // buffer for 2 Bits
252 Uart.highCnt = 0;
253 Uart.startTime = 0;
254 Uart.endTime = 0;
255}
15c4dc5a 256
6a1f2d82 257void UartInit(uint8_t *data, uint8_t *parity)
258{
259 Uart.output = data;
260 Uart.parity = parity;
261 UartReset();
262}
d714d3ef 263
7bc95e2e 264// use parameter non_real_time to provide a timestamp. Set to 0 if the decoder should measure real time
265static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time)
266{
15c4dc5a 267
7bc95e2e 268 Uart.twoBits = (Uart.twoBits << 8) | bit;
269
0c8d25eb 270 if (Uart.state == STATE_UNSYNCD) { // not yet synced
3fe4ff4f 271
0c8d25eb 272 if (Uart.highCnt < 2) { // wait for a stable unmodulated signal
7bc95e2e 273 if (Uart.twoBits == 0xffff) {
274 Uart.highCnt++;
275 } else {
276 Uart.highCnt = 0;
15c4dc5a 277 }
7bc95e2e 278 } else {
0c8d25eb 279 Uart.syncBit = 0xFFFF; // not set
280 // we look for a ...1111111100x11111xxxxxx pattern (the start bit)
281 if ((Uart.twoBits & 0xDF00) == 0x1F00) Uart.syncBit = 8; // mask is 11x11111 xxxxxxxx,
282 // check for 00x11111 xxxxxxxx
283 else if ((Uart.twoBits & 0xEF80) == 0x8F80) Uart.syncBit = 7; // both masks shifted right one bit, left padded with '1'
284 else if ((Uart.twoBits & 0xF7C0) == 0xC7C0) Uart.syncBit = 6; // ...
285 else if ((Uart.twoBits & 0xFBE0) == 0xE3E0) Uart.syncBit = 5;
286 else if ((Uart.twoBits & 0xFDF0) == 0xF1F0) Uart.syncBit = 4;
287 else if ((Uart.twoBits & 0xFEF8) == 0xF8F8) Uart.syncBit = 3;
288 else if ((Uart.twoBits & 0xFF7C) == 0xFC7C) Uart.syncBit = 2;
289 else if ((Uart.twoBits & 0xFFBE) == 0xFE3E) Uart.syncBit = 1;
290 if (Uart.syncBit != 0xFFFF) { // found a sync bit
7bc95e2e 291 Uart.startTime = non_real_time?non_real_time:(GetCountSspClk() & 0xfffffff8);
292 Uart.startTime -= Uart.syncBit;
d7aa3739 293 Uart.endTime = Uart.startTime;
7bc95e2e 294 Uart.state = STATE_START_OF_COMMUNICATION;
15c4dc5a 295 }
7bc95e2e 296 }
15c4dc5a 297
7bc95e2e 298 } else {
15c4dc5a 299
d7aa3739 300 if (IsMillerModulationNibble1(Uart.twoBits >> Uart.syncBit)) {
301 if (IsMillerModulationNibble2(Uart.twoBits >> Uart.syncBit)) { // Modulation in both halves - error
302 UartReset();
d7aa3739 303 } else { // Modulation in first half = Sequence Z = logic "0"
7bc95e2e 304 if (Uart.state == STATE_MILLER_X) { // error - must not follow after X
305 UartReset();
7bc95e2e 306 } else {
307 Uart.bitCount++;
308 Uart.shiftReg = (Uart.shiftReg >> 1); // add a 0 to the shiftreg
309 Uart.state = STATE_MILLER_Z;
310 Uart.endTime = Uart.startTime + 8*(9*Uart.len + Uart.bitCount + 1) - 6;
311 if(Uart.bitCount >= 9) { // if we decoded a full byte (including parity)
312 Uart.output[Uart.len++] = (Uart.shiftReg & 0xff);
313 Uart.parityBits <<= 1; // make room for the parity bit
314 Uart.parityBits |= ((Uart.shiftReg >> 8) & 0x01); // store parity bit
315 Uart.bitCount = 0;
316 Uart.shiftReg = 0;
6a1f2d82 317 if((Uart.len&0x0007) == 0) { // every 8 data bytes
318 Uart.parity[Uart.parityLen++] = Uart.parityBits; // store 8 parity bits
319 Uart.parityBits = 0;
320 }
15c4dc5a 321 }
7bc95e2e 322 }
d7aa3739 323 }
324 } else {
325 if (IsMillerModulationNibble2(Uart.twoBits >> Uart.syncBit)) { // Modulation second half = Sequence X = logic "1"
7bc95e2e 326 Uart.bitCount++;
327 Uart.shiftReg = (Uart.shiftReg >> 1) | 0x100; // add a 1 to the shiftreg
328 Uart.state = STATE_MILLER_X;
329 Uart.endTime = Uart.startTime + 8*(9*Uart.len + Uart.bitCount + 1) - 2;
330 if(Uart.bitCount >= 9) { // if we decoded a full byte (including parity)
331 Uart.output[Uart.len++] = (Uart.shiftReg & 0xff);
332 Uart.parityBits <<= 1; // make room for the new parity bit
333 Uart.parityBits |= ((Uart.shiftReg >> 8) & 0x01); // store parity bit
334 Uart.bitCount = 0;
335 Uart.shiftReg = 0;
6a1f2d82 336 if ((Uart.len&0x0007) == 0) { // every 8 data bytes
337 Uart.parity[Uart.parityLen++] = Uart.parityBits; // store 8 parity bits
338 Uart.parityBits = 0;
339 }
7bc95e2e 340 }
d7aa3739 341 } else { // no modulation in both halves - Sequence Y
7bc95e2e 342 if (Uart.state == STATE_MILLER_Z || Uart.state == STATE_MILLER_Y) { // Y after logic "0" - End of Communication
15c4dc5a 343 Uart.state = STATE_UNSYNCD;
6a1f2d82 344 Uart.bitCount--; // last "0" was part of EOC sequence
345 Uart.shiftReg <<= 1; // drop it
346 if(Uart.bitCount > 0) { // if we decoded some bits
347 Uart.shiftReg >>= (9 - Uart.bitCount); // right align them
348 Uart.output[Uart.len++] = (Uart.shiftReg & 0xff); // add last byte to the output
349 Uart.parityBits <<= 1; // add a (void) parity bit
350 Uart.parityBits <<= (8 - (Uart.len&0x0007)); // left align parity bits
351 Uart.parity[Uart.parityLen++] = Uart.parityBits; // and store it
352 return TRUE;
353 } else if (Uart.len & 0x0007) { // there are some parity bits to store
354 Uart.parityBits <<= (8 - (Uart.len&0x0007)); // left align remaining parity bits
355 Uart.parity[Uart.parityLen++] = Uart.parityBits; // and store them
52bfb955 356 }
357 if (Uart.len) {
6a1f2d82 358 return TRUE; // we are finished with decoding the raw data sequence
52bfb955 359 } else {
0c8d25eb 360 UartReset(); // Nothing received - start over
361 Uart.highCnt = 1;
7bc95e2e 362 }
15c4dc5a 363 }
7bc95e2e 364 if (Uart.state == STATE_START_OF_COMMUNICATION) { // error - must not follow directly after SOC
365 UartReset();
0c8d25eb 366 Uart.highCnt = 1;
7bc95e2e 367 } else { // a logic "0"
368 Uart.bitCount++;
369 Uart.shiftReg = (Uart.shiftReg >> 1); // add a 0 to the shiftreg
370 Uart.state = STATE_MILLER_Y;
371 if(Uart.bitCount >= 9) { // if we decoded a full byte (including parity)
372 Uart.output[Uart.len++] = (Uart.shiftReg & 0xff);
373 Uart.parityBits <<= 1; // make room for the parity bit
374 Uart.parityBits |= ((Uart.shiftReg >> 8) & 0x01); // store parity bit
375 Uart.bitCount = 0;
376 Uart.shiftReg = 0;
6a1f2d82 377 if ((Uart.len&0x0007) == 0) { // every 8 data bytes
378 Uart.parity[Uart.parityLen++] = Uart.parityBits; // store 8 parity bits
379 Uart.parityBits = 0;
380 }
15c4dc5a 381 }
382 }
d7aa3739 383 }
15c4dc5a 384 }
7bc95e2e 385
386 }
15c4dc5a 387
7bc95e2e 388 return FALSE; // not finished yet, need more data
15c4dc5a 389}
390
7bc95e2e 391
392
15c4dc5a 393//=============================================================================
e691fc45 394// ISO 14443 Type A - Manchester decoder
15c4dc5a 395//=============================================================================
e691fc45 396// Basics:
7bc95e2e 397// This decoder is used when the PM3 acts as a reader.
e691fc45 398// The tag will modulate the reader field by asserting different loads to it. As a consequence, the voltage
399// at the reader antenna will be modulated as well. The FPGA detects the modulation for us and would deliver e.g. the following:
400// ........ 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .......
401// The Manchester decoder needs to identify the following sequences:
402// 4 ticks modulated followed by 4 ticks unmodulated: Sequence D = 1 (also used as "start of communication")
403// 4 ticks unmodulated followed by 4 ticks modulated: Sequence E = 0
404// 8 ticks unmodulated: Sequence F = end of communication
405// 8 ticks modulated: A collision. Save the collision position and treat as Sequence D
7bc95e2e 406// Note 1: the bitstream may start at any time. We therefore need to sync.
e691fc45 407// Note 2: parameter offset is used to determine the position of the parity bits (required for the anticollision command only)
b62a5a84 408static tDemod Demod;
15c4dc5a 409
d7aa3739 410// Lookup-Table to decide if 4 raw bits are a modulation.
d714d3ef 411// We accept three or four "1" in any position
7bc95e2e 412const bool Mod_Manchester_LUT[] = {
d7aa3739 413 FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,
d714d3ef 414 FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE
7bc95e2e 415};
416
417#define IsManchesterModulationNibble1(b) (Mod_Manchester_LUT[(b & 0x00F0) >> 4])
418#define IsManchesterModulationNibble2(b) (Mod_Manchester_LUT[(b & 0x000F)])
15c4dc5a 419
2f2d9fc5 420
7bc95e2e 421void DemodReset()
e691fc45 422{
7bc95e2e 423 Demod.state = DEMOD_UNSYNCD;
424 Demod.len = 0; // number of decoded data bytes
6a1f2d82 425 Demod.parityLen = 0;
7bc95e2e 426 Demod.shiftReg = 0; // shiftreg to hold decoded data bits
427 Demod.parityBits = 0; //
428 Demod.collisionPos = 0; // Position of collision bit
429 Demod.twoBits = 0xffff; // buffer for 2 Bits
430 Demod.highCnt = 0;
431 Demod.startTime = 0;
432 Demod.endTime = 0;
e691fc45 433}
15c4dc5a 434
6a1f2d82 435void DemodInit(uint8_t *data, uint8_t *parity)
436{
437 Demod.output = data;
438 Demod.parity = parity;
439 DemodReset();
440}
441
7bc95e2e 442// use parameter non_real_time to provide a timestamp. Set to 0 if the decoder should measure real time
443static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non_real_time)
e691fc45 444{
7bc95e2e 445
446 Demod.twoBits = (Demod.twoBits << 8) | bit;
e691fc45 447
7bc95e2e 448 if (Demod.state == DEMOD_UNSYNCD) {
449
450 if (Demod.highCnt < 2) { // wait for a stable unmodulated signal
451 if (Demod.twoBits == 0x0000) {
452 Demod.highCnt++;
453 } else {
454 Demod.highCnt = 0;
455 }
456 } else {
457 Demod.syncBit = 0xFFFF; // not set
458 if ((Demod.twoBits & 0x7700) == 0x7000) Demod.syncBit = 7;
459 else if ((Demod.twoBits & 0x3B80) == 0x3800) Demod.syncBit = 6;
460 else if ((Demod.twoBits & 0x1DC0) == 0x1C00) Demod.syncBit = 5;
461 else if ((Demod.twoBits & 0x0EE0) == 0x0E00) Demod.syncBit = 4;
462 else if ((Demod.twoBits & 0x0770) == 0x0700) Demod.syncBit = 3;
463 else if ((Demod.twoBits & 0x03B8) == 0x0380) Demod.syncBit = 2;
464 else if ((Demod.twoBits & 0x01DC) == 0x01C0) Demod.syncBit = 1;
465 else if ((Demod.twoBits & 0x00EE) == 0x00E0) Demod.syncBit = 0;
d7aa3739 466 if (Demod.syncBit != 0xFFFF) {
7bc95e2e 467 Demod.startTime = non_real_time?non_real_time:(GetCountSspClk() & 0xfffffff8);
468 Demod.startTime -= Demod.syncBit;
469 Demod.bitCount = offset; // number of decoded data bits
e691fc45 470 Demod.state = DEMOD_MANCHESTER_DATA;
2f2d9fc5 471 }
7bc95e2e 472 }
15c4dc5a 473
7bc95e2e 474 } else {
15c4dc5a 475
7bc95e2e 476 if (IsManchesterModulationNibble1(Demod.twoBits >> Demod.syncBit)) { // modulation in first half
477 if (IsManchesterModulationNibble2(Demod.twoBits >> Demod.syncBit)) { // ... and in second half = collision
e691fc45 478 if (!Demod.collisionPos) {
479 Demod.collisionPos = (Demod.len << 3) + Demod.bitCount;
480 }
481 } // modulation in first half only - Sequence D = 1
7bc95e2e 482 Demod.bitCount++;
483 Demod.shiftReg = (Demod.shiftReg >> 1) | 0x100; // in both cases, add a 1 to the shiftreg
484 if(Demod.bitCount == 9) { // if we decoded a full byte (including parity)
e691fc45 485 Demod.output[Demod.len++] = (Demod.shiftReg & 0xff);
7bc95e2e 486 Demod.parityBits <<= 1; // make room for the parity bit
e691fc45 487 Demod.parityBits |= ((Demod.shiftReg >> 8) & 0x01); // store parity bit
488 Demod.bitCount = 0;
489 Demod.shiftReg = 0;
6a1f2d82 490 if((Demod.len&0x0007) == 0) { // every 8 data bytes
491 Demod.parity[Demod.parityLen++] = Demod.parityBits; // store 8 parity bits
492 Demod.parityBits = 0;
493 }
15c4dc5a 494 }
7bc95e2e 495 Demod.endTime = Demod.startTime + 8*(9*Demod.len + Demod.bitCount + 1) - 4;
496 } else { // no modulation in first half
497 if (IsManchesterModulationNibble2(Demod.twoBits >> Demod.syncBit)) { // and modulation in second half = Sequence E = 0
e691fc45 498 Demod.bitCount++;
7bc95e2e 499 Demod.shiftReg = (Demod.shiftReg >> 1); // add a 0 to the shiftreg
e691fc45 500 if(Demod.bitCount >= 9) { // if we decoded a full byte (including parity)
e691fc45 501 Demod.output[Demod.len++] = (Demod.shiftReg & 0xff);
7bc95e2e 502 Demod.parityBits <<= 1; // make room for the new parity bit
e691fc45 503 Demod.parityBits |= ((Demod.shiftReg >> 8) & 0x01); // store parity bit
504 Demod.bitCount = 0;
505 Demod.shiftReg = 0;
6a1f2d82 506 if ((Demod.len&0x0007) == 0) { // every 8 data bytes
507 Demod.parity[Demod.parityLen++] = Demod.parityBits; // store 8 parity bits1
508 Demod.parityBits = 0;
509 }
15c4dc5a 510 }
7bc95e2e 511 Demod.endTime = Demod.startTime + 8*(9*Demod.len + Demod.bitCount + 1);
e691fc45 512 } else { // no modulation in both halves - End of communication
6a1f2d82 513 if(Demod.bitCount > 0) { // there are some remaining data bits
514 Demod.shiftReg >>= (9 - Demod.bitCount); // right align the decoded bits
515 Demod.output[Demod.len++] = Demod.shiftReg & 0xff; // and add them to the output
516 Demod.parityBits <<= 1; // add a (void) parity bit
517 Demod.parityBits <<= (8 - (Demod.len&0x0007)); // left align remaining parity bits
518 Demod.parity[Demod.parityLen++] = Demod.parityBits; // and store them
519 return TRUE;
520 } else if (Demod.len & 0x0007) { // there are some parity bits to store
521 Demod.parityBits <<= (8 - (Demod.len&0x0007)); // left align remaining parity bits
522 Demod.parity[Demod.parityLen++] = Demod.parityBits; // and store them
52bfb955 523 }
524 if (Demod.len) {
d7aa3739 525 return TRUE; // we are finished with decoding the raw data sequence
526 } else { // nothing received. Start over
527 DemodReset();
e691fc45 528 }
15c4dc5a 529 }
7bc95e2e 530 }
e691fc45 531
532 }
15c4dc5a 533
e691fc45 534 return FALSE; // not finished yet, need more data
15c4dc5a 535}
536
537//=============================================================================
538// Finally, a `sniffer' for ISO 14443 Type A
539// Both sides of communication!
540//=============================================================================
541
542//-----------------------------------------------------------------------------
543// Record the sequence of commands sent by the reader to the tag, with
544// triggering so that we start recording at the point that the tag is moved
545// near the reader.
546//-----------------------------------------------------------------------------
5cd9ec01
M
547void RAMFUNC SnoopIso14443a(uint8_t param) {
548 // param:
549 // bit 0 - trigger from first card answer
550 // bit 1 - trigger from first reader 7-bit request
551
552 LEDsoff();
5cd9ec01 553
09ffd16e 554 iso14443a_setup(FPGA_HF_ISO14443A_SNIFFER);
555
f71f4deb 556 // Allocate memory from BigBuf for some buffers
557 // free all previous allocations first
558 BigBuf_free();
559
5cd9ec01 560 // The command (reader -> tag) that we're receiving.
f71f4deb 561 uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
562 uint8_t *receivedCmdPar = BigBuf_malloc(MAX_PARITY_SIZE);
6a1f2d82 563
5cd9ec01 564 // The response (tag -> reader) that we're receiving.
f71f4deb 565 uint8_t *receivedResponse = BigBuf_malloc(MAX_FRAME_SIZE);
566 uint8_t *receivedResponsePar = BigBuf_malloc(MAX_PARITY_SIZE);
5cd9ec01
M
567
568 // The DMA buffer, used to stream samples from the FPGA
f71f4deb 569 uint8_t *dmaBuf = BigBuf_malloc(DMA_BUFFER_SIZE);
570
571 // init trace buffer
3000dc4e
MHS
572 clear_trace();
573 set_tracing(TRUE);
f71f4deb 574
7bc95e2e 575 uint8_t *data = dmaBuf;
576 uint8_t previous_data = 0;
5cd9ec01
M
577 int maxDataLen = 0;
578 int dataLen = 0;
7bc95e2e 579 bool TagIsActive = FALSE;
580 bool ReaderIsActive = FALSE;
581
5cd9ec01 582 // Set up the demodulator for tag -> reader responses.
6a1f2d82 583 DemodInit(receivedResponse, receivedResponsePar);
584
5cd9ec01 585 // Set up the demodulator for the reader -> tag commands
6a1f2d82 586 UartInit(receivedCmd, receivedCmdPar);
587
7bc95e2e 588 // Setup and start DMA.
5cd9ec01 589 FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE);
7bc95e2e 590
09ffd16e 591 // We won't start recording the frames that we acquire until we trigger;
592 // a good trigger condition to get started is probably when we see a
593 // response from the tag.
594 // triggered == FALSE -- to wait first for card
595 bool triggered = !(param & 0x03);
596
5cd9ec01 597 // And now we loop, receiving samples.
7bc95e2e 598 for(uint32_t rsamples = 0; TRUE; ) {
599
5cd9ec01
M
600 if(BUTTON_PRESS()) {
601 DbpString("cancelled by button");
7bc95e2e 602 break;
5cd9ec01 603 }
15c4dc5a 604
5cd9ec01
M
605 LED_A_ON();
606 WDT_HIT();
15c4dc5a 607
5cd9ec01
M
608 int register readBufDataP = data - dmaBuf;
609 int register dmaBufDataP = DMA_BUFFER_SIZE - AT91C_BASE_PDC_SSC->PDC_RCR;
610 if (readBufDataP <= dmaBufDataP){
611 dataLen = dmaBufDataP - readBufDataP;
612 } else {
7bc95e2e 613 dataLen = DMA_BUFFER_SIZE - readBufDataP + dmaBufDataP;
5cd9ec01
M
614 }
615 // test for length of buffer
616 if(dataLen > maxDataLen) {
617 maxDataLen = dataLen;
f71f4deb 618 if(dataLen > (9 * DMA_BUFFER_SIZE / 10)) {
7bc95e2e 619 Dbprintf("blew circular buffer! dataLen=%d", dataLen);
620 break;
5cd9ec01
M
621 }
622 }
623 if(dataLen < 1) continue;
624
625 // primary buffer was stopped( <-- we lost data!
626 if (!AT91C_BASE_PDC_SSC->PDC_RCR) {
627 AT91C_BASE_PDC_SSC->PDC_RPR = (uint32_t) dmaBuf;
628 AT91C_BASE_PDC_SSC->PDC_RCR = DMA_BUFFER_SIZE;
7bc95e2e 629 Dbprintf("RxEmpty ERROR!!! data length:%d", dataLen); // temporary
5cd9ec01
M
630 }
631 // secondary buffer sets as primary, secondary buffer was stopped
632 if (!AT91C_BASE_PDC_SSC->PDC_RNCR) {
633 AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) dmaBuf;
634 AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
635 }
636
637 LED_A_OFF();
7bc95e2e 638
639 if (rsamples & 0x01) { // Need two samples to feed Miller and Manchester-Decoder
3be2a5ae 640
7bc95e2e 641 if(!TagIsActive) { // no need to try decoding reader data if the tag is sending
642 uint8_t readerdata = (previous_data & 0xF0) | (*data >> 4);
643 if (MillerDecoding(readerdata, (rsamples-1)*4)) {
644 LED_C_ON();
5cd9ec01 645
7bc95e2e 646 // check - if there is a short 7bit request from reader
647 if ((!triggered) && (param & 0x02) && (Uart.len == 1) && (Uart.bitCount == 7)) triggered = TRUE;
5cd9ec01 648
7bc95e2e 649 if(triggered) {
6a1f2d82 650 if (!LogTrace(receivedCmd,
651 Uart.len,
652 Uart.startTime*16 - DELAY_READER_AIR2ARM_AS_SNIFFER,
653 Uart.endTime*16 - DELAY_READER_AIR2ARM_AS_SNIFFER,
654 Uart.parity,
655 TRUE)) break;
7bc95e2e 656 }
657 /* And ready to receive another command. */
658 UartReset();
659 /* And also reset the demod code, which might have been */
660 /* false-triggered by the commands from the reader. */
661 DemodReset();
662 LED_B_OFF();
663 }
664 ReaderIsActive = (Uart.state != STATE_UNSYNCD);
5cd9ec01 665 }
3be2a5ae 666
7bc95e2e 667 if(!ReaderIsActive) { // no need to try decoding tag data if the reader is sending - and we cannot afford the time
668 uint8_t tagdata = (previous_data << 4) | (*data & 0x0F);
669 if(ManchesterDecoding(tagdata, 0, (rsamples-1)*4)) {
670 LED_B_ON();
5cd9ec01 671
6a1f2d82 672 if (!LogTrace(receivedResponse,
673 Demod.len,
674 Demod.startTime*16 - DELAY_TAG_AIR2ARM_AS_SNIFFER,
675 Demod.endTime*16 - DELAY_TAG_AIR2ARM_AS_SNIFFER,
676 Demod.parity,
677 FALSE)) break;
5cd9ec01 678
7bc95e2e 679 if ((!triggered) && (param & 0x01)) triggered = TRUE;
5cd9ec01 680
7bc95e2e 681 // And ready to receive another response.
682 DemodReset();
683 LED_C_OFF();
684 }
685 TagIsActive = (Demod.state != DEMOD_UNSYNCD);
686 }
5cd9ec01
M
687 }
688
7bc95e2e 689 previous_data = *data;
690 rsamples++;
5cd9ec01 691 data++;
d714d3ef 692 if(data == dmaBuf + DMA_BUFFER_SIZE) {
5cd9ec01
M
693 data = dmaBuf;
694 }
695 } // main cycle
696
697 DbpString("COMMAND FINISHED");
15c4dc5a 698
7bc95e2e 699 FpgaDisableSscDma();
700 Dbprintf("maxDataLen=%d, Uart.state=%x, Uart.len=%d", maxDataLen, Uart.state, Uart.len);
3000dc4e 701 Dbprintf("traceLen=%d, Uart.output[0]=%08x", BigBuf_get_traceLen(), (uint32_t)Uart.output[0]);
5cd9ec01 702 LEDsoff();
15c4dc5a 703}
704
15c4dc5a 705//-----------------------------------------------------------------------------
706// Prepare tag messages
707//-----------------------------------------------------------------------------
6a1f2d82 708static void CodeIso14443aAsTagPar(const uint8_t *cmd, uint16_t len, uint8_t *parity)
15c4dc5a 709{
8f51ddb0 710 ToSendReset();
15c4dc5a 711
712 // Correction bit, might be removed when not needed
713 ToSendStuffBit(0);
714 ToSendStuffBit(0);
715 ToSendStuffBit(0);
716 ToSendStuffBit(0);
717 ToSendStuffBit(1); // 1
718 ToSendStuffBit(0);
719 ToSendStuffBit(0);
720 ToSendStuffBit(0);
8f51ddb0 721
15c4dc5a 722 // Send startbit
72934aa3 723 ToSend[++ToSendMax] = SEC_D;
7bc95e2e 724 LastProxToAirDuration = 8 * ToSendMax - 4;
15c4dc5a 725
6a1f2d82 726 for(uint16_t i = 0; i < len; i++) {
8f51ddb0 727 uint8_t b = cmd[i];
15c4dc5a 728
729 // Data bits
6a1f2d82 730 for(uint16_t j = 0; j < 8; j++) {
15c4dc5a 731 if(b & 1) {
72934aa3 732 ToSend[++ToSendMax] = SEC_D;
15c4dc5a 733 } else {
72934aa3 734 ToSend[++ToSendMax] = SEC_E;
8f51ddb0
M
735 }
736 b >>= 1;
737 }
15c4dc5a 738
0014cb46 739 // Get the parity bit
6a1f2d82 740 if (parity[i>>3] & (0x80>>(i&0x0007))) {
8f51ddb0 741 ToSend[++ToSendMax] = SEC_D;
7bc95e2e 742 LastProxToAirDuration = 8 * ToSendMax - 4;
15c4dc5a 743 } else {
72934aa3 744 ToSend[++ToSendMax] = SEC_E;
7bc95e2e 745 LastProxToAirDuration = 8 * ToSendMax;
15c4dc5a 746 }
8f51ddb0 747 }
15c4dc5a 748
8f51ddb0
M
749 // Send stopbit
750 ToSend[++ToSendMax] = SEC_F;
15c4dc5a 751
8f51ddb0
M
752 // Convert from last byte pos to length
753 ToSendMax++;
8f51ddb0
M
754}
755
6a1f2d82 756static void CodeIso14443aAsTag(const uint8_t *cmd, uint16_t len)
757{
758 uint8_t par[MAX_PARITY_SIZE];
759
760 GetParity(cmd, len, par);
761 CodeIso14443aAsTagPar(cmd, len, par);
15c4dc5a 762}
763
15c4dc5a 764
8f51ddb0
M
765static void Code4bitAnswerAsTag(uint8_t cmd)
766{
767 int i;
768
5f6d6c90 769 ToSendReset();
8f51ddb0
M
770
771 // Correction bit, might be removed when not needed
772 ToSendStuffBit(0);
773 ToSendStuffBit(0);
774 ToSendStuffBit(0);
775 ToSendStuffBit(0);
776 ToSendStuffBit(1); // 1
777 ToSendStuffBit(0);
778 ToSendStuffBit(0);
779 ToSendStuffBit(0);
780
781 // Send startbit
782 ToSend[++ToSendMax] = SEC_D;
783
784 uint8_t b = cmd;
785 for(i = 0; i < 4; i++) {
786 if(b & 1) {
787 ToSend[++ToSendMax] = SEC_D;
7bc95e2e 788 LastProxToAirDuration = 8 * ToSendMax - 4;
8f51ddb0
M
789 } else {
790 ToSend[++ToSendMax] = SEC_E;
7bc95e2e 791 LastProxToAirDuration = 8 * ToSendMax;
8f51ddb0
M
792 }
793 b >>= 1;
794 }
795
796 // Send stopbit
797 ToSend[++ToSendMax] = SEC_F;
798
5f6d6c90 799 // Convert from last byte pos to length
800 ToSendMax++;
15c4dc5a 801}
802
803//-----------------------------------------------------------------------------
804// Wait for commands from reader
805// Stop when button is pressed
806// Or return TRUE when command is captured
807//-----------------------------------------------------------------------------
6a1f2d82 808static int GetIso14443aCommandFromReader(uint8_t *received, uint8_t *parity, int *len)
15c4dc5a 809{
810 // Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen
811 // only, since we are receiving, not transmitting).
812 // Signal field is off with the appropriate LED
813 LED_D_OFF();
814 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_LISTEN);
815
816 // Now run a `software UART' on the stream of incoming samples.
6a1f2d82 817 UartInit(received, parity);
7bc95e2e 818
819 // clear RXRDY:
820 uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 821
822 for(;;) {
823 WDT_HIT();
824
825 if(BUTTON_PRESS()) return FALSE;
7bc95e2e 826
15c4dc5a 827 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
7bc95e2e 828 b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
829 if(MillerDecoding(b, 0)) {
830 *len = Uart.len;
15c4dc5a 831 return TRUE;
832 }
7bc95e2e 833 }
15c4dc5a 834 }
835}
28afbd2b 836
6a1f2d82 837static int EmSendCmd14443aRaw(uint8_t *resp, uint16_t respLen, bool correctionNeeded);
7bc95e2e 838int EmSend4bitEx(uint8_t resp, bool correctionNeeded);
28afbd2b 839int EmSend4bit(uint8_t resp);
6a1f2d82 840int EmSendCmdExPar(uint8_t *resp, uint16_t respLen, bool correctionNeeded, uint8_t *par);
841int EmSendCmdEx(uint8_t *resp, uint16_t respLen, bool correctionNeeded);
842int EmSendCmd(uint8_t *resp, uint16_t respLen);
843int EmSendCmdPar(uint8_t *resp, uint16_t respLen, uint8_t *par);
844bool EmLogTrace(uint8_t *reader_data, uint16_t reader_len, uint32_t reader_StartTime, uint32_t reader_EndTime, uint8_t *reader_Parity,
845 uint8_t *tag_data, uint16_t tag_len, uint32_t tag_StartTime, uint32_t tag_EndTime, uint8_t *tag_Parity);
15c4dc5a 846
117d9ec2 847static uint8_t* free_buffer_pointer;
ce02f6f9 848
849typedef struct {
850 uint8_t* response;
851 size_t response_n;
852 uint8_t* modulation;
853 size_t modulation_n;
7bc95e2e 854 uint32_t ProxToAirDuration;
ce02f6f9 855} tag_response_info_t;
856
ce02f6f9 857bool prepare_tag_modulation(tag_response_info_t* response_info, size_t max_buffer_size) {
7bc95e2e 858 // Example response, answer to MIFARE Classic read block will be 16 bytes + 2 CRC = 18 bytes
ce02f6f9 859 // This will need the following byte array for a modulation sequence
860 // 144 data bits (18 * 8)
861 // 18 parity bits
862 // 2 Start and stop
863 // 1 Correction bit (Answer in 1172 or 1236 periods, see FPGA)
864 // 1 just for the case
865 // ----------- +
866 // 166 bytes, since every bit that needs to be send costs us a byte
867 //
f71f4deb 868
869
ce02f6f9 870 // Prepare the tag modulation bits from the message
871 CodeIso14443aAsTag(response_info->response,response_info->response_n);
872
873 // Make sure we do not exceed the free buffer space
874 if (ToSendMax > max_buffer_size) {
875 Dbprintf("Out of memory, when modulating bits for tag answer:");
876 Dbhexdump(response_info->response_n,response_info->response,false);
877 return false;
878 }
879
880 // Copy the byte array, used for this modulation to the buffer position
881 memcpy(response_info->modulation,ToSend,ToSendMax);
882
7bc95e2e 883 // Store the number of bytes that were used for encoding/modulation and the time needed to transfer them
ce02f6f9 884 response_info->modulation_n = ToSendMax;
7bc95e2e 885 response_info->ProxToAirDuration = LastProxToAirDuration;
ce02f6f9 886
887 return true;
888}
889
f71f4deb 890
891// "precompile" responses. There are 7 predefined responses with a total of 28 bytes data to transmit.
892// Coded responses need one byte per bit to transfer (data, parity, start, stop, correction)
893// 28 * 8 data bits, 28 * 1 parity bits, 7 start bits, 7 stop bits, 7 correction bits
894// -> need 273 bytes buffer
895#define ALLOCATED_TAG_MODULATION_BUFFER_SIZE 273
896
ce02f6f9 897bool prepare_allocated_tag_modulation(tag_response_info_t* response_info) {
898 // Retrieve and store the current buffer index
899 response_info->modulation = free_buffer_pointer;
900
901 // Determine the maximum size we can use from our buffer
f71f4deb 902 size_t max_buffer_size = ALLOCATED_TAG_MODULATION_BUFFER_SIZE;
ce02f6f9 903
904 // Forward the prepare tag modulation function to the inner function
f71f4deb 905 if (prepare_tag_modulation(response_info, max_buffer_size)) {
ce02f6f9 906 // Update the free buffer offset
907 free_buffer_pointer += ToSendMax;
908 return true;
909 } else {
910 return false;
911 }
912}
913
15c4dc5a 914//-----------------------------------------------------------------------------
915// Main loop of simulated tag: receive commands from reader, decide what
916// response to send, and send it.
917//-----------------------------------------------------------------------------
28afbd2b 918void SimulateIso14443aTag(int tagType, int uid_1st, int uid_2nd, byte_t* data)
15c4dc5a 919{
81cd0474 920 uint8_t sak;
921
922 // The first response contains the ATQA (note: bytes are transmitted in reverse order).
923 uint8_t response1[2];
924
925 switch (tagType) {
926 case 1: { // MIFARE Classic
927 // Says: I am Mifare 1k - original line
928 response1[0] = 0x04;
929 response1[1] = 0x00;
930 sak = 0x08;
931 } break;
932 case 2: { // MIFARE Ultralight
933 // Says: I am a stupid memory tag, no crypto
934 response1[0] = 0x04;
935 response1[1] = 0x00;
936 sak = 0x00;
937 } break;
938 case 3: { // MIFARE DESFire
939 // Says: I am a DESFire tag, ph33r me
940 response1[0] = 0x04;
941 response1[1] = 0x03;
942 sak = 0x20;
943 } break;
944 case 4: { // ISO/IEC 14443-4
945 // Says: I am a javacard (JCOP)
946 response1[0] = 0x04;
947 response1[1] = 0x00;
948 sak = 0x28;
949 } break;
3fe4ff4f 950 case 5: { // MIFARE TNP3XXX
951 // Says: I am a toy
952 response1[0] = 0x01;
953 response1[1] = 0x0f;
954 sak = 0x01;
955 } break;
81cd0474 956 default: {
957 Dbprintf("Error: unkown tagtype (%d)",tagType);
958 return;
959 } break;
960 }
961
962 // The second response contains the (mandatory) first 24 bits of the UID
c8b6da22 963 uint8_t response2[5] = {0x00};
81cd0474 964
965 // Check if the uid uses the (optional) part
c8b6da22 966 uint8_t response2a[5] = {0x00};
967
81cd0474 968 if (uid_2nd) {
969 response2[0] = 0x88;
970 num_to_bytes(uid_1st,3,response2+1);
971 num_to_bytes(uid_2nd,4,response2a);
972 response2a[4] = response2a[0] ^ response2a[1] ^ response2a[2] ^ response2a[3];
973
974 // Configure the ATQA and SAK accordingly
975 response1[0] |= 0x40;
976 sak |= 0x04;
977 } else {
978 num_to_bytes(uid_1st,4,response2);
979 // Configure the ATQA and SAK accordingly
980 response1[0] &= 0xBF;
981 sak &= 0xFB;
982 }
983
984 // Calculate the BitCountCheck (BCC) for the first 4 bytes of the UID.
985 response2[4] = response2[0] ^ response2[1] ^ response2[2] ^ response2[3];
986
987 // Prepare the mandatory SAK (for 4 and 7 byte UID)
c8b6da22 988 uint8_t response3[3] = {0x00};
81cd0474 989 response3[0] = sak;
990 ComputeCrc14443(CRC_14443_A, response3, 1, &response3[1], &response3[2]);
991
992 // Prepare the optional second SAK (for 7 byte UID), drop the cascade bit
c8b6da22 993 uint8_t response3a[3] = {0x00};
81cd0474 994 response3a[0] = sak & 0xFB;
995 ComputeCrc14443(CRC_14443_A, response3a, 1, &response3a[1], &response3a[2]);
996
254b70a4 997 uint8_t response5[] = { 0x00, 0x00, 0x00, 0x00 }; // Very random tag nonce
6a1f2d82 998 uint8_t response6[] = { 0x04, 0x58, 0x80, 0x02, 0x00, 0x00 }; // dummy ATS (pseudo-ATR), answer to RATS:
999 // Format byte = 0x58: FSCI=0x08 (FSC=256), TA(1) and TC(1) present,
1000 // TA(1) = 0x80: different divisors not supported, DR = 1, DS = 1
1001 // TB(1) = not present. Defaults: FWI = 4 (FWT = 256 * 16 * 2^4 * 1/fc = 4833us), SFGI = 0 (SFG = 256 * 16 * 2^0 * 1/fc = 302us)
1002 // TC(1) = 0x02: CID supported, NAD not supported
ce02f6f9 1003 ComputeCrc14443(CRC_14443_A, response6, 4, &response6[4], &response6[5]);
1004
7bc95e2e 1005 #define TAG_RESPONSE_COUNT 7
1006 tag_response_info_t responses[TAG_RESPONSE_COUNT] = {
1007 { .response = response1, .response_n = sizeof(response1) }, // Answer to request - respond with card type
1008 { .response = response2, .response_n = sizeof(response2) }, // Anticollision cascade1 - respond with uid
1009 { .response = response2a, .response_n = sizeof(response2a) }, // Anticollision cascade2 - respond with 2nd half of uid if asked
1010 { .response = response3, .response_n = sizeof(response3) }, // Acknowledge select - cascade 1
1011 { .response = response3a, .response_n = sizeof(response3a) }, // Acknowledge select - cascade 2
1012 { .response = response5, .response_n = sizeof(response5) }, // Authentication answer (random nonce)
1013 { .response = response6, .response_n = sizeof(response6) }, // dummy ATS (pseudo-ATR), answer to RATS
1014 };
1015
1016 // Allocate 512 bytes for the dynamic modulation, created when the reader queries for it
1017 // Such a response is less time critical, so we can prepare them on the fly
1018 #define DYNAMIC_RESPONSE_BUFFER_SIZE 64
1019 #define DYNAMIC_MODULATION_BUFFER_SIZE 512
1020 uint8_t dynamic_response_buffer[DYNAMIC_RESPONSE_BUFFER_SIZE];
1021 uint8_t dynamic_modulation_buffer[DYNAMIC_MODULATION_BUFFER_SIZE];
1022 tag_response_info_t dynamic_response_info = {
1023 .response = dynamic_response_buffer,
1024 .response_n = 0,
1025 .modulation = dynamic_modulation_buffer,
1026 .modulation_n = 0
1027 };
ce02f6f9 1028
09ffd16e 1029 // We need to listen to the high-frequency, peak-detected path.
1030 iso14443a_setup(FPGA_HF_ISO14443A_TAGSIM_LISTEN);
1031
f71f4deb 1032 BigBuf_free_keep_EM();
1033
1034 // allocate buffers:
1035 uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
1036 uint8_t *receivedCmdPar = BigBuf_malloc(MAX_PARITY_SIZE);
1037 free_buffer_pointer = BigBuf_malloc(ALLOCATED_TAG_MODULATION_BUFFER_SIZE);
1038
1039 // clear trace
3000dc4e
MHS
1040 clear_trace();
1041 set_tracing(TRUE);
f71f4deb 1042
7bc95e2e 1043 // Prepare the responses of the anticollision phase
ce02f6f9 1044 // there will be not enough time to do this at the moment the reader sends it REQA
7bc95e2e 1045 for (size_t i=0; i<TAG_RESPONSE_COUNT; i++) {
1046 prepare_allocated_tag_modulation(&responses[i]);
1047 }
15c4dc5a 1048
7bc95e2e 1049 int len = 0;
15c4dc5a 1050
1051 // To control where we are in the protocol
1052 int order = 0;
1053 int lastorder;
1054
1055 // Just to allow some checks
1056 int happened = 0;
1057 int happened2 = 0;
81cd0474 1058 int cmdsRecvd = 0;
15c4dc5a 1059
254b70a4 1060 cmdsRecvd = 0;
7bc95e2e 1061 tag_response_info_t* p_response;
15c4dc5a 1062
254b70a4 1063 LED_A_ON();
1064 for(;;) {
7bc95e2e 1065 // Clean receive command buffer
6a1f2d82 1066 if(!GetIso14443aCommandFromReader(receivedCmd, receivedCmdPar, &len)) {
ce02f6f9 1067 DbpString("Button press");
254b70a4 1068 break;
1069 }
7bc95e2e 1070
1071 p_response = NULL;
1072
254b70a4 1073 // Okay, look at the command now.
1074 lastorder = order;
1075 if(receivedCmd[0] == 0x26) { // Received a REQUEST
ce02f6f9 1076 p_response = &responses[0]; order = 1;
254b70a4 1077 } else if(receivedCmd[0] == 0x52) { // Received a WAKEUP
ce02f6f9 1078 p_response = &responses[0]; order = 6;
254b70a4 1079 } else if(receivedCmd[1] == 0x20 && receivedCmd[0] == 0x93) { // Received request for UID (cascade 1)
ce02f6f9 1080 p_response = &responses[1]; order = 2;
6a1f2d82 1081 } else if(receivedCmd[1] == 0x20 && receivedCmd[0] == 0x95) { // Received request for UID (cascade 2)
ce02f6f9 1082 p_response = &responses[2]; order = 20;
254b70a4 1083 } else if(receivedCmd[1] == 0x70 && receivedCmd[0] == 0x93) { // Received a SELECT (cascade 1)
ce02f6f9 1084 p_response = &responses[3]; order = 3;
254b70a4 1085 } else if(receivedCmd[1] == 0x70 && receivedCmd[0] == 0x95) { // Received a SELECT (cascade 2)
ce02f6f9 1086 p_response = &responses[4]; order = 30;
254b70a4 1087 } else if(receivedCmd[0] == 0x30) { // Received a (plain) READ
6a1f2d82 1088 EmSendCmdEx(data+(4*receivedCmd[1]),16,false);
7bc95e2e 1089 // Dbprintf("Read request from reader: %x %x",receivedCmd[0],receivedCmd[1]);
5f6d6c90 1090 // We already responded, do not send anything with the EmSendCmd14443aRaw() that is called below
7bc95e2e 1091 p_response = NULL;
254b70a4 1092 } else if(receivedCmd[0] == 0x50) { // Received a HALT
3fe4ff4f 1093
7bc95e2e 1094 if (tracing) {
6a1f2d82 1095 LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 1096 }
1097 p_response = NULL;
254b70a4 1098 } else if(receivedCmd[0] == 0x60 || receivedCmd[0] == 0x61) { // Received an authentication request
ce02f6f9 1099 p_response = &responses[5]; order = 7;
254b70a4 1100 } else if(receivedCmd[0] == 0xE0) { // Received a RATS request
7bc95e2e 1101 if (tagType == 1 || tagType == 2) { // RATS not supported
1102 EmSend4bit(CARD_NACK_NA);
1103 p_response = NULL;
1104 } else {
1105 p_response = &responses[6]; order = 70;
1106 }
6a1f2d82 1107 } else if (order == 7 && len == 8) { // Received {nr] and {ar} (part of authentication)
7bc95e2e 1108 if (tracing) {
6a1f2d82 1109 LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 1110 }
1111 uint32_t nr = bytes_to_num(receivedCmd,4);
1112 uint32_t ar = bytes_to_num(receivedCmd+4,4);
1113 Dbprintf("Auth attempt {nr}{ar}: %08x %08x",nr,ar);
1114 } else {
1115 // Check for ISO 14443A-4 compliant commands, look at left nibble
1116 switch (receivedCmd[0]) {
1117
1118 case 0x0B:
1119 case 0x0A: { // IBlock (command)
1120 dynamic_response_info.response[0] = receivedCmd[0];
1121 dynamic_response_info.response[1] = 0x00;
1122 dynamic_response_info.response[2] = 0x90;
1123 dynamic_response_info.response[3] = 0x00;
1124 dynamic_response_info.response_n = 4;
1125 } break;
1126
1127 case 0x1A:
1128 case 0x1B: { // Chaining command
1129 dynamic_response_info.response[0] = 0xaa | ((receivedCmd[0]) & 1);
1130 dynamic_response_info.response_n = 2;
1131 } break;
1132
1133 case 0xaa:
1134 case 0xbb: {
1135 dynamic_response_info.response[0] = receivedCmd[0] ^ 0x11;
1136 dynamic_response_info.response_n = 2;
1137 } break;
1138
1139 case 0xBA: { //
1140 memcpy(dynamic_response_info.response,"\xAB\x00",2);
1141 dynamic_response_info.response_n = 2;
1142 } break;
1143
1144 case 0xCA:
1145 case 0xC2: { // Readers sends deselect command
1146 memcpy(dynamic_response_info.response,"\xCA\x00",2);
1147 dynamic_response_info.response_n = 2;
1148 } break;
1149
1150 default: {
1151 // Never seen this command before
1152 if (tracing) {
6a1f2d82 1153 LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 1154 }
1155 Dbprintf("Received unknown command (len=%d):",len);
1156 Dbhexdump(len,receivedCmd,false);
1157 // Do not respond
1158 dynamic_response_info.response_n = 0;
1159 } break;
1160 }
ce02f6f9 1161
7bc95e2e 1162 if (dynamic_response_info.response_n > 0) {
1163 // Copy the CID from the reader query
1164 dynamic_response_info.response[1] = receivedCmd[1];
ce02f6f9 1165
7bc95e2e 1166 // Add CRC bytes, always used in ISO 14443A-4 compliant cards
1167 AppendCrc14443a(dynamic_response_info.response,dynamic_response_info.response_n);
1168 dynamic_response_info.response_n += 2;
ce02f6f9 1169
7bc95e2e 1170 if (prepare_tag_modulation(&dynamic_response_info,DYNAMIC_MODULATION_BUFFER_SIZE) == false) {
1171 Dbprintf("Error preparing tag response");
1172 if (tracing) {
6a1f2d82 1173 LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 1174 }
1175 break;
1176 }
1177 p_response = &dynamic_response_info;
1178 }
81cd0474 1179 }
15c4dc5a 1180
1181 // Count number of wakeups received after a halt
1182 if(order == 6 && lastorder == 5) { happened++; }
1183
1184 // Count number of other messages after a halt
1185 if(order != 6 && lastorder == 5) { happened2++; }
1186
15c4dc5a 1187 if(cmdsRecvd > 999) {
1188 DbpString("1000 commands later...");
254b70a4 1189 break;
15c4dc5a 1190 }
ce02f6f9 1191 cmdsRecvd++;
1192
1193 if (p_response != NULL) {
7bc95e2e 1194 EmSendCmd14443aRaw(p_response->modulation, p_response->modulation_n, receivedCmd[0] == 0x52);
1195 // do the tracing for the previous reader request and this tag answer:
6a1f2d82 1196 uint8_t par[MAX_PARITY_SIZE];
1197 GetParity(p_response->response, p_response->response_n, par);
3fe4ff4f 1198
7bc95e2e 1199 EmLogTrace(Uart.output,
1200 Uart.len,
1201 Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG,
1202 Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG,
6a1f2d82 1203 Uart.parity,
7bc95e2e 1204 p_response->response,
1205 p_response->response_n,
1206 LastTimeProxToAirStart*16 + DELAY_ARM2AIR_AS_TAG,
1207 (LastTimeProxToAirStart + p_response->ProxToAirDuration)*16 + DELAY_ARM2AIR_AS_TAG,
6a1f2d82 1208 par);
7bc95e2e 1209 }
1210
1211 if (!tracing) {
1212 Dbprintf("Trace Full. Simulation stopped.");
1213 break;
1214 }
1215 }
15c4dc5a 1216
1217 Dbprintf("%x %x %x", happened, happened2, cmdsRecvd);
1218 LED_A_OFF();
f71f4deb 1219 BigBuf_free_keep_EM();
15c4dc5a 1220}
1221
9492e0b0 1222
1223// prepare a delayed transfer. This simply shifts ToSend[] by a number
1224// of bits specified in the delay parameter.
1225void PrepareDelayedTransfer(uint16_t delay)
1226{
1227 uint8_t bitmask = 0;
1228 uint8_t bits_to_shift = 0;
1229 uint8_t bits_shifted = 0;
1230
1231 delay &= 0x07;
1232 if (delay) {
1233 for (uint16_t i = 0; i < delay; i++) {
1234 bitmask |= (0x01 << i);
1235 }
7bc95e2e 1236 ToSend[ToSendMax++] = 0x00;
9492e0b0 1237 for (uint16_t i = 0; i < ToSendMax; i++) {
1238 bits_to_shift = ToSend[i] & bitmask;
1239 ToSend[i] = ToSend[i] >> delay;
1240 ToSend[i] = ToSend[i] | (bits_shifted << (8 - delay));
1241 bits_shifted = bits_to_shift;
1242 }
1243 }
1244}
1245
7bc95e2e 1246
1247//-------------------------------------------------------------------------------------
15c4dc5a 1248// Transmit the command (to the tag) that was placed in ToSend[].
9492e0b0 1249// Parameter timing:
7bc95e2e 1250// if NULL: transfer at next possible time, taking into account
1251// request guard time and frame delay time
1252// if == 0: transfer immediately and return time of transfer
9492e0b0 1253// if != 0: delay transfer until time specified
7bc95e2e 1254//-------------------------------------------------------------------------------------
6a1f2d82 1255static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing)
15c4dc5a 1256{
7bc95e2e 1257
9492e0b0 1258 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
e30c654b 1259
7bc95e2e 1260 uint32_t ThisTransferTime = 0;
e30c654b 1261
9492e0b0 1262 if (timing) {
1263 if(*timing == 0) { // Measure time
7bc95e2e 1264 *timing = (GetCountSspClk() + 8) & 0xfffffff8;
9492e0b0 1265 } else {
1266 PrepareDelayedTransfer(*timing & 0x00000007); // Delay transfer (fine tuning - up to 7 MF clock ticks)
1267 }
7bc95e2e 1268 if(MF_DBGLEVEL >= 4 && GetCountSspClk() >= (*timing & 0xfffffff8)) Dbprintf("TransmitFor14443a: Missed timing");
1269 while(GetCountSspClk() < (*timing & 0xfffffff8)); // Delay transfer (multiple of 8 MF clock ticks)
1270 LastTimeProxToAirStart = *timing;
1271 } else {
1272 ThisTransferTime = ((MAX(NextTransferTime, GetCountSspClk()) & 0xfffffff8) + 8);
1273 while(GetCountSspClk() < ThisTransferTime);
1274 LastTimeProxToAirStart = ThisTransferTime;
9492e0b0 1275 }
1276
7bc95e2e 1277 // clear TXRDY
1278 AT91C_BASE_SSC->SSC_THR = SEC_Y;
1279
7bc95e2e 1280 uint16_t c = 0;
9492e0b0 1281 for(;;) {
1282 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
1283 AT91C_BASE_SSC->SSC_THR = cmd[c];
1284 c++;
1285 if(c >= len) {
1286 break;
1287 }
1288 }
1289 }
7bc95e2e 1290
1291 NextTransferTime = MAX(NextTransferTime, LastTimeProxToAirStart + REQUEST_GUARD_TIME);
15c4dc5a 1292}
1293
7bc95e2e 1294
15c4dc5a 1295//-----------------------------------------------------------------------------
195af472 1296// Prepare reader command (in bits, support short frames) to send to FPGA
15c4dc5a 1297//-----------------------------------------------------------------------------
6a1f2d82 1298void CodeIso14443aBitsAsReaderPar(const uint8_t *cmd, uint16_t bits, const uint8_t *parity)
15c4dc5a 1299{
7bc95e2e 1300 int i, j;
1301 int last;
1302 uint8_t b;
e30c654b 1303
7bc95e2e 1304 ToSendReset();
e30c654b 1305
7bc95e2e 1306 // Start of Communication (Seq. Z)
1307 ToSend[++ToSendMax] = SEC_Z;
1308 LastProxToAirDuration = 8 * (ToSendMax+1) - 6;
1309 last = 0;
1310
1311 size_t bytecount = nbytes(bits);
1312 // Generate send structure for the data bits
1313 for (i = 0; i < bytecount; i++) {
1314 // Get the current byte to send
1315 b = cmd[i];
1316 size_t bitsleft = MIN((bits-(i*8)),8);
1317
1318 for (j = 0; j < bitsleft; j++) {
1319 if (b & 1) {
1320 // Sequence X
1321 ToSend[++ToSendMax] = SEC_X;
1322 LastProxToAirDuration = 8 * (ToSendMax+1) - 2;
1323 last = 1;
1324 } else {
1325 if (last == 0) {
1326 // Sequence Z
1327 ToSend[++ToSendMax] = SEC_Z;
1328 LastProxToAirDuration = 8 * (ToSendMax+1) - 6;
1329 } else {
1330 // Sequence Y
1331 ToSend[++ToSendMax] = SEC_Y;
1332 last = 0;
1333 }
1334 }
1335 b >>= 1;
1336 }
1337
6a1f2d82 1338 // Only transmit parity bit if we transmitted a complete byte
7bc95e2e 1339 if (j == 8) {
1340 // Get the parity bit
6a1f2d82 1341 if (parity[i>>3] & (0x80 >> (i&0x0007))) {
7bc95e2e 1342 // Sequence X
1343 ToSend[++ToSendMax] = SEC_X;
1344 LastProxToAirDuration = 8 * (ToSendMax+1) - 2;
1345 last = 1;
1346 } else {
1347 if (last == 0) {
1348 // Sequence Z
1349 ToSend[++ToSendMax] = SEC_Z;
1350 LastProxToAirDuration = 8 * (ToSendMax+1) - 6;
1351 } else {
1352 // Sequence Y
1353 ToSend[++ToSendMax] = SEC_Y;
1354 last = 0;
1355 }
1356 }
1357 }
1358 }
e30c654b 1359
7bc95e2e 1360 // End of Communication: Logic 0 followed by Sequence Y
1361 if (last == 0) {
1362 // Sequence Z
1363 ToSend[++ToSendMax] = SEC_Z;
1364 LastProxToAirDuration = 8 * (ToSendMax+1) - 6;
1365 } else {
1366 // Sequence Y
1367 ToSend[++ToSendMax] = SEC_Y;
1368 last = 0;
1369 }
1370 ToSend[++ToSendMax] = SEC_Y;
e30c654b 1371
7bc95e2e 1372 // Convert to length of command:
1373 ToSendMax++;
15c4dc5a 1374}
1375
195af472 1376//-----------------------------------------------------------------------------
1377// Prepare reader command to send to FPGA
1378//-----------------------------------------------------------------------------
6a1f2d82 1379void CodeIso14443aAsReaderPar(const uint8_t *cmd, uint16_t len, const uint8_t *parity)
195af472 1380{
6a1f2d82 1381 CodeIso14443aBitsAsReaderPar(cmd, len*8, parity);
195af472 1382}
1383
0c8d25eb 1384
9ca155ba
M
1385//-----------------------------------------------------------------------------
1386// Wait for commands from reader
1387// Stop when button is pressed (return 1) or field was gone (return 2)
1388// Or return 0 when command is captured
1389//-----------------------------------------------------------------------------
6a1f2d82 1390static int EmGetCmd(uint8_t *received, uint16_t *len, uint8_t *parity)
9ca155ba
M
1391{
1392 *len = 0;
1393
1394 uint32_t timer = 0, vtime = 0;
1395 int analogCnt = 0;
1396 int analogAVG = 0;
1397
1398 // Set FPGA mode to "simulated ISO 14443 tag", no modulation (listen
1399 // only, since we are receiving, not transmitting).
1400 // Signal field is off with the appropriate LED
1401 LED_D_OFF();
1402 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_LISTEN);
1403
1404 // Set ADC to read field strength
1405 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
1406 AT91C_BASE_ADC->ADC_MR =
0c8d25eb 1407 ADC_MODE_PRESCALE(63) |
1408 ADC_MODE_STARTUP_TIME(1) |
1409 ADC_MODE_SAMPLE_HOLD_TIME(15);
9ca155ba
M
1410 AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ADC_CHAN_HF);
1411 // start ADC
1412 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
1413
1414 // Now run a 'software UART' on the stream of incoming samples.
6a1f2d82 1415 UartInit(received, parity);
7bc95e2e 1416
1417 // Clear RXRDY:
1418 uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
0c8d25eb 1419
9ca155ba
M
1420 for(;;) {
1421 WDT_HIT();
1422
1423 if (BUTTON_PRESS()) return 1;
1424
1425 // test if the field exists
1426 if (AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ADC_CHAN_HF)) {
1427 analogCnt++;
1428 analogAVG += AT91C_BASE_ADC->ADC_CDR[ADC_CHAN_HF];
1429 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
1430 if (analogCnt >= 32) {
0c8d25eb 1431 if ((MAX_ADC_HF_VOLTAGE * (analogAVG / analogCnt) >> 10) < MF_MINFIELDV) {
9ca155ba
M
1432 vtime = GetTickCount();
1433 if (!timer) timer = vtime;
1434 // 50ms no field --> card to idle state
1435 if (vtime - timer > 50) return 2;
1436 } else
1437 if (timer) timer = 0;
1438 analogCnt = 0;
1439 analogAVG = 0;
1440 }
1441 }
7bc95e2e 1442
9ca155ba 1443 // receive and test the miller decoding
7bc95e2e 1444 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
1445 b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
1446 if(MillerDecoding(b, 0)) {
1447 *len = Uart.len;
9ca155ba
M
1448 return 0;
1449 }
7bc95e2e 1450 }
1451
9ca155ba
M
1452 }
1453}
1454
9ca155ba 1455
6a1f2d82 1456static int EmSendCmd14443aRaw(uint8_t *resp, uint16_t respLen, bool correctionNeeded)
7bc95e2e 1457{
1458 uint8_t b;
1459 uint16_t i = 0;
1460 uint32_t ThisTransferTime;
1461
9ca155ba
M
1462 // Modulate Manchester
1463 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_MOD);
7bc95e2e 1464
1465 // include correction bit if necessary
1466 if (Uart.parityBits & 0x01) {
1467 correctionNeeded = TRUE;
1468 }
1469 if(correctionNeeded) {
9ca155ba
M
1470 // 1236, so correction bit needed
1471 i = 0;
7bc95e2e 1472 } else {
1473 i = 1;
9ca155ba 1474 }
7bc95e2e 1475
d714d3ef 1476 // clear receiving shift register and holding register
7bc95e2e 1477 while(!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY));
1478 b = AT91C_BASE_SSC->SSC_RHR; (void) b;
1479 while(!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY));
1480 b = AT91C_BASE_SSC->SSC_RHR; (void) b;
9ca155ba 1481
7bc95e2e 1482 // wait for the FPGA to signal fdt_indicator == 1 (the FPGA is ready to queue new data in its delay line)
1483 for (uint16_t j = 0; j < 5; j++) { // allow timeout - better late than never
1484 while(!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY));
1485 if (AT91C_BASE_SSC->SSC_RHR) break;
1486 }
1487
1488 while ((ThisTransferTime = GetCountSspClk()) & 0x00000007);
1489
1490 // Clear TXRDY:
1491 AT91C_BASE_SSC->SSC_THR = SEC_F;
1492
9ca155ba 1493 // send cycle
bb42a03e 1494 for(; i < respLen; ) {
9ca155ba 1495 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
7bc95e2e 1496 AT91C_BASE_SSC->SSC_THR = resp[i++];
1497 FpgaSendQueueDelay = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
9ca155ba 1498 }
7bc95e2e 1499
9ca155ba
M
1500 if(BUTTON_PRESS()) {
1501 break;
1502 }
1503 }
1504
7bc95e2e 1505 // Ensure that the FPGA Delay Queue is empty before we switch to TAGSIM_LISTEN again:
0c8d25eb 1506 uint8_t fpga_queued_bits = FpgaSendQueueDelay >> 3;
1507 for (i = 0; i <= fpga_queued_bits/8 + 1; ) {
7bc95e2e 1508 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
1509 AT91C_BASE_SSC->SSC_THR = SEC_F;
1510 FpgaSendQueueDelay = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
1511 i++;
1512 }
1513 }
0c8d25eb 1514
7bc95e2e 1515 LastTimeProxToAirStart = ThisTransferTime + (correctionNeeded?8:0);
1516
9ca155ba
M
1517 return 0;
1518}
1519
7bc95e2e 1520int EmSend4bitEx(uint8_t resp, bool correctionNeeded){
1521 Code4bitAnswerAsTag(resp);
0a39986e 1522 int res = EmSendCmd14443aRaw(ToSend, ToSendMax, correctionNeeded);
7bc95e2e 1523 // do the tracing for the previous reader request and this tag answer:
6a1f2d82 1524 uint8_t par[1];
1525 GetParity(&resp, 1, par);
7bc95e2e 1526 EmLogTrace(Uart.output,
1527 Uart.len,
1528 Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG,
1529 Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG,
6a1f2d82 1530 Uart.parity,
7bc95e2e 1531 &resp,
1532 1,
1533 LastTimeProxToAirStart*16 + DELAY_ARM2AIR_AS_TAG,
1534 (LastTimeProxToAirStart + LastProxToAirDuration)*16 + DELAY_ARM2AIR_AS_TAG,
6a1f2d82 1535 par);
0a39986e 1536 return res;
9ca155ba
M
1537}
1538
8f51ddb0 1539int EmSend4bit(uint8_t resp){
7bc95e2e 1540 return EmSend4bitEx(resp, false);
8f51ddb0
M
1541}
1542
6a1f2d82 1543int EmSendCmdExPar(uint8_t *resp, uint16_t respLen, bool correctionNeeded, uint8_t *par){
7bc95e2e 1544 CodeIso14443aAsTagPar(resp, respLen, par);
8f51ddb0 1545 int res = EmSendCmd14443aRaw(ToSend, ToSendMax, correctionNeeded);
7bc95e2e 1546 // do the tracing for the previous reader request and this tag answer:
1547 EmLogTrace(Uart.output,
1548 Uart.len,
1549 Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG,
1550 Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG,
6a1f2d82 1551 Uart.parity,
7bc95e2e 1552 resp,
1553 respLen,
1554 LastTimeProxToAirStart*16 + DELAY_ARM2AIR_AS_TAG,
1555 (LastTimeProxToAirStart + LastProxToAirDuration)*16 + DELAY_ARM2AIR_AS_TAG,
6a1f2d82 1556 par);
8f51ddb0
M
1557 return res;
1558}
1559
6a1f2d82 1560int EmSendCmdEx(uint8_t *resp, uint16_t respLen, bool correctionNeeded){
1561 uint8_t par[MAX_PARITY_SIZE];
1562 GetParity(resp, respLen, par);
1563 return EmSendCmdExPar(resp, respLen, correctionNeeded, par);
8f51ddb0
M
1564}
1565
6a1f2d82 1566int EmSendCmd(uint8_t *resp, uint16_t respLen){
1567 uint8_t par[MAX_PARITY_SIZE];
1568 GetParity(resp, respLen, par);
1569 return EmSendCmdExPar(resp, respLen, false, par);
8f51ddb0
M
1570}
1571
6a1f2d82 1572int EmSendCmdPar(uint8_t *resp, uint16_t respLen, uint8_t *par){
7bc95e2e 1573 return EmSendCmdExPar(resp, respLen, false, par);
1574}
1575
6a1f2d82 1576bool EmLogTrace(uint8_t *reader_data, uint16_t reader_len, uint32_t reader_StartTime, uint32_t reader_EndTime, uint8_t *reader_Parity,
1577 uint8_t *tag_data, uint16_t tag_len, uint32_t tag_StartTime, uint32_t tag_EndTime, uint8_t *tag_Parity)
7bc95e2e 1578{
1579 if (tracing) {
1580 // we cannot exactly measure the end and start of a received command from reader. However we know that the delay from
1581 // end of the received command to start of the tag's (simulated by us) answer is n*128+20 or n*128+84 resp.
1582 // with n >= 9. The start of the tags answer can be measured and therefore the end of the received command be calculated:
1583 uint16_t reader_modlen = reader_EndTime - reader_StartTime;
1584 uint16_t approx_fdt = tag_StartTime - reader_EndTime;
1585 uint16_t exact_fdt = (approx_fdt - 20 + 32)/64 * 64 + 20;
1586 reader_EndTime = tag_StartTime - exact_fdt;
1587 reader_StartTime = reader_EndTime - reader_modlen;
6a1f2d82 1588 if (!LogTrace(reader_data, reader_len, reader_StartTime, reader_EndTime, reader_Parity, TRUE)) {
7bc95e2e 1589 return FALSE;
6a1f2d82 1590 } else return(!LogTrace(tag_data, tag_len, tag_StartTime, tag_EndTime, tag_Parity, FALSE));
7bc95e2e 1591 } else {
1592 return TRUE;
1593 }
9ca155ba
M
1594}
1595
15c4dc5a 1596//-----------------------------------------------------------------------------
1597// Wait a certain time for tag response
1598// If a response is captured return TRUE
e691fc45 1599// If it takes too long return FALSE
15c4dc5a 1600//-----------------------------------------------------------------------------
6a1f2d82 1601static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, uint8_t *receivedResponsePar, uint16_t offset)
15c4dc5a 1602{
52bfb955 1603 uint32_t c;
e691fc45 1604
15c4dc5a 1605 // Set FPGA mode to "reader listen mode", no modulation (listen
534983d7 1606 // only, since we are receiving, not transmitting).
1607 // Signal field is on with the appropriate LED
1608 LED_D_ON();
1609 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_LISTEN);
1c611bbd 1610
534983d7 1611 // Now get the answer from the card
6a1f2d82 1612 DemodInit(receivedResponse, receivedResponsePar);
15c4dc5a 1613
7bc95e2e 1614 // clear RXRDY:
1615 uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
0c8d25eb 1616
15c4dc5a 1617 c = 0;
1618 for(;;) {
534983d7 1619 WDT_HIT();
15c4dc5a 1620
534983d7 1621 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
534983d7 1622 b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
7bc95e2e 1623 if(ManchesterDecoding(b, offset, 0)) {
1624 NextTransferTime = MAX(NextTransferTime, Demod.endTime - (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/16 + FRAME_DELAY_TIME_PICC_TO_PCD);
15c4dc5a 1625 return TRUE;
19a700a8 1626 } else if (c++ > iso14a_timeout && Demod.state == DEMOD_UNSYNCD) {
7bc95e2e 1627 return FALSE;
15c4dc5a 1628 }
534983d7 1629 }
1630 }
15c4dc5a 1631}
1632
6a1f2d82 1633void ReaderTransmitBitsPar(uint8_t* frame, uint16_t bits, uint8_t *par, uint32_t *timing)
15c4dc5a 1634{
6a1f2d82 1635 CodeIso14443aBitsAsReaderPar(frame, bits, par);
dfc3c505 1636
7bc95e2e 1637 // Send command to tag
1638 TransmitFor14443a(ToSend, ToSendMax, timing);
1639 if(trigger)
1640 LED_A_ON();
dfc3c505 1641
7bc95e2e 1642 // Log reader command in trace buffer
1643 if (tracing) {
6a1f2d82 1644 LogTrace(frame, nbytes(bits), LastTimeProxToAirStart*16 + DELAY_ARM2AIR_AS_READER, (LastTimeProxToAirStart + LastProxToAirDuration)*16 + DELAY_ARM2AIR_AS_READER, par, TRUE);
7bc95e2e 1645 }
15c4dc5a 1646}
1647
6a1f2d82 1648void ReaderTransmitPar(uint8_t* frame, uint16_t len, uint8_t *par, uint32_t *timing)
dfc3c505 1649{
6a1f2d82 1650 ReaderTransmitBitsPar(frame, len*8, par, timing);
dfc3c505 1651}
15c4dc5a 1652
6a1f2d82 1653void ReaderTransmitBits(uint8_t* frame, uint16_t len, uint32_t *timing)
e691fc45 1654{
1655 // Generate parity and redirect
6a1f2d82 1656 uint8_t par[MAX_PARITY_SIZE];
1657 GetParity(frame, len/8, par);
1658 ReaderTransmitBitsPar(frame, len, par, timing);
e691fc45 1659}
1660
6a1f2d82 1661void ReaderTransmit(uint8_t* frame, uint16_t len, uint32_t *timing)
15c4dc5a 1662{
1663 // Generate parity and redirect
6a1f2d82 1664 uint8_t par[MAX_PARITY_SIZE];
1665 GetParity(frame, len, par);
1666 ReaderTransmitBitsPar(frame, len*8, par, timing);
15c4dc5a 1667}
1668
6a1f2d82 1669int ReaderReceiveOffset(uint8_t* receivedAnswer, uint16_t offset, uint8_t *parity)
e691fc45 1670{
6a1f2d82 1671 if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, offset)) return FALSE;
7bc95e2e 1672 if (tracing) {
6a1f2d82 1673 LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, FALSE);
7bc95e2e 1674 }
e691fc45 1675 return Demod.len;
1676}
1677
6a1f2d82 1678int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity)
15c4dc5a 1679{
6a1f2d82 1680 if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, 0)) return FALSE;
7bc95e2e 1681 if (tracing) {
6a1f2d82 1682 LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, FALSE);
7bc95e2e 1683 }
e691fc45 1684 return Demod.len;
f89c7050
M
1685}
1686
e691fc45 1687/* performs iso14443a anticollision procedure
534983d7 1688 * fills the uid pointer unless NULL
1689 * fills resp_data unless NULL */
6a1f2d82 1690int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, uint32_t *cuid_ptr) {
1691 uint8_t wupa[] = { 0x52 }; // 0x26 - REQA 0x52 - WAKE-UP
1692 uint8_t sel_all[] = { 0x93,0x20 };
1693 uint8_t sel_uid[] = { 0x93,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
1694 uint8_t rats[] = { 0xE0,0x80,0x00,0x00 }; // FSD=256, FSDI=8, CID=0
f71f4deb 1695 uint8_t resp[MAX_FRAME_SIZE]; // theoretically. A usual RATS will be much smaller
1696 uint8_t resp_par[MAX_PARITY_SIZE];
6a1f2d82 1697 byte_t uid_resp[4];
1698 size_t uid_resp_len;
1699
1700 uint8_t sak = 0x04; // cascade uid
1701 int cascade_level = 0;
1702 int len;
1703
1704 // Broadcast for a card, WUPA (0x52) will force response from all cards in the field
9492e0b0 1705 ReaderTransmitBitsPar(wupa,7,0, NULL);
7bc95e2e 1706
6a1f2d82 1707 // Receive the ATQA
1708 if(!ReaderReceive(resp, resp_par)) return 0;
6a1f2d82 1709
1710 if(p_hi14a_card) {
1711 memcpy(p_hi14a_card->atqa, resp, 2);
1712 p_hi14a_card->uidlen = 0;
1713 memset(p_hi14a_card->uid,0,10);
1714 }
5f6d6c90 1715
6a1f2d82 1716 // clear uid
1717 if (uid_ptr) {
1718 memset(uid_ptr,0,10);
1719 }
79a73ab2 1720
6a1f2d82 1721 // OK we will select at least at cascade 1, lets see if first byte of UID was 0x88 in
1722 // which case we need to make a cascade 2 request and select - this is a long UID
1723 // While the UID is not complete, the 3nd bit (from the right) is set in the SAK.
1724 for(; sak & 0x04; cascade_level++) {
1725 // SELECT_* (L1: 0x93, L2: 0x95, L3: 0x97)
1726 sel_uid[0] = sel_all[0] = 0x93 + cascade_level * 2;
1727
1728 // SELECT_ALL
1729 ReaderTransmit(sel_all, sizeof(sel_all), NULL);
1730 if (!ReaderReceive(resp, resp_par)) return 0;
1731
1732 if (Demod.collisionPos) { // we had a collision and need to construct the UID bit by bit
1733 memset(uid_resp, 0, 4);
1734 uint16_t uid_resp_bits = 0;
1735 uint16_t collision_answer_offset = 0;
1736 // anti-collision-loop:
1737 while (Demod.collisionPos) {
1738 Dbprintf("Multiple tags detected. Collision after Bit %d", Demod.collisionPos);
1739 for (uint16_t i = collision_answer_offset; i < Demod.collisionPos; i++, uid_resp_bits++) { // add valid UID bits before collision point
1740 uint16_t UIDbit = (resp[i/8] >> (i % 8)) & 0x01;
758f1fd1 1741 uid_resp[uid_resp_bits / 8] |= UIDbit << (uid_resp_bits % 8);
6a1f2d82 1742 }
1743 uid_resp[uid_resp_bits/8] |= 1 << (uid_resp_bits % 8); // next time select the card(s) with a 1 in the collision position
1744 uid_resp_bits++;
1745 // construct anticollosion command:
1746 sel_uid[1] = ((2 + uid_resp_bits/8) << 4) | (uid_resp_bits & 0x07); // length of data in bytes and bits
1747 for (uint16_t i = 0; i <= uid_resp_bits/8; i++) {
1748 sel_uid[2+i] = uid_resp[i];
1749 }
1750 collision_answer_offset = uid_resp_bits%8;
1751 ReaderTransmitBits(sel_uid, 16 + uid_resp_bits, NULL);
1752 if (!ReaderReceiveOffset(resp, collision_answer_offset, resp_par)) return 0;
e691fc45 1753 }
6a1f2d82 1754 // finally, add the last bits and BCC of the UID
1755 for (uint16_t i = collision_answer_offset; i < (Demod.len-1)*8; i++, uid_resp_bits++) {
1756 uint16_t UIDbit = (resp[i/8] >> (i%8)) & 0x01;
1757 uid_resp[uid_resp_bits/8] |= UIDbit << (uid_resp_bits % 8);
e691fc45 1758 }
e691fc45 1759
6a1f2d82 1760 } else { // no collision, use the response to SELECT_ALL as current uid
1761 memcpy(uid_resp, resp, 4);
1762 }
1763 uid_resp_len = 4;
5f6d6c90 1764
6a1f2d82 1765 // calculate crypto UID. Always use last 4 Bytes.
1766 if(cuid_ptr) {
1767 *cuid_ptr = bytes_to_num(uid_resp, 4);
1768 }
e30c654b 1769
6a1f2d82 1770 // Construct SELECT UID command
1771 sel_uid[1] = 0x70; // transmitting a full UID (1 Byte cmd, 1 Byte NVB, 4 Byte UID, 1 Byte BCC, 2 Bytes CRC)
1772 memcpy(sel_uid+2, uid_resp, 4); // the UID
1773 sel_uid[6] = sel_uid[2] ^ sel_uid[3] ^ sel_uid[4] ^ sel_uid[5]; // calculate and add BCC
1774 AppendCrc14443a(sel_uid, 7); // calculate and add CRC
1775 ReaderTransmit(sel_uid, sizeof(sel_uid), NULL);
1776
1777 // Receive the SAK
1778 if (!ReaderReceive(resp, resp_par)) return 0;
1779 sak = resp[0];
1780
52ab55ab 1781 // Test if more parts of the uid are coming
6a1f2d82 1782 if ((sak & 0x04) /* && uid_resp[0] == 0x88 */) {
1783 // Remove first byte, 0x88 is not an UID byte, it CT, see page 3 of:
1784 // http://www.nxp.com/documents/application_note/AN10927.pdf
6a1f2d82 1785 uid_resp[0] = uid_resp[1];
1786 uid_resp[1] = uid_resp[2];
1787 uid_resp[2] = uid_resp[3];
1788
1789 uid_resp_len = 3;
1790 }
5f6d6c90 1791
6a1f2d82 1792 if(uid_ptr) {
1793 memcpy(uid_ptr + (cascade_level*3), uid_resp, uid_resp_len);
1794 }
5f6d6c90 1795
6a1f2d82 1796 if(p_hi14a_card) {
1797 memcpy(p_hi14a_card->uid + (cascade_level*3), uid_resp, uid_resp_len);
1798 p_hi14a_card->uidlen += uid_resp_len;
1799 }
1800 }
79a73ab2 1801
6a1f2d82 1802 if(p_hi14a_card) {
1803 p_hi14a_card->sak = sak;
1804 p_hi14a_card->ats_len = 0;
1805 }
534983d7 1806
3fe4ff4f 1807 // non iso14443a compliant tag
1808 if( (sak & 0x20) == 0) return 2;
534983d7 1809
6a1f2d82 1810 // Request for answer to select
1811 AppendCrc14443a(rats, 2);
1812 ReaderTransmit(rats, sizeof(rats), NULL);
1c611bbd 1813
6a1f2d82 1814 if (!(len = ReaderReceive(resp, resp_par))) return 0;
5191b3d1 1815
3fe4ff4f 1816
6a1f2d82 1817 if(p_hi14a_card) {
1818 memcpy(p_hi14a_card->ats, resp, sizeof(p_hi14a_card->ats));
1819 p_hi14a_card->ats_len = len;
1820 }
5f6d6c90 1821
6a1f2d82 1822 // reset the PCB block number
1823 iso14_pcb_blocknum = 0;
19a700a8 1824
1825 // set default timeout based on ATS
1826 iso14a_set_ATS_timeout(resp);
1827
6a1f2d82 1828 return 1;
7e758047 1829}
15c4dc5a 1830
7bc95e2e 1831void iso14443a_setup(uint8_t fpga_minor_mode) {
7cc204bf 1832 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
9492e0b0 1833 // Set up the synchronous serial port
1834 FpgaSetupSsc();
7bc95e2e 1835 // connect Demodulated Signal to ADC:
7e758047 1836 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
e30c654b 1837
7e758047 1838 // Signal field is on with the appropriate LED
7bc95e2e 1839 if (fpga_minor_mode == FPGA_HF_ISO14443A_READER_MOD
1840 || fpga_minor_mode == FPGA_HF_ISO14443A_READER_LISTEN) {
1841 LED_D_ON();
1842 } else {
1843 LED_D_OFF();
1844 }
1845 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | fpga_minor_mode);
534983d7 1846
7bc95e2e 1847 // Start the timer
1848 StartCountSspClk();
1849
1850 DemodReset();
1851 UartReset();
1852 NextTransferTime = 2*DELAY_ARM2AIR_AS_READER;
1853 iso14a_set_timeout(1050); // 10ms default
7e758047 1854}
15c4dc5a 1855
6a1f2d82 1856int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, void *data) {
1857 uint8_t parity[MAX_PARITY_SIZE];
534983d7 1858 uint8_t real_cmd[cmd_len+4];
1859 real_cmd[0] = 0x0a; //I-Block
b0127e65 1860 // put block number into the PCB
1861 real_cmd[0] |= iso14_pcb_blocknum;
534983d7 1862 real_cmd[1] = 0x00; //CID: 0 //FIXME: allow multiple selected cards
1863 memcpy(real_cmd+2, cmd, cmd_len);
1864 AppendCrc14443a(real_cmd,cmd_len+2);
1865
9492e0b0 1866 ReaderTransmit(real_cmd, cmd_len+4, NULL);
6a1f2d82 1867 size_t len = ReaderReceive(data, parity);
1868 uint8_t *data_bytes = (uint8_t *) data;
b0127e65 1869 if (!len)
1870 return 0; //DATA LINK ERROR
1871 // if we received an I- or R(ACK)-Block with a block number equal to the
1872 // current block number, toggle the current block number
1873 else if (len >= 4 // PCB+CID+CRC = 4 bytes
1874 && ((data_bytes[0] & 0xC0) == 0 // I-Block
1875 || (data_bytes[0] & 0xD0) == 0x80) // R-Block with ACK bit set to 0
1876 && (data_bytes[0] & 0x01) == iso14_pcb_blocknum) // equal block numbers
1877 {
1878 iso14_pcb_blocknum ^= 1;
1879 }
1880
534983d7 1881 return len;
1882}
1883
7e758047 1884//-----------------------------------------------------------------------------
1885// Read an ISO 14443a tag. Send out commands and store answers.
1886//
1887//-----------------------------------------------------------------------------
7bc95e2e 1888void ReaderIso14443a(UsbCommand *c)
7e758047 1889{
534983d7 1890 iso14a_command_t param = c->arg[0];
7bc95e2e 1891 uint8_t *cmd = c->d.asBytes;
04bc1c66 1892 size_t len = c->arg[1] & 0xffff;
1893 size_t lenbits = c->arg[1] >> 16;
1894 uint32_t timeout = c->arg[2];
9492e0b0 1895 uint32_t arg0 = 0;
1896 byte_t buf[USB_CMD_DATA_SIZE];
6a1f2d82 1897 uint8_t par[MAX_PARITY_SIZE];
902cb3c0 1898
5f6d6c90 1899 if(param & ISO14A_CONNECT) {
3000dc4e 1900 clear_trace();
5f6d6c90 1901 }
e691fc45 1902
3000dc4e 1903 set_tracing(TRUE);
e30c654b 1904
79a73ab2 1905 if(param & ISO14A_REQUEST_TRIGGER) {
7bc95e2e 1906 iso14a_set_trigger(TRUE);
9492e0b0 1907 }
15c4dc5a 1908
534983d7 1909 if(param & ISO14A_CONNECT) {
7bc95e2e 1910 iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);
5f6d6c90 1911 if(!(param & ISO14A_NO_SELECT)) {
1912 iso14a_card_select_t *card = (iso14a_card_select_t*)buf;
1913 arg0 = iso14443a_select_card(NULL,card,NULL);
1914 cmd_send(CMD_ACK,arg0,card->uidlen,0,buf,sizeof(iso14a_card_select_t));
1915 }
534983d7 1916 }
e30c654b 1917
534983d7 1918 if(param & ISO14A_SET_TIMEOUT) {
04bc1c66 1919 iso14a_set_timeout(timeout);
534983d7 1920 }
e30c654b 1921
534983d7 1922 if(param & ISO14A_APDU) {
902cb3c0 1923 arg0 = iso14_apdu(cmd, len, buf);
79a73ab2 1924 cmd_send(CMD_ACK,arg0,0,0,buf,sizeof(buf));
534983d7 1925 }
e30c654b 1926
534983d7 1927 if(param & ISO14A_RAW) {
1928 if(param & ISO14A_APPEND_CRC) {
1929 AppendCrc14443a(cmd,len);
1930 len += 2;
c7324bef 1931 if (lenbits) lenbits += 16;
15c4dc5a 1932 }
5f6d6c90 1933 if(lenbits>0) {
6a1f2d82 1934 GetParity(cmd, lenbits/8, par);
1935 ReaderTransmitBitsPar(cmd, lenbits, par, NULL);
5f6d6c90 1936 } else {
1937 ReaderTransmit(cmd,len, NULL);
1938 }
6a1f2d82 1939 arg0 = ReaderReceive(buf, par);
9492e0b0 1940 cmd_send(CMD_ACK,arg0,0,0,buf,sizeof(buf));
534983d7 1941 }
15c4dc5a 1942
79a73ab2 1943 if(param & ISO14A_REQUEST_TRIGGER) {
7bc95e2e 1944 iso14a_set_trigger(FALSE);
9492e0b0 1945 }
15c4dc5a 1946
79a73ab2 1947 if(param & ISO14A_NO_DISCONNECT) {
534983d7 1948 return;
9492e0b0 1949 }
15c4dc5a 1950
15c4dc5a 1951 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
1952 LEDsoff();
15c4dc5a 1953}
b0127e65 1954
1c611bbd 1955
1c611bbd 1956// Determine the distance between two nonces.
1957// Assume that the difference is small, but we don't know which is first.
1958// Therefore try in alternating directions.
1959int32_t dist_nt(uint32_t nt1, uint32_t nt2) {
1960
1961 uint16_t i;
1962 uint32_t nttmp1, nttmp2;
e772353f 1963
1c611bbd 1964 if (nt1 == nt2) return 0;
1965
1966 nttmp1 = nt1;
1967 nttmp2 = nt2;
1968
1969 for (i = 1; i < 32768; i++) {
1970 nttmp1 = prng_successor(nttmp1, 1);
1971 if (nttmp1 == nt2) return i;
1972 nttmp2 = prng_successor(nttmp2, 1);
dc8ba239 1973 if (nttmp2 == nt1) return -i;
1c611bbd 1974 }
1975
1976 return(-99999); // either nt1 or nt2 are invalid nonces
e772353f 1977}
1978
e772353f 1979
1c611bbd 1980//-----------------------------------------------------------------------------
1981// Recover several bits of the cypher stream. This implements (first stages of)
1982// the algorithm described in "The Dark Side of Security by Obscurity and
1983// Cloning MiFare Classic Rail and Building Passes, Anywhere, Anytime"
1984// (article by Nicolas T. Courtois, 2009)
1985//-----------------------------------------------------------------------------
1986void ReaderMifare(bool first_try)
1987{
1988 // Mifare AUTH
1989 uint8_t mf_auth[] = { 0x60,0x00,0xf5,0x7b };
1990 uint8_t mf_nr_ar[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
1991 static uint8_t mf_nr_ar3;
e772353f 1992
f71f4deb 1993 uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE];
1994 uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE];
7bc95e2e 1995
09ffd16e 1996 if (first_try) {
1997 iso14443a_setup(FPGA_HF_ISO14443A_READER_MOD);
1998 }
1999
f71f4deb 2000 // free eventually allocated BigBuf memory. We want all for tracing.
2001 BigBuf_free();
2002
3000dc4e
MHS
2003 clear_trace();
2004 set_tracing(TRUE);
e772353f 2005
1c611bbd 2006 byte_t nt_diff = 0;
6a1f2d82 2007 uint8_t par[1] = {0}; // maximum 8 Bytes to be sent here, 1 byte parity is therefore enough
1c611bbd 2008 static byte_t par_low = 0;
2009 bool led_on = TRUE;
ca4714cd 2010 uint8_t uid[10] ={0};
1c611bbd 2011 uint32_t cuid;
e772353f 2012
6a1f2d82 2013 uint32_t nt = 0;
2ed270a8 2014 uint32_t previous_nt = 0;
1c611bbd 2015 static uint32_t nt_attacked = 0;
3fe4ff4f 2016 byte_t par_list[8] = {0x00};
2017 byte_t ks_list[8] = {0x00};
e772353f 2018
dfb387bf 2019 #define PRNG_SEQUENCE_LENGTH (1 << 16);
1c611bbd 2020 static uint32_t sync_time;
2021 static uint32_t sync_cycles;
2022 int catch_up_cycles = 0;
2023 int last_catch_up = 0;
2024 uint16_t consecutive_resyncs = 0;
2025 int isOK = 0;
e772353f 2026
1c611bbd 2027 if (first_try) {
1c611bbd 2028 mf_nr_ar3 = 0;
7bc95e2e 2029 sync_time = GetCountSspClk() & 0xfffffff8;
dfb387bf 2030 sync_cycles = PRNG_SEQUENCE_LENGTH; // theory: Mifare Classic's random generator repeats every 2^16 cycles (and so do the tag nonces).
1c611bbd 2031 nt_attacked = 0;
2032 nt = 0;
6a1f2d82 2033 par[0] = 0;
1c611bbd 2034 }
2035 else {
2036 // we were unsuccessful on a previous call. Try another READER nonce (first 3 parity bits remain the same)
1c611bbd 2037 mf_nr_ar3++;
2038 mf_nr_ar[3] = mf_nr_ar3;
6a1f2d82 2039 par[0] = par_low;
1c611bbd 2040 }
e30c654b 2041
15c4dc5a 2042 LED_A_ON();
2043 LED_B_OFF();
2044 LED_C_OFF();
1c611bbd 2045
dc8ba239 2046
dfb387bf 2047 #define MAX_UNEXPECTED_RANDOM 4 // maximum number of unexpected (i.e. real) random numbers when trying to sync. Then give up.
2048 #define MAX_SYNC_TRIES 16
2049 uint16_t unexpected_random = 0;
2050 uint16_t sync_tries = 0;
2051 int16_t debug_info_nr = -1;
2052 uint32_t debug_info[MAX_SYNC_TRIES];
dc8ba239 2053
1c611bbd 2054 for(uint16_t i = 0; TRUE; i++) {
2055
dc8ba239 2056 LED_C_ON();
1c611bbd 2057 WDT_HIT();
e30c654b 2058
1c611bbd 2059 // Test if the action was cancelled
2060 if(BUTTON_PRESS()) {
dc8ba239 2061 isOK = -1;
1c611bbd 2062 break;
2063 }
2064
1c611bbd 2065 if(!iso14443a_select_card(uid, NULL, &cuid)) {
9492e0b0 2066 if (MF_DBGLEVEL >= 1) Dbprintf("Mifare: Can't select card");
1c611bbd 2067 continue;
2068 }
2069
dfb387bf 2070 if (debug_info_nr == -1) {
2071 sync_time = (sync_time & 0xfffffff8) + sync_cycles + catch_up_cycles;
2072 catch_up_cycles = 0;
1c611bbd 2073
dfb387bf 2074 // if we missed the sync time already, advance to the next nonce repeat
2075 while(GetCountSspClk() > sync_time) {
2076 sync_time = (sync_time & 0xfffffff8) + sync_cycles;
2077 }
e30c654b 2078
dfb387bf 2079 // Transmit MIFARE_CLASSIC_AUTH at synctime. Should result in returning the same tag nonce (== nt_attacked)
2080 ReaderTransmit(mf_auth, sizeof(mf_auth), &sync_time);
2081 } else {
2082 ReaderTransmit(mf_auth, sizeof(mf_auth), NULL);
2083 }
f89c7050 2084
1c611bbd 2085 // Receive the (4 Byte) "random" nonce
6a1f2d82 2086 if (!ReaderReceive(receivedAnswer, receivedAnswerPar)) {
9492e0b0 2087 if (MF_DBGLEVEL >= 1) Dbprintf("Mifare: Couldn't receive tag nonce");
1c611bbd 2088 continue;
2089 }
2090
1c611bbd 2091 previous_nt = nt;
2092 nt = bytes_to_num(receivedAnswer, 4);
2093
2094 // Transmit reader nonce with fake par
9492e0b0 2095 ReaderTransmitPar(mf_nr_ar, sizeof(mf_nr_ar), par, NULL);
1c611bbd 2096
2097 if (first_try && previous_nt && !nt_attacked) { // we didn't calibrate our clock yet
2098 int nt_distance = dist_nt(previous_nt, nt);
2099 if (nt_distance == 0) {
2100 nt_attacked = nt;
dfb387bf 2101 } else {
dc8ba239 2102 if (nt_distance == -99999) { // invalid nonce received
dfb387bf 2103 unexpected_random++;
2104 if (!nt_attacked && unexpected_random > MAX_UNEXPECTED_RANDOM) {
dc8ba239 2105 isOK = -3; // Card has an unpredictable PRNG. Give up
2106 break;
2107 } else {
2108 continue; // continue trying...
2109 }
1c611bbd 2110 }
dfb387bf 2111 if (++sync_tries > MAX_SYNC_TRIES) {
2112 if (sync_tries > 2 * MAX_SYNC_TRIES) {
2113 isOK = -4; // Card's PRNG runs at an unexpected frequency or resets unexpectedly
2114 break;
2115 } else { // continue for a while, just to collect some debug info
2116 debug_info[++debug_info_nr] = nt_distance;
2117 continue;
2118 }
2119 }
1c611bbd 2120 sync_cycles = (sync_cycles - nt_distance);
dfb387bf 2121 if (sync_cycles <= 0) {
2122 sync_cycles += PRNG_SEQUENCE_LENGTH;
2123 }
2124 if (MF_DBGLEVEL >= 3) {
2125 Dbprintf("calibrating in cycle %d. nt_distance=%d, Sync_cycles: %d\n", i, nt_distance, sync_cycles);
2126 }
1c611bbd 2127 continue;
2128 }
2129 }
2130
2131 if ((nt != nt_attacked) && nt_attacked) { // we somehow lost sync. Try to catch up again...
2132 catch_up_cycles = -dist_nt(nt_attacked, nt);
2133 if (catch_up_cycles == 99999) { // invalid nonce received. Don't resync on that one.
2134 catch_up_cycles = 0;
2135 continue;
2136 }
2137 if (catch_up_cycles == last_catch_up) {
2138 consecutive_resyncs++;
2139 }
2140 else {
2141 last_catch_up = catch_up_cycles;
2142 consecutive_resyncs = 0;
2143 }
2144 if (consecutive_resyncs < 3) {
9492e0b0 2145 if (MF_DBGLEVEL >= 3) Dbprintf("Lost sync in cycle %d. nt_distance=%d. Consecutive Resyncs = %d. Trying one time catch up...\n", i, -catch_up_cycles, consecutive_resyncs);
1c611bbd 2146 }
2147 else {
2148 sync_cycles = sync_cycles + catch_up_cycles;
9492e0b0 2149 if (MF_DBGLEVEL >= 3) Dbprintf("Lost sync in cycle %d for the fourth time consecutively (nt_distance = %d). Adjusting sync_cycles to %d.\n", i, -catch_up_cycles, sync_cycles);
1c611bbd 2150 }
2151 continue;
2152 }
2153
2154 consecutive_resyncs = 0;
2155
2156 // Receive answer. This will be a 4 Bit NACK when the 8 parity bits are OK after decoding
6a1f2d82 2157 if (ReaderReceive(receivedAnswer, receivedAnswerPar))
1c611bbd 2158 {
9492e0b0 2159 catch_up_cycles = 8; // the PRNG is delayed by 8 cycles due to the NAC (4Bits = 0x05 encrypted) transfer
1c611bbd 2160
2161 if (nt_diff == 0)
2162 {
6a1f2d82 2163 par_low = par[0] & 0xE0; // there is no need to check all parities for other nt_diff. Parity Bits for mf_nr_ar[0..2] won't change
1c611bbd 2164 }
2165
2166 led_on = !led_on;
2167 if(led_on) LED_B_ON(); else LED_B_OFF();
2168
6a1f2d82 2169 par_list[nt_diff] = SwapBits(par[0], 8);
1c611bbd 2170 ks_list[nt_diff] = receivedAnswer[0] ^ 0x05;
2171
2172 // Test if the information is complete
2173 if (nt_diff == 0x07) {
2174 isOK = 1;
2175 break;
2176 }
2177
2178 nt_diff = (nt_diff + 1) & 0x07;
2179 mf_nr_ar[3] = (mf_nr_ar[3] & 0x1F) | (nt_diff << 5);
6a1f2d82 2180 par[0] = par_low;
1c611bbd 2181 } else {
2182 if (nt_diff == 0 && first_try)
2183 {
6a1f2d82 2184 par[0]++;
dc8ba239 2185 if (par[0] == 0x00) { // tried all 256 possible parities without success. Card doesn't send NACK.
2186 isOK = -2;
2187 break;
2188 }
1c611bbd 2189 } else {
6a1f2d82 2190 par[0] = ((par[0] & 0x1F) + 1) | par_low;
1c611bbd 2191 }
2192 }
2193 }
2194
1c611bbd 2195
2196 mf_nr_ar[3] &= 0x1F;
dfb387bf 2197
2198 if (isOK == -4) {
2199 if (MF_DBGLEVEL >= 3) {
2200 for(uint16_t i = 0; i < MAX_SYNC_TRIES; i++) {
2201 Dbprintf("collected debug info[%d] = %d\n", i, debug_info[i]);
2202 }
2203 }
2204 }
1c611bbd 2205
2206 byte_t buf[28];
2207 memcpy(buf + 0, uid, 4);
2208 num_to_bytes(nt, 4, buf + 4);
2209 memcpy(buf + 8, par_list, 8);
2210 memcpy(buf + 16, ks_list, 8);
2211 memcpy(buf + 24, mf_nr_ar, 4);
2212
dc8ba239 2213 cmd_send(CMD_ACK, isOK, 0, 0, buf, 28);
1c611bbd 2214
2215 // Thats it...
2216 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
2217 LEDsoff();
7bc95e2e 2218
3000dc4e 2219 set_tracing(FALSE);
20f9a2a1 2220}
1c611bbd 2221
d2f487af 2222/**
2223 *MIFARE 1K simulate.
2224 *
2225 *@param flags :
2226 * FLAG_INTERACTIVE - In interactive mode, we are expected to finish the operation with an ACK
2227 * 4B_FLAG_UID_IN_DATA - means that there is a 4-byte UID in the data-section, we're expected to use that
2228 * 7B_FLAG_UID_IN_DATA - means that there is a 7-byte UID in the data-section, we're expected to use that
2229 * FLAG_NR_AR_ATTACK - means we should collect NR_AR responses for bruteforcing later
2230 *@param exitAfterNReads, exit simulation after n blocks have been read, 0 is inifite
2231 */
2232void Mifare1ksim(uint8_t flags, uint8_t exitAfterNReads, uint8_t arg2, uint8_t *datain)
20f9a2a1 2233{
50193c1e 2234 int cardSTATE = MFEMUL_NOFIELD;
8556b852 2235 int _7BUID = 0;
9ca155ba 2236 int vHf = 0; // in mV
8f51ddb0 2237 int res;
0a39986e
M
2238 uint32_t selTimer = 0;
2239 uint32_t authTimer = 0;
6a1f2d82 2240 uint16_t len = 0;
8f51ddb0 2241 uint8_t cardWRBL = 0;
9ca155ba
M
2242 uint8_t cardAUTHSC = 0;
2243 uint8_t cardAUTHKEY = 0xff; // no authentication
51969283 2244 uint32_t cardRr = 0;
9ca155ba 2245 uint32_t cuid = 0;
d2f487af 2246 //uint32_t rn_enc = 0;
51969283 2247 uint32_t ans = 0;
0014cb46
M
2248 uint32_t cardINTREG = 0;
2249 uint8_t cardINTBLOCK = 0;
9ca155ba
M
2250 struct Crypto1State mpcs = {0, 0};
2251 struct Crypto1State *pcs;
2252 pcs = &mpcs;
d2f487af 2253 uint32_t numReads = 0;//Counts numer of times reader read a block
f71f4deb 2254 uint8_t receivedCmd[MAX_MIFARE_FRAME_SIZE];
2255 uint8_t receivedCmd_par[MAX_MIFARE_PARITY_SIZE];
2256 uint8_t response[MAX_MIFARE_FRAME_SIZE];
2257 uint8_t response_par[MAX_MIFARE_PARITY_SIZE];
9ca155ba 2258
d2f487af 2259 uint8_t rATQA[] = {0x04, 0x00}; // Mifare classic 1k 4BUID
2260 uint8_t rUIDBCC1[] = {0xde, 0xad, 0xbe, 0xaf, 0x62};
2261 uint8_t rUIDBCC2[] = {0xde, 0xad, 0xbe, 0xaf, 0x62}; // !!!
2262 uint8_t rSAK[] = {0x08, 0xb6, 0xdd};
2263 uint8_t rSAK1[] = {0x04, 0xda, 0x17};
9ca155ba 2264
d2f487af 2265 uint8_t rAUTH_NT[] = {0x01, 0x02, 0x03, 0x04};
2266 uint8_t rAUTH_AT[] = {0x00, 0x00, 0x00, 0x00};
7bc95e2e 2267
d2f487af 2268 //Here, we collect UID,NT,AR,NR,UID2,NT2,AR2,NR2
2269 // This can be used in a reader-only attack.
2270 // (it can also be retrieved via 'hf 14a list', but hey...
2271 uint32_t ar_nr_responses[] = {0,0,0,0,0,0,0,0};
2272 uint8_t ar_nr_collected = 0;
0014cb46 2273
7bc95e2e 2274 // Authenticate response - nonce
51969283 2275 uint32_t nonce = bytes_to_num(rAUTH_NT, 4);
7bc95e2e 2276
d2f487af 2277 //-- Determine the UID
2278 // Can be set from emulator memory, incoming data
2279 // and can be 7 or 4 bytes long
7bc95e2e 2280 if (flags & FLAG_4B_UID_IN_DATA)
d2f487af 2281 {
2282 // 4B uid comes from data-portion of packet
2283 memcpy(rUIDBCC1,datain,4);
8556b852 2284 rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];
8556b852 2285
7bc95e2e 2286 } else if (flags & FLAG_7B_UID_IN_DATA) {
d2f487af 2287 // 7B uid comes from data-portion of packet
2288 memcpy(&rUIDBCC1[1],datain,3);
2289 memcpy(rUIDBCC2, datain+3, 4);
2290 _7BUID = true;
7bc95e2e 2291 } else {
d2f487af 2292 // get UID from emul memory
2293 emlGetMemBt(receivedCmd, 7, 1);
2294 _7BUID = !(receivedCmd[0] == 0x00);
2295 if (!_7BUID) { // ---------- 4BUID
2296 emlGetMemBt(rUIDBCC1, 0, 4);
2297 } else { // ---------- 7BUID
2298 emlGetMemBt(&rUIDBCC1[1], 0, 3);
2299 emlGetMemBt(rUIDBCC2, 3, 4);
2300 }
2301 }
7bc95e2e 2302
d2f487af 2303 /*
2304 * Regardless of what method was used to set the UID, set fifth byte and modify
2305 * the ATQA for 4 or 7-byte UID
2306 */
d2f487af 2307 rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];
7bc95e2e 2308 if (_7BUID) {
d2f487af 2309 rATQA[0] = 0x44;
8556b852 2310 rUIDBCC1[0] = 0x88;
e9b8d0dd 2311 rUIDBCC1[4] = rUIDBCC1[0] ^ rUIDBCC1[1] ^ rUIDBCC1[2] ^ rUIDBCC1[3];
8556b852
M
2312 rUIDBCC2[4] = rUIDBCC2[0] ^ rUIDBCC2[1] ^ rUIDBCC2[2] ^ rUIDBCC2[3];
2313 }
2314
d2f487af 2315 if (MF_DBGLEVEL >= 1) {
2316 if (!_7BUID) {
b03c0f2d 2317 Dbprintf("4B UID: %02x%02x%02x%02x",
2318 rUIDBCC1[0], rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3]);
7bc95e2e 2319 } else {
b03c0f2d 2320 Dbprintf("7B UID: (%02x)%02x%02x%02x%02x%02x%02x%02x",
2321 rUIDBCC1[0], rUIDBCC1[1], rUIDBCC1[2], rUIDBCC1[3],
2322 rUIDBCC2[0], rUIDBCC2[1] ,rUIDBCC2[2], rUIDBCC2[3]);
d2f487af 2323 }
2324 }
7bc95e2e 2325
09ffd16e 2326 // We need to listen to the high-frequency, peak-detected path.
2327 iso14443a_setup(FPGA_HF_ISO14443A_TAGSIM_LISTEN);
2328
2329 // free eventually allocated BigBuf memory but keep Emulator Memory
2330 BigBuf_free_keep_EM();
2331
2332 // clear trace
2333 clear_trace();
2334 set_tracing(TRUE);
2335
2336
7bc95e2e 2337 bool finished = FALSE;
d2f487af 2338 while (!BUTTON_PRESS() && !finished) {
9ca155ba 2339 WDT_HIT();
9ca155ba
M
2340
2341 // find reader field
9ca155ba 2342 if (cardSTATE == MFEMUL_NOFIELD) {
0c8d25eb 2343 vHf = (MAX_ADC_HF_VOLTAGE * AvgAdc(ADC_CHAN_HF)) >> 10;
9ca155ba 2344 if (vHf > MF_MINFIELDV) {
0014cb46 2345 cardSTATE_TO_IDLE();
9ca155ba
M
2346 LED_A_ON();
2347 }
2348 }
d2f487af 2349 if(cardSTATE == MFEMUL_NOFIELD) continue;
9ca155ba 2350
d2f487af 2351 //Now, get data
2352
6a1f2d82 2353 res = EmGetCmd(receivedCmd, &len, receivedCmd_par);
d2f487af 2354 if (res == 2) { //Field is off!
2355 cardSTATE = MFEMUL_NOFIELD;
2356 LEDsoff();
2357 continue;
7bc95e2e 2358 } else if (res == 1) {
2359 break; //return value 1 means button press
2360 }
2361
d2f487af 2362 // REQ or WUP request in ANY state and WUP in HALTED state
2363 if (len == 1 && ((receivedCmd[0] == 0x26 && cardSTATE != MFEMUL_HALTED) || receivedCmd[0] == 0x52)) {
2364 selTimer = GetTickCount();
2365 EmSendCmdEx(rATQA, sizeof(rATQA), (receivedCmd[0] == 0x52));
2366 cardSTATE = MFEMUL_SELECT1;
2367
2368 // init crypto block
2369 LED_B_OFF();
2370 LED_C_OFF();
2371 crypto1_destroy(pcs);
2372 cardAUTHKEY = 0xff;
2373 continue;
0a39986e 2374 }
7bc95e2e 2375
50193c1e 2376 switch (cardSTATE) {
d2f487af 2377 case MFEMUL_NOFIELD:
2378 case MFEMUL_HALTED:
50193c1e 2379 case MFEMUL_IDLE:{
6a1f2d82 2380 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
50193c1e
M
2381 break;
2382 }
2383 case MFEMUL_SELECT1:{
9ca155ba
M
2384 // select all
2385 if (len == 2 && (receivedCmd[0] == 0x93 && receivedCmd[1] == 0x20)) {
d2f487af 2386 if (MF_DBGLEVEL >= 4) Dbprintf("SELECT ALL received");
9ca155ba 2387 EmSendCmd(rUIDBCC1, sizeof(rUIDBCC1));
0014cb46 2388 break;
9ca155ba
M
2389 }
2390
d2f487af 2391 if (MF_DBGLEVEL >= 4 && len == 9 && receivedCmd[0] == 0x93 && receivedCmd[1] == 0x70 )
2392 {
2393 Dbprintf("SELECT %02x%02x%02x%02x received",receivedCmd[2],receivedCmd[3],receivedCmd[4],receivedCmd[5]);
2394 }
9ca155ba 2395 // select card
0a39986e
M
2396 if (len == 9 &&
2397 (receivedCmd[0] == 0x93 && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], rUIDBCC1, 4) == 0)) {
bfb6a143 2398 EmSendCmd(_7BUID?rSAK1:rSAK, _7BUID?sizeof(rSAK1):sizeof(rSAK));
9ca155ba 2399 cuid = bytes_to_num(rUIDBCC1, 4);
8556b852
M
2400 if (!_7BUID) {
2401 cardSTATE = MFEMUL_WORK;
0014cb46
M
2402 LED_B_ON();
2403 if (MF_DBGLEVEL >= 4) Dbprintf("--> WORK. anticol1 time: %d", GetTickCount() - selTimer);
2404 break;
8556b852
M
2405 } else {
2406 cardSTATE = MFEMUL_SELECT2;
8556b852 2407 }
9ca155ba 2408 }
50193c1e
M
2409 break;
2410 }
d2f487af 2411 case MFEMUL_AUTH1:{
2412 if( len != 8)
2413 {
2414 cardSTATE_TO_IDLE();
6a1f2d82 2415 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
d2f487af 2416 break;
2417 }
0c8d25eb 2418
d2f487af 2419 uint32_t ar = bytes_to_num(receivedCmd, 4);
6a1f2d82 2420 uint32_t nr = bytes_to_num(&receivedCmd[4], 4);
d2f487af 2421
2422 //Collect AR/NR
2423 if(ar_nr_collected < 2){
273b57a7 2424 if(ar_nr_responses[2] != ar)
2425 {// Avoid duplicates... probably not necessary, ar should vary.
d2f487af 2426 ar_nr_responses[ar_nr_collected*4] = cuid;
2427 ar_nr_responses[ar_nr_collected*4+1] = nonce;
2428 ar_nr_responses[ar_nr_collected*4+2] = ar;
2429 ar_nr_responses[ar_nr_collected*4+3] = nr;
273b57a7 2430 ar_nr_collected++;
d2f487af 2431 }
2432 }
2433
2434 // --- crypto
2435 crypto1_word(pcs, ar , 1);
2436 cardRr = nr ^ crypto1_word(pcs, 0, 0);
2437
2438 // test if auth OK
2439 if (cardRr != prng_successor(nonce, 64)){
b03c0f2d 2440 if (MF_DBGLEVEL >= 2) Dbprintf("AUTH FAILED for sector %d with key %c. cardRr=%08x, succ=%08x",
2441 cardAUTHSC, cardAUTHKEY == 0 ? 'A' : 'B',
2442 cardRr, prng_successor(nonce, 64));
7bc95e2e 2443 // Shouldn't we respond anything here?
d2f487af 2444 // Right now, we don't nack or anything, which causes the
2445 // reader to do a WUPA after a while. /Martin
b03c0f2d 2446 // -- which is the correct response. /piwi
d2f487af 2447 cardSTATE_TO_IDLE();
6a1f2d82 2448 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
d2f487af 2449 break;
2450 }
2451
2452 ans = prng_successor(nonce, 96) ^ crypto1_word(pcs, 0, 0);
2453
2454 num_to_bytes(ans, 4, rAUTH_AT);
2455 // --- crypto
2456 EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));
2457 LED_C_ON();
2458 cardSTATE = MFEMUL_WORK;
b03c0f2d 2459 if (MF_DBGLEVEL >= 4) Dbprintf("AUTH COMPLETED for sector %d with key %c. time=%d",
2460 cardAUTHSC, cardAUTHKEY == 0 ? 'A' : 'B',
2461 GetTickCount() - authTimer);
d2f487af 2462 break;
2463 }
50193c1e 2464 case MFEMUL_SELECT2:{
7bc95e2e 2465 if (!len) {
6a1f2d82 2466 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 2467 break;
2468 }
8556b852 2469 if (len == 2 && (receivedCmd[0] == 0x95 && receivedCmd[1] == 0x20)) {
9ca155ba 2470 EmSendCmd(rUIDBCC2, sizeof(rUIDBCC2));
8556b852
M
2471 break;
2472 }
9ca155ba 2473
8556b852
M
2474 // select 2 card
2475 if (len == 9 &&
2476 (receivedCmd[0] == 0x95 && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], rUIDBCC2, 4) == 0)) {
2477 EmSendCmd(rSAK, sizeof(rSAK));
8556b852
M
2478 cuid = bytes_to_num(rUIDBCC2, 4);
2479 cardSTATE = MFEMUL_WORK;
2480 LED_B_ON();
0014cb46 2481 if (MF_DBGLEVEL >= 4) Dbprintf("--> WORK. anticol2 time: %d", GetTickCount() - selTimer);
8556b852
M
2482 break;
2483 }
0014cb46
M
2484
2485 // i guess there is a command). go into the work state.
7bc95e2e 2486 if (len != 4) {
6a1f2d82 2487 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 2488 break;
2489 }
0014cb46 2490 cardSTATE = MFEMUL_WORK;
d2f487af 2491 //goto lbWORK;
2492 //intentional fall-through to the next case-stmt
50193c1e 2493 }
51969283 2494
7bc95e2e 2495 case MFEMUL_WORK:{
2496 if (len == 0) {
6a1f2d82 2497 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 2498 break;
2499 }
2500
d2f487af 2501 bool encrypted_data = (cardAUTHKEY != 0xFF) ;
2502
7bc95e2e 2503 if(encrypted_data) {
51969283
M
2504 // decrypt seqence
2505 mf_crypto1_decrypt(pcs, receivedCmd, len);
d2f487af 2506 }
7bc95e2e 2507
d2f487af 2508 if (len == 4 && (receivedCmd[0] == 0x60 || receivedCmd[0] == 0x61)) {
2509 authTimer = GetTickCount();
2510 cardAUTHSC = receivedCmd[1] / 4; // received block num
2511 cardAUTHKEY = receivedCmd[0] - 0x60;
2512 crypto1_destroy(pcs);//Added by martin
2513 crypto1_create(pcs, emlGetKey(cardAUTHSC, cardAUTHKEY));
51969283 2514
d2f487af 2515 if (!encrypted_data) { // first authentication
b03c0f2d 2516 if (MF_DBGLEVEL >= 4) Dbprintf("Reader authenticating for block %d (0x%02x) with key %d",receivedCmd[1] ,receivedCmd[1],cardAUTHKEY );
51969283 2517
d2f487af 2518 crypto1_word(pcs, cuid ^ nonce, 0);//Update crypto state
2519 num_to_bytes(nonce, 4, rAUTH_AT); // Send nonce
7bc95e2e 2520 } else { // nested authentication
b03c0f2d 2521 if (MF_DBGLEVEL >= 4) Dbprintf("Reader doing nested authentication for block %d (0x%02x) with key %d",receivedCmd[1] ,receivedCmd[1],cardAUTHKEY );
7bc95e2e 2522 ans = nonce ^ crypto1_word(pcs, cuid ^ nonce, 0);
d2f487af 2523 num_to_bytes(ans, 4, rAUTH_AT);
2524 }
0c8d25eb 2525
d2f487af 2526 EmSendCmd(rAUTH_AT, sizeof(rAUTH_AT));
2527 //Dbprintf("Sending rAUTH %02x%02x%02x%02x", rAUTH_AT[0],rAUTH_AT[1],rAUTH_AT[2],rAUTH_AT[3]);
2528 cardSTATE = MFEMUL_AUTH1;
2529 break;
51969283 2530 }
7bc95e2e 2531
8f51ddb0
M
2532 // rule 13 of 7.5.3. in ISO 14443-4. chaining shall be continued
2533 // BUT... ACK --> NACK
2534 if (len == 1 && receivedCmd[0] == CARD_ACK) {
2535 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2536 break;
2537 }
2538
2539 // rule 12 of 7.5.3. in ISO 14443-4. R(NAK) --> R(ACK)
2540 if (len == 1 && receivedCmd[0] == CARD_NACK_NA) {
2541 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
2542 break;
0a39986e
M
2543 }
2544
7bc95e2e 2545 if(len != 4) {
6a1f2d82 2546 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
7bc95e2e 2547 break;
2548 }
d2f487af 2549
2550 if(receivedCmd[0] == 0x30 // read block
2551 || receivedCmd[0] == 0xA0 // write block
b03c0f2d 2552 || receivedCmd[0] == 0xC0 // inc
2553 || receivedCmd[0] == 0xC1 // dec
2554 || receivedCmd[0] == 0xC2 // restore
7bc95e2e 2555 || receivedCmd[0] == 0xB0) { // transfer
2556 if (receivedCmd[1] >= 16 * 4) {
d2f487af 2557 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
e35031d2 2558 if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate (0x%02x) on out of range block: %d (0x%02x), nacking",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
d2f487af 2559 break;
2560 }
2561
7bc95e2e 2562 if (receivedCmd[1] / 4 != cardAUTHSC) {
8f51ddb0 2563 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
e35031d2 2564 if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate (0x%02x) on block (0x%02x) not authenticated for (0x%02x), nacking",receivedCmd[0],receivedCmd[1],cardAUTHSC);
8f51ddb0
M
2565 break;
2566 }
d2f487af 2567 }
2568 // read block
2569 if (receivedCmd[0] == 0x30) {
b03c0f2d 2570 if (MF_DBGLEVEL >= 4) {
d2f487af 2571 Dbprintf("Reader reading block %d (0x%02x)",receivedCmd[1],receivedCmd[1]);
2572 }
8f51ddb0
M
2573 emlGetMem(response, receivedCmd[1], 1);
2574 AppendCrc14443a(response, 16);
6a1f2d82 2575 mf_crypto1_encrypt(pcs, response, 18, response_par);
2576 EmSendCmdPar(response, 18, response_par);
d2f487af 2577 numReads++;
7bc95e2e 2578 if(exitAfterNReads > 0 && numReads == exitAfterNReads) {
d2f487af 2579 Dbprintf("%d reads done, exiting", numReads);
2580 finished = true;
2581 }
0a39986e
M
2582 break;
2583 }
0a39986e 2584 // write block
d2f487af 2585 if (receivedCmd[0] == 0xA0) {
b03c0f2d 2586 if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0xA0 write block %d (%02x)",receivedCmd[1],receivedCmd[1]);
8f51ddb0 2587 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
8f51ddb0
M
2588 cardSTATE = MFEMUL_WRITEBL2;
2589 cardWRBL = receivedCmd[1];
0a39986e 2590 break;
7bc95e2e 2591 }
0014cb46 2592 // increment, decrement, restore
d2f487af 2593 if (receivedCmd[0] == 0xC0 || receivedCmd[0] == 0xC1 || receivedCmd[0] == 0xC2) {
b03c0f2d 2594 if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0x%02x inc(0xC1)/dec(0xC0)/restore(0xC2) block %d (%02x)",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
d2f487af 2595 if (emlCheckValBl(receivedCmd[1])) {
2596 if (MF_DBGLEVEL >= 2) Dbprintf("Reader tried to operate on block, but emlCheckValBl failed, nacking");
0014cb46
M
2597 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2598 break;
2599 }
2600 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
2601 if (receivedCmd[0] == 0xC1)
2602 cardSTATE = MFEMUL_INTREG_INC;
2603 if (receivedCmd[0] == 0xC0)
2604 cardSTATE = MFEMUL_INTREG_DEC;
2605 if (receivedCmd[0] == 0xC2)
2606 cardSTATE = MFEMUL_INTREG_REST;
2607 cardWRBL = receivedCmd[1];
0014cb46
M
2608 break;
2609 }
0014cb46 2610 // transfer
d2f487af 2611 if (receivedCmd[0] == 0xB0) {
b03c0f2d 2612 if (MF_DBGLEVEL >= 4) Dbprintf("RECV 0x%02x transfer block %d (%02x)",receivedCmd[0],receivedCmd[1],receivedCmd[1]);
0014cb46
M
2613 if (emlSetValBl(cardINTREG, cardINTBLOCK, receivedCmd[1]))
2614 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2615 else
2616 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
0014cb46
M
2617 break;
2618 }
9ca155ba 2619 // halt
d2f487af 2620 if (receivedCmd[0] == 0x50 && receivedCmd[1] == 0x00) {
9ca155ba 2621 LED_B_OFF();
0a39986e 2622 LED_C_OFF();
0014cb46
M
2623 cardSTATE = MFEMUL_HALTED;
2624 if (MF_DBGLEVEL >= 4) Dbprintf("--> HALTED. Selected time: %d ms", GetTickCount() - selTimer);
6a1f2d82 2625 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
0a39986e 2626 break;
9ca155ba 2627 }
d2f487af 2628 // RATS
2629 if (receivedCmd[0] == 0xe0) {//RATS
8f51ddb0
M
2630 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2631 break;
2632 }
d2f487af 2633 // command not allowed
2634 if (MF_DBGLEVEL >= 4) Dbprintf("Received command not allowed, nacking");
2635 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
51969283 2636 break;
8f51ddb0
M
2637 }
2638 case MFEMUL_WRITEBL2:{
2639 if (len == 18){
2640 mf_crypto1_decrypt(pcs, receivedCmd, len);
2641 emlSetMem(receivedCmd, cardWRBL, 1);
2642 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_ACK));
2643 cardSTATE = MFEMUL_WORK;
51969283 2644 } else {
0014cb46 2645 cardSTATE_TO_IDLE();
6a1f2d82 2646 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
8f51ddb0 2647 }
8f51ddb0 2648 break;
50193c1e 2649 }
0014cb46
M
2650
2651 case MFEMUL_INTREG_INC:{
2652 mf_crypto1_decrypt(pcs, receivedCmd, len);
2653 memcpy(&ans, receivedCmd, 4);
2654 if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {
2655 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2656 cardSTATE_TO_IDLE();
2657 break;
7bc95e2e 2658 }
6a1f2d82 2659 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
0014cb46
M
2660 cardINTREG = cardINTREG + ans;
2661 cardSTATE = MFEMUL_WORK;
2662 break;
2663 }
2664 case MFEMUL_INTREG_DEC:{
2665 mf_crypto1_decrypt(pcs, receivedCmd, len);
2666 memcpy(&ans, receivedCmd, 4);
2667 if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {
2668 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2669 cardSTATE_TO_IDLE();
2670 break;
2671 }
6a1f2d82 2672 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
0014cb46
M
2673 cardINTREG = cardINTREG - ans;
2674 cardSTATE = MFEMUL_WORK;
2675 break;
2676 }
2677 case MFEMUL_INTREG_REST:{
2678 mf_crypto1_decrypt(pcs, receivedCmd, len);
2679 memcpy(&ans, receivedCmd, 4);
2680 if (emlGetValBl(&cardINTREG, &cardINTBLOCK, cardWRBL)) {
2681 EmSend4bit(mf_crypto1_encrypt4bit(pcs, CARD_NACK_NA));
2682 cardSTATE_TO_IDLE();
2683 break;
2684 }
6a1f2d82 2685 LogTrace(Uart.output, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE);
0014cb46
M
2686 cardSTATE = MFEMUL_WORK;
2687 break;
2688 }
50193c1e 2689 }
50193c1e
M
2690 }
2691
9ca155ba
M
2692 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
2693 LEDsoff();
2694
d2f487af 2695 if(flags & FLAG_INTERACTIVE)// Interactive mode flag, means we need to send ACK
2696 {
2697 //May just aswell send the collected ar_nr in the response aswell
2698 cmd_send(CMD_ACK,CMD_SIMULATE_MIFARE_CARD,0,0,&ar_nr_responses,ar_nr_collected*4*4);
2699 }
d714d3ef 2700
d2f487af 2701 if(flags & FLAG_NR_AR_ATTACK)
2702 {
7bc95e2e 2703 if(ar_nr_collected > 1) {
d2f487af 2704 Dbprintf("Collected two pairs of AR/NR which can be used to extract keys from reader:");
d714d3ef 2705 Dbprintf("../tools/mfkey/mfkey32 %08x %08x %08x %08x %08x %08x",
0c8d25eb 2706 ar_nr_responses[0], // UID
d2f487af 2707 ar_nr_responses[1], //NT
2708 ar_nr_responses[2], //AR1
2709 ar_nr_responses[3], //NR1
2710 ar_nr_responses[6], //AR2
2711 ar_nr_responses[7] //NR2
2712 );
7bc95e2e 2713 } else {
d2f487af 2714 Dbprintf("Failed to obtain two AR/NR pairs!");
7bc95e2e 2715 if(ar_nr_collected >0) {
d714d3ef 2716 Dbprintf("Only got these: UID=%08x, nonce=%08x, AR1=%08x, NR1=%08x",
d2f487af 2717 ar_nr_responses[0], // UID
2718 ar_nr_responses[1], //NT
2719 ar_nr_responses[2], //AR1
2720 ar_nr_responses[3] //NR1
2721 );
2722 }
2723 }
2724 }
3000dc4e 2725 if (MF_DBGLEVEL >= 1) Dbprintf("Emulator stopped. Tracing: %d trace length: %d ", tracing, BigBuf_get_traceLen());
0c8d25eb 2726
15c4dc5a 2727}
b62a5a84 2728
d2f487af 2729
2730
b62a5a84
M
2731//-----------------------------------------------------------------------------
2732// MIFARE sniffer.
2733//
2734//-----------------------------------------------------------------------------
5cd9ec01
M
2735void RAMFUNC SniffMifare(uint8_t param) {
2736 // param:
2737 // bit 0 - trigger from first card answer
2738 // bit 1 - trigger from first reader 7-bit request
39864b0b
M
2739
2740 // C(red) A(yellow) B(green)
b62a5a84
M
2741 LEDsoff();
2742 // init trace buffer
3000dc4e
MHS
2743 clear_trace();
2744 set_tracing(TRUE);
b62a5a84 2745
b62a5a84
M
2746 // The command (reader -> tag) that we're receiving.
2747 // The length of a received command will in most cases be no more than 18 bytes.
2748 // So 32 should be enough!
f71f4deb 2749 uint8_t receivedCmd[MAX_MIFARE_FRAME_SIZE];
2750 uint8_t receivedCmdPar[MAX_MIFARE_PARITY_SIZE];
b62a5a84 2751 // The response (tag -> reader) that we're receiving.
f71f4deb 2752 uint8_t receivedResponse[MAX_MIFARE_FRAME_SIZE];
2753 uint8_t receivedResponsePar[MAX_MIFARE_PARITY_SIZE];
b62a5a84 2754
09ffd16e 2755 iso14443a_setup(FPGA_HF_ISO14443A_SNIFFER);
2756
f71f4deb 2757 // free eventually allocated BigBuf memory
2758 BigBuf_free();
2759 // allocate the DMA buffer, used to stream samples from the FPGA
2760 uint8_t *dmaBuf = BigBuf_malloc(DMA_BUFFER_SIZE);
7bc95e2e 2761 uint8_t *data = dmaBuf;
2762 uint8_t previous_data = 0;
5cd9ec01
M
2763 int maxDataLen = 0;
2764 int dataLen = 0;
7bc95e2e 2765 bool ReaderIsActive = FALSE;
2766 bool TagIsActive = FALSE;
2767
b62a5a84 2768 // Set up the demodulator for tag -> reader responses.
6a1f2d82 2769 DemodInit(receivedResponse, receivedResponsePar);
b62a5a84
M
2770
2771 // Set up the demodulator for the reader -> tag commands
6a1f2d82 2772 UartInit(receivedCmd, receivedCmdPar);
b62a5a84
M
2773
2774 // Setup for the DMA.
7bc95e2e 2775 FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE); // set transfer address and number of bytes. Start transfer.
b62a5a84 2776
b62a5a84 2777 LED_D_OFF();
39864b0b
M
2778
2779 // init sniffer
2780 MfSniffInit();
b62a5a84 2781
b62a5a84 2782 // And now we loop, receiving samples.
7bc95e2e 2783 for(uint32_t sniffCounter = 0; TRUE; ) {
2784
5cd9ec01
M
2785 if(BUTTON_PRESS()) {
2786 DbpString("cancelled by button");
7bc95e2e 2787 break;
5cd9ec01
M
2788 }
2789
b62a5a84
M
2790 LED_A_ON();
2791 WDT_HIT();
39864b0b 2792
7bc95e2e 2793 if ((sniffCounter & 0x0000FFFF) == 0) { // from time to time
2794 // check if a transaction is completed (timeout after 2000ms).
2795 // if yes, stop the DMA transfer and send what we have so far to the client
2796 if (MfSniffSend(2000)) {
2797 // Reset everything - we missed some sniffed data anyway while the DMA was stopped
2798 sniffCounter = 0;
2799 data = dmaBuf;
2800 maxDataLen = 0;
2801 ReaderIsActive = FALSE;
2802 TagIsActive = FALSE;
2803 FpgaSetupSscDma((uint8_t *)dmaBuf, DMA_BUFFER_SIZE); // set transfer address and number of bytes. Start transfer.
39864b0b 2804 }
39864b0b 2805 }
7bc95e2e 2806
2807 int register readBufDataP = data - dmaBuf; // number of bytes we have processed so far
2808 int register dmaBufDataP = DMA_BUFFER_SIZE - AT91C_BASE_PDC_SSC->PDC_RCR; // number of bytes already transferred
2809 if (readBufDataP <= dmaBufDataP){ // we are processing the same block of data which is currently being transferred
2810 dataLen = dmaBufDataP - readBufDataP; // number of bytes still to be processed
2811 } else {
2812 dataLen = DMA_BUFFER_SIZE - readBufDataP + dmaBufDataP; // number of bytes still to be processed
5cd9ec01
M
2813 }
2814 // test for length of buffer
7bc95e2e 2815 if(dataLen > maxDataLen) { // we are more behind than ever...
2816 maxDataLen = dataLen;
f71f4deb 2817 if(dataLen > (9 * DMA_BUFFER_SIZE / 10)) {
5cd9ec01 2818 Dbprintf("blew circular buffer! dataLen=0x%x", dataLen);
7bc95e2e 2819 break;
b62a5a84
M
2820 }
2821 }
5cd9ec01 2822 if(dataLen < 1) continue;
b62a5a84 2823
7bc95e2e 2824 // primary buffer was stopped ( <-- we lost data!
5cd9ec01
M
2825 if (!AT91C_BASE_PDC_SSC->PDC_RCR) {
2826 AT91C_BASE_PDC_SSC->PDC_RPR = (uint32_t) dmaBuf;
2827 AT91C_BASE_PDC_SSC->PDC_RCR = DMA_BUFFER_SIZE;
55acbb2a 2828 Dbprintf("RxEmpty ERROR!!! data length:%d", dataLen); // temporary
5cd9ec01
M
2829 }
2830 // secondary buffer sets as primary, secondary buffer was stopped
2831 if (!AT91C_BASE_PDC_SSC->PDC_RNCR) {
2832 AT91C_BASE_PDC_SSC->PDC_RNPR = (uint32_t) dmaBuf;
b62a5a84
M
2833 AT91C_BASE_PDC_SSC->PDC_RNCR = DMA_BUFFER_SIZE;
2834 }
5cd9ec01
M
2835
2836 LED_A_OFF();
b62a5a84 2837
7bc95e2e 2838 if (sniffCounter & 0x01) {
b62a5a84 2839
7bc95e2e 2840 if(!TagIsActive) { // no need to try decoding tag data if the reader is sending
2841 uint8_t readerdata = (previous_data & 0xF0) | (*data >> 4);
2842 if(MillerDecoding(readerdata, (sniffCounter-1)*4)) {
2843 LED_C_INV();
6a1f2d82 2844 if (MfSniffLogic(receivedCmd, Uart.len, Uart.parity, Uart.bitCount, TRUE)) break;
b62a5a84 2845
7bc95e2e 2846 /* And ready to receive another command. */
2847 UartReset();
2848
2849 /* And also reset the demod code */
2850 DemodReset();
2851 }
2852 ReaderIsActive = (Uart.state != STATE_UNSYNCD);
2853 }
2854
2855 if(!ReaderIsActive) { // no need to try decoding tag data if the reader is sending
2856 uint8_t tagdata = (previous_data << 4) | (*data & 0x0F);
2857 if(ManchesterDecoding(tagdata, 0, (sniffCounter-1)*4)) {
2858 LED_C_INV();
b62a5a84 2859
6a1f2d82 2860 if (MfSniffLogic(receivedResponse, Demod.len, Demod.parity, Demod.bitCount, FALSE)) break;
39864b0b 2861
7bc95e2e 2862 // And ready to receive another response.
2863 DemodReset();
2864 }
2865 TagIsActive = (Demod.state != DEMOD_UNSYNCD);
2866 }
b62a5a84
M
2867 }
2868
7bc95e2e 2869 previous_data = *data;
2870 sniffCounter++;
5cd9ec01 2871 data++;
d714d3ef 2872 if(data == dmaBuf + DMA_BUFFER_SIZE) {
5cd9ec01 2873 data = dmaBuf;
b62a5a84 2874 }
7bc95e2e 2875
b62a5a84
M
2876 } // main cycle
2877
2878 DbpString("COMMAND FINISHED");
2879
55acbb2a 2880 FpgaDisableSscDma();
39864b0b
M
2881 MfSniffEnd();
2882
7bc95e2e 2883 Dbprintf("maxDataLen=%x, Uart.state=%x, Uart.len=%x", maxDataLen, Uart.state, Uart.len);
b62a5a84 2884 LEDsoff();
3803d529 2885}
Impressum, Datenschutz