CHG: A repaint the plot window should be done to make sure its visual.

[proxmark3-svn] / client / cmdhflegic.c

diff --git a/client/cmdhflegic.c b/client/cmdhflegic.c
index 47dabeb1597cfb47e11178690ba3930628887aa0..be9018f6629be5f23f76e793e55d87913fb7b793 100644 (file)
--- a/client/cmdhflegic.c
+++ b/client/cmdhflegic.c
@@ -11,11 +11,15 @@
 
 static int CmdHelp(const char *Cmd);
 
 
 static int CmdHelp(const char *Cmd);
 

+#define SESSION_IV 0x55
+#define MAX_LENGTH 1024        
+

 int usage_legic_calccrc8(void){
        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("Options:");
 int usage_legic_calccrc8(void){
        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("Options:");

+       PrintAndLog("      h             : this help");

        PrintAndLog("      b <hexbytes>  : hex bytes");
        PrintAndLog("      u <uidcrc>    : MCC hexbyte");
        PrintAndLog("      c <crc type>  : 8|16 bit crc size");
        PrintAndLog("      b <hexbytes>  : hex bytes");
        PrintAndLog("      u <uidcrc>    : MCC hexbyte");
        PrintAndLog("      c <crc type>  : 8|16 bit crc size");


@@ -25,35 +29,65 @@ int usage_legic_calccrc8(void){
        PrintAndLog("      hf legic crc8 b deadbeef1122 u 9A c 16");
        return 0;
 }
        PrintAndLog("      hf legic crc8 b deadbeef1122 u 9A c 16");
        return 0;
 }

-

 int usage_legic_load(void){
        PrintAndLog("It loads datasamples from the file `filename` to device memory");
 int usage_legic_load(void){
        PrintAndLog("It loads datasamples from the file `filename` to device memory");

-       PrintAndLog("Usage:  hf legic load <file name>");
+       PrintAndLog("Usage:  hf legic load [h] <file name>");
+       PrintAndLog("Options:");
+       PrintAndLog("  h             : this help");
+       PrintAndLog("  <filename>    : Name of file to load");

        PrintAndLog("");
        PrintAndLog("Samples:");
        PrintAndLog("      hf legic load filename");
        return 0;
 }
        PrintAndLog("");
        PrintAndLog("Samples:");
        PrintAndLog("      hf legic load filename");
        return 0;
 }

-

 int usage_legic_read(void){    
        PrintAndLog("Read data from a legic tag.");
 int usage_legic_read(void){    
        PrintAndLog("Read data from a legic tag.");

-       PrintAndLog("Usage:  hf legic read <offset> <num of bytes>");
+       PrintAndLog("Usage:  hf legic read [h] <offset> <length> <IV>");

        PrintAndLog("Options:");
        PrintAndLog("Options:");

-       PrintAndLog("  <offset>        : offset in data array to start download from");
-       PrintAndLog("  <num of bytes>  : number of bytes to download");
+       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");

        PrintAndLog("");
        PrintAndLog("Samples:");
        PrintAndLog("      hf legic read");
        PrintAndLog("");
        PrintAndLog("Samples:");
        PrintAndLog("      hf legic read");

+       PrintAndLog("      hf legic read 10 4");

        return 0;
 }
        return 0;
 }

-

 int usage_legic_sim(void){
 int usage_legic_sim(void){

+       PrintAndLog("Missing help text.");
+       return 0;
+}
+int usage_legic_write(void){
+       PrintAndLog(" Write sample buffer to a legic tag. (use after load or read)");
+       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("  <IV>          : (optional) Initialization vector to use");
+       PrintAndLog("");
+       PrintAndLog("Samples:");
+       PrintAndLog("      hf legic write");
+       PrintAndLog("      hf legic write 10 4");

        return 0;
 }
 int usage_legic_rawwrite(void){
        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("Options:");
+       PrintAndLog("  h             : this help");
+       PrintAndLog("  <address>     : address to write to");
+       PrintAndLog("  <value>       : value to write");
+       PrintAndLog("  <IV>          : (optional) Initialization vector to use");
+       PrintAndLog("");
+       PrintAndLog("Samples:");
+       PrintAndLog("      hf legic writeraw");
+       PrintAndLog("      hf legic writeraw 10 4");

        return 0;
 }
 int usage_legic_fill(void){
        return 0;
 }
 int usage_legic_fill(void){

+       PrintAndLog("Missing help text.");

        return 0;
 }
 
        return 0;
 }
 


@@ -204,10 +238,10 @@ int CmdLegicDecode(const char *Cmd) {
                        // decode segments
                        for (segmentNum=1; segmentNum < 128; segmentNum++ )
                        {
                        // decode segments
                        for (segmentNum=1; segmentNum < 128; segmentNum++ )
                        {

-                               segment_len = ((data_buf[i+1]^crc)&0x0f) * 256 + (data_buf[i]^crc);
-                               segment_flag = ((data_buf[i+1]^crc)&0xf0)>>4;
-                               wrp = (data_buf[i+2]^crc);
-                               wrc = ((data_buf[i+3]^crc)&0x70)>>4;
+                               segment_len = ((data_buf[i+1] ^ crc) & 0x0f) * 256 + (data_buf[i] ^ crc);
+                               segment_flag = ((data_buf[i+1] ^ crc) & 0xf0) >> 4;
+                               wrp = (data_buf[i+2] ^ crc);
+                               wrc = ((data_buf[i+3] ^ crc) & 0x70) >> 4;

 
                                bool hasWRC = (wrc > 0);
                                bool hasWRP = (wrp > wrc);
 
                                bool hasWRC = (wrc > 0);
                                bool hasWRP = (wrp > wrc);


@@ -219,20 +253,20 @@ int CmdLegicDecode(const char *Cmd) {
                                segCrcBytes[1]=data_buf[1];                     //uid1
                                segCrcBytes[2]=data_buf[2];                     //uid2
                                segCrcBytes[3]=data_buf[3];                     //uid3
                                segCrcBytes[1]=data_buf[1];                     //uid1
                                segCrcBytes[2]=data_buf[2];                     //uid2
                                segCrcBytes[3]=data_buf[3];                     //uid3

-                               segCrcBytes[4]=(data_buf[i]^crc);       //hdr0
-                               segCrcBytes[5]=(data_buf[i+1]^crc); //hdr1
-                               segCrcBytes[6]=(data_buf[i+2]^crc); //hdr2
-                               segCrcBytes[7]=(data_buf[i+3]^crc); //hdr3
+                               segCrcBytes[4]=(data_buf[i] ^ crc);   //hdr0
+                               segCrcBytes[5]=(data_buf[i+1] ^ crc); //hdr1
+                               segCrcBytes[6]=(data_buf[i+2] ^ crc); //hdr2
+                               segCrcBytes[7]=(data_buf[i+3] ^ crc); //hdr3

 
                                segCalcCRC = CRC8Legic(segCrcBytes, 8);
 
                                segCalcCRC = CRC8Legic(segCrcBytes, 8);

-                               segCRC = data_buf[i+4]^crc;
+                               segCRC = data_buf[i+4] ^ crc;

 
                                PrintAndLog("Segment %02u \nraw header | 0x%02X 0x%02X 0x%02X 0x%02X \nSegment len: %u,  Flag: 0x%X (valid:%01u, last:%01u), WRP: %02u, WRC: %02u, RD: %01u, CRC: 0x%02X (%s)",
                                        segmentNum,
 
                                PrintAndLog("Segment %02u \nraw header | 0x%02X 0x%02X 0x%02X 0x%02X \nSegment len: %u,  Flag: 0x%X (valid:%01u, last:%01u), WRP: %02u, WRC: %02u, RD: %01u, CRC: 0x%02X (%s)",
                                        segmentNum,

-                                       data_buf[i]^crc,
-                                       data_buf[i+1]^crc,
-                                       data_buf[i+2]^crc,
-                                       data_buf[i+3]^crc,
+                                       data_buf[i] ^ crc,
+                                       data_buf[i+1] ^ crc,
+                                       data_buf[i+2] ^ crc,
+                                       data_buf[i+3] ^ crc,

                                        segment_len, 
                                        segment_flag,
                                        (segment_flag & 0x4) >> 2,
                                        segment_len, 
                                        segment_flag,
                                        (segment_flag & 0x4) >> 2,


@@ -251,7 +285,7 @@ int CmdLegicDecode(const char *Cmd) {
                                        PrintAndLog("\nrow  | data");
                                        PrintAndLog("-----+------------------------------------------------");
 
                                        PrintAndLog("\nrow  | data");
                                        PrintAndLog("-----+------------------------------------------------");
 

-                                       for ( k=i; k < (i+wrc); ++k)
+                                       for ( k=i; k < (i + wrc); ++k)

                                                data_buf[k] ^= crc;
 
                                        print_hex_break( data_buf+i, wrc, 16);
                                                data_buf[k] ^= crc;
 
                                        print_hex_break( data_buf+i, wrc, 16);


@@ -300,7 +334,7 @@ int CmdLegicDecode(const char *Cmd) {
                        i = 8;
 
                        wrp = data_buf[7] & 0x0F;
                        i = 8;
 
                        wrp = data_buf[7] & 0x0F;

-                       wrc = (data_buf[7] & 0x707) >> 4;
+                       wrc = (data_buf[7] & 0x70) >> 4;

 
                        bool hasWRC = (wrc > 0);
                        bool hasWRP = (wrp > wrc);
 
                        bool hasWRC = (wrc > 0);
                        bool hasWRP = (wrp > wrc);


@@ -342,30 +376,32 @@ int CmdLegicDecode(const char *Cmd) {
                        PrintAndLog("-----+------------------------------------------------\n");
                }
        }
                        PrintAndLog("-----+------------------------------------------------\n");
                }
        }

-

        return 0;
 }
 
 int CmdLegicRFRead(const char *Cmd) {
        return 0;
 }
 
 int CmdLegicRFRead(const char *Cmd) {

-       
+

        // params:
        // offset in data
        // number of bytes.
        char cmdp = param_getchar(Cmd, 0);
        if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_read();
        
        // params:
        // offset in data
        // number of bytes.
        char cmdp = param_getchar(Cmd, 0);
        if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_read();
        

-       int byte_count = 0, offset = 0;
-       sscanf(Cmd, "%i %i", &offset, &byte_count);
-       if(byte_count == 0) byte_count = -1;
-       if(byte_count + offset > 1024) byte_count = 1024 - offset;
+       uint32_t offset = 0, len = 0, IV = 0;
+       sscanf(Cmd, "%x %x %x", &offset, &len, &IV);

 
 

-       UsbCommand c= {CMD_READER_LEGIC_RF, {offset, byte_count, 0}};
+       // OUT-OF-BOUNDS check
+       if(len + offset > MAX_LENGTH) len = MAX_LENGTH - offset;
+       
+       IV &= 0x7F;
+       PrintAndLog("Current IV: 0x%02x", IV);
+       
+       UsbCommand c= {CMD_READER_LEGIC_RF, {offset, len, IV}};

        clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
 
        clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
 

-

 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 :)  


@@ -506,28 +542,64 @@ int CmdLegicRfSim(const char *Cmd) {
        return 0;
 }
 
        return 0;
 }
 

-//TODO: write a help text (iceman)

 int CmdLegicRfWrite(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();
+       
+       uint32_t offset = 0, len = 0, IV = SESSION_IV;
+       

     UsbCommand c = {CMD_WRITER_LEGIC_RF, {0,0,0}};
     UsbCommand c = {CMD_WRITER_LEGIC_RF, {0,0,0}};

-    int res = sscanf(Cmd, " 0x%"llx" 0x%"llx, &c.arg[0], &c.arg[1]);
-       if(res != 2) {
-               PrintAndLog("Please specify the offset and length as two hex strings");
+    int res = sscanf(Cmd, "%x %x %x", &offset, &len, &IV);
+       if(res < 2) {
+               PrintAndLog("Please specify the offset and length as two hex strings and, optionally, the IV also as an hex string");

         return -1;
     }
         return -1;
     }

+
+       // OUT-OF-BOUNDS check
+       if(len + offset > MAX_LENGTH) len = MAX_LENGTH - offset;
+
+       
+       IV &= 0x7F;
+       PrintAndLog("Current IV: 0x%02x", IV);
+       
+       c.arg[0] = offset;
+       c.arg[1] = len;
+    c.arg[2] = IV;
+       

        clearCommandBuffer();
     SendCommand(&c);
     return 0;
 }
 
        clearCommandBuffer();
     SendCommand(&c);
     return 0;
 }
 

-//TODO: write a help text (iceman)

 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 address = 0, data = 0, IV = SESSION_IV;        

        char answer;
        char answer;

+

     UsbCommand c = { CMD_RAW_WRITER_LEGIC_RF, {0,0,0} };
     UsbCommand c = { CMD_RAW_WRITER_LEGIC_RF, {0,0,0} };

-    int res = sscanf(Cmd, " 0x%"llx" 0x%"llx, &c.arg[0], &c.arg[1]);
-       if(res != 2) {
-               PrintAndLog("Please specify the offset and value as two hex strings");
-        return -1;
-    }
+    int res = sscanf(Cmd, "%x %x %x", &address, &data, &IV);
+       if(res < 2)
+               return usage_legic_rawwrite();
+
+       // OUT-OF-BOUNDS check
+       if(address > MAX_LENGTH)
+               return usage_legic_rawwrite();
+       
+       IV &= 0x7F;
+       PrintAndLog("Current IV: 0x%02x", IV);
+
+       c.arg[0] = address;
+       c.arg[1] = data;
+    c.arg[2] = IV;

        
        if (c.arg[0] == 0x05 || c.arg[0] == 0x06) {
                PrintAndLog("############# DANGER !! #############");
        
        if (c.arg[0] == 0x05 || c.arg[0] == 0x06) {
                PrintAndLog("############# DANGER !! #############");


@@ -660,12 +732,12 @@ int CmdLegicCalcCrc8(const char *Cmd){
 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)"},
 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] -- read bytes from a LEGIC card"},
+       {"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)"},
        {"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> -- Write sample buffer (user after load or read)"},
-       {"writeRaw",CmdLegicRfRawWrite, 0, "<address> <value> -- Write direct to address"},
+       {"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"},
        {NULL, NULL, 0, NULL}
        {"fill",        CmdLegicRfFill, 0, "<offset> <length> <value> -- Fill/Write tag with constant value"},
        {"crc8",        CmdLegicCalcCrc8, 1, "Calculate Legic CRC8 over given hexbytes"},
        {NULL, NULL, 0, NULL}