implement argtable in hf 14a apdu

client/Makefile

@@ -88,6 +88,8 @@ CMDSRCS = 	crapto1/crapto1.c\
 			crapto1/crypto1.c\
 			polarssl/des.c \
 			polarssl/aes.c\
+			clparser/argtable3.c\
+			clparser/clparser.c\
 			mfkey.c\
 			loclass/cipher.c \
 			loclass/cipherutils.c \
@@ -162,7 +164,7 @@ CMDSRCS = 	crapto1/crapto1.c\
 			reveng/bmpbit.c\
 			reveng/model.c\
 			reveng/poly.c\
-			reveng/getopt.c\
+			#reveng/getopt.c\
 
 cpu_arch = $(shell uname -m)
 ifneq ($(findstring 86, $(cpu_arch)), )

client/clparser/argtable3.h

@@ -0,0 +1,305 @@
+/*******************************************************************************
+ * This file is part of the argtable3 library.
+ *
+ * Copyright (C) 1998-2001,2003-2011,2013 Stewart Heitmann
+ * <sheitmann@users.sourceforge.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of STEWART HEITMANN nor the  names of its contributors
+ *       may be used to endorse or promote products derived from this software
+ *       without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL STEWART HEITMANN BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#ifndef ARGTABLE3
+#define ARGTABLE3
+
+#include <stdio.h>      /* FILE */
+#include <time.h>       /* struct tm */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ARG_REX_ICASE 1
+    
+/* bit masks for arg_hdr.flag */
+enum
+{
+    ARG_TERMINATOR=0x1,
+    ARG_HASVALUE=0x2,
+    ARG_HASOPTVALUE=0x4
+};
+
+typedef void (arg_resetfn)(void *parent);
+typedef int  (arg_scanfn)(void *parent, const char *argval);
+typedef int  (arg_checkfn)(void *parent);
+typedef void (arg_errorfn)(void *parent, FILE *fp, int error, const char *argval, const char *progname);
+
+
+/*
+* The arg_hdr struct defines properties that are common to all arg_xxx structs.
+* The argtable library requires each arg_xxx struct to have an arg_hdr
+* struct as its first data member.
+* The argtable library functions then use this data to identify the
+* properties of the command line option, such as its option tags,
+* datatype string, and glossary strings, and so on.
+* Moreover, the arg_hdr struct contains pointers to custom functions that
+* are provided by each arg_xxx struct which perform the tasks of parsing
+* that particular arg_xxx arguments, performing post-parse checks, and
+* reporting errors.
+* These functions are private to the individual arg_xxx source code
+* and are the pointer to them are initiliased by that arg_xxx struct's
+* constructor function. The user could alter them after construction
+* if desired, but the original intention is for them to be set by the
+* constructor and left unaltered.
+*/
+struct arg_hdr
+{
+    char         flag;        /* Modifier flags: ARG_TERMINATOR, ARG_HASVALUE. */
+    const char  *shortopts;   /* String defining the short options */
+    const char  *longopts;    /* String defiing the long options */
+    const char  *datatype;    /* Description of the argument data type */
+    const char  *glossary;    /* Description of the option as shown by arg_print_glossary function */
+    int          mincount;    /* Minimum number of occurences of this option accepted */
+    int          maxcount;    /* Maximum number of occurences if this option accepted */
+    void        *parent;      /* Pointer to parent arg_xxx struct */
+    arg_resetfn *resetfn;     /* Pointer to parent arg_xxx reset function */
+    arg_scanfn  *scanfn;      /* Pointer to parent arg_xxx scan function */
+    arg_checkfn *checkfn;     /* Pointer to parent arg_xxx check function */
+    arg_errorfn *errorfn;     /* Pointer to parent arg_xxx error function */
+    void        *priv;        /* Pointer to private header data for use by arg_xxx functions */
+};
+
+struct arg_rem
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+};
+
+struct arg_lit
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+};
+
+struct arg_int
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    int *ival;               /* Array of parsed argument values */
+};
+
+struct arg_dbl
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    double *dval;            /* Array of parsed argument values */
+};
+
+struct arg_str
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    const char **sval;       /* Array of parsed argument values */
+};
+
+struct arg_rex
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args */
+    const char **sval;       /* Array of parsed argument values */
+};
+
+struct arg_file
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of matching command line args*/
+    const char **filename;   /* Array of parsed filenames  (eg: /home/foo.bar) */
+    const char **basename;   /* Array of parsed basenames  (eg: foo.bar) */
+    const char **extension;  /* Array of parsed extensions (eg: .bar) */
+};
+
+struct arg_date
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    const char *format;      /* strptime format string used to parse the date */
+    int count;               /* Number of matching command line args */
+    struct tm *tmval;        /* Array of parsed time values */
+};
+
+enum {ARG_ELIMIT=1, ARG_EMALLOC, ARG_ENOMATCH, ARG_ELONGOPT, ARG_EMISSARG};
+struct arg_end
+{
+    struct arg_hdr hdr;      /* The mandatory argtable header struct */
+    int count;               /* Number of errors encountered */
+    int *error;              /* Array of error codes */
+    void **parent;           /* Array of pointers to offending arg_xxx struct */
+    const char **argval;     /* Array of pointers to offending argv[] string */
+};
+
+
+/**** arg_xxx constructor functions *********************************/
+
+struct arg_rem* arg_rem(const char* datatype, const char* glossary);
+
+struct arg_lit* arg_lit0(const char* shortopts,
+    const char* longopts,
+    const char* glossary);
+struct arg_lit* arg_lit1(const char* shortopts,
+    const char* longopts,
+    const char *glossary);
+struct arg_lit* arg_litn(const char* shortopts,
+    const char* longopts,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_key* arg_key0(const char* keyword,
+    int flags,
+    const char* glossary);
+struct arg_key* arg_key1(const char* keyword,
+    int flags,
+    const char* glossary);
+struct arg_key* arg_keyn(const char* keyword,
+    int flags,
+    int mincount,
+    int maxcount,
+    const char* glossary);
+
+struct arg_int* arg_int0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_int* arg_int1(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char *glossary);
+struct arg_int* arg_intn(const char* shortopts,
+    const char* longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_dbl* arg_dbl0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_dbl* arg_dbl1(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char *glossary);
+struct arg_dbl* arg_dbln(const char* shortopts,
+    const char* longopts,
+    const char *datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_str* arg_str0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_str* arg_str1(const char* shortopts,
+    const char* longopts,                    
+    const char* datatype,
+    const char *glossary);
+struct arg_str* arg_strn(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_rex* arg_rex0(const char* shortopts,
+    const char* longopts,
+    const char* pattern,
+    const char* datatype,
+    int flags,
+    const char* glossary);
+struct arg_rex* arg_rex1(const char* shortopts,
+    const char* longopts,
+    const char* pattern,
+    const char* datatype,
+    int flags,
+    const char *glossary);
+struct arg_rex* arg_rexn(const char* shortopts,
+    const char* longopts,
+    const char* pattern,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    int flags,
+    const char *glossary);
+
+struct arg_file* arg_file0(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char* glossary);
+struct arg_file* arg_file1(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    const char *glossary);
+struct arg_file* arg_filen(const char* shortopts,
+    const char* longopts,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_date* arg_date0(const char* shortopts,
+    const char* longopts,
+    const char* format,
+    const char* datatype,
+    const char* glossary);
+struct arg_date* arg_date1(const char* shortopts,
+    const char* longopts,
+    const char* format,
+    const char* datatype,
+    const char *glossary);
+struct arg_date* arg_daten(const char* shortopts,
+    const char* longopts,
+    const char* format,
+    const char* datatype,
+    int mincount,
+    int maxcount,
+    const char *glossary);
+
+struct arg_end* arg_end(int maxerrors);
+
+
+/**** other functions *******************************************/
+int arg_nullcheck(void **argtable);
+int arg_parse(int argc, char **argv, void **argtable);
+void arg_print_option(FILE *fp, const char *shortopts, const char *longopts, const char *datatype, const char *suffix);
+void arg_print_syntax(FILE *fp, void **argtable, const char *suffix);
+void arg_print_syntaxv(FILE *fp, void **argtable, const char *suffix);
+void arg_print_glossary(FILE *fp, void **argtable, const char *format);
+void arg_print_glossary_gnu(FILE *fp, void **argtable);
+void arg_print_errors(FILE* fp, struct arg_end* end, const char* progname);
+void arg_freetable(void **argtable, size_t n);
+
+/**** deprecated functions, for back-compatibility only ********/
+void arg_free(void **argtable);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

client/clparser/clparser.c

@@ -0,0 +1,163 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2017 Merlok
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// EMV commands
+//-----------------------------------------------------------------------------
+
+#include "clparser.h"
+#include <stdio.h>
+#include <string.h>
+
+void **argtable = NULL;
+size_t argtableLen = 0;
+char *programName = NULL;
+char *programHint = NULL;
+char buf[500] = {0};
+
+int CLParserInit(char *vprogramName, char *vprogramHint) {
+	argtable = NULL;
+	argtableLen = 0;
+	programName = vprogramName;
+	programHint = vprogramHint;
+	memset(buf, 0x00, 500);
+	
+	return 0;
+}
+
+int CLParserParseArg(int argc, char **argv, void* vargtable[], size_t vargtableLen) { 
+	int nerrors;
+	
+	argtable = vargtable;
+	argtableLen = vargtableLen;
+	
+	/* verify the argtable[] entries were allocated sucessfully */
+	if (arg_nullcheck(argtable) != 0) {
+		/* NULL entries were detected, some allocations must have failed */
+		printf("ERROR: Insufficient memory\n");
+		return 2;
+	}
+	/* Parse the command line as defined by argtable[] */
+	nerrors = arg_parse(argc, argv, argtable);
+	
+	/* special case: '--help' takes precedence over error reporting */
+	if (argc < 2 ||((struct arg_lit *)argtable[0])->count > 0) { // help must be the first record  
+		printf("Usage: %s", programName);
+		arg_print_syntaxv(stdout, argtable, "\n");
+		if (programHint)
+			printf("%s\n\n", programHint);
+		arg_print_glossary(stdout, argtable, "    %-19s %s\n");
+		printf("\n");
+		
+		return 1;
+	}
+
+	/* If the parser returned any errors then display them and exit */
+	if (nerrors > 0) {
+		/* Display the error details contained in the arg_end struct.*/
+		arg_print_errors(stdout, ((struct arg_end *)argtable[vargtableLen - 1]), programName);
+		printf("Try '%s --help' for more information.\n", programName);
+		
+		return 3;
+	}	
+	
+	return 0;
+}
+
+enum ParserState {
+	PS_FIRST,
+	PS_ARGUMENT,
+	PS_OPTION,
+};
+
+#define isSpace(c)(c == ' ' || c == '\t')
+
+int CLParserParseString(const char* str, void* vargtable[], size_t vargtableLen) {
+	int argc = 0;
+	char *argv[200] = {NULL};
+	
+	int len = strlen(str);
+	char *bufptr = buf;
+	char *spaceptr = NULL;
+	enum ParserState state = PS_FIRST;
+	
+	argv[argc++] = bufptr;	
+	// param0 = program name
+	memcpy(buf, programName, strlen(programName) + 1); // with 0x00
+	bufptr += strlen(programName) + 1;
+	if (len)
+		argv[argc++] = bufptr;	
+	
+	// parse params
+	for (int i = 0; i < len; i++) {
+		switch(state){
+			case PS_FIRST: // first char
+				if (str[i] == '-'){ // first char before space is '-' - next element - option
+					state = PS_OPTION;
+
+					if (spaceptr) {
+						bufptr = spaceptr;
+						*bufptr = 0x00;
+						bufptr++;
+						argv[argc++] = bufptr;	
+					}
+				}
+				spaceptr = NULL;
+			case PS_ARGUMENT:
+				if (state == PS_FIRST)
+					state = PS_ARGUMENT;
+				if (isSpace(str[i])) {
+					spaceptr = bufptr;
+					state = PS_FIRST;
+				}
+				*bufptr = str[i];
+				bufptr++;
+				break;
+			case PS_OPTION:
+				if (isSpace(str[i])){
+					state = PS_FIRST;
+
+					*bufptr = 0x00;
+					bufptr++;
+					argv[argc++] = bufptr;	
+					break;
+				}
+				
+				*bufptr = str[i];
+				bufptr++;
+				break;
+		}
+	}
+
+	return CLParserParseArg(argc, argv, vargtable, vargtableLen);
+}
+
+void CLParserFree() {
+	arg_freetable(argtable, argtableLen);
+	argtable = NULL;
+	
+	return;
+}
+
+// convertors
+int CLParamHexToBuf(struct arg_str *argstr, uint8_t *data, int maxdatalen, int *datalen) {
+	switch(param_gethex_to_eol(argstr->sval[0], 0, data, maxdatalen, datalen)) {
+	case 1:
+		printf("Parameter error: Invalid HEX value.\n");
+		return 1;
+	case 2:
+		printf("Parameter error: parameter too large.\n");
+		return 2;
+	case 3:
+		printf("Parameter error: Hex string must have even number of digits.\n");
+		return 3;
+	}
+	
+	return 0;
+}
+
+
+

client/clparser/clparser.h

@@ -0,0 +1,19 @@
+//-----------------------------------------------------------------------------
+// Copyright (C) 2017 Merlok
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// EMV commands
+//-----------------------------------------------------------------------------
+
+#include "argtable3.h"
+#include "util.h"
+
+extern int CLParserInit(char *vprogramName, char *vprogramHint);
+extern int CLParserParseString(const char* str, void* argtable[], size_t vargtableLen);
+extern int CLParserParseArg(int argc, char **argv, void* argtable[], size_t vargtableLen);
+extern void CLParserFree();
+
+extern int CLParamHexToBuf(struct arg_str *argstr, uint8_t *data, int maxdatalen, int *datalen);

client/cmdhf14a.c

@@ -28,6 +28,7 @@
 #include "mifare.h"
 #include "cmdhfmfu.h"
 #include "mifarehost.h"
+#include "clparser/clparser.h"
 #include "emv/apduinfo.h"
 #include "emv/emvcore.h"
 
@@ -725,57 +726,27 @@ int CmdHF14AAPDU(const char *cmd) {
 	bool activateField = false;
 	bool leaveSignalON = false;
 	bool decodeTLV = false;
-	
-	if (strlen(cmd) < 2) {
-		PrintAndLog("Usage: hf 14a apdu [-s] [-k] [-t] <APDU (hex)>");
-		PrintAndLog("       -s    activate field and select card");
-		PrintAndLog("       -k    leave the signal field ON after receive response");
-		PrintAndLog("       -t    executes TLV decoder if it possible. TODO!!!!");
-		return 0;
-	}
 
-	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 's':
-				case 'S':
-					activateField = true;
-					break;
-				case 'k':
-				case 'K':
-					leaveSignalON = true;
-					break;
-				case 't':
-				case 'T':
-					decodeTLV = true;
-					break;
-				default:
-					PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
-					return 1;
-			}
-			
-		if (isxdigit(c)) {
-			// len = data + PCB(1b) + CRC(2b)
-			switch(param_gethex_to_eol(cmd, cmdp, data, sizeof(data) - 1 - 2, &datalen)) {
-			case 1:
-				PrintAndLog("Invalid HEX value.");
-				return 1;
-			case 2:
-				PrintAndLog("APDU too large.");
-				return 1;
-			case 3:
-				PrintAndLog("Hex must have even number of digits.");
-				return 1;
-			}
-			
-			// we get all the hex to end of line with spaces
-			break;
-		}
-		
-		cmdp++;
-	}
+	CLParserInit("hf 14a apdu", "Send ISO 14443-4 APDU to tag");
+	struct arg_lit *ahelp  = arg_lit0("hH",  "help",    "print this help and exit");
+	struct arg_lit *as     = arg_lit0("sS",  "select",  "activate field and select card");
+	struct arg_lit *ak     = arg_lit0("kK",  "keep",    "leave the signal field ON after receive response");
+	struct arg_lit *at     = arg_lit0("tT",  "tlv",     "executes TLV decoder if it possible");
+	struct arg_str *astr   = arg_str1(NULL,  NULL,      "<APDU (hex)>", NULL);
+	struct arg_end *aend   = arg_end(20);
+	void* argtable[] = {ahelp, as, ak, at, astr, aend};
+	if (CLParserParseString(cmd, argtable, sizeof(argtable) / sizeof(argtable[0])))
+		return 0;
+	
+	activateField = as->count;
+	leaveSignalON = ak->count;
+	decodeTLV = at->count;
+	// len = data + PCB(1b) + CRC(2b)
+	if (CLParamHexToBuf(astr, data, sizeof(data) - 1 -2, &datalen))
+		return 1;
+	
+	CLParserFree();
+//	PrintAndLog("---str [%d] %s", astr->count, astr->sval[0]);
 
 	PrintAndLog(">>>>[%s%s%s] %s", activateField ? "sel ": "", leaveSignalON ? "keep ": "", decodeTLV ? "TLV": "", sprint_hex(data, datalen));
 	

client/reveng/cli.c

@@ -98,7 +98,7 @@ int reveng_main(int argc, char *argv[]) {
 
 	SETBMP();
 	
-	pos=0;
+	//pos=0;
 	optind=1;
 	do {
 		c=getopt(argc, argv, "?A:BDFLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:yz");