mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2024-09-21 15:56:21 +08:00
53d5dc643f
Added a lot of #ifndef , extern C, Move inside from ARMSRC -> THUMBS, which made the compiled image smaller.. I don't know if it broke anything. Moved MF_DBGLEVEL definitions into common.h Moved print_result from util.c into appmain.c Also split up some struct typedef into header files so they could be reused in other code places. ''' danger ''' this might have broken stuff...
638 lines
21 KiB
C
638 lines
21 KiB
C
/*-
|
|
* 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$
|
|
*/
|
|
|
|
/*
|
|
* This implementation was written based on information provided by the
|
|
* following documents:
|
|
*
|
|
* NIST Special Publication 800-38B
|
|
* Recommendation for Block Cipher Modes of Operation: The CMAC Mode for Authentication
|
|
* May 2005
|
|
*/
|
|
#include "desfire_crypto.h"
|
|
|
|
static void xor (const uint8_t *ivect, uint8_t *data, const size_t len);
|
|
static size_t key_macing_length (desfirekey_t key);
|
|
|
|
static void xor (const uint8_t *ivect, uint8_t *data, const size_t len) {
|
|
for (size_t i = 0; i < len; i++) {
|
|
data[i] ^= ivect[i];
|
|
}
|
|
}
|
|
|
|
void cmac_generate_subkeys ( desfirekey_t key) {
|
|
int kbs = key_block_size (key);
|
|
const uint8_t R = (kbs == 8) ? 0x1B : 0x87;
|
|
|
|
uint8_t l[kbs];
|
|
memset (l, 0, kbs);
|
|
|
|
uint8_t ivect[kbs];
|
|
memset (ivect, 0, kbs);
|
|
|
|
mifare_cypher_blocks_chained (NULL, key, ivect, l, kbs, MCD_RECEIVE, MCO_ENCYPHER);
|
|
|
|
bool xor = false;
|
|
|
|
// Used to compute CMAC on complete blocks
|
|
memcpy (key->cmac_sk1, l, kbs);
|
|
xor = l[0] & 0x80;
|
|
lsl (key->cmac_sk1, kbs);
|
|
if (xor)
|
|
key->cmac_sk1[kbs-1] ^= R;
|
|
|
|
// Used to compute CMAC on the last block if non-complete
|
|
memcpy (key->cmac_sk2, key->cmac_sk1, kbs);
|
|
xor = key->cmac_sk1[0] & 0x80;
|
|
lsl (key->cmac_sk2, kbs);
|
|
if (xor)
|
|
key->cmac_sk2[kbs-1] ^= R;
|
|
}
|
|
|
|
void cmac (const desfirekey_t key, uint8_t *ivect, const uint8_t *data, size_t len, uint8_t *cmac) {
|
|
int kbs = key_block_size (key);
|
|
uint8_t *buffer = malloc (padded_data_length (len, kbs));
|
|
|
|
memcpy (buffer, data, len);
|
|
|
|
if ((!len) || (len % kbs)) {
|
|
buffer[len++] = 0x80;
|
|
while (len % kbs) {
|
|
buffer[len++] = 0x00;
|
|
}
|
|
xor (key->cmac_sk2, buffer + len - kbs, kbs);
|
|
} else {
|
|
xor (key->cmac_sk1, buffer + len - kbs, kbs);
|
|
}
|
|
|
|
mifare_cypher_blocks_chained (NULL, key, ivect, buffer, len, MCD_SEND, MCO_ENCYPHER);
|
|
|
|
memcpy (cmac, ivect, kbs);
|
|
free(buffer);
|
|
}
|
|
|
|
size_t key_block_size (const desfirekey_t key) {
|
|
size_t block_size = 8;
|
|
switch (key->type) {
|
|
case T_DES:
|
|
case T_3DES:
|
|
case T_3K3DES:
|
|
block_size = 8;
|
|
break;
|
|
case T_AES:
|
|
block_size = 16;
|
|
break;
|
|
}
|
|
return block_size;
|
|
}
|
|
|
|
/*
|
|
* Size of MACing produced with the key.
|
|
*/
|
|
static size_t key_macing_length (const desfirekey_t key) {
|
|
size_t mac_length = MAC_LENGTH;
|
|
switch (key->type) {
|
|
case T_DES:
|
|
case T_3DES:
|
|
mac_length = MAC_LENGTH;
|
|
break;
|
|
case T_3K3DES:
|
|
case T_AES:
|
|
mac_length = CMAC_LENGTH;
|
|
break;
|
|
}
|
|
return mac_length;
|
|
}
|
|
|
|
/*
|
|
* Size required to store nbytes of data in a buffer of size n*block_size.
|
|
*/
|
|
size_t padded_data_length (const size_t nbytes, const size_t block_size) {
|
|
if ((!nbytes) || (nbytes % block_size))
|
|
return ((nbytes / block_size) + 1) * block_size;
|
|
else
|
|
return nbytes;
|
|
}
|
|
|
|
/*
|
|
* Buffer size required to MAC nbytes of data
|
|
*/
|
|
size_t maced_data_length (const desfirekey_t key, const size_t nbytes) {
|
|
return nbytes + key_macing_length (key);
|
|
}
|
|
/*
|
|
* Buffer size required to encipher nbytes of data and a two bytes CRC.
|
|
*/
|
|
size_t enciphered_data_length (const desfiretag_t tag, const size_t nbytes, int communication_settings) {
|
|
size_t crc_length = 0;
|
|
if (!(communication_settings & NO_CRC)) {
|
|
switch (DESFIRE(tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
crc_length = 2;
|
|
break;
|
|
case AS_NEW:
|
|
crc_length = 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
size_t block_size = DESFIRE(tag)->session_key ? key_block_size (DESFIRE(tag)->session_key) : 1;
|
|
|
|
return padded_data_length (nbytes + crc_length, block_size);
|
|
}
|
|
|
|
void* mifare_cryto_preprocess_data (desfiretag_t tag, void *data, size_t *nbytes, size_t offset, int communication_settings) {
|
|
uint8_t *res = data;
|
|
uint8_t mac[4];
|
|
size_t edl;
|
|
bool append_mac = true;
|
|
desfirekey_t key = DESFIRE(tag)->session_key;
|
|
|
|
if (!key)
|
|
return data;
|
|
|
|
switch (communication_settings & MDCM_MASK) {
|
|
case MDCM_PLAIN:
|
|
if (AS_LEGACY == DESFIRE(tag)->authentication_scheme)
|
|
break;
|
|
|
|
/*
|
|
* When using new authentication methods, PLAIN data transmission from
|
|
* the PICC to the PCD are CMACed, so we have to maintain the
|
|
* cryptographic initialisation vector up-to-date to check data
|
|
* integrity later.
|
|
*
|
|
* The only difference with CMACed data transmission is that the CMAC
|
|
* is not apended to the data send by the PCD to the PICC.
|
|
*/
|
|
|
|
append_mac = false;
|
|
|
|
/* pass through */
|
|
case MDCM_MACED:
|
|
switch (DESFIRE(tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
if (!(communication_settings & MAC_COMMAND))
|
|
break;
|
|
|
|
/* pass through */
|
|
edl = padded_data_length (*nbytes - offset, key_block_size (DESFIRE(tag)->session_key)) + offset;
|
|
|
|
// Fill in the crypto buffer with data ...
|
|
memcpy (res, data, *nbytes);
|
|
// ... and 0 padding
|
|
memset (res + *nbytes, 0, edl - *nbytes);
|
|
|
|
mifare_cypher_blocks_chained (tag, NULL, NULL, res + offset, edl - offset, MCD_SEND, MCO_ENCYPHER);
|
|
|
|
memcpy (mac, res + edl - 8, 4);
|
|
|
|
// Copy again provided data (was overwritten by mifare_cypher_blocks_chained)
|
|
memcpy (res, data, *nbytes);
|
|
|
|
if (!(communication_settings & MAC_COMMAND))
|
|
break;
|
|
// Append MAC
|
|
size_t bla = maced_data_length (DESFIRE(tag)->session_key, *nbytes - offset) + offset;
|
|
bla++;
|
|
|
|
memcpy (res + *nbytes, mac, 4);
|
|
|
|
*nbytes += 4;
|
|
break;
|
|
case AS_NEW:
|
|
if (!(communication_settings & CMAC_COMMAND))
|
|
break;
|
|
cmac (key, DESFIRE (tag)->ivect, res, *nbytes, DESFIRE (tag)->cmac);
|
|
|
|
if (append_mac) {
|
|
size_t len = maced_data_length (key, *nbytes);
|
|
++len;
|
|
memcpy (res, data, *nbytes);
|
|
memcpy (res + *nbytes, DESFIRE (tag)->cmac, CMAC_LENGTH);
|
|
*nbytes += CMAC_LENGTH;
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case MDCM_ENCIPHERED:
|
|
/* |<-------------- data -------------->|
|
|
* |<--- offset -->| |
|
|
* +---------------+--------------------+-----+---------+
|
|
* | CMD + HEADERS | DATA TO BE SECURED | CRC | PADDING |
|
|
* +---------------+--------------------+-----+---------+ ----------------
|
|
* | |<~~~~v~~~~~~~~~~~~~>| ^ | | (DES / 3DES)
|
|
* | | `---- crc16() ----' | |
|
|
* | | | ^ | | ----- *or* -----
|
|
* |<~~~~~~~~~~~~~~~~~~~~v~~~~~~~~~~~~~>| ^ | | (3K3DES / AES)
|
|
* | `---- crc32() ----' | |
|
|
* | | ---- *then* ----
|
|
* |<---------------------------------->|
|
|
* encypher()/decypher()
|
|
*/
|
|
|
|
if (!(communication_settings & ENC_COMMAND))
|
|
break;
|
|
edl = enciphered_data_length (tag, *nbytes - offset, communication_settings) + offset;
|
|
|
|
// Fill in the crypto buffer with data ...
|
|
memcpy (res, data, *nbytes);
|
|
if (!(communication_settings & NO_CRC)) {
|
|
// ... CRC ...
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
AppendCrc14443a(res + offset, *nbytes - offset);
|
|
*nbytes += 2;
|
|
break;
|
|
case AS_NEW:
|
|
crc32_append (res, *nbytes);
|
|
*nbytes += 4;
|
|
break;
|
|
}
|
|
}
|
|
// ... and padding
|
|
memset (res + *nbytes, 0, edl - *nbytes);
|
|
|
|
*nbytes = edl;
|
|
|
|
mifare_cypher_blocks_chained (tag, NULL, NULL, res + offset, *nbytes - offset, MCD_SEND, (AS_NEW == DESFIRE(tag)->authentication_scheme) ? MCO_ENCYPHER : MCO_DECYPHER);
|
|
break;
|
|
default:
|
|
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
break;
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, size_t *nbytes, int communication_settings)
|
|
{
|
|
void *res = data;
|
|
size_t edl;
|
|
void *edata = NULL;
|
|
uint8_t first_cmac_byte = 0x00;
|
|
|
|
desfirekey_t key = DESFIRE(tag)->session_key;
|
|
|
|
if (!key)
|
|
return data;
|
|
|
|
// Return directly if we just have a status code.
|
|
if (1 == *nbytes)
|
|
return res;
|
|
|
|
switch (communication_settings & MDCM_MASK) {
|
|
case MDCM_PLAIN:
|
|
|
|
if (AS_LEGACY == DESFIRE(tag)->authentication_scheme)
|
|
break;
|
|
|
|
/* pass through */
|
|
case MDCM_MACED:
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
if (communication_settings & MAC_VERIFY) {
|
|
*nbytes -= key_macing_length (key);
|
|
if (*nbytes <= 0) {
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
#ifdef WITH_DEBUG
|
|
Dbprintf ("No room for MAC!");
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
edl = enciphered_data_length (tag, *nbytes - 1, communication_settings);
|
|
edata = malloc (edl);
|
|
|
|
memcpy (edata, data, *nbytes - 1);
|
|
memset ((uint8_t *)edata + *nbytes - 1, 0, edl - *nbytes + 1);
|
|
|
|
mifare_cypher_blocks_chained (tag, NULL, NULL, edata, edl, MCD_SEND, MCO_ENCYPHER);
|
|
|
|
if (0 != memcmp ((uint8_t *)data + *nbytes - 1, (uint8_t *)edata + edl - 8, 4)) {
|
|
#ifdef WITH_DEBUG
|
|
Dbprintf ("MACing not verified");
|
|
hexdump ((uint8_t *)data + *nbytes - 1, key_macing_length (key), "Expect ", 0);
|
|
hexdump ((uint8_t *)edata + edl - 8, key_macing_length (key), "Actual ", 0);
|
|
#endif
|
|
DESFIRE (tag)->last_pcd_error = CRYPTO_ERROR;
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case AS_NEW:
|
|
if (!(communication_settings & CMAC_COMMAND))
|
|
break;
|
|
if (communication_settings & CMAC_VERIFY) {
|
|
if (*nbytes < 9) {
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
break;
|
|
}
|
|
first_cmac_byte = ((uint8_t *)data)[*nbytes - 9];
|
|
((uint8_t *)data)[*nbytes - 9] = ((uint8_t *)data)[*nbytes-1];
|
|
}
|
|
|
|
int n = (communication_settings & CMAC_VERIFY) ? 8 : 0;
|
|
cmac (key, DESFIRE (tag)->ivect, ((uint8_t *)data), *nbytes - n, DESFIRE (tag)->cmac);
|
|
|
|
if (communication_settings & CMAC_VERIFY) {
|
|
((uint8_t *)data)[*nbytes - 9] = first_cmac_byte;
|
|
if (0 != memcmp (DESFIRE (tag)->cmac, (uint8_t *)data + *nbytes - 9, 8)) {
|
|
#ifdef WITH_DEBUG
|
|
Dbprintf ("CMAC NOT verified :-(");
|
|
hexdump ((uint8_t *)data + *nbytes - 9, 8, "Expect ", 0);
|
|
hexdump (DESFIRE (tag)->cmac, 8, "Actual ", 0);
|
|
#endif
|
|
DESFIRE (tag)->last_pcd_error = CRYPTO_ERROR;
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
} else {
|
|
*nbytes -= 8;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
free (edata);
|
|
|
|
break;
|
|
case MDCM_ENCIPHERED:
|
|
(*nbytes)--;
|
|
bool verified = false;
|
|
int crc_pos = 0x00;
|
|
int end_crc_pos = 0x00;
|
|
uint8_t x;
|
|
|
|
/*
|
|
* AS_LEGACY:
|
|
* ,-----------------+-------------------------------+--------+
|
|
* \ BLOCK n-1 | BLOCK n | STATUS |
|
|
* / PAYLOAD | CRC0 | CRC1 | 0x80? | 0x000000000000 | 0x9100 |
|
|
* `-----------------+-------------------------------+--------+
|
|
*
|
|
* <------------ DATA ------------>
|
|
* FRAME = PAYLOAD + CRC(PAYLOAD) + PADDING
|
|
*
|
|
* AS_NEW:
|
|
* ,-------------------------------+-----------------------------------------------+--------+
|
|
* \ BLOCK n-1 | BLOCK n | STATUS |
|
|
* / PAYLOAD | CRC0 | CRC1 | CRC2 | CRC3 | 0x80? | 0x0000000000000000000000000000 | 0x9100 |
|
|
* `-------------------------------+-----------------------------------------------+--------+
|
|
* <----------------------------------- DATA ------------------------------------->|
|
|
*
|
|
* <----------------- DATA ---------------->
|
|
* FRAME = PAYLOAD + CRC(PAYLOAD + STATUS) + PADDING + STATUS
|
|
* `------------------'
|
|
*/
|
|
|
|
mifare_cypher_blocks_chained (tag, NULL, NULL, res, *nbytes, MCD_RECEIVE, MCO_DECYPHER);
|
|
|
|
/*
|
|
* Look for the CRC and ensure it is followed by NULL padding. We
|
|
* can't start by the end because the CRC is supposed to be 0 when
|
|
* verified, and accumulating 0's in it should not change it.
|
|
*/
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
crc_pos = *nbytes - 8 - 1; // The CRC can be over two blocks
|
|
if (crc_pos < 0) {
|
|
/* Single block */
|
|
crc_pos = 0;
|
|
}
|
|
break;
|
|
case AS_NEW:
|
|
/* Move status between payload and CRC */
|
|
res = DESFIRE (tag)->crypto_buffer;
|
|
memcpy (res, data, *nbytes);
|
|
|
|
crc_pos = (*nbytes) - 16 - 3;
|
|
if (crc_pos < 0) {
|
|
/* Single block */
|
|
crc_pos = 0;
|
|
}
|
|
memcpy ((uint8_t *)res + crc_pos + 1, (uint8_t *)res + crc_pos, *nbytes - crc_pos);
|
|
((uint8_t *)res)[crc_pos] = 0x00;
|
|
crc_pos++;
|
|
*nbytes += 1;
|
|
break;
|
|
}
|
|
|
|
do {
|
|
uint16_t crc16 =0x00;
|
|
uint32_t crc;
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
end_crc_pos = crc_pos + 2;
|
|
AppendCrc14443a (res, end_crc_pos);
|
|
|
|
//
|
|
|
|
|
|
crc = crc16;
|
|
break;
|
|
case AS_NEW:
|
|
end_crc_pos = crc_pos + 4;
|
|
crc32_ex (res, end_crc_pos, (uint8_t *)&crc);
|
|
break;
|
|
}
|
|
if (!crc) {
|
|
verified = true;
|
|
for (int n = end_crc_pos; n < *nbytes - 1; n++) {
|
|
uint8_t byte = ((uint8_t *)res)[n];
|
|
if (!( (0x00 == byte) || ((0x80 == byte) && (n == end_crc_pos)) ))
|
|
verified = false;
|
|
}
|
|
}
|
|
if (verified) {
|
|
*nbytes = crc_pos;
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
((uint8_t *)data)[(*nbytes)++] = 0x00;
|
|
break;
|
|
case AS_NEW:
|
|
/* The status byte was already before the CRC */
|
|
break;
|
|
}
|
|
} else {
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
break;
|
|
case AS_NEW:
|
|
x = ((uint8_t *)res)[crc_pos - 1];
|
|
((uint8_t *)res)[crc_pos - 1] = ((uint8_t *)res)[crc_pos];
|
|
((uint8_t *)res)[crc_pos] = x;
|
|
break;
|
|
}
|
|
crc_pos++;
|
|
}
|
|
} while (!verified && (end_crc_pos < *nbytes));
|
|
|
|
if (!verified) {
|
|
#ifdef WITH_DEBUG
|
|
/* FIXME In some configurations, the file is transmitted PLAIN */
|
|
Dbprintf("CRC not verified in decyphered stream");
|
|
#endif
|
|
DESFIRE (tag)->last_pcd_error = CRYPTO_ERROR;
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
Dbprintf("Unknown communication settings");
|
|
*nbytes = -1;
|
|
res = NULL;
|
|
break;
|
|
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
void mifare_cypher_single_block (desfirekey_t key, uint8_t *data, uint8_t *ivect, MifareCryptoDirection direction, MifareCryptoOperation operation, size_t block_size)
|
|
{
|
|
uint8_t ovect[MAX_CRYPTO_BLOCK_SIZE];
|
|
|
|
if (direction == MCD_SEND) {
|
|
xor (ivect, data, block_size);
|
|
} else {
|
|
memcpy (ovect, data, block_size);
|
|
}
|
|
|
|
uint8_t edata[MAX_CRYPTO_BLOCK_SIZE];
|
|
|
|
switch (key->type) {
|
|
case T_DES:
|
|
switch (operation) {
|
|
case MCO_ENCYPHER:
|
|
//DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_ENCRYPT);
|
|
des_enc(edata, data, key->data);
|
|
break;
|
|
case MCO_DECYPHER:
|
|
//DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_DECRYPT);
|
|
des_dec(edata, data, key->data);
|
|
break;
|
|
}
|
|
break;
|
|
case T_3DES:
|
|
switch (operation) {
|
|
case MCO_ENCYPHER:
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_ENCRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) edata, (DES_cblock *) data, &(key->ks2), DES_DECRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_ENCRYPT);
|
|
tdes_enc(edata,data, key->data);
|
|
break;
|
|
case MCO_DECYPHER:
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_DECRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) edata, (DES_cblock *) data, &(key->ks2), DES_ENCRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_DECRYPT);
|
|
tdes_dec(data, edata, key->data);
|
|
break;
|
|
}
|
|
break;
|
|
case T_3K3DES:
|
|
switch (operation) {
|
|
case MCO_ENCYPHER:
|
|
tdes_enc(edata,data, key->data);
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_ENCRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) edata, (DES_cblock *) data, &(key->ks2), DES_DECRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks3), DES_ENCRYPT);
|
|
break;
|
|
case MCO_DECYPHER:
|
|
tdes_dec(data, edata, key->data);
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks3), DES_DECRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) edata, (DES_cblock *) data, &(key->ks2), DES_ENCRYPT);
|
|
// DES_ecb_encrypt ((DES_cblock *) data, (DES_cblock *) edata, &(key->ks1), DES_DECRYPT);
|
|
break;
|
|
}
|
|
break;
|
|
case T_AES:
|
|
switch (operation)
|
|
{
|
|
case MCO_ENCYPHER:
|
|
{
|
|
AesCtx ctx;
|
|
AesCtxIni(&ctx, ivect, key->data, KEY128,CBC);
|
|
AesEncrypt(&ctx, data, edata, sizeof(edata) );
|
|
break;
|
|
}
|
|
case MCO_DECYPHER:
|
|
{
|
|
AesCtx ctx;
|
|
AesCtxIni(&ctx, ivect, key->data, KEY128,CBC);
|
|
AesDecrypt(&ctx, edata, data, sizeof(edata));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
memcpy (data, edata, block_size);
|
|
|
|
if (direction == MCD_SEND) {
|
|
memcpy (ivect, data, block_size);
|
|
} else {
|
|
xor (ivect, data, block_size);
|
|
memcpy (ivect, ovect, block_size);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function performs all CBC cyphering / deciphering.
|
|
*
|
|
* The tag argument may be NULL, in which case both key and ivect shall be set.
|
|
* When using the tag session_key and ivect for processing data, these
|
|
* arguments should be set to NULL.
|
|
*
|
|
* Because the tag may contain additional data, one may need to call this
|
|
* function with tag, key and ivect defined.
|
|
*/
|
|
void mifare_cypher_blocks_chained (desfiretag_t tag, desfirekey_t key, uint8_t *ivect, uint8_t *data, size_t data_size, MifareCryptoDirection direction, MifareCryptoOperation operation) {
|
|
size_t block_size;
|
|
|
|
if (tag) {
|
|
if (!key)
|
|
key = DESFIRE (tag)->session_key;
|
|
if (!ivect)
|
|
ivect = DESFIRE (tag)->ivect;
|
|
|
|
switch (DESFIRE (tag)->authentication_scheme) {
|
|
case AS_LEGACY:
|
|
memset (ivect, 0, MAX_CRYPTO_BLOCK_SIZE);
|
|
break;
|
|
case AS_NEW:
|
|
break;
|
|
}
|
|
}
|
|
|
|
block_size = key_block_size (key);
|
|
|
|
size_t offset = 0;
|
|
while (offset < data_size) {
|
|
mifare_cypher_single_block (key, data + offset, ivect, direction, operation, block_size);
|
|
offset += block_size;
|
|
}
|
|
} |