[proxmark3-svn] / common / desfire.h

#ifndef __DESFIRE_H
#define __DESFIRE_H

#include "aes.h"
#define DESFIRE(tag) ((struct desfire_tag *) tag)
#define DESFIRE_KEY(key) ((struct desfire_key *) key)

#define MAX_CRYPTO_BLOCK_SIZE 16
/* Mifare DESFire EV1 Application crypto operations */
#define APPLICATION_CRYPTO_DES    0x00
#define APPLICATION_CRYPTO_3K3DES 0x40
#define APPLICATION_CRYPTO_AES    0x80

#define MAC_LENGTH 4
#define CMAC_LENGTH 8

typedef enum {
    MCD_SEND,
    MCD_RECEIVE
} MifareCryptoDirection;

typedef enum {
    MCO_ENCYPHER,
    MCO_DECYPHER
} MifareCryptoOperation;

#define MDCM_MASK 0x000F

#define CMAC_NONE 0

// Data send to the PICC is used to update the CMAC
#define CMAC_COMMAND 0x010
// Data received from the PICC is used to update the CMAC
#define CMAC_VERIFY  0x020

// MAC the command (when MDCM_MACED)
#define MAC_COMMAND 0x100
// The command returns a MAC to verify (when MDCM_MACED)
#define MAC_VERIFY  0x200

#define ENC_COMMAND 0x1000
#define NO_CRC      0x2000

#define MAC_MASK   0x0F0
#define CMAC_MACK  0xF00

/* Communication mode */
#define MDCM_PLAIN      0x00
#define MDCM_MACED      0x01
#define MDCM_ENCIPHERED 0x03

/* Error code managed by the library */
#define CRYPTO_ERROR            0x01


enum DESFIRE_AUTH_SCHEME {
	AS_LEGACY,
	AS_NEW
};

enum DESFIRE_CRYPTOALGO {
	T_DES = 0x00,
	T_3DES = 0x01,
	T_3K3DES = 0x02,
	T_AES = 0x03
};

struct desfire_key {

    enum DESFIRE_CRYPTOALGO type;
    uint8_t data[24];
    // DES_key_schedule ks1;
    // DES_key_schedule ks2;
    // DES_key_schedule ks3;
	AesCtx aes_ks;
    uint8_t cmac_sk1[24];
    uint8_t cmac_sk2[24];
    uint8_t aes_version;
};

typedef struct desfire_key *desfirekey_t;

struct desfire_tag {
    iso14a_card_select_t info;
    int active;
    uint8_t last_picc_error;
    uint8_t last_internal_error;
    uint8_t last_pcd_error;
    desfirekey_t session_key;
	enum DESFIRE_AUTH_SCHEME authentication_scheme;
    uint8_t authenticated_key_no;
    
	uint8_t ivect[MAX_CRYPTO_BLOCK_SIZE];
    uint8_t cmac[16];
    uint8_t *crypto_buffer;
    size_t crypto_buffer_size;
    uint32_t selected_application;
};
typedef struct desfire_tag *desfiretag_t;


/* File types */
enum DESFIRE_FILE_TYPES {
    MDFT_STANDARD_DATA_FILE             = 0x00,
    MDFT_BACKUP_DATA_FILE               = 0x01,
    MDFT_VALUE_FILE_WITH_BACKUP         = 0x02,
    MDFT_LINEAR_RECORD_FILE_WITH_BACKUP = 0x03,
    MDFT_CYCLIC_RECORD_FILE_WITH_BACKUP = 0x04
};


enum DESFIRE_STATUS {
    OPERATION_OK 				= 0x00,
    NO_CHANGES 					= 0x0c,
    OUT_OF_EEPROM_ERROR 		= 0x0e,
    ILLEGAL_COMMAND_CODE 		= 0x1c,
    INTEGRITY_ERROR 			= 0x1e,
    NO_SUCH_KEY 				= 0x40,
    LENGTH_ERROR 				= 0x7e,
    PERMISSION_DENIED 			= 0x9d,
    PARAMETER_ERROR 			= 0x9e,
    APPLICATION_NOT_FOUND 		= 0xa0,
    APPL_INTEGRITY_ERROR 		= 0xa1,
    AUTHENTICATION_ERROR 		= 0xae,
    ADDITIONAL_FRAME 			= 0xaf,
    BOUNDARY_ERROR 				= 0xbe,
    PICC_INTEGRITY_ERROR 		= 0xc1,
    COMMAND_ABORTED 			= 0xca,
    PICC_DISABLED_ERROR 		= 0xcd,
    COUNT_ERROR 				= 0xce,
    DUPLICATE_ERROR 			= 0xde,
    EEPROM_ERROR 				= 0xee,
    FILE_NOT_FOUND 				= 0xf0,
    FILE_INTEGRITY_ERROR 		= 0xf1
};

enum DESFIRE_CMD {
    CREATE_APPLICATION 			= 0xca,
    DELETE_APPLICATION 			= 0xda,
    GET_APPLICATION_IDS 		= 0x6a,
    SELECT_APPLICATION 			= 0x5a,
    FORMAT_PICC 				= 0xfc,
    GET_VERSION 				= 0x60,
    READ_DATA 					= 0xbd,
    WRITE_DATA					= 0x3d,
    GET_VALUE 					= 0x6c,
    CREDIT 						= 0x0c,
    DEBIT 						= 0xdc,
    LIMITED_CREDIT 				= 0x1c,
    WRITE_RECORD 				= 0x3b,
    READ_RECORDS 				= 0xbb,
    CLEAR_RECORD_FILE 			= 0xeb,
    COMMIT_TRANSACTION 			= 0xc7,
    ABORT_TRANSACTION 			= 0xa7,
    GET_FREE_MEMORY             = 0x6e,
	GET_FILE_IDS 				= 0x6f,
    GET_FILE_SETTINGS 			= 0xf5,
    CHANGE_FILE_SETTINGS 		= 0x5f,
    CREATE_STD_DATA_FILE 		= 0xcd,
    CREATE_BACKUP_DATA_FILE 	= 0xcb,
    CREATE_VALUE_FILE 			= 0xcc,
    CREATE_LINEAR_RECORD_FILE 	= 0xc1,
    CREATE_CYCLIC_RECORD_FILE 	= 0xc0,
    DELETE_FILE 				= 0xdf,
    AUTHENTICATE	 			= 0x0a,  // AUTHENTICATE_NATIVE
	AUTHENTICATE_ISO 			= 0x1a,  // AUTHENTICATE_STANDARD
	AUTHENTICATE_AES 			= 0xaa,
    CHANGE_KEY_SETTINGS 		= 0x54,
    GET_KEY_SETTINGS 			= 0x45,
    CHANGE_KEY 					= 0xc4,
    GET_KEY_VERSION 			= 0x64,
    AUTHENTICATION_FRAME 		= 0xAF
};

#endif
Commit	Line	Data
f38a1528	1	#ifndef __DESFIRE_H
	2	#define __DESFIRE_H
	3
	4	#include "aes.h"
	5	#define DESFIRE(tag) ((struct desfire_tag *) tag)
	6	#define DESFIRE_KEY(key) ((struct desfire_key *) key)
	7
	8	#define MAX_CRYPTO_BLOCK_SIZE 16
	9	/* Mifare DESFire EV1 Application crypto operations */
	10	#define APPLICATION_CRYPTO_DES 0x00
	11	#define APPLICATION_CRYPTO_3K3DES 0x40
	12	#define APPLICATION_CRYPTO_AES 0x80
	13
	14	#define MAC_LENGTH 4
	15	#define CMAC_LENGTH 8
	16
	17	typedef enum {
	18	MCD_SEND,
	19	MCD_RECEIVE
	20	} MifareCryptoDirection;
	21
	22	typedef enum {
	23	MCO_ENCYPHER,
	24	MCO_DECYPHER
	25	} MifareCryptoOperation;
	26
	27	#define MDCM_MASK 0x000F
	28
	29	#define CMAC_NONE 0
	30
	31	// Data send to the PICC is used to update the CMAC
	32	#define CMAC_COMMAND 0x010
	33	// Data received from the PICC is used to update the CMAC
	34	#define CMAC_VERIFY 0x020
	35
	36	// MAC the command (when MDCM_MACED)
	37	#define MAC_COMMAND 0x100
	38	// The command returns a MAC to verify (when MDCM_MACED)
	39	#define MAC_VERIFY 0x200
	40
	41	#define ENC_COMMAND 0x1000
	42	#define NO_CRC 0x2000
	43
	44	#define MAC_MASK 0x0F0
	45	#define CMAC_MACK 0xF00
	46
	47	/* Communication mode */
	48	#define MDCM_PLAIN 0x00
	49	#define MDCM_MACED 0x01
	50	#define MDCM_ENCIPHERED 0x03
	51
	52	/* Error code managed by the library */
	53	#define CRYPTO_ERROR 0x01
	54
	55
	56	enum DESFIRE_AUTH_SCHEME {
	57	AS_LEGACY,
	58	AS_NEW
	59	};
	60
	61	enum DESFIRE_CRYPTOALGO {
	62	T_DES = 0x00,
	63	T_3DES = 0x01,
	64	T_3K3DES = 0x02,
65	T_AES = 0x03
66	};
67
68	struct desfire_key {
69
70	enum DESFIRE_CRYPTOALGO type;
71	uint8_t data[24];
72	// DES_key_schedule ks1;
73	// DES_key_schedule ks2;
74	// DES_key_schedule ks3;
75	AesCtx aes_ks;
76	uint8_t cmac_sk1[24];
77	uint8_t cmac_sk2[24];
78	uint8_t aes_version;
79	};
80
81	typedef struct desfire_key *desfirekey_t;
82
83	struct desfire_tag {
84	iso14a_card_select_t info;
85	int active;
86	uint8_t last_picc_error;
87	uint8_t last_internal_error;
88	uint8_t last_pcd_error;
89	desfirekey_t session_key;
90	enum DESFIRE_AUTH_SCHEME authentication_scheme;
91	uint8_t authenticated_key_no;
92
93	uint8_t ivect[MAX_CRYPTO_BLOCK_SIZE];
94	uint8_t cmac[16];
95	uint8_t *crypto_buffer;
96	size_t crypto_buffer_size;
97	uint32_t selected_application;
98	};
99	typedef struct desfire_tag *desfiretag_t;
100
101
102	/* File types */
103	enum DESFIRE_FILE_TYPES {
104	MDFT_STANDARD_DATA_FILE = 0x00,
105	MDFT_BACKUP_DATA_FILE = 0x01,
106	MDFT_VALUE_FILE_WITH_BACKUP = 0x02,
107	MDFT_LINEAR_RECORD_FILE_WITH_BACKUP = 0x03,
108	MDFT_CYCLIC_RECORD_FILE_WITH_BACKUP = 0x04
109	};
110
111
112
113	enum DESFIRE_STATUS {
114	OPERATION_OK = 0x00,
115	NO_CHANGES = 0x0c,
116	OUT_OF_EEPROM_ERROR = 0x0e,
117	ILLEGAL_COMMAND_CODE = 0x1c,
118	INTEGRITY_ERROR = 0x1e,
119	NO_SUCH_KEY = 0x40,
120	LENGTH_ERROR = 0x7e,
121	PERMISSION_DENIED = 0x9d,
122	PARAMETER_ERROR = 0x9e,
123	APPLICATION_NOT_FOUND = 0xa0,
124	APPL_INTEGRITY_ERROR = 0xa1,
125	AUTHENTICATION_ERROR = 0xae,
126	ADDITIONAL_FRAME = 0xaf,
127	BOUNDARY_ERROR = 0xbe,
128	PICC_INTEGRITY_ERROR = 0xc1,
129	COMMAND_ABORTED = 0xca,
130	PICC_DISABLED_ERROR = 0xcd,
131	COUNT_ERROR = 0xce,
132	DUPLICATE_ERROR = 0xde,
133	EEPROM_ERROR = 0xee,
134	FILE_NOT_FOUND = 0xf0,
135	FILE_INTEGRITY_ERROR = 0xf1
136	};
137
138	enum DESFIRE_CMD {
139	CREATE_APPLICATION = 0xca,
140	DELETE_APPLICATION = 0xda,
141	GET_APPLICATION_IDS = 0x6a,
142	SELECT_APPLICATION = 0x5a,
143	FORMAT_PICC = 0xfc,
144	GET_VERSION = 0x60,
145	READ_DATA = 0xbd,
146	WRITE_DATA = 0x3d,
147	GET_VALUE = 0x6c,
148	CREDIT = 0x0c,
149	DEBIT = 0xdc,
150	LIMITED_CREDIT = 0x1c,
151	WRITE_RECORD = 0x3b,
152	READ_RECORDS = 0xbb,
153	CLEAR_RECORD_FILE = 0xeb,
154	COMMIT_TRANSACTION = 0xc7,
155	ABORT_TRANSACTION = 0xa7,
156	GET_FREE_MEMORY = 0x6e,
157	GET_FILE_IDS = 0x6f,
158	GET_FILE_SETTINGS = 0xf5,
159	CHANGE_FILE_SETTINGS = 0x5f,
160	CREATE_STD_DATA_FILE = 0xcd,
161	CREATE_BACKUP_DATA_FILE = 0xcb,
162	CREATE_VALUE_FILE = 0xcc,
163	CREATE_LINEAR_RECORD_FILE = 0xc1,
164	CREATE_CYCLIC_RECORD_FILE = 0xc0,
165	DELETE_FILE = 0xdf,
166	AUTHENTICATE = 0x0a, // AUTHENTICATE_NATIVE
167	AUTHENTICATE_ISO = 0x1a, // AUTHENTICATE_STANDARD
168	AUTHENTICATE_AES = 0xaa,
169	CHANGE_KEY_SETTINGS = 0x54,
170	GET_KEY_SETTINGS = 0x45,
171	CHANGE_KEY = 0xc4,
172	GET_KEY_VERSION = 0x64,
173	AUTHENTICATION_FRAME = 0xAF
174	};
175
176	#endif
177