Merge branch 'master' into emv_argtable
authorOleg Moiseenko <olegmsn@gmail.com>
Tue, 18 Sep 2018 15:29:59 +0000 (18:29 +0300)
committerGitHub <noreply@github.com>
Tue, 18 Sep 2018 15:29:59 +0000 (18:29 +0300)
1  2 
CHANGELOG.md
client/emv/cmdemv.c

diff --cc CHANGELOG.md
Simple merge
index d1ae2d456e791dd190ee22242bb6cbc8dafc989f,541f505a9845c30c2bf6cf130633860e1aefc504..dceade799edd54f71a16ae6798d1cbd0281fe5ff
  #include <ctype.h>
  #include "cmdemv.h"
  #include "test/cryptotest.h"
 +#include "cliparser/cliparser.h"
+ #include <jansson.h>
+ int UsageCmdHFEMVSelect(void) {
+       PrintAndLog("HELP :  Executes select applet command:\n");
+       PrintAndLog("Usage:  hf emv select [-s][-k][-a][-t] <HEX applet AID>\n");
+       PrintAndLog("  Options:");
+       PrintAndLog("  -s       : select card");
+       PrintAndLog("  -k       : keep field for next command");
+       PrintAndLog("  -a       : show APDU reqests and responses\n");
+       PrintAndLog("  -t       : TLV decode results\n");
+       PrintAndLog("Samples:");
+       PrintAndLog(" hf emv select -s a00000000101 -> select card, select applet");
+       PrintAndLog(" hf emv select -s -t a00000000101 -> select card, select applet, show result in TLV");
+       return 0;
+ }
  
  int CmdHFEMVSelect(const char *cmd) {
        uint8_t data[APDU_AID_LEN] = {0};
@@@ -105,197 -190,75 +120,197 @@@ int CmdHFEMVSearch(const char *cmd) 
        return 0;
  }
  
 -int UsageCmdHFEMVPPSE(void) {
 -      PrintAndLog("HELP :  Executes PSE/PPSE select command. It returns list of applet on the card:\n");
 -      PrintAndLog("Usage:  hf emv pse [-s][-k][-1][-2][-a][-t]\n");
 -      PrintAndLog("  Options:");
 -      PrintAndLog("  -s       : select card");
 -      PrintAndLog("  -k       : keep field for next command");
 -      PrintAndLog("  -1       : ppse (1PAY.SYS.DDF01)");
 -      PrintAndLog("  -2       : pse (2PAY.SYS.DDF01)");
 -      PrintAndLog("  -a       : show APDU reqests and responses\n");
 -      PrintAndLog("  -t       : TLV decode results\n");
 -      PrintAndLog("Samples:");
 -      PrintAndLog(" hf emv pse -s -1 -> select, get pse");
 -      PrintAndLog(" hf emv pse -s -k -2 -> select, get ppse, keep field");
 -      PrintAndLog(" hf emv pse -s -t -2 -> select, get ppse, show result in TLV");
 -      return 0;
 -}
 -
  int CmdHFEMVPPSE(const char *cmd) {
        
 +      CLIParserInit("hf emv pse", 
 +              "Executes PSE/PPSE select command. It returns list of applet on the card:\n", 
 +              "Usage:\n\thf emv pse -s1 -> select, get pse\n\thf emv pse -st2 -> select, get ppse, show result in TLV\n");
 +
 +      void* argtable[] = {
 +              arg_param_begin,
 +              arg_lit0("sS",  "select",  "activate field and select card"),
 +              arg_lit0("kK",  "keep",    "keep field ON for next command"),
 +              arg_lit0("1",   "pse",     "pse (1PAY.SYS.DDF01) mode"),
 +              arg_lit0("2",   "ppse",    "ppse (2PAY.SYS.DDF01) mode (default mode)"),
 +              arg_lit0("aA",  "apdu",    "show APDU reqests and responses"),
 +              arg_lit0("tT",  "tlv",     "TLV decode results of selected applets"),
 +              arg_param_end
 +      };
 +      CLIExecWithReturn(cmd, argtable, true);
 +      
 +      bool activateField = arg_get_lit(1);
 +      bool leaveSignalON = arg_get_lit(2);
        uint8_t PSENum = 2;
 -      bool activateField = false;
 -      bool leaveSignalON = false;
 -      bool decodeTLV = false;
 +      if (arg_get_lit(3))
 +              PSENum = 1;
 +      if (arg_get_lit(4))
 +              PSENum = 2;
 +      bool APDULogging = arg_get_lit(5);
 +      bool decodeTLV = arg_get_lit(6);
 +      CLIParserFree();        
 +      
 +      SetAPDULogging(APDULogging);
 +      
 +      // exec
 +      uint8_t buf[APDU_RES_LEN] = {0};
 +      size_t len = 0;
 +      uint16_t sw = 0;
 +      int res = EMVSelectPSE(activateField, leaveSignalON, PSENum, buf, sizeof(buf), &len, &sw);
 +      
 +      if (sw)
 +              PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff)); 
  
 -      if (strlen(cmd) < 1) {
 -              UsageCmdHFEMVPPSE();
 +      if (res)
 +              return res;
 +      
 +      
 +      if (decodeTLV)
 +              TLVPrintFromBuffer(buf, len);
 +
 +      return 0;
 +}
 +
- #define TLV_ADD(tag, value)( tlvdb_add(tlvRoot, tlvdb_fixed(tag, sizeof(value) - 1, (const unsigned char *)value)) )
++#define TLV_ADD(tag, value)( tlvdb_change_or_add_node(tlvRoot, tag, sizeof(value) - 1, (const unsigned char *)value) )
 +
 +int CmdHFEMVGPO(const char *cmd) {
 +      uint8_t data[APDU_RES_LEN] = {0};
 +      int datalen = 0;
 +
 +      CLIParserInit("hf emv gpo", 
 +              "Executes Get Processing Options command. It returns data in TLV format (0x77 - format2) or plain format (0x80 - format1).\nNeeds a EMV applet to be selected.", 
 +              "Usage:\n\thf emv gpo -k -> execute GPO\n"
 +                      "\thf emv gpo -st 01020304 -> execute GPO with 4-byte PDOL data, show result in TLV\n"); 
 +                      // here need to add load params from file and gen pdol
 +
 +      void* argtable[] = {
 +              arg_param_begin,
 +              arg_lit0("kK",  "keep",    "keep field ON for next command"),
 +              arg_lit0("pP",  "params",  "load parameters for PDOL making from `emv/defparams.json` file (by default uses default parameters) (NOT WORK!!!)"),
 +              arg_lit0("mM",  "make",    "make PDOLdata from PDOL (tag 9F38) and parameters (NOT WORK!!!)"),
 +              arg_lit0("aA",  "apdu",    "show APDU reqests and responses"),
 +              arg_lit0("tT",  "tlv",     "TLV decode results of selected applets"),
 +              arg_str0(NULL,  NULL,      "<HEX PDOLdata/PDOL>", NULL),
 +              arg_param_end
 +      };
 +      CLIExecWithReturn(cmd, argtable, true);
 +      
 +      bool leaveSignalON = arg_get_lit(1);
 +      bool paramsLoadFromFile = arg_get_lit(2);
 +      bool dataMakeFromPDOL = arg_get_lit(3);
 +      bool APDULogging = arg_get_lit(4);
 +      bool decodeTLV = arg_get_lit(5);
 +      CLIGetStrWithReturn(6, data, &datalen);
 +      CLIParserFree();        
 +      
 +      SetAPDULogging(APDULogging);
 +      
 +      // Init TLV tree
 +      const char *alr = "Root terminal TLV tree";
 +      struct tlvdb *tlvRoot = tlvdb_fixed(1, strlen(alr), (const unsigned char *)alr);
 +      
 +      // calc PDOL
 +      struct tlv *pdol_data_tlv = NULL;
 +      struct tlv data_tlv = {
 +              .tag = 0x01,
 +              .len = datalen,
 +              .value = (uint8_t *)data,
 +      };
 +      if (dataMakeFromPDOL) {
 +              // TODO
 +              PrintAndLog("Make PDOL data not implemented!");
 +
 +              //9F02:(Amount, authorized (Numeric)) len:6
 +              TLV_ADD(0x9F02, "\x00\x00\x00\x00\x01\x00");
 +              //9F1A:(Terminal Country Code) len:2
 +              TLV_ADD(0x9F1A, "ru");
 +              //5F2A:(Transaction Currency Code) len:2
 +              // USD 840, EUR 978, RUR 810, RUB 643, RUR 810(old), UAH 980, AZN 031, n/a 999
 +              TLV_ADD(0x5F2A, "\x09\x80");
 +              //9A:(Transaction Date) len:3
 +              TLV_ADD(0x9A,   "\x00\x00\x00");
 +              //9C:(Transaction Type) len:1   |  00 => Goods and service #01 => Cash
 +              TLV_ADD(0x9C,   "\x00");
 +              // 9F37 Unpredictable Number len:4
 +              TLV_ADD(0x9F37, "\x01\x02\x03\x04");
 +              // 9F6A Unpredictable Number (MSD for UDOL) len:4
 +              TLV_ADD(0x9F6A, "\x01\x02\x03\x04");
 +              //9F66:(Terminal Transaction Qualifiers (TTQ)) len:4
 +              TLV_ADD(0x9F66, "\x26\x00\x00\x00"); // qVSDC
 +
 +              if (paramsLoadFromFile) {
 +              };
 +/*            pdol_data_tlv = dol_process(tlvdb_get(tlvRoot, 0x9f38, NULL), tlvRoot, 0x83);
 +              if (!pdol_data_tlv){
 +                      PrintAndLog("ERROR: can't create PDOL TLV.");
 +                      tlvdb_free(tlvRoot);
 +                      return 4;
 +              }*/
                return 0;
 +      } else {
 +              pdol_data_tlv = &data_tlv;
 +      }
 +
 +      size_t pdol_data_tlv_data_len = 0;
 +      unsigned char *pdol_data_tlv_data = tlv_encode(pdol_data_tlv, &pdol_data_tlv_data_len);
 +      if (!pdol_data_tlv_data) {
 +              PrintAndLog("ERROR: can't create PDOL data.");
 +              tlvdb_free(tlvRoot);
 +              return 4;
        }
 +      PrintAndLog("PDOL data[%d]: %s", pdol_data_tlv_data_len, sprint_hex(pdol_data_tlv_data, pdol_data_tlv_data_len));
 +      
 +      // exec
 +      uint8_t buf[APDU_RES_LEN] = {0};
 +      size_t len = 0;
 +      uint16_t sw = 0;
 +      int res = EMVGPO(leaveSignalON, pdol_data_tlv_data, pdol_data_tlv_data_len, buf, sizeof(buf), &len, &sw, tlvRoot);
 +      
 +      free(pdol_data_tlv_data);
 +      tlvdb_free(tlvRoot);
 +      
 +      if (sw)
 +              PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff)); 
  
 -      SetAPDULogging(false);
 +      if (res)
 +              return res;
        
 -      int cmdp = 0;
 -      while(param_getchar(cmd, cmdp) != 0x00) {
 -              char c = param_getchar(cmd, cmdp);
 -              if ((c == '-') && (param_getlength(cmd, cmdp) == 2))
 -                      switch (param_getchar_indx(cmd, 1, cmdp)) {
 -                              case 'h':
 -                              case 'H':
 -                                      UsageCmdHFEMVPPSE();
 -                                      return 0;
 -                              case 's':
 -                              case 'S':
 -                                      activateField = true;
 -                                      break;
 -                              case 'k':
 -                              case 'K':
 -                                      leaveSignalON = true;
 -                                      break;
 -                              case 'a':
 -                              case 'A':
 -                                      SetAPDULogging(true);
 -                                      break;
 -                              case 't':
 -                              case 'T':
 -                                      decodeTLV = true;
 -                                      break;
 -                              case '1':
 -                                      PSENum = 1;
 -                                      break;
 -                              case '2':
 -                                      PSENum = 2;
 -                                      break;
 -                              default:
 -                                      PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
 -                                      return 1;
 -              }
 -              cmdp++;
 +      if (decodeTLV)
 +              TLVPrintFromBuffer(buf, len);
 +
 +      return 0;
 +}
 +
 +int CmdHFEMVReadRecord(const char *cmd) {
 +      uint8_t data[APDU_RES_LEN] = {0};
 +      int datalen = 0;
 +
 +      CLIParserInit("hf emv readrec", 
 +              "Executes Read Record command. It returns data in TLV format.\nNeeds a bank applet to be selected and sometimes needs GPO to be executed.", 
 +              "Usage:\n\thf emv readrec -k 0101 -> read file SFI=01, SFIrec=01\n\thf emv readrec -kt 0201-> read file 0201 and show result in TLV\n");
 +
 +      void* argtable[] = {
 +              arg_param_begin,
 +              arg_lit0("kK",  "keep",    "keep field ON for next command"),
 +              arg_lit0("aA",  "apdu",    "show APDU reqests and responses"),
 +              arg_lit0("tT",  "tlv",     "TLV decode results of selected applets"),
 +              arg_str1(NULL,  NULL,      "<SFI 1byte HEX><SFIrec 1byte HEX>", NULL),
 +              arg_param_end
 +      };
 +      CLIExecWithReturn(cmd, argtable, true);
 +      
 +      bool leaveSignalON = arg_get_lit(1);
 +      bool APDULogging = arg_get_lit(2);
 +      bool decodeTLV = arg_get_lit(3);
 +      CLIGetStrWithReturn(4, data, &datalen);
 +      CLIParserFree();
 +      
 +      if (datalen != 2) {
 +              PrintAndLog("ERROR: Command needs to have 2 bytes of data");
 +              return 1;
        }
        
 +      SetAPDULogging(APDULogging);
 +              
        // exec
        uint8_t buf[APDU_RES_LEN] = {0};
        size_t len = 0;
        return 0;
  }
  
 +int CmdHFEMVAC(const char *cmd) {
 +      uint8_t data[APDU_RES_LEN] = {0};
 +      int datalen = 0;
 +
 +      CLIParserInit("hf emv genac", 
 +              "Generate Application Cryptogram command. It returns data in TLV format .\nNeeds a EMV applet to be selected and GPO to be executed.", 
 +              "Usage:\n\thf emv genac -k 0102 -> generate AC with 2-byte CDOLdata and keep field ON after command\n"
 +                      "\thf emv genac -t 01020304 -> generate AC with 4-byte CDOL data, show result in TLV\n"
 +                      "\thf emv genac -Daac 01020304 -> generate AC with 4-byte CDOL data and terminal decision 'declined'\n"); 
 +
 +      void* argtable[] = {
 +              arg_param_begin,
 +              arg_lit0("kK",  "keep",     "keep field ON for next command"),
 +              arg_lit0("cC",  "cda",      "executes CDA transaction. Needs to get SDAD in results."),
 +              arg_str0("dD",  "decision", "<aac|tc|arqc>", "Terminal decision. aac - declined, tc - approved, arqc - online authorisation requested"),
 +              arg_lit0("aA",  "apdu",     "show APDU reqests and responses"),
 +              arg_lit0("tT",  "tlv",      "TLV decode results of selected applets"),
 +              arg_str1(NULL,  NULL,       "<HEX CDOLdata>", NULL),
 +              arg_param_end
 +      };
 +      CLIExecWithReturn(cmd, argtable, false);
 +      
 +      bool leaveSignalON = arg_get_lit(1);
 +      bool trTypeCDA = arg_get_lit(2);
 +      uint8_t termDecision = 0xff;
 +      if (arg_get_str_len(3)) {
 +              if (!strncmp(arg_get_str(3)->sval[0], "aac", 4))
 +                      termDecision = EMVAC_AAC;
 +              if (!strncmp(arg_get_str(3)->sval[0], "tc", 4))
 +                      termDecision = EMVAC_TC;
 +              if (!strncmp(arg_get_str(3)->sval[0], "arqc", 4))
 +                      termDecision = EMVAC_ARQC;
 +
 +              if (termDecision == 0xff) {
 +                      PrintAndLog("ERROR: can't find terminal decision '%s'", arg_get_str(3)->sval[0]);
 +                      return 1;
 +              }
 +      } else {
 +              termDecision = EMVAC_TC;
 +      }
 +      if (trTypeCDA)
 +              termDecision = termDecision | EMVAC_CDAREQ;
 +      bool APDULogging = arg_get_lit(4);
 +      bool decodeTLV = arg_get_lit(5);
 +      CLIGetStrWithReturn(6, data, &datalen);
 +      CLIParserFree();        
 +      
 +      SetAPDULogging(APDULogging);
 +      
 +      // Init TLV tree
 +      const char *alr = "Root terminal TLV tree";
 +      struct tlvdb *tlvRoot = tlvdb_fixed(1, strlen(alr), (const unsigned char *)alr);
 +      
 +      // calc CDOL
 +      struct tlv *cdol_data_tlv = NULL;
 +//    struct tlv *cdol_data_tlv = dol_process(tlvdb_get(tlvRoot, 0x8c, NULL), tlvRoot, 0x01); // 0x01 - dummy tag
 +      struct tlv data_tlv = {
 +              .tag = 0x01,
 +              .len = datalen,
 +              .value = (uint8_t *)data,
 +      };      
 +      cdol_data_tlv = &data_tlv;
 +      PrintAndLog("CDOL data[%d]: %s", cdol_data_tlv->len, sprint_hex(cdol_data_tlv->value, cdol_data_tlv->len));
 +      
 +      // exec
 +      uint8_t buf[APDU_RES_LEN] = {0};
 +      size_t len = 0;
 +      uint16_t sw = 0;
 +      int res = EMVAC(leaveSignalON, termDecision, (uint8_t *)cdol_data_tlv->value, cdol_data_tlv->len, buf, sizeof(buf), &len, &sw, tlvRoot);
 +      
 +//    free(cdol_data_tlv);
 +      tlvdb_free(tlvRoot);
 +      
 +      if (sw)
 +              PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff)); 
 +
 +      if (res)
 +              return res;
 +      
 +      if (decodeTLV)
 +              TLVPrintFromBuffer(buf, len);
 +
 +      return 0;       
 +}
 +
 +int CmdHFEMVGenerateChallenge(const char *cmd) {
 +
 +      CLIParserInit("hf emv challenge", 
 +              "Executes Generate Challenge command. It returns 4 or 8-byte random number from card.\nNeeds a EMV applet to be selected and GPO to be executed.", 
 +              "Usage:\n\thf emv challenge -> get challenge\n\thf emv challenge -k -> get challenge, keep fileld ON\n");
 +
 +      void* argtable[] = {
 +              arg_param_begin,
 +              arg_lit0("kK",  "keep",    "keep field ON for next command"),
 +              arg_lit0("aA",  "apdu",    "show APDU reqests and responses"),
 +              arg_param_end
 +      };
 +      CLIExecWithReturn(cmd, argtable, true);
 +      
 +      bool leaveSignalON = arg_get_lit(1);
 +      bool APDULogging = arg_get_lit(2);
 +      CLIParserFree();        
 +      
 +      SetAPDULogging(APDULogging);
 +      
 +      // exec
 +      uint8_t buf[APDU_RES_LEN] = {0};
 +      size_t len = 0;
 +      uint16_t sw = 0;
 +      int res = EMVGenerateChallenge(leaveSignalON, buf, sizeof(buf), &len, &sw, NULL);
 +      
 +      if (sw)
 +              PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff)); 
 +
 +      if (res)
 +              return res;
 +
 +      PrintAndLog("Challenge: %s", sprint_hex(buf, len));
 +      
 +      if (len != 4 && len != 8)
 +              PrintAndLog("WARNING: length of challenge must be 4 or 8, but it %d", len);
 +      
 +      return 0;
 +}
 +
 +int CmdHFEMVInternalAuthenticate(const char *cmd) {
 +      uint8_t data[APDU_RES_LEN] = {0};
 +      int datalen = 0;
 +
 +      CLIParserInit("hf emv intauth", 
 +              "Generate Internal Authenticate command. Usually needs 4-byte random number. It returns data in TLV format .\nNeeds a EMV applet to be selected and GPO to be executed.", 
 +              "Usage:\n\thf emv intauth -k 01020304 -> execute Internal Authenticate with 4-byte DDOLdata and keep field ON after command\n"
 +                      "\thf emv intauth -t 01020304 -> execute Internal Authenticate with 4-byte DDOL data, show result in TLV\n"); 
 +
 +      void* argtable[] = {
 +              arg_param_begin,
 +              arg_lit0("kK",  "keep",    "keep field ON for next command"),
 +              arg_lit0("aA",  "apdu",    "show APDU reqests and responses"),
 +              arg_lit0("tT",  "tlv",     "TLV decode results of selected applets"),
 +              arg_str1(NULL,  NULL,      "<HEX DDOLdata>", NULL),
 +              arg_param_end
 +      };
 +      CLIExecWithReturn(cmd, argtable, false);
 +      
 +      bool leaveSignalON = arg_get_lit(1);
 +      bool APDULogging = arg_get_lit(2);
 +      bool decodeTLV = arg_get_lit(3);
 +      CLIGetStrWithReturn(4, data, &datalen);
 +      CLIParserFree();        
 +      
 +      SetAPDULogging(APDULogging);
 +      
 +      // DDOL
 +      PrintAndLog("DDOL data[%d]: %s", datalen, sprint_hex(data, datalen));
 +      
 +      // exec
 +      uint8_t buf[APDU_RES_LEN] = {0};
 +      size_t len = 0;
 +      uint16_t sw = 0;
 +      int res = EMVInternalAuthenticate(leaveSignalON, data, datalen, buf, sizeof(buf), &len, &sw, NULL);
 +      
 +      if (sw)
 +              PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff)); 
 +
 +      if (res)
 +              return res;
 +      
 +      if (decodeTLV)
 +              TLVPrintFromBuffer(buf, len);
 +
 +      return 0;       
 +}
 +
  int UsageCmdHFEMVExec(void) {
        PrintAndLog("HELP :  Executes EMV contactless transaction:\n");
-       PrintAndLog("Usage:  hf emv exec [-s][-a][-t][-f][-v][-c][-x][-g]\n");
+       PrintAndLog("Usage:  hf emv exec [-s][-a][-t][-j][-f][-v][-c][-x][-g]\n");
        PrintAndLog("  Options:");
        PrintAndLog("  -s       : select card");
        PrintAndLog("  -a       : show APDU reqests and responses\n");
        return 0;
  }
  
 -#define TLV_ADD(tag, value)( tlvdb_change_or_add_node(tlvRoot, tag, sizeof(value) - 1, (const unsigned char *)value) )
  #define dreturn(n) {free(pdol_data_tlv);tlvdb_free(tlvSelect);tlvdb_free(tlvRoot);DropField();return n;}
  
+ bool HexToBuffer(const char *errormsg, const char *hexvalue, uint8_t * buffer, size_t maxbufferlen, size_t *bufferlen) {
+       int buflen = 0; 
+       
+       switch(param_gethex_to_eol(hexvalue, 0, buffer, maxbufferlen, &buflen)) {
+       case 1:
+               PrintAndLog("%s Invalid HEX value.", errormsg);
+               return false;
+       case 2:
+               PrintAndLog("%s Hex value too large.", errormsg);
+               return false;
+       case 3:
+               PrintAndLog("%s Hex value must have even number of digits.", errormsg);
+               return false;
+       }
+       
+       if (buflen > maxbufferlen) {
+               PrintAndLog("%s HEX length (%d) more than %d", errormsg, *bufferlen, maxbufferlen);
+               return false;
+       }
+       
+       *bufferlen = buflen;
+       
+       return true;
+ }
+ bool ParamLoadFromJson(struct tlvdb *tlv) {
+       json_t *root;
+       json_error_t error;
+       if (!tlv) {
+               PrintAndLog("ERROR load params: tlv tree is NULL.");
+               return false; 
+       }
+       // current path + file name
+       const char *relfname = "emv/defparams.json"; 
+       char fname[strlen(get_my_executable_directory()) + strlen(relfname) + 1];
+       strcpy(fname, get_my_executable_directory());
+       strcat(fname, relfname);
+       root = json_load_file(fname, 0, &error);
+       if (!root) {
+               PrintAndLog("Load params: json error on line %d: %s", error.line, error.text);
+               return false; 
+       }
+       
+       if (!json_is_array(root)) {
+               PrintAndLog("Load params: Invalid json format. root must be array.");
+               return false; 
+       }
+       
+       PrintAndLog("Load params: json OK");
+       
+       for(int i = 0; i < json_array_size(root); i++) {
+               json_t *data, *jtype, *jlength, *jvalue;
+               data = json_array_get(root, i);
+               if(!json_is_object(data))
+               {
+                       PrintAndLog("Load params: data [%d] is not an object", i + 1);
+                       json_decref(root);
+                       return false;
+               }
+               
+               jtype = json_object_get(data, "type");
+               if(!json_is_string(jtype))
+               {
+                       PrintAndLog("Load params: data [%d] type is not a string", i + 1);
+                       json_decref(root);
+                       return false;
+               }
+               const char *tlvType = json_string_value(jtype);
+               jvalue = json_object_get(data, "value");
+               if(!json_is_string(jvalue))
+               {
+                       PrintAndLog("Load params: data [%d] value is not a string", i + 1);
+                       json_decref(root);
+                       return false;
+               }
+               const char *tlvValue = json_string_value(jvalue);
+               jlength = json_object_get(data, "length");
+               if(!json_is_number(jlength))
+               {
+                       PrintAndLog("Load params: data [%d] length is not a number", i + 1);
+                       json_decref(root);
+                       return false;
+               }
+               
+               int tlvLength = json_integer_value(jlength);
+               if (tlvLength > 250) {
+                       PrintAndLog("Load params: data [%d] length more than 250", i + 1);
+                       json_decref(root);
+                       return false;
+               }
+               
+               PrintAndLog("TLV param: %s[%d]=%s", tlvType, tlvLength, tlvValue);
+               uint8_t buf[251] = {0};
+               size_t buflen = 0;
+               
+               // here max length must be 4, but now tlv_tag_t is 2-byte var. so let it be 2 by now...  TODO: needs refactoring tlv_tag_t...
+               if (!HexToBuffer("TLV Error type:", tlvType, buf, 2, &buflen)) { 
+                       json_decref(root);
+                       return false;
+               }
+               tlv_tag_t tag = 0;
+               for (int i = 0; i < buflen; i++) {
+                       tag = (tag << 8) + buf[i];
+               }       
+               
+               if (!HexToBuffer("TLV Error value:", tlvValue, buf, sizeof(buf) - 1, &buflen)) {
+                       json_decref(root);
+                       return false;
+               }
+               
+               if (buflen != tlvLength) {
+                       PrintAndLog("Load params: data [%d] length of HEX must(%d) be identical to length in TLV param(%d)", i + 1, buflen, tlvLength);
+                       json_decref(root);
+                       return false;
+               }
+               
+               tlvdb_change_or_add_node(tlv, tag, tlvLength, (const unsigned char *)buf);              
+       }
+       json_decref(root);
+       return true;
+ }
+ void ParamLoadDefaults(struct tlvdb *tlvRoot) {
+       //9F02:(Amount, authorized (Numeric)) len:6
+       TLV_ADD(0x9F02, "\x00\x00\x00\x00\x01\x00");
+       //9F1A:(Terminal Country Code) len:2
+       TLV_ADD(0x9F1A, "ru");
+       //5F2A:(Transaction Currency Code) len:2
+       // USD 840, EUR 978, RUR 810, RUB 643, RUR 810(old), UAH 980, AZN 031, n/a 999
+       TLV_ADD(0x5F2A, "\x09\x80");
+       //9A:(Transaction Date) len:3
+       TLV_ADD(0x9A,   "\x00\x00\x00");
+       //9C:(Transaction Type) len:1   |  00 => Goods and service #01 => Cash
+       TLV_ADD(0x9C,   "\x00");
+       // 9F37 Unpredictable Number len:4
+       TLV_ADD(0x9F37, "\x01\x02\x03\x04");
+       // 9F6A Unpredictable Number (MSD for UDOL) len:4
+       TLV_ADD(0x9F6A, "\x01\x02\x03\x04");
+       //9F66:(Terminal Transaction Qualifiers (TTQ)) len:4
+       TLV_ADD(0x9F66, "\x26\x00\x00\x00"); // qVSDC
+ }
  int CmdHFEMVExec(const char *cmd) {
        bool activateField = false;
        bool showAPDU = false;
@@@ -1044,17 -1005,13 +1229,18 @@@ int CmdHFEMVTest(const char *cmd) 
  
  int CmdHelp(const char *Cmd);
  static command_t CommandTable[] =  {
 -      {"help",        CmdHelp,                1,      "This help"},
 -      {"exec",        CmdHFEMVExec,   0,      "Executes EMV contactless transaction."},
 -      {"pse",         CmdHFEMVPPSE,   0,      "Execute PPSE. It selects 2PAY.SYS.DDF01 or 1PAY.SYS.DDF01 directory."},
 -      {"search",      CmdHFEMVSearch, 0,      "Try to select all applets from applets list and print installed applets."},
 -      {"select",      CmdHFEMVSelect, 0,      "Select applet."},
 +      {"help",                CmdHelp,                                                1,      "This help"},
 +      {"exec",                CmdHFEMVExec,                                   0,      "Executes EMV contactless transaction."},
 +      {"pse",                 CmdHFEMVPPSE,                                   0,      "Execute PPSE. It selects 2PAY.SYS.DDF01 or 1PAY.SYS.DDF01 directory."},
 +      {"search",              CmdHFEMVSearch,                                 0,      "Try to select all applets from applets list and print installed applets."},
 +      {"select",              CmdHFEMVSelect,                                 0,      "Select applet."},
 +      {"gpo",                 CmdHFEMVGPO,                                    0,      "Execute GetProcessingOptions."},
 +      {"readrec",             CmdHFEMVReadRecord,                             0,      "Read files from card."},
 +      {"genac",               CmdHFEMVAC,                                             0,      "Generate ApplicationCryptogram."},
 +      {"challenge",   CmdHFEMVGenerateChallenge,              0,      "Generate challenge."},
 +      {"intauth",             CmdHFEMVInternalAuthenticate,   0,      "Internal authentication."},
+ //    {"scan",        CmdHFEMVScan,   0,      "Scan EMV card and save it contents to json file for emulator."},
 -      {"test",        CmdHFEMVTest,   0,      "Crypto logic test."},
 +      {"test",                CmdHFEMVTest,                                   0,      "Crypto logic test."},
        {NULL, NULL, 0, NULL}
  };
  
Impressum, Datenschutz