target and bitstream back to front!

[proxmark3-svn] / client / cmdhf14a.c

diff --git a/client/cmdhf14a.c b/client/cmdhf14a.c
index cf7570dd41e76a6c641f7d3726a5adc0e481ca4a..35fcd68cc172b76c889a086c8d309abdca998f8d 100644 (file)
--- a/client/cmdhf14a.c
+++ b/client/cmdhf14a.c
@@ -191,8 +191,124 @@ int CmdHF14AReader(const char *Cmd)
                case 0x98: PrintAndLog(" SAK : Gemplus MPCOS"); break;
                default: ;
        }
-       if(resp->arg[0] == 1)
+       if(resp->arg[0] == 1) {
+               bool ta1 = 0, tb1 = 0, tc1 = 0;
+               int pos;
+
                PrintAndLog(" ATS : %s", sprint_hex(card->ats, card->ats_len));
+               if (card->ats_len > 0) {
+                       PrintAndLog("       -  TL : length is %d bytes", card->ats[0]);
+               }
+               if (card->ats_len > 1) {
+                       ta1 = (card->ats[1] & 0x10) == 0x10;
+                       tb1 = (card->ats[1] & 0x20) == 0x20;
+                       tc1 = (card->ats[1] & 0x40) == 0x40;
+                       PrintAndLog("       -  T0 : TA1 is%s present, TB1 is%s present, "
+                                       "TC1 is%s present, FSCI is %d",
+                               (ta1 ? "" : " NOT"), (tb1 ? "" : " NOT"), (tc1 ? "" : " NOT"),
+                               (card->ats[1] & 0x0f));
+               }
+               pos = 2;
+               if (ta1 && card->ats_len > pos) {
+                       char dr[16], ds[16];
+                       dr[0] = ds[0] = '\0';
+                       if (card->ats[pos] & 0x10) strcat(ds, "2, ");
+                       if (card->ats[pos] & 0x20) strcat(ds, "4, ");
+                       if (card->ats[pos] & 0x40) strcat(ds, "8, ");
+                       if (card->ats[pos] & 0x01) strcat(dr, "2, ");
+                       if (card->ats[pos] & 0x02) strcat(dr, "4, ");
+                       if (card->ats[pos] & 0x04) strcat(dr, "8, ");
+                       if (strlen(ds) != 0) ds[strlen(ds) - 2] = '\0';
+                       if (strlen(dr) != 0) dr[strlen(dr) - 2] = '\0';
+                       PrintAndLog("       - TA1 : different divisors are%s supported, "
+                                       "DR: [%s], DS: [%s]",
+                                       (card->ats[pos] & 0x80 ? " NOT" : ""), dr, ds);
+                       pos++;
+               }
+               if (tb1 && card->ats_len > pos) {
+                       PrintAndLog("       - TB1 : SFGI = %d, FWI = %d",
+                                       (card->ats[pos] & 0x08),
+                                       (card->ats[pos] & 0x80) >> 4);
+                       pos++;
+               }
+               if (tc1 && card->ats_len > pos) {
+                       PrintAndLog("       - TC1 : NAD is%s supported, CID is%s supported",
+                                       (card->ats[pos] & 0x01) ? "" : " NOT",
+                                       (card->ats[pos] & 0x02) ? "" : " NOT");
+                       pos++;
+               }
+               if (card->ats_len > pos) {
+                       char *tip = "";
+                       if (card->ats_len - pos > 7) {
+                               if (memcmp(card->ats + pos, "\xC1\x05\x2F\x2F\x01\xBC\xD6", 7) == 0) {
+                                       tip = "-> MIFARE Plus X 2K or 4K";
+                               } else if (memcmp(card->ats + pos, "\xC1\x05\x2F\x2F\x00\x35\xC7", 7) == 0) {
+                                       tip = "-> MIFARE Plus S 2K or 4K";
+                               }
+                       } 
+                       PrintAndLog("       -  HB : %s%s", sprint_hex(card->ats + pos, card->ats_len - pos - 2), tip);
+                       if (card->ats[pos] == 0xC1) {
+                               PrintAndLog("               c1 -> Mifare or (multiple) virtual cards of various type");
+                               PrintAndLog("                  %02x -> Length is %d bytes",
+                                               card->ats[pos + 1], card->ats[pos + 1]);
+                               switch (card->ats[pos + 2] & 0xf0) {
+                                       case 0x10:
+                                               PrintAndLog("                     1x -> MIFARE DESFire");
+                                               break;
+                                       case 0x20:
+                                               PrintAndLog("                     2x -> MIFARE Plus");
+                                               break;
+                               }
+                               switch (card->ats[pos + 2] & 0x0f) {
+                                       case 0x00:
+                                               PrintAndLog("                     x0 -> <1 kByte");
+                                               break;
+                                       case 0x01:
+                                               PrintAndLog("                     x0 -> 1 kByte");
+                                               break;
+                                       case 0x02:
+                                               PrintAndLog("                     x0 -> 2 kByte");
+                                               break;
+                                       case 0x03:
+                                               PrintAndLog("                     x0 -> 4 kByte");
+                                               break;
+                                       case 0x04:
+                                               PrintAndLog("                     x0 -> 8 kByte");
+                                               break;
+                               }
+                               switch (card->ats[pos + 3] & 0xf0) {
+                                       case 0x00:
+                                               PrintAndLog("                        0x -> Engineering sample");
+                                               break;
+                                       case 0x20:
+                                               PrintAndLog("                        2x -> Released");
+                                               break;
+                               }
+                               switch (card->ats[pos + 3] & 0x0f) {
+                                       case 0x00:
+                                               PrintAndLog("                        x0 -> Generation 1");
+                                               break;
+                                       case 0x01:
+                                               PrintAndLog("                        x1 -> Generation 2");
+                                               break;
+                                       case 0x02:
+                                               PrintAndLog("                        x2 -> Generation 3");
+                                               break;
+                               }
+                               switch (card->ats[pos + 4] & 0x0f) {
+                                       case 0x00:
+                                               PrintAndLog("                           x0 -> Only VCSL supported");
+                                               break;
+                                       case 0x01:
+                                               PrintAndLog("                           x1 -> VCS, VCSL, and SVC supported");
+                                               break;
+                                       case 0x0E:
+                                               PrintAndLog("                           xE -> no VCS command supported");
+                                               break;
+                               }
+                       }
+               }
+       }
        else
                PrintAndLog("proprietary non-iso14443a card found, RATS not supported");
 
@@ -284,9 +400,26 @@ int CmdHF14ASim(const char *Cmd)
   return 0;
 }
 
-int CmdHF14ASnoop(const char *Cmd)
-{
-  UsbCommand c = {CMD_SNOOP_ISO_14443a};
+int CmdHF14ASnoop(const char *Cmd) {
+       int param = 0;
+       
+       if (param_getchar(Cmd, 0) == 'h') {
+               PrintAndLog("It get data from the field and saves it into command buffer.");
+               PrintAndLog("Buffer accessible from command hf 14a list.");
+               PrintAndLog("Usage:  hf 14a snoop [c][r]");
+               PrintAndLog("c - triggered by first data from card");
+               PrintAndLog("r - triggered by first 7-bit request from reader (REQ,WUP,...)");
+               PrintAndLog("sample: hf 14a snoop c r");
+               return 0;
+       }       
+       
+       for (int i = 0; i < 2; i++) {
+               char ctmp = param_getchar(Cmd, i);
+               if (ctmp == 'c' || ctmp == 'C') param |= 0x01;
+               if (ctmp == 'r' || ctmp == 'R') param |= 0x02;
+       }
+
+  UsbCommand c = {CMD_SNOOP_ISO_14443a, {param, 0, 0}};
   SendCommand(&c);
   return 0;
 }