]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhf14b.c
ADD: @pwpiwi 's fix https://github.com/Proxmark/proxmark3/commit/50365fedcbaf91ce530c...
[proxmark3-svn] / client / cmdhf14b.c
index 525ffcc63d1d62a79c14c1845ff8099fe3390b06..52888bfdfbd9d83781ce5dd57e095907a5631158 100644 (file)
@@ -22,6 +22,9 @@
 #include "cmdparser.h"
 #include "cmdhf14b.h"
 #include "cmdmain.h"
+#include "cmdhf14a.h"
+//#include "sleep.h"
+#include "cmddata.h"
 
 static int CmdHelp(const char *Cmd);
 
@@ -149,16 +152,11 @@ int CmdHF14BList(const char *Cmd)
 
        return 0;
 }
-int CmdHF14BRead(const char *Cmd)
-{
-  UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443, {strtol(Cmd, NULL, 0), 0, 0}};
-  SendCommand(&c);
-  return 0;
-}
 
 int CmdHF14Sim(const char *Cmd)
 {
   UsbCommand c={CMD_SIMULATE_TAG_ISO_14443};
+       clearCommandBuffer();
   SendCommand(&c);
   return 0;
 }
@@ -166,6 +164,7 @@ int CmdHF14Sim(const char *Cmd)
 int CmdHFSimlisten(const char *Cmd)
 {
   UsbCommand c = {CMD_SIMULATE_TAG_HF_LISTEN};
+       clearCommandBuffer();
   SendCommand(&c);
   return 0;
 }
@@ -173,6 +172,7 @@ int CmdHFSimlisten(const char *Cmd)
 int CmdHF14BSnoop(const char *Cmd)
 {
   UsbCommand c = {CMD_SNOOP_ISO_14443};
+       clearCommandBuffer();
   SendCommand(&c);
   return 0;
 }
@@ -184,6 +184,7 @@ int CmdHF14BSnoop(const char *Cmd)
 int CmdSri512Read(const char *Cmd)
 {
   UsbCommand c = {CMD_READ_SRI512_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
+       clearCommandBuffer();
   SendCommand(&c);
   return 0;
 }
@@ -195,24 +196,76 @@ int CmdSri512Read(const char *Cmd)
 int CmdSrix4kRead(const char *Cmd)
 {
   UsbCommand c = {CMD_READ_SRIX4K_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
+       clearCommandBuffer();
   SendCommand(&c);
   return 0;
 }
 
-int CmdHF14BCmdRaw (const char *cmd) {
+int rawClose(void){
     UsbCommand resp;
-    uint8_t *recv;
-    UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; // len,recv?
-    uint8_t reply=1;
-    uint8_t crc=0;
-    uint8_t power=0;
+       UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}};
+       clearCommandBuffer();
+       SendCommand(&c);
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
+               return 0;
+       }
+       return 0;       
+}
+
+int HF14BCmdRaw(bool reply, bool *crc, uint8_t power_trace, uint8_t *data, uint8_t *datalen, bool verbose){
+       UsbCommand resp;
+       UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; // len,recv,power/trace
+  if(*crc)
+  {
+    uint8_t first, second;
+    ComputeCrc14443(CRC_14443_B, data, *datalen, &first, &second);
+    data[*datalen] = first;
+    data[*datalen + 1] = second;
+    *datalen += 2;
+  }
+  
+  c.arg[0] = *datalen;
+  c.arg[1] = reply;
+       c.arg[2] = power_trace;
+  memcpy(c.d.asBytes,data,*datalen);
+       clearCommandBuffer();
+  SendCommand(&c);
+  
+  if (!reply) return 1; 
+
+  if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
+    if (verbose) PrintAndLog("timeout while waiting for reply.");
+    return 0;
+  }
+  *datalen = resp.arg[0];
+       if (verbose) PrintAndLog("received %u octets", *datalen);
+       if(*datalen<2) return 0;
+
+  memcpy(data, resp.d.asBytes, *datalen);
+  if (verbose) PrintAndLog("%s", sprint_hex(data, *datalen));
+
+  uint8_t first, second;
+  ComputeCrc14443(CRC_14443_B, data, *datalen-2, &first, &second);
+  if(data[*datalen-2] == first && data[*datalen-1] == second) {
+    if (verbose) PrintAndLog("CRC OK");
+    *crc = true;
+  } else {
+    if (verbose) PrintAndLog("CRC failed");
+    *crc = false;
+  }
+  return 1;
+}
+
+int CmdHF14BCmdRaw (const char *Cmd) {
+    bool reply = true;
+    bool crc = false;
+       uint8_t power_trace = 0;
     char buf[5]="";
-    int i=0;
     uint8_t data[100] = {0x00};
-    unsigned int datalen=0, temp;
-    char *hexout;
-    
-    if (strlen(cmd)<3) {
+    uint8_t datalen = 0;
+    unsigned int temp;
+    int i = 0;
+    if (strlen(Cmd)<3) {
         PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] <0A 0B 0C ... hex>");
         PrintAndLog("       -r    do not read response");
         PrintAndLog("       -c    calculate and append CRC");
@@ -221,23 +274,23 @@ int CmdHF14BCmdRaw (const char *cmd) {
     }
 
     // strip
-    while (*cmd==' ' || *cmd=='\t') cmd++;
+    while (*Cmd==' ' || *Cmd=='\t') Cmd++;
     
-    while (cmd[i]!='\0') {
-        if (cmd[i]==' ' || cmd[i]=='\t') { i++; continue; }
-        if (cmd[i]=='-') {
-            switch (cmd[i+1]) {
+    while (Cmd[i]!='\0') {
+        if (Cmd[i]==' ' || Cmd[i]=='\t') { i++; continue; }
+        if (Cmd[i]=='-') {
+            switch (Cmd[i+1]) {
                 case 'r': 
                 case 'R': 
-                    reply=0;
+                    reply = false;
                     break;
                 case 'c':
                 case 'C':                
-                    crc=1;
+                    crc = true;
                     break;
                 case 'p': 
                 case 'P': 
-                    power=1;
+                                       power_trace |= 1;
                     break;
                 default:
                     PrintAndLog("Invalid option");
@@ -246,17 +299,16 @@ int CmdHF14BCmdRaw (const char *cmd) {
             i+=2;
             continue;
         }
-        if ((cmd[i]>='0' && cmd[i]<='9') ||
-            (cmd[i]>='a' && cmd[i]<='f') ||
-            (cmd[i]>='A' && cmd[i]<='F') ) {
+        if ((Cmd[i]>='0' && Cmd[i]<='9') ||
+            (Cmd[i]>='a' && Cmd[i]<='f') ||
+            (Cmd[i]>='A' && Cmd[i]<='F') ) {
             buf[strlen(buf)+1]=0;
-            buf[strlen(buf)]=cmd[i];
+            buf[strlen(buf)]=Cmd[i];
             i++;
             
             if (strlen(buf)>=2) {
                 sscanf(buf,"%x",&temp);
-                data[datalen]=(uint8_t)(temp & 0xff);
-                datalen++;
+                data[datalen++]=(uint8_t)(temp & 0xff);
                 *buf=0;
             }
             continue;
@@ -269,53 +321,174 @@ int CmdHF14BCmdRaw (const char *cmd) {
       PrintAndLog("Missing data input");
       return 0;
     }
-    if(crc)
-    {
-        uint8_t first, second;
-        ComputeCrc14443(CRC_14443_B, data, datalen, &first, &second);
-        data[datalen++] = first;
-        data[datalen++] = second;
-    }
-    
-    c.arg[0] = datalen;
-    c.arg[1] = reply;
-    c.arg[2] = power;
-    memcpy(c.d.asBytes,data,datalen);
-    
-    SendCommand(&c);
-    
-    if (reply) {
-        if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
-            recv = resp.d.asBytes;
-            PrintAndLog("received %i octets",resp.arg[0]);
-            if(!resp.arg[0])
-                return 0;
-            hexout = (char *)malloc(resp.arg[0] * 3 + 1);
-            if (hexout != NULL) {
-                uint8_t first, second;
-                for (int i = 0; i < resp.arg[0]; i++) { // data in hex
-                    sprintf(&hexout[i * 3], "%02X ", recv[i]);
-                }
-                PrintAndLog("%s", hexout);
-                free(hexout);
-                ComputeCrc14443(CRC_14443_B, recv, resp.arg[0]-2, &first, &second);
-                if(recv[resp.arg[0]-2]==first && recv[resp.arg[0]-1]==second) {
-                    PrintAndLog("CRC OK");
-                } else {
-                    PrintAndLog("CRC failed");
-                }
-            } else {
-                PrintAndLog("malloc failed your client has low memory?");
-            }
-        } else {
-            PrintAndLog("timeout while waiting for reply.");
-        }
-    } // if reply
-    return 0;
+
+       return HF14BCmdRaw(reply, &crc, power_trace, data, &datalen, true);
 }
 
-int CmdHF14BWrite( const char *Cmd){
+static void print_atqb_resp(uint8_t *data){
+  PrintAndLog ("           UID: %s", sprint_hex(data+1,4));
+  PrintAndLog ("      App Data: %s", sprint_hex(data+5,4));
+  PrintAndLog ("      Protocol: %s", sprint_hex(data+9,3));
+  uint8_t BitRate = data[9];
+  if (!BitRate) 
+    PrintAndLog ("      Bit Rate: 106 kbit/s only PICC <-> PCD");
+  if (BitRate & 0x10)
+    PrintAndLog ("      Bit Rate: 212 kbit/s PICC -> PCD supported");
+  if (BitRate & 0x20)
+    PrintAndLog ("      Bit Rate: 424 kbit/s PICC -> PCD supported"); 
+  if (BitRate & 0x40)
+    PrintAndLog ("      Bit Rate: 847 kbit/s PICC -> PCD supported"); 
+  if (BitRate & 0x01)
+    PrintAndLog ("      Bit Rate: 212 kbit/s PICC <- PCD supported");
+  if (BitRate & 0x02)
+    PrintAndLog ("      Bit Rate: 424 kbit/s PICC <- PCD supported"); 
+  if (BitRate & 0x04)
+    PrintAndLog ("      Bit Rate: 847 kbit/s PICC <- PCD supported"); 
+  if (BitRate & 0x80) 
+    PrintAndLog ("                Same bit rate <-> required");
+
+  uint16_t maxFrame = data[10]>>4;
+  if (maxFrame < 5) 
+    maxFrame = 8*maxFrame + 16;
+  else if (maxFrame == 5)
+    maxFrame = 64;
+  else if (maxFrame == 6)
+    maxFrame = 96;
+  else if (maxFrame == 7)
+    maxFrame = 128;
+  else if (maxFrame == 8)
+    maxFrame = 256;
+  else
+    maxFrame = 257;
+
+  PrintAndLog ("Max Frame Size: %d%s",maxFrame, (maxFrame == 257) ? "+ RFU" : "");
+
+  uint8_t protocolT = data[10] & 0xF;
+  PrintAndLog (" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT) ? "" : "not " );
+  PrintAndLog ("Frame Wait Int: %d", data[11]>>4);
+  PrintAndLog (" App Data Code: Application is %s",(data[11]&4) ? "Standard" : "Proprietary");
+  PrintAndLog (" Frame Options: NAD is %ssupported",(data[11]&2) ? "" : "not ");
+  PrintAndLog (" Frame Options: CID is %ssupported",(data[11]&1) ? "" : "not ");
+  
+  return;
+}
 
+char *get_ST_Chip_Model(uint8_t data){
+       static char model[20];
+       char *retStr = model;
+       memset(model,0, sizeof(model));
+
+       switch (data) {
+               case 0x0: sprintf(retStr, "SRIX4K (Special)"); break;
+               case 0x2: sprintf(retStr, "SR176"); break;
+               case 0x3: sprintf(retStr, "SRIX4K"); break;
+               case 0x4: sprintf(retStr, "SRIX512"); break;
+               case 0x6: sprintf(retStr, "SRI512"); break;
+               case 0x7: sprintf(retStr, "SRI4K"); break;
+               case 0xC: sprintf(retStr, "SRT512"); break;
+               default: sprintf(retStr, "Unknown"); break;
+       }
+       return retStr;
+}
+
+static void print_st_info(uint8_t *data){
+       //uid = first 8 bytes in data
+       PrintAndLog(" UID: %s", sprint_hex(data,8));
+       PrintAndLog(" MFG: %02X, %s", data[1], getTagInfo(data[1]));
+       PrintAndLog("Chip: %02X, %s", data[2]>>2, get_ST_Chip_Model(data[2]>>2));
+       return;
+}
+
+int HF14BStdRead(uint8_t *data, uint8_t *datalen){
+  bool crc = true;
+  *datalen = 3;
+  //std read cmd
+  data[0] = 0x05;
+  data[1] = 0x00;
+  data[2] = 0x08;
+
+       if (HF14BCmdRaw(true, &crc, 0, data, datalen, false)==0) return 0;
+
+       if (data[0] != 0x50  || *datalen != 14 || !crc) return 0;
+
+  PrintAndLog ("\n14443-3b tag found:");
+  print_atqb_resp(data);
+
+  return 1;
+}
+
+int HF14B_ST_Read(uint8_t *data, uint8_t *datalen){
+  bool crc = true;
+  *datalen = 2;
+       //wake cmd
+  data[0] = 0x06;
+  data[1] = 0x00;
+
+       //leave power on
+       // verbose on for now for testing - turn off when functional
+       if (HF14BCmdRaw(true, &crc, 1, data, datalen, true)==0) return rawClose();
+
+       if (*datalen != 3 || !crc) return rawClose();
+
+  uint8_t chipID = data[0];
+       // select
+  data[0] = 0x0E;
+  data[1] = chipID;
+  *datalen = 2;
+
+       //leave power on
+       // verbose on for now for testing - turn off when functional
+       if (HF14BCmdRaw(true, &crc, 1, data, datalen, true)==0) return rawClose();
+
+       if (*datalen != 3 || !crc || data[0] != chipID) return rawClose();
+
+       // get uid
+  data[0] = 0x0B;
+  *datalen = 1;
+
+       //power off
+       // verbose on for now for testing - turn off when functional
+       if (HF14BCmdRaw(true, &crc, 1, data, datalen, true)==0) return 0;
+       rawClose();
+       if (*datalen != 10 || !crc) return 0;
+
+       PrintAndLog("\n14443-3b ST tag found:");
+       print_st_info(data);
+  return 1;
+}
+
+int HF14BReader(bool verbose){
+  uint8_t data[100];
+  uint8_t datalen = 5;
+  
+  // try std 14b (atqb)
+       if (HF14BStdRead(data, &datalen)) return 1;
+
+  // try st 14b
+       if (HF14B_ST_Read(data, &datalen)) return 1;
+
+       if (verbose) PrintAndLog("no 14443B tag found");
+       return 0;
+}
+
+int CmdHF14BReader(const char *Cmd){
+       return HF14BReader(true);
+}
+
+int CmdHFRawSamples(const char *Cmd){
+       UsbCommand resp;
+       UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443, {strtol(Cmd,NULL,0), 0, 0}};
+       SendCommand(&c);
+
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
+               PrintAndLog("timeout while waiting for reply.");
+               return 0;
+       }
+       getSamples("39999", true);
+       return 1;
+}
+
+int CmdHF14BWrite( const char *Cmd){
 /*
  * For SRIX4K  blocks 00 - 7F
  * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
@@ -386,8 +559,9 @@ static command_t CommandTable[] =
 {
   {"help",        CmdHelp,        1, "This help"},
   {"demod",       CmdHF14BDemod,  1, "Demodulate ISO14443 Type B from tag"},
+       {"getsamples",  CmdHFRawSamples,0, "[atqb=0 or ST=1] Send wake cmd and Get raw HF samples to GraphBuffer"},
   {"list",        CmdHF14BList,   0, "[Deprecated] List ISO 14443b history"},
-  {"read",        CmdHF14BRead,   0, "Read HF tag (ISO 14443)"},
+  {"reader",      CmdHF14BReader, 0, "Find 14b tag (HF ISO 14443b)"},
   {"sim",         CmdHF14Sim,     0, "Fake ISO 14443 tag"},
   {"simlisten",   CmdHFSimlisten, 0, "Get HF samples as fake tag"},
   {"snoop",       CmdHF14BSnoop,  0, "Eavesdrop ISO 14443"},
Impressum, Datenschutz