]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhflegic.c
ADD: "hf legic eload" - Load binary file to emulator memory. Use "h" for help text
[proxmark3-svn] / client / cmdhflegic.c
index ea75e15f9e43d0b55052a5856e383c4983274dd4..d544a91cca73d5ca9060075b7705b952fb0cf358 100644 (file)
@@ -39,18 +39,19 @@ int usage_legic_load(void){
        PrintAndLog("      hf legic load filename");
        return 0;
 }
-int usage_legic_read(void){    
+int usage_legic_rdmem(void){   
        PrintAndLog("Read data from a legic tag.");
-       PrintAndLog("Usage:  hf legic read [h] <offset> <length> <IV>");
+       PrintAndLog("Usage:  hf legic rdmem [h] <offset> <length> <IV>");
        PrintAndLog("Options:");
        PrintAndLog("  h             : this help");
-       PrintAndLog("  <offset>      : offset in data array to start download from");
-       PrintAndLog("  <length>      : number of bytes to download");
-       PrintAndLog("  <IV>          : (optional) Initialization vector to use (ODD and 7bits)");
+       PrintAndLog("  <offset>      : offset in data array to start download from (hex)");
+       PrintAndLog("  <length>      : number of bytes to read (hex)");
+       PrintAndLog("  <IV>          : (optional) Initialization vector to use (hex, odd and 7bits)");
        PrintAndLog("");
        PrintAndLog("Samples:");
-       PrintAndLog("      hf legic read");
-       PrintAndLog("      hf legic read 10 4");
+       PrintAndLog("      hf legic rdmem 0 21        - reads from byte[0] 21 bytes(system header)");
+       PrintAndLog("      hf legic rdmem 0 4 55      - reads from byte[0] 4 bytes with IV 0x55");
+       PrintAndLog("      hf legic rdmem 0 100 55    - reads 256bytes with IV 0x55");
        return 0;
 }
 int usage_legic_sim(void){
@@ -62,35 +63,40 @@ int usage_legic_write(void){
        PrintAndLog("Usage:  hf legic write [h] <offset> <length> <IV>");
        PrintAndLog("Options:");
        PrintAndLog("  h             : this help");
-       PrintAndLog("  <offset>      : offset in data array to start writing from");
-       PrintAndLog("  <length>      : number of bytes to write");
+       PrintAndLog("  <offset>      : offset in data array to start writing from (hex)");
+       PrintAndLog("  <length>      : number of bytes to write (hex)");
        PrintAndLog("  <IV>          : (optional) Initialization vector to use (ODD and 7bits)");
        PrintAndLog("");
        PrintAndLog("Samples:");
-       PrintAndLog("      hf legic write");
-       PrintAndLog("      hf legic write 10 4");
+       PrintAndLog("      hf legic write 10 4      - writes 0x4 to byte[0x10]");
        return 0;
 }
 int usage_legic_rawwrite(void){
-       PrintAndLog("Write raw data direct to a specific address on legic tag.");
-       PrintAndLog("Usage:  hf legic writeraw [h] <address> <value> <IV>");
+       PrintAndLog("Write raw data direct to a specific offset on legic tag.");
+       PrintAndLog("Usage:  hf legic writeraw [h] <offset> <value> <IV>");
        PrintAndLog("Options:");
        PrintAndLog("  h             : this help");
-       PrintAndLog("  <address>     : address to write to");
-       PrintAndLog("  <value>       : value to write");
-       PrintAndLog("  <IV>          : (optional) Initialization vector to use (ODD and 7bits)");
+       PrintAndLog("  <offset>      : offset to write to (hex)");
+       PrintAndLog("  <value>       : value (hex)");
+       PrintAndLog("  <IV>          : (optional) Initialization vector to use (hex, odd and 7bits)");
        PrintAndLog("");
        PrintAndLog("Samples:");
-       PrintAndLog("      hf legic writeraw");
-       PrintAndLog("      hf legic writeraw 10 4");
+       PrintAndLog("      hf legic writeraw 10 4    - writes 0x4 to byte[0x10]");
        return 0;
 }
-int usage_legic_fill(void){
-       PrintAndLog("Missing help text.");
+int usage_legic_reader(void){
+       PrintAndLog("Read UID and type information from a legic tag.");
+       PrintAndLog("Usage:  hf legic reader [h]");
+       PrintAndLog("Options:");
+       PrintAndLog("  h             : this help");
+       PrintAndLog("");
+       PrintAndLog("Samples:");
+       PrintAndLog("      hf legic reader");
        return 0;
 }
 int usage_legic_info(void){
-       PrintAndLog("Read info from a legic tag.");
+       PrintAndLog("Reads information from a legic prime tag.");
+       PrintAndLog("Shows systemarea, user areas etc");
        PrintAndLog("Usage:  hf legic info [h]");
        PrintAndLog("Options:");
        PrintAndLog("  h             : this help");
@@ -99,12 +105,63 @@ int usage_legic_info(void){
        PrintAndLog("      hf legic info");
        return 0;
 }
+int usage_legic_dump(void){
+       PrintAndLog("Reads all pages from LEGIC MIM22, MIM256, MIM1024");
+       PrintAndLog("and saves binary dump into the file `filename.bin` or `cardUID.bin`");
+       PrintAndLog("It autodetects card type.\n");     
+       PrintAndLog("Usage:  hf legic dump [h] o <filename w/o .bin>");
+       PrintAndLog("Options:");
+       PrintAndLog("  h             : this help");
+       PrintAndLog("  n <FN>  : filename w/o .bin to save the dump as");       
+       PrintAndLog("");
+       PrintAndLog("Samples:");
+       PrintAndLog("      hf legic dump");
+       PrintAndLog("      hf legic dump o myfile");
+       return 0;
+}
+
+int usage_legic_eload(void){
+       PrintAndLog("It loads binary dump from the file `filename.bin`");
+       PrintAndLog("Usage:  hf legic eload [h] [card memory] <file name w/o `.bin`>");
+       PrintAndLog("Options:");
+       PrintAndLog("  h             : this help");
+       PrintAndLog("  [card memory] : 0 = MIM22");
+       PrintAndLog("                : 1 = MIM256 (default)");
+       PrintAndLog("                : 2 = MIM1024");
+       PrintAndLog("  <filename>    : filename w/o .bin to load");     
+       PrintAndLog("");
+       PrintAndLog("Samples:");
+       PrintAndLog("      hf legic eload filename");
+       PrintAndLog("      hf legic eload 2 filename");
+       return 0;
+}
+int usage_legic_esave(void){
+       PrintAndLog("It saves binary dump into the file `filename.bin` or `cardID.bin`");
+       PrintAndLog(" Usage:  hf legic esave [h] [card memory] [file name w/o `.bin`]");
+       PrintAndLog("Options:");
+       PrintAndLog("  h             : this help");
+       PrintAndLog("  [card memory] : 0 = MIM22");
+       PrintAndLog("                : 1 = MIM256 (default)");
+       PrintAndLog("                : 2 = MIM1024");
+       PrintAndLog("  <filename>    : filename w/o .bin to load");     
+       PrintAndLog("");
+       PrintAndLog("Samples:");        
+       PrintAndLog("      hf legic esave ");
+       PrintAndLog("      hf legic esave 2");
+       PrintAndLog("      hf legic esave 2 filename");
+       return 0;
+}
+
+
 /*
  *  Output BigBuf and deobfuscate LEGIC RF tag data.
  *  This is based on information given in the talk held
  *  by Henryk Ploetz and Karsten Nohl at 26c3
  */
-int CmdLegicDecode(const char *Cmd) {
+int CmdLegicInfo(const char *Cmd) {
+
+       char cmdp = param_getchar(Cmd, 0);
+       if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_info();
 
        int i = 0, k = 0, segmentNum = 0, segment_len = 0, segment_flag = 0;
        int crc = 0, wrp = 0, wrc = 0;
@@ -114,6 +171,8 @@ int CmdLegicDecode(const char *Cmd) {
        int dcf = 0;
        int bIsSegmented = 0;
 
+       CmdLegicRdmem("0 22 55");
+       
        // copy data from device
        GetEMLFromBigBuf(data, sizeof(data), 0);
        if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2000)){
@@ -136,6 +195,7 @@ int CmdLegicDecode(const char *Cmd) {
                (calc_crc == crc) ? "OK":"Fail"
        );
  
+       // MCD = Manufacturer ID (should be list meaning something?)
 
        token_type[0] = 0;
        dcf = ((int)data[6] << 8) | (int)data[5];
@@ -387,13 +447,13 @@ int CmdLegicDecode(const char *Cmd) {
        return 0;
 }
 
-int CmdLegicRFRead(const char *Cmd) {
+int CmdLegicRdmem(const char *Cmd) {
 
        // params:
        // offset in data memory
        // number of bytes to read
        char cmdp = param_getchar(Cmd, 0);
-       if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_read();
+       if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_rdmem();
        
        uint32_t offset = 0, len = 0, IV = 1;
        sscanf(Cmd, "%x %x %x", &offset, &len, &IV);
@@ -401,47 +461,41 @@ int CmdLegicRFRead(const char *Cmd) {
        // OUT-OF-BOUNDS check
        if ( len + offset > MAX_LENGTH ) {
                len = MAX_LENGTH - offset;
-               PrintAndLog("Out-of-bound, shorten len to %d", len);
+               PrintAndLog("Out-of-bound, shorten len to %d (0x%02X)", len, len);
        }
        
-       if ( (IV & 0x7F) != IV ){
-               IV &= 0x7F;
-               PrintAndLog("Truncating IV to 7bits");
-       }
-       
-       if ( (IV & 1) == 0 ){
-               IV |= 0x01;
-               PrintAndLog("LSB of IV must be SET");   
-       }
-
-       //PrintAndLog("Using IV: 0x%02x", IV);
+       legic_chk_iv(&IV);
        
        UsbCommand c = {CMD_READER_LEGIC_RF, {offset, len, IV}};
        clearCommandBuffer();
        SendCommand(&c);
        UsbCommand resp;
-       if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) {
+       if (WaitForResponseTimeout(CMD_ACK, &resp, 3000)) {
                uint8_t isOK = resp.arg[0] & 0xFF;
-               uint16_t len = resp.arg[1] & 0x3FF;
+               uint16_t readlen = resp.arg[1];
                 if ( isOK ) {
 
-                       uint8_t *data = malloc(len);
+                       uint8_t *data = malloc(readlen);
                        if ( !data ){
                                PrintAndLog("Cannot allocate memory");
                                return 2;
                        }
+                       
+                       if ( readlen != len )
+                               PrintAndLog("Fail, only managed to read 0x%02X bytes", readlen);
+                       
                        // copy data from device
-                       GetEMLFromBigBuf(data, len, 0);
-                       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2000)){
+                       GetEMLFromBigBuf(data, readlen, 0);
+                       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)){
                                PrintAndLog("Command execute timeout");
                                if ( data ) 
                                        free(data);
                                return 1;
                        }
        
-                       PrintAndLog("\nData");
-                       PrintAndLog("-----------------------------");
-                       print_hex_break( data, len, 32);
+                       PrintAndLog("\n ##  | Data");
+                       PrintAndLog("-----+-----");
+                       print_hex_break( data, readlen, 32);
                 } else {
                         PrintAndLog("failed reading tag");
                 }
@@ -452,6 +506,8 @@ int CmdLegicRFRead(const char *Cmd) {
        return 0;
 }
 
+// load, filename  (ascii hex textfile)
+// uploads it to device mem
 int CmdLegicLoad(const char *Cmd) {
 
 // iceman: potential bug, where all filepaths or filename which starts with H or h will print the helptext :)  
@@ -531,6 +587,9 @@ int CmdLegicLoad(const char *Cmd) {
     return 0;
 }
 
+// Save,  filename, num of bytes, starting offset. (in decimal)
+//  ie:  "hf legic save nnn.txt 100 0  (saves the first 100bytes)
+// (ascii hex textfile)
 int CmdLegicSave(const char *Cmd) {
        int requested = 1024;
        int offset = 0;
@@ -584,6 +643,8 @@ int CmdLegicSave(const char *Cmd) {
 }
 
 //TODO: write a help text (iceman)
+// should say which tagtype
+// should load a tag to device mem.
 int CmdLegicRfSim(const char *Cmd) {
        UsbCommand c = {CMD_SIMULATE_TAG_LEGIC_RF, {6,3,0}};
        sscanf(Cmd, " %"lli" %"lli" %"lli, &c.arg[0], &c.arg[1], &c.arg[2]);
@@ -594,11 +655,9 @@ int CmdLegicRfSim(const char *Cmd) {
 
 int CmdLegicRfWrite(const char *Cmd) {
 
-       // params:
        // offset - in tag memory
        // length - num of bytes to be written
-       // IV - initialisation vector
-       
+
        char cmdp = param_getchar(Cmd, 0);
        if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_write();
        
@@ -609,31 +668,32 @@ int CmdLegicRfWrite(const char *Cmd) {
                PrintAndLog("Please specify the offset and length as two hex strings and, optionally, the IV also as an hex string");
         return -1;
     }
+       
+       // tagtype
+       legic_card_select_t card;
+       if (legic_get_type(&card)) {
+               PrintAndLog("Failed to identify tagtype");
+               return -1;
+       }
 
+       legic_print_type(card.cardsize, 0);
+       
        // OUT-OF-BOUNDS check
-       if ( len + offset > MAX_LENGTH ) {
-               len = MAX_LENGTH - offset;
-               PrintAndLog("Out-of-bound, shorten len to %d", len);
-       }
-       if ( (IV & 0x7F) != IV ){
-               IV &= 0x7F;
-               PrintAndLog("Truncating IV to 7bits");
-       }
-       if ( (IV & 1) == 0 ){
-               IV |= 0x01;  // IV must be odd
-               PrintAndLog("LSB of IV must be SET");   
+       if ( len + offset > card.cardsize ) {
+               PrintAndLog("Out-of-bounds, Cardsize = %d, [offset+len = %d ]", card.cardsize, len + offset);
+               return -2;
        }
        
+       legic_chk_iv(&IV);
+       
     UsbCommand c = {CMD_WRITER_LEGIC_RF, {offset, len, IV}};   
        clearCommandBuffer();
     SendCommand(&c);
        UsbCommand resp;
        if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) {
                uint8_t isOK = resp.arg[0] & 0xFF;
-                if ( isOK ) {
-                } else {
-                        PrintAndLog("failed writig tag");
-                }
+                if ( !isOK )
+                        PrintAndLog("failed writing tag");
        } else {
                PrintAndLog("command execution time out");
                return 1;
@@ -647,17 +707,18 @@ int CmdLegicRfRawWrite(const char *Cmd) {
        char cmdp = param_getchar(Cmd, 0);
        if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_rawwrite();
        
-       uint32_t address = 0, data = 0, IV = 0; 
+       uint32_t offset = 0, data = 0, IV = 0;  
        char answer;
 
-    UsbCommand c = { CMD_RAW_WRITER_LEGIC_RF, {0,0,0} };
-    int res = sscanf(Cmd, "%x %x %x", &address, &data, &IV);
+    int res = sscanf(Cmd, "%x %x %x", &offset, &data, &IV);
        if(res < 2)
                return usage_legic_rawwrite();
-
+       
        // OUT-OF-BOUNDS check
-       if(address > MAX_LENGTH)
-               return usage_legic_rawwrite();
+       if ( offset > MAX_LENGTH ) {
+               PrintAndLog("Out-of-bound, offset");
+               return 1;
+       }
        
        if ( (IV & 0x7F) != IV ){
                IV &= 0x7F;
@@ -667,11 +728,8 @@ int CmdLegicRfRawWrite(const char *Cmd) {
                IV |= 0x01;  // IV must be odd
                PrintAndLog("LSB of IV must be SET");   
        }
-       PrintAndLog("Current IV: 0x%02x", IV);
 
-       c.arg[0] = address;
-       c.arg[1] = data;
-    c.arg[2] = IV;
+       UsbCommand c = { CMD_RAW_WRITER_LEGIC_RF, {offset, data, IV} };
        
        if (c.arg[0] == 0x05 || c.arg[0] == 0x06) {
                PrintAndLog("############# DANGER !! #############");
@@ -690,31 +748,6 @@ int CmdLegicRfRawWrite(const char *Cmd) {
        return 0;
 }
 
-//TODO: write a help text (iceman)
-int CmdLegicRfFill(const char *Cmd) {
-    UsbCommand cmd = {CMD_WRITER_LEGIC_RF, {0,0,0} };
-    int res = sscanf(Cmd, " 0x%"llx" 0x%"llx" 0x%"llx, &cmd.arg[0], &cmd.arg[1], &cmd.arg[2]);
-    if(res != 3) {
-        PrintAndLog("Please specify the offset, length and value as two hex strings");
-        return -1;
-    }
-
-    int i;
-    UsbCommand c = {CMD_DOWNLOADED_SIM_SAMPLES_125K, {0, 0, 0}};
-       memset(c.d.asBytes, cmd.arg[2], 48);
-
-       for(i = 0; i < 22; i++) {
-               c.arg[0] = i*48;
-               
-               clearCommandBuffer();
-               SendCommand(&c);
-               WaitForResponse(CMD_ACK, NULL);
-       }
-       clearCommandBuffer();
-    SendCommand(&cmd);
-    return 0;
- }
-
 void static calc4(uint8_t *cmd, uint8_t len){
        crc_t crc;
        //crc_init_ref(&crc, 4, 0x19 >> 1, 0x5, 0, TRUE, TRUE);
@@ -834,59 +867,328 @@ int CmdLegicCalcCrc8(const char *Cmd){
        if (data) free(data);
        return 0;
 } 
-int HFLegicInfo(const char *Cmd, bool verbose) {
 
-       char cmdp = param_getchar(Cmd, 0);
-       if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_info();
-       
+int legic_print_type(uint32_t tagtype, uint8_t spaces){
+       char spc[11] = "          ";
+       spc[10]=0x00;
+       char *spacer = spc + (10-spaces);
+
+       if ( tagtype == 22 )    
+               PrintAndLog("%sTYPE : MIM%d card (outdated)", spacer, tagtype);
+       else if ( tagtype == 256 )
+               PrintAndLog("%sTYPE : MIM%d card (234 bytes)", spacer, tagtype);
+       else if ( tagtype == 1024 )
+               PrintAndLog("%sTYPE : MIM%d card (1002 bytes)", spacer, tagtype);
+       else
+               PrintAndLog("%sTYPE : Unknown %06x", spacer, tagtype);
+       return 0;
+}
+int legic_get_type(legic_card_select_t *card){
+
+       if ( card == NULL ) return 1;
+
        UsbCommand c = {CMD_LEGIC_INFO, {0,0,0}};
        clearCommandBuffer();
     SendCommand(&c);
        UsbCommand resp;
-       if (!WaitForResponseTimeout(CMD_ACK, &resp, 500)) {
-               if ( verbose ) PrintAndLog("command execution time out");
-               return 1;
-       }
+       if (!WaitForResponseTimeout(CMD_ACK, &resp, 500))
+               return 2;
        
        uint8_t isOK = resp.arg[0] & 0xFF;
-       if ( !isOK ) {
-               if ( verbose ) PrintAndLog("legic card select failed");
-               return 1;
+       if ( !isOK ) 
+               return 3;
+       
+       memcpy(card, (legic_card_select_t *)resp.d.asBytes, sizeof(legic_card_select_t));
+       return 0;
+}
+void legic_chk_iv(uint32_t *iv){
+       if ( (*iv & 0x7F) != *iv ){
+               *iv &= 0x7F;
+               PrintAndLog("Truncating IV to 7bits, %u", *iv);
+       }
+       // IV must be odd
+       if ( (*iv & 1) == 0 ){
+               *iv |= 0x01;  
+               PrintAndLog("LSB of IV must be SET %u", *iv);   
        }
+}
+
+void legic_seteml(uint8_t *src, uint32_t offset, uint32_t numofbytes) {
+
+       size_t len = 0;
+       UsbCommand c = {CMD_LEGIC_ESET, {0, 0, 0}};     
+
+       for(size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
+               
+               len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);         
+               c.arg[0] = i; // offset
+               c.arg[1] = len; // number of bytes
+               memcpy(c.d.asBytes, src, len); 
+               clearCommandBuffer();
+               SendCommand(&c);
+               PrintAndLog("ICE: offset %d | len %d", i, len);
+       }
+}
+
+int HFLegicReader(const char *Cmd, bool verbose) {
+
+       char cmdp = param_getchar(Cmd, 0);
+       if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_reader();
        
        legic_card_select_t card;
-       memcpy(&card, (legic_card_select_t *)resp.d.asBytes, sizeof(legic_card_select_t));
-
-       PrintAndLog("  UID : %s", sprint_hex(card.uid, sizeof(card.uid)));
-       switch(card.cardsize) {
-               case 22:
-               case 256: 
-               case 1024:
-                       PrintAndLog(" TYPE : MIM%d card (%d bytes)", card.cardsize, card.cardsize); break;                              
-               default: {
-                       PrintAndLog("Unknown card format: %d", card.cardsize); 
+       switch(legic_get_type(&card)){
+               case 1: 
+                       if ( verbose ) PrintAndLog("command execution time out"); 
                        return 1;
+               case 2: 
+               case 3: 
+                       if ( verbose ) PrintAndLog("legic card select failed");
+                       return 2;
+               default: break;
+       }
+       PrintAndLog(" UID : %s", sprint_hex(card.uid, sizeof(card.uid)));
+       legic_print_type(card.cardsize, 0);
+       return 0;
+}
+int CmdLegicReader(const char *Cmd){
+       return HFLegicReader(Cmd, TRUE);
+}
+
+int CmdLegicDump(const char *Cmd){
+
+       FILE *f;
+       char filename[FILE_PATH_SIZE] = {0x00};
+       char *fnameptr = filename;
+       size_t fileNlen = 0;
+       bool errors = false;
+       uint16_t dumplen;       
+       uint8_t cmdp = 0;
+       
+       memset(filename, 0, sizeof(filename));
+       
+       while(param_getchar(Cmd, cmdp) != 0x00) {
+               switch(param_getchar(Cmd, cmdp)) {
+                       case 'h':
+                       case 'H':
+                               return usage_legic_dump();
+                       case 'o':
+                       case 'O':
+                               fileNlen = param_getstr(Cmd, cmdp+1, filename);
+                               if (!fileNlen) 
+                                       errors = true; 
+                               if (fileNlen > FILE_PATH_SIZE-5) 
+                                       fileNlen = FILE_PATH_SIZE-5;
+                               cmdp += 2;
+                               break;
+                       default:
+                               PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
+                               errors = true;
+                               break;
                }
+               if(errors) break;
+       }
+
+       //Validations
+       if(errors) return usage_legic_dump();
+       
+       // tagtype
+       legic_card_select_t card;
+       if (legic_get_type(&card)) {
+               PrintAndLog("Failed to identify tagtype");
+               return -1;
+       }
+       dumplen = card.cardsize;
+       
+       legic_print_type(dumplen, 0);   
+       PrintAndLog("Reading tag memory...");
+
+       UsbCommand c = {CMD_READER_LEGIC_RF, {0x00, dumplen, 0x55}};
+       clearCommandBuffer();
+       SendCommand(&c);
+       UsbCommand resp;
+       if (!WaitForResponseTimeout(CMD_ACK, &resp, 3000)) {
+               PrintAndLog("Command execute time-out");
+               return 1;
+       }
+               
+       uint8_t isOK = resp.arg[0] & 0xFF;
+       if ( !isOK ) {
+               PrintAndLog("Failed dumping tag data");
+               return 2;
+       }
+
+       uint16_t readlen = resp.arg[1];
+       uint8_t *data = malloc(readlen);
+       if (!data) {
+               PrintAndLog("Fail, cannot allocate memory");
+               return 3;
+       }
+       
+       if ( readlen != dumplen )
+               PrintAndLog("Fail, only managed to read 0x%02X bytes of 0x%02X", readlen, dumplen);
+
+       // copy data from device
+       GetEMLFromBigBuf(data, readlen, 0);
+       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)) {
+               PrintAndLog("Fail, transfer from device time-out");
+               free(data);
+               return 4;
+       }
+
+       // user supplied filename?
+       if (fileNlen < 1)
+               sprintf(fnameptr,"%02X%02X%02X%02X.bin", data[0], data[1], data[2], data[3]);
+       else
+               sprintf(fnameptr + fileNlen,".bin");
+
+       if ((f = fopen(filename,"wb")) == NULL) { 
+               PrintAndLog("Could not create file name %s", filename);
+               if (data)
+                       free(data);
+               return 5;
+       }
+       fwrite(data, 1, readlen, f);
+       fclose(f);
+       free(data);
+       PrintAndLog("Wrote %d bytes to %s", readlen, filename);
+       return 0;
+}      
+
+int CmdLegicELoad(const char *Cmd) {
+       FILE * f;
+       char filename[FILE_PATH_SIZE];
+       char *fnameptr = filename;
+       int len, numofbytes;
+       int nameParamNo = 1;
+       
+       char cmdp = param_getchar(Cmd, 0);              
+       if ( cmdp == 'h' || cmdp == 'H' || cmdp == 0x00)
+               return usage_legic_eload();
+
+       switch (cmdp) {
+               case '0' : numofbytes = 22; break;
+               case '1' : 
+               case '\0': numofbytes = 256; break;
+               case '2' : numofbytes = 1024; break;
+               default  : numofbytes = 256;  nameParamNo = 0;break;
+       }
+
+       // set up buffer
+       uint8_t *data = malloc(numofbytes);
+       if (!data) {
+               PrintAndLog("Fail, cannot allocate memory");
+               return 3;               
+       }
+       memset(data, 0, numofbytes);
+       
+       // set up file
+       len = param_getstr(Cmd, nameParamNo, filename);
+       if (len > FILE_PATH_SIZE - 5) 
+               len = FILE_PATH_SIZE - 5;
+       fnameptr += len;
+       sprintf(fnameptr, ".bin");      
+       
+       // open file
+       if ((f = fopen(filename,"rb")) == NULL) { 
+               PrintAndLog("File %s not found or locked", filename);
+               free(data);
+               return 1;
        }
+
+       // load file
+       size_t bytes_read = fread(data, 1, numofbytes, f);
+       if ( bytes_read == 0){
+               PrintAndLog("File reading error");
+               free(data);
+               fclose(f);
+               return 2;
+       }
+       fclose(f);
+       
+       // transfer to device
+       legic_seteml(data, 0, numofbytes);
+               
+       free(data);     
+       PrintAndLog("\nLoaded %d bytes from file: %s  to emulator memory", numofbytes, filename);
        return 0;
 }
-int CmdLegicInfo(const char *Cmd){
-       return HFLegicInfo(Cmd, TRUE);
+
+int CmdLegicESave(const char *Cmd) {
+       FILE *f;
+       char filename[FILE_PATH_SIZE];
+       char *fnameptr = filename;
+       int fileNlen, numofbytes, nameParamNo = 1;
+       
+       memset(filename, 0, sizeof(filename));
+
+       char cmdp = param_getchar(Cmd, 0);
+       
+       if ( cmdp == 'h' || cmdp == 'H' || cmdp == 0x00)
+               return usage_legic_esave();
+
+       switch (cmdp) {
+               case '0' : numofbytes = 22; break;
+               case '1' : 
+               case '\0': numofbytes = 256; break;
+               case '2' : numofbytes = 1024; break;
+               default  : numofbytes = 256; nameParamNo = 0; break;
+       }
+
+       fileNlen = param_getstr(Cmd, nameParamNo, filename);
+       
+       if (fileNlen > FILE_PATH_SIZE - 5) 
+               fileNlen = FILE_PATH_SIZE - 5;
+
+       // set up buffer
+       uint8_t *data = malloc(numofbytes);
+       if (!data) {
+               PrintAndLog("Fail, cannot allocate memory");
+               return 3;               
+       }
+       memset(data, 0, numofbytes);
+               
+       // download emulator memory
+       PrintAndLog("Reading emulator memory...");
+       
+       GetEMLFromBigBuf(data, numofbytes, 0);
+       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)) {
+               PrintAndLog("Fail, transfer from device time-out");
+               free(data);
+               return 4;
+       }
+
+       // user supplied filename?
+       if (fileNlen < 1)               
+               sprintf(fnameptr,"%02X%02X%02X%02X.bin", data[0], data[1], data[2], data[3]);
+       else
+               sprintf(fnameptr + fileNlen,".bin");
+       
+       // open file
+       if ((f = fopen(filename,"wb")) == NULL) { 
+               PrintAndLog("Could not create file name %s", filename);
+               free(data);
+               return 1;
+       }
+       fwrite(data, 1, numofbytes, f);
+       fclose(f);
+       free(data);
+       PrintAndLog("\nSaved %d bytes from emulator memory to file: %s", numofbytes, filename);
+       return 0;
 }
        
 static command_t CommandTable[] =  {
-       {"help",        CmdHelp,        1, "This help"},
-       {"decode",      CmdLegicDecode, 0, "Display deobfuscated and decoded LEGIC RF tag data (use after hf legic reader)"},
-       {"read",        CmdLegicRFRead, 0, "[offset][length] <iv> -- read bytes from a LEGIC card"},
-       {"save",        CmdLegicSave,   0, "<filename> [<length>] -- Store samples"},
-       {"load",        CmdLegicLoad,   0, "<filename> -- Restore samples"},
-       {"sim",         CmdLegicRfSim,  0, "[phase drift [frame drift [req/resp drift]]] Start tag simulator (use after load or read)"},
-       {"write",       CmdLegicRfWrite,0, "<offset> <length> <iv> -- Write sample buffer (user after load or read)"},
-       {"writeraw",CmdLegicRfRawWrite, 0, "<address> <value> <iv> -- Write direct to address"},
-       {"fill",        CmdLegicRfFill, 0, "<offset> <length> <value> -- Fill/Write tag with constant value"},
-       {"crc8",        CmdLegicCalcCrc8, 1, "Calculate Legic CRC8 over given hexbytes"},
-       {"info",        CmdLegicInfo, 1, "Information"},
+       {"help",        CmdHelp,                        1, "This help"},
+       {"reader",      CmdLegicReader,         1, "LEGIC Prime Reader UID and Type tag info"},
+       {"info",        CmdLegicInfo,           0, "Display deobfuscated and decoded LEGIC Prime tag data"},
+       {"dump",        CmdLegicDump,           0, "Dump LEGIC Prime card to binary file"},
+       {"rdmem",       CmdLegicRdmem,          0, "[offset][length] <iv> -- read bytes from a LEGIC card"},
+       {"save",        CmdLegicSave,           0, "<filename> [<length>] -- Store samples"},
+       {"load",        CmdLegicLoad,           0, "<filename> -- Restore samples"},
+       {"sim",         CmdLegicRfSim,          0, "[phase drift [frame drift [req/resp drift]]] Start tag simulator (use after load or read)"},
+       {"write",       CmdLegicRfWrite,        0, "<offset> <length> <iv> -- Write sample buffer (user after load or read)"},
+       {"crc8",        CmdLegicCalcCrc8,       1, "Calculate Legic CRC8 over given hexbytes"}, 
+       {"eload",       CmdLegicELoad,          1, "Load binary dump to emulator memory"},
+       {"esave",       CmdLegicESave,          1, "Save emulator memory to binary file"},
        {NULL, NULL, 0, NULL}
 };
 
Impressum, Datenschutz