diff --git a/libfreefare/freefare_internal.h b/libfreefare/freefare_internal.h
index 3a0ca56..03a122d 100644
--- a/libfreefare/freefare_internal.h
+++ b/libfreefare/freefare_internal.h
@@ -228,6 +228,7 @@ struct mifare_desfire_tag {
     uint8_t last_internal_error;
     uint8_t last_pcd_error;
     MifareDESFireKey session_key;
+    enum { AS_LEGACY, AS_NEW } authentication_scheme;
     uint8_t authenticated_key_no;
     uint8_t ivect[MAX_CRYPTO_BLOCK_SIZE];
     uint8_t cmac[16];
diff --git a/libfreefare/mifare_desfire.c b/libfreefare/mifare_desfire.c
index 2169e5e..915adc0 100644
--- a/libfreefare/mifare_desfire.c
+++ b/libfreefare/mifare_desfire.c
@@ -334,6 +334,8 @@ authenticate (MifareTag tag, uint8_t cmd, uint8_t key_no, MifareDESFireKey key)
     free (MIFARE_DESFIRE (tag)->session_key);
     MIFARE_DESFIRE (tag)->session_key = NULL;
 
+    MIFARE_DESFIRE (tag)->authentication_scheme = (0x0A == cmd) ? AS_LEGACY : AS_NEW;
+
     BUFFER_INIT (cmd1, 2);
     BUFFER_INIT (res, 17);
 
@@ -395,12 +397,10 @@ authenticate (MifareTag tag, uint8_t cmd, uint8_t key_no, MifareDESFireKey key)
     MIFARE_DESFIRE (tag)->session_key = mifare_desfire_session_key_new (PCD_RndA, PICC_RndB, key);
     memset (MIFARE_DESFIRE (tag)->ivect, 0, MAX_CRYPTO_BLOCK_SIZE);
 
-    switch (MIFARE_DESFIRE (tag)->session_key->type) {
-    case T_DES:
-    case T_3DES:
+    switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+    case AS_LEGACY:
 	break;
-    case T_3K3DES:
-    case T_AES:
+    case AS_NEW:
 	cmac_generate_subkeys (MIFARE_DESFIRE (tag)->session_key);
 	break;
     }
@@ -536,16 +536,14 @@ mifare_desfire_change_key (MifareTag tag, uint8_t key_no, MifareDESFireKey new_k
 	cmd[__cmd_n++] = new_key->aes_version;
 
     if ((MIFARE_DESFIRE (tag)->authenticated_key_no & 0x0f) != (key_no & 0x0f)) {
-	switch (MIFARE_DESFIRE (tag)->session_key->type) {
-	case T_DES:
-	case T_3DES:
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    iso14443a_crc_append (cmd + 2, __cmd_n - 2);
 	    __cmd_n += 2;
 	    iso14443a_crc (new_key->data, new_key_length, cmd + __cmd_n);
 	    __cmd_n += 2;
 	    break;
-	case T_3K3DES:
-	case T_AES:
+	case AS_NEW:
 	    desfire_crc32_append (cmd, __cmd_n);
 	    __cmd_n += 4;
 
@@ -554,14 +552,12 @@ mifare_desfire_change_key (MifareTag tag, uint8_t key_no, MifareDESFireKey new_k
 	    break;
 	}
     } else {
-	switch (MIFARE_DESFIRE (tag)->session_key->type) {
-	case T_DES:
-	case T_3DES:
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    iso14443a_crc_append (cmd + 2 , __cmd_n - 2);
 	    __cmd_n += 2;
 	    break;
-	case T_3K3DES:
-	case T_AES:
+	case AS_NEW:
 	    desfire_crc32_append (cmd, __cmd_n);
 	    __cmd_n += 4;
 	    break;
@@ -1219,12 +1215,10 @@ read_data (MifareTag tag, uint8_t command, uint8_t file_no, off_t offset, size_t
 
     uint8_t ocs = cs;
     if ((MIFARE_DESFIRE (tag)->session_key) && (cs | MDCM_MACED)) {
-	switch (MIFARE_DESFIRE (tag)->session_key->type) {
-	case T_DES:
-	case T_3DES:
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    break;
-	case T_3K3DES:
-	case T_AES:
+	case AS_NEW:
 	    cs = MDCM_PLAIN;
 	    break;
 	}
diff --git a/libfreefare/mifare_desfire_crypto.c b/libfreefare/mifare_desfire_crypto.c
index b5f86a1..9a11cad 100644
--- a/libfreefare/mifare_desfire_crypto.c
+++ b/libfreefare/mifare_desfire_crypto.c
@@ -264,13 +264,11 @@ enciphered_data_length (const MifareTag tag, const size_t nbytes, int communicat
 {
     size_t crc_length = 0;
     if (!(communication_settings & NO_CRC)) {
-	switch (MIFARE_DESFIRE (tag)->session_key->type) {
-	case T_DES:
-	case T_3DES:
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    crc_length = 2;
 	    break;
-	case T_3K3DES:
-	case T_AES:
+	case AS_NEW:
 	    crc_length = 4;
 	    break;
 	}
@@ -312,7 +310,7 @@ mifare_cryto_preprocess_data (MifareTag tag, void *data, size_t *nbytes, off_t o
 
     switch (communication_settings & MDCM_MASK) {
     case MDCM_PLAIN:
-	if ((T_DES == key->type) || (T_3DES == key->type))
+	if (AS_LEGACY == MIFARE_DESFIRE (tag)->authentication_scheme)
 	    break;
 
 	/*
@@ -329,9 +327,8 @@ mifare_cryto_preprocess_data (MifareTag tag, void *data, size_t *nbytes, off_t o
 
 	/* pass through */
     case MDCM_MACED:
-	switch (key->type) {
-	case T_DES:
-	case T_3DES:
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    if (!(communication_settings & MAC_COMMAND))
 		break;
 
@@ -363,8 +360,7 @@ mifare_cryto_preprocess_data (MifareTag tag, void *data, size_t *nbytes, off_t o
 
 	    *nbytes += 4;
 	    break;
-	case T_3K3DES:
-	case T_AES:
+	case AS_NEW:
 	    if (!(communication_settings & CMAC_COMMAND))
 		break;
 	    cmac (key, MIFARE_DESFIRE (tag)->ivect, res, *nbytes, MIFARE_DESFIRE (tag)->cmac);
@@ -412,20 +408,15 @@ mifare_cryto_preprocess_data (MifareTag tag, void *data, size_t *nbytes, off_t o
 	    memcpy (res, data, *nbytes);
 	    if (!(communication_settings & NO_CRC)) {
 		// ... CRC ...
-		switch (key->type) {
-		case T_DES:
-		case T_3DES:
+		switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+		case AS_LEGACY:
 		    iso14443a_crc_append ((uint8_t *)res + offset, *nbytes - offset);
 		    *nbytes += 2;
 		    break;
-		case T_3K3DES:
+		case AS_NEW:
 		    desfire_crc32_append ((uint8_t *)res, *nbytes);
 		    *nbytes += 4;
 		    break;
-		case T_AES:
-		    // Never reached.
-		    abort ();
-		    break;
 		}
 	    }
 	    // ... and 0 padding
@@ -433,7 +424,7 @@ mifare_cryto_preprocess_data (MifareTag tag, void *data, size_t *nbytes, off_t o
 
 	    *nbytes = edl;
 
-	    mifare_cbc_des (tag, NULL, NULL, (uint8_t *) res + offset, *nbytes - offset, MCD_SEND, (key->type == T_3K3DES) ? MCO_ENCYPHER : MCO_DECYPHER);
+	    mifare_cbc_des (tag, NULL, NULL, (uint8_t *) res + offset, *nbytes - offset, MCD_SEND, (AS_NEW == MIFARE_DESFIRE (tag)->authentication_scheme) ? MCO_ENCYPHER : MCO_DECYPHER);
 
 	    break;
 	case T_AES:
@@ -492,14 +483,13 @@ mifare_cryto_postprocess_data (MifareTag tag, void *data, ssize_t *nbytes, int c
     switch (communication_settings & MDCM_MASK) {
     case MDCM_PLAIN:
 
-	if ((T_DES == key->type) || (T_3DES == key->type))
+	if (AS_LEGACY == MIFARE_DESFIRE (tag)->authentication_scheme)
 	    break;
 
 	/* pass through */
     case MDCM_MACED:
-	switch (key->type) {
-	case T_DES:
-	case T_3DES:
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    if (communication_settings & MAC_VERIFY) {
 		*nbytes -= key_macing_length (key);
 
@@ -523,8 +513,7 @@ mifare_cryto_postprocess_data (MifareTag tag, void *data, ssize_t *nbytes, int c
 		}
 	    }
 	    break;
-	case T_3K3DES:
-	case T_AES:
+	case AS_NEW:
 	    if (!(communication_settings & CMAC_COMMAND))
 		break;
 	    if (communication_settings & CMAC_VERIFY) {
@@ -562,10 +551,9 @@ mifare_cryto_postprocess_data (MifareTag tag, void *data, ssize_t *nbytes, int c
 
 	break;
     case MDCM_ENCIPHERED:
-	switch (key->type) {
-	case T_DES:
-	case T_3DES:
-	    (*nbytes)--;
+	(*nbytes)--;
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
 	    mifare_cbc_des (tag, NULL, NULL, res, *nbytes, MCD_RECEIVE, MCO_DECYPHER);
 
 	    /*
@@ -605,9 +593,7 @@ mifare_cryto_postprocess_data (MifareTag tag, void *data, ssize_t *nbytes, int c
 	    }
 	    break;
 
-	case T_3K3DES:
-	case T_AES:
-	    (*nbytes)--;
+	case AS_NEW:
 	    mifare_cbc_des (tag, NULL, NULL, res, *nbytes, MCD_RECEIVE, MCO_DECYPHER);
 	    uint8_t *p = ((uint8_t *)res) + *nbytes - 1;
 	    while (!*p) {
@@ -747,6 +733,14 @@ mifare_cbc_des (MifareTag tag, MifareDESFireKey key, uint8_t *ivect, uint8_t *da
 	    key = MIFARE_DESFIRE (tag)->session_key;
 	if (!ivect)
 	    ivect = MIFARE_DESFIRE (tag)->ivect;
+
+	switch (MIFARE_DESFIRE (tag)->authentication_scheme) {
+	case AS_LEGACY:
+	    memset (ivect, 0, MAX_CRYPTO_BLOCK_SIZE);
+	    break;
+	case AS_NEW:
+	    break;
+	}
     }
 
     if (!key || !ivect)
@@ -755,8 +749,6 @@ mifare_cbc_des (MifareTag tag, MifareDESFireKey key, uint8_t *ivect, uint8_t *da
     switch (key->type) {
     case T_DES:
     case T_3DES:
-	memset (ivect, 0, MAX_CRYPTO_BLOCK_SIZE);
-	/* pass-through */
     case T_3K3DES:
 	block_size = 8;
 	break;
diff --git a/test/Makefile.am b/test/Makefile.am
index 20b038f..912f635 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -63,6 +63,7 @@ test_mifare_desfire_des_la_SOURCES = test_mifare_desfire_des.c
 test_mifare_desfire_des_la_LIBADD = $(top_builddir)/libfreefare/libfreefare.la
 
 test_mifare_desfire_ev1_la_SOURCES = test_mifare_desfire_ev1.c \
+				     test_mifare_desfire_ev1_3des.c \
 				     test_mifare_desfire_ev1_3k3des.c \
 				     test_mifare_desfire_ev1_aes.c \
 				     mifare_desfire_ev1_fixture.c \
diff --git a/test/test_mifare_desfire_ev1_3des.c b/test/test_mifare_desfire_ev1_3des.c
new file mode 100644
index 0000000..f597246
--- /dev/null
+++ b/test/test_mifare_desfire_ev1_3des.c
@@ -0,0 +1,831 @@
+/*-
+ * Copyright (C) 2010, Romain Tartiere.
+ * 
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ * 
+ * $Id$
+ */
+
+#include <cutter.h>
+#include <errno.h>
+#include <string.h>
+#include <strings.h>
+
+#include <freefare.h>
+#include "freefare_internal.h"
+
+#include "mifare_desfire_ev1_fixture.h"
+#include "common/mifare_desfire_auto_authenticate.h"
+
+#define cut_assert_success(last_command) \
+    do { \
+	if ((res < 0) || (mifare_desfire_last_picc_error (tag) != OPERATION_OK)) { \
+	    cut_fail ("%s returned %d, error: %s, errno: %s\n", last_command, res, mifare_desfire_error_lookup (mifare_desfire_last_picc_error (tag)), strerror (errno)); \
+	} \
+    } while (0)
+
+void
+test_mifare_desfire_ev1_3des (void)
+{
+    int res;
+
+    /* Select the master application */
+    res = mifare_desfire_select_application (tag, NULL);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    /* Get version information */
+    struct mifare_desfire_version_info version_info;
+    res = mifare_desfire_get_version (tag, &version_info);
+    cut_assert_success ("mifare_desfire_get_version()");
+
+     mifare_desfire_auto_authenticate (tag, 0);
+
+    /*
+     * This unit test change key settings to more restrictive ones, so reset
+     * them to factory defaults in case the previous run failed unexpectedly.
+     */
+    res = mifare_desfire_change_key_settings (tag, 0xF);
+    cut_assert_success ("mifare_desfire_change_key_settings()");
+    res = mifare_desfire_change_key_settings (tag, 0xF);
+    cut_assert_success ("mifare_desfire_change_key_settings()");
+
+    /* Change master key to AES */
+    MifareDESFireKey key = mifare_desfire_3des_key_new_with_version (key_data_3des);
+    mifare_desfire_change_key (tag, 0, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    /* Wipeout the card */
+    res = mifare_desfire_format_picc (tag);
+    cut_assert_success ("mifare_desfire_format_picc()");
+
+
+    /* Create 3 applications */
+    res = mifare_desfire_select_application (tag, NULL);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    key = mifare_desfire_3des_key_new_with_version (key_data_3des);
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    uint8_t key_version;
+    res = mifare_desfire_get_key_version (tag, 0, &key_version);
+    cut_assert_success ("mifare_desfire_get_key_version()");
+    cut_assert_equal_int (0x55, 0x55, cut_message ("Wrong key_version value."));
+
+    uint32_t size;
+    res = mifare_desfire_free_mem (tag, &size);
+    cut_assert_success ("mifare_desfire_free_mem()");
+
+    MifareDESFireAID aid_a = mifare_desfire_aid_new (0x00AAAAAA);
+    //cut_assert_not_null (aid_a, cut_message ("Cannot allocate AID"));
+    res = mifare_desfire_create_application (tag, aid_a, 0xFF, 0);
+    cut_assert_success ("mifare_desfire_create_application()");
+
+    MifareDESFireAID aid_b = mifare_desfire_aid_new (0x00BBBBBB);
+    cut_assert_not_null (aid_b, cut_message ("Cannot allocate AID"));
+    res = mifare_desfire_create_application (tag, aid_b, 0xEF, 6);
+    cut_assert_success ("mifare_desfire_create_application()");
+
+    MifareDESFireAID aid_c = mifare_desfire_aid_new (0x00CCCCCC);
+    cut_assert_not_null (aid_c, cut_message ("Cannot allocate AID"));
+    res = mifare_desfire_create_application (tag, aid_c, 0xC2, 14);
+    cut_assert_success ("mifare_desfire_create_application()");
+
+    // Ensure we can find the created applications
+    MifareDESFireAID *aids = NULL;
+    size_t aid_count;
+    res = mifare_desfire_get_application_ids (tag, &aids, &aid_count);
+    cut_assert_success ("mifare_desfire_get_application_ids()");
+    cut_assert_equal_int (3, aid_count, cut_message ("Wrong application count"));
+    mifare_desfire_free_application_ids (aids);
+
+    // Create files in the application A
+    res = mifare_desfire_select_application (tag, aid_a);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    uint8_t std_data_file_id = 15;
+
+    res = mifare_desfire_create_std_data_file (tag, std_data_file_id, MDCM_PLAIN, 0xEEEE, 100);
+    cut_assert_success ("mifare_desfire_create_std_data_file()");
+
+    res = mifare_desfire_create_backup_data_file (tag, 5, MDCM_PLAIN, 0xEEEE, 64);
+    cut_assert_success ("mifare_desfire_create_backup_data_file()");
+
+    res = mifare_desfire_create_value_file (tag, 4, MDCM_PLAIN, 0xEEEE, 0, 1000, 0, 0);
+    cut_assert_success ("mifare_desfire_create_value_file()");
+
+    res = mifare_desfire_create_cyclic_record_file (tag, 0, MDCM_PLAIN, 0xEEEE, 4, 10);
+    cut_assert_success ("mifare_desfire_create_cyclic_record_file()");
+
+    // Write some data in the standard data file
+    res = mifare_desfire_write_data (tag, std_data_file_id, 0, 30, (uint8_t *)"Some data to write to the card");
+    cut_assert_success ("mifare_desfire_write_data()");
+    cut_assert_equal_int (30, res, cut_message ("Wrong number of bytes writen"));
+
+    res = mifare_desfire_write_data (tag, std_data_file_id, 34, 22, (uint8_t *)"Another block of data.");
+    cut_assert_success ("mifare_desfire_write_data()");
+    cut_assert_equal_int (22, res, cut_message ("Wrong number of bytes writen"));
+
+    // Make the file read-only
+    res = mifare_desfire_change_file_settings (tag, std_data_file_id, MDCM_PLAIN, 0xEFFF);
+    cut_assert_success ("mifare_desfire_change_file_settings()");
+
+    // Read a part of the file
+    uint8_t buffer[120];
+    res = mifare_desfire_read_data (tag, std_data_file_id, 10, 50, &buffer);
+    cut_assert_success ("mifare_desfire_read_data()");
+    cut_assert_equal_int (50, res, cut_message ("Wrong number of bytes read"));
+    cut_assert_equal_memory ("to write to the card\0\0\0\0Another block of data.\0\0\0\0", 50, buffer, 50, cut_message ("Wrong data"));
+
+    // Read all the file at once
+    res = mifare_desfire_read_data (tag, std_data_file_id, 0, 0, &buffer);
+    cut_assert_success ("mifare_desfire_read_data()");
+    cut_assert_equal_int (100, res, cut_message ("Wrong number of bytes read"));
+    cut_assert_equal_memory ("Some data to write to the"
+			     " card\0\0\0\0Another block of"
+			     " data.\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+			     "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 100, buffer, 100, cut_message ("Wrong data"));
+
+    // Try to overwrute the file
+    res = mifare_desfire_write_data (tag, std_data_file_id, 20, 5, (char *)"Test!");
+    cut_assert_equal_int (-1, res, cut_message ("Wrong return value"));
+    cut_assert_equal_int (PERMISSION_ERROR, mifare_desfire_last_picc_error (tag), cut_message ("Wrong PICC error"));
+
+    int32_t expected_value = 0;
+    for (int transaction = 0; transaction < 15; transaction++) {
+
+	char data_buffer[3];
+
+	sprintf (data_buffer, "%02d", transaction);
+
+	// Write to the backup file
+	res = mifare_desfire_write_data (tag, 5, 3*transaction, 3, data_buffer);
+	cut_assert_success ("mifare_desfire_write_data()");
+
+	// Manipulate the value file
+	res = mifare_desfire_credit (tag, 4, 100);
+	cut_assert_success ("mifare_desfire_credit()");
+
+	res = mifare_desfire_debit (tag, 4, 97);
+	cut_assert_success ("mifare_desfire_debit()");
+
+	// Write to the cyclic record file
+	res = mifare_desfire_write_record (tag, 0, 2, 2, data_buffer);
+	cut_assert_success ("mifare_desfire_write_record()");
+
+	// Overwrite the cyclic record file
+	res = mifare_desfire_write_record (tag, 0, 0, 2, (char *)"r.");
+	cut_assert_success("mifare_desfire_write_record()");
+
+	// Ensure that no content was changed yet
+	char ref_buffer[64];
+	bzero (ref_buffer, sizeof (ref_buffer));
+	for (int n = 0; n < transaction; n++) {
+	    sprintf (ref_buffer + 3 * n, "%02d", n);
+	}
+
+	res = mifare_desfire_read_data (tag, 5, 0, 0, buffer);
+	cut_assert_success ("mifare_desfire_read_data()");
+	cut_assert_equal_int (64, res, cut_message ("Wrong number of bytes read"));
+	cut_assert_equal_memory (buffer, 64, ref_buffer, 64, cut_message ("Wrong data"));
+
+	int32_t value;
+	res = mifare_desfire_get_value (tag, 4, &value);
+	cut_assert_success ("mifare_desfire_get_value()");
+	cut_assert_equal_int (expected_value, value, cut_message ("Wrong value"));
+
+	// Reading records from an empty file would abort the transaction
+	if (0 != transaction) {
+	    // Get the latest record
+	    res = mifare_desfire_read_records (tag, 0, 0, 1, buffer);
+	    cut_assert_success ("mifare_desfire_read_records()");
+	    sprintf (ref_buffer, "r.%02d", transaction);
+	    cut_assert_not_equal_memory (ref_buffer, 4, buffer, res, cut_message ("Wrong data"));
+	}
+
+	// Commit !
+	res = mifare_desfire_commit_transaction (tag);
+	cut_assert_success ("mifare_desfire_commit_transaction()");
+
+
+	res = mifare_desfire_read_data (tag, 5, 3*transaction, 3, buffer);
+	cut_assert_success ("mifare_desfire_read_data()");
+	cut_assert_equal_memory (data_buffer, 3, buffer, res, cut_message ("Wrong data"));
+
+	expected_value += 3;
+
+	res = mifare_desfire_get_value (tag, 4, &value);
+	cut_assert_success ("mifare_desfire_get_value()");
+	cut_assert_equal_int (expected_value, value, cut_message ("Wrong value"));
+
+	res = mifare_desfire_read_records (tag, 0, 0, 1, buffer);
+	cut_assert_success ("mifare_desfire_read_records()");
+	sprintf (ref_buffer, "r.%02d", transaction);
+	cut_assert_equal_memory (ref_buffer, 4, buffer, res, cut_message ("Wrong data"));
+    }
+
+    // Ensure limited credit is disabled
+    res = mifare_desfire_limited_credit (tag, 4, 20);
+    cut_assert_equal_int (-1, res, cut_message ("mifare_desfire_limited_credit() should fail"));
+
+    // Get all files
+    uint8_t *files;
+    size_t file_count;
+    res = mifare_desfire_get_file_ids (tag, &files, &file_count);
+    cut_assert_success ("mifare_desfire_get_file_ids()");
+    cut_assert_equal_int (4, file_count, cut_message ("Wrong number of files"));
+
+    for (size_t i=0; i<file_count;i++) {
+	if ((files[i] != 0) && (files[i] != 4) &&
+	    (files[i] != 5) && (files[i] != 15)) {
+	    cut_fail ("File %d should not exist.", files[i]);
+	}
+
+	struct mifare_desfire_file_settings settings;
+	res = mifare_desfire_get_file_settings (tag, files[i], &settings);
+	cut_assert_success ("mifare_desfire_get_file_settings()");
+
+	switch (files[i]) {
+	case 0:
+	    cut_assert_equal_int (MDFT_CYCLIC_RECORD_FILE_WITH_BACKUP, settings.file_type, cut_message ("Wrong file type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("Wrong communication settings"));
+	    cut_assert_equal_int (4, settings.settings.linear_record_file.record_size, cut_message ("Wrong record size"));
+	    cut_assert_equal_int (10, settings.settings.linear_record_file.max_number_of_records, cut_message ("Wrong max number of records"));
+	    cut_assert_equal_int (9, settings.settings.linear_record_file.current_number_of_records, cut_message ("Wrong current number of records"));
+	    break;
+	case 4:
+	    cut_assert_equal_int (MDFT_VALUE_FILE_WITH_BACKUP, settings.file_type, cut_message ("Wrong file type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("Wrong communication settings"));
+
+	    cut_assert_equal_int (0, settings.settings.value_file.lower_limit, cut_message ("Wrong lower limit"));
+	    cut_assert_equal_int (1000, settings.settings.value_file.upper_limit, cut_message ("Wrong upper limit"));
+	    cut_assert_equal_int (97, settings.settings.value_file.limited_credit_value, cut_message ("Wrong limited_credit value"));
+	    cut_assert_equal_int (0, settings.settings.value_file.limited_credit_enabled, cut_message ("Wrong limited_credit enable state"));
+	    break;
+	case 5:
+	    cut_assert_equal_int (MDFT_BACKUP_DATA_FILE, settings.file_type, cut_message ("Wrong file type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("Wrong communication settings"));
+	    cut_assert_equal_int (64, settings.settings.standard_file.file_size, cut_message ("Wrong file size"));
+	    break;
+	case 15:
+	    cut_assert_equal_int (MDFT_STANDARD_DATA_FILE, settings.file_type, cut_message ("Wrong file type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("Wrong communication settings"));
+	    cut_assert_equal_int (100, settings.settings.standard_file.file_size, cut_message ("Wrong file size"));
+	    break;
+	default:
+	    cut_fail ("Wow!  Cosmic ray!");
+	}
+
+	res = mifare_desfire_delete_file (tag, files[i]);
+	cut_assert_success ("mifare_desfire_delete_file()");
+    }
+
+    free (files);
+
+    // All files should have been removed
+    res = mifare_desfire_get_file_ids (tag, &files, &file_count);
+    cut_assert_success ("mifare_desfire_get_file_ids()");
+    cut_assert_equal_int (0, file_count, cut_message ("Wrong number of files"));
+
+    // Delete application A
+    res = mifare_desfire_select_application (tag, 0);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    key = mifare_desfire_3des_key_new (key_data_3des);
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    res = mifare_desfire_delete_application (tag, aid_a);
+    cut_assert_success ("mifare_desfire_delete_application()");
+
+    // Ensure application A was deleted
+    res = mifare_desfire_get_application_ids (tag, &aids, &aid_count);
+    cut_assert_success ("mifare_desfire_get_application_ids()");
+    cut_assert_equal_int (2, aid_count, cut_message ("Wrong application count"));
+    mifare_desfire_free_application_ids (aids);
+
+    // Change application B keys
+    res = mifare_desfire_select_application (tag, aid_b);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    key = mifare_desfire_des_key_new (key_data_null);
+    res = mifare_desfire_authenticate (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate()");
+    mifare_desfire_key_free (key);
+
+    // Use an AES application master key
+    key = mifare_desfire_3des_key_new_with_version ((uint8_t *) "App.B Master Key12345678");
+    res = mifare_desfire_change_key (tag, 0, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+
+    /* Authenticate with the new master key */
+    key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Master Key12345678");
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    res = mifare_desfire_get_key_version (tag, 0, &key_version);
+    cut_assert_success ("mifare_desfire_get_key_version()");
+    cut_assert_equal_int (0x83, key_version, cut_message ("Wrong key version"));
+
+    /* Change key #1 */
+    key = mifare_desfire_des_key_new (key_data_null);
+    res = mifare_desfire_authenticate (tag, 1, key);
+    cut_assert_success ("mifare_desfire_authenticate()");
+    mifare_desfire_key_free (key);
+
+    key = mifare_desfire_3des_key_new ((uint8_t *) "Another AES key!12345678");
+    res = mifare_desfire_change_key (tag, 1, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+
+    /* Change key #5 */
+    key = mifare_desfire_des_key_new (key_data_null);
+    res = mifare_desfire_authenticate (tag, 5, key);
+    cut_assert_success ("mifare_desfire_authenticate()");
+    mifare_desfire_key_free (key);
+
+    key = mifare_desfire_3des_key_new ((uint8_t *) "B's Chg Keys Key12345678");
+    res = mifare_desfire_change_key (tag, 5, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+
+    /* Set key #5 as the change key */
+    key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Master Key12345678");
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    res = mifare_desfire_change_key_settings (tag, 0x5F);
+    cut_assert_success ("mifare_desfire_change_key_settings()");
+
+    uint8_t key_settings;
+    uint8_t max_keys;
+    res = mifare_desfire_get_key_settings (tag, &key_settings, &max_keys);
+    cut_assert_success ("mifare_desfire_get_key_settings()");
+
+    cut_assert_equal_int (0x5F, key_settings, cut_message ("Wrong key settings"));
+    cut_assert_equal_int (6, max_keys, cut_message ("Wrong maximum number of keys"));
+
+    /* Change key #1 to #4 using the three key procedure. */
+    key = mifare_desfire_3des_key_new ((uint8_t *) "B's Chg Keys Key12345678");
+    res = mifare_desfire_authenticate_iso (tag, 5, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    key = mifare_desfire_3des_key_new ((uint8_t *)"App.B Key #1.   12345678");
+    MifareDESFireKey key1 = mifare_desfire_3des_key_new ((uint8_t *) "Another AES key!12345678");
+    res = mifare_desfire_change_key (tag, 1, key, key1);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+    mifare_desfire_key_free (key1);
+    key = mifare_desfire_3des_key_new ((uint8_t *)"App.B Key #2..  12345678");
+    res = mifare_desfire_change_key (tag, 2, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+    key = mifare_desfire_3des_key_new ((uint8_t *)"App.B Key #3... 12345678");
+    res = mifare_desfire_change_key (tag, 3, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+    key = mifare_desfire_3des_key_new ((uint8_t *)"App.B Key #4....12345678");
+    res = mifare_desfire_change_key (tag, 4, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (key);
+
+    std_data_file_id--;
+
+    res = mifare_desfire_create_std_data_file (tag, std_data_file_id, MDCM_PLAIN, 0x1234, 100);
+    cut_assert_success ("mifare_desfire_create_std_data_file()");
+    expected_value = -1000000;
+    res = mifare_desfire_create_value_file (tag, 4, 0, 0x1324, -987654321, -1000, expected_value, 1);
+    cut_assert_success ("mifare_desfire_create_value_file()");
+    res = mifare_desfire_create_linear_record_file (tag, 1, 0, 0x1324, 25, 4);
+
+    int nr = 0;
+    for (int transaction = 0; transaction < 7; transaction++) {
+	uint8_t cs = transaction % 3;
+	if (cs == 2) cs++;
+
+	key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Key #4....12345678");
+	res = mifare_desfire_authenticate_iso (tag, 4, key);
+	cut_assert_success ("mifare_desfire_authenticate_iso()");
+	mifare_desfire_key_free (key);
+
+	res = mifare_desfire_change_file_settings (tag, std_data_file_id, cs, 0x1234);
+	cut_assert_success ("mifare_desfire_change_file_settings()");
+	res = mifare_desfire_change_file_settings (tag, 4, cs, 0x1324);
+	cut_assert_success ("mifare_desfire_change_file_settings()");
+	res = mifare_desfire_change_file_settings (tag, 1, cs, 0x1324);
+	cut_assert_success ("mifare_desfire_change_file_settings()");
+
+	// Authenticate witht he write key
+	key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Key #2..  12345678");
+	res = mifare_desfire_authenticate_iso (tag, 2, key);
+	cut_assert_success ("mifare_desfire_authenticate_iso()");
+	mifare_desfire_key_free (key);
+
+	char data_buffer[100];
+	char data_buffer2[100];
+	char data_buffer3[100];
+	for (int i = 0; i < 100; i++)
+	    data_buffer[i] = transaction + i;
+
+	res = mifare_desfire_write_data (tag, std_data_file_id, 0, 100, data_buffer);
+	cut_assert_success ("mifare_desfire_write_data()");
+
+	sprintf (data_buffer2, "Transaction #%d", transaction);
+
+	res = mifare_desfire_write_data (tag, std_data_file_id, 5, strlen (data_buffer2), data_buffer2);
+	cut_assert_success ("mifare_desfire_write_data()");
+
+	memcpy (data_buffer + 5, data_buffer2, strlen (data_buffer2));
+
+	// Write to the linear record.  When it's full, erase it and restart.
+	for (int i = 0; i < 2; i++) {
+	    if ((transaction % 2 == 1) && (i == 1)) {
+		res = mifare_desfire_clear_record_file (tag, 1);
+		cut_assert_success ("mifare_desfire_clear_record_file()");
+
+		sprintf (data_buffer3, "Test invalid write");
+		res = mifare_desfire_write_record (tag, 1, 0, strlen (data_buffer3), data_buffer3);
+		cut_assert_equal_int (-1, res, cut_message ("error code"));
+		cut_assert_equal_int (PERMISSION_ERROR, mifare_desfire_last_picc_error (tag), cut_message ("PICC error"));
+
+		// The previous failure has aborted the transaction, so
+		// re-authenticate, then clear record again.
+		key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Key #2..  12345678");
+		res = mifare_desfire_authenticate_iso (tag, 2, key);
+		cut_assert_success ("mifare_desfire_authenticate_iso");
+		mifare_desfire_key_free (key);
+
+		res = mifare_desfire_clear_record_file (tag, 1);
+		cut_assert_success ("mifare_desfire_clear_record_file()");
+
+		res = mifare_desfire_commit_transaction (tag);
+		cut_assert_success ("mifare_desfire_commit_transaction()");
+		nr = 0;
+	    }
+
+	    res = mifare_desfire_write_record (tag, 1, 0, 25, "0123456789012345678901234");
+	    cut_assert_success ("mifare_desfire_write_record()");
+
+	    res = mifare_desfire_write_record (tag, 1, 5, strlen (data_buffer2), data_buffer2);
+	    cut_assert_success ("mifare_desfire_write_record()");
+	}
+	nr++;
+
+	// Modify the value file
+	res = mifare_desfire_debit (tag, 4, 1300);
+	cut_assert_success ("mifare_desfire_debit()");
+	expected_value -= 1300;
+	res = mifare_desfire_credit (tag, 4, 20);
+	cut_assert_success ("mifare_desfire_credit()");
+	expected_value += 20;
+	res = mifare_desfire_debit (tag, 4, 1700);
+	cut_assert_success ("mifare_desfire_debit()");
+	expected_value -= 1700;
+
+	// Commit
+	res = mifare_desfire_commit_transaction (tag);
+	cut_assert_success ("mifare_desfire_commit_transaction()");
+
+	// Refund the whole debited amount
+	res = mifare_desfire_limited_credit (tag, 4, 3000);
+	cut_assert_success ("mifare_desfire_limited_credit()");
+	expected_value += 3000;
+
+	// Commit
+	res = mifare_desfire_commit_transaction (tag);
+	cut_assert_success ("mifare_desfire_commit_transaction()");
+
+	// Authenticate with the key that allows reading
+	key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Key #1.   12345678");
+	res = mifare_desfire_authenticate_iso (tag, 1, key);
+	cut_assert_success ("mifare_desfire_authenticate_iso()");
+	mifare_desfire_key_free (key);
+
+	// Read first half of the file
+	res = mifare_desfire_read_data (tag, std_data_file_id, 0, 50, data_buffer3);
+	cut_assert_success ("mifare_desfire_read_data()");
+	cut_assert_equal_int (50, res, cut_message ("length"));
+	cut_assert_equal_memory (data_buffer, 50, data_buffer3, res, cut_message ("data"));
+
+	// Read second half of the file
+	res = mifare_desfire_read_data (tag, std_data_file_id, 50, 0, data_buffer3);
+	cut_assert_success ("mifare_desfire_read_data()");
+	cut_assert_equal_int (50, res, cut_message ("length"));
+	cut_assert_equal_memory (data_buffer + 50, 50, data_buffer3, res, cut_message ("data"));
+
+	// Get the value file current balance
+	int32_t value;
+	res = mifare_desfire_get_value (tag, 4, &value);
+	cut_assert_success ("mifare_desfire_get_value()");
+	cut_assert_equal_int (expected_value, value, cut_message ("value"));
+
+	// Get the number of records in the linear record file
+	struct mifare_desfire_file_settings settings;
+	res = mifare_desfire_get_file_settings (tag, 1, &settings);
+	cut_assert_success ("mifare_desfire_get_file_settings()");
+	cut_assert_equal_int (MDFT_LINEAR_RECORD_FILE_WITH_BACKUP, settings.file_type, cut_message ("settings"));
+	cut_assert_equal_int (nr, settings.settings.linear_record_file.current_number_of_records, cut_message ("settings"));
+
+	// Read the oldest record
+	res = mifare_desfire_read_records (tag, 1, nr - 1, 1, data_buffer3);
+	cut_assert_success ("mifare_desfire_read_records()");
+	cut_assert_equal_int (25, res, cut_message ("length"));
+
+	sprintf (data_buffer, "0123456789012345678901234");
+	sprintf (data_buffer2, "Transaction #%d", transaction - nr + 1);
+	memcpy ((uint8_t *)data_buffer + 5, data_buffer2, strlen (data_buffer2));
+	cut_assert_equal_memory (data_buffer, strlen (data_buffer), data_buffer3, res, cut_message ("data"));
+
+	// Read all records
+	res = mifare_desfire_read_records (tag, 1, 0, 0, data_buffer3);
+	cut_assert_success ("mifare_desfire_read_records()");
+	cut_assert_equal_int (25 * nr, res, cut_message ("length"));
+    }
+
+    res = mifare_desfire_get_file_ids (tag, &files, &file_count);
+    cut_assert_success ("mifare_desfire_get_file_ids");
+    cut_assert_equal_int (3, file_count, cut_message ("count"));
+
+    for (size_t i = 0; i < file_count; i++) {
+	struct mifare_desfire_file_settings settings;
+	res = mifare_desfire_get_file_settings (tag, files[i], &settings);
+	cut_assert_success ("mifare_desfire_get_file_settings()");
+
+	switch (files[i]) {
+	case 1:
+	    cut_assert_equal_int (MDFT_LINEAR_RECORD_FILE_WITH_BACKUP, settings.file_type, cut_message ("type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("cs"));
+	    cut_assert_equal_int (0x1324, settings.access_rights, cut_message ("access_rights"));
+	    cut_assert_equal_int (25, settings.settings.linear_record_file.record_size, cut_message ("record_size"));
+	    cut_assert_equal_int (4, settings.settings.linear_record_file.max_number_of_records, cut_message ("max_number_of_records"));
+	    cut_assert_equal_int (2, settings.settings.linear_record_file.current_number_of_records, cut_message ("current_number_of_records"));
+	    break;
+	case 4:
+	    cut_assert_equal_int (MDFT_VALUE_FILE_WITH_BACKUP , settings.file_type, cut_message ("type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("cs"));
+	    cut_assert_equal_int (0x1324, settings.access_rights, cut_message ("access_rights"));
+	    cut_assert_equal_int (-987654321, settings.settings.value_file.lower_limit, cut_message ("lower_limit"));
+	    cut_assert_equal_int (-1000, settings.settings.value_file.upper_limit, cut_message ("upper_limit"));
+	    cut_assert_equal_int (0, settings.settings.value_file.limited_credit_value, cut_message ("limited_credit_value"));
+	    cut_assert_equal_int (1, settings.settings.value_file.limited_credit_enabled, cut_message ("limited_credit_enabled"));
+	    break;
+	case 14: /* std_data_file_id */
+	    cut_assert_equal_int (MDFT_STANDARD_DATA_FILE, settings.file_type, cut_message ("type"));
+	    cut_assert_equal_int (MDCM_PLAIN, settings.communication_settings, cut_message ("cs"));
+	    cut_assert_equal_int (0x1234, settings.access_rights, cut_message ("access_rights"));
+	    cut_assert_equal_int (100, settings.settings.standard_file.file_size, cut_message ("size"));
+	    break;
+	default:
+	    cut_fail ("file_no");
+
+	}
+
+	res = mifare_desfire_delete_file (tag, files[i]);
+	cut_assert_success ("mifare_desfire_delete_file()");
+    }
+    free (files);
+
+    // Check there are no files anymore
+    res = mifare_desfire_get_file_ids (tag, &files, &file_count);
+    cut_assert_success ("mifare_desfire_get_file_ids");
+    cut_assert_equal_int (0, file_count, cut_message ("count"));
+
+    /* Delete application B */
+    key = mifare_desfire_3des_key_new ((uint8_t *) "App.B Master Key12345678");
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    res = mifare_desfire_delete_application (tag, aid_b);
+    cut_assert_success ("mifare_desfire_delete_application()");
+
+    res = mifare_desfire_get_application_ids (tag, &aids, &aid_count);
+    cut_assert_success ("mifare_desfire_get_application_ids()");
+    cut_assert_equal_int (1, aid_count, cut_message ("Wrong AID count"));
+    mifare_desfire_free_application_ids (aids);
+
+    /* Tests using application C */
+
+    res = mifare_desfire_select_application (tag, aid_c);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    key = mifare_desfire_des_key_new (key_data_null);
+    res = mifare_desfire_authenticate (tag, 12, key);
+    cut_assert_success ("mifare_desfire_authenticate()");
+
+    MifareDESFireKey new_key = mifare_desfire_3des_key_new ((uint8_t *)"App.C Key #1.   12345678");
+    res = mifare_desfire_change_key (tag, 1, new_key, key);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (new_key);
+
+    new_key = mifare_desfire_3des_key_new ((uint8_t *)"App.C Key #2..  12345678");
+    res = mifare_desfire_change_key (tag, 2, new_key, key);
+    cut_assert_success ("mifare_desfire_change_key()");
+    mifare_desfire_key_free (new_key);
+
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+
+    res = mifare_desfire_create_cyclic_record_file (tag, 6, MDCM_PLAIN, 0x12E0, 100, 22);
+    cut_assert_success ("mifare_desfire_create_cyclic_record_file()");
+
+    for (int transaction = 0; transaction < 50; transaction++) {
+	char data_buffer[100];
+	char read_buffer[100];
+
+	uint8_t cs = transaction % 3;
+	if (cs == 2) cs++;
+
+	key = mifare_desfire_des_key_new (key_data_null);
+	res = mifare_desfire_authenticate (tag, 0, key);
+	cut_assert_success ("mifare_desfire_authenticate()");
+	mifare_desfire_key_free (key);
+
+	res = mifare_desfire_change_file_settings (tag, 6, cs, 0x12E0);
+	cut_assert_success ("mifare_desfire_change_file_settings()");
+
+	if (transaction & 4) {
+	    key = mifare_desfire_3des_key_new ((uint8_t *) "App.C Key #2..  12345678");
+	    res = mifare_desfire_authenticate_iso (tag, 2, key);
+	    cut_assert_success ("mifare_desfire_authenticate_iso()");
+	    mifare_desfire_key_free (key);
+	} else {
+	    cs = 0;
+	}
+
+	memset (data_buffer, '_', 100);
+	data_buffer[0]  = transaction;
+	data_buffer[99] = transaction;
+	sprintf (data_buffer + 5, " Transaction #%d ", transaction);
+	res = mifare_desfire_write_record (tag, 6, 0, 100, data_buffer);
+	cut_assert_success ("mifare_desfire_write_record()");
+
+	if (transaction & 4) {
+	    key = mifare_desfire_3des_key_new ((uint8_t *) "App.C Key #1.   12345678");
+	    res = mifare_desfire_authenticate_iso (tag, 1, key);
+	    cut_assert_success ("mifare_desfire_authenticate_iso()");
+	    mifare_desfire_key_free (key);
+	}
+
+	if (transaction % 7 == 0) {
+	    res = mifare_desfire_abort_transaction (tag);
+	    cut_assert_success ("mifare_desfire_abort_transaction()");
+
+	    ssize_t n = mifare_desfire_read_records (tag, 6, 0, 1, read_buffer);
+	    if (transaction == 0) {
+		cut_assert_equal_int (-1, n, cut_message ("Wrong return value"));
+	    } else {
+		cut_assert_equal_int (100, n, cut_message ("Wrong return value"));
+		cut_assert_not_equal_memory (data_buffer, sizeof (data_buffer), read_buffer, sizeof (read_buffer), cut_message ("Wrong data"));
+	    }
+	} else {
+	    res = mifare_desfire_commit_transaction (tag);
+	    cut_assert_success ("mifare_desfire_commit_transaction()");
+
+	    ssize_t n = mifare_desfire_read_records (tag, 6, 0, 1, read_buffer);
+	    cut_assert_equal_int (100, n, cut_message ("Wrong return value"));
+	    cut_assert_equal_memory (data_buffer, sizeof (data_buffer), read_buffer, sizeof (read_buffer), cut_message ("Wrong data"));
+	}
+    }
+
+    // Read each record
+    key = mifare_desfire_3des_key_new ((uint8_t *) "App.C Key #1.   12345678");
+    res = mifare_desfire_authenticate_iso (tag, 1, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    int t = 49;
+    for (int i = 0; i < 22; i++) {
+	char data_buffer[100];
+	char ref_data_buffer[100];
+
+	if (0 == (t % 7))
+	    t--;
+
+	memset (ref_data_buffer, '_', 100);
+	ref_data_buffer[0]  = t;
+	ref_data_buffer[99] = t;
+	sprintf (ref_data_buffer + 5, " Transaction #%d ", t);
+	res = mifare_desfire_read_records (tag, 6, i, 1, data_buffer);
+	if (i == 21) {
+	    cut_assert_equal_int (-1, res, cut_message ("return value"));
+	} else {
+	    cut_assert_success ("mifare_desfire_read_records()");
+	    cut_assert_equal_memory (ref_data_buffer, 100, data_buffer, res, cut_message ("data"));
+	}
+
+	t--;
+    }
+
+    /*
+     * Change master key settings to require master key authentication for all
+     * card operations.  Only allow to revert this.
+     */
+
+    res = mifare_desfire_select_application (tag, 0);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    key = mifare_desfire_3des_key_new (key_data_3des);
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    res = mifare_desfire_change_key_settings (tag, 0x08);
+    cut_assert_success ("mifare_desfire_change_key_settings()");
+
+    /* Clear authentication */
+    res = mifare_desfire_select_application (tag, 0);
+    cut_assert_success ("mifare_desfire_select_application()");
+
+    /* We should not be able to list applications now */
+    res = mifare_desfire_get_application_ids (tag, &aids, &aid_count);
+    cut_assert_equal_int (-1, res, cut_message ("Wrong return value"));
+    cut_assert_equal_int (AUTHENTICATION_ERROR, mifare_desfire_last_picc_error (tag), cut_message ("Wrong PICC error"));
+
+    /* Deleting an application should not be possible */
+    res = mifare_desfire_delete_application (tag, aid_c);
+    cut_assert_equal_int (-1, res, cut_message ("Wrong return value"));
+    cut_assert_equal_int (AUTHENTICATION_ERROR, mifare_desfire_last_picc_error (tag), cut_message ("Wrong PICC error"));
+
+    /* Creating an application should also be forbidden */
+    MifareDESFireAID aid_d = mifare_desfire_aid_new (0x00DDDDDD);
+    res = mifare_desfire_create_application (tag, aid_d, 0xEF, 0);
+    cut_assert_equal_int (-1, res, cut_message ("Wrong return value"));
+    cut_assert_equal_int (AUTHENTICATION_ERROR, mifare_desfire_last_picc_error (tag), cut_message ("Wrong PICC error"));
+
+    /*
+     * Now we retry authenticated with the master key.
+     */
+    key = mifare_desfire_3des_key_new (key_data_3des);
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    /* We should be able to list applications again */
+    res = mifare_desfire_get_application_ids (tag, &aids, &aid_count);
+    cut_assert_success ("mifare_desfire_get_application_ids()");
+    cut_assert_equal_int (1, aid_count, cut_message ("Wrong AID count"));
+    mifare_desfire_free_application_ids (aids);
+
+    /* Deleting an application should be possible again */
+    res = mifare_desfire_delete_application (tag, aid_c);
+    cut_assert_success ("mifare_desfire_delete_application()");
+
+    /* Creating an application should also be possible */
+    res = mifare_desfire_create_application (tag, aid_d, 0xEF, 0);
+    cut_assert_success ("mifare_desfire_create_application()");
+
+    /* Revert master key settings to default */
+    res = mifare_desfire_change_key_settings (tag, 0xF);
+    cut_assert_success ("mifare_desfire_change_key_settings()");
+
+    /* Change the master key back to the default one */
+    key = mifare_desfire_3des_key_new (key_data_3des);
+    res = mifare_desfire_authenticate_iso (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate_iso()");
+    mifare_desfire_key_free (key);
+
+    key = mifare_desfire_des_key_new_with_version (key_data_null);
+    res = mifare_desfire_change_key (tag, 0, key, NULL);
+    cut_assert_success ("mifare_desfire_change_key()");
+
+    /*
+     * Delete everything from the card
+     */
+
+    res = mifare_desfire_authenticate (tag, 0, key);
+    cut_assert_success ("mifare_desfire_authenticate()");
+    mifare_desfire_key_free (key);
+
+    res = mifare_desfire_format_picc (tag);
+    cut_assert_success ("mifare_desfire_format_picc()");
+
+    free (aid_a);
+    free (aid_b);
+    free (aid_c);
+    free (aid_d);
+}
+