]>
cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmdlfem4x.c
c26b4f392b7b04f2392c0ca3af704bfd7a1ad502
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
7 //-----------------------------------------------------------------------------
8 // Low frequency EM4x commands
9 //-----------------------------------------------------------------------------
14 #include "proxmark3.h"
18 #include "cmdparser.h"
22 #include "cmdlfem4x.h"
25 char *global_em410xId
;
27 static int CmdHelp(const char *Cmd
);
29 int CmdEMdemodASK(const char *Cmd
)
31 char cmdp
= param_getchar(Cmd
, 0);
32 int findone
= (cmdp
== '1') ? 1 : 0;
33 UsbCommand c
={CMD_EM410X_DEMOD
};
39 /* Read the ID of an EM410x tag.
41 * 1111 1111 1 <-- standard non-repeatable header
42 * XXXX [row parity bit] <-- 10 rows of 5 bits for our 40 bit tag ID
44 * CCCC <-- each bit here is parity for the 10 bits above in corresponding column
45 * 0 <-- stop bit, end of tag
47 int CmdEM410xRead(const char *Cmd
)
52 if(!AskEm410xDemod("", &hi
, &lo
, false)) return 0;
53 PrintAndLog("EM410x pattern found: ");
56 PrintAndLog ("EM410x XL pattern found");
60 sprintf(id
, "%010"PRIx64
,lo
);
66 // emulate an EM410X tag
67 int CmdEM410xSim(const char *Cmd
)
69 int i
, n
, j
, binary
[4], parity
[4];
71 char cmdp
= param_getchar(Cmd
, 0);
72 uint8_t uid
[5] = {0x00};
74 if (cmdp
== 'h' || cmdp
== 'H') {
75 PrintAndLog("Usage: lf em 410xsim <UID> <clock>");
77 PrintAndLog(" sample: lf em 410xsim 0F0368568B");
80 /* clock is 64 in EM410x tags */
83 if (param_gethex(Cmd
, 0, uid
, 10)) {
84 PrintAndLog("UID must include 10 HEX symbols");
87 param_getdec(Cmd
,1, &clock
);
89 PrintAndLog("Starting simulating UID %02X%02X%02X%02X%02X clock: %d", uid
[0],uid
[1],uid
[2],uid
[3],uid
[4],clock
);
90 PrintAndLog("Press pm3-button to about simulation");
96 /* write 9 start bits */
97 for (i
= 0; i
< 9; i
++)
98 AppendGraph(0, clock
, 1);
100 /* for each hex char */
101 parity
[0] = parity
[1] = parity
[2] = parity
[3] = 0;
102 for (i
= 0; i
< 10; i
++)
104 /* read each hex char */
105 sscanf(&Cmd
[i
], "%1x", &n
);
106 for (j
= 3; j
>= 0; j
--, n
/= 2)
109 /* append each bit */
110 AppendGraph(0, clock
, binary
[0]);
111 AppendGraph(0, clock
, binary
[1]);
112 AppendGraph(0, clock
, binary
[2]);
113 AppendGraph(0, clock
, binary
[3]);
115 /* append parity bit */
116 AppendGraph(0, clock
, binary
[0] ^ binary
[1] ^ binary
[2] ^ binary
[3]);
118 /* keep track of column parity */
119 parity
[0] ^= binary
[0];
120 parity
[1] ^= binary
[1];
121 parity
[2] ^= binary
[2];
122 parity
[3] ^= binary
[3];
126 AppendGraph(0, clock
, parity
[0]);
127 AppendGraph(0, clock
, parity
[1]);
128 AppendGraph(0, clock
, parity
[2]);
129 AppendGraph(0, clock
, parity
[3]);
132 AppendGraph(1, clock
, 0);
134 CmdLFSim("0"); //240 start_gap.
138 /* Function is equivalent of lf read + data samples + em410xread
139 * looped until an EM410x tag is detected
141 * Why is CmdSamples("16000")?
142 * TBD: Auto-grow sample size based on detected sample rate. IE: If the
143 * rate gets lower, then grow the number of samples
144 * Changed by martin, 4000 x 4 = 16000,
145 * see http://www.proxmark.org/forum/viewtopic.php?pid=7235#p7235
147 int CmdEM410xWatch(const char *Cmd
)
151 printf("\naborted via keyboard!\n");
156 getSamples("8201",true); //capture enough to get 2 complete preambles (4096*2+9)
157 } while (!CmdEM410xRead(""));
162 //currently only supports manchester modulations
163 int CmdEM410xWatchnSpoof(const char *Cmd
)
166 PrintAndLog("# Replaying captured ID: %s",global_em410xId
);
171 int CmdEM410xWrite(const char *Cmd
)
173 uint64_t id
= 0xFFFFFFFFFFFFFFFF; // invalid id value
174 int card
= 0xFF; // invalid card value
175 unsigned int clock
= 0; // invalid clock value
177 sscanf(Cmd
, "%" PRIx64
" %d %d", &id
, &card
, &clock
);
180 if (id
== 0xFFFFFFFFFFFFFFFF) {
181 PrintAndLog("Error! ID is required.\n");
184 if (id
>= 0x10000000000) {
185 PrintAndLog("Error! Given EM410x ID is longer than 40 bits.\n");
191 PrintAndLog("Error! Card type required.\n");
195 PrintAndLog("Error! Bad card type selected.\n");
204 // Allowed clock rates: 16, 32, 40 and 64
205 if ((clock
!= 16) && (clock
!= 32) && (clock
!= 64) && (clock
!= 40)) {
206 PrintAndLog("Error! Clock rate %d not valid. Supported clock rates are 16, 32, 40 and 64.\n", clock
);
211 PrintAndLog("Writing %s tag with UID 0x%010" PRIx64
" (clock rate: %d)", "T55x7", id
, clock
);
212 // NOTE: We really should pass the clock in as a separate argument, but to
213 // provide for backwards-compatibility for older firmware, and to avoid
214 // having to add another argument to CMD_EM410X_WRITE_TAG, we just store
215 // the clock rate in bits 8-15 of the card value
216 card
= (card
& 0xFF) | ((clock
<< 8) & 0xFF00);
217 } else if (card
== 0) {
218 PrintAndLog("Writing %s tag with UID 0x%010" PRIx64
, "T5555", id
, clock
);
219 card
= (card
& 0xFF) | ((clock
<< 8) & 0xFF00);
221 PrintAndLog("Error! Bad card type selected.\n");
225 UsbCommand c
= {CMD_EM410X_WRITE_TAG
, {card
, (uint32_t)(id
>> 32), (uint32_t)id
}};
231 //**************** Start of EM4x50 Code ************************
232 bool EM_EndParityTest(uint8_t *BitStream
, size_t size
, uint8_t rows
, uint8_t cols
, uint8_t pType
)
234 if (rows
*cols
>size
) return false;
236 //assume last col is a parity and do not test
237 for (uint8_t colNum
= 0; colNum
< cols
-1; colNum
++) {
238 for (uint8_t rowNum
= 0; rowNum
< rows
; rowNum
++) {
239 colP
^= BitStream
[(rowNum
*cols
)+colNum
];
241 if (colP
!= pType
) return false;
246 bool EM_ByteParityTest(uint8_t *BitStream
, size_t size
, uint8_t rows
, uint8_t cols
, uint8_t pType
)
248 if (rows
*cols
>size
) return false;
250 //assume last row is a parity row and do not test
251 for (uint8_t rowNum
= 0; rowNum
< rows
-1; rowNum
++) {
252 for (uint8_t colNum
= 0; colNum
< cols
; colNum
++) {
253 rowP
^= BitStream
[(rowNum
*cols
)+colNum
];
255 if (rowP
!= pType
) return false;
260 uint32_t OutputEM4x50_Block(uint8_t *BitStream
, size_t size
, bool verbose
, bool pTest
)
262 if (size
<45) return 0;
263 uint32_t code
= bytebits_to_byte(BitStream
,8);
264 code
= code
<<8 | bytebits_to_byte(BitStream
+9,8);
265 code
= code
<<8 | bytebits_to_byte(BitStream
+18,8);
266 code
= code
<<8 | bytebits_to_byte(BitStream
+27,8);
267 if (verbose
|| g_debugMode
){
268 for (uint8_t i
= 0; i
<5; i
++){
269 if (i
== 4) PrintAndLog(""); //parity byte spacer
270 PrintAndLog("%d%d%d%d%d%d%d%d %d -> 0x%02x",
280 bytebits_to_byte(BitStream
+i
*9,8)
284 PrintAndLog("Parity Passed");
286 PrintAndLog("Parity Failed");
290 /* Read the transmitted data of an EM4x50 tag from the graphbuffer
293 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity
294 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity
295 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity
296 * XXXXXXXX [row parity bit (even)] <- 8 bits plus parity
297 * CCCCCCCC <- column parity bits
299 * LW <- Listen Window
301 * This pattern repeats for every block of data being transmitted.
302 * Transmission starts with two Listen Windows (LW - a modulated
303 * pattern of 320 cycles each (32/32/128/64/64)).
305 * Note that this data may or may not be the UID. It is whatever data
306 * is stored in the blocks defined in the control word First and Last
307 * Word Read values. UID is stored in block 32.
309 //completed by Marshmellow
310 int EM4x50Read(const char *Cmd
, bool verbose
)
312 uint8_t fndClk
[] = {8,16,32,40,50,64,128};
316 int i
, j
, startblock
, skip
, block
, start
, end
, low
, high
, minClk
;
317 bool complete
= false;
318 int tmpbuff
[MAX_GRAPH_TRACE_LEN
/ 64];
324 memset(tmpbuff
, 0, MAX_GRAPH_TRACE_LEN
/ 64);
326 // get user entry if any
327 sscanf(Cmd
, "%i %i", &clk
, &invert
);
329 // save GraphBuffer - to restore it later
332 // first get high and low values
333 for (i
= 0; i
< GraphTraceLen
; i
++) {
334 if (GraphBuffer
[i
] > high
)
335 high
= GraphBuffer
[i
];
336 else if (GraphBuffer
[i
] < low
)
337 low
= GraphBuffer
[i
];
343 // get to first full low to prime loop and skip incomplete first pulse
344 while ((GraphBuffer
[i
] < high
) && (i
< GraphTraceLen
))
346 while ((GraphBuffer
[i
] > low
) && (i
< GraphTraceLen
))
350 // populate tmpbuff buffer with pulse lengths
351 while (i
< GraphTraceLen
) {
352 // measure from low to low
353 while ((GraphBuffer
[i
] > low
) && (i
< GraphTraceLen
))
356 while ((GraphBuffer
[i
] < high
) && (i
< GraphTraceLen
))
358 while ((GraphBuffer
[i
] > low
) && (i
< GraphTraceLen
))
360 if (j
>=(MAX_GRAPH_TRACE_LEN
/64)) {
363 tmpbuff
[j
++]= i
- start
;
364 if (i
-start
< minClk
&& i
< GraphTraceLen
) {
370 for (uint8_t clkCnt
= 0; clkCnt
<7; clkCnt
++) {
371 tol
= fndClk
[clkCnt
]/8;
372 if (minClk
>= fndClk
[clkCnt
]-tol
&& minClk
<= fndClk
[clkCnt
]+1) {
380 // look for data start - should be 2 pairs of LW (pulses of clk*3,clk*2)
382 for (i
= 0; i
< j
- 4 ; ++i
) {
384 if (tmpbuff
[i
] >= clk
*3-tol
&& tmpbuff
[i
] <= clk
*3+tol
) //3 clocks
385 if (tmpbuff
[i
+1] >= clk
*2-tol
&& tmpbuff
[i
+1] <= clk
*2+tol
) //2 clocks
386 if (tmpbuff
[i
+2] >= clk
*3-tol
&& tmpbuff
[i
+2] <= clk
*3+tol
) //3 clocks
387 if (tmpbuff
[i
+3] >= clk
-tol
) //1.5 to 2 clocks - depends on bit following
395 // skip over the remainder of LW
396 skip
+= tmpbuff
[i
+1] + tmpbuff
[i
+2] + clk
;
397 if (tmpbuff
[i
+3]>clk
)
398 phaseoff
= tmpbuff
[i
+3]-clk
;
401 // now do it again to find the end
403 for (i
+= 3; i
< j
- 4 ; ++i
) {
405 if (tmpbuff
[i
] >= clk
*3-tol
&& tmpbuff
[i
] <= clk
*3+tol
) //3 clocks
406 if (tmpbuff
[i
+1] >= clk
*2-tol
&& tmpbuff
[i
+1] <= clk
*2+tol
) //2 clocks
407 if (tmpbuff
[i
+2] >= clk
*3-tol
&& tmpbuff
[i
+2] <= clk
*3+tol
) //3 clocks
408 if (tmpbuff
[i
+3] >= clk
-tol
) //1.5 to 2 clocks - depends on bit following
416 if (verbose
|| g_debugMode
) {
418 PrintAndLog("\nNote: one block = 50 bits (32 data, 12 parity, 6 marker)");
420 PrintAndLog("No data found!, clock tried:%d",clk
);
421 PrintAndLog("Try again with more samples.");
422 PrintAndLog(" or after a 'data askedge' command to clean up the read");
425 } else if (start
< 0) return 0;
427 snprintf(tmp2
, sizeof(tmp2
),"%d %d 1000 %d", clk
, invert
, clk
*47);
428 // get rid of leading crap
429 snprintf(tmp
, sizeof(tmp
), "%i", skip
);
432 bool AllPTest
= true;
433 // now work through remaining buffer printing out data blocks
437 if (verbose
|| g_debugMode
) PrintAndLog("\nBlock %i:", block
);
440 // look for LW before start of next block
441 for ( ; i
< j
- 4 ; ++i
) {
443 if (tmpbuff
[i
] >= clk
*3-tol
&& tmpbuff
[i
] <= clk
*3+tol
)
444 if (tmpbuff
[i
+1] >= clk
-tol
)
447 if (i
>= j
-4) break; //next LW not found
449 if (tmpbuff
[i
+1]>clk
)
450 phaseoff
= tmpbuff
[i
+1]-clk
;
454 if (ASKDemod(tmp2
, false, false, 1) < 1) {
458 //set DemodBufferLen to just one block
459 DemodBufferLen
= skip
/clk
;
461 pTest
= EM_ByteParityTest(DemodBuffer
,DemodBufferLen
,5,9,0);
462 pTest
&= EM_EndParityTest(DemodBuffer
,DemodBufferLen
,5,9,0);
465 Code
[block
] = OutputEM4x50_Block(DemodBuffer
,DemodBufferLen
,verbose
, pTest
);
466 if (g_debugMode
) PrintAndLog("\nskipping %d samples, bits:%d", skip
, skip
/clk
);
467 //skip to start of next block
468 snprintf(tmp
,sizeof(tmp
),"%i",skip
);
471 if (i
>= end
) break; //in case chip doesn't output 6 blocks
474 if (verbose
|| g_debugMode
|| AllPTest
){
476 PrintAndLog("*** Warning!");
477 PrintAndLog("Partial data - no end found!");
478 PrintAndLog("Try again with more samples.");
480 PrintAndLog("Found data at sample: %i - using clock: %i", start
, clk
);
482 for (block
=0; block
< end
; block
++){
483 PrintAndLog("Block %d: %08x",block
,Code
[block
]);
486 PrintAndLog("Parities Passed");
488 PrintAndLog("Parities Failed");
489 PrintAndLog("Try cleaning the read samples with 'data askedge'");
493 //restore GraphBuffer
495 return (int)AllPTest
;
498 int CmdEM4x50Read(const char *Cmd
)
500 return EM4x50Read(Cmd
, true);
503 //**************** Start of EM4x05/EM4x69 Code ************************
504 int usage_lf_em_read(void) {
505 PrintAndLog("Read EM4x05/EM4x69. Tag must be on antenna. ");
507 PrintAndLog("Usage: lf em 4x05readword [h] <address> <pwd>");
508 PrintAndLog("Options:");
509 PrintAndLog(" h - this help");
510 PrintAndLog(" address - memory address to read. (0-15)");
511 PrintAndLog(" pwd - password (hex) (optional)");
512 PrintAndLog("samples:");
513 PrintAndLog(" lf em 4x05readword 1");
514 PrintAndLog(" lf em 4x05readword 1 11223344");
518 // for command responses from em4x05 or em4x69
519 // download samples from device and copy them to the Graphbuffer
520 bool downloadSamplesEM() {
521 // 8 bit preamble + 32 bit word response (max clock (128) * 40bits = 5120 samples)
523 GetFromBigBuf(got
, sizeof(got
), 0);
524 if ( !WaitForResponseTimeout(CMD_ACK
, NULL
, 4000) ) {
525 PrintAndLog("command execution time out");
528 setGraphBuf(got
, sizeof(got
));
532 bool EM4x05testDemodReadData(uint32_t *word
, bool readCmd
) {
533 // em4x05/em4x69 command response preamble is 00001010
534 // skip first two 0 bits as they might have been missed in the demod
535 uint8_t preamble
[] = {0,0,1,0,1,0};
538 // set size to 20 to only test first 14 positions for the preamble or less if not a read command
539 size_t size
= (readCmd
) ? 20 : 11;
541 size
= (size
> DemodBufferLen
) ? DemodBufferLen
: size
;
543 if ( !preambleSearchEx(DemodBuffer
, preamble
, sizeof(preamble
), &size
, &startIdx
, true) ) {
544 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305 preamble not found :: %d", startIdx
);
547 // if this is a readword command, get the read bytes and test the parities
549 if (!EM_EndParityTest(DemodBuffer
+ startIdx
+ sizeof(preamble
), 45, 5, 9, 0)) {
550 if (g_debugMode
) PrintAndLog("DEBUG: Error - End Parity check failed");
553 // test for even parity bits and remove them. (leave out the end row of parities so 36 bits)
554 if ( removeParity(DemodBuffer
, startIdx
+ sizeof(preamble
),9,0,36) == 0 ) {
555 if (g_debugMode
) PrintAndLog("DEBUG: Error - Parity not detected");
559 setDemodBuf(DemodBuffer
, 32, 0);
560 *word
= bytebits_to_byteLSBF(DemodBuffer
, 32);
565 // FSK, PSK, ASK/MANCHESTER, ASK/BIPHASE, ASK/DIPHASE
566 // should cover 90% of known used configs
567 // the rest will need to be manually demoded for now...
568 int demodEM4x05resp(uint32_t *word
, bool readCmd
) {
571 // test for FSK wave (easiest to 99% ID)
572 if (GetFskClock("", false, false)) {
573 //valid fsk clocks found
574 ans
= FSKrawDemod("0 0", false);
576 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: FSK Demod failed, ans: %d", ans
);
578 if (EM4x05testDemodReadData(word
, readCmd
)) {
583 // PSK clocks should be easy to detect ( but difficult to demod a non-repeating pattern... )
584 ans
= GetPskClock("", false, false);
587 ans
= PSKDemod("0 0 6", false);
589 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed, ans: %d", ans
);
591 if (EM4x05testDemodReadData(word
, readCmd
)) {
595 psk1TOpsk2(DemodBuffer
, DemodBufferLen
);
596 if (EM4x05testDemodReadData(word
, readCmd
)) {
601 ans
= PSKDemod("0 1 6", false);
603 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed, ans: %d", ans
);
605 if (EM4x05testDemodReadData(word
, readCmd
)) {
609 psk1TOpsk2(DemodBuffer
, DemodBufferLen
);
610 if (EM4x05testDemodReadData(word
, readCmd
)) {
618 // manchester is more common than biphase... try first
619 bool stcheck
= false;
620 // try manchester - NOTE: ST only applies to T55x7 tags.
621 ans
= ASKDemod_ext("0,0,1", false, false, 1, &stcheck
);
623 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: ASK/Manchester Demod failed, ans: %d", ans
);
625 if (EM4x05testDemodReadData(word
, readCmd
)) {
631 ans
= ASKbiphaseDemod("0 0 1", false);
633 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed, ans: %d", ans
);
635 if (EM4x05testDemodReadData(word
, readCmd
)) {
640 //try diphase (differential biphase or inverted)
641 ans
= ASKbiphaseDemod("0 1 1", false);
643 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed, ans: %d", ans
);
645 if (EM4x05testDemodReadData(word
, readCmd
)) {
653 int EM4x05ReadWord_ext(uint8_t addr
, uint32_t pwd
, bool usePwd
, uint32_t *wordData
) {
654 UsbCommand c
= {CMD_EM4X_READ_WORD
, {addr
, pwd
, usePwd
}};
655 clearCommandBuffer();
658 if (!WaitForResponseTimeout(CMD_ACK
, &resp
, 2500)){
659 PrintAndLog("Command timed out");
662 if ( !downloadSamplesEM() ) {
665 int testLen
= (GraphTraceLen
< 1000) ? GraphTraceLen
: 1000;
666 if (graphJustNoise(GraphBuffer
, testLen
)) {
667 PrintAndLog("no tag not found");
671 return demodEM4x05resp(wordData
, true);
674 int EM4x05ReadWord(uint8_t addr
, uint32_t pwd
, bool usePwd
) {
675 uint32_t wordData
= 0;
676 int success
= EM4x05ReadWord_ext(addr
, pwd
, usePwd
, &wordData
);
678 PrintAndLog("%s Address %02d | %08X", (addr
>13) ? "Lock":" Got",addr
,wordData
);
680 PrintAndLog("Read Address %02d | failed",addr
);
685 int CmdEM4x05ReadWord(const char *Cmd
) {
689 uint8_t ctmp
= param_getchar(Cmd
, 0);
690 if ( strlen(Cmd
) == 0 || ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_read();
692 addr
= param_get8ex(Cmd
, 0, 50, 10);
693 // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
694 pwd
= param_get32ex(Cmd
, 1, 1, 16);
697 PrintAndLog("Address must be between 0 and 15");
701 PrintAndLog("Reading address %02u", addr
);
704 PrintAndLog("Reading address %02u | password %08X", addr
, pwd
);
707 return EM4x05ReadWord(addr
, pwd
, usePwd
);
710 int usage_lf_em_dump(void) {
711 PrintAndLog("Dump EM4x05/EM4x69. Tag must be on antenna. ");
713 PrintAndLog("Usage: lf em 4x05dump [h] <pwd>");
714 PrintAndLog("Options:");
715 PrintAndLog(" h - this help");
716 PrintAndLog(" pwd - password (hex) (optional)");
717 PrintAndLog("samples:");
718 PrintAndLog(" lf em 4x05dump");
719 PrintAndLog(" lf em 4x05dump 11223344");
723 int CmdEM4x05dump(const char *Cmd
) {
727 uint8_t ctmp
= param_getchar(Cmd
, 0);
728 if ( ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_dump();
730 // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
731 pwd
= param_get32ex(Cmd
, 0, 1, 16);
737 for (; addr
< 16; addr
++) {
740 PrintAndLog(" PWD Address %02u | %08X",addr
,pwd
);
742 PrintAndLog(" PWD Address 02 | cannot read");
745 success
&= EM4x05ReadWord(addr
, pwd
, usePwd
);
753 int usage_lf_em_write(void) {
754 PrintAndLog("Write EM4x05/EM4x69. Tag must be on antenna. ");
756 PrintAndLog("Usage: lf em 4x05writeword [h] <address> <data> <pwd>");
757 PrintAndLog("Options:");
758 PrintAndLog(" h - this help");
759 PrintAndLog(" address - memory address to write to. (0-15)");
760 PrintAndLog(" data - data to write (hex)");
761 PrintAndLog(" pwd - password (hex) (optional)");
762 PrintAndLog("samples:");
763 PrintAndLog(" lf em 4x05writeword 1");
764 PrintAndLog(" lf em 4x05writeword 1 deadc0de 11223344");
768 int CmdEM4x05WriteWord(const char *Cmd
) {
769 uint8_t ctmp
= param_getchar(Cmd
, 0);
770 if ( strlen(Cmd
) == 0 || ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_write();
774 uint8_t addr
= 16; // default to invalid address
775 uint32_t data
= 0xFFFFFFFF; // default to blank data
776 uint32_t pwd
= 0xFFFFFFFF; // default to blank password
778 addr
= param_get8ex(Cmd
, 0, 16, 10);
779 data
= param_get32ex(Cmd
, 1, 0, 16);
780 pwd
= param_get32ex(Cmd
, 2, 1, 16);
784 PrintAndLog("Address must be between 0 and 15");
788 PrintAndLog("Writing address %d data %08X", addr
, data
);
791 PrintAndLog("Writing address %d data %08X using password %08X", addr
, data
, pwd
);
794 uint16_t flag
= (addr
<< 8 ) | usePwd
;
796 UsbCommand c
= {CMD_EM4X_WRITE_WORD
, {flag
, data
, pwd
}};
797 clearCommandBuffer();
800 if (!WaitForResponseTimeout(CMD_ACK
, &resp
, 2000)){
801 PrintAndLog("Error occurred, device did not respond during write operation.");
804 if ( !downloadSamplesEM() ) {
807 //check response for 00001010 for write confirmation!
810 int result
= demodEM4x05resp(&dummy
,false);
812 PrintAndLog("Write Verified");
814 PrintAndLog("Write could not be verified");
819 void printEM4x05config(uint32_t wordData
) {
820 uint16_t datarate
= (((wordData
& 0x3F)+1)*2);
821 uint8_t encoder
= ((wordData
>> 6) & 0xF);
823 memset(enc
,0,sizeof(enc
));
825 uint8_t PSKcf
= (wordData
>> 10) & 0x3;
827 memset(cf
,0,sizeof(cf
));
828 uint8_t delay
= (wordData
>> 12) & 0x3;
830 memset(cdelay
,0,sizeof(cdelay
));
831 uint8_t LWR
= (wordData
>> 14) & 0xF; //last word read
834 case 0: snprintf(enc
,sizeof(enc
),"NRZ"); break;
835 case 1: snprintf(enc
,sizeof(enc
),"Manchester"); break;
836 case 2: snprintf(enc
,sizeof(enc
),"Biphase"); break;
837 case 3: snprintf(enc
,sizeof(enc
),"Miller"); break;
838 case 4: snprintf(enc
,sizeof(enc
),"PSK1"); break;
839 case 5: snprintf(enc
,sizeof(enc
),"PSK2"); break;
840 case 6: snprintf(enc
,sizeof(enc
),"PSK3"); break;
841 case 7: snprintf(enc
,sizeof(enc
),"Unknown"); break;
842 case 8: snprintf(enc
,sizeof(enc
),"FSK1"); break;
843 case 9: snprintf(enc
,sizeof(enc
),"FSK2"); break;
844 default: snprintf(enc
,sizeof(enc
),"Unknown"); break;
848 case 0: snprintf(cf
,sizeof(cf
),"RF/2"); break;
849 case 1: snprintf(cf
,sizeof(cf
),"RF/8"); break;
850 case 2: snprintf(cf
,sizeof(cf
),"RF/4"); break;
851 case 3: snprintf(cf
,sizeof(cf
),"unknown"); break;
855 case 0: snprintf(cdelay
, sizeof(cdelay
),"no delay"); break;
856 case 1: snprintf(cdelay
, sizeof(cdelay
),"BP/8 or 1/8th bit period delay"); break;
857 case 2: snprintf(cdelay
, sizeof(cdelay
),"BP/4 or 1/4th bit period delay"); break;
858 case 3: snprintf(cdelay
, sizeof(cdelay
),"no delay"); break;
860 PrintAndLog("ConfigWord: %08X (Word 4)\n", wordData
);
861 PrintAndLog("Config Breakdown:", wordData
);
862 PrintAndLog(" Data Rate: %02u | RF/%u", wordData
& 0x3F, datarate
);
863 PrintAndLog(" Encoder: %u | %s", encoder
, enc
);
864 PrintAndLog(" PSK CF: %u | %s", PSKcf
, cf
);
865 PrintAndLog(" Delay: %u | %s", delay
, cdelay
);
866 PrintAndLog(" LastWordR: %02u | Address of last word for default read", LWR
);
867 PrintAndLog(" ReadLogin: %u | Read Login is %s", (wordData
& 0x40000)>>18, (wordData
& 0x40000) ? "Required" : "Not Required");
868 PrintAndLog(" ReadHKL: %u | Read Housekeeping Words Login is %s", (wordData
& 0x80000)>>19, (wordData
& 0x80000) ? "Required" : "Not Required");
869 PrintAndLog("WriteLogin: %u | Write Login is %s", (wordData
& 0x100000)>>20, (wordData
& 0x100000) ? "Required" : "Not Required");
870 PrintAndLog(" WriteHKL: %u | Write Housekeeping Words Login is %s", (wordData
& 0x200000)>>21, (wordData
& 0x200000) ? "Required" : "Not Required");
871 PrintAndLog(" R.A.W.: %u | Read After Write is %s", (wordData
& 0x400000)>>22, (wordData
& 0x400000) ? "On" : "Off");
872 PrintAndLog(" Disable: %u | Disable Command is %s", (wordData
& 0x800000)>>23, (wordData
& 0x800000) ? "Accepted" : "Not Accepted");
873 PrintAndLog(" R.T.F.: %u | Reader Talk First is %s", (wordData
& 0x1000000)>>24, (wordData
& 0x1000000) ? "Enabled" : "Disabled");
874 PrintAndLog(" Pigeon: %u | Pigeon Mode is %s\n", (wordData
& 0x4000000)>>26, (wordData
& 0x4000000) ? "Enabled" : "Disabled");
877 void printEM4x05info(uint8_t chipType
, uint8_t cap
, uint16_t custCode
, uint32_t serial
) {
879 case 9: PrintAndLog("\n Chip Type: %u | EM4305", chipType
); break;
880 case 4: PrintAndLog(" Chip Type: %u | Unknown", chipType
); break;
881 case 2: PrintAndLog(" Chip Type: %u | EM4469", chipType
); break;
882 //add more here when known
883 default: PrintAndLog(" Chip Type: %u Unknown", chipType
); break;
887 case 3: PrintAndLog(" Cap Type: %u | 330pF",cap
); break;
888 case 2: PrintAndLog(" Cap Type: %u | %spF",cap
, (chipType
==2)? "75":"210"); break;
889 case 1: PrintAndLog(" Cap Type: %u | 250pF",cap
); break;
890 case 0: PrintAndLog(" Cap Type: %u | no resonant capacitor",cap
); break;
891 default: PrintAndLog(" Cap Type: %u | unknown",cap
); break;
894 PrintAndLog(" Cust Code: %03u | %s", custCode
, (custCode
== 0x200) ? "Default": "Unknown");
896 PrintAndLog("\n Serial #: %08X\n", serial
);
900 void printEM4x05ProtectionBits(uint32_t wordData
) {
901 for (uint8_t i
= 0; i
< 15; i
++) {
902 PrintAndLog(" Word: %02u | %s", i
, (((1 << i
) & wordData
) || i
< 2) ? "Is Write Locked" : "Is Not Write Locked");
904 PrintAndLog(" Word: %02u | %s", i
+1, (((1 << i
) & wordData
) || i
< 2) ? "Is Write Locked" : "Is Not Write Locked");
909 //quick test for EM4x05/EM4x69 tag
910 bool EM4x05Block0Test(uint32_t *wordData
) {
911 if (EM4x05ReadWord_ext(0,0,false,wordData
) == 1) {
917 int CmdEM4x05info(const char *Cmd
) {
920 uint32_t wordData
= 0;
922 uint8_t ctmp
= param_getchar(Cmd
, 0);
923 if ( ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_dump();
925 // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
926 pwd
= param_get32ex(Cmd
, 0, 1, 16);
932 // read word 0 (chip info)
933 // block 0 can be read even without a password.
934 if ( !EM4x05Block0Test(&wordData
) )
937 uint8_t chipType
= (wordData
>> 1) & 0xF;
938 uint8_t cap
= (wordData
>> 5) & 3;
939 uint16_t custCode
= (wordData
>> 9) & 0x3FF;
941 // read word 1 (serial #) doesn't need pwd
943 if (EM4x05ReadWord_ext(1, 0, false, &wordData
) != 1) {
944 //failed, but continue anyway...
946 printEM4x05info(chipType
, cap
, custCode
, wordData
);
948 // read word 4 (config block)
949 // needs password if one is set
951 if ( EM4x05ReadWord_ext(4, pwd
, usePwd
, &wordData
) != 1 ) {
955 printEM4x05config(wordData
);
957 // read word 14 and 15 to see which is being used for the protection bits
959 if ( EM4x05ReadWord_ext(14, pwd
, usePwd
, &wordData
) != 1 ) {
963 // if status bit says this is not the used protection word
964 if (!(wordData
& 0x8000)) {
965 if ( EM4x05ReadWord_ext(15, pwd
, usePwd
, &wordData
) != 1 ) {
970 if (!(wordData
& 0x8000)) {
971 //something went wrong
974 printEM4x05ProtectionBits(wordData
);
980 static command_t CommandTable
[] =
982 {"help", CmdHelp
, 1, "This help"},
983 {"410xdemod", CmdEMdemodASK
, 0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},
984 {"410xread", CmdEM410xRead
, 1, "[clock rate] -- Extract ID from EM410x tag in GraphBuffer"},
985 {"410xsim", CmdEM410xSim
, 0, "<UID> [clock rate] -- Simulate EM410x tag"},
986 {"410xwatch", CmdEM410xWatch
, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
987 {"410xspoof", CmdEM410xWatchnSpoof
, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
988 {"410xwrite", CmdEM410xWrite
, 0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
989 {"4x05dump", CmdEM4x05dump
, 0, "(pwd) -- Read EM4x05/EM4x69 all word data"},
990 {"4x05info", CmdEM4x05info
, 0, "(pwd) -- Get info from EM4x05/EM4x69 tag"},
991 {"4x05readword", CmdEM4x05ReadWord
, 0, "<Word> (pwd) -- Read EM4x05/EM4x69 word data"},
992 {"4x05writeword", CmdEM4x05WriteWord
, 0, "<Word> <data> (pwd) -- Write EM4x05/EM4x69 word data"},
993 {"4x50read", CmdEM4x50Read
, 1, "demod data from EM4x50 tag from the graph buffer"},
994 {NULL
, NULL
, 0, NULL
}
997 int CmdLFEM4X(const char *Cmd
)
999 CmdsParse(CommandTable
, Cmd
);
1003 int CmdHelp(const char *Cmd
)
1005 CmdsHelp(CommandTable
);