int
main(int argc, const char *argv[])
{
bool verbose = false;
signal(SIGINT, stop_polling);
// Display libnfc version
const char *acLibnfcVersion = nfc_version();
printf("%s uses libnfc %s\n", argv[0], acLibnfcVersion);
if (argc != 1) {
if ((argc == 2) && (0 == strcmp("-v", argv[1]))) {
verbose = true;
} else {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
}
const uint8_t uiPollNr = 20;
const uint8_t uiPeriod = 2;
const nfc_modulation nmModulations[5] = {
{ .nmt = NMT_ISO14443A, .nbr = NBR_106 },
{ .nmt = NMT_ISO14443B, .nbr = NBR_106 },
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;
}
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);
}
int
main(int argc, const char *argv[])
{
system("clear");
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.
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));
printf("...\n", nfc_device_get_name(pnd));
while (true){
// 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) {
print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen);
}
sleep(1);
}
// Close NFC device
nfc_close(pnd);
// Release the context
nfc_exit(context);
return EXIT_SUCCESS;
}
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;
}
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);
if (context == NULL) {
exit(EXIT_FAILURE);
}
// Display libnfc version
const char *acLibnfcVersion = nfc_version();
(void)argc;
// 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) {
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);
}
// Poll for a ISO14443A (MIFARE) tag
nfc_modulation nmMifare;
nmMifare.nmt = NMT_ISO14443A;
nmMifare.nbr = NBR_106;
if (nfc_initiator_select_passive_target(pnd, nmMifare, NULL, 0, &nt) > 0)
print_hex(nt.nti.nai.abtUid, nt.nti.nai.szUidLen);
// Close NFC device
nfc_close(pnd);
// Release the context
nfc_exit(context);
exit(EXIT_SUCCESS);
}
bool verification_libnfc_context(nfc_context** context, QLabel* label_conf_libnfc, QLabel* Message_utilisateur){
bool res= 1;
if (*context == NULL) {
Message_utilisateur->setText("Unable to init libnfc !");
label_conf_libnfc->setText("Non détécté");
label_conf_libnfc->setStyleSheet("background-color: red;");
res=0;
}
else {
Message_utilisateur->setText("libNFC detected");
const char *acLibnfcVersion = nfc_version();
QString message ="v.";
message += acLibnfcVersion;
label_conf_libnfc->setText(message);
label_conf_libnfc->setStyleSheet("background-color: green;");
}
return res;
}
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);
}
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[])
{
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[])
{
nfc_device_t *pnd;
(void) argc;
(void) argv;
// Display libnfc version
const char *acLibnfcVersion = nfc_version ();
printf ("%s use libnfc %s\n", argv[0], acLibnfcVersion);
// Connect using the first available NFC device
pnd = nfc_connect (NULL);
if (pnd == NULL) {
ERR ("%s", "Unable to connect to NFC device.");
return EXIT_FAILURE;
}
printf ("Connected to NFC device: %s\n", pnd->acName);
// 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
char input = getchar ();
int mode = input - '0' + 1;
printf ("\n");
if (mode < VIRTUAL_CARD_MODE || mode > DUAL_CARD_MODE) {
ERR ("%s", "Invalid selection.");
return EXIT_FAILURE;
}
// Connect with the SAM
sam_connection (pnd, mode);
switch (mode) {
case VIRTUAL_CARD_MODE:
{
// FIXME after the loop the device doesn't respond to host commands...
printf ("Now the SAM is readable for 1 minute from an external reader.\n");
wait_one_minute ();
}
break;
case WIRED_CARD_MODE:
{
nfc_target_t nt;
// Set connected NFC device to initiator mode
nfc_initiator_init (pnd);
// Drop the field for a while
if (!nfc_configure (pnd, NDO_ACTIVATE_FIELD, false)) {
nfc_perror (pnd, "nfc_configure");
exit (EXIT_FAILURE);
}
// Let the reader only try once to find a tag
if (!nfc_configure (pnd, NDO_INFINITE_SELECT, false)) {
nfc_perror (pnd, "nfc_configure");
exit (EXIT_FAILURE);
}
// Enable field so more power consuming cards can power themselves up
if (!nfc_configure (pnd, NDO_ACTIVATE_FIELD, true)) {
nfc_perror (pnd, "nfc_configure");
exit (EXIT_FAILURE);
}
// Read the SAM's info
const nfc_modulation_t nmSAM = {
.nmt = NMT_ISO14443A,
.nbr = NBR_106,
};
if (!nfc_initiator_select_passive_target (pnd, nmSAM, NULL, 0, &nt)) {
nfc_perror (pnd, "nfc_initiator_select_passive_target");
ERR ("%s", "Reading of SAM info failed.");
return EXIT_FAILURE;
}
printf ("The following ISO14443A tag (SAM) was found:\n\n");
print_nfc_iso14443a_info (nt.nti.nai, true);
}
break;
case DUAL_CARD_MODE:
{
byte_t abtRx[MAX_FRAME_LEN];
size_t szRx;
nfc_target_t nt = {
.nm.nmt = NMT_ISO14443A,
.nm.nbr = NBR_UNDEFINED,
.nti.nai.abtAtqa = { 0x04, 0x00 },
.nti.nai.abtUid = { 0x08, 0xad, 0xbe, 0xef },
.nti.nai.btSak = 0x20,
.nti.nai.szUidLen = 4,
.nti.nai.szAtsLen = 0,
};
printf ("Now both, NFC device (configured as target) and SAM are readables from an external NFC initiator.\n");
printf ("Please note that NFC device (configured as target) stay in target mode until it receive RATS, ATR_REQ or proprietary command.\n");
if (!nfc_target_init (pnd, &nt, abtRx, &szRx)) {
nfc_perror(pnd, "nfc_target_init");
return EXIT_FAILURE;
}
// wait_one_minute ();
}
break;
}
// Disconnect from the SAM
sam_connection (pnd, NORMAL_MODE);
// Disconnect from NFC device
nfc_disconnect (pnd);
return 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, const char *argv[])
{
size_t szFound;
size_t i;
nfc_device_t *pnd;
nfc_device_desc_t *pnddDevices;
const char *acLibnfcVersion;
bool result;
byte_t abtRx[PN53x_EXTENDED_FRAME_MAX_LEN];
size_t szRx;
const byte_t pncmd_diagnose_communication_line_test[] = { 0xD4, 0x00, 0x00, 0x06, 'l', 'i', 'b', 'n', 'f', 'c' };
const byte_t pncmd_diagnose_rom_test[] = { 0xD4, 0x00, 0x01 };
const byte_t pncmd_diagnose_ram_test[] = { 0xD4, 0x00, 0x02 };
if (argc > 1) {
errx (1, "usage: %s", argv[0]);
}
// Display libnfc version
acLibnfcVersion = nfc_version ();
printf ("%s use libnfc %s\n", argv[0], acLibnfcVersion);
if (!(pnddDevices = malloc (MAX_DEVICE_COUNT * sizeof (*pnddDevices)))) {
fprintf (stderr, "malloc() failed\n");
return EXIT_FAILURE;
}
nfc_list_devices (pnddDevices, MAX_DEVICE_COUNT, &szFound);
if (szFound == 0) {
printf ("No NFC device found.\n");
}
for (i = 0; i < szFound; i++) {
pnd = nfc_connect (&(pnddDevices[i]));
if (pnd == NULL) {
ERR ("%s", "Unable to connect to NFC device.");
return EXIT_FAILURE;
}
printf ("NFC device [%s] connected.\n", pnd->acName);
result = pn53x_transceive (pnd, pncmd_diagnose_communication_line_test, sizeof (pncmd_diagnose_communication_line_test), abtRx, &szRx);
if (result) {
result = (memcmp (pncmd_diagnose_communication_line_test + 2, abtRx, sizeof (pncmd_diagnose_communication_line_test) - 2) == 0);
}
printf (" Communication line test: %s\n", result ? "OK" : "Failed");
result = pn53x_transceive (pnd, pncmd_diagnose_rom_test, sizeof (pncmd_diagnose_rom_test), abtRx, &szRx);
if (result) {
result = ((szRx == 1) && (abtRx[0] == 0x00));
}
printf (" ROM test: %s\n", result ? "OK" : "Failed");
result = pn53x_transceive (pnd, pncmd_diagnose_ram_test, sizeof (pncmd_diagnose_ram_test), abtRx, &szRx);
if (result) {
result = ((szRx == 1) && (abtRx[0] == 0x00));
}
printf (" RAM test: %s\n", result ? "OK" : "Failed");
}
}
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, 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[])
{
(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,
},
},
};
std::string LibNfc::getVersion()
{
return nfc_version();
}
