[proxmark3-svn] / client / emv / cmdemv.c

//-----------------------------------------------------------------------------
// 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 "cmdemv.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};
	int datalen = 0;
	bool activateField = false;
	bool leaveSignalON = false;
	bool decodeTLV = false;

	if (strlen(cmd) < 1) {
		UsageCmdHFEMVSelect();
		return 0;
	}
	
	SetAPDULogging(false);
	
	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':
					UsageCmdHFEMVSelect();
					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;
				default:
					PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
					return 1;
		}

		if (isxdigit(c)) {
			switch(param_gethex_to_eol(cmd, cmdp, data, sizeof(data), &datalen)) {
			case 1:
				PrintAndLog("Invalid HEX value.");
				return 1;
			case 2:
				PrintAndLog("AID 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++;
	}
	
	// exec
	uint8_t buf[APDU_RES_LEN] = {0};
	size_t len = 0;
	uint16_t sw = 0;
	int res = EMVSelect(activateField, 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 UsageCmdHFEMVSearch(void) {
	PrintAndLog("HELP :  Tries to select all applets from applet list:\n");
	PrintAndLog("Usage:  hf emv search [-s][-k][-a][-t]\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 of selected applets\n");
	PrintAndLog("Samples:");
	PrintAndLog(" hf emv search -s -> select card and search");
	PrintAndLog(" hf emv search -s -t -> select card, search and show result in TLV");
	return 0;
}

int CmdHFEMVSearch(const char *cmd) {

	bool activateField = false;
	bool leaveSignalON = false;
	bool decodeTLV = false;

	if (strlen(cmd) < 1) {
		UsageCmdHFEMVSearch();
		return 0;
	}
	
	SetAPDULogging(false);
	
	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':
					UsageCmdHFEMVSearch();
					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;
				default:
					PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
					return 1;
		}
		cmdp++;
	}

	struct tlvdb *t = NULL;
	const char *al = "Applets list";
	t = tlvdb_fixed(1, strlen(al), (const unsigned char *)al);

	if (EMVSearch(activateField, leaveSignalON, decodeTLV, t)) {
		tlvdb_free(t);
		return 2;
	}
	
	PrintAndLog("Search completed.");

	// print list here
	if (!decodeTLV) {  
		TLVPrintAIDlistFromSelectTLV(t);
	}
	
	tlvdb_free(t);
	
	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) {
	
	uint8_t PSENum = 2;
	bool activateField = false;
	bool leaveSignalON = false;
	bool decodeTLV = false;

	if (strlen(cmd) < 1) {
		UsageCmdHFEMVPPSE();
		return 0;
	}

	SetAPDULogging(false);
	
	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++;
	}
	
	// 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 (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]\n");
	PrintAndLog("  Options:");
	PrintAndLog("  -s       : select card");
	PrintAndLog("  -a       : show APDU reqests and responses\n");
	PrintAndLog("  -t       : TLV decode results\n");
	PrintAndLog("  -f       : force search AID. Search AID instead of execute PPSE.\n");
	PrintAndLog("Samples:");
	PrintAndLog(" hf emv pse -s -> select card");
	PrintAndLog(" hf emv pse -s -t -a -> select card, show responses in TLV, show APDU");
	return 0;
}

#define TLV_ADD(tag, value)( tlvdb_add(tlvRoot, tlvdb_fixed(tag, sizeof(value) - 1, (const unsigned char *)value)) )

int CmdHFEMVExec(const char *cmd) {
	bool activateField = false;
	bool showAPDU = false;
	bool decodeTLV = false;
	bool forceSearch = false;

	uint8_t buf[APDU_RES_LEN] = {0};
	size_t len = 0;
	uint16_t sw = 0;
	uint8_t AID[APDU_AID_LEN] = {0};
	size_t AIDlen = 0;
	
	int res;
	
	if (strlen(cmd) < 1) {
		UsageCmdHFEMVExec();
		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 'h':
				case 'H':
					UsageCmdHFEMVPPSE();
					return 0;
				case 's':
				case 'S':
					activateField = true;
					break;
				case 'a':
				case 'A':
					showAPDU = true;
					break;
				case 't':
				case 'T':
					decodeTLV = true;
					break;
				case 'f':
				case 'F':
					forceSearch = true;
					break;
				default:
					PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
					return 1;
		}
		cmdp++;
	}

	
	// init applets list tree
	struct tlvdb *tlvSelect = NULL;
	const char *al = "Applets list";
	tlvSelect = tlvdb_fixed(1, strlen(al), (const unsigned char *)al);

	// Application Selection
	// https://www.openscdp.org/scripts/tutorial/emv/applicationselection.html
	if (!forceSearch) {
		// PPSE
		PrintAndLog("\n* PPSE.");
		SetAPDULogging(showAPDU);
		res = EMVSearchPSE(activateField, true, decodeTLV, tlvSelect);

		// check PPSE and select application id
		if (!res) {	
			TLVPrintAIDlistFromSelectTLV(tlvSelect);
			EMVSelectApplication(tlvSelect, AID, &AIDlen);
		}
	}
	
	// Search
	if (!AIDlen) {
		PrintAndLog("\n* Search AID in list.");
		SetAPDULogging(false);
		if (EMVSearch(activateField, true, decodeTLV, tlvSelect)) {
			tlvdb_free(tlvSelect);
			return 2;
		}

		// check search and select application id
		TLVPrintAIDlistFromSelectTLV(tlvSelect);
		EMVSelectApplication(tlvSelect, AID, &AIDlen);
	}
	
	// Init TLV tree
	struct tlvdb *tlvRoot = NULL;
	const char *alr = "Root terminal TLV tree";
	tlvRoot = tlvdb_fixed(1, strlen(alr), (const unsigned char *)alr);
	
	// check if we found EMV application on card
	if (!AIDlen) {
		PrintAndLog("Can't select AID. EMV AID not found");
		return 2;
	}
	
	// Select
	PrintAndLog("\n* Selecting AID:%s", sprint_hex_inrow(AID, AIDlen));
	SetAPDULogging(showAPDU);
	res = EMVSelect(false, true, AID, AIDlen, buf, sizeof(buf), &len, &sw, tlvRoot);
	
	if (res) {	
		PrintAndLog("Can't select AID (%d). Exit...", res);
		return 3;
	}
	
	if (decodeTLV)
		TLVPrintFromBuffer(buf, len);
	PrintAndLog("* Selected.");
	
	PrintAndLog("\n* Init transaction parameters.");

    //9F66:(Terminal Transaction Qualifiers (TTQ)) len:4
	TLV_ADD(0x9F66, "\x86\x00\x00\x00"); // MSD
//	TLV_ADD(0x9F66, "\x26\x00\x00\x00"); // qVSDC
//	TLV_ADD(0x9F66, "\x8e\x00\x00\x00"); // CDA
    //9F02:(Amount, Authorised (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");

	TLVPrintFromTLV(tlvRoot); // TODO delete!!!
	
	PrintAndLog("\n* Calc PDOL.");
	struct tlv *pdol_data_tlv = dol_process(tlvdb_get(tlvRoot, 0x9f38, NULL), tlvRoot, 0x83);
	if (!pdol_data_tlv){
		PrintAndLog("ERROR: can't create PDOL TLV.");
		return 4;
	}
	
	size_t pdol_data_tlv_data_len;
	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.");
		return 4;
	}
	PrintAndLog("PDOL data[%d]: %s", pdol_data_tlv_data_len, sprint_hex(pdol_data_tlv_data, pdol_data_tlv_data_len));

	PrintAndLog("\n* GPO.");
	res = EMVGPO(true, pdol_data_tlv_data, pdol_data_tlv_data_len, buf, sizeof(buf), &len, &sw, tlvRoot);
	
	free(pdol_data_tlv);
	
	if (res) {	
		PrintAndLog("GPO error(%d): %4x. Exit...", res, sw);
		return 5;
	}

	// process response template format 1 [id:80  2b AIP + x4b AFL] and format 2 [id:77 TLV]
	if (buf[0] == 0x80) {
		if (decodeTLV){
			PrintAndLog("GPO response format1:");
			TLVPrintFromBuffer(buf, len);
		}
		
		if (len < 4 || (len - 4) % 4) {
			PrintAndLog("ERROR: GPO response format1 parsing error. length=%d", len);
		} else {
			// AIP
			struct tlvdb * f1AIP = tlvdb_fixed(0x82, 2, buf + 2);
			tlvdb_add(tlvRoot, f1AIP);
			if (decodeTLV){
				PrintAndLog("\n* * Decode response format 1 (0x80) AIP and AFL:");
				TLVPrintFromTLV(f1AIP);
			}

			// AFL
			struct tlvdb * f1AFL = tlvdb_fixed(0x94, len - 4, buf + 2 + 2);
			tlvdb_add(tlvRoot, f1AFL);
			if (decodeTLV)
				TLVPrintFromTLV(f1AFL);
		}		
	} else {
		if (decodeTLV)
			TLVPrintFromBuffer(buf, len);
	}
	
	// extract PAN from track2
	{
		const struct tlv *track2 = tlvdb_get(tlvRoot, 0x57, NULL);
		if (!tlvdb_get(tlvRoot, 0x5a, NULL) && track2 && track2->len >= 8) {
			struct tlvdb *pan = GetPANFromTrack2(track2);
			if (pan) {
				tlvdb_add(tlvRoot, pan); 
				
				const struct tlv *pantlv = tlvdb_get(tlvRoot, 0x5a, NULL);	
				PrintAndLog("\n* * Extracted PAN from track2: %s", sprint_hex(pantlv->value, pantlv->len));
			} else {
				PrintAndLog("\n* * WARNING: Can't extract PAN from track2.");
			}
		}
	}
	
	PrintAndLog("\n* Read records from AFL.");
	const struct tlv *AFL = tlvdb_get(tlvRoot, 0x94, NULL);
	if (!AFL || !AFL->len) {
		PrintAndLog("WARNING: AFL not found.");
	}
	
	while(AFL && AFL->len) {
		if (AFL->len % 4) {
			PrintAndLog("ERROR: Wrong AFL length: %d", AFL->len);
			break;
		}

		for (int i = 0; i < AFL->len / 4; i++) {
			uint8_t SFI = AFL->value[i * 4 + 0] >> 3;
			uint8_t SFIstart = AFL->value[i * 4 + 1];
			uint8_t SFIend = AFL->value[i * 4 + 2];
			uint8_t SFIoffline = AFL->value[i * 4 + 3];
			
			PrintAndLog("* * SFI[%02x] start:%02x end:%02x offline:%02x", SFI, SFIstart, SFIend, SFIoffline);
			if (SFI == 0 || SFI == 31 || SFIstart == 0 || SFIstart > SFIend) {
				PrintAndLog("SFI ERROR! Skipped...");
				continue;
			}
			
			for(int n = SFIstart; n <= SFIend; n++) {
				PrintAndLog("* * * SFI[%02x] %d", SFI, n);
				
				res = EMVReadRecord(true, SFI, n, buf, sizeof(buf), &len, &sw, tlvRoot);
				if (res) {
					PrintAndLog("ERROR SFI[%02x]. APDU error %4x", SFI, sw);
					continue;
				}
				
				if (decodeTLV) {
					TLVPrintFromBuffer(buf, len);
					PrintAndLog("");
				}
				
				if (SFIoffline) {
					// here will be offline records storing...
					// dont foget: if (sfi < 11)
				}
			}
		}
		
		break;
	}	
	
	// transaction check
	const struct tlv *AIPtlv = tlvdb_get(tlvRoot, 0x82, NULL);	
	uint16_t AIP = AIPtlv->value[0] + AIPtlv->value[1] * 0x100;
	PrintAndLog("* * AIP=%x", AIP);

	// qVSDC
	{
		// 9F26: Application Cryptogram
		const struct tlv *AC = tlvdb_get(tlvRoot, 0x9F26, NULL);
		if (AC) {
			PrintAndLog("\n--> qVSDC transaction.");
			PrintAndLog("* AC path");
			
			// 9F36: Application Transaction Counter (ATC)
			const struct tlv *ATC = tlvdb_get(tlvRoot, 0x9F36, NULL);
			if (ATC) {
			
				// 9F10: Issuer Application Data - optional
				const struct tlv *IAD = tlvdb_get(tlvRoot, 0x9F10, NULL);

				// print AC data
				PrintAndLog("ATC: %s", sprint_hex(ATC->value, ATC->len));
				PrintAndLog("AC: %s", sprint_hex(AC->value, AC->len));
				if (IAD){
					PrintAndLog("IAD: %s", sprint_hex(IAD->value, IAD->len));
					
					if (IAD->len >= IAD->value[0] + 1) {
						PrintAndLog("\tKey index:  0x%02x", IAD->value[1]);
						PrintAndLog("\tCrypto ver: 0x%02x(%03d)", IAD->value[2], IAD->value[2]);
						PrintAndLog("\tCVR:", sprint_hex(&IAD->value[3], IAD->value[0] - 2));
						struct tlvdb * cvr = tlvdb_fixed(0x20, IAD->value[0] - 2, &IAD->value[3]);
						TLVPrintFromTLVLev(cvr, 1);
					}
				} else {
					PrintAndLog("WARNING: IAD not found.");
				}
				
			} else {
				PrintAndLog("ERROR AC: Application Transaction Counter (ATC) not found.");
			}
		}
	}
	
	// TODO: Mastercard M/CHIP
	{
		const struct tlv *CDOL1 = tlvdb_get(tlvRoot, 0x8c, NULL);
		if (CDOL1 && GetCardPSVendor(AID, AIDlen) == CV_MASTERCARD) { // and m/chip transaction flag
		
		}
	}
		
	// MSD
	if (AIP & 0x8000) {
		PrintAndLog("\n--> MSD transaction.");
		
		
		PrintAndLog("* MSD dCVV path. Check dCVV");

		const struct tlv *track2 = tlvdb_get(tlvRoot, 0x57, NULL);
		if (track2) {
			PrintAndLog("Track2: %s", sprint_hex(track2->value, track2->len));

			struct tlvdb *dCVV = GetdCVVRawFromTrack2(track2);
			PrintAndLog("dCVV raw data:");
			TLVPrintFromTLV(dCVV);
			
			if (GetCardPSVendor(AID, AIDlen) == CV_MASTERCARD) {
				PrintAndLog("\n* Mastercard calculate UDOL");

				// UDOL (9F69)
				const struct tlv *UDOL = tlvdb_get(tlvRoot, 0x9F69, NULL);
				// UDOL(9F69) default: 9F6A (Unpredictable number) 4 bytes
				const struct tlv defUDOL = {
					.tag = 0x01,
					.len = 3,
					.value = (uint8_t *)"\x9f\x6a\x04",
				};
				if (!UDOL)
					PrintAndLog("Use default UDOL.");

				struct tlv *udol_data_tlv = dol_process(UDOL ? UDOL : &defUDOL, tlvRoot, 0x01); // 0x01 - fake tag!
				if (!udol_data_tlv){
					PrintAndLog("ERROR: can't create UDOL TLV.");
					return 4;
				}
				
				size_t udol_data_tlv_data_len;
				unsigned char *udol_data_tlv_data = tlv_encode(udol_data_tlv, &udol_data_tlv_data_len);
				if (!udol_data_tlv_data) {
					PrintAndLog("ERROR: can't create UDOL data.");
					return 4;
				}

				// eliminate fake tag
				udol_data_tlv_data_len -= 2;
				udol_data_tlv_data += 2;
				
				PrintAndLog("UDOL data[%d]: %s", udol_data_tlv_data_len, sprint_hex(udol_data_tlv_data, udol_data_tlv_data_len));
				
				PrintAndLog("\n* Mastercard compute cryptographic checksum(UDOL)");
				
				res = MSCComputeCryptoChecksum(true, udol_data_tlv_data, udol_data_tlv_data_len, buf, sizeof(buf), &len, &sw, tlvRoot);
				if (res) {
					PrintAndLog("ERROR Compute Crypto Checksum. APDU error %4x", sw);
					return 5;
				}
				
				if (decodeTLV) {
					TLVPrintFromBuffer(buf, len);
					PrintAndLog("");
				}

			}
		} else {
			PrintAndLog("ERROR MSD: Track2 data not found.");
		}
	}
	
	// additional contacless EMV commands (fDDA, external authenticate)
	
	
	// DropField
	DropField();
	
	// Destroy TLV's
	tlvdb_free(tlvSelect);
	tlvdb_free(tlvRoot);

	PrintAndLog("\n* Transaction completed.");
	
	return 0;
}

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."},
	{NULL, NULL, 0, NULL}
};

int CmdHFEMV(const char *Cmd) {
	CmdsParse(CommandTable, Cmd);
	return 0;
}

int CmdHelp(const char *Cmd) {
	CmdsHelp(CommandTable);
	return 0;
}
Commit	Line	Data
3c5fce2b OM	1	//-----------------------------------------------------------------------------
	2	// Copyright (C) 2017 Merlok
	3	//
	4	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	5	// at your option, any later version. See the LICENSE.txt file for the text of
	6	// the license.
	7	//-----------------------------------------------------------------------------
	8	// EMV commands
	9	//-----------------------------------------------------------------------------
	10
	11	#include "cmdemv.h"
	12
	13	int UsageCmdHFEMVSelect(void) {
	14	PrintAndLog("HELP : Executes select applet command:\n");
	15	PrintAndLog("Usage: hf emv select [-s][-k][-a][-t] <HEX applet AID>\n");
	16	PrintAndLog(" Options:");
	17	PrintAndLog(" -s : select card");
	18	PrintAndLog(" -k : keep field for next command");
	19	PrintAndLog(" -a : show APDU reqests and responses\n");
	20	PrintAndLog(" -t : TLV decode results\n");
	21	PrintAndLog("Samples:");
	22	PrintAndLog(" hf emv select -s a00000000101 -> select card, select applet");
	23	PrintAndLog(" hf emv select -s -t a00000000101 -> select card, select applet, show result in TLV");
	24	return 0;
	25	}
	26
	27	int CmdHFEMVSelect(const char *cmd) {
	28	uint8_t data[APDU_AID_LEN] = {0};
	29	int datalen = 0;
	30	bool activateField = false;
	31	bool leaveSignalON = false;
	32	bool decodeTLV = false;
	33
	34	if (strlen(cmd) < 1) {
	35	UsageCmdHFEMVSelect();
	36	return 0;
	37	}
	38
	39	SetAPDULogging(false);
	40
	41	int cmdp = 0;
	42	while(param_getchar(cmd, cmdp) != 0x00) {
	43	char c = param_getchar(cmd, cmdp);
	44	if ((c == '-') && (param_getlength(cmd, cmdp) == 2))
	45	switch (param_getchar_indx(cmd, 1, cmdp)) {
	46	case 'h':
	47	case 'H':
	48	UsageCmdHFEMVSelect();
	49	return 0;
	50	case 's':
	51	case 'S':
	52	activateField = true;
	53	break;
	54	case 'k':
	55	case 'K':
	56	leaveSignalON = true;
	57	break;
	58	case 'a':
	59	case 'A':
	60	SetAPDULogging(true);
	61	break;
	62	case 't':
	63	case 'T':
	64	decodeTLV = true;
65	break;
66	default:
67	PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
68	return 1;
69	}
70
71	if (isxdigit(c)) {
72	switch(param_gethex_to_eol(cmd, cmdp, data, sizeof(data), &datalen)) {
73	case 1:
74	PrintAndLog("Invalid HEX value.");
75	return 1;
76	case 2:
77	PrintAndLog("AID too large.");
78	return 1;
79	case 3:
80	PrintAndLog("Hex must have even number of digits.");
81	return 1;
82	}
83
84	// we get all the hex to end of line with spaces
85	break;
86	}
87
88
89	cmdp++;
90	}
91
92	// exec
93	uint8_t buf[APDU_RES_LEN] = {0};
94	size_t len = 0;
95	uint16_t sw = 0;
96	int res = EMVSelect(activateField, leaveSignalON, data, datalen, buf, sizeof(buf), &len, &sw, NULL);
97
98	if (sw)
99	PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff));
100
101	if (res)
102	return res;
103
104	if (decodeTLV)
105	TLVPrintFromBuffer(buf, len);
106
107	return 0;
108	}
109
110	int UsageCmdHFEMVSearch(void) {
111	PrintAndLog("HELP : Tries to select all applets from applet list:\n");
112	PrintAndLog("Usage: hf emv search [-s][-k][-a][-t]\n");
113	PrintAndLog(" Options:");
114	PrintAndLog(" -s : select card");
115	PrintAndLog(" -k : keep field for next command");
116	PrintAndLog(" -a : show APDU reqests and responses\n");
117	PrintAndLog(" -t : TLV decode results of selected applets\n");
118	PrintAndLog("Samples:");
119	PrintAndLog(" hf emv search -s -> select card and search");
120	PrintAndLog(" hf emv search -s -t -> select card, search and show result in TLV");
121	return 0;
122	}
123
124	int CmdHFEMVSearch(const char *cmd) {
125
126	bool activateField = false;
127	bool leaveSignalON = false;
128	bool decodeTLV = false;
129
130	if (strlen(cmd) < 1) {
131	UsageCmdHFEMVSearch();
132	return 0;
133	}
134
135	SetAPDULogging(false);
136
137	int cmdp = 0;
138	while(param_getchar(cmd, cmdp) != 0x00) {
139	char c = param_getchar(cmd, cmdp);
140	if ((c == '-') && (param_getlength(cmd, cmdp) == 2))
141	switch (param_getchar_indx(cmd, 1, cmdp)) {
142	case 'h':
143	case 'H':
144	UsageCmdHFEMVSearch();
145	return 0;
146	case 's':
147	case 'S':
148	activateField = true;
149	break;
150	case 'k':
151	case 'K':
152	leaveSignalON = true;
153	break;
154	case 'a':
155	case 'A':
156	SetAPDULogging(true);
157	break;
158	case 't':
159	case 'T':
160	decodeTLV = true;
161	break;
162	default:
163	PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
164	return 1;
165	}
166	cmdp++;
167	}
168
169	struct tlvdb *t = NULL;
170	const char *al = "Applets list";
171	t = tlvdb_fixed(1, strlen(al), (const unsigned char *)al);
172
173	if (EMVSearch(activateField, leaveSignalON, decodeTLV, t)) {
174	tlvdb_free(t);
175	return 2;
176	}
177
178	PrintAndLog("Search completed.");
179
180	// print list here
181	if (!decodeTLV) {
182	TLVPrintAIDlistFromSelectTLV(t);
183	}
184
185	tlvdb_free(t);
186
187	return 0;
188	}
189
190	int UsageCmdHFEMVPPSE(void) {
191	PrintAndLog("HELP : Executes PSE/PPSE select command. It returns list of applet on the card:\n");
192	PrintAndLog("Usage: hf emv pse [-s][-k][-1][-2][-a][-t]\n");
193	PrintAndLog(" Options:");
194	PrintAndLog(" -s : select card");
195	PrintAndLog(" -k : keep field for next command");
196	PrintAndLog(" -1 : ppse (1PAY.SYS.DDF01)");
197	PrintAndLog(" -2 : pse (2PAY.SYS.DDF01)");
198	PrintAndLog(" -a : show APDU reqests and responses\n");
199	PrintAndLog(" -t : TLV decode results\n");
200	PrintAndLog("Samples:");
201	PrintAndLog(" hf emv pse -s -1 -> select, get pse");
202	PrintAndLog(" hf emv pse -s -k -2 -> select, get ppse, keep field");
203	PrintAndLog(" hf emv pse -s -t -2 -> select, get ppse, show result in TLV");
204	return 0;
205	}
206
207	int CmdHFEMVPPSE(const char *cmd) {
208
209	uint8_t PSENum = 2;
210	bool activateField = false;
211	bool leaveSignalON = false;
212	bool decodeTLV = false;
213
214	if (strlen(cmd) < 1) {
215	UsageCmdHFEMVPPSE();
216	return 0;
217	}
218
219	SetAPDULogging(false);
220
221	int cmdp = 0;
222	while(param_getchar(cmd, cmdp) != 0x00) {
223	char c = param_getchar(cmd, cmdp);
224	if ((c == '-') && (param_getlength(cmd, cmdp) == 2))
225	switch (param_getchar_indx(cmd, 1, cmdp)) {
226	case 'h':
227	case 'H':
228	UsageCmdHFEMVPPSE();
229	return 0;
230	case 's':
231	case 'S':
232	activateField = true;
233	break;
234	case 'k':
235	case 'K':
236	leaveSignalON = true;
237	break;
238	case 'a':
239	case 'A':
240	SetAPDULogging(true);
241	break;
242	case 't':
243	case 'T':
244	decodeTLV = true;
245	break;
246	case '1':
247	PSENum = 1;
248	break;
249	case '2':
250	PSENum = 2;
251	break;
252	default:
253	PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
254	return 1;
255	}
256	cmdp++;
257	}
258
259	// exec
260	uint8_t buf[APDU_RES_LEN] = {0};
261	size_t len = 0;
262	uint16_t sw = 0;
263	int res = EMVSelectPSE(activateField, leaveSignalON, PSENum, buf, sizeof(buf), &len, &sw);
264
265	if (sw)
266	PrintAndLog("APDU response status: %04x - %s", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xff));
267
268	if (res)
269	return res;
270
271
272	if (decodeTLV)
273	TLVPrintFromBuffer(buf, len);
274
275	return 0;
276	}
277
278	int UsageCmdHFEMVExec(void) {
279	PrintAndLog("HELP : Executes EMV contactless transaction:\n");
280	PrintAndLog("Usage: hf emv exec [-s][-a][-t]\n");
281	PrintAndLog(" Options:");
282	PrintAndLog(" -s : select card");
283	PrintAndLog(" -a : show APDU reqests and responses\n");
284	PrintAndLog(" -t : TLV decode results\n");
285	PrintAndLog(" -f : force search AID. Search AID instead of execute PPSE.\n");
286	PrintAndLog("Samples:");
287	PrintAndLog(" hf emv pse -s -> select card");
288	PrintAndLog(" hf emv pse -s -t -a -> select card, show responses in TLV, show APDU");
289	return 0;
290	}
291
292	#define TLV_ADD(tag, value)( tlvdb_add(tlvRoot, tlvdb_fixed(tag, sizeof(value) - 1, (const unsigned char *)value)) )
293
294	int CmdHFEMVExec(const char *cmd) {
295	bool activateField = false;
296	bool showAPDU = false;
297	bool decodeTLV = false;
298	bool forceSearch = false;
299
300	uint8_t buf[APDU_RES_LEN] = {0};
301	size_t len = 0;
302	uint16_t sw = 0;
303	uint8_t AID[APDU_AID_LEN] = {0};
304	size_t AIDlen = 0;
305
306	int res;
307
308	if (strlen(cmd) < 1) {
309	UsageCmdHFEMVExec();
310	return 0;
311	}
312
313	int cmdp = 0;
314	while(param_getchar(cmd, cmdp) != 0x00) {
315	char c = param_getchar(cmd, cmdp);
316	if ((c == '-') && (param_getlength(cmd, cmdp) == 2))
317	switch (param_getchar_indx(cmd, 1, cmdp)) {
318	case 'h':
319	case 'H':
320	UsageCmdHFEMVPPSE();
321	return 0;
322	case 's':
323	case 'S':
324	activateField = true;
325	break;
326	case 'a':
327	case 'A':
328	showAPDU = true;
329	break;
330	case 't':
331	case 'T':
332	decodeTLV = true;
333	break;
334	case 'f':
335	case 'F':
336	forceSearch = true;
337	break;
338	default:
339	PrintAndLog("Unknown parameter '%c'", param_getchar_indx(cmd, 1, cmdp));
340	return 1;
341	}
342	cmdp++;
343	}
344
345
346	// init applets list tree
347	struct tlvdb *tlvSelect = NULL;
348	const char *al = "Applets list";
349	tlvSelect = tlvdb_fixed(1, strlen(al), (const unsigned char *)al);
350
351	// Application Selection
352	// https://www.openscdp.org/scripts/tutorial/emv/applicationselection.html
353	if (!forceSearch) {
354	// PPSE
355	PrintAndLog("\n* PPSE.");
356	SetAPDULogging(showAPDU);
357	res = EMVSearchPSE(activateField, true, decodeTLV, tlvSelect);
358
359	// check PPSE and select application id
360	if (!res) {
361	TLVPrintAIDlistFromSelectTLV(tlvSelect);
362	EMVSelectApplication(tlvSelect, AID, &AIDlen);
363	}
364	}
365
366	// Search
367	if (!AIDlen) {
368	PrintAndLog("\n* Search AID in list.");
369	SetAPDULogging(false);
370	if (EMVSearch(activateField, true, decodeTLV, tlvSelect)) {
371	tlvdb_free(tlvSelect);
372	return 2;
373	}
374
375	// check search and select application id
376	TLVPrintAIDlistFromSelectTLV(tlvSelect);
377	EMVSelectApplication(tlvSelect, AID, &AIDlen);
378	}
379
380	// Init TLV tree
381	struct tlvdb *tlvRoot = NULL;
382	const char *alr = "Root terminal TLV tree";
383	tlvRoot = tlvdb_fixed(1, strlen(alr), (const unsigned char *)alr);
384
385	// check if we found EMV application on card
386	if (!AIDlen) {
387	PrintAndLog("Can't select AID. EMV AID not found");
388	return 2;
389	}
390
391	// Select
392	PrintAndLog("\n* Selecting AID:%s", sprint_hex_inrow(AID, AIDlen));
393	SetAPDULogging(showAPDU);
394	res = EMVSelect(false, true, AID, AIDlen, buf, sizeof(buf), &len, &sw, tlvRoot);
395
396	if (res) {
397	PrintAndLog("Can't select AID (%d). Exit...", res);
398	return 3;
399	}
400
401	if (decodeTLV)
402	TLVPrintFromBuffer(buf, len);
403	PrintAndLog("* Selected.");
404
3c5fce2b OM	405	PrintAndLog("\n* Init transaction parameters.");
	406
	407	//9F66:(Terminal Transaction Qualifiers (TTQ)) len:4
44128a0e	408	TLV_ADD(0x9F66, "\x86\x00\x00\x00"); // MSD
44128a0e	409	// TLV_ADD(0x9F66, "\x26\x00\x00\x00"); // qVSDC
66efdc1f	410	// TLV_ADD(0x9F66, "\x8e\x00\x00\x00"); // CDA
3c5fce2b OM	411	//9F02:(Amount, Authorised (Numeric)) len:6
	412	TLV_ADD(0x9F02, "\x00\x00\x00\x00\x01\x00");
	413	//9F1A:(Terminal Country Code) len:2
	414	TLV_ADD(0x9F1A, "ru");
	415	//5F2A:(Transaction Currency Code) len:2
	416	// USD 840, EUR 978, RUR 810, RUB 643, RUR 810(old), UAH 980, AZN 031, n/a 999
	417	TLV_ADD(0x5F2A, "\x09\x80");
	418	//9A:(Transaction Date) len:3
	419	TLV_ADD(0x9A, "\x00\x00\x00");
	420	//9C:(Transaction Type) len:1 \| 00 => Goods and service #01 => Cash
	421	TLV_ADD(0x9C, "\x00");
	422	// 9F37 Unpredictable Number len:4
	423	TLV_ADD(0x9F37, "\x01\x02\x03\x04");
66efdc1f	424	// 9F6A Unpredictable Number (MSD for UDOL) len:4
66efdc1f	425	TLV_ADD(0x9F6A, "\x01\x02\x03\x04");
3c5fce2b	426
66efdc1f	427	TLVPrintFromTLV(tlvRoot); // TODO delete!!!
3c5fce2b OM	428
	429	PrintAndLog("\n* Calc PDOL.");
	430	struct tlv *pdol_data_tlv = dol_process(tlvdb_get(tlvRoot, 0x9f38, NULL), tlvRoot, 0x83);
	431	if (!pdol_data_tlv){
	432	PrintAndLog("ERROR: can't create PDOL TLV.");
	433	return 4;
	434	}
	435
	436	size_t pdol_data_tlv_data_len;
	437	unsigned char *pdol_data_tlv_data = tlv_encode(pdol_data_tlv, &pdol_data_tlv_data_len);
	438	if (!pdol_data_tlv_data) {
	439	PrintAndLog("ERROR: can't create PDOL data.");
	440	return 4;
	441	}
	442	PrintAndLog("PDOL data[%d]: %s", pdol_data_tlv_data_len, sprint_hex(pdol_data_tlv_data, pdol_data_tlv_data_len));
	443
3c5fce2b OM	444	PrintAndLog("\n* GPO.");
	445	res = EMVGPO(true, pdol_data_tlv_data, pdol_data_tlv_data_len, buf, sizeof(buf), &len, &sw, tlvRoot);
	446
	447	free(pdol_data_tlv);
	448
	449	if (res) {
	450	PrintAndLog("GPO error(%d): %4x. Exit...", res, sw);
	451	return 5;
	452	}
	453
	454	// process response template format 1 [id:80 2b AIP + x4b AFL] and format 2 [id:77 TLV]
	455	if (buf[0] == 0x80) {
3c5fce2b OM	456	if (decodeTLV){
	457	PrintAndLog("GPO response format1:");
	458	TLVPrintFromBuffer(buf, len);
	459	}
3c5fce2b	460
66efdc1f	461	if (len < 4 \|\| (len - 4) % 4) {
	462	PrintAndLog("ERROR: GPO response format1 parsing error. length=%d", len);
	463	} else {
	464	// AIP
	465	struct tlvdb * f1AIP = tlvdb_fixed(0x82, 2, buf + 2);
	466	tlvdb_add(tlvRoot, f1AIP);
	467	if (decodeTLV){
	468	PrintAndLog("\n* * Decode response format 1 (0x80) AIP and AFL:");
	469	TLVPrintFromTLV(f1AIP);
	470	}
	471
	472	// AFL
	473	struct tlvdb * f1AFL = tlvdb_fixed(0x94, len - 4, buf + 2 + 2);
	474	tlvdb_add(tlvRoot, f1AFL);
	475	if (decodeTLV)
	476	TLVPrintFromTLV(f1AFL);
	477	}
	478	} else {
3c5fce2b OM	479	if (decodeTLV)
	480	TLVPrintFromBuffer(buf, len);
	481	}
	482
66efdc1f	483	// extract PAN from track2
	484	{
	485	const struct tlv *track2 = tlvdb_get(tlvRoot, 0x57, NULL);
	486	if (!tlvdb_get(tlvRoot, 0x5a, NULL) && track2 && track2->len >= 8) {
	487	struct tlvdb *pan = GetPANFromTrack2(track2);
	488	if (pan) {
	489	tlvdb_add(tlvRoot, pan);
	490
	491	const struct tlv *pantlv = tlvdb_get(tlvRoot, 0x5a, NULL);
	492	PrintAndLog("\n* * Extracted PAN from track2: %s", sprint_hex(pantlv->value, pantlv->len));
	493	} else {
	494	PrintAndLog("\n* * WARNING: Can't extract PAN from track2.");
	495	}
	496	}
	497	}
	498
3c5fce2b OM	499	PrintAndLog("\n* Read records from AFL.");
	500	const struct tlv *AFL = tlvdb_get(tlvRoot, 0x94, NULL);
	501	if (!AFL \|\| !AFL->len) {
	502	PrintAndLog("WARNING: AFL not found.");
	503	}
	504
	505	while(AFL && AFL->len) {
	506	if (AFL->len % 4) {
	507	PrintAndLog("ERROR: Wrong AFL length: %d", AFL->len);
	508	break;
	509	}
	510
	511	for (int i = 0; i < AFL->len / 4; i++) {
	512	uint8_t SFI = AFL->value[i * 4 + 0] >> 3;
	513	uint8_t SFIstart = AFL->value[i * 4 + 1];
	514	uint8_t SFIend = AFL->value[i * 4 + 2];
	515	uint8_t SFIoffline = AFL->value[i * 4 + 3];
	516
	517	PrintAndLog("* * SFI[%02x] start:%02x end:%02x offline:%02x", SFI, SFIstart, SFIend, SFIoffline);
	518	if (SFI == 0 \|\| SFI == 31 \|\| SFIstart == 0 \|\| SFIstart > SFIend) {
	519	PrintAndLog("SFI ERROR! Skipped...");
	520	continue;
	521	}
	522
	523	for(int n = SFIstart; n <= SFIend; n++) {
	524	PrintAndLog("* * * SFI[%02x] %d", SFI, n);
	525
	526	res = EMVReadRecord(true, SFI, n, buf, sizeof(buf), &len, &sw, tlvRoot);
	527	if (res) {
	528	PrintAndLog("ERROR SFI[%02x]. APDU error %4x", SFI, sw);
	529	continue;
	530	}
	531
	532	if (decodeTLV) {
	533	TLVPrintFromBuffer(buf, len);
	534	PrintAndLog("");
	535	}
	536
	537	if (SFIoffline) {
	538	// here will be offline records storing...
	539	// dont foget: if (sfi < 11)
	540	}
	541	}
	542	}
	543
	544	break;
	545	}
	546
66efdc1f	547	// transaction check
	548	const struct tlv *AIPtlv = tlvdb_get(tlvRoot, 0x82, NULL);
	549	uint16_t AIP = AIPtlv->value[0] + AIPtlv->value[1] * 0x100;
	550	PrintAndLog("* * AIP=%x", AIP);
	551
	552	// qVSDC
	553	{
	554	// 9F26: Application Cryptogram
	555	const struct tlv *AC = tlvdb_get(tlvRoot, 0x9F26, NULL);
	556	if (AC) {
	557	PrintAndLog("\n--> qVSDC transaction.");
	558	PrintAndLog("* AC path");
	559
	560	// 9F36: Application Transaction Counter (ATC)
	561	const struct tlv *ATC = tlvdb_get(tlvRoot, 0x9F36, NULL);
	562	if (ATC) {
	563
	564	// 9F10: Issuer Application Data - optional
	565	const struct tlv *IAD = tlvdb_get(tlvRoot, 0x9F10, NULL);
	566
	567	// print AC data
	568	PrintAndLog("ATC: %s", sprint_hex(ATC->value, ATC->len));
	569	PrintAndLog("AC: %s", sprint_hex(AC->value, AC->len));
	570	if (IAD){
	571	PrintAndLog("IAD: %s", sprint_hex(IAD->value, IAD->len));
	572
	573	if (IAD->len >= IAD->value[0] + 1) {
	574	PrintAndLog("\tKey index: 0x%02x", IAD->value[1]);
	575	PrintAndLog("\tCrypto ver: 0x%02x(%03d)", IAD->value[2], IAD->value[2]);
	576	PrintAndLog("\tCVR:", sprint_hex(&IAD->value[3], IAD->value[0] - 2));
	577	struct tlvdb * cvr = tlvdb_fixed(0x20, IAD->value[0] - 2, &IAD->value[3]);
	578	TLVPrintFromTLVLev(cvr, 1);
	579	}
	580	} else {
	581	PrintAndLog("WARNING: IAD not found.");
	582	}
	583
	584	} else {
	585	PrintAndLog("ERROR AC: Application Transaction Counter (ATC) not found.");
	586	}
	587	}
	588	}
	589
	590	// TODO: Mastercard M/CHIP
	591	{
	592	const struct tlv *CDOL1 = tlvdb_get(tlvRoot, 0x8c, NULL);
	593	if (CDOL1 && GetCardPSVendor(AID, AIDlen) == CV_MASTERCARD) { // and m/chip transaction flag
	594
	595	}
	596	}
	597
	598	// MSD
	599	if (AIP & 0x8000) {
	600	PrintAndLog("\n--> MSD transaction.");
	601
	602
	603	PrintAndLog("* MSD dCVV path. Check dCVV");
	604
	605	const struct tlv *track2 = tlvdb_get(tlvRoot, 0x57, NULL);
	606	if (track2) {
	607	PrintAndLog("Track2: %s", sprint_hex(track2->value, track2->len));
	608
	609	struct tlvdb *dCVV = GetdCVVRawFromTrack2(track2);
	610	PrintAndLog("dCVV raw data:");
611	TLVPrintFromTLV(dCVV);
612
613	if (GetCardPSVendor(AID, AIDlen) == CV_MASTERCARD) {
614	PrintAndLog("\n* Mastercard calculate UDOL");
615
616	// UDOL (9F69)
617	const struct tlv *UDOL = tlvdb_get(tlvRoot, 0x9F69, NULL);
618	// UDOL(9F69) default: 9F6A (Unpredictable number) 4 bytes
619	const struct tlv defUDOL = {
620	.tag = 0x01,
621	.len = 3,
622	.value = (uint8_t *)"\x9f\x6a\x04",
623	};
624	if (!UDOL)
625	PrintAndLog("Use default UDOL.");
626
627	struct tlv *udol_data_tlv = dol_process(UDOL ? UDOL : &defUDOL, tlvRoot, 0x01); // 0x01 - fake tag!
628	if (!udol_data_tlv){
629	PrintAndLog("ERROR: can't create UDOL TLV.");
630	return 4;
631	}
632
633	size_t udol_data_tlv_data_len;
634	unsigned char *udol_data_tlv_data = tlv_encode(udol_data_tlv, &udol_data_tlv_data_len);
635	if (!udol_data_tlv_data) {
636	PrintAndLog("ERROR: can't create UDOL data.");
637	return 4;
638	}
639
640	// eliminate fake tag
641	udol_data_tlv_data_len -= 2;
642	udol_data_tlv_data += 2;
643
644	PrintAndLog("UDOL data[%d]: %s", udol_data_tlv_data_len, sprint_hex(udol_data_tlv_data, udol_data_tlv_data_len));
645
646	PrintAndLog("\n* Mastercard compute cryptographic checksum(UDOL)");
647
648	res = MSCComputeCryptoChecksum(true, udol_data_tlv_data, udol_data_tlv_data_len, buf, sizeof(buf), &len, &sw, tlvRoot);
649	if (res) {
650	PrintAndLog("ERROR Compute Crypto Checksum. APDU error %4x", sw);
651	return 5;
652	}
653
654	if (decodeTLV) {
655	TLVPrintFromBuffer(buf, len);
656	PrintAndLog("");
657	}
658
659	}
660	} else {
661	PrintAndLog("ERROR MSD: Track2 data not found.");
662	}
663	}
664
665	// additional contacless EMV commands (fDDA, external authenticate)
3c5fce2b OM	666
	667
	668	// DropField
	669	DropField();
	670
	671	// Destroy TLV's
	672	tlvdb_free(tlvSelect);
	673	tlvdb_free(tlvRoot);
	674
	675	PrintAndLog("\n* Transaction completed.");
	676
	677	return 0;
	678	}
	679
	680	int CmdHelp(const char *Cmd);
	681	static command_t CommandTable[] = {
	682	{"help", CmdHelp, 1, "This help"},
	683	{"exec", CmdHFEMVExec, 0, "Executes EMV contactless transaction."},
	684	{"pse", CmdHFEMVPPSE, 0, "Execute PPSE. It selects 2PAY.SYS.DDF01 or 1PAY.SYS.DDF01 directory."},
	685	{"search", CmdHFEMVSearch, 0, "Try to select all applets from applets list and print installed applets."},
	686	{"select", CmdHFEMVSelect, 0, "Select applet."},
	687	{NULL, NULL, 0, NULL}
	688	};
	689
	690	int CmdHFEMV(const char *Cmd) {
	691	CmdsParse(CommandTable, Cmd);
	692	return 0;
	693	}
	694
	695	int CmdHelp(const char *Cmd) {
	696	CmdsHelp(CommandTable);
	697	return 0;
	698	}