]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhf.c
projects / proxmark3-svn / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
chg: too many \ slashes
[proxmark3-svn] / client / cmdhf.c
diff --git a/client/cmdhf.c b/client/cmdhf.c
index f6fb3a9925f0f2678eb5e766da9f38f94208e1c2..0ca601fb34e6be5db3a0286c2207444205dcbb46 100644 (file)
--- a/client/cmdhf.c
+++ b/client/cmdhf.c
@@ -19,178 +19,168 @@
 #include "cmdhf14b.h"
 #include "cmdhf15.h"
 #include "cmdhfepa.h"
 #include "cmdhf14b.h"
 #include "cmdhf15.h"
 #include "cmdhfepa.h"
-#include "cmdhflegic.h"
-#include "cmdhficlass.h"
-#include "cmdhfmf.h"
-#include "cmdhfmfu.h"
-#include "cmdhfmfdes.h"
-#include "cmdhftopaz.h"
+#include "cmdhflegic.h"         // LEGIC
+#include "cmdhficlass.h" // ICLASS
+#include "cmdhfmf.h"    // CLASSIC
+#include "cmdhfmfu.h"   // ULTRALIGHT/NTAG etc
+#include "cmdhfmfdes.h"         // DESFIRE
+#include "cmdhftopaz.h"         // TOPAZ
+#include "cmdhfemv.h"   // EMV
 #include "protocols.h"
 
 static int CmdHelp(const char *Cmd);
 
 #include "protocols.h"
 
 static int CmdHelp(const char *Cmd);
 
-int CmdHFTune(const char *Cmd)
-{
-  UsbCommand c={CMD_MEASURE_ANTENNA_TUNING_HF};
-  SendCommand(&c);
-  return 0;
+int CmdHFTune(const char *Cmd) {
+       PrintAndLog("Measuring HF antenna, press button to exit");
+       UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING_HF};
+       clearCommandBuffer();
+       SendCommand(&c);
+       return 0;
 }
 
 }
 
-
-void annotateIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
-       switch(cmd[0])
-       {
-       case ISO14443A_CMD_WUPA:        snprintf(exp,size,"WUPA"); break;
-       case ISO14443A_CMD_ANTICOLL_OR_SELECT:{
-               // 93 20 = Anticollision (usage: 9320 - answer: 4bytes UID+1byte UID-bytes-xor)
-               // 93 70 = Select (usage: 9370+5bytes 9320 answer - answer: 1byte SAK)
-               if(cmd[1] == 0x70)
-               {
-                       snprintf(exp,size,"SELECT_UID"); break;
-               }else
-               {
-                       snprintf(exp,size,"ANTICOLL"); break;
+int applyIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       switch ( cmd[0] ){
+               case ISO14443A_CMD_WUPA:        snprintf(exp,size,"WUPA"); break;
+               case ISO14443A_CMD_ANTICOLL_OR_SELECT:{
+                       // 93 20 = Anticollision (usage: 9320 - answer: 4bytes UID+1byte UID-bytes-xor)
+                       // 93 70 = Select (usage: 9370+5bytes 9320 answer - answer: 1byte SAK)
+                       if(cmd[1] == 0x70)
+                               snprintf(exp,size,"SELECT_UID");
+                       else
+                               snprintf(exp,size,"ANTICOLL");
+                       break;
                }
                }
-       }
-       case ISO14443A_CMD_ANTICOLL_OR_SELECT_2:{
-               //95 20 = Anticollision of cascade level2
-               //95 70 = Select of cascade level2
-               if(cmd[2] == 0x70)
-               {
-                       snprintf(exp,size,"SELECT_UID-2"); break;
-               }else
-               {
-                       snprintf(exp,size,"ANTICOLL-2"); break;
+               case ISO14443A_CMD_ANTICOLL_OR_SELECT_2:{
+                       //95 20 = Anticollision of cascade level2
+                       //95 70 = Select of cascade level2
+                       if(cmd[2] == 0x70)
+                               snprintf(exp,size,"SELECT_UID-2");
+                       else
+                               snprintf(exp,size,"ANTICOLL-2");
+                       break;
                }
                }
+               case ISO14443A_CMD_REQA:                snprintf(exp,size,"REQA"); break;
+               case ISO14443A_CMD_READBLOCK:   snprintf(exp,size,"READBLOCK(%d)",cmd[1]); break;
+               case ISO14443A_CMD_WRITEBLOCK:  snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); break;
+               case ISO14443A_CMD_HALT:                snprintf(exp,size,"HALT"); break;
+               case ISO14443A_CMD_RATS:                snprintf(exp,size,"RATS"); break;
+               case MIFARE_CMD_INC:                    snprintf(exp,size,"INC(%d)",cmd[1]); break;
+               case MIFARE_CMD_DEC:                    snprintf(exp,size,"DEC(%d)",cmd[1]); break;
+               case MIFARE_CMD_RESTORE:                snprintf(exp,size,"RESTORE(%d)",cmd[1]); break;
+               case MIFARE_CMD_TRANSFER:               snprintf(exp,size,"TRANSFER(%d)",cmd[1]); break;
+               case MIFARE_AUTH_KEYA:{
+                       if ( cmdsize > 3)
+                               snprintf(exp,size,"AUTH-A(%d)",cmd[1]); 
+                       else
+                               //      case MIFARE_ULEV1_VERSION :  both 0x60.
+                               snprintf(exp,size,"EV1 VERSION");
+                       break;
+               }
+               case MIFARE_AUTH_KEYB:                  snprintf(exp,size,"AUTH-B(%d)",cmd[1]); break;
+               case MIFARE_MAGICWUPC1:                 snprintf(exp,size,"MAGIC WUPC1"); break;
+               case MIFARE_MAGICWUPC2:                 snprintf(exp,size,"MAGIC WUPC2"); break;
+               case MIFARE_MAGICWIPEC:                 snprintf(exp,size,"MAGIC WIPEC"); break;
+               case MIFARE_ULC_AUTH_1 :                snprintf(exp,size,"AUTH "); break;
+               case MIFARE_ULC_AUTH_2 :                snprintf(exp,size,"AUTH_ANSW"); break;
+               case MIFARE_ULEV1_AUTH :        
+                       if ( cmdsize == 7 )
+                               snprintf(exp,size,"PWD-AUTH KEY: 0x%02x%02x%02x%02x", cmd[1], cmd[2], cmd[3], cmd[4] );
+                       else
+                               snprintf(exp,size,"PWD-AUTH");
+                       break;
+               case MIFARE_ULEV1_FASTREAD : {
+                       if ( cmdsize >=3 && cmd[2] <= 0xE6)
+                               snprintf(exp,size,"READ RANGE (%d-%d)",cmd[1],cmd[2]); 
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULC_WRITE : {
+                       if ( cmd[1] < 0x21 )
+                               snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); 
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULEV1_READ_CNT :{
+                       if ( cmd[1] < 5 )
+                               snprintf(exp,size,"READ CNT(%d)",cmd[1]);
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULEV1_INCR_CNT : {
+                       if ( cmd[1] < 5 )
+                               snprintf(exp,size,"INCR(%d)",cmd[1]);
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULEV1_READSIG :             snprintf(exp,size,"READ_SIG"); break;
+               case MIFARE_ULEV1_CHECKTEAR :   snprintf(exp,size,"CHK_TEARING(%d)",cmd[1]); break;
+               case MIFARE_ULEV1_VCSL :                snprintf(exp,size,"VCSL"); break;
+               default:                                                return 0;
        }
        }
-       case ISO14443A_CMD_REQA:                snprintf(exp,size,"REQA"); break;
-       case ISO14443A_CMD_READBLOCK:   snprintf(exp,size,"READBLOCK(%d)",cmd[1]); break;
-       case ISO14443A_CMD_WRITEBLOCK:  snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); break;
-       case ISO14443A_CMD_HALT:                snprintf(exp,size,"HALT"); break;
-       case ISO14443A_CMD_RATS:                snprintf(exp,size,"RATS"); break;
-       case MIFARE_CMD_INC:                    snprintf(exp,size,"INC(%d)",cmd[1]); break;
-       case MIFARE_CMD_DEC:                    snprintf(exp,size,"DEC(%d)",cmd[1]); break;
-       case MIFARE_CMD_RESTORE:                snprintf(exp,size,"RESTORE(%d)",cmd[1]); break;
-       case MIFARE_CMD_TRANSFER:               snprintf(exp,size,"TRANSFER(%d)",cmd[1]); break;
-       case MIFARE_AUTH_KEYA:{
-               if ( cmdsize > 3)
-                       snprintf(exp,size,"AUTH-A(%d)",cmd[1]); 
-               else
-                       //      case MIFARE_ULEV1_VERSION :  both 0x60.
-                       snprintf(exp,size,"EV1 VERSION");
-               break;
-       }
-       case MIFARE_AUTH_KEYB:                  snprintf(exp,size,"AUTH-B(%d)",cmd[1]); break;
-       case MIFARE_MAGICWUPC1:                 snprintf(exp,size,"MAGIC WUPC1"); break;
-       case MIFARE_MAGICWUPC2:                 snprintf(exp,size,"MAGIC WUPC2"); break;
-       case MIFARE_MAGICWIPEC:                 snprintf(exp,size,"MAGIC WIPEC"); break;
-       case MIFARE_ULC_AUTH_1 :                snprintf(exp,size,"AUTH "); break;
-       case MIFARE_ULC_AUTH_2 :                snprintf(exp,size,"AUTH_ANSW"); break;
-       case MIFARE_ULEV1_AUTH :        
-               if ( cmdsize == 7 )
-                       snprintf(exp,size,"PWD-AUTH KEY: 0x%02x%02x%02x%02x", cmd[1], cmd[2], cmd[3], cmd[4] );
-               else
-                       snprintf(exp,size,"PWD-AUTH");
-               break;
-       case MIFARE_ULEV1_FASTREAD : {
-               if ( cmdsize >=3 && cmd[2] <= 0xE6)
-                       snprintf(exp,size,"READ RANGE (%d-%d)",cmd[1],cmd[2]); 
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULC_WRITE : {
-               if ( cmd[1] < 0x21 )
-                       snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); 
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULEV1_READ_CNT :{
-               if ( cmd[1] < 5 )
-                       snprintf(exp,size,"READ CNT(%d)",cmd[1]);
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULEV1_INCR_CNT : {
-               if ( cmd[1] < 5 )
-                       snprintf(exp,size,"INCR(%d)",cmd[1]);
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULEV1_READSIG :             snprintf(exp,size,"READ_SIG"); break;
-       case MIFARE_ULEV1_CHECKTEAR :   snprintf(exp,size,"CHK_TEARING(%d)",cmd[1]); break;
-       case MIFARE_ULEV1_VCSL :                snprintf(exp,size,"VCSL"); break;
-       default:                                                snprintf(exp,size,"?"); break;
-       }
-       return;
+       return 1;
 }
 
 }
 
-void annotateIclass(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
-       switch(cmd[0])
-       {
-       case ICLASS_CMD_ACTALL:      snprintf(exp,size,"ACTALL"); break;
-       case ICLASS_CMD_READ_OR_IDENTIFY:{
-               if(cmdsize > 1){
-                       snprintf(exp,size,"READ(%d)",cmd[1]);
-               }else{
-                       snprintf(exp,size,"IDENTIFY");
+void annotateIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       applyIso14443a(exp, size, cmd, cmdsize);
+}
+
+void annotateIclass(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       switch (cmd[0]) {
+               case ICLASS_CMD_ACTALL:      snprintf(exp,size,"ACTALL"); break;
+               case ICLASS_CMD_READ_OR_IDENTIFY:{
+                       if(cmdsize > 1){
+                               snprintf(exp,size,"READ(%d)",cmd[1]);
+                       }else{
+                               snprintf(exp,size,"IDENTIFY");
+                       }
+                       break;
                }
                }
-               break;
-       }
-       case ICLASS_CMD_SELECT:      snprintf(exp,size,"SELECT"); break;
-       case ICLASS_CMD_PAGESEL:     snprintf(exp,size,"PAGESEL(%d)", cmd[1]); break;
-       case ICLASS_CMD_READCHECK_KC:snprintf(exp,size,"READCHECK[Kc](%d)", cmd[1]); break;
-       case ICLASS_CMD_READCHECK_KD:snprintf(exp,size,"READCHECK[Kd](%d)", cmd[1]); break;
-       case ICLASS_CMD_CHECK:       snprintf(exp,size,"CHECK"); break;
-       case ICLASS_CMD_DETECT:      snprintf(exp,size,"DETECT"); break;
-       case ICLASS_CMD_HALT:        snprintf(exp,size,"HALT"); break;
-       case ICLASS_CMD_UPDATE:      snprintf(exp,size,"UPDATE(%d)",cmd[1]); break;
-       case ICLASS_CMD_ACT:         snprintf(exp,size,"ACT"); break;
-       case ICLASS_CMD_READ4:       snprintf(exp,size,"READ4(%d)",cmd[1]); break;
-       default:                     snprintf(exp,size,"?"); break;
+               case ICLASS_CMD_SELECT:      snprintf(exp,size,"SELECT"); break;
+               case ICLASS_CMD_PAGESEL:     snprintf(exp,size,"PAGESEL(%d)", cmd[1]); break;
+               case ICLASS_CMD_READCHECK_KC:snprintf(exp,size,"READCHECK[Kc](%d)", cmd[1]); break;
+               case ICLASS_CMD_READCHECK_KD:snprintf(exp,size,"READCHECK[Kd](%d)", cmd[1]); break;
+               case ICLASS_CMD_CHECK:       snprintf(exp,size,"CHECK"); break;
+               case ICLASS_CMD_DETECT:      snprintf(exp,size,"DETECT"); break;
+               case ICLASS_CMD_HALT:        snprintf(exp,size,"HALT"); break;
+               case ICLASS_CMD_UPDATE:      snprintf(exp,size,"UPDATE(%d)",cmd[1]); break;
+               case ICLASS_CMD_ACT:         snprintf(exp,size,"ACT"); break;
+               case ICLASS_CMD_READ4:       snprintf(exp,size,"READ4(%d)",cmd[1]); break;
+               default:                     snprintf(exp,size,"?"); break;
        }
        return;
 }
 
        }
        return;
 }
 
-void annotateIso15693(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
-
-       if(cmd[0] == 0x26)
-       {
+void annotateIso15693(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       if(cmd[0] == 0x26) {
                switch(cmd[1]){
                switch(cmd[1]){
-               case ISO15693_INVENTORY           :snprintf(exp, size, "INVENTORY");break;
-               case ISO15693_STAYQUIET           :snprintf(exp, size, "STAY_QUIET");break;
-               default:                     snprintf(exp,size,"?"); break;
-
+                       case ISO15693_INVENTORY                         :snprintf(exp, size, "INVENTORY");break;
+                       case ISO15693_STAYQUIET                         :snprintf(exp, size, "STAY_QUIET");break;
+                       default                                                         :snprintf(exp,size,"?"); break;
                }
                }
-       }else if(cmd[0] == 0x02)
-       {
-               switch(cmd[1])
-               {
-               case ISO15693_READBLOCK            :snprintf(exp, size, "READBLOCK");break;
-               case ISO15693_WRITEBLOCK           :snprintf(exp, size, "WRITEBLOCK");break;
-               case ISO15693_LOCKBLOCK            :snprintf(exp, size, "LOCKBLOCK");break;
-               case ISO15693_READ_MULTI_BLOCK     :snprintf(exp, size, "READ_MULTI_BLOCK");break;
-               case ISO15693_SELECT               :snprintf(exp, size, "SELECT");break;
-               case ISO15693_RESET_TO_READY       :snprintf(exp, size, "RESET_TO_READY");break;
-               case ISO15693_WRITE_AFI            :snprintf(exp, size, "WRITE_AFI");break;
-               case ISO15693_LOCK_AFI             :snprintf(exp, size, "LOCK_AFI");break;
-               case ISO15693_WRITE_DSFID          :snprintf(exp, size, "WRITE_DSFID");break;
-               case ISO15693_LOCK_DSFID           :snprintf(exp, size, "LOCK_DSFID");break;
-               case ISO15693_GET_SYSTEM_INFO      :snprintf(exp, size, "GET_SYSTEM_INFO");break;
-               case ISO15693_READ_MULTI_SECSTATUS :snprintf(exp, size, "READ_MULTI_SECSTATUS");break;
-               default:                            snprintf(exp,size,"?"); break;
+       } else if(cmd[0] == 0x02) {
+               switch (cmd[1]) {
+                       case ISO15693_READBLOCK            :snprintf(exp, size, "READBLOCK");break;
+                       case ISO15693_WRITEBLOCK           :snprintf(exp, size, "WRITEBLOCK");break;
+                       case ISO15693_LOCKBLOCK            :snprintf(exp, size, "LOCKBLOCK");break;
+                       case ISO15693_READ_MULTI_BLOCK     :snprintf(exp, size, "READ_MULTI_BLOCK");break;
+                       case ISO15693_SELECT               :snprintf(exp, size, "SELECT");break;
+                       case ISO15693_RESET_TO_READY       :snprintf(exp, size, "RESET_TO_READY");break;
+                       case ISO15693_WRITE_AFI            :snprintf(exp, size, "WRITE_AFI");break;
+                       case ISO15693_LOCK_AFI             :snprintf(exp, size, "LOCK_AFI");break;
+                       case ISO15693_WRITE_DSFID          :snprintf(exp, size, "WRITE_DSFID");break;
+                       case ISO15693_LOCK_DSFID           :snprintf(exp, size, "LOCK_DSFID");break;
+                       case ISO15693_GET_SYSTEM_INFO      :snprintf(exp, size, "GET_SYSTEM_INFO");break;
+                       case ISO15693_READ_MULTI_SECSTATUS :snprintf(exp, size, "READ_MULTI_SECSTATUS");break;
+                       default:                            snprintf(exp,size,"?"); break;
                }
        }
 }
 
                }
        }
 }
 
-void annotateTopaz(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
+void annotateTopaz(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
        switch(cmd[0]) {
                case TOPAZ_REQA                                         :snprintf(exp, size, "REQA");break;
                case TOPAZ_WUPA                                         :snprintf(exp, size, "WUPA");break;
        switch(cmd[0]) {
                case TOPAZ_REQA                                         :snprintf(exp, size, "REQA");break;
                case TOPAZ_WUPA                                         :snprintf(exp, size, "WUPA");break;
@@ -256,6 +246,83 @@ void annotateIso7816(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
        }
 }
 
        }
 }
 
+// MIFARE DESFire
+void annotateMfDesfire(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
+       
+       // it's basically a ISO14443a tag, so try annotation from there
+       if (!applyIso14443a(exp, size, cmd, cmdsize)){
+               //PrintAndLog("rest");
+               //PrintAndLog("(%d)",cmd[0]);
+               // S-block 11xxx010
+               if ( (cmd[0] & 0xC0) && (cmdsize == 3) ) {              
+                       switch ( (cmd[0] & 0x30)  ) {
+                               case 0x30       : snprintf(exp, size, "S-block DESELECT"); break;
+                               case 0x00       : snprintf(exp, size, "S-block WTX"); break;
+                               default         : snprintf(exp, size, "S-block"); break;
+                       }               
+               }
+               // R-block (ack) 101xx01x
+               else if ( ((cmd[0] & 0xB0) == 0xA0) && ( cmdsize > 2) ) {
+                       if ( (cmd[0] & 0x10) == 0 ) 
+                               snprintf(exp, size, "R-block ACK(%d)", (cmd[0] & 0x01));
+                       else
+                               snprintf(exp, size, "R-block NACK(%d)", (cmd[0] & 0x01));
+               }
+               // I-block 000xCN1x
+               else if ( (cmd[0] & 0xC0) == 0x00){
+                       // PCB [CID] [NAD] [INF] CRC CRC
+                       int pos = 1;
+                       if ( (cmd[0] & 0x08) == 0x08) // cid byte following
+                               pos = pos + 1;
+                       if ( (cmd[0] & 0x04) == 0x04) // nad byte following
+                               pos = pos + 1;
+                       //PrintAndLog("[%d]",pos);
+                       switch ( cmd[pos] ){
+                               case MFDES_CREATE_APPLICATION                   :snprintf(exp, size, "CREATE APPLICATION");break;
+                               case MFDES_DELETE_APPLICATION                   :snprintf(exp, size, "DELETE APPLICATION");break;
+                               case MFDES_GET_APPLICATION_IDS                  :snprintf(exp, size, "GET APPLICATION IDS");break;
+                               case MFDES_SELECT_APPLICATION                   :snprintf(exp, size, "SELECT APPLICATION");break;
+                               case MFDES_FORMAT_PICC                                  :snprintf(exp, size, "FORMAT PICC");break;
+                               case MFDES_GET_VERSION                                  :snprintf(exp, size, "GET VERSION");break;
+                               case MFDES_READ_DATA                                    :snprintf(exp, size, "READ DATA");break;
+                               case MFDES_WRITE_DATA                                   :snprintf(exp, size, "WRITE DATA");break;
+                               case MFDES_GET_VALUE                                    :snprintf(exp, size, "GET VALUE");break;
+                               case MFDES_CREDIT                                               :snprintf(exp, size, "CREDIT");break;
+                               case MFDES_DEBIT                                                :snprintf(exp, size, "DEBIT");break;
+                               case MFDES_LIMITED_CREDIT                               :snprintf(exp, size, "LIMITED CREDIT");break;
+                               case MFDES_WRITE_RECORD                                 :snprintf(exp, size, "WRITE RECORD");break;
+                               case MFDES_READ_RECORDS                                 :snprintf(exp, size, "READ RECORDS");break;
+                               case MFDES_CLEAR_RECORD_FILE                    :snprintf(exp, size, "CLEAR RECORD FILE");break;
+                               case MFDES_COMMIT_TRANSACTION                   :snprintf(exp, size, "COMMIT TRANSACTION");break;
+                               case MFDES_ABORT_TRANSACTION                    :snprintf(exp, size, "ABORT TRANSACTION");break;
+                               case MFDES_GET_FREE_MEMORY                              :snprintf(exp, size, "GET FREE MEMORY");break;
+                               case MFDES_GET_FILE_IDS                                 :snprintf(exp, size, "GET FILE IDS");break;
+                               case MFDES_GET_ISOFILE_IDS                              :snprintf(exp, size, "GET ISOFILE IDS");break;
+                               case MFDES_GET_FILE_SETTINGS                    :snprintf(exp, size, "GET FILE SETTINGS");break;
+                               case MFDES_CHANGE_FILE_SETTINGS                 :snprintf(exp, size, "CHANGE FILE SETTINGS");break;
+                               case MFDES_CREATE_STD_DATA_FILE                 :snprintf(exp, size, "CREATE STD DATA FILE");break;
+                               case MFDES_CREATE_BACKUP_DATA_FILE              :snprintf(exp, size, "CREATE BACKUP DATA FILE");break;
+                               case MFDES_CREATE_VALUE_FILE                    :snprintf(exp, size, "CREATE VALUE FILE");break;
+                               case MFDES_CREATE_LINEAR_RECORD_FILE    :snprintf(exp, size, "CREATE LINEAR RECORD FILE");break;
+                               case MFDES_CREATE_CYCLIC_RECORD_FILE    :snprintf(exp, size, "CREATE CYCLIC RECORD FILE");break;
+                               case MFDES_DELETE_FILE                                  :snprintf(exp, size, "DELETE FILE");break;
+                               case MFDES_AUTHENTICATE                                 :snprintf(exp, size, "AUTH NATIVE (keyNo %d)", cmd[pos+1]);break;  // AUTHENTICATE_NATIVE
+                               case MFDES_AUTHENTICATE_ISO                             :snprintf(exp, size, "AUTH ISO (keyNo %d)", cmd[pos+1]);break;  // AUTHENTICATE_STANDARD
+                               case MFDES_AUTHENTICATE_AES                             :snprintf(exp, size, "AUTH AES (keyNo %d)", cmd[pos+1]);break;
+                               case MFDES_CHANGE_KEY_SETTINGS                  :snprintf(exp, size, "CHANGE KEY SETTINGS");break;
+                               case MFDES_GET_KEY_SETTINGS                             :snprintf(exp, size, "GET KEY SETTINGS");break;
+                               case MFDES_CHANGE_KEY                                   :snprintf(exp, size, "CHANGE KEY");break;
+                               case MFDES_GET_KEY_VERSION                              :snprintf(exp, size, "GET KEY VERSION");break;
+                               case MFDES_AUTHENTICATION_FRAME                 :snprintf(exp, size, "AUTH FRAME / NEXT FRAME");break;
+                               default                                                                 :break;
+                       }
+               }else{
+                       // anything else
+                       snprintf(exp,size,"?");
+               }
+       }
+}
+
 /**
 06 00 = INITIATE
 0E xx = SELECT ID (xx = Chip-ID)
 /**
 06 00 = INITIATE
 0E xx = SELECT ID (xx = Chip-ID)
@@ -267,10 +334,23 @@ void annotateIso7816(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
 0A 11 22 33 44 55 66 = Authenticate (11 22 33 44 55 66 = data to authenticate)
 **/
 
 0A 11 22 33 44 55 66 = Authenticate (11 22 33 44 55 66 = data to authenticate)
 **/
 
-void annotateIso14443b(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
+void annotateIso14443b(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
        switch(cmd[0]){
        switch(cmd[0]){
-               case ISO14443B_REQB             : snprintf(exp,size,"REQB");break;
+               case ISO14443B_REQB             : {
+                       
+                       switch ( cmd[2] & 0x07 ) {
+                               case 0: snprintf(exp, size,"1 slot ");break;
+                               case 1: snprintf(exp, size,"2 slots ");break; 
+                               case 2: snprintf(exp, size,"4 slots ");break;
+                               case 3: snprintf(exp, size,"8 slots ");break;
+                               default: snprintf(exp, size,"16 slots ");break;
+                       }                       
+                       if ( (cmd[2] & 0x8) )
+                               snprintf(exp, size,"WUPB");
+                       else
+                               snprintf(exp, size,"REQB");
+                       break;
+               }
                case ISO14443B_ATTRIB           : snprintf(exp,size,"ATTRIB");break;
                case ISO14443B_HALT             : snprintf(exp,size,"HALT");break;
                case ISO14443B_INITIATE     : snprintf(exp,size,"INITIATE");break;
                case ISO14443B_ATTRIB           : snprintf(exp,size,"ATTRIB");break;
                case ISO14443B_HALT             : snprintf(exp,size,"HALT");break;
                case ISO14443B_INITIATE     : snprintf(exp,size,"INITIATE");break;
@@ -287,6 +367,61 @@ void annotateIso14443b(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
        }
 }
 
        }
 }
 
+// LEGIC 
+// 1 = read
+// 0 = write
+// Quite simpel tag
+void annotateLegic(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){     
+       uint8_t bitsend = cmd[0];       
+       uint8_t cmdBit = (cmd[1] & 1);
+       switch (bitsend){
+               case 7:
+                       snprintf(exp, size, "IV 0x%02X", cmd[1]);
+                       break;
+               case 6: {
+                       switch ( cmd[1] ) {
+                               case LEGIC_MIM_22:       snprintf(exp, size, "MIM22"); break;
+                               case LEGIC_MIM_256:      snprintf(exp, size, "MIM256"); break;
+                               case LEGIC_MIM_1024: snprintf(exp, size, "MIM1024"); break;
+                               case LEGIC_ACK_22:       snprintf(exp, size, "ACK 22"); break;
+                               case LEGIC_ACK_256:      snprintf(exp, size, "ACK 256/1024"); break;
+                       }
+                       break;
+               }
+               case 9:
+               case 11: {
+
+                       uint16_t address = (cmd[2] << 7) | cmd[1] >> 1;
+                       
+                       if (cmdBit == LEGIC_READ) 
+                               snprintf(exp, size, "READ Byte(%d)", address);
+                       
+                       if (cmdBit == LEGIC_WRITE ) 
+                               snprintf(exp, size, "WRITE Byte(%d)", address);
+                       break;
+               }
+               case 21: {
+                       if (cmdBit == LEGIC_WRITE ) {
+                               uint16_t address = ((cmd[2] << 7) | cmd[1] >> 1) & 0xFF;
+                               uint8_t val = (cmd[3] & 1 ) << 7 | cmd[2] >> 1;
+                               snprintf(exp, size, "WRITE Byte(%d) %02X", address, val);
+                       }
+                       break;
+               }
+               case 23: {
+                       if (cmdBit == LEGIC_WRITE ) {
+                               uint16_t address = ((cmd[2] << 7) | cmd[1] >> 1) & 0x3FF;
+                               uint8_t val = (cmd[3] & 0x7 ) << 5 | cmd[2] >> 3;
+                               snprintf(exp, size, "WRITE Byte(%d) %02X", address, val);
+                       }
+                       break;
+               }
+               case 12:
+               default:
+                       break;
+       }
+}
+
 /**
  * @brief iso14443A_CRC_check Checks CRC in command or response
  * @param isResponse
 /**
  * @brief iso14443A_CRC_check Checks CRC in command or response
  * @param isResponse
@@ -398,7 +533,6 @@ uint8_t iclass_CRC_check(bool isResponse, uint8_t* data, uint8_t len)
        }
 }
 
        }
 }
 
-
 bool is_last_record(uint16_t tracepos, uint8_t *trace, uint16_t traceLen)
 {
        return(tracepos + sizeof(uint32_t) + sizeof(uint16_t) + sizeof(uint16_t) >= traceLen);
 bool is_last_record(uint16_t tracepos, uint8_t *trace, uint16_t traceLen)
 {
        return(tracepos + sizeof(uint32_t) + sizeof(uint16_t) + sizeof(uint16_t) >= traceLen);
@@ -509,8 +643,9 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
                                crcStatus = iso14443B_CRC_check(isResponse, frame, data_len);
                                break;
                        case ISO_14443A:
                                crcStatus = iso14443B_CRC_check(isResponse, frame, data_len);
                                break;
                        case ISO_14443A:
+                       case MFDES:
                                crcStatus = iso14443A_CRC_check(isResponse, frame, data_len);
                                crcStatus = iso14443A_CRC_check(isResponse, frame, data_len);
-                               break;                          
+                               break;
                        default: 
                                break;
                }
                        default: 
                                break;
                }
@@ -531,9 +666,8 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
                        oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);
                }
                uint8_t parityBits = parityBytes[j>>3];
                        oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);
                }
                uint8_t parityBits = parityBytes[j>>3];
-               if (protocol != ISO_14443B &&  (isResponse || protocol == ISO_14443A)  && (oddparity != ((parityBits >> (7-(j&0x0007))) & 0x01))) {
+               if (protocol != LEGIC && protocol != ISO_14443B && protocol != ISO_7816_4 &&  (isResponse || protocol == ISO_14443A)  && (oddparity != ((parityBits >> (7-(j&0x0007))) & 0x01))) {
                        snprintf(line[j/16]+(( j % 16) * 4),110, "%02x! ", frame[j]);
                        snprintf(line[j/16]+(( j % 16) * 4),110, "%02x! ", frame[j]);
-
                } else {
                        snprintf(line[j/16]+(( j % 16) * 4),110, "%02x  ", frame[j]);
                }
                } else {
                        snprintf(line[j/16]+(( j % 16) * 4),110, "%02x  ", frame[j]);
                }
@@ -550,22 +684,29 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
                }
        }
 
                }
        }
 
-       if(data_len == 0){
+       if (data_len == 0 ) {
                sprintf(line[0],"<empty trace - possible error>");
                sprintf(line[0],"<empty trace - possible error>");
+               return tracepos;
        }
        }
-       //--- Draw the CRC column
+
+       // Draw the CRC column
        char *crc = (crcStatus == 0 ? "!crc" : (crcStatus == 1 ? " ok " : "    "));
 
        EndOfTransmissionTimestamp = timestamp + duration;
 
        char *crc = (crcStatus == 0 ? "!crc" : (crcStatus == 1 ? " ok " : "    "));
 
        EndOfTransmissionTimestamp = timestamp + duration;
 
-       if(!isResponse)
-       {
+       // Always annotate LEGIC read/tag
+       if ( protocol == LEGIC )
+               annotateLegic(explanation,sizeof(explanation),frame,data_len);
+       
+       if (!isResponse)        {
                switch(protocol) {
                        case ICLASS:            annotateIclass(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_14443A:        annotateIso14443a(explanation,sizeof(explanation),frame,data_len); break;
                switch(protocol) {
                        case ICLASS:            annotateIclass(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_14443A:        annotateIso14443a(explanation,sizeof(explanation),frame,data_len); break;
+                       case MFDES:                     annotateMfDesfire(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_14443B:        annotateIso14443b(explanation,sizeof(explanation),frame,data_len); break;
                        case TOPAZ:                     annotateTopaz(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_7816_4:        annotateIso7816(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_14443B:        annotateIso14443b(explanation,sizeof(explanation),frame,data_len); break;
                        case TOPAZ:                     annotateTopaz(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_7816_4:        annotateIso7816(explanation,sizeof(explanation),frame,data_len); break;
+
                        default:                        break;
                }
        }
                        default:                        break;
                }
        }
@@ -573,7 +714,7 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
        int num_lines = MIN((data_len - 1)/16 + 1, 16);
        for (int j = 0; j < num_lines ; j++) {
                if (j == 0) {
        int num_lines = MIN((data_len - 1)/16 + 1, 16);
        for (int j = 0; j < num_lines ; j++) {
                if (j == 0) {
-                       PrintAndLog(" %10d | %10d | %s |%-64s | %s| %s",
+                       PrintAndLog(" %10u | %10u | %s |%-64s | %s| %s",
                                (timestamp - first_timestamp),
                                (EndOfTransmissionTimestamp - first_timestamp),
                                (isResponse ? "Tag" : "Rdr"),
                                (timestamp - first_timestamp),
                                (EndOfTransmissionTimestamp - first_timestamp),
                                (isResponse ? "Tag" : "Rdr"),
@@ -592,7 +733,7 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
        
        if (showWaitCycles && !isResponse && next_record_is_response(tracepos, trace)) {
                uint32_t next_timestamp = *((uint32_t *)(trace + tracepos));
        
        if (showWaitCycles && !isResponse && next_record_is_response(tracepos, trace)) {
                uint32_t next_timestamp = *((uint32_t *)(trace + tracepos));
-                       PrintAndLog(" %10d | %10d | %s |fdt (Frame Delay Time): %d",
+                       PrintAndLog(" %10u | %10u | %s |fdt (Frame Delay Time): %d",
                                (EndOfTransmissionTimestamp - first_timestamp),
                                (next_timestamp - first_timestamp),
                                "   ",
                                (EndOfTransmissionTimestamp - first_timestamp),
                                (next_timestamp - first_timestamp),
                                "   ",
@@ -611,9 +752,11 @@ int usage_hf_list(){
        PrintAndLog("    raw    - just show raw data without annotations");
        PrintAndLog("    14a    - interpret data as iso14443a communications");
        PrintAndLog("    14b    - interpret data as iso14443b communications");
        PrintAndLog("    raw    - just show raw data without annotations");
        PrintAndLog("    14a    - interpret data as iso14443a communications");
        PrintAndLog("    14b    - interpret data as iso14443b communications");
+       PrintAndLog("    des    - interpret data as DESFire communications");
        PrintAndLog("    iclass - interpret data as iclass communications");
        PrintAndLog("    topaz  - interpret data as topaz communications");
        PrintAndLog("    7816   - interpret data as iso7816-4 communications");
        PrintAndLog("    iclass - interpret data as iclass communications");
        PrintAndLog("    topaz  - interpret data as topaz communications");
        PrintAndLog("    7816   - interpret data as iso7816-4 communications");
+       PrintAndLog("    legic  - interpret data as LEGIC communications");
        PrintAndLog("");
        PrintAndLog("example:   hf list 14a f");
        PrintAndLog("                   hf list iclass");
        PrintAndLog("");
        PrintAndLog("example:   hf list 14a f");
        PrintAndLog("                   hf list iclass");
@@ -642,8 +785,9 @@ int usage_hf_snoop(){
        return 0;
 }
 
        return 0;
 }
 
-int CmdHFList(const char *Cmd)
-{
+int CmdHFList(const char *Cmd) {
+       clearCommandBuffer();
+               
        bool showWaitCycles = false;
        bool markCRCBytes = false;
        char type[10] = {0};
        bool showWaitCycles = false;
        bool markCRCBytes = false;
        char type[10] = {0};
@@ -671,7 +815,9 @@ int CmdHFList(const char *Cmd)
        else if(strcmp(type, "14a") == 0)       protocol = ISO_14443A;
        else if(strcmp(type, "14b") == 0)       protocol = ISO_14443B;
        else if(strcmp(type, "topaz")== 0)      protocol = TOPAZ;
        else if(strcmp(type, "14a") == 0)       protocol = ISO_14443A;
        else if(strcmp(type, "14b") == 0)       protocol = ISO_14443B;
        else if(strcmp(type, "topaz")== 0)      protocol = TOPAZ;
-       else if(strcmp(type, "7816")== 0)       protocol = ISO_7816_4;                  
+       else if(strcmp(type, "7816")== 0)       protocol = ISO_7816_4;  
+       else if(strcmp(type,"des")== 0)         protocol = MFDES;
+       else if(strcmp(type,"legic")==0)        protocol = LEGIC;
        else if(strcmp(type, "raw")== 0)        protocol = -1;//No crc, no annotations
        else errors = true;
 
        else if(strcmp(type, "raw")== 0)        protocol = -1;//No crc, no annotations
        else errors = true;
 
@@ -704,14 +850,17 @@ int CmdHFList(const char *Cmd)
        PrintAndLog("Recorded Activity (TraceLen = %d bytes)", traceLen);
        PrintAndLog("");
        PrintAndLog("Start = Start of Start Bit, End = End of last modulation. Src = Source of Transfer");
        PrintAndLog("Recorded Activity (TraceLen = %d bytes)", traceLen);
        PrintAndLog("");
        PrintAndLog("Start = Start of Start Bit, End = End of last modulation. Src = Source of Transfer");
-       PrintAndLog("iso14443a - All times are in carrier periods (1/13.56Mhz)");
-       PrintAndLog("iClass    - Timings are not as accurate");
+       if ( protocol == ISO_14443A )
+               PrintAndLog("iso14443a - All times are in carrier periods (1/13.56Mhz)");
+       if ( protocol == ICLASS )
+               PrintAndLog("iClass    - Timings are not as accurate");
+       if ( protocol == LEGIC )
+               PrintAndLog("LEGIC    - Timings are in ticks (1us == 1.5ticks)");
        PrintAndLog("");
     PrintAndLog("      Start |        End | Src | Data (! denotes parity error)                                   | CRC | Annotation         |");
        PrintAndLog("------------|------------|-----|-----------------------------------------------------------------|-----|--------------------|");
 
        PrintAndLog("");
     PrintAndLog("      Start |        End | Src | Data (! denotes parity error)                                   | CRC | Annotation         |");
        PrintAndLog("------------|------------|-----|-----------------------------------------------------------------|-----|--------------------|");
 
-       while(tracepos < traceLen)
-       {
+       while(tracepos < traceLen) {
                tracepos = printTraceLine(tracepos, traceLen, trace, protocol, showWaitCycles, markCRCBytes);
        }
 
                tracepos = printTraceLine(tracepos, traceLen, trace, protocol, showWaitCycles, markCRCBytes);
        }
 
@@ -726,71 +875,82 @@ int CmdHFSearch(const char *Cmd){
        
        PrintAndLog("");
        int ans = CmdHF14AReader("s");
        
        PrintAndLog("");
        int ans = CmdHF14AReader("s");
-
        if (ans > 0) {
        if (ans > 0) {
-               PrintAndLog("\nValid ISO14443A Tag Found - Quiting Search\n");
+               PrintAndLog("\nValid ISO14443-A Tag Found - Quiting Search\n");
                return ans;
        } 
                return ans;
        } 
-       ans = HF14BInfo(false);
+       ans = HF14BReader(false); //CmdHF14BReader("s");
        if (ans) {
        if (ans) {
-               PrintAndLog("\nValid ISO14443B Tag Found - Quiting Search\n");
+               PrintAndLog("\nValid ISO14443-B Tag Found - Quiting Search\n");
                return ans;
        }
                return ans;
        }
-       ans = HFiClassReader("", false, false);
+       ans = HF15Reader("", false);
        if (ans) {
        if (ans) {
-               PrintAndLog("\nValid iClass Tag (or PicoPass Tag) Found - Quiting Search\n");
+               PrintAndLog("\nValid ISO15693 Tag Found - Quiting Search\n");
                return ans;
        }
                return ans;
        }
-       ans = HF15Reader("", false);
+       ans = HFLegicReader("", false);
+       if ( ans == 0) {
+               PrintAndLog("\nValid LEGIC Tag Found - Quiting Search\n");
+               return 1;
+       }
+       ans = CmdHFTopazReader("s");
+       if (ans == 0) {
+               PrintAndLog("\nValid Topaz Tag Found - Quiting Search\n");
+               return 1;
+       }
+       ans = HFiClassReader("", false, false);
        if (ans) {
        if (ans) {
-               PrintAndLog("\nValid ISO15693 Tag Found - Quiting Search\n");
+               PrintAndLog("\nValid iClass Tag (or PicoPass Tag) Found - Quiting Search\n");
                return ans;
        }
                return ans;
        }
+       
        PrintAndLog("\nno known/supported 13.56 MHz tags found\n");
        return 0;
 }
 
        PrintAndLog("\nno known/supported 13.56 MHz tags found\n");
        return 0;
 }
 
-int CmdHFSnoop(const char *Cmd)
-{
+int CmdHFSnoop(const char *Cmd) {
        char cmdp = param_getchar(Cmd, 0);      
        if (cmdp == 'h' || cmdp == 'H') return usage_hf_snoop();
        
        int skippairs =  param_get32ex(Cmd, 0, 0, 10);
        int skiptriggers =  param_get32ex(Cmd, 1, 0, 10);
        
        char cmdp = param_getchar(Cmd, 0);      
        if (cmdp == 'h' || cmdp == 'H') return usage_hf_snoop();
        
        int skippairs =  param_get32ex(Cmd, 0, 0, 10);
        int skiptriggers =  param_get32ex(Cmd, 1, 0, 10);
        
-       UsbCommand c = {CMD_HF_SNIFFER, {skippairs,skiptriggers,0}};
+       UsbCommand c = {CMD_HF_SNIFFER, {skippairs, skiptriggers, 0}};
+       clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
 
        SendCommand(&c);
        return 0;
 }
 
-static command_t CommandTable[] = 
-{
-  {"help",        CmdHelp,          1, "This help"},
-  {"14a",         CmdHF14A,         1, "{ ISO14443A RFIDs... }"},
-  {"14b",         CmdHF14B,         1, "{ ISO14443B RFIDs... }"},
-  {"15",          CmdHF15,          1, "{ ISO15693 RFIDs... }"},
-  {"epa",         CmdHFEPA,         1, "{ German Identification Card... }"},
-  {"legic",       CmdHFLegic,       0, "{ LEGIC RFIDs... }"},
-  {"iclass",      CmdHFiClass,      1, "{ ICLASS RFIDs... }"},
-  {"mf",               CmdHFMF,                1, "{ MIFARE RFIDs... }"},
-  {"mfu",         CmdHFMFUltra,     1, "{ MIFARE Ultralight RFIDs... }"},
-  {"mfdes",                    CmdHFMFDes,             1, "{ MIFARE Desfire RFIDs... }"},
-  {"topaz",                    CmdHFTopaz,             1, "{ TOPAZ (NFC Type 1) RFIDs... }"},
-  {"tune",                     CmdHFTune,      0, "Continuously measure HF antenna tuning"},
-  {"list",        CmdHFList,        1, "List protocol data in trace buffer"},
-  {"search",      CmdHFSearch,      1, "Search for known HF tags [preliminary]"},
-  {"snoop",       CmdHFSnoop,       0, "<samples to skip (10000)> <triggers to skip (1)> Generic LF/HF Snoop in Testing stage"},
+static command_t CommandTable[] = {
+       {"help",        CmdHelp,          1, "This help"},
+       {"14a",         CmdHF14A,         1, "{ ISO14443A RFIDs... }"},
+       {"14b",         CmdHF14B,         1, "{ ISO14443B RFIDs... }"},
+       {"15",          CmdHF15,          1, "{ ISO15693 RFIDs... }"},
+       {"epa",         CmdHFEPA,         1, "{ German Identification Card... }"},
+#ifdef WITH_EMV
+       {"emv",         CmdHFEmv,         1, "{ EMV RFIDs... }"},
+#endif 
+       {"legic",       CmdHFLegic,       1, "{ LEGIC RFIDs... }"},
+       {"iclass",      CmdHFiClass,      1, "{ ICLASS RFIDs... }"},
+       {"mf",          CmdHFMF,                  1, "{ MIFARE RFIDs... }"},
+       {"mfu",         CmdHFMFUltra,     1, "{ MIFARE Ultralight RFIDs... }"},
+       {"mfdes",               CmdHFMFDes,               1, "{ MIFARE Desfire RFIDs... }"},
+       {"topaz",               CmdHFTopaz,               1, "{ TOPAZ (NFC Type 1) RFIDs... }"},
+       {"tune",                CmdHFTune,            0, "Continuously measure HF antenna tuning"},
+       {"list",        CmdHFList,        1, "List protocol data in trace buffer"},
+       {"search",      CmdHFSearch,      1, "Search for known HF tags [preliminary]"},
+       {"snoop",       CmdHFSnoop,       0, "<samples to skip (10000)> <triggers to skip (1)> Generic LF/HF Snoop in Testing stage"},
        {NULL, NULL, 0, NULL}
 };
 
        {NULL, NULL, 0, NULL}
 };
 
-int CmdHF(const char *Cmd)
-{
-  CmdsParse(CommandTable, Cmd);
-  return 0; 
+int CmdHF(const char *Cmd) {
+       clearCommandBuffer();
+       CmdsParse(CommandTable, Cmd);
+       return 0; 
 }
 
 }
 
-int CmdHelp(const char *Cmd)
-{
-  CmdsHelp(CommandTable);
-  return 0;
+int CmdHelp(const char *Cmd) {
+       CmdsHelp(CommandTable);
+       return 0;
 }
 }
Proxmark3 GIT tracking
Impressum, Datenschutz