]>
git.zerfleddert.de Git - proxmark3-svn/blob - client/cmdlfem4x.c
397b21e7280a398f6acaa27bddeed5f977e6e1f5
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 em4x em410xsim <UID> <clock>");
77 PrintAndLog(" sample: lf em4x em410xsim 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 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};
537 // set size to 15 to only test first 9 positions for the preamble
538 size_t size
= (15 > DemodBufferLen
) ? DemodBufferLen
: 15;
541 if ( !onePreambleSearch(DemodBuffer
, preamble
, sizeof(preamble
), size
, &startIdx
) ) {
542 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305 preamble not found :: %d", startIdx
);
545 // if this is a readword command, get the read bytes and test the parities
547 if (!EM_EndParityTest(DemodBuffer
+ startIdx
+ sizeof(preamble
), 45, 5, 9, 0)) {
548 if (g_debugMode
) PrintAndLog("DEBUG: Error - End Parity check failed");
551 //test for even parity bits.
552 if ( removeParity(DemodBuffer
, startIdx
+ sizeof(preamble
),9,0,44) == 0 ) {
553 if (g_debugMode
) PrintAndLog("DEBUG: Error - Parity not detected");
557 setDemodBuf(DemodBuffer
, 40, 0);
558 *word
= bytebits_to_byteLSBF(DemodBuffer
, 32);
563 // FSK, PSK, ASK/MANCHESTER, ASK/BIPHASE, ASK/DIPHASE
564 // should cover 90% of known used configs
565 // the rest will need to be manually demoded for now...
566 int demodEM4x05resp(uint32_t *word
, bool readCmd
) {
569 // test for FSK wave (easiest to 99% ID)
570 if (GetFskClock("", FALSE
, FALSE
)) {
571 //valid fsk clocks found
572 ans
= FSKrawDemod("0 0", false);
574 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: FSK Demod failed, ans: %d", ans
);
576 if (EM4x05testDemodReadData(word
, readCmd
)) {
581 // PSK clocks should be easy to detect ( but difficult to demod a non-repeating pattern... )
582 ans
= GetPskClock("", FALSE
, FALSE
);
585 ans
= PSKDemod("0 0 6", FALSE
);
587 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed, ans: %d", ans
);
589 if (EM4x05testDemodReadData(word
, readCmd
)) {
593 psk1TOpsk2(DemodBuffer
, DemodBufferLen
);
594 if (EM4x05testDemodReadData(word
, readCmd
)) {
599 ans
= PSKDemod("0 1 6", FALSE
);
601 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed, ans: %d", ans
);
603 if (EM4x05testDemodReadData(word
, readCmd
)) {
607 psk1TOpsk2(DemodBuffer
, DemodBufferLen
);
608 if (EM4x05testDemodReadData(word
, readCmd
)) {
616 // manchester is more common than biphase... try first
617 bool stcheck
= false;
618 // try manchester - NOTE: ST only applies to T55x7 tags.
619 ans
= ASKDemod_ext("0,0,1", false, false, 1, &stcheck
);
621 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: ASK/Manchester Demod failed, ans: %d", ans
);
623 if (EM4x05testDemodReadData(word
, readCmd
)) {
629 ans
= ASKbiphaseDemod("0 0 1", FALSE
);
631 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed, ans: %d", ans
);
633 if (EM4x05testDemodReadData(word
, readCmd
)) {
638 //try diphase (differential biphase or inverted)
639 ans
= ASKbiphaseDemod("0 1 1", FALSE
);
641 if (g_debugMode
) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed, ans: %d", ans
);
643 if (EM4x05testDemodReadData(word
, readCmd
)) {
651 int EM4x05ReadWord(uint8_t addr
, uint32_t pwd
, bool usePwd
) {
652 UsbCommand c
= {CMD_EM4X_READ_WORD
, {addr
, pwd
, usePwd
}};
653 clearCommandBuffer();
656 if (!WaitForResponseTimeout(CMD_ACK
, &resp
, 2500)){
657 PrintAndLog("Command timed out");
660 if ( !downloadSamplesEM() ) {
663 int testLen
= (GraphTraceLen
< 1000) ? GraphTraceLen
: 1000;
664 if (graphJustNoise(GraphBuffer
, testLen
)) {
665 PrintAndLog("no tag not found");
669 uint32_t wordData
= 0;
670 int success
= demodEM4x05resp(&wordData
, true);
672 PrintAndLog(" Got Address %02d | %08X",addr
,wordData
);
674 PrintAndLog("RSead Address %02d | failed",addr
);
679 int CmdEM4x05ReadWord(const char *Cmd
) {
683 uint8_t ctmp
= param_getchar(Cmd
, 0);
684 if ( strlen(Cmd
) == 0 || ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_read();
686 addr
= param_get8ex(Cmd
, 0, 50, 10);
687 // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
688 pwd
= param_get32ex(Cmd
, 1, 1, 16);
691 PrintAndLog("Address must be between 0 and 15");
695 PrintAndLog("Reading address %02u", addr
);
698 PrintAndLog("Reading address %02u | password %08X", addr
, pwd
);
701 return EM4x05ReadWord(addr
, pwd
, usePwd
);
704 int usage_lf_em_dump(void) {
705 PrintAndLog("Dump EM4x05/EM4x69. Tag must be on antenna. ");
707 PrintAndLog("Usage: lf em 4x05dump [h] <pwd>");
708 PrintAndLog("Options:");
709 PrintAndLog(" h - this help");
710 PrintAndLog(" pwd - password (hex) (optional)");
711 PrintAndLog("samples:");
712 PrintAndLog(" lf em 4x05dump");
713 PrintAndLog(" lf em 4x05dump 11223344");
717 int CmdEM4x05dump(const char *Cmd
) {
721 uint8_t ctmp
= param_getchar(Cmd
, 0);
722 if ( ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_dump();
724 // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
725 pwd
= param_get32ex(Cmd
, 0, 1, 16);
731 for (; addr
< 16; addr
++) {
734 PrintAndLog("PWD Address %02u | %08X",addr
,pwd
);
736 PrintAndLog("PWD Address 02 | cannot read");
739 success
&= EM4x05ReadWord(addr
, pwd
, usePwd
);
747 int usage_lf_em_write(void) {
748 PrintAndLog("Write EM4x05/EM4x69. Tag must be on antenna. ");
750 PrintAndLog("Usage: lf em 4x05writeword [h] <address> <data> <pwd>");
751 PrintAndLog("Options:");
752 PrintAndLog(" h - this help");
753 PrintAndLog(" address - memory address to write to. (0-15)");
754 PrintAndLog(" data - data to write (hex)");
755 PrintAndLog(" pwd - password (hex) (optional)");
756 PrintAndLog("samples:");
757 PrintAndLog(" lf em 4x05writeword 1");
758 PrintAndLog(" lf em 4x05writeword 1 deadc0de 11223344");
762 int CmdEM4x05WriteWord(const char *Cmd
) {
763 uint8_t ctmp
= param_getchar(Cmd
, 0);
764 if ( strlen(Cmd
) == 0 || ctmp
== 'H' || ctmp
== 'h' ) return usage_lf_em_write();
768 uint8_t addr
= 16; // default to invalid address
769 uint32_t data
= 0xFFFFFFFF; // default to blank data
770 uint32_t pwd
= 0xFFFFFFFF; // default to blank password
772 addr
= param_get8ex(Cmd
, 0, 16, 10);
773 data
= param_get32ex(Cmd
, 1, 0, 16);
774 pwd
= param_get32ex(Cmd
, 2, 1, 16);
778 PrintAndLog("Address must be between 0 and 15");
782 PrintAndLog("Writing address %d data %08X", addr
, data
);
785 PrintAndLog("Writing address %d data %08X using password %08X", addr
, data
, pwd
);
788 uint16_t flag
= (addr
<< 8 ) | usePwd
;
790 UsbCommand c
= {CMD_EM4X_WRITE_WORD
, {flag
, data
, pwd
}};
791 clearCommandBuffer();
794 if (!WaitForResponseTimeout(CMD_ACK
, &resp
, 2000)){
795 PrintAndLog("Error occurred, device did not respond during write operation.");
798 if ( !downloadSamplesEM() ) {
801 //check response for 00001010 for write confirmation!
804 int result
= demodEM4x05resp(&dummy
,false);
806 PrintAndLog("Write Verified");
811 static command_t CommandTable
[] =
813 {"help", CmdHelp
, 1, "This help"},
814 {"410xdemod", CmdEMdemodASK
, 0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},
815 {"410xread", CmdEM410xRead
, 1, "[clock rate] -- Extract ID from EM410x tag in GraphBuffer"},
816 {"410xsim", CmdEM410xSim
, 0, "<UID> [clock rate] -- Simulate EM410x tag"},
817 {"410xwatch", CmdEM410xWatch
, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
818 {"410xspoof", CmdEM410xWatchnSpoof
, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
819 {"410xwrite", CmdEM410xWrite
, 0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
820 {"4x05dump", CmdEM4x05dump
, 1, "(pwd) -- Read EM4x05/EM4x69 all word data"},
821 {"4x05readword", CmdEM4x05ReadWord
, 1, "<Word> (pwd) -- Read EM4x05/EM4x69 word data"},
822 {"4x05writeword", CmdEM4x05WriteWord
, 1, "<Word> <data> (pwd) -- Write EM4x05/EM4x69 word data"},
823 {"4x50read", CmdEM4x50Read
, 1, "demod data from EM4x50 tag from the graph buffer"},
824 {NULL
, NULL
, 0, NULL
}
827 int CmdLFEM4X(const char *Cmd
)
829 CmdsParse(CommandTable
, Cmd
);
833 int CmdHelp(const char *Cmd
)
835 CmdsHelp(CommandTable
);