RfidResearchGroup/proxmark3
1
1
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-01-01 13:14:30 +08:00
Code Issues Projects Releases Packages Wiki Activity
proxmark3/armsrc/emvutil.c

1871 lines
86 KiB
C
Raw Blame History

//-----------------------------------------------------------------------------
// Peter Fillmore 2015
// Many authors, whom made it possible
//
// 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.
//-----------------------------------------------------------------------------
// various EMV related functions.
//-----------------------------------------------------------------------------
#include "emvutil.h"
#define DUMP(varname) Dbprintf("%s=", #varname);
//uint8_t PCB = 0x00; //track Protocol Control Byte externally
//util functions
//print detected tag name over the serial link
int emv_printtag(uint8_t* selected_tag, emvcard* inputcard, uint8_t* outputstring, uint8_t* outputlen)
{
//search tag list and print the match
//get the value of the tag
uint8_t tagvalue[255];
uint8_t tagvaluelen;
emv_lookuptag(selected_tag, inputcard, tagvalue, &tagvaluelen);
//loop through selected tag, print the value found
for(int i=0; i<(sizeof(EMV_TAG_LIST)/sizeof(EMV_TAG_LIST[0])); i++){
if(!memcmp(selected_tag, EMV_TAG_LIST[i].tag, 2)){
memcpy(outputstring, EMV_TAG_LIST[i].description, strlen(EMV_TAG_LIST[i].description));
memcpy(outputstring+(strlen(EMV_TAG_LIST[i].description)), "=", 1);
memcpy(outputstring+(strlen(EMV_TAG_LIST[i].description))+1, tagvalue, tagvaluelen);
*outputlen = strlen(EMV_TAG_LIST[i].description) + 1 + tagvaluelen;
break;
}
}
return 0;
}
//returns the value of the emv tag in the supplied emvcard structure
int emv_lookuptag(uint8_t* tag, emvcard *currentcard, uint8_t* outputval, uint8_t* outputvallen)
{
//loop through tag and return the appropriate value
uint8_t returnedtag[255];
uint8_t returnedlength = 0;
memset(returnedtag, 0x00, sizeof(returnedtag));
if(!memcmp(tag, "\x4F\x00",2)){
memcpy(&returnedtag, currentcard->tag_4F, currentcard->tag_4F_len);
returnedlength = currentcard->tag_4F_len; goto exitfunction;}
else if(!memcmp(tag, "\x50\x00",2)){
memcpy(&returnedtag, currentcard->tag_50, currentcard->tag_50_len);
returnedlength = currentcard->tag_50_len; goto exitfunction;}
else if(!memcmp(tag, "\x56\x00",2)){
memcpy(&returnedtag, currentcard->tag_56, currentcard->tag_56_len);
returnedlength = currentcard->tag_56_len; goto exitfunction;}
else if(!memcmp(tag, "\x57\x00",2)){
memcpy(&returnedtag, currentcard->tag_57, currentcard->tag_57_len);
returnedlength = currentcard->tag_57_len; goto exitfunction;}
else if(!memcmp(tag, "\x5A\x00",2)){
memcpy(&returnedtag, currentcard->tag_5A, currentcard->tag_5A_len);
returnedlength = currentcard->tag_5A_len; goto exitfunction;}
else if(!memcmp(tag, "\x82\x00",2)){
memcpy(&returnedtag, currentcard->tag_82, sizeof(currentcard->tag_82));
returnedlength = sizeof(currentcard->tag_82);goto exitfunction;}
else if(!memcmp(tag, "\x84\x00",2)){
memcpy(&returnedtag, currentcard->tag_84, currentcard->tag_84_len);
returnedlength = currentcard->tag_84_len; goto exitfunction;}
else if(!memcmp(tag, "\x86\x00",2)){
memcpy(&returnedtag, currentcard->tag_86, currentcard->tag_86_len);
returnedlength = currentcard->tag_86_len; goto exitfunction;}
else if(!memcmp(tag, "\x87\x00",2)){
memcpy(&returnedtag, currentcard->tag_87, sizeof(currentcard->tag_87));
returnedlength = sizeof(currentcard->tag_87);goto exitfunction;}
else if(!memcmp(tag, "\x88\x00",2)){
memcpy(&returnedtag, currentcard->tag_88, currentcard->tag_50_len);
returnedlength = sizeof(currentcard->tag_88); goto exitfunction;}
else if(!memcmp(tag, "\x8A\x00",2)){
memcpy(&returnedtag, currentcard->tag_8A, sizeof(currentcard->tag_8A));
returnedlength = sizeof(currentcard->tag_8A);goto exitfunction;}
else if(!memcmp(tag, "\x8C\x00",2)){
memcpy(&returnedtag, currentcard->tag_8C, currentcard->tag_8C_len);
returnedlength = currentcard->tag_8C_len; goto exitfunction;}
else if(!memcmp(tag, "\x8D\x00",2)){
memcpy(&returnedtag, currentcard->tag_8D, currentcard->tag_8D_len);
returnedlength = currentcard->tag_8D_len; goto exitfunction;}
else if(!memcmp(tag, "\x8E\x00",2)){
memcpy(&returnedtag, currentcard->tag_8E, currentcard->tag_8E_len);
returnedlength = currentcard->tag_8E_len; goto exitfunction;}
else if(!memcmp(tag, "\x8F\x00",2)){
memcpy(&returnedtag, currentcard->tag_8F, sizeof(currentcard->tag_8F));
returnedlength = sizeof(currentcard->tag_8F);goto exitfunction;}
else if(!memcmp(tag, "\x90\x00",2)){
memcpy(&returnedtag, currentcard->tag_90, currentcard->tag_90_len);
returnedlength = currentcard->tag_90_len; goto exitfunction;}
else if(!memcmp(tag, "\x92\x00",2)){
memcpy(&returnedtag, currentcard->tag_92, currentcard->tag_92_len);
returnedlength = currentcard->tag_92_len; goto exitfunction;}
else if(!memcmp(tag, "\x93\x00",2)){
memcpy(&returnedtag, currentcard->tag_93, currentcard->tag_93_len);
returnedlength = currentcard->tag_93_len; goto exitfunction;}
else if(!memcmp(tag, "\x94\x00",2)){
memcpy(&returnedtag, currentcard->tag_94, currentcard->tag_94_len);
returnedlength = currentcard->tag_94_len; goto exitfunction;}
else if(!memcmp(tag, "\x95\x00",2)){
memcpy(&returnedtag, currentcard->tag_95, sizeof(currentcard->tag_95));
returnedlength = sizeof(currentcard->tag_95);goto exitfunction;}
else if(!memcmp(tag, "\x97\x00",2)){
memcpy(&returnedtag, currentcard->tag_97, currentcard->tag_97_len);
returnedlength = currentcard->tag_97_len; goto exitfunction;}
else if(!memcmp(tag, "\x98\x00",2)){
memcpy(&returnedtag, currentcard->tag_98, sizeof(currentcard->tag_98));
returnedlength = sizeof(currentcard->tag_98);goto exitfunction;}
else if(!memcmp(tag, "\x99\x00",2)){
memcpy(&returnedtag, currentcard->tag_99, currentcard->tag_99_len);
returnedlength = currentcard->tag_99_len; goto exitfunction;}
else if(!memcmp(tag, "\x9A\x00",2)){
memcpy(&returnedtag, currentcard->tag_9A, sizeof(currentcard->tag_9A));
returnedlength = sizeof(currentcard->tag_9A);goto exitfunction;}
else if(!memcmp(tag, "\x9B\x00",2)){
memcpy(&returnedtag, currentcard->tag_9B, sizeof(currentcard->tag_9B));
returnedlength = sizeof(currentcard->tag_9B);goto exitfunction;}
else if(!memcmp(tag, "\x9C\x00",2)){
memcpy(&returnedtag, currentcard->tag_9C, sizeof(currentcard->tag_9C));
returnedlength = sizeof(currentcard->tag_9C);goto exitfunction;}
else if(!memcmp(tag, "\x9D\x00",2)){
memcpy(&returnedtag, currentcard->tag_9D, currentcard->tag_9D_len);
returnedlength = currentcard->tag_9D_len; goto exitfunction;}
else if(!memcmp(tag, "\x9D\x00",2)){
memcpy(&returnedtag, currentcard->tag_9D, currentcard->tag_9D_len);
returnedlength = currentcard->tag_9D_len; goto exitfunction;}
else if(!memcmp(tag, "\xCD\x00",2)){
memcpy(&returnedtag, currentcard->tag_CD, sizeof(currentcard->tag_CD));
returnedlength = sizeof(currentcard->tag_CD);goto exitfunction;}
else if(!memcmp(tag, "\xCE\x00",2)){
memcpy(&returnedtag, currentcard->tag_CE, sizeof(currentcard->tag_CE));
returnedlength = sizeof(currentcard->tag_CE);goto exitfunction;}
else if(!memcmp(tag, "\xCF\x00",2)){
memcpy(&returnedtag, currentcard->tag_CF, sizeof(currentcard->tag_CF));
returnedlength = sizeof(currentcard->tag_CF);goto exitfunction;}
else if(!memcmp(tag, "\xD7\x00",2)){
memcpy(&returnedtag, currentcard->tag_D7, sizeof(currentcard->tag_D7));
returnedlength = sizeof(currentcard->tag_D7);goto exitfunction;}
else if(!memcmp(tag, "\xD8\x00",2)){
memcpy(&returnedtag, currentcard->tag_D8, sizeof(currentcard->tag_D8));
returnedlength = sizeof(currentcard->tag_D8);goto exitfunction;}
else if(!memcmp(tag, "\xD9\x00",2)){
memcpy(&returnedtag, currentcard->tag_D9, currentcard->tag_D9_len);
returnedlength = currentcard->tag_D9_len;goto exitfunction;}
else if(!memcmp(tag, "\xDA\x00",2)){
memcpy(&returnedtag, currentcard->tag_DA, sizeof(currentcard->tag_DA));
returnedlength = sizeof(currentcard->tag_DA);goto exitfunction;}
else if(!memcmp(tag, "\xDB\x00",2)){
memcpy(&returnedtag, currentcard->tag_DB, sizeof(currentcard->tag_DB));
returnedlength = sizeof(currentcard->tag_DB);goto exitfunction;}
else if(!memcmp(tag, "\xDC\x00",2)){
memcpy(&returnedtag, currentcard->tag_DC, sizeof(currentcard->tag_DC));
returnedlength = sizeof(currentcard->tag_DC);goto exitfunction;}
else if(!memcmp(tag, "\xDD\x00",2)){
memcpy(&returnedtag, currentcard->tag_DD, sizeof(currentcard->tag_DD));
returnedlength = sizeof(currentcard->tag_DD);goto exitfunction;}
else if(!memcmp(tag, "\xA5\x00",2)){
memcpy(&returnedtag, currentcard->tag_A5, currentcard->tag_A5_len);
returnedlength = currentcard->tag_A5_len; goto exitfunction;}
else if(!memcmp(tag, "\xAF\x00",2)){
memcpy(&returnedtag, currentcard->tag_AF, currentcard->tag_AF_len);
returnedlength = currentcard->tag_AF_len; goto exitfunction;}
if(*tag == 0x5F){
if(*(tag+1) == 0x20){
memcpy(&returnedtag, currentcard->tag_5F20, currentcard->tag_5F20_len);
returnedlength = currentcard->tag_5F20_len; goto exitfunction;}
else if(*(tag+1) == 0x24){
memcpy(&returnedtag, currentcard->tag_5F24, sizeof(currentcard->tag_5F24));
returnedlength = sizeof(currentcard->tag_5F24);goto exitfunction;}
else if(*(tag+1) == 0x25){
memcpy(&returnedtag, currentcard->tag_5F25, sizeof(currentcard->tag_5F25));
returnedlength = sizeof(currentcard->tag_5F25);goto exitfunction;}
else if(*(tag+1) == 0x28){
memcpy(&returnedtag, currentcard->tag_5F28, sizeof(currentcard->tag_5F28));
returnedlength = sizeof(currentcard->tag_5F28);goto exitfunction;}
else if(*(tag+1) == 0x2A){
memcpy(&returnedtag, currentcard->tag_5F2A, sizeof(currentcard->tag_5F2A));
returnedlength = sizeof(currentcard->tag_5F2A);goto exitfunction;}
else if(*(tag+1) == 0x2D){
memcpy(&returnedtag, currentcard->tag_5F2D, currentcard->tag_5F2D_len);
returnedlength = currentcard->tag_5F2D_len; goto exitfunction;}
else if(*(tag+1) == 0x30){
memcpy(&returnedtag, currentcard->tag_5F30, sizeof(currentcard->tag_5F30));
returnedlength = sizeof(currentcard->tag_5F30);goto exitfunction;}
else if(*(tag+1) == 0x34){
memcpy(&returnedtag, currentcard->tag_5F34, sizeof(currentcard->tag_5F34));
returnedlength = sizeof(currentcard->tag_5F34);goto exitfunction;}
else if(*(tag+1) == 0x36){
memcpy(&returnedtag, currentcard->tag_5F36, sizeof(currentcard->tag_5F36));
returnedlength = sizeof(currentcard->tag_5F36);goto exitfunction;}
else if(*(tag+1) == 0x50){
memcpy(&returnedtag, currentcard->tag_5F50, currentcard->tag_5F50_len);
returnedlength = currentcard->tag_5F50_len; goto exitfunction;}
else if(*(tag+1) == 0x54){
memcpy(&returnedtag, currentcard->tag_5F54, currentcard->tag_5F54_len);
returnedlength = currentcard->tag_5F54_len; goto exitfunction;}
}
if(*tag == 0x9F) {
if(*(tag+1) == 0x01){
memcpy(&returnedtag, currentcard->tag_9F01, sizeof(currentcard->tag_9F01));
returnedlength = sizeof(currentcard->tag_9F01);goto exitfunction;}
else if(*(tag+1) == 0x02){
memcpy(&returnedtag, currentcard->tag_9F02, sizeof(currentcard->tag_9F02));
returnedlength = sizeof(currentcard->tag_9F02);goto exitfunction;}
else if(*(tag+1) == 0x03){
returnedlength = sizeof(currentcard->tag_9F03);goto exitfunction;}
else if(*(tag+1) == 0x04){
memcpy(&returnedtag, currentcard->tag_9F04, sizeof(currentcard->tag_9F04));
returnedlength = sizeof(currentcard->tag_9F04);goto exitfunction;}
else if(*(tag+1) == 0x05){
memcpy(&returnedtag, currentcard->tag_9F05, currentcard->tag_9F05_len);
returnedlength = currentcard->tag_9F05_len; goto exitfunction;}
else if(*(tag+1) == 0x06){
memcpy(&returnedtag, currentcard->tag_9F06, currentcard->tag_9F06_len);
returnedlength = currentcard->tag_9F06_len; goto exitfunction;}
else if(*(tag+1) == 0x07){
memcpy(&returnedtag, currentcard->tag_9F07, sizeof(currentcard->tag_9F07));
returnedlength = sizeof(currentcard->tag_9F07);goto exitfunction;}
else if(*(tag+1) == 0x08){
memcpy(&returnedtag, currentcard->tag_9F08, sizeof(currentcard->tag_9F08));
returnedlength = sizeof(currentcard->tag_9F08);goto exitfunction;}
else if(*(tag+1) == 0x09){
memcpy(&returnedtag, currentcard->tag_9F09, sizeof(currentcard->tag_9F09));
returnedlength = sizeof(currentcard->tag_9F09);goto exitfunction;}
else if(*(tag+1) == 0x0B){
memcpy(&returnedtag, currentcard->tag_9F0B, currentcard->tag_9F0B_len);
returnedlength = currentcard->tag_9F0B_len; goto exitfunction;}
else if(*(tag+1) == 0x0D){
memcpy(&returnedtag, currentcard->tag_9F0D, sizeof(currentcard->tag_9F0D));
returnedlength = sizeof(currentcard->tag_9F0D); goto exitfunction;}
else if(*(tag+1) == 0x0E){
memcpy(&returnedtag, currentcard->tag_9F0E, sizeof(currentcard->tag_9F0E));
returnedlength = sizeof(currentcard->tag_9F0E); goto exitfunction;}
else if(*(tag+1) == 0x0F){
memcpy(&returnedtag, currentcard->tag_9F0F, sizeof(currentcard->tag_9F0F));
returnedlength = sizeof(currentcard->tag_9F0F); goto exitfunction;}
else if(*(tag+1) == 0x10){
memcpy(&returnedtag, currentcard->tag_9F10, currentcard->tag_9F10_len);
returnedlength = currentcard->tag_9F10_len; goto exitfunction;}
else if(*(tag+1) == 0x11){
memcpy(&returnedtag, currentcard->tag_9F11, sizeof(currentcard->tag_9F11));
returnedlength = sizeof(currentcard->tag_9F11); goto exitfunction;}
else if(*(tag+1) == 0x12){
memcpy(&returnedtag, currentcard->tag_9F12, currentcard->tag_9F12_len);
returnedlength = currentcard->tag_9F12_len; goto exitfunction;}
else if(*(tag+1) == 0x1A){
memcpy(&returnedtag, currentcard->tag_9F1A, sizeof(currentcard->tag_9F1A));
returnedlength = sizeof(currentcard->tag_9F1A); goto exitfunction;}
else if(*(tag+1) == 0x1F){
memcpy(&returnedtag, currentcard->tag_9F1F, currentcard->tag_9F1F_len);
returnedlength = currentcard->tag_9F1F_len; goto exitfunction;}
else if(*(tag+1) == 0x32){
memcpy(&returnedtag, currentcard->tag_9F32, currentcard->tag_9F32_len);
returnedlength = currentcard->tag_9F32_len; goto exitfunction;}
else if(*(tag+1) == 0x34){
memcpy(&returnedtag, currentcard->tag_9F34, sizeof(currentcard->tag_9F34));
returnedlength = sizeof(currentcard->tag_9F34); goto exitfunction;}
else if(*(tag+1) == 0x35){
memcpy(&returnedtag, currentcard->tag_9F35, sizeof(currentcard->tag_9F35));
returnedlength = sizeof(currentcard->tag_9F35); goto exitfunction;}
else if(*(tag+1) == 0x37){
memcpy(&returnedtag, currentcard->tag_9F37, sizeof(currentcard->tag_9F37));
returnedlength = sizeof(currentcard->tag_9F37);goto exitfunction;}
else if(*(tag+1) == 0x38){
memcpy(&returnedtag, currentcard->tag_9F38, currentcard->tag_9F38_len);
returnedlength = currentcard->tag_9F38_len; goto exitfunction;}
else if(*(tag+1) == 0x44){
memcpy(&returnedtag, currentcard->tag_9F44, sizeof(currentcard->tag_9F44));
returnedlength = sizeof(currentcard->tag_9F44);goto exitfunction;}
else if(*(tag+1) == 0x45){
memcpy(&returnedtag, currentcard->tag_9F45, sizeof(currentcard->tag_9F45));
returnedlength = sizeof(currentcard->tag_9F45);goto exitfunction;}
else if(*(tag+1) == 0x46){
memcpy(&returnedtag, currentcard->tag_9F46, currentcard->tag_9F46_len);
returnedlength = currentcard->tag_9F46_len; goto exitfunction;}
else if(*(tag+1) == 0x47){
memcpy(&returnedtag, currentcard->tag_9F47, currentcard->tag_9F47_len);
returnedlength = currentcard->tag_9F47_len; goto exitfunction;}
else if(*(tag+1) == 0x48){
memcpy(&returnedtag, currentcard->tag_9F48, currentcard->tag_9F48_len);
returnedlength = currentcard->tag_9F48_len; goto exitfunction;}
else if(*(tag+1) == 0x49){
memcpy(&returnedtag, currentcard->tag_9F49, currentcard->tag_9F49_len);
returnedlength = currentcard->tag_9F49_len; goto exitfunction;}
else if(*(tag+1) == 0x4A){
memcpy(&returnedtag, currentcard->tag_9F4A, sizeof(currentcard->tag_9F4A));
returnedlength = sizeof(currentcard->tag_9F4A);goto exitfunction;}
else if(*(tag+1) == 0x4B){
memcpy(&returnedtag, currentcard->tag_9F4B, currentcard->tag_9F4B_len);
returnedlength = currentcard->tag_9F4B_len; goto exitfunction;}
else if(*(tag+1) == 0x4C){
memcpy(&returnedtag, currentcard->tag_9F4C, sizeof(currentcard->tag_9F4C));
returnedlength = sizeof(currentcard->tag_9F4C); goto exitfunction;}
else if(*(tag+1) == 0x60){
memcpy(&returnedtag, currentcard->tag_9F60, sizeof(currentcard->tag_9F60));
returnedlength = sizeof(currentcard->tag_9F60);goto exitfunction;}
else if(*(tag+1) == 0x61){
memcpy(&returnedtag, currentcard->tag_9F61, sizeof(currentcard->tag_9F61));
returnedlength = sizeof(currentcard->tag_9F61);goto exitfunction;}
else if(*(tag+1) == 0x62){
memcpy(&returnedtag, currentcard->tag_9F62, sizeof(currentcard->tag_9F62));
returnedlength = sizeof(currentcard->tag_9F62);goto exitfunction;}
else if(*(tag+1) == 0x63){
memcpy(&returnedtag, currentcard->tag_9F63, sizeof(currentcard->tag_9F63));
returnedlength = sizeof(currentcard->tag_9F63);goto exitfunction;}
else if(*(tag+1) == 0x64){
memcpy(&returnedtag, currentcard->tag_9F64, sizeof(currentcard->tag_9F64));
returnedlength = sizeof(currentcard->tag_9F64);goto exitfunction;}
else if(*(tag+1) == 0x65){
memcpy(&returnedtag, currentcard->tag_9F65, sizeof(currentcard->tag_9F65));
returnedlength = sizeof(currentcard->tag_9F65);goto exitfunction;}
else if(*(tag+1) == 0x66){
memcpy(&returnedtag, currentcard->tag_9F66, sizeof(currentcard->tag_9F66));
returnedlength = sizeof(currentcard->tag_9F66);goto exitfunction;}
else if(*(tag+1) == 0x67){
memcpy(&returnedtag, currentcard->tag_9F67, sizeof(currentcard->tag_9F67));
returnedlength = sizeof(currentcard->tag_9F67);goto exitfunction;}
else if(*(tag+1) == 0x68){
memcpy(&returnedtag, currentcard->tag_9F68, currentcard->tag_9F68_len);
returnedlength = currentcard->tag_9F68_len;goto exitfunction;}
else if(*(tag+1) == 0x69){
memcpy(&returnedtag, currentcard->tag_9F69, currentcard->tag_9F69_len);
returnedlength = currentcard->tag_9F69_len; goto exitfunction;}
else if(*(tag+1) == 0x6A){
memcpy(&returnedtag, currentcard->tag_9F6A, sizeof(currentcard->tag_9F6A));
returnedlength = sizeof(currentcard->tag_9F6A);goto exitfunction;}
else if(*(tag+1) == 0x6B){
memcpy(&returnedtag, currentcard->tag_9F6B, currentcard->tag_9F6B_len);
returnedlength = currentcard->tag_9F6B_len; goto exitfunction;}
else if(*(tag+1) == 0x6C){
memcpy(&returnedtag, currentcard->tag_9F6C, sizeof(currentcard->tag_9F6C));
returnedlength = sizeof(currentcard->tag_9F6C);goto exitfunction;}
}
else {
if(!memcmp(tag, "\x61\x00",2)){
memcpy(&returnedtag, currentcard->tag_61, currentcard->tag_61_len);
returnedlength = currentcard->tag_61_len; goto exitfunction;}
else if(!memcmp(tag, "\x6F\x00",2)){
memcpy(&returnedtag, currentcard->tag_6F, currentcard->tag_6F_len);
returnedlength = currentcard->tag_6F_len; goto exitfunction;}
else if(!memcmp(tag, "\xAF\x00",2)){
memcpy(&returnedtag, currentcard->tag_AF, currentcard->tag_AF_len);
returnedlength = currentcard->tag_AF_len; goto exitfunction;}
else if(!memcmp(tag, "\x70\x00",2)){
memcpy(&returnedtag, currentcard->tag_70, currentcard->tag_70_len);
returnedlength = currentcard->tag_70_len; goto exitfunction;}
else if(!memcmp(tag, "\x77\x00",2)){
memcpy(&returnedtag, currentcard->tag_77, currentcard->tag_77_len);
returnedlength = currentcard->tag_77_len; goto exitfunction;}
else if(!memcmp(tag, "\x80\x00",2)){
memcpy(&returnedtag, currentcard->tag_80, currentcard->tag_80_len);
returnedlength = currentcard->tag_80_len; goto exitfunction;}
else if(!memcmp(tag, "\xBF\x0C",2)){
memcpy(&returnedtag, currentcard->tag_BF0C, currentcard->tag_BF0C_len);
returnedlength = currentcard->tag_BF0C_len; goto exitfunction;}
else if(!memcmp(tag, "\xFF\x01",2)){ //special DF tag
memcpy(&returnedtag, currentcard->tag_DFName, currentcard->tag_DFName_len);
returnedlength = currentcard->tag_DFName_len; goto exitfunction;}
}
exitfunction: //goto label to exit search quickly once found
memcpy(outputval, &returnedtag, returnedlength);
*outputvallen = returnedlength;
return 0;
}
//function to
int emv_settag(uint32_t tag, uint8_t *datain, emvcard *currentcard){
char binarydata[255] = {0};
/*
// if((strlen((const char *)datain)%2) != 0){ //must be an even string
// return -1;
// }
// if(strlen((const char *)datain) > 255) {
// return -1;
// }
*/
uint8_t datalen = strlen((const char *)datain) / 2; //length of datain
for(int i = 0; i < strlen((const char *)datain); i += 2){
binarydata[i/2] |= (char)hex2int(datain[i]) << 4;
binarydata[i/2] |= (char)hex2int(datain[i+1]);
}
Dbprintf("BINARYDATA=");
Dbhexdump(datalen,(uint8_t *)binarydata,false);
switch(tag){
case 0x4F:
memcpy(currentcard->tag_4F, binarydata, datalen);
currentcard->tag_4F_len = datalen;
break;
case 0x50:
memcpy(currentcard->tag_50, binarydata, datalen);
currentcard->tag_50_len = datalen;
break;
case 0x56:
memcpy(currentcard->tag_56, binarydata, datalen);
currentcard->tag_56_len = datalen;
break;
case 0x57:
memcpy(currentcard->tag_57, binarydata, datalen);
currentcard->tag_57_len = datalen;
break;
case 0x5a:
memcpy(currentcard->tag_5A, binarydata, datalen);
currentcard->tag_5A_len = datalen;
break;
case 0x61:
memcpy(currentcard->tag_61, binarydata, datalen);
currentcard->tag_61_len = datalen;
break;
case 0x6f:
memcpy(currentcard->tag_6F, binarydata, datalen);
currentcard->tag_6F_len = datalen;
break;
case 0x70:
memcpy(currentcard->tag_70, binarydata, datalen);
currentcard->tag_70_len = datalen;
break;
case 0x77:
memcpy(currentcard->tag_77, binarydata, datalen);
currentcard->tag_77_len = datalen;
break;
case 0x80:
memcpy(currentcard->tag_80, binarydata, datalen);
currentcard->tag_80_len = datalen;
break;
case 0x82:
memcpy(currentcard->tag_82, binarydata, sizeof(currentcard->tag_82));
break;
case 0x84:
memcpy(currentcard->tag_84, binarydata, datalen);
currentcard->tag_84_len = datalen;
break;
case 0x86:
memcpy(currentcard->tag_86, binarydata, datalen);
currentcard->tag_86_len = datalen;
break;
case 0x87:
memcpy(currentcard->tag_87, binarydata, sizeof(currentcard->tag_87));
break;
case 0x88:
memcpy(currentcard->tag_88, binarydata, sizeof(currentcard->tag_88));
break;
case 0x8a:
memcpy(currentcard->tag_8A, binarydata, sizeof(currentcard->tag_8A));
break;
case 0x8c:
memcpy(currentcard->tag_8C, binarydata, datalen);
currentcard->tag_8C_len = datalen;
break;
case 0x8d:
memcpy(currentcard->tag_8D, binarydata, datalen);
currentcard->tag_8D_len = datalen;
break;
case 0x8e:
memcpy(currentcard->tag_8E, binarydata, datalen);
currentcard->tag_8E_len = datalen;
break;
case 0x8f:
memcpy(currentcard->tag_8F, binarydata, sizeof(currentcard->tag_8F));
break;
case 0x90:
memcpy(currentcard->tag_90, binarydata, datalen);
currentcard->tag_90_len = datalen;
break;
case 0x91:
memcpy(currentcard->tag_91, binarydata, datalen);
currentcard->tag_91_len = datalen;
break;
case 0x92:
memcpy(currentcard->tag_92, binarydata, datalen);
currentcard->tag_92_len = datalen;
break;
case 0x93:
memcpy(currentcard->tag_93, binarydata, datalen);
currentcard->tag_93_len = datalen;
break;
case 0x94:
memcpy(currentcard->tag_94, binarydata, datalen);
currentcard->tag_94_len = datalen;
break;
case 0x95:
memcpy(currentcard->tag_95, binarydata, sizeof(currentcard->tag_95));
break;
case 0x97:
memcpy(currentcard->tag_97, binarydata, datalen);
currentcard->tag_97_len = datalen;
break;
case 0x98:
memcpy(currentcard->tag_98, binarydata, sizeof(currentcard->tag_98));
break;
case 0x99:
memcpy(currentcard->tag_99, binarydata, datalen);
currentcard->tag_99_len = datalen;
break;
case 0x9a:
memcpy(currentcard->tag_9A, binarydata, sizeof(currentcard->tag_9A));
break;
case 0x9b:
memcpy(currentcard->tag_9B, binarydata, sizeof(currentcard->tag_9B));
break;
case 0x9c:
memcpy(currentcard->tag_9C, binarydata, sizeof(currentcard->tag_9C));
break;
case 0x9d:
memcpy(currentcard->tag_9D, binarydata, datalen);
currentcard->tag_9D_len = datalen;
break;
case 0xa5:
memcpy(currentcard->tag_A5, binarydata, datalen);
currentcard->tag_A5_len = datalen;
break;
case 0xaf:
memcpy(currentcard->tag_AF, binarydata, datalen);
currentcard->tag_AF_len = datalen;
break;
case 0xcd:
memcpy(currentcard->tag_CD, binarydata, sizeof(currentcard->tag_CD));
break;
case 0xce:
memcpy(currentcard->tag_CE, binarydata, sizeof(currentcard->tag_CE));
break;
case 0xcf:
memcpy(currentcard->tag_CF, binarydata, sizeof(currentcard->tag_CF));
break;
case 0xd7:
memcpy(currentcard->tag_CF, binarydata, sizeof(currentcard->tag_CF));
break;
case 0xd8:
memcpy(currentcard->tag_CF, binarydata, sizeof(currentcard->tag_CF));
break;
case 0xd9:
break;
case 0xda:
memcpy(currentcard->tag_DA, binarydata, sizeof(currentcard->tag_DA));
break;
case 0xdb:
memcpy(currentcard->tag_DB, binarydata, sizeof(currentcard->tag_DB));
break;
case 0xdc:
memcpy(currentcard->tag_DB, binarydata, sizeof(currentcard->tag_DB));
break;
case 0xdd:
memcpy(currentcard->tag_DD, binarydata, sizeof(currentcard->tag_DD));
break;
case 0x5f20:
break;
case 0x5f24:
memcpy(currentcard->tag_5F24, binarydata, sizeof(currentcard->tag_5F24));
break;
case 0x5f25:
memcpy(currentcard->tag_5F25, binarydata, sizeof(currentcard->tag_5F25));
break;
case 0x5f28:
memcpy(currentcard->tag_5F28, binarydata, sizeof(currentcard->tag_5F28));
break;
case 0x5f2a:
memcpy(currentcard->tag_5F2A, binarydata, sizeof(currentcard->tag_5F2A));
break;
case 0x5f2d:
break;
case 0x5f30:
memcpy(currentcard->tag_5F30, binarydata, sizeof(currentcard->tag_5F30));
break;
case 0x5f34:
memcpy(currentcard->tag_5F34, binarydata, sizeof(currentcard->tag_5F34));
break;
case 0x5f36:
memcpy(currentcard->tag_5F36, binarydata, sizeof(currentcard->tag_5F36));
break;
case 0x5f50:
break;
case 0x5f54:
memcpy(currentcard->tag_5F54, binarydata, sizeof(currentcard->tag_5F54));
break;
case 0x9f01:
memcpy(currentcard->tag_9F01, binarydata, sizeof(currentcard->tag_9F01));
break;
case 0x9f02:
memcpy(currentcard->tag_9F02, binarydata, sizeof(currentcard->tag_9F02));
break;
case 0x9f03:
memcpy(currentcard->tag_9F03, binarydata, sizeof(currentcard->tag_9F03));
break;
case 0x9f04:
memcpy(currentcard->tag_9F04, binarydata, sizeof(currentcard->tag_9F04));
break;
case 0x9f05:
memcpy(currentcard->tag_9F05, binarydata, datalen);
currentcard->tag_9F05_len = datalen;
break;
case 0x9f06:
memcpy(currentcard->tag_9F06, binarydata, datalen);
currentcard->tag_9F06_len = datalen;
break;
case 0x9f07:
memcpy(currentcard->tag_9F07, binarydata, sizeof(currentcard->tag_9F07));
break;
case 0x9f08:
memcpy(currentcard->tag_9F08, binarydata, sizeof(currentcard->tag_9F08));
break;
case 0x9f09:
memcpy(currentcard->tag_9F09, binarydata, sizeof(currentcard->tag_9F09));
break;
case 0x9f0b:
memcpy(currentcard->tag_9F0B, binarydata, sizeof(currentcard->tag_9F0B));
break;
case 0x9f0d:
memcpy(currentcard->tag_9F0D, binarydata, sizeof(currentcard->tag_9F0D));
break;
case 0x9f0e:
memcpy(currentcard->tag_9F0E, binarydata, sizeof(currentcard->tag_9F0E));
break;
case 0x9f0f:
memcpy(currentcard->tag_9F0F, binarydata, sizeof(currentcard->tag_9F0F));
break;
case 0x9f10:
memcpy(currentcard->tag_9F10, binarydata, datalen);
currentcard->tag_9F10_len = datalen;break;
case 0x9f11:
memcpy(currentcard->tag_9F11, binarydata, sizeof(currentcard->tag_9F11));
break;
case 0x9f12:
memcpy(currentcard->tag_9F12, binarydata, datalen);
currentcard->tag_9F12_len = datalen;break;
case 0x9f13:
memcpy(currentcard->tag_9F13, binarydata, sizeof(currentcard->tag_9F13));
break;
case 0x9f14:
memcpy(currentcard->tag_9F14, binarydata, sizeof(currentcard->tag_9F14));
break;
case 0x9f15:
memcpy(currentcard->tag_9F15, binarydata, sizeof(currentcard->tag_9F15));
break;
case 0x9f16:
memcpy(currentcard->tag_9F16, binarydata, sizeof(currentcard->tag_9F16));
break;
case 0x9f17:
memcpy(currentcard->tag_9F17, binarydata, sizeof(currentcard->tag_9F17));
break;
case 0x9f18:
memcpy(currentcard->tag_9F18, binarydata, sizeof(currentcard->tag_9F18));
break;
case 0x9f1a:
memcpy(currentcard->tag_9F1A, binarydata, sizeof(currentcard->tag_9F1A));
break;
case 0x9f1b:
memcpy(currentcard->tag_9F1B, binarydata, sizeof(currentcard->tag_9F1B));
break;
case 0x9f1c:
memcpy(currentcard->tag_9F1C, binarydata, sizeof(currentcard->tag_9F1C));
break;
case 0x9f1d:
memcpy(currentcard->tag_9F1D, binarydata, datalen);
currentcard->tag_9F1D_len = datalen;break;
case 0x9f1e:
memcpy(currentcard->tag_9F1E, binarydata, sizeof(currentcard->tag_9F1E));
break;
case 0x9f1f:
memcpy(currentcard->tag_9F1F, binarydata, datalen);
currentcard->tag_9F1F_len = datalen;break;
case 0x9f20:
memcpy(currentcard->tag_9F20, binarydata, datalen);
currentcard->tag_9F20_len = datalen;break;
case 0x9f21:
memcpy(currentcard->tag_9F21, binarydata, sizeof(currentcard->tag_9F21));
break;
case 0x9f22:
memcpy(currentcard->tag_9F22, binarydata, sizeof(currentcard->tag_9F22));
break;
case 0x9f23:
memcpy(currentcard->tag_9F23, binarydata, sizeof(currentcard->tag_9F23));
break;
case 0x9f26:
memcpy(currentcard->tag_9F26, binarydata, sizeof(currentcard->tag_9F26));
break;
case 0x9f27:
memcpy(currentcard->tag_9F27, binarydata, sizeof(currentcard->tag_9F27));
break;
case 0x9f2d:
memcpy(currentcard->tag_9F2D, binarydata, datalen);
currentcard->tag_9F2D_len = datalen;break;
case 0x9f2e:
memcpy(currentcard->tag_9F2E, binarydata, sizeof(currentcard->tag_9F2E));
break;
case 0x9f2f:
memcpy(currentcard->tag_9F2F, binarydata, datalen);
currentcard->tag_9F2F_len = datalen;break;
case 0x9f32:
memcpy(currentcard->tag_9F32, binarydata, datalen);
currentcard->tag_9F32_len = datalen;break;
case 0x9f33:
memcpy(currentcard->tag_9F33, binarydata, sizeof(currentcard->tag_9F33));
break;
case 0x9f34:
memcpy(currentcard->tag_9F34, binarydata, sizeof(currentcard->tag_9F34));
break;
case 0x9f35:
memcpy(currentcard->tag_9F35, binarydata, sizeof(currentcard->tag_9F35));
break;
case 0x9f36:
memcpy(currentcard->tag_9F36, binarydata, sizeof(currentcard->tag_9F36));
break;
case 0x9f37:
memcpy(currentcard->tag_9F37, binarydata, sizeof(currentcard->tag_9F37));
break;
case 0x9f38:
break;
case 0x9f39:
memcpy(currentcard->tag_9F39, binarydata, sizeof(currentcard->tag_9F39));
break;
case 0x9f40:
memcpy(currentcard->tag_9F40, binarydata, sizeof(currentcard->tag_9F40));
break;
case 0x9f41:
memcpy(currentcard->tag_9F41, binarydata, sizeof(currentcard->tag_9F41));
break;
case 0x9f42:
memcpy(currentcard->tag_9F42, binarydata, sizeof(currentcard->tag_9F42));
break;
case 0x9f43:
memcpy(currentcard->tag_9F43, binarydata, sizeof(currentcard->tag_9F43));
break;
case 0x9f44:
memcpy(currentcard->tag_9F44, binarydata, sizeof(currentcard->tag_9F44));
break;
case 0x9f45:
memcpy(currentcard->tag_9F45, binarydata, sizeof(currentcard->tag_9F45));
break;
case 0x9f46:
memcpy(currentcard->tag_9F46, binarydata, datalen);
currentcard->tag_9F46_len = datalen;break;
case 0x9f47:
memcpy(currentcard->tag_9F47, binarydata, datalen);
currentcard->tag_9F47_len = datalen;break;
case 0x9f48:
memcpy(currentcard->tag_9F48, binarydata, datalen);
currentcard->tag_9F48_len = datalen;break;
case 0x9f49:
memcpy(currentcard->tag_9F49, binarydata, datalen);
currentcard->tag_9F49_len = datalen;break;
case 0x9f4a:
memcpy(currentcard->tag_9F4A, binarydata, sizeof(currentcard->tag_9F4A));
break;
case 0x9f4b:
memcpy(currentcard->tag_9F4B, binarydata, datalen);
currentcard->tag_9F4B_len = datalen;break;
case 0x9f4c:
memcpy(currentcard->tag_9F4C, binarydata, sizeof(currentcard->tag_9F4C));
break;
case 0x9f4d:
memcpy(currentcard->tag_9F4D, binarydata, sizeof(currentcard->tag_9F4D));
break;
case 0x9f4e:
memcpy(currentcard->tag_9F4E, binarydata, sizeof(currentcard->tag_9F4E));
break;
case 0x9f60:
memcpy(currentcard->tag_9F60, binarydata, sizeof(currentcard->tag_9F60));
break;
case 0x9f61:
memcpy(currentcard->tag_9F61, binarydata, sizeof(currentcard->tag_9F61));
break;
case 0x9f62:
memcpy(currentcard->tag_9F62, binarydata, sizeof(currentcard->tag_9F62));
break;
case 0x9f63:
memcpy(currentcard->tag_9F63, binarydata, sizeof(currentcard->tag_9F63));
break;
case 0x9f64:
memcpy(currentcard->tag_9F64, binarydata, sizeof(currentcard->tag_9F64));
break;
case 0x9f65:
memcpy(currentcard->tag_9F65, binarydata, sizeof(currentcard->tag_9F65));
break;
case 0x9f66:
memcpy(currentcard->tag_9F66, binarydata, sizeof(currentcard->tag_9F66));
break;
case 0x9f67:
memcpy(currentcard->tag_9F67, binarydata, sizeof(currentcard->tag_9F67));
break;
case 0x9f68:
memcpy(currentcard->tag_9F68, binarydata, datalen);
currentcard->tag_9F68_len = datalen;break;
case 0x9f69:
memcpy(currentcard->tag_9F69, binarydata, datalen);
currentcard->tag_9F69_len = datalen;break;
case 0x9f6a:
memcpy(currentcard->tag_9F6A, binarydata, sizeof(currentcard->tag_9F6A));
break;
case 0x9f6b:
memcpy(currentcard->tag_9F6B, binarydata, sizeof(currentcard->tag_9F6B));
break;
case 0x9f6c:
memcpy(currentcard->tag_9F6C, binarydata, sizeof(currentcard->tag_9F6C));
break;
case 0xbf0c:
memcpy(currentcard->tag_BF0C, binarydata, datalen);
currentcard->tag_BF0C_len = datalen;break;
default:
break;
}
return 0;
}
/* generates an emv template based off tag values supplied */
int emv_generatetemplate(uint8_t* templateval,emvcard* currentcard, uint8_t* returnedval, uint8_t* returnedlen,uint8_t numtags, ...)
{
va_list arguments;
uint8_t* currenttag; //value of the current tag
uint8_t tagval[256]; //buffer to hold the extracted tag value
uint8_t taglen = 0; //extracted tag length
uint8_t bufferval[256];
uint8_t counter = 0;
uint32_t encodedlen = 0;
va_start(arguments, numtags);
for(int x=0; x<numtags; x++){
currenttag = va_arg(arguments, uint8_t*);
emv_lookuptag(currenttag, currentcard, tagval, &taglen);
encode_ber_tlv_item(currenttag, (uint8_t)strlen((const char*)currenttag), tagval, (uint32_t)taglen, bufferval+counter, &encodedlen);
counter +=encodedlen;
}
encode_ber_tlv_item(templateval, strlen((const char*) templateval), bufferval, counter, returnedval, &encodedlen);
*returnedlen = encodedlen;
va_end(arguments);
return 0;
}
//generate a valid pdol list
int emv_generateDOL(uint8_t* DOL, uint8_t DOLlen,emvcard* currentcard,uint8_t* DOLoutput, uint8_t* DOLoutputlen)
{
if(!DOL || !currentcard || !DOLoutput) // null pointer checks
return 1;
//scan through the DOL list and construct the result.
uint8_t i = 0;
uint8_t DOLcounter = 0; //points to the current DOL buffer location
uint8_t scannedtaglen = 0; //length of a scanned tag
uint8_t scannedtag[2] = {0x00,0x00}; //buffer for the scanned tag
uint8_t DOLoutputbuffer[255];
uint8_t retrievedtagvallen;
memset(DOLoutputbuffer,0x00, 255); //clear the output buffer
while(i < DOLlen)
{
//length of DOL tag
if((*(DOL+i) & 0x1F) == 0x1F)
{ scannedtaglen = 2;}
else
{scannedtaglen=1;}
memcpy(scannedtag, DOL+i,scannedtaglen);
//look up tag value and copy
//Dbhexdump(2,scannedtag,false);
emv_lookuptag(scannedtag,currentcard,&(DOLoutputbuffer[DOLcounter]),&retrievedtagvallen);
DOLcounter += (uint8_t)DOL[i+scannedtaglen];
i += scannedtaglen + 1;
memset(scannedtag, 0x00, 2); //clear current tag
}
memcpy(DOLoutput, DOLoutputbuffer, DOLcounter);
*DOLoutputlen = DOLcounter;
return 0;
}
//decode the tag inputted and fill in the supplied structure. clean up the cleanup_passpass function
int emv_emvtags_decode_tag(tlvtag* inputtag, emvcard* currentcard)
{
if(!inputtag || !currentcard) {
return 1;
}
//scan decoded tag
if(*(inputtag->tag) == 0x5F) {
if(*(inputtag->tag+1) == 0x20){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F20)))
return 1;
memcpy(currentcard->tag_5F20, inputtag->value, inputtag->valuelength);
currentcard->tag_5F20_len = inputtag->valuelength;
}
if(*(inputtag->tag+1) == 0x24){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F24)))
return 1;
memcpy(currentcard->tag_5F24, inputtag->value, sizeof(currentcard->tag_5F24));}
if(*(inputtag->tag+1) == 0x25){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F25)))
return 1;
memcpy(currentcard->tag_5F25, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x28){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F28)))
return 1;
memcpy(currentcard->tag_5F28, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x2A){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F2A)))
return 1;
memcpy(currentcard->tag_5F2A, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x2D){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F2D)))
return 1;
memcpy(currentcard->tag_5F2D, inputtag->value, inputtag->valuelength);
currentcard->tag_5F2D_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x30){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F30)))
return 1;
memcpy(currentcard->tag_5F30, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x34){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F34)))
return 1;
memcpy(currentcard->tag_5F34, inputtag->value, sizeof(currentcard->tag_5F34));}
if(*(inputtag->tag+1) == 0x36){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F36)))
return 1;
memcpy(currentcard->tag_5F36, inputtag->value, sizeof(currentcard->tag_5F36));}
if(*(inputtag->tag+1) == 0x50){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F50)))
return 1;
memcpy(currentcard->tag_5F50, inputtag->value, inputtag->valuelength);
currentcard->tag_5F50_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x54){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F54)))
return 1;
memcpy(currentcard->tag_5F54, inputtag->value, inputtag->valuelength);
currentcard->tag_5F54_len = inputtag->valuelength;}
}
if(*(inputtag->tag) == 0x9F){
if(*(inputtag->tag+1) == 0x01){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F01)))
return 1;
memcpy(currentcard->tag_9F01, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x02){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F02)))
return 1;
memcpy(currentcard->tag_9F02, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x03){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F03)))
return 1;
memcpy(currentcard->tag_9F03, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x04){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F04)))
return 1;
memcpy(currentcard->tag_9F04, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x05){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F05)))
return 1;
memcpy(currentcard->tag_9F05, inputtag->value, inputtag->valuelength);
currentcard->tag_9F05_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x06){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F06)))
return 1;
memcpy(currentcard->tag_9F06, inputtag->value, inputtag->valuelength);
currentcard->tag_9F06_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x07){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F07)))
return 1;
memcpy(currentcard->tag_9F07, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x08){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F08)))
return 1;
memcpy(currentcard->tag_9F08, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x09){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F09)))
return 1;
memcpy(currentcard->tag_9F09, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x0B){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0B)))
return 1;
memcpy(currentcard->tag_9F0B, inputtag->value, inputtag->valuelength);
currentcard->tag_9F0B_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x0D){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0D)))
return 1;
memcpy(currentcard->tag_9F0D, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x0E){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0E)))
return 1;
memcpy(currentcard->tag_9F0E, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x0F){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0F)))
return 1;
memcpy(currentcard->tag_9F0F, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x11){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F11)))
return 1;
memcpy(currentcard->tag_9F11, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x12){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F12)))
return 1;
memcpy(currentcard->tag_9F12, inputtag->value, inputtag->valuelength);
currentcard->tag_9F12_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x13){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F13)))
return 1;
memcpy(currentcard->tag_9F13, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x14){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F14)))
return 1;
memcpy(currentcard->tag_9F14, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x15){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F15)))
return 1;
memcpy(currentcard->tag_9F15, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x16){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F16)))
return 1;
memcpy(currentcard->tag_9F16, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x17){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F17)))
return 1;
memcpy(currentcard->tag_9F17, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x18){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F18)))
return 1;
memcpy(currentcard->tag_9F18, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x1A){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1A)))
return 1;
memcpy(currentcard->tag_9F1A, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x1B){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1B)))
return 1;
memcpy(currentcard->tag_9F1B, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x1C){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1C)))
return 1;
memcpy(currentcard->tag_9F1C, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x1D){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1D)))
return 1;
memcpy(currentcard->tag_9F1D, inputtag->value, inputtag->valuelength);
currentcard->tag_9F1D_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x1E){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1E)))
return 1;
memcpy(currentcard->tag_9F1E, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x1F){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1F)))
return 1;
memcpy(currentcard->tag_9F1F, inputtag->value, inputtag->valuelength);
currentcard->tag_9F1F_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x32){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F32)))
return 1;
currentcard->tag_9F32_len = inputtag->valuelength;
memcpy(currentcard->tag_9F32, inputtag->value, inputtag->valuelength);
}
if(*(inputtag->tag+1) == 0x34){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F34)))
return 1;
memcpy(currentcard->tag_9F34, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x35){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F35)))
return 1;
memcpy(currentcard->tag_9F35, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x37){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F37)))
return 1;
memcpy(currentcard->tag_9F37, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x38){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F38)))
return 1;
memcpy(currentcard->tag_9F38, inputtag->value, inputtag->valuelength);
currentcard->tag_9F38_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x44){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F44)))
return 1;
memcpy(currentcard->tag_9F44, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x45){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F45)))
return 1;
memcpy(currentcard->tag_9F45, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x46){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F46)))
return 1;
memcpy(currentcard->tag_9F46, inputtag->value, inputtag->valuelength);
currentcard->tag_9F46_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x47){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F47)))
return 1;
memcpy(currentcard->tag_9F47, inputtag->value, inputtag->valuelength);
currentcard->tag_9F47_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x48){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F48)))
return 1;
memcpy(currentcard->tag_9F48, inputtag->value, inputtag->valuelength);
currentcard->tag_9F48_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x49){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F49)))
return 1;
memcpy(currentcard->tag_9F49, inputtag->value, inputtag->valuelength);
currentcard->tag_9F49_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x4A){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F4A)))
return 1;
memcpy(currentcard->tag_9F4A, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x4B){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F4B)))
return 1;
memcpy(currentcard->tag_9F4B, inputtag->value, inputtag->valuelength);
currentcard->tag_9F4B_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x4C){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F4C)))
return 1;
memcpy(currentcard->tag_9F4C, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x60){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F60)))
return 1;
memcpy(currentcard->tag_9F60, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x61){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F61)))
return 1;
memcpy(currentcard->tag_9F61, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x62){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F62)))
return 1;
memcpy(currentcard->tag_9F62, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x63){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F63)))
return 1;
memcpy(currentcard->tag_9F63, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x64){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F64)))
return 1;
memcpy(currentcard->tag_9F64, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x65){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F65)))
return 1;
memcpy(currentcard->tag_9F65, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x66){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F66)))
return 1;
memcpy(currentcard->tag_9F66, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x67){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F67)))
return 1;
memcpy(currentcard->tag_9F67, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x68){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F68)))
return 1;
memcpy(currentcard->tag_9F68, inputtag->value, inputtag->valuelength);
currentcard->tag_9F68_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x69){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F69)))
return 1;
memcpy(currentcard->tag_9F69, inputtag->value, inputtag->valuelength);
currentcard->tag_9F69_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x6A){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F6A)))
return 1;
memcpy(currentcard->tag_9F6A, inputtag->value, inputtag->valuelength);}
if(*(inputtag->tag+1) == 0x6B){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F6B)))
return 1;
memcpy(currentcard->tag_9F6B, inputtag->value, inputtag->valuelength);
currentcard->tag_9F6B_len = inputtag->valuelength;}
if(*(inputtag->tag+1) == 0x6C){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F6C)))
return 1;
memcpy(currentcard->tag_9F6C, inputtag->value, inputtag->valuelength);}
}
else
{
if(*(inputtag->tag) == 0xBF){ //BF0C
if(*(inputtag->tag+1) == 0x0C){
if(!(inputtag->valuelength <= sizeof(currentcard->tag_BF0C)))
return 1;
memcpy(currentcard->tag_BF0C, inputtag->value, inputtag->valuelength);
currentcard->tag_BF0C_len = inputtag->valuelength;}
}
else if(*(inputtag->tag) == 0x4F){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_4F)))
return 1;
memcpy(currentcard->tag_4F, inputtag->value, inputtag->valuelength);
currentcard->tag_4F_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x50){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_50)))
return 1;
memcpy(currentcard->tag_50, inputtag->value, inputtag->valuelength);
currentcard->tag_50_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x56){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_56)))
return 1;
memcpy(currentcard->tag_56, inputtag->value, inputtag->valuelength);
currentcard->tag_56_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x57){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_57)))
return 1;
memcpy(currentcard->tag_57, inputtag->value, inputtag->valuelength);
currentcard->tag_57_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x5A){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_5A)))
return 1;
memcpy(currentcard->tag_5A, inputtag->value, inputtag->valuelength);
currentcard->tag_5A_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x61){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_61)))
return 1;
memcpy(currentcard->tag_61, inputtag->value, inputtag->valuelength);
currentcard->tag_61_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x6F){ //BF0C
memcpy(currentcard->tag_6F,inputtag->value,inputtag->valuelength);}
else if(*(inputtag->tag) == 0x70){ //BF0C
memcpy(currentcard->tag_70,inputtag->value,inputtag->valuelength);}
else if(*(inputtag->tag) == 0x77){ //BF0C
memcpy(currentcard->tag_77,inputtag->value,inputtag->valuelength);}
else if(*(inputtag->tag) == 0x80){ //BF0C
memcpy(currentcard->tag_80,inputtag->value,inputtag->valuelength);}
else if(*(inputtag->tag) == 0x82){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_82)))
return 1;
memcpy(currentcard->tag_82, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x84){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_84)))
return 1;
memcpy(currentcard->tag_84, inputtag->value, inputtag->valuelength);
currentcard->tag_84_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x86){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_86)))
return 1;
memcpy(currentcard->tag_86, inputtag->value, inputtag->valuelength);
currentcard->tag_86_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x87){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_87)))
return 1;
memcpy(currentcard->tag_87, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x88){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_88)))
return 1;
memcpy(currentcard->tag_88, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x8A){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_8A)))
return 1;
memcpy(currentcard->tag_8A, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x8C){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_8C)))
return 1;
memcpy(currentcard->tag_8C, inputtag->value, inputtag->valuelength);
currentcard->tag_8C_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x8D){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_8D)))
return 1;
memcpy(currentcard->tag_8D, inputtag->value, inputtag->valuelength);
currentcard->tag_8D_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x8E){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_8E)))
return 1;
memcpy(currentcard->tag_8E, inputtag->value, inputtag->valuelength);
currentcard->tag_8E_len = inputtag->valuelength;
}
else if(*(inputtag->tag) == 0x8F){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_8F)))
return 1;
memcpy(currentcard->tag_8F,inputtag->value,sizeof(currentcard->tag_8F));}
else if(*(inputtag->tag) == 0x90){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_90)))
return 1;
memcpy(currentcard->tag_90, inputtag->value, inputtag->valuelength);
currentcard->tag_90_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x92){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_92)))
return 1;
memcpy(currentcard->tag_92, inputtag->value, inputtag->valuelength);
currentcard->tag_92_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x93){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_93)))
return 1;
memcpy(currentcard->tag_93, inputtag->value, inputtag->valuelength);
currentcard->tag_93_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x94){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_94)))
return 1;
memcpy(currentcard->tag_94, inputtag->value, inputtag->valuelength);
currentcard->tag_94_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x95){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_95)))
return 1;
memcpy(currentcard->tag_95, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x97){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_97)))
return 1;
memcpy(currentcard->tag_97, inputtag->value, inputtag->valuelength);
currentcard->tag_97_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x98){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_98)))
return 1;
memcpy(currentcard->tag_98, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x99){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_99)))
return 1;
memcpy(currentcard->tag_99, inputtag->value, inputtag->valuelength);
currentcard->tag_99_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0x9A){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9A)))
return 1;
memcpy(currentcard->tag_9A, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x9B){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9B)))
return 1;
memcpy(currentcard->tag_9B, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x9C){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9C)))
return 1;
memcpy(currentcard->tag_9C, inputtag->value, inputtag->valuelength);}
else if(*(inputtag->tag) == 0x9D){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_9D)))
return 1;
memcpy(currentcard->tag_9D, inputtag->value, inputtag->valuelength);
currentcard->tag_9D_len = inputtag->valuelength;}
else if(*(inputtag->tag) == 0xA5){ //BF0C
if(!(inputtag->valuelength <= sizeof(currentcard->tag_A5)))
return 1;
memcpy(currentcard->tag_A5, inputtag->value, inputtag->valuelength);
currentcard->tag_A5_len = inputtag->valuelength;}
}
return 0;
}
int emv_decode_field(uint8_t* inputfield,uint16_t inputlength, emvcard *result)
{
uint16_t lengthcounter=0;
tlvtag newtag;
//copy result to the testtag
if(!result){
return 1;
}
//loop through and decode template
while(lengthcounter < inputlength)
{
//decode the tlv tag
decode_ber_tlv_item((inputfield+lengthcounter),&newtag);
//write the emvcard strucutre
emv_emvtags_decode_tag(&newtag,result);
//move to next value and decode
lengthcounter += newtag.fieldlength-1;
}
return 0;
}
int emv_select(uint8_t* AID, uint8_t AID_len, void* data)
{
uint16_t selectCmd_len = 4 + 1 + AID_len + 1;
uint8_t selectCmd[selectCmd_len];
selectCmd[0] = 0x00;
selectCmd[1] = 0xA4;
selectCmd[2] = 0x04;
selectCmd[3] = 0x00;
selectCmd[4] = AID_len;
memcpy(&(selectCmd[5]), AID, AID_len);
selectCmd[selectCmd_len-1] = 0x00;
return iso14_apdu(selectCmd, selectCmd_len, data);
}
int emv_selectPPSE()
{
int isOK = 0;
//PPSE directory = "2PAY.SYS.DDF01"
//uint8_t AID[14] = {0x32,0x50,0x41,0x59,0x2E,0x53,0x59,0x53,0x2E,0x44,0x44,0x46,0x30,0x31};
while(true) {
if(!emv_select((uint8_t*)DF_PSE, 14, NULL)){
if(MF_DBGLEVEL >= 1) Dbprintf("SELECT PPSE FAILED");
break;
}
isOK=1;
break;
}
if(MF_DBGLEVEL >= 2) DbpString("SELECT_PPSE Finished");
return isOK;
}
//perform READ RECORD
int emv_readrecord(uint8_t recordnumber, uint8_t sfi, void* data)
{
uint16_t readRecordCmd_len = 5;
uint8_t readRecordCmd[readRecordCmd_len];
readRecordCmd[0] = 0x00;
readRecordCmd[1] = 0xB2;
readRecordCmd[2] = recordnumber;
readRecordCmd[3] = ((sfi << 3) | 0x04);
readRecordCmd[4] = 0x00;
return iso14_apdu(readRecordCmd, readRecordCmd_len, data);
}
int emv_getprocessingoptions(uint8_t* pdol, uint8_t pdol_len, void* data)
{
uint16_t processingCmd_len = 4 + 1 + 2 + pdol_len + 1;
uint8_t processingCmd[processingCmd_len];
processingCmd[0] = 0x80;
processingCmd[1] = 0xA8;
processingCmd[2] = 0x00;
processingCmd[3] = 0x00;
processingCmd[4] = pdol_len + 2;
processingCmd[5] = 0x83; //template
processingCmd[6] = pdol_len;
if(pdol_len > 0){
memcpy(&(processingCmd[7]), pdol, pdol_len);}
processingCmd[processingCmd_len-1] = 0x00;
return iso14_apdu(processingCmd, processingCmd_len, data);
}
int emv_computecryptogram(uint8_t* UDOL, uint8_t UDOL_len, void *data)
{
uint16_t cryptogramCmd_len = 4 + 1 + UDOL_len + 1;
uint8_t cryptogramCmd[cryptogramCmd_len];
cryptogramCmd[0] = 0x80;
cryptogramCmd[1] = 0x2A;
cryptogramCmd[2] = 0x8E;
cryptogramCmd[3] = 0x80;
cryptogramCmd[4] = UDOL_len;
memcpy(&(cryptogramCmd[5]), UDOL, UDOL_len);
cryptogramCmd[cryptogramCmd_len-1] = 0x00;
return iso14_apdu(cryptogramCmd, cryptogramCmd_len, data);
}
int emv_getchallenge(void *data)
{
uint16_t challengeCmd_len = 5;
uint8_t challengeCmd[challengeCmd_len];
challengeCmd[0] = 0x00;
challengeCmd[1] = 0x84;
challengeCmd[2] = 0x00;
challengeCmd[3] = 0x00;
challengeCmd[4] = 0x00;
return iso14_apdu(challengeCmd, challengeCmd_len, data);
}
int emv_loopback(uint8_t* transData , uint8_t transData_len, void *data)
{
uint16_t loopbackCmd_len = 4 + 1 + transData_len + 1;
uint8_t loopbackCmd[loopbackCmd_len];
loopbackCmd[0] = 0x00;
loopbackCmd[1] = 0xEE;
loopbackCmd[2] = 0x00;
loopbackCmd[3] = 0x00;
loopbackCmd[4] = loopbackCmd_len;
memcpy(&(loopbackCmd[5]), transData, transData_len);
return iso14_apdu(loopbackCmd, loopbackCmd_len, data);
}
//generateAC
int emv_generateAC(uint8_t refcontrolparam, uint8_t* cdolinput, uint8_t cdolinputlen, void* data)
{
uint16_t acCmd_len = 4 + 1 + cdolinputlen + 1;
uint8_t acCmd[acCmd_len];
acCmd[0] = 0x80;
acCmd[1] = 0xAE;
acCmd[2] = refcontrolparam;
acCmd[3] = 0x00;
acCmd[4] = cdolinputlen;
memcpy(&(acCmd[5]), cdolinput, cdolinputlen);
acCmd[acCmd_len-1] = 0x00;
Dbhexdump(acCmd_len, acCmd,false);
return iso14_apdu(acCmd, acCmd_len, data);
}
int emv_decodeAFL(uint8_t* AFL, uint8_t AFLlen ){
return 0;
}
//ICEMAN: move to client
//Print out AIP Bit meanings
int emv_decodeAIP(uint8_t* AIP)
{
if ((AIP[0] & AIP_SDA_SUPPORTED) == AIP_SDA_SUPPORTED) Dbprintf("SDA supported");
if ((AIP[0] & AIP_DDA_SUPPORTED) == AIP_DDA_SUPPORTED) Dbprintf("DDA supported");
if ((AIP[0] & AIP_CARDHOLDER_VERIFICATION) == AIP_CARDHOLDER_VERIFICATION) Dbprintf("Cardholder verification is supported");
if ((AIP[0] & AIP_TERMINAL_RISK) == AIP_TERMINAL_RISK) Dbprintf("Terminal risk management is to be performed");
if ((AIP[0] & AIP_ISSUER_AUTH) == AIP_ISSUER_AUTH) Dbprintf("Issuer authentication is supported ");
if ((AIP[0] & AIP_CDA_SUPPORTED) == AIP_CDA_SUPPORTED) Dbprintf("CDA supported");
if ((AIP[1] & AIP_CHIP_SUPPORTED) == AIP_CHIP_SUPPORTED) Dbprintf("Chip supported");
if ((AIP[1] & AIP_MSR_SUPPORTED) == AIP_MSR_SUPPORTED) Dbprintf("MSR supported");
return 0;
}
//ICEMAN: move to client
int emv_decodeCVM(uint8_t* CVM, uint8_t CVMlen)
{
uint8_t counter = 0;
uint32_t amountX = 0;
uint32_t amountY = 0;
amountX = bytes_to_num(CVM, 4);
amountY = bytes_to_num(CVM+4, 4);
counter +=8;
while (counter < CVMlen)
{
if ((CVM[counter] & 0x40) == 0x40){
if ((CVM[counter] & 0x3F)== 0x00){ Dbprintf("Fail CVM processing");}
if ((CVM[counter] & 0x3F) == 0x01){ Dbprintf("Plaintext PIN verification performed by ICC");}
if ((CVM[counter] & 0x3F) == 0x02){ Dbprintf("Enciphered PIN verified online");}
if ((CVM[counter] & 0x3F) == 0x03){ Dbprintf("Plaintext PIN verification performed by ICC and signature (paper)");}
if ((CVM[counter] & 0x3F) == 0x04){ Dbprintf("Enciphered PIN verification performed by ICC");}
if ((CVM[counter] & 0x3F) == 0x05){ Dbprintf("Enciphered PIN verification performed by ICC and signature (paper)");}
if ((CVM[counter] & 0x3F) == 0x30){ Dbprintf("Signature (paper)");}
// iceman, wrong masked used? changed from 0x3f -> 0x7f
if ((CVM[counter] & 0x7F) == 0x40){ Dbprintf("No CVM required");}
counter +=2;
} else {
Dbprintf("Fail cardholder verification if this CVM is unsuccessful");
counter +=2;
}
if (CVM[counter+1] == 0x00){ Dbprintf("Always");}
if (CVM[counter+1] == 0x01){ Dbprintf("If unattended cash");}
if (CVM[counter+1] == 0x02){ Dbprintf("If not unattended cash and not manual cash and not purchase with cashback");}
if (CVM[counter+1] == 0x03){ Dbprintf("If terminal supports the CVM");}
if (CVM[counter+1] == 0x04){ Dbprintf("If manual cash");}
if (CVM[counter+1] == 0x05){ Dbprintf("If purchase with cashback");}
if (CVM[counter+1] == 0x06){ Dbprintf("If transaction is in the application currency and is under %" PRIu32 " value", amountX);}
if (CVM[counter+1] == 0x07){ Dbprintf("If transaction is in the application currency and is over %" PRIu32 " value", amountX);}
if (CVM[counter+1] == 0x08){ Dbprintf("If transaction is in the application currency and is under %" PRIu32 " value", amountY);}
if (CVM[counter+1] == 0x09){ Dbprintf("If transaction is in the application currency and is over %" PRIu32 " value", amountY);}
}
return 0;
}
//simulate a emvcard card
//input is a structure containing values to simulate
//clones an EMV card
void emvsnoop() {
//states
int cardSTATE = EMVEMUL_NOFIELD;
int vHf = 0;
int res;
uint16_t len = 0;
uint8_t* receivedCmd = BigBuf_malloc(MAX_MIFARE_FRAME_SIZE);
uint8_t par[MAX_MIFARE_PARITY_SIZE] = {0x00};
uint8_t rATQA[] = {0x04,0x00};
uint8_t rUIDBCC[] = {0x8F,0x2F,0x27,0xE1, 0x66};
uint8_t rSAK[] = {0x28, 0xB4, 0xFC};
iso14443a_setup(FPGA_HF_ISO14443A_TAGSIM_LISTEN);
bool finished = false;
while (!BUTTON_PRESS() && !finished){
WDT_HIT();
//find reader field
if(cardSTATE == EMVEMUL_NOFIELD){
vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;
if(vHf > EMV_MINFIELDV){
cardSTATE_TO_IDLE();
LED_A_ON();
}
}
if(cardSTATE == EMVEMUL_NOFIELD) continue;
//get data
res = EmGetCmd(receivedCmd, &len, par);
if(res == 2) { //field is off
cardSTATE = EMVEMUL_NOFIELD;
LEDsoff();
continue;
}
else if(res==1){
break; // button press
}
if(len==1 && ((receivedCmd[0] == 0x26 && cardSTATE != EMVEMUL_HALTED) || receivedCmd[0] == 0x52)){
EmSendCmd(rATQA, sizeof(rATQA));
cardSTATE = EMVEMUL_SELECT1;
continue;
}
switch(cardSTATE){
case EMVEMUL_NOFIELD:
case EMVEMUL_HALTED:
case EMVEMUL_IDLE:{
break;
}
case EMVEMUL_SELECT1:{
//select all
if(len==2 && (receivedCmd[0] == 0x93 && receivedCmd[1] == 0x20)) {
EmSendCmd(rUIDBCC, sizeof(rUIDBCC));
break;
}
if(len==2 && (receivedCmd[0] == 0x93 && receivedCmd[1] == 0x70 && memcmp(&receivedCmd[2], rUIDBCC, 4) == 0)) {
EmSendCmd(rSAK, sizeof(rSAK));
break;
}
}
}
}
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff();
}
//ICEMAN: move to client
//dump the current card to the console
void dumpCard(emvcard* currentcard){
DUMP(currentcard->ATQA);
Dbhexdump(sizeof(currentcard->ATQA), currentcard->ATQA, false);
DUMP(currentcard->UID);
Dbhexdump(currentcard->UID_len, currentcard->UID, false);
DUMP(currentcard->SAK);
Dbhexdump(1, &currentcard->SAK, false);
DUMP(currentcard->ATS);
Dbhexdump(currentcard->ATS_len, currentcard->ATS, false);
DUMP(currentcard->tag_4F);
Dbhexdump(currentcard->tag_4F_len, currentcard->tag_4F, false);
DUMP(currentcard->tag_50);
Dbhexdump(currentcard->tag_50_len, currentcard->tag_50, false);
DUMP(currentcard->tag_56);
Dbhexdump(currentcard->tag_56_len, currentcard->tag_56, false);
DUMP(currentcard->tag_57);
Dbhexdump(currentcard->tag_57_len, currentcard->tag_57, false);
DUMP(currentcard->tag_5A);
Dbhexdump(currentcard->tag_5A_len, currentcard->tag_5A, false);
DUMP(currentcard->tag_82);
Dbhexdump(sizeof(currentcard->tag_82), currentcard->tag_82, false);
DUMP(currentcard->tag_84);
Dbhexdump(currentcard->tag_84_len, currentcard->tag_84, false);
DUMP(currentcard->tag_86);
Dbhexdump(currentcard->tag_86_len, currentcard->tag_86, false);
DUMP(currentcard->tag_87);
Dbhexdump(1, currentcard->tag_87, false);
DUMP(currentcard->tag_88);
Dbhexdump(1, currentcard->tag_88, false);
DUMP(currentcard->tag_8A);
Dbhexdump(2, currentcard->tag_8A, false);
DUMP(currentcard->tag_8C);
Dbhexdump(currentcard->tag_8C_len, currentcard->tag_8C, false);
DUMP(currentcard->tag_8D);
Dbhexdump(currentcard->tag_8D_len, currentcard->tag_8D, false);
DUMP(currentcard->tag_8E);
Dbhexdump(currentcard->tag_8E_len, currentcard->tag_8E, false);
DUMP(currentcard->tag_8F);
Dbhexdump(1, currentcard->tag_8F, false);
DUMP(currentcard->tag_90);
Dbhexdump(currentcard->tag_90_len, currentcard->tag_90, false);
DUMP(currentcard->tag_92);
Dbhexdump(currentcard->tag_92_len, currentcard->tag_92, false);
DUMP(currentcard->tag_93);
Dbhexdump(currentcard->tag_93_len, currentcard->tag_93, false);
DUMP(currentcard->tag_94);
Dbhexdump(currentcard->tag_94_len, currentcard->tag_94, false);
DUMP(currentcard->tag_95);
Dbhexdump(5, currentcard->tag_95, false);
DUMP(currentcard->tag_97);
Dbhexdump(currentcard->tag_97_len, currentcard->tag_97, false);
DUMP(currentcard->tag_98);
Dbhexdump(20, currentcard->tag_98, false);
DUMP(currentcard->tag_99);
Dbhexdump(currentcard->tag_99_len, currentcard->tag_99, false);
DUMP(currentcard->tag_9A);
Dbhexdump(3, currentcard->tag_9A, false);
DUMP(currentcard->tag_9B);
Dbhexdump(2, currentcard->tag_9B, false);
DUMP(currentcard->tag_9C);
Dbhexdump(1, currentcard->tag_9C, false);
DUMP(currentcard->tag_9D);
Dbhexdump(currentcard->tag_9D_len, currentcard->tag_9D, false);
DUMP(currentcard->tag_CD);
Dbhexdump(3, currentcard->tag_CD, false);
DUMP(currentcard->tag_CE);
Dbhexdump(3, currentcard->tag_CE, false);
DUMP(currentcard->tag_CF);
Dbhexdump(3, currentcard->tag_CF, false);
DUMP(currentcard->tag_D7);
Dbhexdump(3, currentcard->tag_D7, false);
DUMP(currentcard->tag_D8);
Dbhexdump(2, currentcard->tag_D8, false);
DUMP(currentcard->tag_D9);
Dbhexdump(currentcard->tag_D9_len, currentcard->tag_D9, false);
DUMP(currentcard->tag_DA);
Dbhexdump(2, currentcard->tag_DA, false);
DUMP(currentcard->tag_DB);
Dbhexdump(2, currentcard->tag_DB, false);
DUMP(currentcard->tag_DC);
Dbhexdump(2, currentcard->tag_DC, false);
DUMP(currentcard->tag_DD);
Dbhexdump(2, currentcard->tag_DD, false);
DUMP(currentcard->tag_AF);
Dbhexdump(currentcard->tag_AF_len, currentcard->tag_AF, false);
DUMP(currentcard->tag_5F20);
Dbhexdump(currentcard->tag_5F20_len, currentcard->tag_5F20, false);
DUMP(currentcard->tag_5F24);
Dbhexdump(3, currentcard->tag_5F24, false);
DUMP(currentcard->tag_5F25);
Dbhexdump(3, currentcard->tag_5F25, false);
DUMP(currentcard->tag_5F28);
Dbhexdump(2, currentcard->tag_5F28, false);
DUMP(currentcard->tag_5F2A);
Dbhexdump(2, currentcard->tag_5F2A, false);
DUMP(currentcard->tag_5F2D);
Dbhexdump(currentcard->tag_5F2D_len, currentcard->tag_5F2D, false);
DUMP(currentcard->tag_5F30);
Dbhexdump(3, currentcard->tag_5F30, false);
DUMP(currentcard->tag_5F34);
Dbhexdump(1, currentcard->tag_5F34, false);
DUMP(currentcard->tag_5F36);
Dbhexdump(2, currentcard->tag_5F36, false);
DUMP(currentcard->tag_5F50);
Dbhexdump(currentcard->tag_5F50_len, currentcard->tag_5F50, false);
DUMP(currentcard->tag_5F54);
Dbhexdump(currentcard->tag_5F54_len, currentcard->tag_5F54, false);
DUMP(currentcard->tag_9F01);
Dbhexdump(6, currentcard->tag_9F01, false);
DUMP(currentcard->tag_9F02);
Dbhexdump(6, currentcard->tag_9F02, false);
DUMP(currentcard->tag_9F03);
Dbhexdump(6, currentcard->tag_9F03, false);
DUMP(currentcard->tag_9F04);
Dbhexdump(4, currentcard->tag_9F04, false);
DUMP(currentcard->tag_9F05);
Dbhexdump(currentcard->tag_9F05_len, currentcard->tag_9F05, false);
DUMP(currentcard->tag_9F06);
Dbhexdump(currentcard->tag_9F06_len, currentcard->tag_9F06, false);
DUMP(currentcard->tag_9F07);
Dbhexdump(2, currentcard->tag_9F07, false);
DUMP(currentcard->tag_9F08);
Dbhexdump(2, currentcard->tag_9F08, false);
DUMP(currentcard->tag_9F09);
Dbhexdump(2, currentcard->tag_9F09, false);
DUMP(currentcard->tag_9F0B);
Dbhexdump(currentcard->tag_9F0B_len, currentcard->tag_9F0B, false);
DUMP(currentcard->tag_9F0D);
Dbhexdump(5, currentcard->tag_9F0D, false);
DUMP(currentcard->tag_9F0E);
Dbhexdump(5, currentcard->tag_9F0E, false);
DUMP(currentcard->tag_9F0F);
Dbhexdump(5, currentcard->tag_9F0F, false);
DUMP(currentcard->tag_9F10);
Dbhexdump(currentcard->tag_9F10_len, currentcard->tag_9F10, false);
DUMP(currentcard->tag_9F11);
Dbhexdump(1, currentcard->tag_9F11, false);
DUMP(currentcard->tag_9F12);
Dbhexdump(currentcard->tag_9F12_len, currentcard->tag_9F12, false);
DUMP(currentcard->tag_9F13);
Dbhexdump(2, currentcard->tag_9F13, false);
DUMP(currentcard->tag_9F14);
Dbhexdump(1, currentcard->tag_9F14, false);
DUMP(currentcard->tag_9F15);
Dbhexdump(2, currentcard->tag_9F15, false);
DUMP(currentcard->tag_9F16);
Dbhexdump(15, currentcard->tag_9F16, false);
DUMP(currentcard->tag_9F17);
Dbhexdump(1, currentcard->tag_9F17, false);
DUMP(currentcard->tag_9F18);
Dbhexdump(4, currentcard->tag_9F18, false);
DUMP(currentcard->tag_9F1A);
Dbhexdump(2, currentcard->tag_9F1A, false);
DUMP(currentcard->tag_9F1B);
Dbhexdump(4, currentcard->tag_9F1B, false);
DUMP(currentcard->tag_9F1C);
Dbhexdump(8, currentcard->tag_9F1C, false);
DUMP(currentcard->tag_9F1D);
Dbhexdump(currentcard->tag_9F1D_len, currentcard->tag_9F1D, false);
DUMP(currentcard->tag_9F1E);
Dbhexdump(8, currentcard->tag_9F1E, false);
DUMP(currentcard->tag_9F1F);
Dbhexdump(currentcard->tag_9F1F_len, currentcard->tag_9F1F, false);
DUMP(currentcard->tag_9F20);
Dbhexdump(currentcard->tag_9F20_len, currentcard->tag_9F20, false);
DUMP(currentcard->tag_9F21);
Dbhexdump(3, currentcard->tag_9F1E, false);
DUMP(currentcard->tag_9F22);
Dbhexdump(1, currentcard->tag_9F22, false);
DUMP(currentcard->tag_9F23);
Dbhexdump(1, currentcard->tag_9F23, false);
DUMP(currentcard->tag_9F26);
Dbhexdump(8, currentcard->tag_9F26, false);
DUMP(currentcard->tag_9F27);
Dbhexdump(1, currentcard->tag_9F27, false);
DUMP(currentcard->tag_9F2D);
Dbhexdump(currentcard->tag_9F2D_len, currentcard->tag_9F2D, false);
DUMP(currentcard->tag_9F2E);
Dbhexdump(3, currentcard->tag_9F2E, false);
DUMP(currentcard->tag_9F2F);
Dbhexdump(currentcard->tag_9F2F_len, currentcard->tag_9F2F, false);
DUMP(currentcard->tag_9F32);
Dbhexdump(currentcard->tag_9F32_len, currentcard->tag_9F32, false);
DUMP(currentcard->tag_9F33);
Dbhexdump(3, currentcard->tag_9F33, false);
DUMP(currentcard->tag_9F34);
Dbhexdump(3, currentcard->tag_9F34, false);
DUMP(currentcard->tag_9F35);
Dbhexdump(1, currentcard->tag_9F35, false);
DUMP(currentcard->tag_9F36);
Dbhexdump(2, currentcard->tag_9F36, false);
DUMP(currentcard->tag_9F37);
Dbhexdump(4, currentcard->tag_9F37, false);
DUMP(currentcard->tag_9F38);
Dbhexdump(currentcard->tag_9F38_len, currentcard->tag_9F38, false);
DUMP(currentcard->tag_9F39);
Dbhexdump(1, currentcard->tag_9F39, false);
DUMP(currentcard->tag_9F39);
Dbhexdump(1, currentcard->tag_9F39, false);
DUMP(currentcard->tag_9F40);
Dbhexdump(5, currentcard->tag_9F40, false);
DUMP(currentcard->tag_9F41);
Dbhexdump(4, currentcard->tag_9F41, false);
DUMP(currentcard->tag_9F42);
Dbhexdump(2, currentcard->tag_9F42, false);
DUMP(currentcard->tag_9F43);
Dbhexdump(4, currentcard->tag_9F43, false);
DUMP(currentcard->tag_9F44);
Dbhexdump(1, currentcard->tag_9F44, false);
DUMP(currentcard->tag_9F45);
Dbhexdump(2, currentcard->tag_9F45, false);
DUMP(currentcard->tag_9F46);
Dbhexdump(currentcard->tag_9F46_len, currentcard->tag_9F46, false);
DUMP(currentcard->tag_9F47);
Dbhexdump(currentcard->tag_9F47_len, currentcard->tag_9F47, false);
DUMP(currentcard->tag_9F48);
Dbhexdump(currentcard->tag_9F48_len, currentcard->tag_9F48, false);
DUMP(currentcard->tag_9F49);
Dbhexdump(currentcard->tag_9F49_len, currentcard->tag_9F49, false);
DUMP(currentcard->tag_9F4A);
Dbhexdump(1, currentcard->tag_9F4A, false);
DUMP(currentcard->tag_9F4B);
Dbhexdump(currentcard->tag_9F4B_len, currentcard->tag_9F4B, false);
DUMP(currentcard->tag_9F4C);
Dbhexdump(8, currentcard->tag_9F4C, false);
DUMP(currentcard->tag_9F4D);
Dbhexdump(2, currentcard->tag_9F4D, false);
DUMP(currentcard->tag_9F4E);
Dbhexdump(255, currentcard->tag_9F4E, false);
DUMP(currentcard->tag_9F60);
Dbhexdump(2, currentcard->tag_9F60, false);
DUMP(currentcard->tag_9F61);
Dbhexdump(2, currentcard->tag_9F61, false);
DUMP(currentcard->tag_9F62);
Dbhexdump(6, currentcard->tag_9F62, false);
DUMP(currentcard->tag_9F63);
Dbhexdump(6, currentcard->tag_9F63, false);
DUMP(currentcard->tag_9F64);
Dbhexdump(1, currentcard->tag_9F64, false);
DUMP(currentcard->tag_9F65);
Dbhexdump(2, currentcard->tag_9F65, false);
DUMP(currentcard->tag_9F66);
Dbhexdump(2, currentcard->tag_9F66, false);
DUMP(currentcard->tag_9F67);
Dbhexdump(1, currentcard->tag_9F67, false);
DUMP(currentcard->tag_9F68);
Dbhexdump(currentcard->tag_9F68_len, currentcard->tag_9F68, false);
DUMP(currentcard->tag_9F69);
Dbhexdump(currentcard->tag_9F69_len, currentcard->tag_9F69, false);
DUMP(currentcard->tag_9F6A);
Dbhexdump(8, currentcard->tag_9F6A, false);
DUMP(currentcard->tag_9F6B);
Dbhexdump(currentcard->tag_9F6B_len, currentcard->tag_9F6B, false);
DUMP(currentcard->tag_9F6C);
Dbhexdump(2, currentcard->tag_9F6C, false);
DUMP(currentcard->tag_61);
Dbhexdump(currentcard->tag_61_len, currentcard->tag_61, false);
DUMP(currentcard->tag_A5);
Dbhexdump(currentcard->tag_A5_len, currentcard->tag_A5, false);
DUMP(currentcard->tag_DFNAME);
Dbhexdump(currentcard->tag_DFNAME_len, currentcard->tag_DFNAME, false);
DUMP(currentcard->tag_70);
Dbhexdump(currentcard->tag_70_len, currentcard->tag_70, false);
DUMP(currentcard->tag_77);
Dbhexdump(currentcard->tag_77_len, currentcard->tag_77, false);
DUMP(currentcard->tag_80);
Dbhexdump(currentcard->tag_80_len, currentcard->tag_80, false);
DUMP(currentcard->tag_91);
Dbhexdump(currentcard->tag_91_len, currentcard->tag_91, false);
DUMP(currentcard->tag_BF0C);
Dbhexdump(currentcard->tag_BF0C_len, currentcard->tag_BF0C, false);
DUMP(currentcard->tag_DFName);
Dbhexdump(currentcard->tag_DFName_len, currentcard->tag_DFName, false);
}
Reference in a new issue View git blame Copy permalink