apo/PollDesfire
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Compare commits

base: apo:rewrite
Branches Tags
apo:main
apo:rewrite
apo:poll_desfire_v0.0.1
..
compare: apo:main
Branches Tags
apo:rewrite
apo:main
apo:poll_desfire_v0.0.1

No commits in common. "rewrite" and "main" have entirely different histories.
rewrite ... main

4 changed files with 101 additions and 231 deletions
Show Stats Expand all files Collapse all files

3
Makefile
View File

@ -1,9 +1,8 @@
VERSION ?= $(shell git rev-parse --short HEAD) VERSION ?= $(shell git rev-parse --short HEAD)
PKG_CONFIG ?= pkg-config
all: poll_desfire all: poll_desfire
poll_desfire: poll_desfire.o nfc_init.o poll_desfire: poll_desfire.o
$(CC) $(LDFLAGS) $(shell $(PKG_CONFIG) --libs libfreefare) $^ -o $@ $(CC) $(LDFLAGS) $(shell $(PKG_CONFIG) --libs libfreefare) $^ -o $@
%.o: %.c %.o: %.c

35
nfc_init.c
View File

@ -1,35 +0,0 @@
#include <err.h>
#include <errno.h>
#include <stdlib.h>
#include "poll_desfire.h"
int init(nfc_context **context, nfc_device **device) {
nfc_connstring devices[8];
size_t device_count;
nfc_init(context);
if (context == NULL) {
errx(EXIT_FAILURE, "Unable to init libnfc (malloc)");
}
device_count = nfc_list_devices(*context, devices, sizeof(devices) / sizeof(devices[0]));
if (device_count <= 0) {
errx(EXIT_FAILURE, "No NFC device found.");
}
if (device_count > 1) {
printf("More than 1 device available. Using %s\n", devices[0]);
}
*device = nfc_open(*context, devices[0]);
if (!device) {
errx(EXIT_FAILURE, "nfc_open() failed.");
}
if (nfc_initiator_init(*device) < 0) {
errx(EXIT_FAILURE, "Initiator failed.");
}
return 0;
}
void poll_target(nfc_device *device);

289
poll_desfire.c
View File

@ -1,222 +1,133 @@
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <err.h> #include <err.h>
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "poll_desfire.h"
#define AID 0x22eaa0 #include <nfc/nfc.h>
#define RANDOM_UID_SIZE 8 #include <freefare.h>
void init_keys(MifareDESFireKey *null_key, MifareDESFireKey *null_key_aes, MifareDESFireKey *master_key, MifareDESFireKey *master_key_aes, char const *name) {
uint8_t const key_data_null[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
*null_key = mifare_desfire_des_key_new_with_version(key_data_null);
*null_key_aes = mifare_desfire_aes_key_new_with_version(key_data_null, 0);
uint8_t key_data_real[16] = {0};
{
FILE *f = fopen(name, "rb");
if (!f) {
errx(EXIT_FAILURE, "error opening key file: %s", name);
}
if (fread(key_data_real, 1, sizeof key_data_real, f) < sizeof key_data_real) {
errx(EXIT_FAILURE, "key file too small.");
}
fclose(f);
}
*master_key = mifare_desfire_des_key_new_with_version(key_data_real);
*master_key_aes = mifare_desfire_aes_key_new_with_version(key_data_real, 0);
}
int main(int argc, char **argv) { int main(int argc, char **argv) {
int error = EXIT_SUCCESS; int error = EXIT_SUCCESS;
nfc_context *context = NULL; nfc_device *device = NULL;
nfc_device *device = NULL; FreefareTag *tags = NULL;
FreefareTag *tags = NULL;
MifareDESFireKey key_null, key_null_aes, key_master, key_master_aes;
MifareDESFireAID aid = mifare_desfire_aid_new(AID);
error = init(&context, &device); nfc_connstring devices[8];
init_keys(&key_null, &key_null_aes, &key_master, &key_master_aes, (argc > 1) ? argv[1] : "key"); size_t device_count;
FILE *out = argc > 2 ? fopen(argv[2], "w") : stdout; nfc_context *context;
nfc_init(&context);
if (context == NULL) {
errx(EXIT_FAILURE, "Unable to init libnfc (malloc)");
}
while (true) { uint8_t const key_data_null[8] = {0, 0, 0, 0, 0, 0, 0, 0};
tags = freefare_get_tags(device); MifareDESFireKey key_null = mifare_desfire_des_key_new_with_version(key_data_null);
if (!tags) {
nfc_close(device);
errx(EXIT_FAILURE, "Error listing tags.");
}
for (int id = 0; tags[id]; id++) { uint8_t key_data_real[16] = {0};
FreefareTag tag = tags[id]; {
if (MIFARE_DESFIRE != freefare_get_tag_type(tag)) char const *name = (argc > 1) ? argv[1] : "key";
continue; FILE *f = fopen(name, "rb");
if (!f) {
errx(EXIT_FAILURE, "error opening key file: %s", name);
}
if (fread(key_data_real, 1, sizeof key_data_real, f) < sizeof key_data_real) {
errx(EXIT_FAILURE, "key file too small.");
}
fclose(f);
}
MifareDESFireKey key_real = mifare_desfire_aes_key_new(key_data_real);
char *tag_uid = freefare_get_tag_uid(tag); FILE *out = argc > 2 ? fopen(argv[2], "w") : stdout;
/* Result of various operations */
int res;
res = mifare_desfire_connect(tag); device_count = nfc_list_devices(context, devices, sizeof(devices) / sizeof(devices[0]));
if (res < 0) { if (device_count <= 0) {
warnx("Can't connect to Mifare DESFire target."); errx(EXIT_FAILURE, "No NFC device found.");
goto next_tag; }
}
if (mifare_desfire_select_application(tag, aid) < 0) { if (device_count > 1) {
// Check for old card with our key as master key printf("More than 1 device available. Using %s\n", devices[0]);
res = mifare_desfire_authenticate_aes(tag, 0, key_master_aes); }
if (res >= 0) {
warnx("Old tag detected: %s", tag_uid);
res =
mifare_desfire_change_key(tag, 0, key_null, key_master_aes);
if (res < 0) {
warnx("Could not change key: %d", res);
goto next_tag;
}
}
// Card needs to have default null key as master device = nfc_open(context, devices[0]);
res = mifare_desfire_authenticate(tag, 0, key_null); if (!device) {
if (res < 0 && (res = mifare_desfire_authenticate_aes(tag, 0, key_null_aes) < 0)) { errx(EXIT_FAILURE, "nfc_open() failed.");
warnx("Could not authenticate: %d", res); }
goto next_tag;
} else { warnx("Authenticated using null key: %d", res); }
// create application if (nfc_initiator_init(device) < 0) {
res = mifare_desfire_create_application_aes( errx(EXIT_FAILURE, "Initiator failed.");
tag, aid, MDAPP_SETTINGS(0, 1, 1, 1, 1), 1); }
if (res < 0) {
warnx("Could not create application: %d", res);
goto next_tag;
} else { warnx("Created application: %d", res); }
}
// Select application again while (true) {
res = mifare_desfire_select_application(tag, aid); /* Poll for targets */
if (res < 0) { const nfc_modulation nmModulations = {.nmt = NMT_ISO14443A, .nbr = NBR_106};
warnx("Application not selectable: %d", res); nfc_target target;
goto next_tag; nfc_initiator_poll_target(device, &nmModulations, 1, 10, 1, &target);
} else { warnx("Selected application: %d", res); }
// Key might still be null /* Got at least one, read tag list */
res = mifare_desfire_authenticate_aes(tag, 0, key_null_aes); tags = freefare_get_tags(device);
if (res >= 0) { if (!tags) {
warnx( nfc_close(device);
"Application is still using the default key"); errx(EXIT_FAILURE, "Error listing tags.");
}
// Update to our key
res = mifare_desfire_change_key(tag, 0, key_master_aes, key_null_aes);
if (res < 0) {
warnx(
"Could not change key of new application to master "
"key: %d",
res);
goto next_tag;
} else { warnx("Updated key"); }
} else { warnx("Could not authenticate using null key: %d", res); }
// Authenticate with new key if (!tags[0]) {
res = mifare_desfire_authenticate(tag, 0, key_master_aes); goto free_tags;
if (res < 0) { }
warnx(
"Could not authenticate new application with our key: "
"%d",
res);
goto next_tag;
}
int found = 0; FreefareTag tag = tags[0];
size_t count = 0; if (MIFARE_DESFIRE != freefare_get_tag_type(tag))
uint8_t key_data[RANDOM_UID_SIZE]; goto free_tags;
uint8_t *files;
res = mifare_desfire_get_file_ids(tag, &files, &count);
if (res < 0) {
warnx("Could not list files: %d", res);
goto next_tag;
}
warnx("%d files", count);
for (int j = 0; j < count; j++) {
warnx("File: %d", key_data[j]);
if (key_data[j] == 0) {
found = 1;
}
}
free(files);
if (!found) { char *tag_uid = freefare_get_tag_uid(tag);
// Create file
res = mifare_desfire_create_std_data_file(
tag, 0, 0, MDAR(0, 0, 0, 0), RANDOM_UID_SIZE);
if (res < 0) {
warnx("Could not create data file: %d", res);
goto next_tag;
}
// Grab random data for it /* Result of various operations */
unsigned char uid_data[RANDOM_UID_SIZE]; int res;
{
int fd = open("/dev/urandom", O_RDONLY);
if (fd < 0) {
warnx("Could not open /dev/urandom");
goto next_tag;
}
if (RANDOM_UID_SIZE != res = mifare_desfire_connect(tag);
read(fd, &uid_data[0], RANDOM_UID_SIZE)) { if (res < 0) {
warnx("Could not read data from /dev/random"); warnx("Can't connect to Mifare DESFire target.");
goto next_tag; goto free_tag;
} }
close(fd);
}
// Write data res = mifare_desfire_authenticate(tag, 0, key_null);
res = mifare_desfire_write_data(tag, 0, 0, RANDOM_UID_SIZE, if (res >= 0) {
&uid_data[0]); // Default key still active, create new key
if (res < 0) { res = mifare_desfire_change_key(tag, 0, key_real, key_null);
warnx("Could not write UID data to tag: %d", res);
goto next_tag;
}
}
// Grab UID if (res < 0) {
uint8_t data[RANDOM_UID_SIZE]; warnx("Error changing key");
res = mifare_desfire_read_data(tag, 0, 0, RANDOM_UID_SIZE, &data[0]); goto free_tag;
if (res != RANDOM_UID_SIZE) { }
warnx("Could not read all bytes from tag: %d", res); }
goto next_tag;
}
// Print out key ID and UID res = mifare_desfire_authenticate_aes(tag, 0, key_real);
fprintf(out, "%s:", tag_uid); if (res < 0) {
for (int j = 0; j < RANDOM_UID_SIZE; j++) { warnx("Authentication on master application failed");
fprintf(out, "%02x", data[j]); goto free_tag;
} } else {
fprintf(out, "\n"); fprintf(out, "%s\n", tag_uid);
fflush(out); fflush(out);
}
while (freefare_selected_tag_is_present(device))
;
next_tag: wait_disconnect:
free(tag_uid); while (0 == nfc_initiator_target_is_present(device, 0))
;
mifare_desfire_disconnect(tag);
mifare_desfire_disconnect(tag); free_tag:
} free(tag_uid);
free_tags:
freefare_free_tags(tags);
fflush(stdout);
fflush(stderr);
}
freefare_free_tags(tags); mifare_desfire_key_free(key_null);
fflush(stdout); mifare_desfire_key_free(key_real);
fflush(stderr);
}
mifare_desfire_key_free(key_null); nfc_close(device);
mifare_desfire_key_free(key_master); nfc_exit(context);
nfc_close(device); exit(error);
nfc_exit(context);
exit(error);
} }

5
poll_desfire.h
View File

@ -1,5 +0,0 @@
#include <nfc/nfc.h>
#include <freefare.h>
int init(nfc_context **context, nfc_device **device);
void poll_target(nfc_device *device);