]> cvs.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhflegic.c
CHG: syntax suger
[proxmark3-svn] / client / cmdhflegic.c
index b2c6a3dfebf83619b8139da3859fceaa48d6f3e9..3ee6c5d5d401a401fc70e83b1daa401e13c48a75 100644 (file)
@@ -13,10 +13,10 @@ static int CmdHelp(const char *Cmd);
 
 #define MAX_LENGTH 1024        
 
 
 #define MAX_LENGTH 1024        
 
-int usage_legic_calccrc8(void){
+int usage_legic_calccrc(void){
        PrintAndLog("Calculates the legic crc8/crc16 on the input hexbytes.");
        PrintAndLog("There must be an even number of hexsymbols as input.");
        PrintAndLog("Calculates the legic crc8/crc16 on the input hexbytes.");
        PrintAndLog("There must be an even number of hexsymbols as input.");
-       PrintAndLog("Usage:  hf legic crc8 [h] b <hexbytes> u <uidcrc> c <crc type>");
+       PrintAndLog("Usage:  hf legic crc [h] b <hexbytes> u <uidcrc> c <crc type>");
        PrintAndLog("Options:");
        PrintAndLog("      h             : this help");
        PrintAndLog("      b <hexbytes>  : hex bytes");
        PrintAndLog("Options:");
        PrintAndLog("      h             : this help");
        PrintAndLog("      b <hexbytes>  : hex bytes");
@@ -24,8 +24,8 @@ int usage_legic_calccrc8(void){
        PrintAndLog("      c <crc type>  : 8|16 bit crc size");
        PrintAndLog("");
        PrintAndLog("Samples:");
        PrintAndLog("      c <crc type>  : 8|16 bit crc size");
        PrintAndLog("");
        PrintAndLog("Samples:");
-       PrintAndLog("      hf legic crc8 b deadbeef1122");
-       PrintAndLog("      hf legic crc8 b deadbeef1122 u 9A c 16");
+       PrintAndLog("      hf legic crc b deadbeef1122");
+       PrintAndLog("      hf legic crc b deadbeef1122 u 9A c 16");
        return 0;
 }
 int usage_legic_load(void){
        return 0;
 }
 int usage_legic_load(void){
@@ -71,23 +71,6 @@ int usage_legic_write(void){
        PrintAndLog("      hf legic write 10 4      - writes 0x4 to byte[0x10]");
        return 0;
 }
        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 offset on legic tag.");
-       PrintAndLog("Usage:  hf legic writeraw [h] <offset> <value> <IV>");
-       PrintAndLog("Options:");
-       PrintAndLog("  h             : this help");
-       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 10 4    - writes 0x4 to byte[0x10]");
-       return 0;
-}
-int usage_legic_fill(void){
-       PrintAndLog("Missing help text.");
-       return 0;
-}
 int usage_legic_reader(void){
        PrintAndLog("Read UID and type information from a legic tag.");
        PrintAndLog("Usage:  hf legic reader [h]");
 int usage_legic_reader(void){
        PrintAndLog("Read UID and type information from a legic tag.");
        PrintAndLog("Usage:  hf legic reader [h]");
@@ -123,6 +106,37 @@ int usage_legic_dump(void){
        PrintAndLog("      hf legic dump o myfile");
        return 0;
 }
        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.
 
 /*
  *  Output BigBuf and deobfuscate LEGIC RF tag data.
@@ -142,7 +156,7 @@ int CmdLegicInfo(const char *Cmd) {
        int dcf = 0;
        int bIsSegmented = 0;
 
        int dcf = 0;
        int bIsSegmented = 0;
 
-       CmdLegicRdmem("0 21 55");
+       CmdLegicRdmem("0 22 55");
        
        // copy data from device
        GetEMLFromBigBuf(data, sizeof(data), 0);
        
        // copy data from device
        GetEMLFromBigBuf(data, sizeof(data), 0);
@@ -166,6 +180,7 @@ int CmdLegicInfo(const char *Cmd) {
                (calc_crc == crc) ? "OK":"Fail"
        );
  
                (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];
 
        token_type[0] = 0;
        dcf = ((int)data[6] << 8) | (int)data[5];
@@ -417,11 +432,11 @@ int CmdLegicInfo(const char *Cmd) {
        return 0;
 }
 
        return 0;
 }
 
+// params:
+// offset in data memory
+// number of bytes to read
 int CmdLegicRdmem(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_rdmem();
        
        char cmdp = param_getchar(Cmd, 0);
        if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_rdmem();
        
@@ -434,56 +449,50 @@ int CmdLegicRdmem(const char *Cmd) {
                PrintAndLog("Out-of-bound, shorten len to %d (0x%02X)", len, 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");   
-       }
+       legic_chk_iv(&IV);
        
        UsbCommand c = {CMD_READER_LEGIC_RF, {offset, len, IV}};
        clearCommandBuffer();
        SendCommand(&c);
        UsbCommand resp;
        
        UsbCommand c = {CMD_READER_LEGIC_RF, {offset, len, IV}};
        clearCommandBuffer();
        SendCommand(&c);
        UsbCommand resp;
-       if (WaitForResponseTimeout(CMD_ACK, &resp, 3000)) {
-               uint8_t isOK = resp.arg[0] & 0xFF;
-               uint16_t readlen = resp.arg[1];
-                if ( isOK ) {
+       if ( !WaitForResponseTimeout(CMD_ACK, &resp, 3000) ) {
+               PrintAndLog("command execution time out");
+               return 1;
+       }
 
 
-                       uint8_t *data = malloc(readlen);
-                       if ( !data ){
-                               PrintAndLog("Cannot allocate memory");
-                               return 2;
-                       }
+       uint8_t isOK = resp.arg[0] & 0xFF;
+       uint16_t readlen = resp.arg[1];
+       if ( !isOK ) {
+               PrintAndLog("failed reading tag");
+               return 2;
+       }
+       
+       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);
+       if ( readlen != len )
+               PrintAndLog("Fail, only managed to read 0x%02X bytes", readlen);
                        
                        
-                       // copy data from device
-                       GetEMLFromBigBuf(data, readlen, 0);
-                       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)){
-                               PrintAndLog("Command execute timeout");
-                               if ( data ) 
-                                       free(data);
-                               return 1;
-                       }
-       
-                       PrintAndLog("\n ##  | Data");
-                       PrintAndLog("-----+-----");
-                       print_hex_break( data, readlen, 32);
-                } else {
-                        PrintAndLog("failed reading tag");
-                }
-       } else {
-               PrintAndLog("command execution time out");
+       // copy data from device
+       GetEMLFromBigBuf(data, readlen, 0);
+       if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)){
+               PrintAndLog("Command execute timeout");
+               free(data);
                return 1;
        }
                return 1;
        }
+       
+       PrintAndLog("\n ##  | Data");
+       PrintAndLog("-----+-----");
+       print_hex_break( data, readlen, 32);
+       free(data);
        return 0;
 }
 
        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 :)  
 int CmdLegicLoad(const char *Cmd) {
 
 // iceman: potential bug, where all filepaths or filename which starts with H or h will print the helptext :)  
@@ -563,6 +572,9 @@ int CmdLegicLoad(const char *Cmd) {
     return 0;
 }
 
     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;
 int CmdLegicSave(const char *Cmd) {
        int requested = 1024;
        int offset = 0;
@@ -616,6 +628,8 @@ int CmdLegicSave(const char *Cmd) {
 }
 
 //TODO: write a help text (iceman)
 }
 
 //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]);
 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]);
@@ -626,11 +640,9 @@ int CmdLegicRfSim(const char *Cmd) {
 
 int CmdLegicRfWrite(const char *Cmd) {
 
 
 int CmdLegicRfWrite(const char *Cmd) {
 
-       // params:
        // offset - in tag memory
        // length - num of bytes to be written
        // 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();
        
        char cmdp = param_getchar(Cmd, 0);
        if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_write();
        
@@ -641,31 +653,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;
     }
                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
        // OUT-OF-BOUNDS check
-       if ( len + offset > MAX_LENGTH ) {
-               len = MAX_LENGTH - offset;
-               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;  // 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;
     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;
        } else {
                PrintAndLog("command execution time out");
                return 1;
@@ -674,109 +687,20 @@ int CmdLegicRfWrite(const char *Cmd) {
     return 0;
 }
 
     return 0;
 }
 
+/*
 int CmdLegicRfRawWrite(const char *Cmd) {
 int CmdLegicRfRawWrite(const char *Cmd) {
-
-       char cmdp = param_getchar(Cmd, 0);
-       if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_rawwrite();
-       
-       uint32_t offset = 0, data = 0, IV = 0;  
-       char answer;
-
-    int res = sscanf(Cmd, "%x %x %x", &offset, &data, &IV);
-       if(res < 2)
-               return usage_legic_rawwrite();
-       
-       // OUT-OF-BOUNDS check
-       if ( offset > MAX_LENGTH ) {
-               PrintAndLog("Out-of-bound, offset");
-               return 1;
-       }
-       
-       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");   
-       }
-
-       UsbCommand c = { CMD_RAW_WRITER_LEGIC_RF, {offset, data, IV} };
-       
-       if (c.arg[0] == 0x05 || c.arg[0] == 0x06) {
-               PrintAndLog("############# DANGER !! #############");
-               PrintAndLog("# changing the DCF is irreversible  #");
-               PrintAndLog("#####################################");
-               PrintAndLog("do youe really want to continue? y(es) n(o)");             
-               if (scanf(" %c", &answer) > 0 && (answer == 'y' || answer == 'Y')) {
-                       SendCommand(&c);
-                       return 0;
-               }
-               return -1;
-       }
-       
-       clearCommandBuffer();
-    SendCommand(&c);
+       PrintAndLog("############# DANGER !! #############");
+       PrintAndLog("# changing the DCF is irreversible  #");
+       PrintAndLog("#####################################");
+       PrintAndLog("do youe really want to continue? y(es) n(o)");             
+       // if (scanf(" %c", &answer) > 0 && (answer == 'y' || answer == 'Y')) {
+               // return 0;
+       // }
        return 0;
 }
        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);
-       crc_init(&crc, 4, 0x19 >> 1, 0x5, 0);
-
-       crc_clear(&crc);
-       crc_update(&crc, 1, 1); /* CMD_READ */
-       crc_update(&crc, cmd[0], 8);
-       crc_update(&crc, cmd[1], 8);
-       printf("crc4 %X\n", reflect(crc_finish(&crc), 4) ) ;
-
-       crc_clear(&crc);
-       crc_update(&crc, 1, 1); /* CMD_READ */
-       crc_update(&crc, cmd[0], 8);
-       crc_update(&crc, cmd[1], 8);
-       printf("crc4 %X\n",  crc_finish(&crc) ) ;
-
-       printf("---- old ---\n");
-       crc_update2(&crc, 1, 1); /* CMD_READ */
-       crc_update2(&crc, cmd[0], 8);
-       crc_update2(&crc, cmd[1], 8);
-       printf("crc4 %X \n", reflect(crc_finish(&crc), 4) ) ;
-
-       
-       crc_clear(&crc);
-       crc_update2(&crc, 1, 1); /* CMD_READ */
-       crc_update2(&crc, cmd[0], 8);
-       crc_update2(&crc, cmd[1], 8);
-       printf("crc4 %X\n",  crc_finish(&crc) ) ;
-}      
-int CmdLegicCalcCrc8(const char *Cmd){
+int CmdLegicCalcCrc(const char *Cmd){
 
        uint8_t *data = NULL;
        uint8_t cmdp = 0, uidcrc = 0, type=0;
 
        uint8_t *data = NULL;
        uint8_t cmdp = 0, uidcrc = 0, type=0;
@@ -846,16 +770,13 @@ int CmdLegicCalcCrc8(const char *Cmd){
        //Validations
        if (errors){
                if (data) free(data);
        //Validations
        if (errors){
                if (data) free(data);
-               return usage_legic_calccrc8();
+               return usage_legic_calccrc();
        }
        
        switch (type){
                case 16:
                        PrintAndLog("Legic crc16: %X", CRC16Legic(data, len, uidcrc));
                        break;
        }
        
        switch (type){
                case 16:
                        PrintAndLog("Legic crc16: %X", CRC16Legic(data, len, uidcrc));
                        break;
-               case 4:
-                       calc4(data, 0);
-                       break;
                default:
                        PrintAndLog("Legic crc8: %X",  CRC8Legic(data, len) );
                        break;
                default:
                        PrintAndLog("Legic crc8: %X",  CRC8Legic(data, len) );
                        break;
@@ -864,41 +785,84 @@ int CmdLegicCalcCrc8(const char *Cmd){
        if (data) free(data);
        return 0;
 } 
        if (data) free(data);
        return 0;
 } 
-int HFLegicReader(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;
        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;
        
        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+i, 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;
        
        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;
                        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 0;
 }
 int CmdLegicReader(const char *Cmd){
@@ -907,33 +871,34 @@ int CmdLegicReader(const char *Cmd){
 
 int CmdLegicDump(const char *Cmd){
 
 
 int CmdLegicDump(const char *Cmd){
 
-       FILE *fout;
+       FILE *f;
        char filename[FILE_PATH_SIZE] = {0x00};
        char *fnameptr = filename;
        size_t fileNlen = 0;
        bool errors = false;
        char filename[FILE_PATH_SIZE] = {0x00};
        char *fnameptr = filename;
        size_t fileNlen = 0;
        bool errors = false;
-       uint16_t dumplen = 0x100;
+       uint16_t dumplen;       
+       uint8_t cmdp = 0;
        
        
-       char cmdp = param_getchar(Cmd, 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;
+       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;
        }
                }
                if(errors) break;
        }
@@ -942,9 +907,16 @@ int CmdLegicDump(const char *Cmd){
        if(errors) return usage_legic_dump();
        
        // tagtype
        if(errors) return usage_legic_dump();
        
        // tagtype
-       //uint32_t tagtype = GetHF14AMfU_Type();
-       //if (tagtype == -1) return -1;
+       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 c = {CMD_READER_LEGIC_RF, {0x00, dumplen, 0x55}};
        clearCommandBuffer();
        SendCommand(&c);
@@ -962,10 +934,11 @@ int CmdLegicDump(const char *Cmd){
 
        uint16_t readlen = resp.arg[1];
        uint8_t *data = malloc(readlen);
 
        uint16_t readlen = resp.arg[1];
        uint8_t *data = malloc(readlen);
-       if ( !data ){
+       if (!data) {
                PrintAndLog("Fail, cannot allocate memory");
                return 3;
        }
                PrintAndLog("Fail, cannot allocate memory");
                return 3;
        }
+       memset(data, 0, readlen);
        
        if ( readlen != dumplen )
                PrintAndLog("Fail, only managed to read 0x%02X bytes of 0x%02X", readlen, dumplen);
        
        if ( readlen != dumplen )
                PrintAndLog("Fail, only managed to read 0x%02X bytes of 0x%02X", readlen, dumplen);
@@ -974,7 +947,7 @@ int CmdLegicDump(const char *Cmd){
        GetEMLFromBigBuf(data, readlen, 0);
        if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)) {
                PrintAndLog("Fail, transfer from device time-out");
        GetEMLFromBigBuf(data, readlen, 0);
        if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)) {
                PrintAndLog("Fail, transfer from device time-out");
-               if ( data ) free(data);
+               free(data);
                return 4;
        }
 
                return 4;
        }
 
@@ -984,18 +957,139 @@ int CmdLegicDump(const char *Cmd){
        else
                sprintf(fnameptr + fileNlen,".bin");
 
        else
                sprintf(fnameptr + fileNlen,".bin");
 
-       if ((fout = fopen(filename,"wb")) == NULL) { 
+       if ((f = fopen(filename,"wb")) == NULL) { 
                PrintAndLog("Could not create file name %s", filename);
                PrintAndLog("Could not create file name %s", filename);
-               if ( data ) free(data);
+               if (data)
+                       free(data);
                return 5;
        }
                return 5;
        }
-       fwrite( data, 1, readlen, fout );
-       fclose(fout);
-       if ( data ) free(data);
-       
+       fwrite(data, 1, readlen, f);
+       fclose(f);
+       free(data);
        PrintAndLog("Wrote %d bytes to %s", readlen, filename);
        return 0;
 }      
        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 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"},
        
 static command_t CommandTable[] =  {
        {"help",        CmdHelp,                        1, "This help"},
@@ -1007,9 +1101,9 @@ static command_t CommandTable[] =  {
        {"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)"},
        {"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"},
+       {"crc",         CmdLegicCalcCrc,        1, "Calculate Legic CRC 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}
 };
 
        {NULL, NULL, 0, NULL}
 };
 
Impressum, Datenschutz