]> cvs.zerfleddert.de Git - proxmark3-svn/blame - armsrc/iso15693.c
projects / proxmark3-svn / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
CHG: Updated the README.md
[proxmark3-svn] / armsrc / iso15693.c
CommitLineData
15c4dc5a 1//-----------------------------------------------------------------------------
bd20f8f4 2// Jonathan Westhues, split Nov 2006
3// Modified by Greg Jones, Jan 2009
e6304bca 4// Modified by Adrian Dabrowski "atrox", Mar-Sept 2010,Oct 2011
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.
9//-----------------------------------------------------------------------------
15c4dc5a 10// Routines to support ISO 15693. This includes both the reader software and
11// the `fake tag' modes, but at the moment I've implemented only the reader
12// stuff, and that barely.
bd20f8f4 13// Modified to perform modulation onboard in arm rather than on PC
15c4dc5a 14// Also added additional reader commands (SELECT, READ etc.)
15c4dc5a 15//-----------------------------------------------------------------------------
9455b51c 16// The ISO 15693 describes two transmission modes from reader to tag, and 4
17// transmission modes from tag to reader. As of Mar 2010 this code only
18// supports one of each: "1of4" mode from reader to tag, and the highspeed
19// variant with one subcarrier from card to reader.
20// As long, as the card fully support ISO 15693 this is no problem, since the
21// reader chooses both data rates, but some non-standard tags do not. Further for
22// the simulation to work, we will need to support all data rates.
23//
24// VCD (reader) -> VICC (tag)
25// 1 out of 256:
26// data rate: 1,66 kbit/s (fc/8192)
27// used for long range
28// 1 out of 4:
29// data rate: 26,48 kbit/s (fc/512)
30// used for short range, high speed
31//
32// VICC (tag) -> VCD (reader)
33// Modulation:
34// ASK / one subcarrier (423,75 khz)
35// FSK / two subcarriers (423,75 khz && 484,28 khz)
36// Data Rates / Modes:
37// low ASK: 6,62 kbit/s
38// low FSK: 6.67 kbit/s
39// high ASK: 26,48 kbit/s
40// high FSK: 26,69 kbit/s
41//-----------------------------------------------------------------------------
42// added "1 out of 256" mode (for VCD->PICC) - atrox 20100911
43
44
45// Random Remarks:
46// *) UID is always used "transmission order" (LSB), which is reverse to display order
47
48// TODO / BUGS / ISSUES:
49// *) writing to tags takes longer: we miss the answer from the tag in most cases
50// -> tweak the read-timeout times
51// *) signal decoding from the card is still a bit shaky.
52// *) signal decoding is unable to detect collissions.
53// *) add anti-collission support for inventory-commands
e6304bca 54// *) read security status of a block
9455b51c 55// *) sniffing and simulation do only support one transmission mode. need to support
56// all 8 transmission combinations
57// *) remove or refactor code under "depricated"
58// *) document all the functions
59
bd20f8f4 60
e30c654b 61#include "proxmark3.h"
f7e3ed82 62#include "util.h"
15c4dc5a 63#include "apps.h"
9ab7a6c7 64#include "string.h"
9455b51c 65#include "iso15693tools.h"
902cb3c0 66#include "cmd.h"
15c4dc5a 67
15c4dc5a 68#define arraylen(x) (sizeof(x)/sizeof((x)[0]))
69
9455b51c 70///////////////////////////////////////////////////////////////////////
71// ISO 15693 Part 2 - Air Interface
72// This section basicly contains transmission and receiving of bits
73///////////////////////////////////////////////////////////////////////
74
75#define FrameSOF Iso15693FrameSOF
76#define Logic0 Iso15693Logic0
77#define Logic1 Iso15693Logic1
78#define FrameEOF Iso15693FrameEOF
15c4dc5a 79
9455b51c 80#define Crc(data,datalen) Iso15693Crc(data,datalen)
81#define AddCrc(data,datalen) Iso15693AddCrc(data,datalen)
82#define sprintUID(target,uid) Iso15693sprintUID(target,uid)
15c4dc5a 83
9455b51c 84int DEBUG=0;
85
86
87// ---------------------------
88// Signal Processing
89// ---------------------------
90
91// prepare data using "1 out of 4" code for later transmission
92// resulting data rate is 26,48 kbit/s (fc/512)
93// cmd ... data
94// n ... length of data
f7e3ed82 95static void CodeIso15693AsReader(uint8_t *cmd, int n)
15c4dc5a 96{
97 int i, j;
98
99 ToSendReset();
100
101 // Give it a bit of slack at the beginning
102 for(i = 0; i < 24; i++) {
103 ToSendStuffBit(1);
104 }
105
9455b51c 106 // SOF for 1of4
15c4dc5a 107 ToSendStuffBit(0);
108 ToSendStuffBit(1);
109 ToSendStuffBit(1);
110 ToSendStuffBit(1);
111 ToSendStuffBit(1);
112 ToSendStuffBit(0);
113 ToSendStuffBit(1);
114 ToSendStuffBit(1);
115 for(i = 0; i < n; i++) {
116 for(j = 0; j < 8; j += 2) {
117 int these = (cmd[i] >> j) & 3;
118 switch(these) {
119 case 0:
120 ToSendStuffBit(1);
121 ToSendStuffBit(0);
122 ToSendStuffBit(1);
123 ToSendStuffBit(1);
124 ToSendStuffBit(1);
125 ToSendStuffBit(1);
126 ToSendStuffBit(1);
127 ToSendStuffBit(1);
128 break;
129 case 1:
130 ToSendStuffBit(1);
131 ToSendStuffBit(1);
132 ToSendStuffBit(1);
133 ToSendStuffBit(0);
134 ToSendStuffBit(1);
135 ToSendStuffBit(1);
136 ToSendStuffBit(1);
137 ToSendStuffBit(1);
138 break;
139 case 2:
140 ToSendStuffBit(1);
141 ToSendStuffBit(1);
142 ToSendStuffBit(1);
143 ToSendStuffBit(1);
144 ToSendStuffBit(1);
145 ToSendStuffBit(0);
146 ToSendStuffBit(1);
147 ToSendStuffBit(1);
148 break;
149 case 3:
150 ToSendStuffBit(1);
151 ToSendStuffBit(1);
152 ToSendStuffBit(1);
153 ToSendStuffBit(1);
154 ToSendStuffBit(1);
155 ToSendStuffBit(1);
156 ToSendStuffBit(1);
157 ToSendStuffBit(0);
158 break;
159 }
160 }
161 }
9455b51c 162 // EOF
15c4dc5a 163 ToSendStuffBit(1);
164 ToSendStuffBit(1);
165 ToSendStuffBit(0);
166 ToSendStuffBit(1);
167
168 // And slack at the end, too.
169 for(i = 0; i < 24; i++) {
170 ToSendStuffBit(1);
171 }
172}
173
9455b51c 174// encode data using "1 out of 256" sheme
175// data rate is 1,66 kbit/s (fc/8192)
176// is designed for more robust communication over longer distances
177static void CodeIso15693AsReader256(uint8_t *cmd, int n)
15c4dc5a 178{
15c4dc5a 179 int i, j;
180
9455b51c 181 ToSendReset();
182
183 // Give it a bit of slack at the beginning
184 for(i = 0; i < 24; i++) {
185 ToSendStuffBit(1);
186 }
187
188 // SOF for 1of256
189 ToSendStuffBit(0);
190 ToSendStuffBit(1);
191 ToSendStuffBit(1);
192 ToSendStuffBit(1);
193 ToSendStuffBit(1);
194 ToSendStuffBit(1);
195 ToSendStuffBit(1);
196 ToSendStuffBit(0);
197
15c4dc5a 198 for(i = 0; i < n; i++) {
9455b51c 199 for (j = 0; j<=255; j++) {
200 if (cmd[i]==j) {
201 ToSendStuffBit(1);
202 ToSendStuffBit(0);
15c4dc5a 203 } else {
9455b51c 204 ToSendStuffBit(1);
205 ToSendStuffBit(1);
206 }
207 }
15c4dc5a 208 }
9455b51c 209 // EOF
210 ToSendStuffBit(1);
211 ToSendStuffBit(1);
212 ToSendStuffBit(0);
213 ToSendStuffBit(1);
15c4dc5a 214
9455b51c 215 // And slack at the end, too.
216 for(i = 0; i < 24; i++) {
217 ToSendStuffBit(1);
218 }
15c4dc5a 219}
220
9455b51c 221
15c4dc5a 222// Transmit the command (to the tag) that was placed in ToSend[].
f7e3ed82 223static void TransmitTo15693Tag(const uint8_t *cmd, int len, int *samples, int *wait)
15c4dc5a 224{
225 int c;
226
227// FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
228 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_TX);
229 if(*wait < 10) { *wait = 10; }
230
231// for(c = 0; c < *wait;) {
232// if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
233// AT91C_BASE_SSC->SSC_THR = 0x00; // For exact timing!
234// c++;
235// }
236// if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
f7e3ed82 237// volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 238// (void)r;
239// }
240// WDT_HIT();
241// }
242
243 c = 0;
244 for(;;) {
245 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
246 AT91C_BASE_SSC->SSC_THR = cmd[c];
247 c++;
248 if(c >= len) {
249 break;
250 }
251 }
252 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
f7e3ed82 253 volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 254 (void)r;
255 }
256 WDT_HIT();
257 }
258 *samples = (c + *wait) << 3;
259}
260
261//-----------------------------------------------------------------------------
262// Transmit the command (to the reader) that was placed in ToSend[].
263//-----------------------------------------------------------------------------
f7e3ed82 264static void TransmitTo15693Reader(const uint8_t *cmd, int len, int *samples, int *wait)
15c4dc5a 265{
3fe4ff4f 266 int c = 0;
267 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR|FPGA_HF_SIMULATOR_MODULATE_424K);
15c4dc5a 268 if(*wait < 10) { *wait = 10; }
269
15c4dc5a 270 for(;;) {
271 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
272 AT91C_BASE_SSC->SSC_THR = cmd[c];
273 c++;
274 if(c >= len) {
275 break;
276 }
277 }
278 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
f7e3ed82 279 volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 280 (void)r;
281 }
282 WDT_HIT();
283 }
284 *samples = (c + *wait) << 3;
285}
286
9455b51c 287
288// Read from Tag
289// Parameters:
290// receivedResponse
291// maxLen
292// samples
293// elapsed
294// returns:
295// number of decoded bytes
f7e3ed82 296static int GetIso15693AnswerFromTag(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed)
15c4dc5a 297{
298 int c = 0;
117d9ec2 299 uint8_t *dest = BigBuf_get_addr();
15c4dc5a 300 int getNext = 0;
301
f7e3ed82 302 int8_t prev = 0;
15c4dc5a 303
304// NOW READ RESPONSE
305 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
306 //spindelay(60); // greg - experiment to get rid of some of the 0 byte/failed reads
307 c = 0;
308 getNext = FALSE;
309 for(;;) {
310 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
311 AT91C_BASE_SSC->SSC_THR = 0x43;
312 }
313 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
f7e3ed82 314 int8_t b;
315 b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 316
317 // The samples are correlations against I and Q versions of the
318 // tone that the tag AM-modulates, so every other sample is I,
319 // every other is Q. We just want power, so abs(I) + abs(Q) is
320 // close to what we want.
321 if(getNext) {
f7e3ed82 322 int8_t r;
15c4dc5a 323
324 if(b < 0) {
325 r = -b;
326 } else {
327 r = b;
328 }
329 if(prev < 0) {
330 r -= prev;
331 } else {
332 r += prev;
333 }
334
f7e3ed82 335 dest[c++] = (uint8_t)r;
15c4dc5a 336
337 if(c >= 2000) {
338 break;
339 }
340 } else {
341 prev = b;
342 }
343
344 getNext = !getNext;
345 }
346 }
347
9455b51c 348 //////////////////////////////////////////
349 /////////// DEMODULATE ///////////////////
350 //////////////////////////////////////////
15c4dc5a 351
352 int i, j;
353 int max = 0, maxPos=0;
354
355 int skip = 4;
356
9455b51c 357 // if(GraphTraceLen < 1000) return; // THIS CHECKS FOR A BUFFER TO SMALL
15c4dc5a 358
359 // First, correlate for SOF
360 for(i = 0; i < 100; i++) {
361 int corr = 0;
362 for(j = 0; j < arraylen(FrameSOF); j += skip) {
363 corr += FrameSOF[j]*dest[i+(j/skip)];
364 }
365 if(corr > max) {
366 max = corr;
367 maxPos = i;
368 }
369 }
9455b51c 370 // DbpString("SOF at %d, correlation %d", maxPos,max/(arraylen(FrameSOF)/skip));
15c4dc5a 371
372 int k = 0; // this will be our return value
373
374 // greg - If correlation is less than 1 then there's little point in continuing
375 if ((max/(arraylen(FrameSOF)/skip)) >= 1)
376 {
377
9455b51c 378 i = maxPos + arraylen(FrameSOF)/skip;
379
380 uint8_t outBuf[20];
381 memset(outBuf, 0, sizeof(outBuf));
382 uint8_t mask = 0x01;
383 for(;;) {
384 int corr0 = 0, corr1 = 0, corrEOF = 0;
385 for(j = 0; j < arraylen(Logic0); j += skip) {
386 corr0 += Logic0[j]*dest[i+(j/skip)];
387 }
388 for(j = 0; j < arraylen(Logic1); j += skip) {
389 corr1 += Logic1[j]*dest[i+(j/skip)];
390 }
391 for(j = 0; j < arraylen(FrameEOF); j += skip) {
392 corrEOF += FrameEOF[j]*dest[i+(j/skip)];
393 }
394 // Even things out by the length of the target waveform.
395 corr0 *= 4;
396 corr1 *= 4;
397
398 if(corrEOF > corr1 && corrEOF > corr0) {
399 // DbpString("EOF at %d", i);
400 break;
401 } else if(corr1 > corr0) {
402 i += arraylen(Logic1)/skip;
403 outBuf[k] |= mask;
404 } else {
405 i += arraylen(Logic0)/skip;
406 }
407 mask <<= 1;
408 if(mask == 0) {
409 k++;
410 mask = 0x01;
411 }
412 if((i+(int)arraylen(FrameEOF)) >= 2000) {
413 DbpString("ran off end!");
414 break;
415 }
15c4dc5a 416 }
9455b51c 417 if(mask != 0x01) { // this happens, when we miss the EOF
418 // TODO: for some reason this happens quite often
419 if (DEBUG) Dbprintf("error, uneven octet! (extra bits!) mask=%02x", mask);
420 if (mask<0x08) k--; // discard the last uneven octet;
421 // 0x08 is an assumption - but works quite often
15c4dc5a 422 }
9455b51c 423 // uint8_t str1 [8];
424 // itoa(k,str1);
425 // strncat(str1," octets read",8);
426
427 // DbpString( str1); // DbpString("%d octets", k);
428
429 // for(i = 0; i < k; i+=3) {
430 // //DbpString("# %2d: %02x ", i, outBuf[i]);
431 // DbpIntegers(outBuf[i],outBuf[i+1],outBuf[i+2]);
432 // }
433
434 for(i = 0; i < k; i++) {
435 receivedResponse[i] = outBuf[i];
15c4dc5a 436 }
15c4dc5a 437 } // "end if correlation > 0" (max/(arraylen(FrameSOF)/skip))
438 return k; // return the number of bytes demodulated
439
440/// DbpString("CRC=%04x", Iso15693Crc(outBuf, k-2));
441
442}
443
9455b51c 444
15c4dc5a 445// Now the GetISO15693 message from sniffing command
f7e3ed82 446static int GetIso15693AnswerFromSniff(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed)
15c4dc5a 447{
448 int c = 0;
117d9ec2 449 uint8_t *dest = BigBuf_get_addr();
15c4dc5a 450 int getNext = 0;
451
f7e3ed82 452 int8_t prev = 0;
15c4dc5a 453
454// NOW READ RESPONSE
455 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
456 //spindelay(60); // greg - experiment to get rid of some of the 0 byte/failed reads
457 c = 0;
458 getNext = FALSE;
459 for(;;) {
460 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
461 AT91C_BASE_SSC->SSC_THR = 0x43;
462 }
463 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
3fe4ff4f 464 int8_t b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 465
466 // The samples are correlations against I and Q versions of the
467 // tone that the tag AM-modulates, so every other sample is I,
468 // every other is Q. We just want power, so abs(I) + abs(Q) is
469 // close to what we want.
470 if(getNext) {
f7e3ed82 471 int8_t r;
15c4dc5a 472
473 if(b < 0) {
474 r = -b;
475 } else {
476 r = b;
477 }
478 if(prev < 0) {
479 r -= prev;
480 } else {
481 r += prev;
482 }
483
f7e3ed82 484 dest[c++] = (uint8_t)r;
15c4dc5a 485
486 if(c >= 20000) {
487 break;
488 }
489 } else {
490 prev = b;
491 }
492
493 getNext = !getNext;
494 }
495 }
496
9455b51c 497 //////////////////////////////////////////
498 /////////// DEMODULATE ///////////////////
499 //////////////////////////////////////////
15c4dc5a 500
501 int i, j;
502 int max = 0, maxPos=0;
503
504 int skip = 4;
505
506// if(GraphTraceLen < 1000) return; // THIS CHECKS FOR A BUFFER TO SMALL
507
508 // First, correlate for SOF
509 for(i = 0; i < 19000; i++) {
510 int corr = 0;
511 for(j = 0; j < arraylen(FrameSOF); j += skip) {
512 corr += FrameSOF[j]*dest[i+(j/skip)];
513 }
514 if(corr > max) {
515 max = corr;
516 maxPos = i;
517 }
518 }
519// DbpString("SOF at %d, correlation %d", maxPos,max/(arraylen(FrameSOF)/skip));
520
521 int k = 0; // this will be our return value
522
523 // greg - If correlation is less than 1 then there's little point in continuing
524 if ((max/(arraylen(FrameSOF)/skip)) >= 1) // THIS SHOULD BE 1
525 {
9455b51c 526
527 i = maxPos + arraylen(FrameSOF)/skip;
528
529 uint8_t outBuf[20];
530 memset(outBuf, 0, sizeof(outBuf));
531 uint8_t mask = 0x01;
532 for(;;) {
533 int corr0 = 0, corr1 = 0, corrEOF = 0;
534 for(j = 0; j < arraylen(Logic0); j += skip) {
535 corr0 += Logic0[j]*dest[i+(j/skip)];
536 }
537 for(j = 0; j < arraylen(Logic1); j += skip) {
538 corr1 += Logic1[j]*dest[i+(j/skip)];
539 }
540 for(j = 0; j < arraylen(FrameEOF); j += skip) {
541 corrEOF += FrameEOF[j]*dest[i+(j/skip)];
542 }
543 // Even things out by the length of the target waveform.
544 corr0 *= 4;
545 corr1 *= 4;
546
547 if(corrEOF > corr1 && corrEOF > corr0) {
548 // DbpString("EOF at %d", i);
549 break;
550 } else if(corr1 > corr0) {
551 i += arraylen(Logic1)/skip;
552 outBuf[k] |= mask;
553 } else {
554 i += arraylen(Logic0)/skip;
555 }
556 mask <<= 1;
557 if(mask == 0) {
558 k++;
559 mask = 0x01;
560 }
561 if((i+(int)arraylen(FrameEOF)) >= 2000) {
562 DbpString("ran off end!");
563 break;
564 }
15c4dc5a 565 }
9455b51c 566 if(mask != 0x01) {
567 DbpString("sniff: error, uneven octet! (discard extra bits!)");
568 /// DbpString(" mask=%02x", mask);
15c4dc5a 569 }
9455b51c 570 // uint8_t str1 [8];
571 // itoa(k,str1);
572 // strncat(str1," octets read",8);
573
574 // DbpString( str1); // DbpString("%d octets", k);
575
576 // for(i = 0; i < k; i+=3) {
577 // //DbpString("# %2d: %02x ", i, outBuf[i]);
578 // DbpIntegers(outBuf[i],outBuf[i+1],outBuf[i+2]);
579 // }
580
581 for(i = 0; i < k; i++) {
582 receivedResponse[i] = outBuf[i];
15c4dc5a 583 }
15c4dc5a 584 } // "end if correlation > 0" (max/(arraylen(FrameSOF)/skip))
585 return k; // return the number of bytes demodulated
586
587/// DbpString("CRC=%04x", Iso15693Crc(outBuf, k-2));
588}
589
9455b51c 590
591static void BuildIdentifyRequest(void);
15c4dc5a 592//-----------------------------------------------------------------------------
593// Start to read an ISO 15693 tag. We send an identify request, then wait
594// for the response. The response is not demodulated, just left in the buffer
595// so that it can be downloaded to a PC and processed there.
596//-----------------------------------------------------------------------------
597void AcquireRawAdcSamplesIso15693(void)
598{
117d9ec2 599 uint8_t *dest = BigBuf_get_addr();
15c4dc5a 600
3fe4ff4f 601 int c = 0;
602 int getNext = 0;
f7e3ed82 603 int8_t prev = 0;
15c4dc5a 604
7cc204bf 605 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
15c4dc5a 606 BuildIdentifyRequest();
607
608 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
609
610 // Give the tags time to energize
611 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
612 SpinDelay(100);
613
614 // Now send the command
615 FpgaSetupSsc();
616 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_TX);
617
618 c = 0;
619 for(;;) {
620 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
621 AT91C_BASE_SSC->SSC_THR = ToSend[c];
622 c++;
623 if(c == ToSendMax+3) {
624 break;
625 }
626 }
627 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
f7e3ed82 628 volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 629 (void)r;
630 }
631 WDT_HIT();
632 }
633
634 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
635
636 c = 0;
637 getNext = FALSE;
638 for(;;) {
639 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
640 AT91C_BASE_SSC->SSC_THR = 0x43;
641 }
642 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
f7e3ed82 643 int8_t b;
644 b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
15c4dc5a 645
9455b51c 646 // The samples are correlations against I and Q versions of the
647 // tone that the tag AM-modulates, so every other sample is I,
648 // every other is Q. We just want power, so abs(I) + abs(Q) is
649 // close to what we want.
650 if(getNext) {
651 int8_t r;
652
653 if(b < 0) {
654 r = -b;
655 } else {
656 r = b;
657 }
658 if(prev < 0) {
659 r -= prev;
660 } else {
661 r += prev;
662 }
663
664 dest[c++] = (uint8_t)r;
665
666 if(c >= 2000) {
667 break;
668 }
669 } else {
670 prev = b;
671 }
672
673 getNext = !getNext;
674 }
675 }
676}
677
678
679void RecordRawAdcSamplesIso15693(void)
680{
117d9ec2 681 uint8_t *dest = BigBuf_get_addr();
3fe4ff4f 682
9455b51c 683 int c = 0;
9455b51c 684 int getNext = 0;
9455b51c 685 int8_t prev = 0;
686
7cc204bf 687 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
9455b51c 688 // Setup SSC
689 FpgaSetupSsc();
690
691 // Start from off (no field generated)
5ee53a0e 692 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
693 SpinDelay(200);
9455b51c 694
695 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
696
697 SpinDelay(100);
698
699 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
700
701 c = 0;
702 getNext = FALSE;
703 for(;;) {
704 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
705 AT91C_BASE_SSC->SSC_THR = 0x43;
706 }
707 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
708 int8_t b;
709 b = (int8_t)AT91C_BASE_SSC->SSC_RHR;
710
711 // The samples are correlations against I and Q versions of the
712 // tone that the tag AM-modulates, so every other sample is I,
713 // every other is Q. We just want power, so abs(I) + abs(Q) is
714 // close to what we want.
715 if(getNext) {
716 int8_t r;
717
718 if(b < 0) {
719 r = -b;
720 } else {
721 r = b;
722 }
723 if(prev < 0) {
724 r -= prev;
725 } else {
726 r += prev;
727 }
728
729 dest[c++] = (uint8_t)r;
730
731 if(c >= 7000) {
732 break;
733 }
734 } else {
735 prev = b;
736 }
737
738 getNext = !getNext;
739 WDT_HIT();
740 }
741 }
742 Dbprintf("fin record");
743}
744
745
746// Initialize the proxmark as iso15k reader
e6304bca 747// (this might produces glitches that confuse some tags
9455b51c 748void Iso15693InitReader() {
749 LED_A_ON();
750 LED_B_ON();
751 LED_C_OFF();
752 LED_D_OFF();
753
7cc204bf 754 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
9455b51c 755 // Setup SSC
e6304bca 756 // FpgaSetupSsc();
9455b51c 757
758 // Start from off (no field generated)
759 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
e6304bca 760 SpinDelay(10);
9455b51c 761
762 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
763 FpgaSetupSsc();
764
765 // Give the tags time to energize
766 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
e6304bca 767 SpinDelay(250);
9455b51c 768
769 LED_A_ON();
770 LED_B_OFF();
771 LED_C_OFF();
772 LED_D_OFF();
773}
774
775///////////////////////////////////////////////////////////////////////
776// ISO 15693 Part 3 - Air Interface
777// This section basicly contains transmission and receiving of bits
778///////////////////////////////////////////////////////////////////////
779
780// Encode (into the ToSend buffers) an identify request, which is the first
781// thing that you must send to a tag to get a response.
782static void BuildIdentifyRequest(void)
783{
784 uint8_t cmd[5];
785
786 uint16_t crc;
787 // one sub-carrier, inventory, 1 slot, fast rate
788 // AFI is at bit 5 (1<<4) when doing an INVENTORY
789 cmd[0] = (1 << 2) | (1 << 5) | (1 << 1);
790 // inventory command code
791 cmd[1] = 0x01;
792 // no mask
793 cmd[2] = 0x00;
794 //Now the CRC
795 crc = Crc(cmd, 3);
796 cmd[3] = crc & 0xff;
797 cmd[4] = crc >> 8;
798
799 CodeIso15693AsReader(cmd, sizeof(cmd));
800}
801
802// uid is in transmission order (which is reverse of display order)
803static void BuildReadBlockRequest(uint8_t *uid, uint8_t blockNumber )
804{
805 uint8_t cmd[13];
806
807 uint16_t crc;
808 // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
809 // followed by teh block data
810 // one sub-carrier, inventory, 1 slot, fast rate
811 cmd[0] = (1 << 6)| (1 << 5) | (1 << 1); // no SELECT bit, ADDR bit, OPTION bit
812 // READ BLOCK command code
813 cmd[1] = 0x20;
814 // UID may be optionally specified here
815 // 64-bit UID
816 cmd[2] = uid[0];
817 cmd[3] = uid[1];
818 cmd[4] = uid[2];
819 cmd[5] = uid[3];
820 cmd[6] = uid[4];
821 cmd[7] = uid[5];
822 cmd[8] = uid[6];
823 cmd[9] = uid[7]; // 0xe0; // always e0 (not exactly unique)
824 // Block number to read
825 cmd[10] = blockNumber;//0x00;
826 //Now the CRC
827 crc = Crc(cmd, 11); // the crc needs to be calculated over 12 bytes
828 cmd[11] = crc & 0xff;
829 cmd[12] = crc >> 8;
830
831 CodeIso15693AsReader(cmd, sizeof(cmd));
832}
833
834// Now the VICC>VCD responses when we are simulating a tag
3fe4ff4f 835 static void BuildInventoryResponse( uint8_t *uid)
9455b51c 836{
837 uint8_t cmd[12];
838
839 uint16_t crc;
840 // one sub-carrier, inventory, 1 slot, fast rate
841 // AFI is at bit 5 (1<<4) when doing an INVENTORY
3fe4ff4f 842 //(1 << 2) | (1 << 5) | (1 << 1);
843 cmd[0] = 0; //
844 cmd[1] = 0; // DSFID (data storage format identifier). 0x00 = not supported
9455b51c 845 // 64-bit UID
3fe4ff4f 846 cmd[2] = uid[7]; //0x32;
847 cmd[3] = uid[6]; //0x4b;
848 cmd[4] = uid[5]; //0x03;
849 cmd[5] = uid[4]; //0x01;
850 cmd[6] = uid[3]; //0x00;
851 cmd[7] = uid[2]; //0x10;
852 cmd[8] = uid[1]; //0x05;
853 cmd[9] = uid[0]; //0xe0;
9455b51c 854 //Now the CRC
855 crc = Crc(cmd, 10);
856 cmd[10] = crc & 0xff;
857 cmd[11] = crc >> 8;
858
859 CodeIso15693AsReader(cmd, sizeof(cmd));
860}
861
e6304bca 862// Universal Method for sending to and recv bytes from a tag
9455b51c 863// init ... should we initialize the reader?
864// speed ... 0 low speed, 1 hi speed
865// **recv will return you a pointer to the received data
866// If you do not need the answer use NULL for *recv[]
867// return: lenght of received data
868int SendDataTag(uint8_t *send, int sendlen, int init, int speed, uint8_t **recv) {
869
870 int samples = 0;
871 int tsamples = 0;
872 int wait = 0;
873 int elapsed = 0;
874
875 LED_A_ON();
876 LED_B_ON();
877 LED_C_OFF();
878 LED_D_OFF();
879
99cf19d9 880 if (init) Iso15693InitReader();
881
9455b51c 882 int answerLen=0;
117d9ec2 883 uint8_t *answer = BigBuf_get_addr() + 3660;
884 if (recv != NULL) memset(answer, 0, 100);
9455b51c 885
9455b51c 886 if (!speed) {
887 // low speed (1 out of 256)
888 CodeIso15693AsReader256(send, sendlen);
889 } else {
890 // high speed (1 out of 4)
891 CodeIso15693AsReader(send, sendlen);
892 }
893
894 LED_A_ON();
895 LED_B_OFF();
896
897 TransmitTo15693Tag(ToSend,ToSendMax,&tsamples, &wait);
898 // Now wait for a response
899 if (recv!=NULL) {
900 LED_A_OFF();
901 LED_B_ON();
902 answerLen = GetIso15693AnswerFromTag(answer, 100, &samples, &elapsed) ;
903 *recv=answer;
904 }
905
4a71da5a 906 LEDsoff();
9455b51c 907
908 return answerLen;
909}
15c4dc5a 910
15c4dc5a 911
9455b51c 912// --------------------------------------------------------------------
913// Debug Functions
914// --------------------------------------------------------------------
15c4dc5a 915
9455b51c 916// Decodes a message from a tag and displays its metadata and content
917#define DBD15STATLEN 48
918void DbdecodeIso15693Answer(int len, uint8_t *d) {
919 char status[DBD15STATLEN+1]={0};
920 uint16_t crc;
921
922 if (len>3) {
923 if (d[0]&(1<<3))
924 strncat(status,"ProtExt ",DBD15STATLEN);
925 if (d[0]&1) {
926 // error
927 strncat(status,"Error ",DBD15STATLEN);
928 switch (d[1]) {
929 case 0x01:
930 strncat(status,"01:notSupp",DBD15STATLEN);
15c4dc5a 931 break;
9455b51c 932 case 0x02:
933 strncat(status,"02:notRecog",DBD15STATLEN);
934 break;
935 case 0x03:
936 strncat(status,"03:optNotSupp",DBD15STATLEN);
937 break;
938 case 0x0f:
939 strncat(status,"0f:noInfo",DBD15STATLEN);
940 break;
941 case 0x10:
942 strncat(status,"10:dontExist",DBD15STATLEN);
943 break;
944 case 0x11:
945 strncat(status,"11:lockAgain",DBD15STATLEN);
946 break;
947 case 0x12:
948 strncat(status,"12:locked",DBD15STATLEN);
949 break;
950 case 0x13:
951 strncat(status,"13:progErr",DBD15STATLEN);
952 break;
953 case 0x14:
954 strncat(status,"14:lockErr",DBD15STATLEN);
955 break;
956 default:
957 strncat(status,"unknownErr",DBD15STATLEN);
15c4dc5a 958 }
9455b51c 959 strncat(status," ",DBD15STATLEN);
960 } else {
961 strncat(status,"NoErr ",DBD15STATLEN);
15c4dc5a 962 }
9455b51c 963
964 crc=Crc(d,len-2);
965 if ( (( crc & 0xff ) == d[len-2]) && (( crc >> 8 ) == d[len-1]) )
966 strncat(status,"CrcOK",DBD15STATLEN);
967 else
968 strncat(status,"CrcFail!",DBD15STATLEN);
969
970 Dbprintf("%s",status);
15c4dc5a 971 }
972}
973
9455b51c 974
975
976///////////////////////////////////////////////////////////////////////
977// Functions called via USB/Client
978///////////////////////////////////////////////////////////////////////
979
980void SetDebugIso15693(uint32_t debug) {
981 DEBUG=debug;
982 Dbprintf("Iso15693 Debug is now %s",DEBUG?"on":"off");
983 return;
984}
985
986
987
15c4dc5a 988//-----------------------------------------------------------------------------
989// Simulate an ISO15693 reader, perform anti-collision and then attempt to read a sector
990// all demodulation performed in arm rather than host. - greg
991//-----------------------------------------------------------------------------
f7e3ed82 992void ReaderIso15693(uint32_t parameter)
15c4dc5a 993{
994 LED_A_ON();
995 LED_B_ON();
996 LED_C_OFF();
997 LED_D_OFF();
998
15c4dc5a 999 int answerLen1 = 0;
1000 int answerLen2 = 0;
1001 int answerLen3 = 0;
3fe4ff4f 1002 int i = 0;
1003 int samples = 0;
1004 int tsamples = 0;
1005 int wait = 0;
1006 int elapsed = 0;
1007 uint8_t TagUID[8] = {0x00};
1008
99cf19d9 1009 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
15c4dc5a 1010
99cf19d9 1011 uint8_t *answer1 = BigBuf_get_addr() + 3660;
1012 uint8_t *answer2 = BigBuf_get_addr() + 3760;
1013 uint8_t *answer3 = BigBuf_get_addr() + 3860;
15c4dc5a 1014 // Blank arrays
117d9ec2 1015 memset(answer1, 0x00, 300);
15c4dc5a 1016
3fe4ff4f 1017 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
15c4dc5a 1018 // Setup SSC
1019 FpgaSetupSsc();
1020
1021 // Start from off (no field generated)
5ee53a0e 1022 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
1023 SpinDelay(200);
15c4dc5a 1024
15c4dc5a 1025 // Give the tags time to energize
1026 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
1027 SpinDelay(200);
1028
1029 LED_A_ON();
1030 LED_B_OFF();
1031 LED_C_OFF();
1032 LED_D_OFF();
1033
15c4dc5a 1034 // FIRST WE RUN AN INVENTORY TO GET THE TAG UID
1035 // THIS MEANS WE CAN PRE-BUILD REQUESTS TO SAVE CPU TIME
15c4dc5a 1036
1037 // Now send the IDENTIFY command
1038 BuildIdentifyRequest();
3fe4ff4f 1039
1040 TransmitTo15693Tag(ToSend,ToSendMax,&tsamples, &wait);
1041
15c4dc5a 1042 // Now wait for a response
1043 answerLen1 = GetIso15693AnswerFromTag(answer1, 100, &samples, &elapsed) ;
1044
1045 if (answerLen1 >=12) // we should do a better check than this
1046 {
15c4dc5a 1047 TagUID[0] = answer1[2];
1048 TagUID[1] = answer1[3];
1049 TagUID[2] = answer1[4];
1050 TagUID[3] = answer1[5];
1051 TagUID[4] = answer1[6];
1052 TagUID[5] = answer1[7];
1053 TagUID[6] = answer1[8]; // IC Manufacturer code
9455b51c 1054 TagUID[7] = answer1[9]; // always E0
15c4dc5a 1055
15c4dc5a 1056 }
1057
9455b51c 1058 Dbprintf("%d octets read from IDENTIFY request:", answerLen1);
1059 DbdecodeIso15693Answer(answerLen1,answer1);
d19929cb 1060 Dbhexdump(answerLen1,answer1,true);
9455b51c 1061
1062 // UID is reverse
1063 if (answerLen1>=12)
3fe4ff4f 1064 Dbprintf("UID = %02hX%02hX%02hX%02hX%02hX%02hX%02hX%02hX",
1065 TagUID[7],TagUID[6],TagUID[5],TagUID[4],
1066 TagUID[3],TagUID[2],TagUID[1],TagUID[0]);
9455b51c 1067
1068
1069 Dbprintf("%d octets read from SELECT request:", answerLen2);
1070 DbdecodeIso15693Answer(answerLen2,answer2);
d19929cb 1071 Dbhexdump(answerLen2,answer2,true);
9455b51c 1072
1073 Dbprintf("%d octets read from XXX request:", answerLen3);
1074 DbdecodeIso15693Answer(answerLen3,answer3);
d19929cb 1075 Dbhexdump(answerLen3,answer3,true);
9455b51c 1076
9455b51c 1077 // read all pages
1078 if (answerLen1>=12 && DEBUG) {
1079 i=0;
1080 while (i<32) { // sanity check, assume max 32 pages
1081 BuildReadBlockRequest(TagUID,i);
1082 TransmitTo15693Tag(ToSend,ToSendMax,&tsamples, &wait);
1083 answerLen2 = GetIso15693AnswerFromTag(answer2, 100, &samples, &elapsed);
1084 if (answerLen2>0) {
1085 Dbprintf("READ SINGLE BLOCK %d returned %d octets:",i,answerLen2);
1086 DbdecodeIso15693Answer(answerLen2,answer2);
d19929cb 1087 Dbhexdump(answerLen2,answer2,true);
9455b51c 1088 if ( *((uint32_t*) answer2) == 0x07160101 ) break; // exit on NoPageErr
1089 }
1090 i++;
1091 }
1092 }
15c4dc5a 1093
15c4dc5a 1094 LED_A_OFF();
1095 LED_B_OFF();
1096 LED_C_OFF();
1097 LED_D_OFF();
1098}
1099
15c4dc5a 1100// Simulate an ISO15693 TAG, perform anti-collision and then print any reader commands
1101// all demodulation performed in arm rather than host. - greg
3fe4ff4f 1102void SimTagIso15693(uint32_t parameter, uint8_t *uid)
15c4dc5a 1103{
1104 LED_A_ON();
1105 LED_B_ON();
1106 LED_C_OFF();
1107 LED_D_OFF();
1108
15c4dc5a 1109 int answerLen1 = 0;
3fe4ff4f 1110 int samples = 0;
1111 int tsamples = 0;
1112 int wait = 0;
1113 int elapsed = 0;
15c4dc5a 1114
7cc204bf 1115 FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
15c4dc5a 1116
99cf19d9 1117 uint8_t *buf = BigBuf_get_addr() + 3660;
1118 memset(buf, 0x00, 100);
3fe4ff4f 1119
99cf19d9 1120 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
15c4dc5a 1121 FpgaSetupSsc();
1122
3fe4ff4f 1123 // Start from off (no field generated)
5ee53a0e 1124 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
15c4dc5a 1125 SpinDelay(200);
1126
1127 LED_A_OFF();
1128 LED_B_OFF();
1129 LED_C_ON();
1130 LED_D_OFF();
1131
3fe4ff4f 1132 // Listen to reader
1133 answerLen1 = GetIso15693AnswerFromSniff(buf, 100, &samples, &elapsed) ;
15c4dc5a 1134
1135 if (answerLen1 >=1) // we should do a better check than this
1136 {
1137 // Build a suitable reponse to the reader INVENTORY cocmmand
3fe4ff4f 1138 // not so obsvious, but in the call to BuildInventoryResponse, the command is copied to the global ToSend buffer used below.
1139
1140 BuildInventoryResponse(uid);
1141
15c4dc5a 1142 TransmitTo15693Reader(ToSend,ToSendMax, &tsamples, &wait);
1143 }
1144
1145 Dbprintf("%d octets read from reader command: %x %x %x %x %x %x %x %x %x", answerLen1,
3fe4ff4f 1146 buf[0], buf[1], buf[2], buf[3],
1147 buf[4], buf[5], buf[6], buf[7], buf[8]);
1148
1149 Dbprintf("Simulationg uid: %x %x %x %x %x %x %x %x",
1150 uid[0], uid[1], uid[2], uid[3],
1151 uid[4], uid[5], uid[6], uid[7]);
15c4dc5a 1152
1153 LED_A_OFF();
1154 LED_B_OFF();
1155 LED_C_OFF();
1156 LED_D_OFF();
1157}
9455b51c 1158
1159
1160// Since there is no standardized way of reading the AFI out of a tag, we will brute force it
1161// (some manufactures offer a way to read the AFI, though)
1162void BruteforceIso15693Afi(uint32_t speed)
1163{
1164 uint8_t data[20];
1165 uint8_t *recv=data;
1166 int datalen=0, recvlen=0;
1167
1168 Iso15693InitReader();
1169
1170 // first without AFI
1171 // Tags should respond wihtout AFI and with AFI=0 even when AFI is active
1172
1173 data[0]=ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH |
1174 ISO15_REQ_INVENTORY | ISO15_REQINV_SLOT1;
1175 data[1]=ISO15_CMD_INVENTORY;
1176 data[2]=0; // mask length
1177 datalen=AddCrc(data,3);
1178 recvlen=SendDataTag(data,datalen,0,speed,&recv);
1179 WDT_HIT();
1180 if (recvlen>=12) {
1181 Dbprintf("NoAFI UID=%s",sprintUID(NULL,&recv[2]));
1182 }
1183
1184 // now with AFI
1185
1186 data[0]=ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH |
1187 ISO15_REQ_INVENTORY | ISO15_REQINV_AFI | ISO15_REQINV_SLOT1;
1188 data[1]=ISO15_CMD_INVENTORY;
1189 data[2]=0; // AFI
1190 data[3]=0; // mask length
1191
1192 for (int i=0;i<256;i++) {
1193 data[2]=i & 0xFF;
1194 datalen=AddCrc(data,4);
1195 recvlen=SendDataTag(data,datalen,0,speed,&recv);
1196 WDT_HIT();
1197 if (recvlen>=12) {
1198 Dbprintf("AFI=%i UID=%s",i,sprintUID(NULL,&recv[2]));
1199 }
1200 }
1201 Dbprintf("AFI Bruteforcing done.");
1202
1203}
1204
1205// Allows to directly send commands to the tag via the client
1206void DirectTag15693Command(uint32_t datalen,uint32_t speed, uint32_t recv, uint8_t data[]) {
1207
1208 int recvlen=0;
117d9ec2 1209 uint8_t *recvbuf = BigBuf_get_addr();
902cb3c0 1210// UsbCommand n;
9455b51c 1211
1212 if (DEBUG) {
1213 Dbprintf("SEND");
d19929cb 1214 Dbhexdump(datalen,data,true);
9455b51c 1215 }
1216
1217 recvlen=SendDataTag(data,datalen,1,speed,(recv?&recvbuf:NULL));
1218
1219 if (recv) {
9455b51c 1220 LED_B_ON();
902cb3c0 1221 cmd_send(CMD_ACK,recvlen>48?48:recvlen,0,0,recvbuf,48);
9455b51c 1222 LED_B_OFF();
1223
1224 if (DEBUG) {
1225 Dbprintf("RECV");
1226 DbdecodeIso15693Answer(recvlen,recvbuf);
d19929cb 1227 Dbhexdump(recvlen,recvbuf,true);
9455b51c 1228 }
1229 }
1230
1231}
1232
1233
1234
1235
1236// --------------------------------------------------------------------
1237// -- Misc & deprecated functions
1238// --------------------------------------------------------------------
1239
e6304bca 1240/*
9455b51c 1241
1242// do not use; has a fix UID
1243static void __attribute__((unused)) BuildSysInfoRequest(uint8_t *uid)
1244{
1245 uint8_t cmd[12];
1246
1247 uint16_t crc;
1248 // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
1249 // followed by teh block data
1250 // one sub-carrier, inventory, 1 slot, fast rate
1251 cmd[0] = (1 << 5) | (1 << 1); // no SELECT bit
1252 // System Information command code
1253 cmd[1] = 0x2B;
1254 // UID may be optionally specified here
1255 // 64-bit UID
1256 cmd[2] = 0x32;
1257 cmd[3]= 0x4b;
1258 cmd[4] = 0x03;
1259 cmd[5] = 0x01;
1260 cmd[6] = 0x00;
1261 cmd[7] = 0x10;
1262 cmd[8] = 0x05;
1263 cmd[9]= 0xe0; // always e0 (not exactly unique)
1264 //Now the CRC
1265 crc = Crc(cmd, 10); // the crc needs to be calculated over 2 bytes
1266 cmd[10] = crc & 0xff;
1267 cmd[11] = crc >> 8;
1268
1269 CodeIso15693AsReader(cmd, sizeof(cmd));
1270}
1271
9455b51c 1272
1273// do not use; has a fix UID
1274static void __attribute__((unused)) BuildReadMultiBlockRequest(uint8_t *uid)
1275{
1276 uint8_t cmd[14];
1277
1278 uint16_t crc;
1279 // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
1280 // followed by teh block data
1281 // one sub-carrier, inventory, 1 slot, fast rate
1282 cmd[0] = (1 << 5) | (1 << 1); // no SELECT bit
1283 // READ Multi BLOCK command code
1284 cmd[1] = 0x23;
1285 // UID may be optionally specified here
1286 // 64-bit UID
1287 cmd[2] = 0x32;
1288 cmd[3]= 0x4b;
1289 cmd[4] = 0x03;
1290 cmd[5] = 0x01;
1291 cmd[6] = 0x00;
1292 cmd[7] = 0x10;
1293 cmd[8] = 0x05;
1294 cmd[9]= 0xe0; // always e0 (not exactly unique)
1295 // First Block number to read
1296 cmd[10] = 0x00;
1297 // Number of Blocks to read
1298 cmd[11] = 0x2f; // read quite a few
1299 //Now the CRC
1300 crc = Crc(cmd, 12); // the crc needs to be calculated over 2 bytes
1301 cmd[12] = crc & 0xff;
1302 cmd[13] = crc >> 8;
1303
1304 CodeIso15693AsReader(cmd, sizeof(cmd));
1305}
1306
1307// do not use; has a fix UID
1308static void __attribute__((unused)) BuildArbitraryRequest(uint8_t *uid,uint8_t CmdCode)
1309{
1310 uint8_t cmd[14];
1311
1312 uint16_t crc;
1313 // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
1314 // followed by teh block data
1315 // one sub-carrier, inventory, 1 slot, fast rate
1316 cmd[0] = (1 << 5) | (1 << 1); // no SELECT bit
1317 // READ BLOCK command code
1318 cmd[1] = CmdCode;
1319 // UID may be optionally specified here
1320 // 64-bit UID
1321 cmd[2] = 0x32;
1322 cmd[3]= 0x4b;
1323 cmd[4] = 0x03;
1324 cmd[5] = 0x01;
1325 cmd[6] = 0x00;
1326 cmd[7] = 0x10;
1327 cmd[8] = 0x05;
1328 cmd[9]= 0xe0; // always e0 (not exactly unique)
1329 // Parameter
1330 cmd[10] = 0x00;
1331 cmd[11] = 0x0a;
1332
1333// cmd[12] = 0x00;
1334// cmd[13] = 0x00; //Now the CRC
1335 crc = Crc(cmd, 12); // the crc needs to be calculated over 2 bytes
1336 cmd[12] = crc & 0xff;
1337 cmd[13] = crc >> 8;
1338
1339 CodeIso15693AsReader(cmd, sizeof(cmd));
1340}
1341
1342// do not use; has a fix UID
1343static void __attribute__((unused)) BuildArbitraryCustomRequest(uint8_t uid[], uint8_t CmdCode)
1344{
1345 uint8_t cmd[14];
1346
1347 uint16_t crc;
1348 // If we set the Option_Flag in this request, the VICC will respond with the secuirty status of the block
1349 // followed by teh block data
1350 // one sub-carrier, inventory, 1 slot, fast rate
1351 cmd[0] = (1 << 5) | (1 << 1); // no SELECT bit
1352 // READ BLOCK command code
1353 cmd[1] = CmdCode;
1354 // UID may be optionally specified here
1355 // 64-bit UID
1356 cmd[2] = 0x32;
1357 cmd[3]= 0x4b;
1358 cmd[4] = 0x03;
1359 cmd[5] = 0x01;
1360 cmd[6] = 0x00;
1361 cmd[7] = 0x10;
1362 cmd[8] = 0x05;
1363 cmd[9]= 0xe0; // always e0 (not exactly unique)
1364 // Parameter
1365 cmd[10] = 0x05; // for custom codes this must be manufcturer code
1366 cmd[11] = 0x00;
1367
1368// cmd[12] = 0x00;
1369// cmd[13] = 0x00; //Now the CRC
1370 crc = Crc(cmd, 12); // the crc needs to be calculated over 2 bytes
1371 cmd[12] = crc & 0xff;
1372 cmd[13] = crc >> 8;
1373
1374 CodeIso15693AsReader(cmd, sizeof(cmd));
1375}
1376
1377
1378
1379
e6304bca 1380*/
9455b51c 1381
1382
Proxmark3 GIT tracking
Impressum, Datenschutz