[hf seos] Simulate support

This commit is contained in:
Aaron Tulino (Aaronjamt) committed 2025-12-21 04:26:44 -07:00
1 parent 772b0addad
commit c0e82539f2
7 files changed
+939 -1

No files matched your search

+2
View File
@@ -45,6 +45,7 @@ SRC_FELICA = felica.c
SRC_CRAPTO1 = crypto1.c des.c desfire_crypto.c mifaredesfire.c aes.c platform_util.c
SRC_CRC = crc.c crc16.c crc32.c
SRC_ICLASS = iclass.c optimized_cipherutils.c optimized_ikeys.c optimized_elite.c optimized_cipher.c sam_picopass.c
SRC_SEOS = seos.c sha1.c sha256.c
SRC_LEGIC = legicrf.c legicrfsim.c legic_prng.c
SRC_NFCBARCODE = thinfilm.c
@@ -137,6 +138,7 @@ THUMBSRC = start.c \
$(SRC_ISO14443b) \
$(SRC_CRAPTO1) \
$(SRC_ICLASS) \
$(SRC_SEOS) \
$(SRC_EMV) \
$(SRC_CRC) \
$(SRC_FELICA) \
+12
View File
@@ -45,6 +45,7 @@
#include "em4x50.h"
#include "em4x70.h"
#include "iclass.h"
#include "seos.h"
#include "legicrfsim.h"
//#include "cryptorfsim.h"
#include "epa.h"
@@ -630,6 +631,11 @@ static void SendCapabilities(void) {
#else
capabilities.compiled_with_iclass = false;
#endif
#ifdef WITH_SEOS
capabilities.compiled_with_seos = true;
#else
capabilities.compiled_with_seos = false;
#endif
#ifdef WITH_NFCBARCODE
capabilities.compiled_with_nfcbarcode = true;
#else
@@ -2281,6 +2287,12 @@ static void PacketReceived(PacketCommandNG *packet) {
break;
}
#endif
#ifdef WITH_SEOS
case CMD_HF_SEOS_SIMULATE: {
SimulateSeos((seos_emulate_req_t *)packet->data.asBytes);
break;
}
#endif
#ifdef WITH_HFSNIFF
case CMD_HF_SNIFF: {
+837
View File
@@ -0,0 +1,837 @@
//-----------------------------------------------------------------------------
// Copyright (C) Aaron Tulino - December 2025
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
// Routines to support Seos.
//-----------------------------------------------------------------------------
#include "seos.h"
#include "iso14443a.h"
#include "BigBuf.h"
#include "fpgaloader.h"
#include "string.h"
#include "dbprint.h"
#include "protocols.h"
#include "proxmark3_arm.h"
#include "cmd.h"
// Needed for CRC in emulation mode;
// same construction as in ISO 14443;
// different initial value (CRC_ICLASS)
#include "crc16.h"
#include <mbedtls/aes.h>
#include <mbedtls/des.h>
#include "cmac_calc.h"
#include "cmac_3des.h"
#include <mbedtls/sha1.h>
#include <mbedtls/sha256.h>
const uint8_t SEOS_AID[] = { 0xA0, 0x00, 0x00, 0x04, 0x40, 0x00, 0x01, 0x01, 0x00, 0x01 };
static uint8_t block_size(uint8_t algorithm) {
if (algorithm == SEOS_ENCRYPTION_AES) {
return 16;
} else if (algorithm == SEOS_ENCRYPTION_2K3DES) {
return 8;
} else if (algorithm == SEOS_ENCRYPTION_3K3DES) {
return 8;
} else {
Dbprintf(_RED_("Unknown Encryption Algorithm"));
return 0;
}
}
static uint8_t round_to_next(uint8_t value, uint8_t step) {
if (value % step == 0) {
return value;
} else {
return value + step - (value % step);
}
}
static bool generate_cryptogram(const uint8_t *key, const uint8_t *opt_iv, const uint8_t *input, size_t length, uint8_t *output, uint8_t algorithm) {
// IV is optional, only add if provided. Zeros by default.
uint8_t iv[16] = {0x00};
if (opt_iv != NULL) {
memcpy(iv, opt_iv, 16);
}
uint8_t bs = block_size(algorithm);
uint8_t padded_length = round_to_next(length, bs);
// Allocate enough room to store any additional padding
uint8_t cleartext[padded_length];
uint8_t cryptogram[padded_length];
memset(cleartext, 0, padded_length);
memcpy(cleartext, input, length);
// ISO7816 padding: add 0x80 after data, then follow with all zeros
if (padded_length != length) {
cleartext[length] = 0x80;
}
if (algorithm == SEOS_ENCRYPTION_AES) {
mbedtls_aes_context ctx;
mbedtls_aes_setkey_enc(&ctx, key, 128);
mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_ENCRYPT, length, iv, input, cryptogram);
mbedtls_aes_free(&ctx);
} else if (algorithm == SEOS_ENCRYPTION_2K3DES) {
mbedtls_des3_context ctx;
mbedtls_des3_set2key_enc(&ctx, key);
mbedtls_des3_crypt_cbc(&ctx, MBEDTLS_DES_ENCRYPT, length, iv, input, cryptogram);
mbedtls_des3_free(&ctx);
}
// Add generated cryptogram to output buffer
memcpy(output, cryptogram, length);
return true;
}
static bool decrypt_cryptogram(const uint8_t *key, const uint8_t *input, size_t length, uint8_t *output, uint8_t algorithm) {
uint8_t iv[16] = {0x00};
// Allocate enough room to store any additional padding
uint8_t cleartext[length + block_size(algorithm)];
if (algorithm == SEOS_ENCRYPTION_AES) {
mbedtls_aes_context ctx;
mbedtls_aes_init(&ctx);
mbedtls_aes_setkey_dec(&ctx, key, 128);
mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_DECRYPT, length, iv, input, cleartext);
mbedtls_aes_free(&ctx);
} else if (algorithm == SEOS_ENCRYPTION_2K3DES) {
mbedtls_des3_context ctx;
mbedtls_des3_set2key_dec(&ctx, key);
mbedtls_des3_crypt_cbc(&ctx, MBEDTLS_DES_DECRYPT, length, iv, input, cleartext);
mbedtls_des3_free(&ctx);
} else {
Dbprintf(_RED_("Unknown Encryption Algorithm"));
return false;
}
// Add decrypted cleartext to output buffer
memcpy(output, cleartext, length);
return true;
}
// Returns length of generated CMAC
static uint8_t generate_cmac(const uint8_t *key, const uint8_t *input, size_t length, uint8_t *output, uint8_t max_output_len, uint8_t encryption_algorithm) {
uint8_t size = block_size(encryption_algorithm);
uint8_t mac[size];
if (encryption_algorithm == SEOS_ENCRYPTION_AES) {
ulaes_cmac(key, 16, input, length, mac);
} else if (encryption_algorithm == SEOS_ENCRYPTION_2K3DES || encryption_algorithm == SEOS_ENCRYPTION_3K3DES) {
uint8_t keylen = 16;
if (encryption_algorithm == SEOS_ENCRYPTION_3K3DES) keylen = 24;
des3_cmac(key, keylen, input, length, mac);
} else {
Dbprintf(_RED_("Unknown Encryption Algorithm"));
return false;
}
// Add generated CMAC to output buffer
size = MIN(size, max_output_len);
memcpy(output, mac, size);
return size;
}
static void seos_kdf(bool forEncryption, uint8_t *masterKey, uint8_t keyslot,
uint8_t *adfOid, size_t adfoid_len, uint8_t *diversifier, uint8_t diversifier_len, uint8_t *out, int encryption_algorithm, int hash_algorithm) {
// Encryption key = 04
// KEK Encryption key = 05
// MAC key = 06
// KEK MAC key = 07
uint8_t typeOfKey = 0x06;
if (forEncryption == true) {
typeOfKey = 0x04;
}
uint8_t inputPre[] = {
// Padding
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, typeOfKey, 0x00, 0x00, 0x80, 0x01,
encryption_algorithm, hash_algorithm, keyslot
};
// 00000000000000000000000600008001 09 07 00 06112B0601040181E438010102011801010202 EFB08A28B0529F
// 00000000000000000000000400008001 09 07 00 06112B0601040181E438010102011801010202 EFB08A28B0529F
// 06112B0601040181E438010102011801010202 CF 07 EFB08A28B0529F DBA240413B0969B7111F4B6133A3DEFAD934B6DC
uint8_t input[sizeof(inputPre) + adfoid_len + diversifier_len];
memset(input, 0, sizeof(input));
memcpy(input, inputPre, sizeof(inputPre));
memcpy(input + sizeof(inputPre), adfOid, adfoid_len);
memcpy(input + sizeof(inputPre) + adfoid_len, diversifier, diversifier_len);
// This CMAC always uses AES, regardless of the main encryption algorithm in use.
generate_cmac(masterKey, input, sizeof(input), out, 16, SEOS_ENCRYPTION_AES);
}
// turn off afterwards
void SimulateSeos(seos_emulate_req_t *msg) {
tag_response_info_t *responses;
uint32_t cuid = 0;
// command buffers
uint8_t receivedCmd[MAX_FRAME_SIZE] = { 0x00 };
uint8_t receivedCmdPar[MAX_PARITY_SIZE] = { 0x00 };
// These values are determined at runtime
uint8_t RND_ICC[8] = { 0x00 };
uint8_t RND_IFD[8];
uint8_t KEY_ICC[16] = { 0x00 };
uint8_t KEY_IFD[16];
uint8_t diver_encr_key[16];
uint8_t diver_cmac_key[16];
// Calculated block size
const uint8_t max_bs = 16;
const uint8_t bs = block_size(msg->encr_alg);
if (bs == 0) {
// Can't continue, invalid encryption algorithm
reply_ng(CMD_HF_SEOS_SIMULATE, PM3_EINVARG, NULL, 0);
return;
}
// free eventually allocated BigBuf memory but keep Emulator Memory
BigBuf_free_keep_EM();
// Allocate 512 bytes for the dynamic modulation, created when the reader queries for it
// Such a response is less time critical, so we can prepare them on the fly
#define DYNAMIC_RESPONSE_BUFFER_SIZE 192
#define DYNAMIC_MODULATION_BUFFER_SIZE 1024
uint8_t *dynamic_response_buffer = BigBuf_calloc(DYNAMIC_RESPONSE_BUFFER_SIZE);
if (dynamic_response_buffer == NULL) {
BigBuf_free_keep_EM();
reply_ng(CMD_HF_MIFARE_SIMULATE, PM3_EMALLOC, NULL, 0);
return;
}
uint8_t *dynamic_modulation_buffer = BigBuf_calloc(DYNAMIC_MODULATION_BUFFER_SIZE);
if (dynamic_modulation_buffer == NULL) {
BigBuf_free_keep_EM();
reply_ng(CMD_HF_MIFARE_SIMULATE, PM3_EMALLOC, NULL, 0);
return;
}
tag_response_info_t dynamic_response_info = {
.response = dynamic_response_buffer,
.response_n = 0,
.modulation = dynamic_modulation_buffer,
.modulation_n = 0
};
uint16_t flags = 0;
uint8_t data[PM3_CMD_DATA_SIZE] = { 0 };
memcpy(data, msg->uid, msg->uid_len);
FLAG_SET_UID_IN_DATA(flags, msg->uid_len);
// TODO: Is this required?
uint8_t ats[] = { 0x05, 0x78, 0x77, 0x80, 0x02 };
flags |= FLAG_ATS_IN_DATA;
// 12 = HID Seos 4K card
if (SimulateIso14443aInit(12, flags, data, ats, sizeof(ats), &responses, &cuid, NULL, NULL) == false) {
BigBuf_free_keep_EM();
reply_ng(CMD_HF_SEOS_SIMULATE, PM3_EINIT, NULL, 0);
return;
}
// We need to listen to the high-frequency, peak-detected path.
iso14443a_setup(FPGA_HF_ISO14443A_TAGSIM_LISTEN);
iso14a_set_timeout(201400); // 106 * 19ms default *100?
int len = 0;
int retval = PM3_SUCCESS;
// Just to allow some checks
int cmdsRecvd = 0;
bool odd_reply = true;
clear_trace();
set_tracing(true);
LED_A_ON();
// main loop
bool finished = false;
bool got_rats = false;
while (finished == false) {
// BUTTON_PRESS check done in GetIso14443aCommandFromReader
WDT_HIT();
tag_response_info_t *p_response = NULL;
// Clean receive command buffer
if (GetIso14443aCommandFromReader(receivedCmd, sizeof(receivedCmd), receivedCmdPar, &len) == false) {
Dbprintf("Emulator stopped. Trace length: %d ", BigBuf_get_traceLen());
retval = PM3_EOPABORTED;
break;
}
if (receivedCmd[0] == ISO14443A_CMD_REQA && len == 1) { // Received a REQUEST, but in HALTED, skip
odd_reply = !odd_reply;
if (odd_reply) {
p_response = &responses[RESP_INDEX_ATQA];
}
} else if (receivedCmd[0] == ISO14443A_CMD_WUPA && len == 1) { // Received a WAKEUP
p_response = &responses[RESP_INDEX_ATQA];
} else if (receivedCmd[1] == 0x20 && receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && len == 2) { // Received request for UID (cascade 1)
p_response = &responses[RESP_INDEX_UIDC1];
} else if (receivedCmd[1] == 0x20 && receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && len == 2) { // Received request for UID (cascade 2)
p_response = &responses[RESP_INDEX_UIDC2];
} else if (receivedCmd[1] == 0x20 && receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_3 && len == 2) { // Received request for UID (cascade 3)
p_response = &responses[RESP_INDEX_UIDC3];
} else if (receivedCmd[1] == 0x70 && receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT && len == 9) { // Received a SELECT (cascade 1)
p_response = &responses[RESP_INDEX_SAKC1];
} else if (receivedCmd[1] == 0x70 && receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_2 && len == 9) { // Received a SELECT (cascade 2)
p_response = &responses[RESP_INDEX_SAKC2];
} else if (receivedCmd[1] == 0x70 && receivedCmd[0] == ISO14443A_CMD_ANTICOLL_OR_SELECT_3 && len == 9) { // Received a SELECT (cascade 3)
p_response = &responses[RESP_INDEX_SAKC3];
} else if (receivedCmd[0] == ISO14443A_CMD_PPS) {
p_response = &responses[RESP_INDEX_PPS];
} else if (receivedCmd[0] == ISO14443A_CMD_HALT && len == 4) { // Received a HALT
p_response = NULL;
if (got_rats) {
finished = true;
}
} else if (receivedCmd[0] == ISO14443A_CMD_RATS && len == 4) { // Received a RATS request
p_response = &responses[RESP_INDEX_ATS];
got_rats = true;
} else {
// clear old dynamic responses
dynamic_response_info.response_n = 0;
dynamic_response_info.modulation_n = 0;
// Check for ISO 14443A-4 compliant commands, look at left byte (PCB)
uint8_t offset = 0;
switch (receivedCmd[0]) {
case 0x0B: // IBlock with CID
case 0x0A: {
offset = 1;
}
case 0x02: // IBlock without CID
case 0x03: {
dynamic_response_info.response[0] = receivedCmd[0];
dynamic_response_info.response[1] = 0x00;
dynamic_response_info.response_n = 2;
uint8_t apdu_status[2] = {0x6A, 0x82}; // Default: Not Found
switch (receivedCmd[2 + offset]) { // APDU Class Byte
// receivedCmd in this case is expecting to structured with possibly a CID, then the APDU command for SelectFile
// | IBlock (CID) | CID | APDU Command | CRC |
// or | IBlock (noCID) | APDU Command | CRC |
case 0xA4: { // SELECT FILE
// Select File AID uses the following format for GlobalPlatform
//
// | 00 | A4 | 04 | 00 | xx | AID | 00 |
// xx in this case is len of the AID value in hex
// aid len is found as a hex value in receivedCmd[6] (Index Starts at 0)
uint8_t aid_len = receivedCmd[5 + offset];
uint8_t *aid = &receivedCmd[6 + offset];
// TODO: See if this actually matches exactly (if possible)
if ((aid_len == sizeof(SEOS_AID)) && (memcmp(SEOS_AID, aid, sizeof(SEOS_AID)) == 0)) { // Evaluate the AID sent by the Reader to the AID supplied
// Format as TLV and acknowledge
/*
6F 0C
84 0A
A0000004400001010001
90 00
*/
dynamic_response_info.response[1 + offset] = 0x6F; // Tag
dynamic_response_info.response[2 + offset] = aid_len + 2; // Length
dynamic_response_info.response[3 + offset] = 0x84; // Inner Tag
dynamic_response_info.response[4 + offset] = aid_len; // Inner Length
memcpy(dynamic_response_info.response + 5 + offset, aid, aid_len);
dynamic_response_info.response_n = 5 + aid_len + offset;
// Set status code to Success
apdu_status[0] = 0x90;
apdu_status[1] = 0x00;
} // Any other SELECT FILE command will return with a Not Found
}
break;
case 0xA5: { // SELECT OID
// This is specific to Seos
// Should be a TLV structure with the OID stored in tag 0x06
uint8_t received_tlv_len = receivedCmd[5 + offset];
uint8_t *received_tlv = &receivedCmd[6 + offset];
bool selected_oid = false;
// Check all requested OIDs and see if we support any
uint8_t tlv_offset = 0;
while (tlv_offset < received_tlv_len) {
uint8_t tag = received_tlv[tlv_offset++];
uint8_t length = received_tlv[tlv_offset++];
uint8_t* value = &received_tlv[tlv_offset];
if (tag == 0x06) {
if (length == msg->oid_len && memcmp(value, msg->oid, length) == 0) {
selected_oid = true;
break;
}
}
tlv_offset += length;
}
if (selected_oid) {
// Synthesized IV: half a block of random data followed by half of the CMAC of that data
uint8_t synthesized_iv[max_bs];
memset(synthesized_iv, 0, bs/2); // TODO: Maybe actually use random data?
generate_cmac(msg->privmac, synthesized_iv, bs/2, synthesized_iv+(bs/2), bs/2, msg->encr_alg);
// Always exactly 0x30 bytes in length
const uint8_t reply_len = 0x30;
uint8_t reply_idx = 0;
uint8_t reply[reply_len];
memset(reply, 0, reply_len);
reply[reply_idx++] = 0x06; // Tag: selected OID
reply[reply_idx++] = msg->oid_len;
memcpy(reply+reply_idx, msg->oid, msg->oid_len);
reply_idx += msg->oid_len;
reply[reply_idx++] = 0xCF; // Tag: diversifier
reply[reply_idx++] = msg->diversifier_len;
memcpy(reply+reply_idx, msg->diversifier, msg->diversifier_len);
reply_idx += msg->diversifier_len;
uint8_t cryptogram[reply_len];
if (!generate_cryptogram(msg->privenc, synthesized_iv, reply, reply_len, cryptogram, msg->encr_alg)) {
Dbprintf(_RED_("Select ADF failed") ": Failed to create reply cryptogram.");
break;
}
uint8_t tlv_base = 1 + offset;
uint8_t tlv_idx = tlv_base;
dynamic_response_info.response[tlv_idx++] = 0xCD; // Tag: cryptography type
dynamic_response_info.response[tlv_idx++] = 0x02; // Length
dynamic_response_info.response[tlv_idx++] = msg->encr_alg;
dynamic_response_info.response[tlv_idx++] = msg->hash_alg;
dynamic_response_info.response[tlv_idx++] = 0x85; // Tag: cryptogram
dynamic_response_info.response[tlv_idx++] = reply_len + bs; // Length
memcpy(dynamic_response_info.response+tlv_idx, synthesized_iv, bs);
tlv_idx += bs;
memcpy(dynamic_response_info.response+tlv_idx, cryptogram, reply_len);
tlv_idx += reply_len;
// Always an 8-byte CMAC
uint8_t cmac[8];
uint8_t cmac_size = generate_cmac(msg->privmac, dynamic_response_info.response+tlv_base, tlv_idx-tlv_base, cmac, sizeof(cmac), msg->encr_alg);
dynamic_response_info.response[tlv_idx++] = 0x8E; // Tag: CMAC
dynamic_response_info.response[tlv_idx++] = cmac_size; // Length
memcpy(dynamic_response_info.response+tlv_idx, cmac, cmac_size);
tlv_idx += cmac_size;
dynamic_response_info.response_n = tlv_idx;
// Set status code to Success
apdu_status[0] = 0x90;
apdu_status[1] = 0x00;
} // No error message here because readers may request multiple OIDs before reaching ours
}
break;
case 0x87: { // MUTUAL AUTH
// This is specific to Seos
// Should be a TLV structure with the OID stored in tag 0x16
uint8_t *received_tlv = &receivedCmd[6 + offset];
if (received_tlv[0] != 0x7C) {
Dbprintf(_RED_("Mutual auth failed") ": Invalid tag, expected 7C, got %02X", received_tlv[0]);
break;
}
received_tlv += 2;
if (received_tlv[0] == 0x81) {
// Request for RND.ICC
uint8_t tlv_idx = 1 + offset;
dynamic_response_info.response[tlv_idx++] = 0x7C; // Tag: mutual auth
dynamic_response_info.response[tlv_idx++] = sizeof(RND_ICC)+2; // Length
dynamic_response_info.response[tlv_idx++] = 0x81; // Tag: request for RND.ICC
dynamic_response_info.response[tlv_idx++] = sizeof(RND_ICC); // Length
memcpy(dynamic_response_info.response+tlv_idx, RND_ICC, sizeof(RND_ICC));
tlv_idx += sizeof(RND_ICC);
dynamic_response_info.response_n = tlv_idx;
// Set status code to Success
apdu_status[0] = 0x90;
apdu_status[1] = 0x00;
} else if (received_tlv[0] == 0x82) {
// Request for challenge
uint8_t received_tlv_len = received_tlv[1];
received_tlv += 2;
uint8_t keyslot = receivedCmd[4 + offset]; // APDU P2 byte
seos_kdf(true, msg->authkey, keyslot, msg->oid, msg->oid_len, msg->diversifier, msg->diversifier_len, diver_encr_key, msg->encr_alg, msg->hash_alg);
seos_kdf(false, msg->authkey, keyslot, msg->oid, msg->oid_len, msg->diversifier, msg->diversifier_len, diver_cmac_key, msg->encr_alg, msg->hash_alg);
// Verify CMAC (last 8 bytes)
uint8_t request_len = received_tlv_len - 8;
uint8_t cmac[8];
generate_cmac(diver_cmac_key, received_tlv, request_len, cmac, 8, msg->encr_alg);
if (memcmp(cmac, received_tlv + request_len, 8) != 0) {
Dbprintf(_RED_("Mutual auth failed") ": Invalid CMAC:");
Dbhexdump(8, received_tlv + request_len, false);
Dbprintf("for data:");
Dbhexdump(request_len, received_tlv, false);
break;
}
uint8_t request[received_tlv_len];
if (!decrypt_cryptogram(diver_encr_key, received_tlv, request_len, request, msg->encr_alg)) {
Dbprintf(_RED_("Mutual auth failed") ": Failed to decrypt cryptogram.");
break;
}
// request = RND.IFD | RND.ICC | Key.IFD
if (memcmp(RND_ICC, request + 8, 8) != 0) {
Dbprintf(_RED_("Mutual auth failed") ": Incorrect RND.ICC.");
break;
}
memcpy(RND_IFD, request, 8);
memcpy(KEY_IFD, request + 16, 16);
// reply = RND_ICC | RND_IFD | KEY_ICC
uint8_t reply_plain[32];
memcpy(reply_plain + 0, RND_ICC, 8);
memcpy(reply_plain + 8, RND_IFD, 8);
memcpy(reply_plain + 16, KEY_ICC, 16);
// Generate cryptogram + CMAC
uint8_t reply[sizeof(reply_plain)+8];
generate_cryptogram(diver_encr_key, NULL, reply_plain, sizeof(reply_plain), reply, msg->encr_alg);
generate_cmac(diver_cmac_key, reply, sizeof(reply_plain), reply+sizeof(reply_plain), 8, msg->encr_alg);
uint8_t tlv_idx = 1 + offset;
dynamic_response_info.response[tlv_idx++] = 0x7C; // Tag: mutual auth
dynamic_response_info.response[tlv_idx++] = sizeof(reply)+2; // Length
dynamic_response_info.response[tlv_idx++] = 0x82; // Tag: request for challenge
dynamic_response_info.response[tlv_idx++] = sizeof(reply); // Length
memcpy(dynamic_response_info.response+tlv_idx, reply, sizeof(reply));
tlv_idx += sizeof(reply);
dynamic_response_info.response_n = tlv_idx;
// Set status code to Success
apdu_status[0] = 0x90;
apdu_status[1] = 0x00;
// IMPORTANT: before sending reply, calculate final diversified keys
uint8_t hash_input[38];
uint8_t hash_idx = 0;
// Counter
hash_input[hash_idx++] = 0x00;
hash_input[hash_idx++] = 0x00;
hash_input[hash_idx++] = 0x00;
hash_input[hash_idx++] = 0x01;
// Only copy first 8 bytes of each KEY
memcpy(hash_input+hash_idx, KEY_IFD, 8);
hash_idx += 8;
memcpy(hash_input+hash_idx, KEY_ICC, 8);
hash_idx += 8;
// Yes, this is supposed to be the same thing twice
hash_input[hash_idx++] = msg->encr_alg;
hash_input[hash_idx++] = msg->encr_alg;
// Copy full RND values
memcpy(hash_input+hash_idx, RND_ICC, 8);
hash_idx += 8;
memcpy(hash_input+hash_idx, RND_IFD, 8);
hash_idx += 8;
uint8_t hash_output[40];
if (msg->hash_alg == SEOS_HASHING_SHA1) {
mbedtls_sha1(hash_input, 38, hash_output);
// Increment LSB of counter for second hash
hash_input[3]++;
mbedtls_sha1(hash_input, 38, hash_output + 20);
} else if (msg->hash_alg == SEOS_HASHING_SHA256) {
mbedtls_sha256(hash_input, 38, hash_output, 0);
} else {
Dbprintf(_RED_("Unknown Hashing Algorithm"));
break;
}
memcpy(diver_encr_key, hash_output, 16);
memcpy(diver_cmac_key, hash_output+16, 16);
} else {
Dbprintf( _RED_("Mutual auth failed") ": Incorrect tag %02X found.", received_tlv[0]);
}
}
break;
case 0xDA: // PUT DATA
case 0xCB: { // GET DATA
bool is_put = receivedCmd[2 + offset] == 0xDA;
uint8_t received_tlv_len = receivedCmd[5 + offset];
uint8_t *received_tlv = &receivedCmd[6 + offset];
uint8_t *cryptogram = NULL;
uint8_t *recvd_cmac = NULL;
uint8_t cryptogram_length;
uint8_t recvd_cmac_length;
uint8_t recvd_cmac_offset;
// Check all requested OIDs and see if we support any
uint8_t tlv_offset = 0;
while (tlv_offset < received_tlv_len) {
uint8_t tag = received_tlv[tlv_offset];
uint8_t length = received_tlv[tlv_offset+1];
uint8_t* value = &received_tlv[tlv_offset+2];
if (tag == 0x85) {
cryptogram = value;
cryptogram_length = length;
} else if (tag == 0x8e) {
recvd_cmac = value;
recvd_cmac_length = length;
recvd_cmac_offset = tlv_offset;
}
tlv_offset += 2 + length;
}
if (cryptogram != NULL && recvd_cmac != NULL) {
uint8_t rndCounter[bs];
memcpy(rndCounter, RND_ICC, bs / 2);
memcpy(rndCounter + bs / 2, RND_IFD, bs / 2);
for (int8_t i=bs-1; i>=0; i--) {
rndCounter[i]++;
if (rndCounter[i] != 0x00) break;
}
uint8_t cryptogram_padding = recvd_cmac_offset % bs;
if (cryptogram_padding) cryptogram_padding = bs - cryptogram_padding;
uint8_t padded_apdu_header[bs];
memset(padded_apdu_header, 0, bs);
memcpy(padded_apdu_header, &receivedCmd[1 + offset], 4);
padded_apdu_header[4] = 0x80;
uint8_t mac_input[sizeof(rndCounter) + sizeof(padded_apdu_header) + recvd_cmac_offset + cryptogram_padding];
memset(mac_input, 0, sizeof(mac_input));
memcpy(mac_input, rndCounter, sizeof(rndCounter));
memcpy(mac_input+sizeof(rndCounter), padded_apdu_header, sizeof(padded_apdu_header));
memcpy(mac_input+sizeof(rndCounter)+sizeof(padded_apdu_header), received_tlv, recvd_cmac_offset);
if (cryptogram_padding) {
mac_input[sizeof(rndCounter)+sizeof(padded_apdu_header)+recvd_cmac_offset] = 0x80;
}
uint8_t cmac[recvd_cmac_length];
generate_cmac(diver_cmac_key, mac_input, sizeof(mac_input), cmac, recvd_cmac_length, msg->encr_alg);
if (memcmp(cmac, recvd_cmac, recvd_cmac_length) != 0) {
Dbprintf( _RED_("Get Data failed") ": Invalid CMAC:");
Dbhexdump(recvd_cmac_length, cmac, false);
Dbprintf("for data:");
Dbhexdump(sizeof(mac_input), mac_input, false);
break;
}
uint8_t request[cryptogram_length];
decrypt_cryptogram(diver_encr_key, cryptogram, cryptogram_length, request, msg->encr_alg);
uint8_t tlv_base = 1 + offset;
uint8_t tlv_idx = tlv_base;
if (is_put) {
} else {
//5c 02 ff 00
if (request[0] != 0x5C) {
Dbprintf(_RED_("Get Data failed") ": Invalid request TLV. Expected tag 5C, but got %02X.", request[0]);
break;
}
if (request[1] != msg->data_tag_len || memcmp(request+2, msg->data_tag, msg->data_tag_len) != 0) {
Dbprintf(_RED_("Get Data failed") ": Requested invalid data tag.");
break;
}
uint8_t reply_len = msg->data_tag_len + 1 + msg->data_len;
reply_len = round_to_next(reply_len, bs);
uint8_t reply[reply_len];
memset(reply, 0, reply_len);
uint8_t reply_idx = 0;
memcpy(reply+reply_idx, msg->data_tag, msg->data_tag_len); // Tag
reply_idx += msg->data_tag_len;
reply[reply_idx++] = msg->data_len; // Length
memcpy(reply+reply_idx, msg->data, msg->data_len); // Value
reply_idx += msg->data_len;
if (reply_idx != reply_len) {
// Add 0x80 at first byte after data for start of padding
reply[reply_idx] = 0x80;
}
uint8_t reply_cryptogram[reply_len];
if (!generate_cryptogram(diver_encr_key, NULL, reply, reply_len, reply_cryptogram, msg->encr_alg)) {
Dbprintf(_RED_("Get Data failed") ": Failed to create reply cryptogram.");
break;
}
// Only include a cryptogram for GET DATA
dynamic_response_info.response[tlv_idx++] = 0x85; // Tag: cryptogram
dynamic_response_info.response[tlv_idx++] = reply_len; // Length
memcpy(dynamic_response_info.response+tlv_idx, reply_cryptogram, reply_len);
tlv_idx += reply_len;
}
// Whether we GET DATA or PUT DATA, add the response status code and CMAC
dynamic_response_info.response[tlv_idx++] = 0x99; // Tag: status code
dynamic_response_info.response[tlv_idx++] = 0x02; // Length
dynamic_response_info.response[tlv_idx++] = 0x90;
dynamic_response_info.response[tlv_idx++] = 0x00;
// Unlike every other CMAC, this time we need to increment
// the rndCounter from above again and CMAC with *that*
uint8_t mac_length = sizeof(rndCounter) + (tlv_idx - tlv_base);
mac_length = round_to_next(mac_length, bs);
uint8_t mac_input_2[mac_length];
for (int8_t i=bs-1; i>=0; i--) {
rndCounter[i]++;
if (rndCounter[i] != 0x00) break;
}
memset(mac_input_2, 0, mac_length);
uint8_t mac_idx = 0;
memcpy(mac_input_2, rndCounter, sizeof(rndCounter));
mac_idx += sizeof(rndCounter);
memcpy(mac_input_2+sizeof(rndCounter), dynamic_response_info.response + tlv_base, tlv_idx - tlv_base);
mac_idx += tlv_idx - tlv_base;
if (mac_idx != mac_length) {
// Add 0x80 at first byte after data for start of padding
mac_input_2[mac_idx] = 0x80;
}
uint8_t cmac_size = generate_cmac(diver_cmac_key, mac_input_2, mac_length, cmac, sizeof(cmac), msg->encr_alg);
dynamic_response_info.response[tlv_idx++] = 0x8E; // Tag: CMAC
dynamic_response_info.response[tlv_idx++] = cmac_size; // Length
memcpy(dynamic_response_info.response+tlv_idx, cmac, cmac_size);
tlv_idx += cmac_size;
dynamic_response_info.response_n = tlv_idx;
// Set status code to Success
apdu_status[0] = 0x90;
apdu_status[1] = 0x00;
} else {
Dbprintf( _RED_("Get Data failed") ": No cryptogram or CMAC found in request.");
}
}
break;
default : {
// Any other non-listed command
// Respond Not Found (default)
}
}
// Add APDU status code to end of response
dynamic_response_info.response[dynamic_response_info.response_n + 0] = apdu_status[0];
dynamic_response_info.response[dynamic_response_info.response_n + 1] = apdu_status[1];
dynamic_response_info.response_n += 2;
}
break;
case 0xCA: // S-Block Deselect with CID
case 0xC2: { // S-Block Deselect without CID
dynamic_response_info.response[0] = receivedCmd[0];
dynamic_response_info.response[1] = 0x00;
dynamic_response_info.response_n = 2;
finished = true;
}
break;
default: {
// Never seen this PCB before
if (g_dbglevel >= DBG_DEBUG) {
Dbprintf("Received unknown command (len=%d):", len);
Dbhexdump(len, receivedCmd, false);
}
if ((receivedCmd[0] & 0x10) == 0x10) {
Dbprintf("Warning, reader sent a chained command but we lack support for it. Ignoring command.");
}
// Do not respond
dynamic_response_info.response_n = 0;
}
break;
}
if (dynamic_response_info.response_n > 0) {
// Copy the CID from the reader query
if (offset > 0) {
dynamic_response_info.response[1] = receivedCmd[1];
}
// Add CRC bytes, always used in ISO 14443A-4 compliant cards
AddCrc14A(dynamic_response_info.response, dynamic_response_info.response_n);
dynamic_response_info.response_n += 2;
if (prepare_tag_modulation(&dynamic_response_info, DYNAMIC_MODULATION_BUFFER_SIZE) == false) {
if (g_dbglevel >= DBG_DEBUG) DbpString("Error preparing tag response");
break;
}
p_response = &dynamic_response_info;
}
}
cmdsRecvd++;
// Send response
EmSendPrecompiledCmd(p_response);
}
switch_off();
set_tracing(false);
BigBuf_free_keep_EM();
if (g_dbglevel >= DBG_EXTENDED) {
Dbprintf("-[ Num of received cmd [%d]", cmdsRecvd);
}
reply_ng(CMD_HF_SEOS_SIMULATE, retval, NULL, 0);
}
+25
View File
@@ -0,0 +1,25 @@
//-----------------------------------------------------------------------------
// Copyright (C) Aaron Tulino - December 2025
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
#ifndef __SEOS_H
#define __SEOS_H
#include "common.h"
#include "seos_cmd.h"
void SimulateSeos(seos_emulate_req_t *msg);
#endif
+3
View File
@@ -232,6 +232,9 @@ endif
ifneq ($(SKIP_ICLASS),1)
PLATFORM_DEFS += -DWITH_ICLASS
endif
ifneq ($(SKIP_SEOS),1)
PLATFORM_DEFS += -DWITH_SEOS
endif
ifneq ($(SKIP_FELICA),1)
PLATFORM_DEFS += -DWITH_FELICA
endif
+4 -1
View File
@@ -238,6 +238,7 @@ typedef struct {
bool compiled_with_felica : 1;
bool compiled_with_legicrf : 1;
bool compiled_with_iclass : 1;
bool compiled_with_seos : 1;
bool compiled_with_nfcbarcode : 1;
// misc
bool compiled_with_lcd : 1;
@@ -247,7 +248,7 @@ typedef struct {
bool hw_available_smartcard : 1;
bool is_rdv4 : 1;
} PACKED capabilities_t;
#define CAPABILITIES_VERSION 6
#define CAPABILITIES_VERSION 7
extern capabilities_t g_pm3_capabilities;
// For CMD_LF_T55XX_WRITEBL
@@ -857,6 +858,8 @@ typedef struct {
#define CMD_HF_SAM_SEOS 0x0901
#define CMD_HF_SAM_MFC 0x0902
#define CMD_HF_SEOS_SIMULATE 0x0903
#define CMD_UNKNOWN 0xFFFF
//Mifare simulation flags
+56
View File
@@ -0,0 +1,56 @@
//-----------------------------------------------------------------------------
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
// Seos type prototyping
//-----------------------------------------------------------------------------
#ifndef _SEOS_CMD_H_
#define _SEOS_CMD_H_
#include "common.h"
#define SEOS_ENCRYPTION_2K3DES 0x02
#define SEOS_ENCRYPTION_3K3DES 0x03
#define SEOS_ENCRYPTION_AES 0x09
#define SEOS_HASHING_SHA1 0x06
#define SEOS_HASHING_SHA256 0x07
// Seos emulate request data structure
typedef struct {
uint8_t encr_alg;
uint8_t hash_alg;
uint8_t uid[10];
uint8_t uid_len;
uint8_t privenc[16];
uint8_t privmac[16];
uint8_t authkey[16];
uint8_t diversifier_len;
uint8_t diversifier[16];
uint8_t data_tag_len;
uint8_t data_tag[8];
uint8_t data_len;
uint8_t data[128];
uint8_t oid_len;
uint8_t oid[32];
} PACKED seos_emulate_req_t;
#endif // _SEOS_H_