//----------------------------------------------------------------------------- // 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; xtag) == 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, ¤tcard->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); }