]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdlfem4x.c
meant to put clock detection before demods
[proxmark3-svn] / client / cmdlfem4x.c
index 531199c454ffde2a2aa025c7cbc467bb9d045c05..f9103126ea99863931b8b943e8ea0dbafef4acfd 100644 (file)
@@ -63,6 +63,20 @@ int CmdEM410xRead(const char *Cmd)
        return 1;
 }
 
+int usage_lf_em410x_sim(void) {
+       PrintAndLog("Simulating EM410x tag");
+       PrintAndLog("");
+       PrintAndLog("Usage:  lf em 410xsim [h] <uid> <clock>");
+       PrintAndLog("Options:");
+       PrintAndLog("       h         - this help");
+       PrintAndLog("       uid       - uid (10 HEX symbols)");
+       PrintAndLog("       clock     - clock (32|64) (optional)");
+       PrintAndLog("samples:");
+       PrintAndLog("      lf em 410xsim 0F0368568B");
+       PrintAndLog("      lf em 410xsim 0F0368568B 32");
+       return 0;
+}
+
 // emulate an EM410X tag
 int CmdEM410xSim(const char *Cmd)
 {
@@ -71,12 +85,7 @@ int CmdEM410xSim(const char *Cmd)
        char cmdp = param_getchar(Cmd, 0);
        uint8_t uid[5] = {0x00};
 
-       if (cmdp == 'h' || cmdp == 'H') {
-               PrintAndLog("Usage:  lf em4x em410xsim <UID> <clock>");
-               PrintAndLog("");
-               PrintAndLog("     sample: lf em4x em410xsim 0F0368568B");
-               return 0;
-       }
+       if (cmdp == 'h' || cmdp == 'H') return usage_lf_em410x_sim();
        /* clock is 64 in EM410x tags */
        uint8_t clock = 64;
 
@@ -174,7 +183,7 @@ int CmdEM410xWrite(const char *Cmd)
        int card = 0xFF; // invalid card value
        unsigned int clock = 0; // invalid clock value
 
-       sscanf(Cmd, "%" PRIx64 " %d %d", &id, &card, &clock);
+       sscanf(Cmd, "%" SCNx64 " %d %d", &id, &card, &clock);
 
        // Check ID
        if (id == 0xFFFFFFFFFFFFFFFF) {
@@ -228,6 +237,7 @@ int CmdEM410xWrite(const char *Cmd)
        return 0;
 }
 
+//**************** Start of EM4x50 Code ************************
 bool EM_EndParityTest(uint8_t *BitStream, size_t size, uint8_t rows, uint8_t cols, uint8_t pType)
 {
        if (rows*cols>size) return false;
@@ -499,6 +509,7 @@ int CmdEM4x50Read(const char *Cmd)
        return EM4x50Read(Cmd, true);
 }
 
+//**************** Start of EM4x05/EM4x69 Code ************************
 int usage_lf_em_read(void) {
        PrintAndLog("Read EM4x05/EM4x69.  Tag must be on antenna. ");
        PrintAndLog("");
@@ -513,64 +524,49 @@ int usage_lf_em_read(void) {
        return 0;
 }
 
-//search for given preamble in given BitStream and return success=1 or fail=0 and startIndex
-bool EMpreambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t size, size_t *startIdx) {
-       // Sanity check.  If preamble length is bigger than bitstream length.
-       if ( size <= pLen ) return false;
-       // em only sends preamble once, so look for it once in the first x bits
-       uint8_t foundCnt = 0;
-       for (size_t idx = 0; idx < size - pLen; idx++){
-               if (memcmp(BitStream+idx, preamble, pLen) == 0){
-                       //first index found
-                       foundCnt++;
-                       if (foundCnt == 1) {
-                               if (g_debugMode) PrintAndLog("DEBUG: preamble found at %u", idx);
-                               *startIdx = idx;
-
-                               return true;
-                       }
-               }
+// for command responses from em4x05 or em4x69
+// download samples from device and copy them to the Graphbuffer
+bool downloadSamplesEM() {
+       // 8 bit preamble + 32 bit word response (max clock (128) * 40bits = 5120 samples)
+       uint8_t got[6000]; 
+       GetFromBigBuf(got, sizeof(got), 0);
+       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 4000) ) {
+               PrintAndLog("command execution time out");
+               return false;
        }
-       return false;
+       setGraphBuf(got, sizeof(got));
+       return true;
 }
 
 bool EM4x05testDemodReadData(uint32_t *word, bool readCmd) {
-       // skip first two 0 bits as they might have been missed in the demod 
-       uint8_t preamble[6] = {0,0,1,0,1,0};
+       // em4x05/em4x69 command response preamble is 00001010
+       // skip first two 0 bits as they might have been missed in the demod
+       uint8_t preamble[] = {0,0,1,0,1,0};
        size_t startIdx = 0;
-       // set size to 15 to only test first 9 positions for the preamble
-       size_t size = (15 > DemodBufferLen) ? DemodBufferLen : 15;
-       startIdx = 0; 
 
-       //test preamble
-       bool errChk = EMpreambleSearch(DemodBuffer, preamble, sizeof(preamble), size, &startIdx);
-       if ( !errChk ) {
+       // set size to 20 to only test first 14 positions for the preamble or less if not a read command
+       size_t size = (readCmd) ? 20 : 11;
+       // sanity check
+       size = (size > DemodBufferLen) ? DemodBufferLen : size;
+       // test preamble
+       if ( !preambleSearchEx(DemodBuffer, preamble, sizeof(preamble), &size, &startIdx, true) ) {
                if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305 preamble not found :: %d", startIdx);
                return false;
        }
+       // if this is a readword command, get the read bytes and test the parities
        if (readCmd) {
-               //test for even parity bits.
-               size = removeParity(DemodBuffer, startIdx + sizeof(preamble),9,0,44);
-               if (size == 0) {
+               if (!EM_EndParityTest(DemodBuffer + startIdx + sizeof(preamble), 45, 5, 9, 0)) {
+                       if (g_debugMode) PrintAndLog("DEBUG: Error - End Parity check failed");
+                       return false;
+               }
+               // test for even parity bits and remove them. (leave out the end row of parities so 36 bits)
+               if ( removeParity(DemodBuffer, startIdx + sizeof(preamble),9,0,36) == 0 ) {             
                        if (g_debugMode) PrintAndLog("DEBUG: Error - Parity not detected");
                        return false;
                }
 
-               //todo test last 8 bits for even parity || (xor)
-
-               setDemodBuf(DemodBuffer, 40, 0);
-
-               *word = bytebits_to_byteLSBF(DemodBuffer   , 32);
-
-               uint8_t lo  = (uint8_t) bytebits_to_byteLSBF(DemodBuffer     , 8);
-               uint8_t lo2 = (uint8_t) bytebits_to_byteLSBF(DemodBuffer +  8, 8);
-               uint8_t hi  = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 16, 8);
-               uint8_t hi2 = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 24, 8);
-               uint8_t cs  = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 32, 8);
-               uint8_t cs2 = lo ^ lo2 ^ hi ^ hi2;
-               if (g_debugMode) PrintAndLog("EM4x05/4x69 : %08X CS: %02X %s",*word,cs, (cs2==cs) ? "Passed" : "Failed");
-
-               return (cs2==cs) ? true : false;
+               setDemodBuf(DemodBuffer, 32, 0);
+               *word = bytebits_to_byteLSBF(DemodBuffer, 32);
        }
        return true;
 }
@@ -580,14 +576,13 @@ bool EM4x05testDemodReadData(uint32_t *word, bool readCmd) {
 // the rest will need to be manually demoded for now...
 int demodEM4x05resp(uint32_t *word, bool readCmd) {
        int ans = 0;
-       DemodBufferLen = 0x00;
 
        // test for FSK wave (easiest to 99% ID)
-       if (GetFskClock("", FALSE, FALSE)) {
+       if (GetFskClock("", false, false)) {
                //valid fsk clocks found
                ans = FSKrawDemod("0 0", false);
                if (!ans) {
-                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: FSK Demod failed");
+                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: FSK Demod failed, ans: %d", ans);
                } else {
                        if (EM4x05testDemodReadData(word, readCmd)) {
                                return 1;
@@ -595,13 +590,12 @@ int demodEM4x05resp(uint32_t *word, bool readCmd) {
                }
        }
        // PSK clocks should be easy to detect ( but difficult to demod a non-repeating pattern... )
-       ans = GetPskClock("", FALSE, FALSE);
+       ans = GetPskClock("", false, false);
        if (ans>0) {
                //try psk1
-               DemodBufferLen = 0x00;
-               ans = PSKDemod("0 0 6", FALSE);
+               ans = PSKDemod("0 0 6", false);
                if (!ans) {
-                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed");
+                       if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed, ans: %d", ans);
                } else {
                        if (EM4x05testDemodReadData(word, readCmd)) {
                                return 1;
@@ -613,10 +607,9 @@ int demodEM4x05resp(uint32_t *word, bool readCmd) {
                                }
                        }
                        //try psk1 inverted
-                       DemodBufferLen = 0x00;
-                       ans = PSKDemod("0 1 6", FALSE);
+                       ans = PSKDemod("0 1 6", false);
                        if (!ans) {
-                               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed");
+                               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: PSK1 Demod failed, ans: %d", ans);
                        } else {
                                if (EM4x05testDemodReadData(word, readCmd)) {
                                        return 1;
@@ -631,35 +624,32 @@ int demodEM4x05resp(uint32_t *word, bool readCmd) {
                }
        }
 
-       // more common than biphase
-       DemodBufferLen = 0x00;
+       // manchester is more common than biphase... try first
        bool stcheck = false;
        // try manchester - NOTE: ST only applies to T55x7 tags.
        ans = ASKDemod_ext("0,0,1", false, false, 1, &stcheck);
        if (!ans) {
-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/Manchester Demod failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/Manchester Demod failed, ans: %d", ans);
        } else {
                if (EM4x05testDemodReadData(word, readCmd)) {
                        return 1;
                }
        }
 
-       DemodBufferLen = 0x00;
        //try biphase
-       ans = ASKbiphaseDemod("0 0 1", FALSE);
+       ans = ASKbiphaseDemod("0 0 1", false);
        if (!ans) { 
-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed, ans: %d", ans);
        } else {
                if (EM4x05testDemodReadData(word, readCmd)) {
                        return 1;
                }
        }
 
-       DemodBufferLen = 0x00;
        //try diphase (differential biphase or inverted)
-       ans = ASKbiphaseDemod("0 1 1", FALSE);
+       ans = ASKbiphaseDemod("0 1 1", false);
        if (!ans) { 
-               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed");
+               if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase Demod failed, ans: %d", ans);
        } else {
                if (EM4x05testDemodReadData(word, readCmd)) {
                        return 1;
@@ -669,7 +659,7 @@ int demodEM4x05resp(uint32_t *word, bool readCmd) {
        return -1;
 }
 
-int EM4x05ReadWord(uint8_t addr, uint32_t pwd, bool usePwd) {
+int EM4x05ReadWord_ext(uint8_t addr, uint32_t pwd, bool usePwd, uint32_t *wordData) {
        UsbCommand c = {CMD_EM4X_READ_WORD, {addr, pwd, usePwd}};
        clearCommandBuffer();
        SendCommand(&c);
@@ -678,23 +668,26 @@ int EM4x05ReadWord(uint8_t addr, uint32_t pwd, bool usePwd) {
                PrintAndLog("Command timed out");
                return -1;
        }
-
-       uint8_t got[6000];
-       GetFromBigBuf(got, sizeof(got), 0);
-       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500) ) {
-               PrintAndLog("command execution time out");
+       if ( !downloadSamplesEM() ) {
                return -1;
        }
-       setGraphBuf(got, sizeof(got));
        int testLen = (GraphTraceLen < 1000) ? GraphTraceLen : 1000;
        if (graphJustNoise(GraphBuffer, testLen)) {
                PrintAndLog("no tag not found");
                return -1;
        }
        //attempt demod:
+       return demodEM4x05resp(wordData, true);
+}
+
+int EM4x05ReadWord(uint8_t addr, uint32_t pwd, bool usePwd) {
        uint32_t wordData = 0;
-       int success = demodEM4x05resp(&wordData, true);
-       if (success == 1) PrintAndLog("Got Address %02d | %08X",addr,wordData);
+       int success = EM4x05ReadWord_ext(addr, pwd, usePwd, &wordData);
+       if (success == 1)
+               PrintAndLog("%s Address %02d | %08X", (addr>13) ? "Lock":" Got",addr,wordData);
+       else
+               PrintAndLog("Read Address %02d | failed",addr);
+
        return success;
 }
 
@@ -713,18 +706,14 @@ int CmdEM4x05ReadWord(const char *Cmd) {
                PrintAndLog("Address must be between 0 and 15");
                return 1;
        }
-       if ( pwd == 1 )
+       if ( pwd == 1 ) {
                PrintAndLog("Reading address %02u", addr);
-       else {
+       }       else {
                usePwd = true;
                PrintAndLog("Reading address %02u | password %08X", addr, pwd);
        }
 
-       int result = EM4x05ReadWord(addr, pwd, usePwd);
-       if (result == -1)
-               PrintAndLog("Read failed");
-       
-       return result;
+       return EM4x05ReadWord(addr, pwd, usePwd);
 }
 
 int usage_lf_em_dump(void) {
@@ -757,9 +746,9 @@ int CmdEM4x05dump(const char *Cmd) {
        for (; addr < 16; addr++) {
                if (addr == 2) {
                        if (usePwd) {
-                               PrintAndLog("PWD Address %02u | %08X",addr,pwd);
+                               PrintAndLog(" PWD Address %02u | %08X",addr,pwd);
                        } else {
-                               PrintAndLog("PWD Address 02 | cannot read");
+                               PrintAndLog(" PWD Address 02 | cannot read");
                        }
                } else {
                        success &= EM4x05ReadWord(addr, pwd, usePwd);
@@ -821,24 +810,182 @@ int CmdEM4x05WriteWord(const char *Cmd) {
                PrintAndLog("Error occurred, device did not respond during write operation.");
                return -1;
        }
-       //get response if there is one
-       uint8_t got[6000]; // 8 bit preamble + 32 bit word response (max clock (128) * 40bits = 5120 samples)
-       GetFromBigBuf(got, sizeof(got), 0);
-       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 4000) ) {
-               PrintAndLog("command execution time out");
-               return 0;
+       if ( !downloadSamplesEM() ) {
+               return -1;
        }
-       setGraphBuf(got, sizeof(got));
        //check response for 00001010 for write confirmation!   
        //attempt demod:
        uint32_t dummy = 0;
        int result = demodEM4x05resp(&dummy,false);
        if (result == 1) {
                PrintAndLog("Write Verified");
+       } else {
+               PrintAndLog("Write could not be verified");
        }
        return result;
 }
 
+void printEM4x05config(uint32_t wordData) {
+       uint16_t datarate = (((wordData & 0x3F)+1)*2);
+       uint8_t encoder = ((wordData >> 6) & 0xF);
+       char enc[14];
+       memset(enc,0,sizeof(enc));
+
+       uint8_t PSKcf = (wordData >> 10) & 0x3;
+       char cf[10];
+       memset(cf,0,sizeof(cf));
+       uint8_t delay = (wordData >> 12) & 0x3;
+       char cdelay[33];
+       memset(cdelay,0,sizeof(cdelay));
+       uint8_t LWR = (wordData >> 14) & 0xF; //last word read
+
+       switch (encoder) {
+               case 0: snprintf(enc,sizeof(enc),"NRZ"); break;
+               case 1: snprintf(enc,sizeof(enc),"Manchester"); break;
+               case 2: snprintf(enc,sizeof(enc),"Biphase"); break;
+               case 3: snprintf(enc,sizeof(enc),"Miller"); break;
+               case 4: snprintf(enc,sizeof(enc),"PSK1"); break;
+               case 5: snprintf(enc,sizeof(enc),"PSK2"); break;
+               case 6: snprintf(enc,sizeof(enc),"PSK3"); break;
+               case 7: snprintf(enc,sizeof(enc),"Unknown"); break;
+               case 8: snprintf(enc,sizeof(enc),"FSK1"); break;
+               case 9: snprintf(enc,sizeof(enc),"FSK2"); break;
+               default: snprintf(enc,sizeof(enc),"Unknown"); break;
+       }
+
+       switch (PSKcf) {
+               case 0: snprintf(cf,sizeof(cf),"RF/2"); break;
+               case 1: snprintf(cf,sizeof(cf),"RF/8"); break;
+               case 2: snprintf(cf,sizeof(cf),"RF/4"); break;
+               case 3: snprintf(cf,sizeof(cf),"unknown"); break;
+       }
+
+       switch (delay) {
+               case 0: snprintf(cdelay, sizeof(cdelay),"no delay"); break;
+               case 1: snprintf(cdelay, sizeof(cdelay),"BP/8 or 1/8th bit period delay"); break;
+               case 2: snprintf(cdelay, sizeof(cdelay),"BP/4 or 1/4th bit period delay"); break;
+               case 3: snprintf(cdelay, sizeof(cdelay),"no delay"); break;
+       }
+       PrintAndLog("ConfigWord: %08X (Word 4)\n", wordData);
+       PrintAndLog("Config Breakdown:", wordData);
+       PrintAndLog(" Data Rate:  %02u | RF/%u", wordData & 0x3F, datarate);
+       PrintAndLog("   Encoder:   %u | %s", encoder, enc);
+       PrintAndLog("    PSK CF:   %u | %s", PSKcf, cf);
+       PrintAndLog("     Delay:   %u | %s", delay, cdelay);
+       PrintAndLog(" LastWordR:  %02u | Address of last word for default read", LWR);
+       PrintAndLog(" ReadLogin:   %u | Read Login is %s", (wordData & 0x40000)>>18, (wordData & 0x40000) ? "Required" : "Not Required");       
+       PrintAndLog("   ReadHKL:   %u | Read Housekeeping Words Login is %s", (wordData & 0x80000)>>19, (wordData & 0x80000) ? "Required" : "Not Required");    
+       PrintAndLog("WriteLogin:   %u | Write Login is %s", (wordData & 0x100000)>>20, (wordData & 0x100000) ? "Required" : "Not Required");    
+       PrintAndLog("  WriteHKL:   %u | Write Housekeeping Words Login is %s", (wordData & 0x200000)>>21, (wordData & 0x200000) ? "Required" : "Not Required"); 
+       PrintAndLog("    R.A.W.:   %u | Read After Write is %s", (wordData & 0x400000)>>22, (wordData & 0x400000) ? "On" : "Off");
+       PrintAndLog("   Disable:   %u | Disable Command is %s", (wordData & 0x800000)>>23, (wordData & 0x800000) ? "Accepted" : "Not Accepted");
+       PrintAndLog("    R.T.F.:   %u | Reader Talk First is %s", (wordData & 0x1000000)>>24, (wordData & 0x1000000) ? "Enabled" : "Disabled");
+       PrintAndLog("    Pigeon:   %u | Pigeon Mode is %s\n", (wordData & 0x4000000)>>26, (wordData & 0x4000000) ? "Enabled" : "Disabled");
+}
+
+void printEM4x05info(uint8_t chipType, uint8_t cap, uint16_t custCode, uint32_t serial) {
+       switch (chipType) {
+               case 9: PrintAndLog("\n Chip Type:   %u | EM4305", chipType); break;
+               case 4: PrintAndLog(" Chip Type:   %u | Unknown", chipType); break;
+               case 2: PrintAndLog(" Chip Type:   %u | EM4469", chipType); break;
+               //add more here when known
+               default: PrintAndLog(" Chip Type:   %u Unknown", chipType); break;
+       }
+
+       switch (cap) {
+               case 3: PrintAndLog("  Cap Type:   %u | 330pF",cap); break;
+               case 2: PrintAndLog("  Cap Type:   %u | %spF",cap, (chipType==2)? "75":"210"); break;
+               case 1: PrintAndLog("  Cap Type:   %u | 250pF",cap); break;
+               case 0: PrintAndLog("  Cap Type:   %u | no resonant capacitor",cap); break;
+               default: PrintAndLog("  Cap Type:   %u | unknown",cap); break;
+       }
+
+       PrintAndLog(" Cust Code: %03u | %s", custCode, (custCode == 0x200) ? "Default": "Unknown");
+       if (serial != 0) {
+               PrintAndLog("\n  Serial #: %08X\n", serial);
+       }
+}
+
+void printEM4x05ProtectionBits(uint32_t wordData) {
+       for (uint8_t i = 0; i < 15; i++) {
+               PrintAndLog("      Word:  %02u | %s", i, (((1 << i) & wordData ) || i < 2) ? "Is Write Locked" : "Is Not Write Locked");
+               if (i==14) {
+                       PrintAndLog("      Word:  %02u | %s", i+1, (((1 << i) & wordData ) || i < 2) ? "Is Write Locked" : "Is Not Write Locked");
+               }
+       }
+}
+
+//quick test for EM4x05/EM4x69 tag
+bool EM4x05Block0Test(uint32_t *wordData) {
+       if (EM4x05ReadWord_ext(0,0,false,wordData) == 1) {
+               return true;
+       }
+       return false;
+}
+
+int CmdEM4x05info(const char *Cmd) {
+       //uint8_t addr = 0;
+       uint32_t pwd;
+       uint32_t wordData = 0;
+       bool usePwd = false;
+       uint8_t ctmp = param_getchar(Cmd, 0);
+       if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em_dump();
+
+       // for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
+       pwd = param_get32ex(Cmd, 0, 1, 16);
+       
+       if ( pwd != 1 ) {
+               usePwd = true;
+       }
+
+       // read word 0 (chip info)
+       // block 0 can be read even without a password.
+       if ( !EM4x05Block0Test(&wordData) ) 
+               return -1;
+       
+       uint8_t chipType = (wordData >> 1) & 0xF;
+       uint8_t cap = (wordData >> 5) & 3;
+       uint16_t custCode = (wordData >> 9) & 0x3FF;
+       
+       // read word 1 (serial #) doesn't need pwd
+       wordData = 0;
+       if (EM4x05ReadWord_ext(1, 0, false, &wordData) != 1) {
+               //failed, but continue anyway...
+       }
+       printEM4x05info(chipType, cap, custCode, wordData);
+
+       // read word 4 (config block) 
+       // needs password if one is set
+       wordData = 0;
+       if ( EM4x05ReadWord_ext(4, pwd, usePwd, &wordData) != 1 ) {
+               //failed
+               return 0;
+       }
+       printEM4x05config(wordData);
+
+       // read word 14 and 15 to see which is being used for the protection bits
+       wordData = 0;
+       if ( EM4x05ReadWord_ext(14, pwd, usePwd, &wordData) != 1 ) {
+               //failed
+               return 0;
+       }
+       // if status bit says this is not the used protection word
+       if (!(wordData & 0x8000)) {
+               if ( EM4x05ReadWord_ext(15, pwd, usePwd, &wordData) != 1 ) {
+                       //failed
+                       return 0;
+               }
+       }
+       if (!(wordData & 0x8000)) {
+               //something went wrong
+               return 0;
+       }
+       printEM4x05ProtectionBits(wordData);
+
+       return 1;
+}
+
+
 static command_t CommandTable[] =
 {
        {"help", CmdHelp, 1, "This help"},
@@ -848,9 +995,10 @@ static command_t CommandTable[] =
        {"410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
        {"410xspoof", CmdEM410xWatchnSpoof, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
        {"410xwrite", CmdEM410xWrite, 0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
-       {"4x05dump", CmdEM4x05dump, 1, "(pwd) -- Read EM4x05/EM4x69 all word data"},
-       {"4x05readword", CmdEM4x05ReadWord, 1, "<Word> (pwd) -- Read EM4x05/EM4x69 word data"},
-       {"4x05writeword", CmdEM4x05WriteWord, 1, "<Word> <data> (pwd) -- Write EM4x05/EM4x69 word data"},
+       {"4x05dump", CmdEM4x05dump, 0, "(pwd) -- Read EM4x05/EM4x69 all word data"},
+       {"4x05info", CmdEM4x05info, 0, "(pwd) -- Get info from EM4x05/EM4x69 tag"},
+       {"4x05readword", CmdEM4x05ReadWord, 0, "<Word> (pwd) -- Read EM4x05/EM4x69 word data"},
+       {"4x05writeword", CmdEM4x05WriteWord, 0, "<Word> <data> (pwd) -- Write EM4x05/EM4x69 word data"},
        {"4x50read", CmdEM4x50Read, 1, "demod data from EM4x50 tag from the graph buffer"},
        {NULL, NULL, 0, NULL}
 };
Impressum, Datenschutz