int NFC_Mifare_Classic(int argc, const char *argv[]) //! Lecture - Écriture d'une carte MIFARE Classic { action_t atAction = ACTION_USAGE; uint8_t *pbtUID; int unlock = 0; if (argc < 2) { sprintf(message_erreur,"Syntaxe incorrecte !"); return EXIT_FAILURE; //! Échec ! } const char *command = argv[1]; if (strcmp(command, "r") == 0 || strcmp(command, "R") == 0) { if (argc < 4) { sprintf(message_erreur,"Syntaxe incorrecte !"); return EXIT_FAILURE; //! Échec ! } atAction = ACTION_READ; if (strcmp(command, "R") == 0) { unlock = 1; } bUseKeyA = tolower((int)((unsigned char) * (argv[2]))) == 'a'; bTolerateFailures = tolower((int)((unsigned char) * (argv[2]))) != (int)((unsigned char) * (argv[2])); bUseKeyFile = (argc > 4); bForceKeyFile = ((argc > 5) && (strcmp((char *)argv[5], "f") == 0)); } else if (strcmp(command, "w") == 0 || strcmp(command, "W") == 0) { if (argc < 4) { sprintf(message_erreur,"Syntaxe incorrecte !"); return EXIT_FAILURE; //! Échec ! } atAction = ACTION_WRITE; if (strcmp(command, "W") == 0) { unlock = 1; } bUseKeyA = tolower((int)((unsigned char) * (argv[2]))) == 'a'; bTolerateFailures = tolower((int)((unsigned char) * (argv[2]))) != (int)((unsigned char) * (argv[2])); bUseKeyFile = (argc > 4); bForceKeyFile = ((argc > 5) && (strcmp((char *)argv[5], "f") == 0)); } if (atAction == ACTION_USAGE) { sprintf(message_erreur,"Syntaxe incorrecte !"); return EXIT_FAILURE; //! Échec ! } //! We don't know yet the card size so let's read only the UID from the keyfile for the moment if (bUseKeyFile) { FILE *pfKeys = fopen(argv[4], "rb"); if (pfKeys == NULL) { sprintf(message_erreur,"Could not open keys file: %s\n", argv[4]); return EXIT_FAILURE; //! Échec ! } if (fread(&mtKeys, 1, 4, pfKeys) != 4) { sprintf(message_erreur,"Could not read UID from key file: %s !", argv[4]); fclose(pfKeys); return EXIT_FAILURE; //! Échec ! } fclose(pfKeys); } nfc_init(&context); if (context == NULL) { sprintf(message_erreur,"Unable to init libnfc (malloc) !"); return EXIT_FAILURE; //! Échec ! } //! Try to open the NFC reader pnd = nfc_open(context, NULL); if (pnd == NULL) { sprintf(message_erreur,"Error opening NFC reader !"); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_strerror_r(pnd, message_erreur, TAILLE_MESSAGE_ERREUR); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! }; //! Let the reader only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_strerror_r(pnd, message_erreur, TAILLE_MESSAGE_ERREUR); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } //! Disable ISO14443-4 switching in order to read devices that emulate Mifare Classic with ISO14443-4 compliance. nfc_device_set_property_bool(pnd, NP_AUTO_ISO14443_4, false); #ifdef DEBUG_PRINTF fprintf(stderr,"NFC reader: %s opened\n", nfc_device_get_name(pnd)); #endif //! Try to find a MIFARE Classic tag if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) <= 0) { sprintf(message_erreur,"Error: no tag was found !"); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } //! Test if we are dealing with a MIFARE compatible tag if ((nt.nti.nai.btSak & 0x08) == 0) { #ifdef DEBUG_PRINTF fprintf(stderr,"Warning: tag is probably not a MFC !"); #endif } //! Get the info from the current tag pbtUID = nt.nti.nai.abtUid; if (bUseKeyFile) { uint8_t fileUid[4]; memcpy(fileUid, mtKeys.amb[0].mbm.abtUID, 4); //! Compare if key dump UID is the same as the current tag UID, at least for the first 4 bytes if (memcmp(pbtUID, fileUid, 4) != 0) { #ifdef DEBUG_PRINTF fprintf(stderr,"Expected MIFARE Classic card with UID starting as: %02x%02x%02x%02x\n", fileUid[0], fileUid[1], fileUid[2], fileUid[3]); fprintf(stderr,"Got card with UID starting as: %02x%02x%02x%02x\n", pbtUID[0], pbtUID[1], pbtUID[2], pbtUID[3]); #endif if (! bForceKeyFile) { sprintf(message_erreur,"Aborting !"); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } } } #ifdef DEBUG_PRINTF fprintf(stderr,"Found MIFARE Classic card:\n"); #endif print_nfc_target(&nt, false); //! Guessing size if ((nt.nti.nai.abtAtqa[1] & 0x02) == 0x02) //! 4K uiBlocks = 0xff; else if ((nt.nti.nai.btSak & 0x01) == 0x01) //! 320b uiBlocks = 0x13; else //! 1K/2K, checked through RATS uiBlocks = 0x3f; //! Testing RATS int res; if ((res = get_rats()) > 0) { if ((res >= 10) && (abtRx[5] == 0xc1) && (abtRx[6] == 0x05) && (abtRx[7] == 0x2f) && (abtRx[8] == 0x2f) && ((nt.nti.nai.abtAtqa[1] & 0x02) == 0x00)) { //! MIFARE Plus 2K uiBlocks = 0x7f; } //! Chinese magic emulation card, ATS=0978009102:dabc1910 if ((res == 9) && (abtRx[5] == 0xda) && (abtRx[6] == 0xbc) && (abtRx[7] == 0x19) && (abtRx[8] == 0x10)) { magic2 = true; } } #ifdef DEBUG_PRINTF fprintf(stderr,"Guessing size: seems to be a %i-byte card\n", (uiBlocks + 1) * 16); #endif if (bUseKeyFile) { FILE *pfKeys = fopen(argv[4], "rb"); if (pfKeys == NULL) { sprintf(message_erreur,"Could not open keys file: %s !", argv[4]); return EXIT_FAILURE; //! Échec ! } if (fread(&mtKeys, 1, (uiBlocks + 1) * sizeof(mifare_classic_block), pfKeys) != (uiBlocks + 1) * sizeof(mifare_classic_block)) { sprintf(message_erreur,"Could not read keys file: %s !", argv[4]); fclose(pfKeys); return EXIT_FAILURE; //! Échec ! } fclose(pfKeys); } if (atAction == ACTION_READ) { memset(&mtDump, 0x00, sizeof(mtDump)); } else { FILE *pfDump = fopen(argv[3], "rb"); if (pfDump == NULL) { sprintf(message_erreur,"Could not open dump file: %s !", argv[3]); return EXIT_FAILURE; //! Échec ! } if (fread(&mtDump, 1, (uiBlocks + 1) * sizeof(mifare_classic_block), pfDump) != (uiBlocks + 1) * sizeof(mifare_classic_block)) { sprintf(message_erreur,"Could not read dump file: %s !", argv[3]); fclose(pfDump); return EXIT_FAILURE; //! Échec ! } fclose(pfDump); } if (atAction == ACTION_READ) { if (read_card(unlock)) { #ifdef DEBUG_PRINTF fprintf(stderr,"Writing data to file: %s ...", argv[3]); #endif fflush(stdout); FILE *pfDump = fopen(argv[3], "wb"); if (pfDump == NULL) { sprintf(message_erreur,"Could not open dump file: %s !", argv[3]); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } if (fwrite(&mtDump, 1, (uiBlocks + 1) * sizeof(mifare_classic_block), pfDump) != ((uiBlocks + 1) * sizeof(mifare_classic_block))) { sprintf(message_erreur,"\nCould not write to file: %s !", argv[3]); fclose(pfDump); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } #ifdef DEBUG_PRINTF fprintf(stderr,"Done.\n"); #endif fclose(pfDump); } else { nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; } } else if (atAction == ACTION_WRITE) { write_card(unlock); } nfc_close(pnd); nfc_exit(context); return EXIT_SUCCESS; //! Succès ! }
/* * call-seq: * name * * Get the name of the tag reader */ static VALUE name(VALUE self) { nfc_device * dev; Data_Get_Struct(self, nfc_device, dev); return rb_str_new2(nfc_device_get_name(dev)); }
int main(int argc, const char *argv[]) { nfc_device *pnd; nfc_target nt; // Allocate only a pointer to nfc_context nfc_context *context; // Initialize libnfc and set the nfc_context nfc_init(&context); // Display libnfc version const char *acLibnfcVersion = nfc_version(); printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); // Open, using the first available NFC device which can be in order of selection: // - default device specified using environment variable or // - first specified device in libnfc.conf (/etc/nfc) or // - first specified device in device-configuration directory (/etc/nfc/devices.d) or // - first auto-detected (if feature is not disabled in libnfc.conf) device pnd = nfc_open(context, NULL); if (pnd == NULL) { warnx("ERROR: %s", "Unable to open NFC device."); return EXIT_FAILURE; } // Set opened NFC device to initiator mode if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); // Poll for a ISO14443A (MIFARE) tag const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0) { printf("The following (NFC) ISO14443A tag was found:\n"); printf(" ATQA (SENS_RES): "); print_hex(nt.nti.nai.abtAtqa, 2); printf(" UID (NFCID%c): ", (nt.nti.nai.abtUid[0] == 0x08 ? '3' : '1')); print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); printf(" SAK (SEL_RES): "); print_hex(&nt.nti.nai.btSak, 1); if (nt.nti.nai.szAtsLen) { printf(" ATS (ATR): "); print_hex(nt.nti.nai.abtAts, nt.nti.nai.szAtsLen); } } // Close NFC device nfc_close(pnd); // Release the context nfc_exit(context); return EXIT_SUCCESS; }
void TagInit(ReaderTag *rt){ nfc_init(&rt->context); if (rt->context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } // Try to open the NFC device rt->device = nfc_open(rt->context, NULL); if (rt->device == NULL) { ERR("Error opening NFC device"); nfc_exit(rt->context); exit(EXIT_FAILURE); } if (nfc_initiator_init(rt->device) < 0) { nfc_perror(rt->device, "nfc_initiator_init"); nfc_close(rt->device); nfc_exit(rt->context); exit(EXIT_FAILURE); } // Scan until the cows come home, or the tag, which ever comes first. if (nfc_device_set_property_bool(rt->device, NP_INFINITE_SELECT, true) < 0) { nfc_perror(rt->device, "nfc_device_set_property_bool"); nfc_close(rt->device); nfc_exit(rt->context); exit(EXIT_FAILURE); } printf("NFC device: %s opened\n", nfc_device_get_name(rt->device)); printf("\nWaiting for tag\n"); // Try to find a MIFARE Ultralight tag if (nfc_initiator_select_passive_target(rt->device, nmMifare, NULL, 0, &rt->nt) <= 0) { ERR("no tag was found\n"); nfc_close(rt->device); nfc_exit(rt->context); exit(EXIT_FAILURE); } // Test if we are dealing with a MIFARE compatible tag if (rt->nt.nti.nai.abtAtqa[1] != 0x44) { ERR("tag is not a MIFARE Ultralight card\n"); nfc_close(rt->device); nfc_exit(rt->context); exit(EXIT_FAILURE); } // Get the info from the current tag printf("Found MIFARE Ultralight card with UID: "); size_t szPos; for (szPos = 0; szPos < rt->nt.nti.nai.szUidLen; szPos++) { printf("%02x", rt->nt.nti.nai.abtUid[szPos]); } printf("\n"); }
int main(int argc, const char *argv[]) { nfc_device *pnd; nfc_target nt; nfc_context *context; nfc_init(&context); if (context == NULL) { printf("Unable to init libnfc (malloc)\n"); exit(EXIT_FAILURE); } const char *acLibnfcVersion = nfc_version(); (void)argc; printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s\n", "Unable to open NFC device."); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); for( ; ; ){ const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0) { printf("The following (NFC) ISO14443A tag was found:\n"); printf(" ATQA (SENS_RES): "); print_hex(nt.nti.nai.abtAtqa, 2); printf(" UID (NFCID%c): ", (nt.nti.nai.abtUid[0] == 0x08 ? '3' : '1')); print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); printf(" SAK (SEL_RES): "); print_hex(&nt.nti.nai.btSak, 1); if (nt.nti.nai.szAtsLen) { printf(" ATS (ATR): "); print_hex(nt.nti.nai.abtAts, nt.nti.nai.szAtsLen); } sleep(3); } } nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
void nfosc_stop() { int i; if (!running) return; running = false; if( main_thread ) pthread_detach(main_thread); main_thread = NULL; lo_bundle osc_bundle = lo_bundle_new(LO_TT_IMMEDIATE); for (i=0;i<buffer_size;i++) { lo_message del_message = lo_message_new(); lo_message_add_int32(del_message, tag_buffer[i].device_id); lo_message_add_int32(del_message, tag_buffer[i].symbol_id); lo_message_add_int32(del_message, tag_buffer[i].type_id); lo_message_add_string(del_message, tag_buffer[i].uid_str); lo_bundle_add_message(osc_bundle, "/nfosc/del", del_message); if (verbose) printf("del %d %d %d %s\n",tag_buffer[i].session_id,tag_buffer[i].symbol_id,tag_buffer[i].type_id,tag_buffer[i].uid_str); } lo_timetag frame_time; lo_timetag_now (&frame_time); for (int dev=0;dev<no_devices;dev++) { if (pnd[dev]==NULL) continue; lo_message frm_message = lo_message_new(); lo_message_add_int32(frm_message, -1); lo_message_add_timetag(frm_message, frame_time); lo_message_add_int32(frm_message, 0); // sensor dim if (device_count>1) sprintf(source_string, "NFOSC:%d",dev); lo_message_add_string(frm_message, source_string); // source name lo_bundle_add_message(osc_bundle, "/tuio2/frm", frm_message); lo_message sid_message = lo_message_new(); lo_bundle_add_message(osc_bundle, "/tuio2/alv", sid_message); } int ret = lo_send_bundle(target, osc_bundle); if(ret == -1) { fprintf(stderr, "an OSC error occured: %s\n", lo_address_errstr(target)); exit(1); } for (int dev=0;dev<no_devices;dev++) { if (pnd[dev]!=NULL) { printf("closing NFC reader #%d: %s\n",dev,nfc_device_get_name(pnd[dev])); nfc_close(pnd[dev]); } } nfc_exit(context); write_database(); }
void nfcInitListen() { const char *acLibnfcVersion = nfc_version(); pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s", "Unable to open NFC device."); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); }
int main (int argc, const char *argv[]) { nfc_device *pnd; nfc_target nt; nfc_init (NULL); // Display libnfc version const char *acLibnfcVersion = nfc_version (); printf ("%s uses libnfc %s\n", argv[0], acLibnfcVersion); // Open, using the first available NFC device pnd = nfc_open (NULL, NULL); if (pnd == NULL) { ERR ("%s", "Unable to open NFC device."); return EXIT_FAILURE; } // Set opened NFC device to initiator mode if (nfc_initiator_init (pnd) < 0) { nfc_perror (pnd, "nfc_initiator_init"); exit (EXIT_FAILURE); } printf ("NFC reader: %s opened\n", nfc_device_get_name (pnd)); // Poll for a ISO14443A (MIFARE) tag const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; if (nfc_initiator_select_passive_target (pnd, nmMifare, NULL, 0, &nt) > 0) { printf ("The following (NFC) ISO14443A tag was found:\n"); printf (" ATQA (SENS_RES): "); print_hex (nt.nti.nai.abtAtqa, 2); printf (" UID (NFCID%c): ", (nt.nti.nai.abtUid[0] == 0x08 ? '3' : '1')); print_hex (nt.nti.nai.abtUid, nt.nti.nai.szUidLen); printf (" SAK (SEL_RES): "); print_hex (&nt.nti.nai.btSak, 1); if (nt.nti.nai.szAtsLen) { printf (" ATS (ATR): "); print_hex (nt.nti.nai.abtAts, nt.nti.nai.szAtsLen); } } // Close NFC device nfc_close (pnd); nfc_exit (NULL); return EXIT_SUCCESS; }
std::string NFCReaderUnit::fetchRealName() { if (d_device) { std::string name(nfc_device_get_name(d_device)); if (name.length() == 0) d_connectedName = "NAME_WAS_EMPTY"; else d_connectedName = name; return d_connectedName; } else return d_connectedName = "CANNOT_FETCH_NAME"; }
int main(int argc, const char *argv[]) { nfc_device *pnd; nfc_target nt; nfc_context *context; nfc_init(&context); if(context == NULL) { printf("unable to init (malloc)\n"); exit(EXIT_FAILURE); } pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s\n", "Unable to open NFC Device."); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; for(int i = 0; i < 24; i++) { if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0) { printf("The following (NFC) card was found:\n"); print_card(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); } while (0 == nfc_initiator_target_is_present(pnd, NULL)){} } nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
// main entry point int main(int argc, const char *argv[]) { init_leds(); nfc_device *device_1; nfc_target target_1; nfc_context *context_1; nfc_device *device_2; nfc_target target_2; nfc_context *context_2; nfc_device *device_3; nfc_target target_3; nfc_context *context_3; // Initialize libnfc and set the nfc_context nfc_init(&context_1); nfc_init(&context_2); nfc_init(&context_3); if (context_1 == NULL || context_2 == NULL) || context_3 == NULL)) { printf("Unable to init libnfc.\n"); exit(EXIT_FAILURE); } device_1 = nfc_open(context_1, NULL); device_2 = nfc_open(context_1, NULL); device_3 = nfc_open(context_2, NULL); if (device_1 == NULL || device_2 == NULL || device_3 == NULL) { printf("ERROR: %s\n", "Unable to open NFC device."); exit(EXIT_FAILURE); } // Set opened NFC device to initiator mode if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } const char *deviceId = nfc_device_get_connstring(pnd); printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); printf("NFC reader connstring: %s \n", deviceId); // Poll for a ISO14443A (MIFARE) tag const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; // get the index of the leds to flickr int index; index = atoi(argv[4]); const char* url; url = argv[3]; char body[50]; while(1){ // always make sure leds are just on properly on init of loop // by giving an out of range index all leds will init flash_leds(12); if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0) { printf("The following (NFC) ISO14443A tag was found:\n"); printf(" ATQA (SENS_RES): "); print_hex(nt.nti.nai.abtAtqa, 2); printf(" UID (NFCID%c): ", (nt.nti.nai.abtUid[0] == 0x08 ? '3' : '1')); print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); printf(" SAK (SEL_RES): "); print_hex(&nt.nti.nai.btSak, 1); if (nt.nti.nai.szAtsLen) { printf(" ATS (ATR): "); print_hex(nt.nti.nai.abtAts, nt.nti.nai.szAtsLen); } // convert the tag into human readable format to work with char usertagid[20]=""; size_t szPos; for(szPos=0; szPos<nt.nti.nai.szUidLen;szPos++){ sprintf(usertagid + strlen(usertagid), "%02x", nt.nti.nai.abtUid[szPos]); } // logging printf("tag found w/ id \"%s\"\n", usertagid); printf("writing to file \"%s\"", argv[2]); flash_leds(index); usleep(60*1000); flash_leds(12); usleep(60*1000); flash_leds(index); usleep(60*1000); flash_leds(12); // get time //struct timeval tv; //gettimeofday(&tv,NULL); //tv.tv_sec // seconds //tv.tv_usec // microseconds int ctime; ctime = ((unsigned)time(NULL))*1000; // convert to ms // write that tag to the file arg // TODO write all params so we can use this as a backup in case of no network FILE *file; file = fopen(argv[2],"a+"); /* apend file (add text to a file or create a file if it does not exist.*/ fprintf(file,"%d;%s\n",ctime, usertagid); /*writes*/ fclose(file); /*done!*/ CURL *curl; CURLcode res; /* get a curl handle */ curl = curl_easy_init(); if(curl) { /* First set the URL that is about to receive our POST. This URL can just as well be a https:// URL if that is what should receive the data. */ curl_easy_setopt(curl, CURLOPT_URL, url); http://stackoverflow.com/questions/11444583/command-line-curl-timeout-parameter curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2); /* Now specify the POST data */ // prepare the body // timestamp and other fields to be added here instead of this sample data sprintf( body, "timestamp=%d&tagId=%s&%s", ctime, usertagid, argv[5]); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body); // logging posting to printf("posting to url [%s] with body [%s]", url, body); /* Perform the request, res will get the return code */ res = curl_easy_perform(curl); /* Check for errors */ if(res != CURLE_OK) fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res)); /* always cleanup */ curl_easy_cleanup(curl); } } // end of found target if // add some wait time here, sleep expects seconds // check usleep, should work with microseconds instead usleep(100); }// end of loop // Close NFC device nfc_close(pnd); // Release the context nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { LONG rv; SCARDCONTEXT hContext; SCARDHANDLE hCard; char *reader; BYTE pbSendBuffer[1 + 1 + sizeof(nfc_connstring)]; DWORD dwSendLength; BYTE pbRecvBuffer[1]; DWORD dwActiveProtocol, dwRecvLength, dwReaders; char* mszReaders = NULL; if (argc == 1 || (argc == 2 && (strncmp(argv[1], "yes", strlen("yes")) == 0))) pbSendBuffer[0] = IFDNFC_SET_ACTIVE; else if (argc == 2 && (strncmp(argv[1], "no", strlen("no")) == 0)) pbSendBuffer[0] = IFDNFC_SET_INACTIVE; else if (argc == 2 && (strncmp(argv[1], "se", strlen("se")) == 0)) pbSendBuffer[0] = IFDNFC_SET_ACTIVE_SE; else if (argc == 2 && (strncmp(argv[1], "status", strlen("status")) == 0)) pbSendBuffer[0] = IFDNFC_GET_STATUS; else { printf("Usage: %s [yes|no|status]\n", argv[0]); exit(EXIT_FAILURE); } rv = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, &hContext); if (rv < 0) goto pcsc_error; dwReaders = 0; // Ask how many bytes readers list take rv = SCardListReaders(hContext, NULL, NULL, &dwReaders); if (rv < 0) goto pcsc_error; // Then allocate and fill mszReaders mszReaders = malloc(dwReaders); rv = SCardListReaders(hContext, NULL, mszReaders, &dwReaders); if (rv < 0) goto pcsc_error; int l; for (reader = mszReaders; dwReaders > 0; l = strlen(reader) + 1, dwReaders -= l, reader += l) { if (strcmp(IFDNFC_READER_NAME, reader) <= 0) break; } if (dwReaders <= 0) { printf("Could not find a reader named: %s\n", IFDNFC_READER_NAME); rv = SCARD_E_NO_READERS_AVAILABLE; goto pcsc_error; } // TODO Handle multiple ifdnfc instance for multiple NFC device ? rv = SCardConnect(hContext, reader, SCARD_SHARE_DIRECT, 0, &hCard, &dwActiveProtocol); if (rv < 0) goto pcsc_error; if ((pbSendBuffer[0] == IFDNFC_SET_ACTIVE) || (pbSendBuffer[0] == IFDNFC_SET_ACTIVE_SE)) { const BYTE command = pbSendBuffer[0]; // To correctly probe NFC devices, ifdnfc must be disactivated first pbSendBuffer[0] = IFDNFC_SET_INACTIVE; dwSendLength = 1; rv = SCardControl(hCard, IFDNFC_CTRL_ACTIVE, pbSendBuffer, dwSendLength, pbRecvBuffer, sizeof(pbRecvBuffer), &dwRecvLength); if (rv < 0) { goto pcsc_error; } pbSendBuffer[0] = command; // Initialize libnfc nfc_context *context; nfc_init(&context); if (context == NULL) { fprintf(stderr, "Unable to init libnfc (malloc)\n"); goto error; } // Allocate nfc_connstring array nfc_connstring connstrings[MAX_DEVICE_COUNT]; // List devices size_t szDeviceFound = nfc_list_devices(context, connstrings, MAX_DEVICE_COUNT); int connstring_index = -1; switch (szDeviceFound) { case 0: fprintf(stderr, "Unable to activate ifdnfc: no NFC device found.\n"); nfc_exit(context); goto error; break; case 1: // Only one NFC device available, so auto-select it! connstring_index = 0; break; default: // More than one available NFC devices, propose a shell menu: printf("%d NFC devices found, please select one:\n", (int)szDeviceFound); for (size_t i = 0; i < szDeviceFound; i++) { nfc_device *pnd = nfc_open(context, connstrings[i]); if (pnd != NULL) { printf("[%d] %s\t (%s)\n", (int)i, nfc_device_get_name(pnd), nfc_device_get_connstring(pnd)); nfc_close(pnd); } else { fprintf(stderr, "nfc_open failed for %s\n", connstrings[i]); } } // libnfc isn't needed anymore nfc_exit(context); printf(">> "); // Take user's choice if (1 != scanf("%2d", &connstring_index)) { fprintf(stderr, "Value must an integer.\n"); goto error; } if ((connstring_index < 0) || (connstring_index >= (int)szDeviceFound)) { fprintf(stderr, "Invalid index selection.\n"); goto error; } break; } printf("Activating ifdnfc with \"%s\"...\n", connstrings[connstring_index]); // pbSendBuffer = { IFDNFC_SET_ACTIVE (1 byte), length (2 bytes), nfc_connstring (lenght bytes)} const uint16_t u16ConnstringLength = strlen(connstrings[connstring_index]) + 1; memcpy(pbSendBuffer + 1, &u16ConnstringLength, sizeof(u16ConnstringLength)); memcpy(pbSendBuffer + 1 + sizeof(u16ConnstringLength), connstrings[connstring_index], u16ConnstringLength); dwSendLength = 1 + sizeof(u16ConnstringLength) + u16ConnstringLength; } else { // pbSendBuffer[0] != IFDNFC_SET_ACTIVE dwSendLength = 1; } rv = SCardControl(hCard, IFDNFC_CTRL_ACTIVE, pbSendBuffer, dwSendLength, pbRecvBuffer, sizeof(pbRecvBuffer), &dwRecvLength); if (rv < 0) { goto pcsc_error; } if (dwRecvLength < 1) { rv = SCARD_F_INTERNAL_ERROR; goto pcsc_error; } switch (pbRecvBuffer[0]) { case IFDNFC_IS_ACTIVE: { uint16_t u16ConnstringLength; if (dwRecvLength < (1 + sizeof(u16ConnstringLength))) { rv = SCARD_F_INTERNAL_ERROR; goto pcsc_error; } memcpy(&u16ConnstringLength, pbRecvBuffer + 1, sizeof(u16ConnstringLength)); if ((dwRecvLength - (1 + sizeof(u16ConnstringLength))) != u16ConnstringLength) { rv = SCARD_F_INTERNAL_ERROR; goto pcsc_error; } nfc_connstring connstring; memcpy(connstring, pbRecvBuffer + 1 + sizeof(u16ConnstringLength), u16ConnstringLength); printf("%s is active using %s.\n", IFDNFC_READER_NAME, connstring); } break; case IFDNFC_IS_INACTIVE: printf("%s is inactive.\n", IFDNFC_READER_NAME); break; default: rv = SCARD_F_INTERNAL_ERROR; goto pcsc_error; } rv = SCardDisconnect(hCard, SCARD_LEAVE_CARD); if (rv < 0) goto pcsc_error; free(mszReaders); exit(EXIT_SUCCESS); pcsc_error: puts(pcsc_stringify_error(rv)); error: if (mszReaders) free(mszReaders); exit(EXIT_FAILURE); }
int main(int argc, const char *argv[]) { nfc_device *pnd; nfc_target nt; nfc_context *context; nfc_init(&context); printf("\nRunning checks...\n"); if (context == NULL) { printf("Unable to init libnfc (malloc)\n"); exit(EXIT_FAILURE); } const char *acLibnfcVersion = nfc_version(); (void)argc; printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s", "Unable to open NFC device."); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; // nfc_set_property_bool(pnd, NP_AUTO_ISO14443_4, true); printf("Polling for target...\n"); while (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) <= 0); printf("Target detected! Running command set...\n\n"); uint8_t capdu[264]; size_t capdulen; uint8_t rapdu[264]; size_t rapdulen; // Select application memcpy(capdu, "\x00\xA4\x04\x00\x07\xF0\x39\x41\x48\x14\x81\x00\x00", 13); capdulen=13; rapdulen=sizeof(rapdu); printf("Sending ADPU SELECT...\n"); if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) { exit(EXIT_FAILURE); } if (rapdulen < 2 || rapdu[rapdulen-2] != 0x90 || rapdu[rapdulen-1] != 0x00) { exit(EXIT_FAILURE); } printf("Application selected!\n\n"); // Select Capability Container memcpy(capdu, "\x00\xa4\x00\x0c\x02\xe1\x03", 7); capdulen=7; rapdulen=sizeof(rapdu); printf("Sending CC SELECT...\n"); if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) exit(EXIT_FAILURE); if (rapdulen < 2 || rapdu[rapdulen-2] != 0x90 || rapdu[rapdulen-1] != 0x00) { capdu[3]='\x00'; // Maybe an older Tag4 ? if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) exit(EXIT_FAILURE); } printf("Capability Container selected!\n\n"); // Read Capability Container memcpy(capdu, "\x00\xb0\x00\x00\x0f", 5); capdulen=5; rapdulen=sizeof(rapdu); printf("Sending ReadBinary from CC...\n"); if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) exit(EXIT_FAILURE); if (rapdulen < 2 || rapdu[rapdulen-2] != 0x90 || rapdu[rapdulen-1] != 0x00) exit(EXIT_FAILURE); printf("\nCapability Container header:\n"); size_t szPos; for (szPos = 0; szPos < rapdulen-2; szPos++) { printf("%02x ", rapdu[szPos]); } printf("\n\n"); // NDEF Select memcpy(capdu, "\x00\xa4\x00\x0C\x02\xE1\x04", 7); capdulen=7; rapdulen=sizeof(rapdu); printf("Sending NDEF Select...\n"); if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) exit(EXIT_FAILURE); if (rapdulen < 2 || rapdu[rapdulen-2] != 0x90 || rapdu[rapdulen-1] != 0x00) exit(EXIT_FAILURE); printf("\n"); // ReadBinary memcpy(capdu, "\x00\xb0\x00\x00\x02", 5); capdulen=5; rapdulen=sizeof(rapdu); printf("Sending ReadBinary NLEN...\n"); if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) exit(EXIT_FAILURE); if (rapdulen < 2 || rapdu[rapdulen-2] != 0x90 || rapdu[rapdulen-1] != 0x00) exit(EXIT_FAILURE); printf("\n"); // ReadBinary - Get NDEF data memcpy(capdu, "\x00\xb0\x00\x00\x0f", 5); capdulen=5; rapdulen=sizeof(rapdu); printf("Sending ReadBinary, get NDEF data...\n"); if (CardTransmit(pnd, capdu, capdulen, rapdu, &rapdulen) < 0) exit(EXIT_FAILURE); if (rapdulen < 2 || rapdu[rapdulen-2] != 0x90 || rapdu[rapdulen-1] != 0x00) exit(EXIT_FAILURE); printf("\n"); printf("Wrapping up, closing session.\n\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int arg, i; bool format = false; unsigned int c; char tmp[3] = { 0x00, 0x00, 0x00 }; // Get commandline options for (arg = 1; arg < argc; arg++) { if (0 == strcmp(argv[arg], "-h")) { print_usage(argv); exit(EXIT_SUCCESS); } else if (0 == strcmp(argv[arg], "-f")) { format = true; } else if (0 == strcmp(argv[arg], "-q")) { quiet_output = true; } else if (strlen(argv[arg]) == 8) { for (i = 0 ; i < 4 ; ++i) { memcpy(tmp, argv[arg] + i * 2, 2); sscanf(tmp, "%02x", &c); abtData[i] = (char) c; } abtData[4] = abtData[0] ^ abtData[1] ^ abtData[2] ^ abtData[3]; iso14443a_crc_append(abtData, 16); } else { ERR("%s is not supported option.", argv[arg]); print_usage(argv); exit(EXIT_FAILURE); } } nfc_context *context; nfc_init(&context); // Try to open the NFC reader pnd = nfc_open(context, NULL); if (!pnd) { printf("Error opening NFC reader\n"); exit(EXIT_FAILURE); } // Initialise NFC device as "initiator" if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } // Configure the CRC if (nfc_device_set_property_bool(pnd, NP_HANDLE_CRC, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); exit(EXIT_FAILURE); } // Use raw send/receive methods if (nfc_device_set_property_bool(pnd, NP_EASY_FRAMING, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); exit(EXIT_FAILURE); } // Disable 14443-4 autoswitching if (nfc_device_set_property_bool(pnd, NP_AUTO_ISO14443_4, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); // Send the 7 bits request command specified in ISO 14443A (0x26) if (!transmit_bits(abtReqa, 7)) { printf("Error: No tag available\n"); nfc_close(pnd); nfc_exit(context); return 1; } memcpy(abtAtqa, abtRx, 2); // Anti-collision transmit_bytes(abtSelectAll, 2); // Check answer if ((abtRx[0] ^ abtRx[1] ^ abtRx[2] ^ abtRx[3] ^ abtRx[4]) != 0) { printf("WARNING: BCC check failed!\n"); } // Save the UID CL1 memcpy(abtRawUid, abtRx, 4); //Prepare and send CL1 Select-Command memcpy(abtSelectTag + 2, abtRx, 5); iso14443a_crc_append(abtSelectTag, 7); transmit_bytes(abtSelectTag, 9); abtSak = abtRx[0]; // Test if we are dealing with a CL2 if (abtSak & CASCADE_BIT) { szCL = 2;//or more // Check answer if (abtRawUid[0] != 0x88) { printf("WARNING: Cascade bit set but CT != 0x88!\n"); } } if (szCL == 2) { // We have to do the anti-collision for cascade level 2 // Prepare CL2 commands abtSelectAll[0] = 0x95; // Anti-collision transmit_bytes(abtSelectAll, 2); // Check answer if ((abtRx[0] ^ abtRx[1] ^ abtRx[2] ^ abtRx[3] ^ abtRx[4]) != 0) { printf("WARNING: BCC check failed!\n"); } // Save UID CL2 memcpy(abtRawUid + 4, abtRx, 4); // Selection abtSelectTag[0] = 0x95; memcpy(abtSelectTag + 2, abtRx, 5); iso14443a_crc_append(abtSelectTag, 7); transmit_bytes(abtSelectTag, 9); abtSak = abtRx[0]; // Test if we are dealing with a CL3 if (abtSak & CASCADE_BIT) { szCL = 3; // Check answer if (abtRawUid[0] != 0x88) { printf("WARNING: Cascade bit set but CT != 0x88!\n"); } } if (szCL == 3) { // We have to do the anti-collision for cascade level 3 // Prepare and send CL3 AC-Command abtSelectAll[0] = 0x97; transmit_bytes(abtSelectAll, 2); // Check answer if ((abtRx[0] ^ abtRx[1] ^ abtRx[2] ^ abtRx[3] ^ abtRx[4]) != 0) { printf("WARNING: BCC check failed!\n"); } // Save UID CL3 memcpy(abtRawUid + 8, abtRx, 4); // Prepare and send final Select-Command abtSelectTag[0] = 0x97; memcpy(abtSelectTag + 2, abtRx, 5); iso14443a_crc_append(abtSelectTag, 7); transmit_bytes(abtSelectTag, 9); abtSak = abtRx[0]; } } // Request ATS, this only applies to tags that support ISO 14443A-4 if (abtRx[0] & SAK_FLAG_ATS_SUPPORTED) { iso_ats_supported = true; } printf("\nFound tag with\n UID: "); switch (szCL) { case 1: printf("%02x%02x%02x%02x", abtRawUid[0], abtRawUid[1], abtRawUid[2], abtRawUid[3]); break; case 2: printf("%02x%02x%02x", abtRawUid[1], abtRawUid[2], abtRawUid[3]); printf("%02x%02x%02x%02x", abtRawUid[4], abtRawUid[5], abtRawUid[6], abtRawUid[7]); break; case 3: printf("%02x%02x%02x", abtRawUid[1], abtRawUid[2], abtRawUid[3]); printf("%02x%02x%02x", abtRawUid[5], abtRawUid[6], abtRawUid[7]); printf("%02x%02x%02x%02x", abtRawUid[8], abtRawUid[9], abtRawUid[10], abtRawUid[11]); break; } printf("\n"); printf("ATQA: %02x%02x\n SAK: %02x\n", abtAtqa[1], abtAtqa[0], abtSak); if (szAts > 1) { // if = 1, it's not actual ATS but error code printf(" ATS: "); print_hex(abtAts, szAts); } printf("\n"); // now reset UID iso14443a_crc_append(abtHalt, 2); transmit_bytes(abtHalt, 4); transmit_bits(abtUnlock1, 7); if (format) { transmit_bytes(abtWipe, 1); transmit_bytes(abtHalt, 4); transmit_bits(abtUnlock1, 7); } transmit_bytes(abtUnlock2, 1); transmit_bytes(abtWrite, 4); transmit_bytes(abtData, 18); if (format) { for (i = 3 ; i < 64 ; i += 4) { abtWrite[1] = (char) i; iso14443a_crc_append(abtWrite, 2); transmit_bytes(abtWrite, 4); transmit_bytes(abtBlank, 18); } } nfc_close(pnd); nfc_exit(context); return EXIT_SUCCESS; }
void nfosc_start() { if (running) return; max_symbol_id = 0; session_id = -1; buffer_size = 0; // try to open the NFC device printf("nfOSC v0.5 using libnfc v%s\n", nfc_version()); printf("looking for NFC devices ...\n"); fflush(stdout); nfc_init(&context); if (context == NULL) { fprintf(stderr, "unable to init libnfc (malloc)\n"); exit(1); } nfc_connstring connstrings[MAX_DEVICE_COUNT]; size_t szFound = nfc_list_devices (context, connstrings, MAX_DEVICE_COUNT); no_devices = (int)szFound; for (int dev=0;dev<no_devices;dev++) { pnd[device_count] = nfc_open(context, connstrings[dev]); if (pnd[device_count] == NULL) continue; nfc_initiator_init(pnd[device_count]); // drop the field for a while nfc_device_set_property_bool(pnd[device_count],NP_ACTIVATE_FIELD,false); // let the reader only try once to find a tag nfc_device_set_property_bool(pnd[device_count],NP_INFINITE_SELECT,false); // configure the CRC and Parity settings nfc_device_set_property_bool(pnd[device_count],NP_HANDLE_CRC,true); nfc_device_set_property_bool(pnd[device_count],NP_HANDLE_PARITY,true); // enable field so more power consuming cards can power themselves up nfc_device_set_property_bool(pnd[device_count],NP_ACTIVATE_FIELD,true); printf("connected to NFC reader #%d: %s\n",device_count,nfc_device_get_name(pnd[device_count])); device_count++; } no_devices = device_count; if (device_count==0) { printf("no device found!\n"); return; } else if (device_count==1) { printf("1 device found\n"); sprintf(source_string, "NFOSC"); } else printf("%d devices found\n", device_count); read_database(); printf("sending OSC packets to %s %s\n",host,port); target = lo_address_new(host, port); running = true; pthread_create(&main_thread , NULL, (void *)&main_loop, NULL); }
int main(int argc, const char *argv[]) { bool bReadAction; FILE *pfDump; if (argc < 3) { printf("\n"); printf("%s r|w <dump.mfd>\n", argv[0]); printf("\n"); printf("r|w - Perform read from or write to card\n"); printf("<dump.mfd> - MiFare Dump (MFD) used to write (card to MFD) or (MFD to card)\n"); printf("\n"); exit(EXIT_FAILURE); } DBG("\nChecking arguments and settings\n"); bReadAction = tolower((int)((unsigned char) * (argv[1])) == 'r'); if (bReadAction) { memset(&mtDump, 0x00, sizeof(mtDump)); } else { pfDump = fopen(argv[2], "rb"); if (pfDump == NULL) { ERR("Could not open dump file: %s\n", argv[2]); exit(EXIT_FAILURE); } if (fread(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { ERR("Could not read from dump file: %s\n", argv[2]); fclose(pfDump); exit(EXIT_FAILURE); } fclose(pfDump); } DBG("Successfully opened the dump file\n"); nfc_context *context; nfc_init(&context); if (context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } // Try to open the NFC device pnd = nfc_open(context, NULL); if (pnd == NULL) { ERR("Error opening NFC device"); nfc_exit(context); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Let the device only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC device: %s opened\n", nfc_device_get_name(pnd)); // Try to find a MIFARE Ultralight tag if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) <= 0) { ERR("no tag was found\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Test if we are dealing with a MIFARE compatible tag if (nt.nti.nai.abtAtqa[1] != 0x44) { ERR("tag is not a MIFARE Ultralight card\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Get the info from the current tag printf("Found MIFARE Ultralight card with UID: "); size_t szPos; for (szPos = 0; szPos < nt.nti.nai.szUidLen; szPos++) { printf("%02x", nt.nti.nai.abtUid[szPos]); } printf("\n"); if (bReadAction) { if (read_card()) { printf("Writing data to file: %s ... ", argv[2]); fflush(stdout); pfDump = fopen(argv[2], "wb"); if (pfDump == NULL) { printf("Could not open file: %s\n", argv[2]); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } if (fwrite(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { printf("Could not write to file: %s\n", argv[2]); fclose(pfDump); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } fclose(pfDump); printf("Done.\n"); } } else { write_card(); } nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, const char *argv[]) { nfc_device *pnd; //nfc_target nt; MifareTag *tags = NULL; int i,j,k; int nbrsect=0; MifareClassicBlock data; // Allocate only a pointer to nfc_context nfc_context *context; // Initialize libnfc and set the nfc_context nfc_init(&context); if (context == NULL) { printf("Unable to init libnfc\n"); exit(EXIT_FAILURE); } // Open, using the first available NFC device which can be in order of selection: // - default device specified using environment variable or // - first specified device in libnfc.conf (/etc/nfc) or // - first specified device in device-configuration directory (/etc/nfc/devices.d) or // - first auto-detected (if feature is not disabled in libnfc.conf) device pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s\n", "Unable to open NFC device."); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); tags = freefare_get_tags(pnd); if (!tags) { printf("no Mifare classic\n"); } else { for (i = 0; tags[i]; i++) { switch(freefare_get_tag_type(tags[i])) { case CLASSIC_1K: printf("%u : Mifare 1k (S50) : %s\n", i, freefare_get_tag_uid(tags[i])); nbrsect=16; break; case CLASSIC_4K: printf("%u : Mifare 4k (S70) : %s\n", i, freefare_get_tag_uid(tags[i])); nbrsect=40; break; default: printf("%u : other ISO14443A tag : %s\n", i, freefare_get_tag_uid(tags[i])); } } } if (!tags[0]) { printf("no tag found !\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } printf ("Found %s\n", freefare_get_tag_friendly_name (tags[0])); /* MifareClassicBlockNumber dablock = 1; if(mifare_classic_connect(tags[0]) == OPERATION_OK) { printf("Connected !\n"); if(mifare_classic_authenticate(tags[0], dablock, keys[0], MFC_KEY_A) == OPERATION_OK) { printf("Authenticated !\n"); if(mifare_classic_get_data_block_permission (tags[0], dablock, MCAB_R|MCAB_W, MFC_KEY_A)) printf("i can READ block %d with key A\n", dablock); if(mifare_classic_get_trailer_block_permission (tags[0], ((dablock)/4)*4+3, MCAB_READ_KEYB, MFC_KEY_B)) printf("i can READ KEY A in trailer\n"); } } */ for(i=0; i<nbrsect; i++) { for(j=0; j < sizeof(keys)/sizeof(keys[0]); j++) { if((mifare_classic_connect(tags[0]) == OPERATION_OK) && (mifare_classic_authenticate( tags[0], mifare_classic_sector_last_block(i), keys[j], MFC_KEY_A) == OPERATION_OK)) { printf("sector %02d auth with A[%d]\n", i, j); for(k=mifare_classic_sector_first_block(i); k<=mifare_classic_sector_last_block(i); k++) { if(mifare_classic_read(tags[0], k, &data) == OPERATION_OK) { print_hex(data,16); } else { printf("read error\n"); } } mifare_classic_disconnect(tags[0]); break; } mifare_classic_disconnect(tags[0]); } printf("\n"); } printf("\n"); freefare_free_tags(tags); // Close NFC device nfc_close(pnd); // Release the context nfc_exit(context); exit(EXIT_SUCCESS); }
int NFC_afficher_UID (char *ATQA, char *UID, char *SAQ, char * ATS) //! Attention à la taille des tableaux de caractères ! { nfc_device *pnd; nfc_target nt; nfc_context *context; nfc_init(&context); if (context == NULL) { sprintf(message_erreur,"ERREUR : Impossible d'utiliser LIBNFC !"); return EXIT_FAILURE; //! ERREUR : Impossible d'utiliser LIBNFC ! } pnd = nfc_open(context, NULL); if (pnd == NULL) { sprintf(message_erreur,"Error opening NFC reader !"); return EXIT_FAILURE; //! ERREUR : Aucun périphérique détecté ! } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_strerror_r(pnd, message_erreur, TAILLE_MESSAGE_ERREUR); return EXIT_FAILURE; //! ERREUR - Sortie de la fonction } #ifdef DEBUG_PRINTF fprintf(stderr,"Lecteur NFC : %s\n", nfc_device_get_name(pnd)); //! Identifiant du lecteur NFC #endif const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0) { #ifdef DEBUG_PRINTF fprintf(stderr,"L'étiquette (NFC) ISO14443A suivante a été trouvée :\n\n"); fprintf(stderr," ATQA (SENS_RES): "); fprintf(stderr,"\033[%sm","31"); #endif sprint_hex(nt.nti.nai.abtAtqa,2,ATQA); //! Récupération du ATQA #ifdef DEBUG_PRINTF fprintf(stderr,"\033[%sm","0"); fprintf(stderr,"\n UID (NFCID%c): ", (nt.nti.nai.abtUid[0] == 0x08 ? '3' : '1')); fprintf(stderr,"\033[%sm","31"); #endif sprint_hex(nt.nti.nai.abtUid,nt.nti.nai.szUidLen,UID); //! Récupération du UID #ifdef DEBUG_PRINTF fprintf(stderr,"\033[%sm","0"); fprintf(stderr,"\n SAK (SEL_RES): "); fprintf(stderr,"\033[%sm","31"); #endif sprint_hex(&nt.nti.nai.btSak,1,SAQ); //! Récupération du SAQ #ifdef DEBUG_PRINTF fprintf(stderr,"\033[%sm","0"); #endif if (nt.nti.nai.szAtsLen) { #ifdef DEBUG_PRINTF fprintf(stderr,"\n ATS (ATR): "); fprintf(stderr,"\033[%sm","31"); #endif sprint_hex(nt.nti.nai.abtAts,nt.nti.nai.szAtsLen,ATS); //! Récupération du ATS #ifdef DEBUG_PRINTF fprintf(stderr,"\033[%sm","0"); #endif } #ifdef DEBUG_PRINTF fprintf(stderr,"\n"); #endif } nfc_close(pnd); //! On libère le périphérique NFC nfc_exit(context); return EXIT_SUCCESS; //! Succès ! }
int main(int argc, const char *argv[]) { int iAction = 0; uint8_t iUID[MAX_UID_LEN] = { 0x0 }; size_t szUID = 0; bool bOTP = false; bool bLock = false; bool bUID = false; FILE *pfDump; if (argc < 2) { print_usage(argv); exit(EXIT_FAILURE); } DBG("\nChecking arguments and settings\n"); // Get commandline options for (int arg = 1; arg < argc; arg++) { if (0 == strcmp(argv[arg], "r")) { iAction = 1; } else if (0 == strcmp(argv[arg], "w")) { iAction = 2; } else if (0 == strcmp(argv[arg], "--with-uid")) { if (argc < 5) { ERR("Please supply a UID of 4, 7 or 10 bytes long. Ex: a1:b2:c3:d4"); exit(EXIT_FAILURE); } szUID = str_to_uid(argv[4], iUID); } else if (0 == strcmp(argv[arg], "--full")) { bOTP = true; bLock = true; bUID = true; } else if (0 == strcmp(argv[arg], "--otp")) { bOTP = true; } else if (0 == strcmp(argv[arg], "--lock")) { bLock = true; } else if (0 == strcmp(argv[arg], "--uid")) { bUID = true; } else if (0 == strcmp(argv[arg], "--check-magic")) { iAction = 3; } else { //Skip validation of the filename if ((arg != 2) && (arg != 4)) { ERR("%s is not supported option.", argv[arg]); print_usage(argv); exit(EXIT_FAILURE); } } } if (iAction == 1) { memset(&mtDump, 0x00, sizeof(mtDump)); } else if (iAction == 2) { pfDump = fopen(argv[2], "rb"); if (pfDump == NULL) { ERR("Could not open dump file: %s\n", argv[2]); exit(EXIT_FAILURE); } if (fread(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { ERR("Could not read from dump file: %s\n", argv[2]); fclose(pfDump); exit(EXIT_FAILURE); } fclose(pfDump); DBG("Successfully opened the dump file\n"); } else if (iAction == 3) { DBG("Switching to Check Magic Mode\n"); } else { ERR("Unable to determine operating mode"); exit(EXIT_FAILURE); } nfc_context *context; nfc_init(&context); if (context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } // Try to open the NFC device pnd = nfc_open(context, NULL); if (pnd == NULL) { ERR("Error opening NFC device"); nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC device: %s opened\n", nfc_device_get_name(pnd)); if (list_passive_targets(pnd)) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Let the device only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Try to find a MIFARE Ultralight tag if (nfc_initiator_select_passive_target(pnd, nmMifare, (szUID) ? iUID : NULL, szUID, &nt) <= 0) { ERR("no tag was found\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Test if we are dealing with a MIFARE compatible tag if (nt.nti.nai.abtAtqa[1] != 0x44) { ERR("tag is not a MIFARE Ultralight card\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Get the info from the current tag printf("Using MIFARE Ultralight card with UID: "); size_t szPos; for (szPos = 0; szPos < nt.nti.nai.szUidLen; szPos++) { printf("%02x", nt.nti.nai.abtUid[szPos]); } printf("\n"); if (iAction == 1) { if (read_card()) { printf("Writing data to file: %s ... ", argv[2]); fflush(stdout); pfDump = fopen(argv[2], "wb"); if (pfDump == NULL) { printf("Could not open file: %s\n", argv[2]); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } if (fwrite(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { printf("Could not write to file: %s\n", argv[2]); fclose(pfDump); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } fclose(pfDump); printf("Done.\n"); } } else if (iAction == 2) { write_card(bOTP, bLock, bUID); } else if (iAction == 3) { if (!check_magic()) { printf("Card is not magic\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } else { printf("Card is magic\n"); } } nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, const char *argv[]) { nfc_device *pnd; // nfc_target nt; // static mifare_param mp; int i, j; MifareTag *tags = NULL; int error = 0; MifareClassicBlock dablock; // MifareClassicBlock mydata = {0x00,0x00,0x00,0x42, 0xff,0xff,0xff,0xbd, 0x00,0x00,0x00,0x42, 0,0xff,0x00,0xff}; MifareClassicBlock my_trailer_block; MifareClassicKey my_key_A = { 0xff,0xff,0xff,0xff,0xff,0xff }; MifareClassicKey my_key_B = { 0xff,0xff,0xff,0xff,0xff,0xff }; // Allocate only a pointer to nfc_context nfc_context *context; // Initialize libnfc and set the nfc_context nfc_init(&context); if (context == NULL) { printf("Unable to init libnfc (malloc)\n"); exit(EXIT_FAILURE); } // Display libnfc version const char *acLibnfcVersion = nfc_version(); (void)argc; printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); // Open, using the first available NFC device which can be in order of selection: // - default device specified using environment variable or // - first specified device in libnfc.conf (/etc/nfc) or // - first specified device in device-configuration directory (/etc/nfc/devices.d) or // - first auto-detected (if feature is not disabled in libnfc.conf) device pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s\n", "Unable to open NFC device."); exit(EXIT_FAILURE); } // Set opened NFC device to initiator mode if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); // Poll for a ISO14443A (MIFARE) tag /* const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0) { printf("The following (NFC) ISO14443A tag was found:\n"); printf(" ATQA (SENS_RES): "); print_hex(nt.nti.nai.abtAtqa, 2); printf(" UID (NFCID%c): ", (nt.nti.nai.abtUid[0] == 0x08 ? '3' : '1')); print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); printf(" SAK (SEL_RES): "); print_hex(&nt.nti.nai.btSak, 1); if (nt.nti.nai.szAtsLen) { printf(" ATS (ATR): "); print_hex(nt.nti.nai.abtAts, nt.nti.nai.szAtsLen); } } */ tags = freefare_get_tags(pnd); if (!tags) { printf("no Mifare classic\n"); } else { for (i = 0; (!error) && tags[i]; i++) { if (freefare_get_tag_type(tags[i]) == CLASSIC_1K) printf("%u : Mifare 1k (S50)\n",i); if (freefare_get_tag_type(tags[i]) == CLASSIC_4K) printf("%u : Mifare 4k (S70)\n",i); } if(mifare_classic_connect(tags[0])==0) { printf("connected\n"); if(mifare_classic_authenticate(tags[0], 1,keys[0],MFC_KEY_B) == OPERATION_OK) { printf("Authenticated !\n"); if(mifare_classic_read (tags[0], 1, &dablock) == OPERATION_OK) { printf("Block readed\n"); for(j=0; j<16; j++) { printf("%02X ", dablock[j]); } printf("\n"); } else { printf("Auth error : %s\n", freefare_strerror(tags[0])); } if(mifare_classic_get_data_block_permission (tags[0], 1, MCAB_R, MFC_KEY_A)) printf("i can READ this block with B\n"); if(mifare_classic_get_data_block_permission (tags[0], 1, MCAB_W, MFC_KEY_A)) printf("i can WRITE this block with B\n"); if(mifare_classic_get_data_block_permission (tags[0], 1, MCAB_I, MFC_KEY_A)) printf("i can INC this block with B\n"); if(mifare_classic_get_data_block_permission (tags[0], 1, MCAB_D, MFC_KEY_A)) printf("i can DEC this block with B\n"); printf("---\n"); /* trailer = ((block) / 4) * 4 + 3; */ if(mifare_classic_get_trailer_block_permission (tags[0], 3, MCAB_READ_KEYA, MFC_KEY_A)) printf("i can READ KEY A in trailer\n"); if(mifare_classic_get_trailer_block_permission (tags[0], 3, MCAB_WRITE_KEYA, MFC_KEY_A)) printf("i can WRITE KEY A in trailer\n"); if(mifare_classic_get_trailer_block_permission (tags[0], 3, MCAB_READ_ACCESS_BITS, MFC_KEY_A)) printf("i can READ ACCESS BITS in trailer\n"); if(mifare_classic_get_trailer_block_permission (tags[0], 3, MCAB_WRITE_ACCESS_BITS, MFC_KEY_A)) printf("i can WRITE ACCESS BITS in trailer\n"); if(mifare_classic_get_trailer_block_permission (tags[0], 3, MCAB_READ_KEYB, MFC_KEY_A)) printf("i can READ KEYB in trailer\n"); if(mifare_classic_get_trailer_block_permission (tags[0], 3, MCAB_WRITE_KEYB, MFC_KEY_A)) printf("i can WRITE KEYB in trailer\n"); /* if(mifare_classic_write (tags[0], 1, mydata) == 0) { printf("write ok\n"); } */ if(mifare_classic_init_value (tags[0], 1, 0x42, 00) == 0) { printf("init value bloc ok\n"); } /* compose trailer block */ /* ab0 ab1 ab2 abt gpb */ /* abt = C_100 = 4 = 100 = c3c2c1 != datasheet c1c2c3*/ //mifare_classic_trailer_block (&my_trailer_block, my_key_A, C_000, C_011, C_000, C_100, 0x69, my_key_B); mifare_classic_trailer_block (&my_trailer_block, my_key_A, C_000, C_000, C_000, C_100, 0x69, my_key_B); for(j=0; j<16; j++) { printf("%02X ", my_trailer_block[j]); } printf("\n"); if(mifare_classic_write (tags[0], 3, my_trailer_block) == 0) { printf("trailer write ok\n"); } /* if(mifare_classic_decrement(tags[0], 1, 1) == OPERATION_OK) { printf("decrement ok\n"); } else { printf("Decrement error : %s\n", freefare_strerror(tags[0])); } if(mifare_classic_transfer (tags[0], 1) == OPERATION_OK) { printf("transfer ok\n"); } else { printf("Transfert error : %s\n", freefare_strerror(tags[0])); } if(mifare_classic_read(tags[0], 1, &dablock) == OPERATION_OK) { printf("Block readed\n"); for(j=0; j<16; j++) { printf("%02X ", dablock[j]); } printf("\n"); } else { printf("Read error : %s\n", freefare_strerror(tags[0])); } */ } else { printf("Erreur : %s\n", freefare_strerror(tags[0])); } mifare_classic_disconnect(tags[0]); } } /* for(i=0; i<1; i++) { for(j=0; j<8; j++) { memcpy(mp.mpa.abtKey, &keys[j*6], 6); res = nfc_initiator_mifare_cmd(pnd, MC_AUTH_B, 0, &mp); if(res) { printf("sector %u / key %u : yes\n", i, j); continue; } else { printf("sector %u / key %u : no\n", i, j); } } } */ /* // mifare parameters memcpy(mp.mpa.abtAuthUid,nt.nti.nai.abtUid,4); memcpy(mp.mpa.abtKey, &keys[0*6], 6); // block res = nfc_initiator_mifare_cmd(pnd, MC_AUTH_A, 0, &mp); if(res) { printf("Auth success\n"); } else { printf("Auth failed\n"); } for(i=0; i<4; i++) { res = nfc_initiator_mifare_cmd(pnd, MC_READ, i, &mp); if(res) { print_hex(mp.mpd.abtData,16); } else { printf("Read failed\n"); } } */ // Close NFC device nfc_close(pnd); // Release the context nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int arg; bool quiet_output = false; const char *acLibnfcVersion = nfc_version(); // Get commandline options for (arg = 1; arg < argc; arg++) { if (0 == strcmp(argv[arg], "-h")) { print_usage(argv); return EXIT_SUCCESS; } else if (0 == strcmp(argv[arg], "-q")) { quiet_output = true; } else { ERR("%s is not supported option.", argv[arg]); print_usage(argv); return EXIT_FAILURE; } } // Display libnfc version printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); #ifdef WIN32 signal(SIGINT, (void (__cdecl *)(int)) intr_hdlr); #else signal(SIGINT, intr_hdlr); #endif nfc_connstring connstrings[MAX_DEVICE_COUNT]; // List available devices size_t szFound = nfc_list_devices(NULL, connstrings, MAX_DEVICE_COUNT); if (szFound < 2) { ERR("%zd device found but two opened devices are needed to relay NFC.", szFound); return EXIT_FAILURE; } nfc_init(NULL); // Try to open the NFC emulator device pndTag = nfc_open(NULL, connstrings[0]); if (pndTag == NULL) { printf("Error opening NFC emulator device\n"); return EXIT_FAILURE; } printf("Hint: tag <---> initiator (relay) <---> target (relay) <---> original reader\n\n"); printf("NFC emulator device: %s opened\n", nfc_device_get_name(pndTag)); printf("[+] Try to break out the auto-emulation, this requires a second reader!\n"); printf("[+] To do this, please send any command after the anti-collision\n"); printf("[+] For example, send a RATS command or use the \"nfc-anticol\" tool\n"); nfc_target nt = { .nm = { .nmt = NMT_ISO14443A, .nbr = NBR_UNDEFINED, }, .nti = { .nai = { .abtAtqa = { 0x04, 0x00 }, .abtUid = { 0x08, 0xad, 0xbe, 0xef }, .btSak = 0x20, .szUidLen = 4, .szAtsLen = 0, },
int main(int argc, const char *argv[]) { if (argc < 2) { usage(); exit(EXIT_FAILURE); } parseopts(argv[1]); nfc_init(&context); if (context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } // Try to open the NFC reader pnd = nfc_open(context, NULL); if (pnd == NULL) { ERR("Error opening NFC reader"); nfc_exit(context); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); }; // Let the reader only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Disable ISO14443-4 switching in order to read devices that emulate Mifare Classic with ISO14443-4 compliance. if (nfc_device_set_property_bool(pnd, NP_AUTO_ISO14443_4, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Configure the CRC if (nfc_device_set_property_bool(pnd, NP_HANDLE_CRC, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Use raw send/receive methods if (nfc_device_set_property_bool(pnd, NP_EASY_FRAMING, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC reader: %s opened\n", nfc_device_get_name(pnd)); // Try to find a MIFARE Classic tag if (select_target(pnd, &nt) <= 0) { printf("Error: no tag was found\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Test if we are dealing with a MIFARE compatible tag if ((nt.nti.nai.btSak & 0x08) == 0) { printf("Warning: tag is probably not a MFC!\n"); } printf("Found MIFARE Classic card:\n"); nt.nm = nmMifare; print_nfc_target(&nt, false); // Guessing size if ((nt.nti.nai.abtAtqa[1] & 0x02) == 0x02) // 4K uiBlocks = 0xff; else if ((nt.nti.nai.btSak & 0x01) == 0x01) // 320b uiBlocks = 0x13; else // 1K/2K, checked through RATS uiBlocks = 0x3f; printf("Guessing size: seems to be a %i-byte card\n", (uiBlocks + 1) * 16); if (parse_card()) { printf("Done, %d blocks read.\n", uiBlocks + 1); fflush(stdout); } if(is_addv) if(!easy_add_value(0xff) || !parse_card()) printf("Failed Add Value!!\n"); printTag(&e); nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int arg; const char *acLibnfcVersion = nfc_version(); nfc_target ntRealTarget; // Get commandline options for (arg = 1; arg < argc; arg++) { if (0 == strcmp(argv[arg], "-h")) { print_usage(argv); exit(EXIT_SUCCESS); } else if (0 == strcmp(argv[arg], "-q")) { quiet_output = true; } else if (0 == strcmp(argv[arg], "-t")) { printf("INFO: %s\n", "Target mode only."); initiator_only_mode = false; target_only_mode = true; } else if (0 == strcmp(argv[arg], "-i")) { printf("INFO: %s\n", "Initiator mode only."); initiator_only_mode = true; target_only_mode = false; } else if (0 == strcmp(argv[arg], "-s")) { printf("INFO: %s\n", "Swapping devices."); swap_devices = true; } else if (0 == strcmp(argv[arg], "-n")) { if (++arg == argc || (sscanf(argv[arg], "%10i", &waiting_time) < 1)) { ERR("Missing or wrong waiting time value: %s.", argv[arg]); print_usage(argv); exit(EXIT_FAILURE); } printf("Waiting time: %i secs.\n", waiting_time); } else { ERR("%s is not supported option.", argv[arg]); print_usage(argv); exit(EXIT_FAILURE); } } // Display libnfc version printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); #ifdef WIN32 signal(SIGINT, (void (__cdecl *)(int)) intr_hdlr); #else signal(SIGINT, intr_hdlr); #endif nfc_context *context; nfc_init(&context); if (context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } nfc_connstring connstrings[MAX_DEVICE_COUNT]; // List available devices size_t szFound = nfc_list_devices(context, connstrings, MAX_DEVICE_COUNT); if (initiator_only_mode || target_only_mode) { if (szFound < 1) { ERR("No device found"); nfc_exit(context); exit(EXIT_FAILURE); } if ((fd3 = fdopen(3, "r")) == NULL) { ERR("Could not open file descriptor 3"); nfc_exit(context); exit(EXIT_FAILURE); } if ((fd4 = fdopen(4, "r")) == NULL) { ERR("Could not open file descriptor 4"); nfc_exit(context); exit(EXIT_FAILURE); } } else { if (szFound < 2) { ERR("%" PRIdPTR " device found but two opened devices are needed to relay NFC.", szFound); nfc_exit(context); exit(EXIT_FAILURE); } } if (!target_only_mode) { // Try to open the NFC reader used as initiator // Little hack to allow using initiator no matter if // there is already a target used locally or not on the same machine: // if there is more than one readers opened we open the second reader // (we hope they're always detected in the same order) if ((szFound == 1) || swap_devices) { pndInitiator = nfc_open(context, connstrings[0]); } else { pndInitiator = nfc_open(context, connstrings[1]); } if (pndInitiator == NULL) { printf("Error opening NFC reader\n"); nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC reader device: %s opened\n", nfc_device_get_name(pndInitiator)); if (nfc_initiator_init(pndInitiator) < 0) { printf("Error: fail initializing initiator\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } // Try to find a ISO 14443-4A tag nfc_modulation nm = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; if (nfc_initiator_select_passive_target(pndInitiator, nm, NULL, 0, &ntRealTarget) <= 0) { printf("Error: no tag was found\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } printf("Found tag:\n"); print_nfc_target(&ntRealTarget, false); if (initiator_only_mode) { if (print_hex_fd4(ntRealTarget.nti.nai.abtUid, ntRealTarget.nti.nai.szUidLen, "UID") < 0) { fprintf(stderr, "Error while printing UID to FD4\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } if (print_hex_fd4(ntRealTarget.nti.nai.abtAtqa, 2, "ATQA") < 0) { fprintf(stderr, "Error while printing ATQA to FD4\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } if (print_hex_fd4(&(ntRealTarget.nti.nai.btSak), 1, "SAK") < 0) { fprintf(stderr, "Error while printing SAK to FD4\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } if (print_hex_fd4(ntRealTarget.nti.nai.abtAts, ntRealTarget.nti.nai.szAtsLen, "ATS") < 0) { fprintf(stderr, "Error while printing ATS to FD4\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } } } if (initiator_only_mode) { printf("Hint: tag <---> *INITIATOR* (relay) <-FD3/FD4-> target (relay) <---> original reader\n\n"); } else if (target_only_mode) { printf("Hint: tag <---> initiator (relay) <-FD3/FD4-> *TARGET* (relay) <---> original reader\n\n"); } else { printf("Hint: tag <---> initiator (relay) <---> target (relay) <---> original reader\n\n"); } if (!initiator_only_mode) { nfc_target ntEmulatedTarget = { .nm = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }, }; if (target_only_mode) { size_t foo; if (scan_hex_fd3(ntEmulatedTarget.nti.nai.abtUid, &(ntEmulatedTarget.nti.nai.szUidLen), "UID") < 0) { fprintf(stderr, "Error while scanning UID from FD3\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } if (scan_hex_fd3(ntEmulatedTarget.nti.nai.abtAtqa, &foo, "ATQA") < 0) { fprintf(stderr, "Error while scanning ATQA from FD3\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } if (scan_hex_fd3(&(ntEmulatedTarget.nti.nai.btSak), &foo, "SAK") < 0) { fprintf(stderr, "Error while scanning SAK from FD3\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } if (scan_hex_fd3(ntEmulatedTarget.nti.nai.abtAts, &(ntEmulatedTarget.nti.nai.szAtsLen), "ATS") < 0) { fprintf(stderr, "Error while scanning ATS from FD3\n"); nfc_close(pndInitiator); nfc_exit(context); exit(EXIT_FAILURE); } } else { ntEmulatedTarget.nti = ntRealTarget.nti; } // We can only emulate a short UID, so fix length & ATQA bit: ntEmulatedTarget.nti.nai.szUidLen = 4; ntEmulatedTarget.nti.nai.abtAtqa[1] &= (0xFF - 0x40); // First byte of UID is always automatically replaced by 0x08 in this mode anyway ntEmulatedTarget.nti.nai.abtUid[0] = 0x08; // ATS is always automatically replaced by PN532, we've no control on it: // ATS = (05) 75 33 92 03 // (TL) T0 TA TB TC // | | | +-- CID supported, NAD supported // | | +----- FWI=9 SFGI=2 => FWT=154ms, SFGT=1.21ms // | +-------- DR=2,4 DS=2,4 => supports 106, 212 & 424bps in both directions // +----------- TA,TB,TC, FSCI=5 => FSC=64 // It seems hazardous to tell we support NAD if the tag doesn't support NAD but I don't know how to disable it // PC/SC pseudo-ATR = 3B 80 80 01 01 if there is no historical bytes // Creates ATS and copy max 48 bytes of Tk: uint8_t *pbtTk; size_t szTk; pbtTk = iso14443a_locate_historical_bytes(ntEmulatedTarget.nti.nai.abtAts, ntEmulatedTarget.nti.nai.szAtsLen, &szTk); szTk = (szTk > 48) ? 48 : szTk; uint8_t pbtTkt[48]; memcpy(pbtTkt, pbtTk, szTk); ntEmulatedTarget.nti.nai.abtAts[0] = 0x75; ntEmulatedTarget.nti.nai.abtAts[1] = 0x33; ntEmulatedTarget.nti.nai.abtAts[2] = 0x92; ntEmulatedTarget.nti.nai.abtAts[3] = 0x03; ntEmulatedTarget.nti.nai.szAtsLen = 4 + szTk; memcpy(&(ntEmulatedTarget.nti.nai.abtAts[4]), pbtTkt, szTk); printf("We will emulate:\n"); print_nfc_target(&ntEmulatedTarget, false); // Try to open the NFC emulator device if (swap_devices) { pndTarget = nfc_open(context, connstrings[1]); } else { pndTarget = nfc_open(context, connstrings[0]); } if (pndTarget == NULL) { printf("Error opening NFC emulator device\n"); if (!target_only_mode) { nfc_close(pndInitiator); } nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC emulator device: %s opened\n", nfc_device_get_name(pndTarget)); if (nfc_target_init(pndTarget, &ntEmulatedTarget, abtCapdu, sizeof(abtCapdu), 0) < 0) { ERR("%s", "Initialization of NFC emulator failed"); if (!target_only_mode) { nfc_close(pndInitiator); } nfc_close(pndTarget); nfc_exit(context); exit(EXIT_FAILURE); } printf("%s\n", "Done, relaying frames now!"); }
int main(int argc, const char *argv[]) { nfc_device *pnd; nfc_target nt; const nfc_target ntbis; // Allocate only a pointer to nfc_context nfc_context *context; // Initialize libnfc and set the nfc_context nfc_init(&context); if (context == NULL) { printf("Unable to init libnfc (malloc)\n"); exit(EXIT_FAILURE); } // Display libnfc version const char *acLibnfcVersion = nfc_version(); (void)argc; printf("%s utilise libnfc v%s\n", argv[0], acLibnfcVersion); // Open, using the first available NFC device which can be in order of selection: // - default device specified using environment variable or // - first specified device in libnfc.conf (/etc/nfc) or // - first specified device in device-configuration directory (/etc/nfc/devices.d) or // - first auto-detected (if feature is not disabled in libnfc.conf) device pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("ERROR: %s\n", "Unable to open NFC device."); exit(EXIT_FAILURE); } // Set opened NFC device to initiator mode if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); exit(EXIT_FAILURE); } printf("Lecteur NFC: %s \n", nfc_device_get_name(pnd)); // Poll for a ISO14443A (MIFARE) tag const nfc_modulation nmMifare = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; int uinp_fd; if ((uinp_fd = setup_uinput_device()) < 0) { printf("Unable to find uinput device\n"); return -1; } sleep(1); long int uid = 0; int i = 0; int check = 1; while (1) { if (nfc_initiator_list_passive_targets(pnd, nmMifare, &nt, 1) > 0) { if (uid != parse_dex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen)) { //printf("%s\n", strtol(*nt.nti.nai.abtUid, 16)); i++; printf("\nmotherfucker %d\n", i); printf("Uid : "); print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); printf("Parse dex : "); printf("%ld\n",parse_dex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen)); uid = parse_dex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen); //printf("Before x : "); //printf("%s\n", before_x(uid)); printf("Do x : "); do_x(uinp_fd, uid); } else { //printf("i: %d uid:%ld nt:%ld\n",i, uid, parse_dex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen)); //i++; } } else { check = 0; uid = 0; } } /* Destroy the input device */ ioctl(uinp_fd, UI_DEV_DESTROY); /* Close the UINPUT device */ close(uinp_fd); // Close NFC device nfc_close(pnd); // Release the context nfc_exit(context); exit(EXIT_SUCCESS); }
int main(int argc, const char *argv[]) { (void) argc; (void) argv; nfc_context *context; nfc_init(&context); if (context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } // Display libnfc version const char *acLibnfcVersion = nfc_version(); printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion); // Open using the first available NFC device nfc_device *pnd; pnd = nfc_open(context, NULL); if (pnd == NULL) { ERR("%s", "Unable to open NFC device."); nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC device: %s opened\n", nfc_device_get_name(pnd)); // Print the example's menu printf("\nSelect the communication mode:\n"); printf("[1] Virtual card mode.\n"); printf("[2] Wired card mode.\n"); printf("[3] Dual card mode.\n"); printf(">> "); // Take user's choice int input = getchar(); printf("\n"); if ((input < '1') || (input > '3')) { ERR("%s", "Invalid selection."); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } /* * '1' -> "Virtual mode" (0x02) * '2' -> "Wired card" (0x03) * '3' -> "Dual card" (0x04) */ int iMode = input - '0' + 0x01; pn532_sam_mode mode = iMode; // Connect with the SAM switch (mode) { case PSM_VIRTUAL_CARD: { // FIXME Its a private pn53x function if (pn532_SAMConfiguration(pnd, mode, 0) < 0) { nfc_perror(pnd, "pn53x_SAMConfiguration"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } printf("Now the SAM is readable for 1 minute from an external reader.\n"); wait_one_minute(); } break; case PSM_WIRED_CARD: { // Set opened NFC device to initiator mode if (nfc_initiator_init_secure_element(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init_secure_element"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Let the reader only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Read the SAM's info const nfc_modulation nmSAM = { .nmt = NMT_ISO14443A, .nbr = NBR_106, }; nfc_target nt; int res; if ((res = nfc_initiator_select_passive_target(pnd, nmSAM, NULL, 0, &nt)) < 0) { nfc_perror(pnd, "nfc_initiator_select_passive_target"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } else if (res == 0) { ERR("No SAM found."); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } else if (res == 1) { printf("The following ISO14443A tag (SAM) was found:\n"); print_nfc_target(&nt, true); } else { ERR("%s", "More than one ISO14442 tag found as SAM."); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } } break; case PSM_DUAL_CARD: { // FIXME Its a private pn53x function if (pn532_SAMConfiguration(pnd, mode, 0) < 0) { nfc_perror(pnd, "pn53x_SAMConfiguration"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } uint8_t abtRx[MAX_FRAME_LEN]; nfc_target nt = { .nm = { .nmt = NMT_ISO14443A, .nbr = NBR_UNDEFINED, }, .nti = { .nai = { .abtAtqa = { 0x04, 0x00 }, .abtUid = { 0x08, 0xad, 0xbe, 0xef }, .btSak = 0x20, .szUidLen = 4, .szAtsLen = 0, }, }, };
int main(int argc, const char *argv[]) { int iAction = 0; uint8_t iDumpSize = sizeof(mifareul_tag); uint8_t iUID[MAX_UID_LEN] = { 0x0 }; size_t szUID = 0; bool bOTP = false; bool bLock = false; bool bUID = false; bool bPWD = false; bool bPart = false; bool bFilename = false; FILE *pfDump; if (argc < 3) { print_usage(argv); exit(EXIT_FAILURE); } DBG("\nChecking arguments and settings\n"); // Get commandline options for (int arg = 1; arg < argc; arg++) { if (0 == strcmp(argv[arg], "r")) { iAction = 1; } else if (0 == strcmp(argv[arg], "w")) { iAction = 2; } else if (0 == strcmp(argv[arg], "--with-uid")) { if (arg + 1 == argc) { ERR("Please supply a UID of 4, 7 or 10 bytes long. Ex: a1:b2:c3:d4"); exit(EXIT_FAILURE); } szUID = str_to_uid(argv[++arg], iUID); } else if (0 == strcmp(argv[arg], "--full")) { bOTP = true; bLock = true; bUID = true; } else if (0 == strcmp(argv[arg], "--otp")) { bOTP = true; } else if (0 == strcmp(argv[arg], "--lock")) { bLock = true; } else if (0 == strcmp(argv[arg], "--uid")) { bUID = true; } else if (0 == strcmp(argv[arg], "--check-magic")) { iAction = 3; } else if (0 == strcmp(argv[arg], "--partial")) { bPart = true; } else if (0 == strcmp(argv[arg], "--pw")) { bPWD = true; if (arg + 1 == argc || strlen(argv[++arg]) != 8 || ! ev1_load_pwd(iPWD, argv[arg])) { ERR("Please supply a PASSWORD of 8 HEX digits"); exit(EXIT_FAILURE); } } else { //Skip validation of the filename if (arg != 2) { ERR("%s is not a supported option.", argv[arg]); print_usage(argv); exit(EXIT_FAILURE); } else { bFilename = true; } } } if (! bFilename) { ERR("Please supply a Mifare Dump filename"); exit(EXIT_FAILURE); } nfc_context *context; nfc_init(&context); if (context == NULL) { ERR("Unable to init libnfc (malloc)"); exit(EXIT_FAILURE); } // Try to open the NFC device pnd = nfc_open(context, NULL); if (pnd == NULL) { ERR("Error opening NFC device"); nfc_exit(context); exit(EXIT_FAILURE); } printf("NFC device: %s opened\n", nfc_device_get_name(pnd)); if (list_passive_targets(pnd)) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Let the device only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Try to find a MIFARE Ultralight tag if (nfc_initiator_select_passive_target(pnd, nmMifare, (szUID) ? iUID : NULL, szUID, &nt) <= 0) { ERR("no tag was found\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Test if we are dealing with a MIFARE compatible tag if (nt.nti.nai.abtAtqa[1] != 0x44) { ERR("tag is not a MIFARE Ultralight card\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } // Get the info from the current tag printf("Using MIFARE Ultralight card with UID: "); size_t szPos; for (szPos = 0; szPos < nt.nti.nai.szUidLen; szPos++) { printf("%02x", nt.nti.nai.abtUid[szPos]); } printf("\n"); // test if tag is EV1 if (get_ev1_version()) { if (!bPWD) printf("Tag is EV1 - PASSWORD may be required\n"); printf("EV1 storage size: "); if (abtRx[6] == 0x0b) { printf("48 bytes\n"); uiBlocks = 0x14; iEV1Type = EV1_UL11; iDumpSize = sizeof(mifareul_ev1_mf0ul11_tag); } else if (abtRx[6] == 0x0e) { printf("128 bytes\n"); uiBlocks = 0x29; iEV1Type = EV1_UL21; iDumpSize = sizeof(mifareul_ev1_mf0ul21_tag); } else printf("unknown!\n"); } else { // re-init non EV1 tag if (nfc_initiator_select_passive_target(pnd, nmMifare, (szUID) ? iUID : NULL, szUID, &nt) <= 0) { ERR("no tag was found\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } } // EV1 login required if (bPWD) { printf("Authing with PWD: %02x%02x%02x%02x ", iPWD[0], iPWD[1], iPWD[2], iPWD[3]); if (!ev1_pwd_auth(iPWD)) { printf("\n"); ERR("AUTH failed!\n"); exit(EXIT_FAILURE); } else { printf("Success - PACK: %02x%02x\n", abtRx[0], abtRx[1]); memcpy(iPACK, abtRx, 2); } } if (iAction == 1) { memset(&mtDump, 0x00, sizeof(mtDump)); } else if (iAction == 2) { pfDump = fopen(argv[2], "rb"); if (pfDump == NULL) { ERR("Could not open dump file: %s\n", argv[2]); exit(EXIT_FAILURE); } size_t szDump; if (((szDump = fread(&mtDump, 1, sizeof(mtDump), pfDump)) != iDumpSize && !bPart) || szDump <= 0) { ERR("Could not read from dump file or size mismatch: %s\n", argv[2]); fclose(pfDump); exit(EXIT_FAILURE); } if (szDump != iDumpSize) printf("Performing partial write\n"); fclose(pfDump); DBG("Successfully opened the dump file\n"); } else if (iAction == 3) { DBG("Switching to Check Magic Mode\n"); } else { ERR("Unable to determine operating mode"); exit(EXIT_FAILURE); } if (iAction == 1) { bool bRF = read_card(); printf("Writing data to file: %s ... ", argv[2]); fflush(stdout); pfDump = fopen(argv[2], "wb"); if (pfDump == NULL) { printf("Could not open file: %s\n", argv[2]); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } if (fwrite(&mtDump, 1, uiReadPages * 4, pfDump) != uiReadPages * 4) { printf("Could not write to file: %s\n", argv[2]); fclose(pfDump); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } fclose(pfDump); printf("Done.\n"); if (!bRF) printf("Warning! Read failed - partial data written to file!\n"); } else if (iAction == 2) { write_card(bOTP, bLock, bUID); } else if (iAction == 3) { if (!check_magic()) { printf("Card is not magic\n"); nfc_close(pnd); nfc_exit(context); exit(EXIT_FAILURE); } else { printf("Card is magic\n"); } } nfc_close(pnd); nfc_exit(context); exit(EXIT_SUCCESS); }
int NFC_Mifare_Ultralight(int argc, const char *argv[]) //! Lecture - Écriture d'une carte MIFARE Ultralight { bool bReadAction; FILE *pfDump; if (argc < 3) { sprintf(message_erreur,"Syntaxe incorrecte !"); return EXIT_FAILURE; //! Échec ! } DBG("\nChecking arguments and settings\n"); bReadAction = tolower((int)((unsigned char) * (argv[1])) == 'r'); if (bReadAction) //! LECTURE { memset(&mtDump, 0x00, sizeof(mtDump)); } else //! ÉCRITURE { if (argc !=3 && argc !=6) { sprintf(message_erreur,"Syntaxe incorrecte !"); return EXIT_FAILURE; //! Échec ! } pfDump = fopen(argv[2], "rb"); if (pfDump == NULL) { sprintf(message_erreur,"Could not open dump file: %s !", argv[2]); return EXIT_FAILURE; //! Échec ! } if (fread(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { sprintf(message_erreur,"Could not read from dump file: %s !", argv[2]); fclose(pfDump); return EXIT_FAILURE; //! Échec ! } fclose(pfDump); } DBG("Successfully opened the dump file\n"); nfc_context *context; nfc_init(&context); if (context == NULL) { sprintf(message_erreur,"Unable to init libnfc (malloc) !"); return EXIT_FAILURE; //! Échec ! } //! Try to open the NFC device pnd = nfc_open(context, NULL); if (pnd == NULL) { sprintf(message_erreur,"Error opening NFC device !"); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } if (nfc_initiator_init(pnd) < 0) { nfc_perror(pnd, "nfc_initiator_init"); nfc_strerror_r(pnd, message_erreur, TAILLE_MESSAGE_ERREUR); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } //! Let the device only try once to find a tag if (nfc_device_set_property_bool(pnd, NP_INFINITE_SELECT, false) < 0) { nfc_perror(pnd, "nfc_device_set_property_bool"); nfc_strerror_r(pnd, message_erreur, TAILLE_MESSAGE_ERREUR); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } #ifdef DEBUG_PRINTF fprintf(stderr,"NFC device: %s opened\n", nfc_device_get_name(pnd)); #endif //! Try to find a MIFARE Ultralight tag if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) <= 0) { sprintf(message_erreur,"No tag was found !"); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } //! Test if we are dealing with a MIFARE compatible tag if (nt.nti.nai.abtAtqa[1] != 0x44) { sprintf(message_erreur,"Tag is not a MIFARE Ultralight card !"); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } //! Get the info from the current tag #ifdef DEBUG_PRINTF fprintf(stderr,"Found MIFARE Ultralight card with UID: "); #endif size_t szPos; for (szPos = 0; szPos < nt.nti.nai.szUidLen; szPos++) { #ifdef DEBUG_PRINTF fprintf(stderr,"%02x", nt.nti.nai.abtUid[szPos]); #endif } #ifdef DEBUG_PRINTF fprintf(stderr,"\n"); #endif if (bReadAction) { if (read_card_ultralight()) { #ifdef DEBUG_PRINTF fprintf(stderr,"Writing data to file: %s ... ", argv[2]); #endif fflush(stdout); pfDump = fopen(argv[2], "wb"); if (pfDump == NULL) { sprintf(message_erreur,"Could not open file: %s !", argv[2]); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } if (fwrite(&mtDump, 1, sizeof(mtDump), pfDump) != sizeof(mtDump)) { sprintf(message_erreur,"Could not write to file: %s !", argv[2]); fclose(pfDump); nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; //! Échec ! } fclose(pfDump); #ifdef DEBUG_PRINTF fprintf(stderr,"Done.\n"); #endif } else //! Échec ! { nfc_close(pnd); nfc_exit(context); return EXIT_FAILURE; } } else { write_card_ultralight(argc,argv); } nfc_close(pnd); nfc_exit(context); return EXIT_SUCCESS; //! Succès ! }
int main(int argc, char *argv[]) { uint8_t *pbtTx = NULL; size_t szTxBits; bool quiet_output = false; int arg, i; // Get commandline options for (arg = 1; arg < argc; arg++) { if (0 == strcmp(argv[arg], "-h")) { print_usage(argv); exit(EXIT_SUCCESS); } else if (0 == strcmp(argv[arg], "-q")) { printf("Quiet mode.\n"); quiet_output = true; } else if ((arg == argc - 1) && (strlen(argv[arg]) == 8)) { // See if UID was specified as HEX string uint8_t abtTmp[3] = { 0x00, 0x00, 0x00 }; printf("[+] Using UID: %s\n", argv[arg]); abtUidBcc[4] = 0x00; for (i = 0; i < 4; ++i) { memcpy(abtTmp, argv[arg] + i * 2, 2); abtUidBcc[i] = (uint8_t) strtol((char *) abtTmp, NULL, 16); abtUidBcc[4] ^= abtUidBcc[i]; } } else { ERR("%s is not supported option.", argv[arg]); print_usage(argv); exit(EXIT_FAILURE); } } #ifdef WIN32 signal(SIGINT, (void (__cdecl *)(int)) intr_hdlr); #else signal(SIGINT, intr_hdlr); #endif nfc_context *context; nfc_init(&context); // Try to open the NFC device pnd = nfc_open(context, NULL); if (pnd == NULL) { printf("Unable to open NFC device\n"); exit(EXIT_FAILURE); } printf("\n"); printf("NFC device: %s opened\n", nfc_device_get_name(pnd)); printf("[+] Try to break out the auto-emulation, this requires a second NFC device!\n"); printf("[+] To do this, please send any command after the anti-collision\n"); printf("[+] For example, send a RATS command or use the \"nfc-anticol\" or \"nfc-list\" tool.\n"); // Note: We have to build a "fake" nfc_target in order to do exactly the same that was done before the new nfc_target_init() was introduced. nfc_target nt = { .nm = { .nmt = NMT_ISO14443A, .nbr = NBR_UNDEFINED, }, .nti = { .nai = { .abtAtqa = { 0x04, 0x00 }, .abtUid = { 0x08, 0xad, 0xbe, 0xef }, .btSak = 0x20, .szUidLen = 4, .szAtsLen = 0, },