implement argtable in hf 14a apdu (#490)

* added `hf 14a reader` to source and added functionality to exec empty commands
* added `hf 14a raw`
* added samples to command's help
* added some help
* added changelog
* update to new argtable3 --- https://github.com/argtable/argtable3
* changed included getopt to `https://github.com/freebsd/freebsd/blob/master/include/getopt.h` (getopt from freebsd with simplified BSD license)

CHANGELOG.md

@@ -18,6 +18,7 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
 - Changed `hf 14a raw` - works with LED's and some exchange logic (Merlok)
 - Changed TLV parser messages to more convenient (Merlok)
 - Rewritten Legic Prime reader (`hf legic reader`, `write` and `fill`) - it is using xcorrelation now (AntiCat)
+- `hf 14a` commands works via argtable3 commandline parsing library (Merlok)
 
 ### Fixed
 - Changed start sequence in Qt mode (fix: short commands hangs main Qt thread) (Merlok)

client/Makefile

@@ -106,6 +106,8 @@ CMDSRCS = 	$(SRC_SMARTCARD) \
 			polarssl/bignum.c\
 			polarssl/rsa.c\
 			polarssl/sha1.c\
+			cliparser/argtable3.c\
+			cliparser/cliparser.c\
 			mfkey.c\
 			loclass/cipher.c \
 			loclass/cipherutils.c \

client/cliparser/README.md

@@ -0,0 +1,13 @@
+# Command line parser
+
+cliparser - librari for proxmark with command line parsing high level functions.
+
+## External libraries:
+
+### argtable
+
+Argtable3 is a single-file, ANSI C, command-line parsing library that parses GNU-style command-line options.
+
+You can download argtable3 from this repository https://github.com/argtable/argtable3
+
+[argtable3 license](https://github.com/argtable/argtable3/blob/master/LICENSE)

client/cliparser/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/cliparser/cliparser.c

@@ -0,0 +1,167 @@
+//-----------------------------------------------------------------------------
+// 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.
+//-----------------------------------------------------------------------------
+// Command line parser core commands
+//-----------------------------------------------------------------------------
+
+#include "cliparser.h"
+#include <stdio.h>
+#include <string.h>
+
+void **argtable = NULL;
+size_t argtableLen = 0;
+char *programName = NULL;
+char *programHint = NULL;
+char *programHelp = NULL;
+char buf[500] = {0};
+
+int CLIParserInit(char *vprogramName, char *vprogramHint, char *vprogramHelp) {
+	argtable = NULL;
+	argtableLen = 0;
+	programName = vprogramName;
+	programHint = vprogramHint;
+	programHelp = vprogramHelp;
+	memset(buf, 0x00, 500);
+	
+	return 0;
+}
+
+int CLIParserParseArg(int argc, char **argv, void* vargtable[], size_t vargtableLen, bool allowEmptyExec) { 
+	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 && !allowEmptyExec) ||((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, "    %-20s %s\n");
+		printf("\n");
+		if (programHelp)
+			printf("%s \n", programHelp);
+		
+		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 CLIParserParseString(const char* str, void* vargtable[], size_t vargtableLen, bool allowEmptyExec) {
+	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 CLIParserParseArg(argc, argv, vargtable, vargtableLen, allowEmptyExec);
+}
+
+void CLIParserFree() {
+	arg_freetable(argtable, argtableLen);
+	argtable = NULL;
+	
+	return;
+}
+
+// convertors
+int CLIParamHexToBuf(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/cliparser/cliparser.h

@@ -0,0 +1,32 @@
+//-----------------------------------------------------------------------------
+// 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.
+//-----------------------------------------------------------------------------
+// Command line parser core commands
+//-----------------------------------------------------------------------------
+
+#include "argtable3.h"
+#include "util.h"
+#include <stdbool.h>
+
+#define arg_param_begin arg_lit0("hH",  "help",    "print this help and exit")
+#define arg_param_end arg_end(20)
+
+#define arg_getsize(a) (sizeof(a) / sizeof(a[0]))
+#define arg_get_lit(n)(((struct arg_lit*)argtable[n])->count)
+#define arg_get_int(n)(((struct arg_int*)argtable[n])->ival[0])
+#define arg_get_str(n)((struct arg_str*)argtable[n])
+
+#define CLIExecWithReturn(cmd, atbl, ifempty) if (CLIParserParseString(cmd, atbl, arg_getsize(atbl), ifempty)){CLIParserFree();return 0;}
+#define CLIGetStrBLessWithReturn(paramnum, data, datalen, delta) if (CLIParamHexToBuf(arg_get_str(paramnum), data, sizeof(data) - (delta), datalen)) {CLIParserFree();return 1;}
+#define CLIGetStrWithReturn(paramnum, data, datalen) if (CLIParamHexToBuf(arg_get_str(paramnum), data, sizeof(data), datalen)) {CLIParserFree();return 1;}
+
+extern int CLIParserInit(char *vprogramName, char *vprogramHint, char *vprogramHelp);
+extern int CLIParserParseString(const char* str, void* argtable[], size_t vargtableLen, bool allowEmptyExec);
+extern int CLIParserParseArg(int argc, char **argv, void* argtable[], size_t vargtableLen, bool allowEmptyExec);
+extern void CLIParserFree();
+
+extern int CLIParamHexToBuf(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 "cliparser/cliparser.h"
 #include "emv/apduinfo.h"
 #include "emv/emvcore.h"
 
@@ -137,38 +138,32 @@ int CmdHF14AList(const char *Cmd)
 
 int CmdHF14AReader(const char *Cmd) {
 	uint32_t cm = ISO14A_CONNECT;
-	bool disconnectAfter = true;
+	bool leaveSignalON = false;
 	
-	int cmdp = 0;
-	while(param_getchar(Cmd, cmdp) != 0x00) {
-		switch(param_getchar(Cmd, cmdp)) {
-		case 'h':
-		case 'H':
-			PrintAndLog("Usage: hf 14a reader [k|x] [3]");
-			PrintAndLog("       k    keep the field active after command executed");
-			PrintAndLog("       x    just drop the signal field");
-			PrintAndLog("       3    ISO14443-3 select only (skip RATS)");
-			return 0;
-		case '3':
-			cm |= ISO14A_NO_RATS; 
-			break;
-		case 'k':
-		case 'K':
-			disconnectAfter = false;
-			break;
-		case 'x':
-		case 'X':
-			cm &= ~ISO14A_CONNECT;
-			break;
-		default:
-			PrintAndLog("Unknown command.");
-			return 1;
-		}	
-		
-		cmdp++;
+	CLIParserInit("hf 14a reader", "Executes ISO1443A anticollision-select group of commands.", NULL);
+	void* argtable[] = {
+		arg_param_begin,
+		arg_lit0("kK",  "keep",    "keep the field active after command executed"),
+		arg_lit0("xX",  "drop",    "just drop the signal field"),
+		arg_lit0("3",   NULL,      "ISO14443-3 select only (skip RATS)"),
+		arg_param_end
+	};
+	if (CLIParserParseString(Cmd, argtable, arg_getsize(argtable), true)){
+		CLIParserFree();
+		return 0;
 	}
-
-	if (!disconnectAfter)
+	
+	leaveSignalON = arg_get_lit(1);
+	if (arg_get_lit(2)) {
+		cm = cm - ISO14A_CONNECT;
+	}
+	if (arg_get_lit(3)) {
+		cm |= ISO14A_NO_RATS;
+	}
+	
+	CLIParserFree();
+	
+	if (leaveSignalON)
 		cm |= ISO14A_NO_DISCONNECT; 
 	
 	UsbCommand c = {CMD_READER_ISO_14443a, {cm, 0, 0}};
@@ -200,12 +195,12 @@ int CmdHF14AReader(const char *Cmd) {
 		if(card.ats_len >= 3) {			// a valid ATS consists of at least the length byte (TL) and 2 CRC bytes
 			PrintAndLog(" ATS : %s", sprint_hex(card.ats, card.ats_len));
 		}
-		if (!disconnectAfter) {
+		if (leaveSignalON) {
 			PrintAndLog("Card is selected. You can now start sending commands");
 		}
 	}
 
-	if (disconnectAfter) {
+	if (!leaveSignalON) {
 		PrintAndLog("Field dropped.");
 	}
 	
@@ -737,59 +732,30 @@ int CmdHF14AAPDU(const char *cmd) {
 	bool activateField = false;
 	bool leaveSignalON = false;
 	bool decodeTLV = false;
+
+	CLIParserInit("hf 14a apdu", 
+		"Sends an ISO 7816-4 APDU via ISO 14443-4 block transmission protocol (T=CL)", 
+		"Sample:\n\thf 14a apdu -st 00A404000E325041592E5359532E444446303100\n");
+
+	void* argtable[] = {
+		arg_param_begin,
+		arg_lit0("sS",  "select",  "activate field and select card"),
+		arg_lit0("kK",  "keep",    "leave the signal field ON after receive response"),
+		arg_lit0("tT",  "tlv",     "executes TLV decoder if it possible"),
+		arg_str1(NULL,  NULL,      "<APDU (hex)>", NULL),
+		arg_param_end
+	};
+	CLIExecWithReturn(cmd, argtable, false);
 	
-	if (strlen(cmd) < 2) {
-		PrintAndLog("Usage: hf 14a apdu [-s] [-k] [-t] <APDU (hex)>");
-		PrintAndLog("Command sends an ISO 7816-4 APDU via ISO 14443-4 block transmission protocol (T=CL)");
-		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;
-	}
+	activateField = arg_get_lit(1);
+	leaveSignalON = arg_get_lit(2);
+	decodeTLV = arg_get_lit(3);
+	// len = data + PCB(1b) + CRC(2b)
+	CLIGetStrBLessWithReturn(4, data, &datalen, 1 + 2);
 
-	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((unsigned char)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++;
-	}
 
+	CLIParserFree();
+//	PrintAndLog("---str [%d] %s", arg_get_str(4)->count, arg_get_str(4)->sval[0]);
 	PrintAndLog(">>>>[%s%s%s] %s", activateField ? "sel ": "", leaveSignalON ? "keep ": "", decodeTLV ? "TLV": "", sprint_hex(data, datalen));
 	
 	int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, USB_CMD_DATA_SIZE, &datalen);
@@ -821,102 +787,57 @@ int CmdHF14ACmdRaw(const char *cmd) {
 	bool bTimeout = false;
 	uint32_t timeout = 0;
 	bool topazmode = false;
-	char buf[5]="";
-	int i = 0;
 	uint8_t data[USB_CMD_DATA_SIZE];
-	uint16_t datalen = 0;
-	uint32_t temp;
+	int datalen = 0;
 
-	if (strlen(cmd)<2) {
-		PrintAndLog("Usage: hf 14a raw [-r] [-c] [-p] [-f] [-b] [-t] <number of bits> <0A 0B 0C ... hex>");
-		PrintAndLog("       -r    do not read response");
-		PrintAndLog("       -c    calculate and append CRC");
-		PrintAndLog("       -p    leave the signal field ON after receive");
-		PrintAndLog("       -a    active signal field ON without select");
-		PrintAndLog("       -s    active signal field ON with select");
-		PrintAndLog("       -b    number of bits to send. Useful for send partial byte");
-		PrintAndLog("       -t    timeout in ms");
-		PrintAndLog("       -T    use Topaz protocol to send command");
-		PrintAndLog("       -3    ISO14443-3 select only (skip RATS)");
+	// extract parameters
+	CLIParserInit("hf 14a raw", "Send raw hex data to tag", 
+		"Sample:\n"\
+		"\thf 14a raw -pa -b7 -t1000 52  -- execute WUPA\n"\
+		"\thf 14a raw -p 9320            -- anticollision\n"\
+		"\thf 14a raw -psc 60 00         -- select and mifare AUTH\n");
+	void* argtable[] = {
+		arg_param_begin,
+		arg_lit0("rR",  "nreply",  "do not read response"),
+		arg_lit0("cC",  "crc",     "calculate and append CRC"),
+		arg_lit0("pP",  "power",   "leave the signal field ON after receive"),
+		arg_lit0("aA",  "active",  "active signal field ON without select"),
+		arg_lit0("sS",  "actives", "active signal field ON with select"),
+		arg_int0("bB",  "bits",    NULL, "number of bits to send. Useful for send partial byte"),
+		arg_int0("t",   "timeout", NULL, "timeout in ms"),
+		arg_lit0("T",   "topaz",   "use Topaz protocol to send command"),
+		arg_lit0("3",   NULL,      "ISO14443-3 select only (skip RATS)"),
+		arg_str1(NULL,  NULL,      "<data (hex)>", NULL),
+		arg_param_end
+	};
+	// defaults
+	arg_get_int(6) = 0;
+	arg_get_int(7) = 0;
+	
+	if (CLIParserParseString(cmd, argtable, arg_getsize(argtable), false)){
+		CLIParserFree();
 		return 0;
 	}
-
-
-	// strip
-	while (*cmd==' ' || *cmd=='\t') cmd++;
-
-	while (cmd[i]!='\0') {
-		if (cmd[i]==' ' || cmd[i]=='\t') { i++; continue; }
-		if (cmd[i]=='-') {
-			switch (cmd[i+1]) {
-				case 'r': 
-					reply = false;
-					break;
-				case 'c':
-					crc = true;
-					break;
-				case 'p':
-					power = true;
-					break;
-				case 'a':
-					active = true;
-					break;
-				case 's':
-					active_select = true;
-					break;
-				case 'b': 
-					sscanf(cmd+i+2,"%d",&temp);
-					numbits = temp & 0xFFFF;
-					i+=3;
-					while(cmd[i]!=' ' && cmd[i]!='\0') { i++; }
-					i-=2;
-					break;
-				case 't':
-					bTimeout = true;
-					sscanf(cmd+i+2,"%d",&temp);
-					timeout = temp;
-					i+=3;
-					while(cmd[i]!=' ' && cmd[i]!='\0') { i++; }
-					i-=2;
-					break;
-				case 'T':
-					topazmode = true;
-					break;
-				case '3':
-					no_rats = true;
-					break;
-				default:
-					PrintAndLog("Invalid option");
-					return 0;
-			}
-			i+=2;
-			continue;
-		}
-		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];
-			i++;
-
-			if (strlen(buf)>=2) {
-				sscanf(buf,"%x",&temp);
-				data[datalen]=(uint8_t)(temp & 0xff);
-				*buf=0;
-				if (datalen > sizeof(data)-1) {
-					if (crc)
-						PrintAndLog("Buffer is full, we can't add CRC to your data");
-					break;
-				} else {
-					datalen++;
-				}
-			}
-			continue;
-		}
-		PrintAndLog("Invalid char on input");
-		return 0;
+	
+	reply = !arg_get_lit(1);
+	crc = arg_get_lit(2);
+	power = arg_get_lit(3);
+	active = arg_get_lit(4);
+	active_select = arg_get_lit(5);
+	numbits = arg_get_int(6) & 0xFFFF;
+	timeout = arg_get_int(7);
+	bTimeout = (timeout > 0);	
+	topazmode = arg_get_lit(8);
+	no_rats = arg_get_lit(9);
+	// len = data + CRC(2b)
+	if (CLIParamHexToBuf(arg_get_str(10), data, sizeof(data) -2, &datalen)) {
+		CLIParserFree();
+		return 1;
 	}
-
+	
+	CLIParserFree();	
+	
+	// logic 
 	if(crc && datalen>0 && datalen<sizeof(data)-2)
 	{
 		uint8_t first, second;