From cdca934f7e9f04ba4a6ce29dd2de97d0be547283 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=AD=90=E6=AD=AA?= Date: Sat, 22 Aug 2026 02:11:29 +0800 Subject: [PATCH 01/12] feat: hf mfu ndefwrite command --- CHANGELOG.md | 1 + client/src/cmdhfmfu.c | 426 ++++++++++++++++++++++++++++++++++++++++++ client/src/cmdhfmfu.h | 3 +- client/src/cmdnfc.c | 185 +++++++++++++++++- client/src/nfc/ndef.c | 265 ++++++++++++++++++++++++++ client/src/nfc/ndef.h | 31 +++ 6 files changed, 908 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a80c7790f..c6e1b02bf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ All notable changes to this project will be documented in this file. This project uses the changelog in accordance with [keepchangelog](http://keepachangelog.com/). Please use this to write notable changes, which is not the same as git commit log... ## [unreleased][unreleased] +- Added `nfc encode` and `hf mfu ndefwrite` - build NDEF URI/Text/AAR records and write them to MIFARE Ultralight / NTAG tags, plus a reusable NDEF encoder in `nfc/ndef.c` (@0x6r1an0y) - Fixed `hf iclass sam` - removed the old implementation (@iceman1001) - Fixed Proxmark5 (PM5/AT32) failing to re-enter the bootloader (@nemanjan00) - Fixed `hw fpga config` on Proxmark5 (PM5/AT32) now powers on the FPGA 24MHz clock (@nemanjan00) diff --git a/client/src/cmdhfmfu.c b/client/src/cmdhfmfu.c index 74ec9cbe7..1b307e2bd 100644 --- a/client/src/cmdhfmfu.c +++ b/client/src/cmdhfmfu.c @@ -7402,6 +7402,431 @@ int CmdHF14MfuNDEFRead(const char *Cmd) { return status; } + +// Build a NDEF message from the CLI options and write it into the data area of a +// MIFARE Ultralight / NTAG tag. The tag has to be NDEF formatted already, this +// command never touches the Capability Container in block 3. +int CmdHF14MfuNDEFWrite(const char *Cmd) { + + int ak_len = 0; + bool has_auth_key = false; + bool has_pwd = false; + bool swap_endian = false; + + iso14a_card_select_t card; + uint8_t data[16] = {0x00}; + uint8_t authenticationkey[16] = {0x00}; + uint8_t *auth_key_ptr = authenticationkey; + uint8_t pack[4] = {0, 0, 0, 0}; + + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf mfu ndefwrite", + "Write NFC Data Exchange Format (NDEF) records to a MIFARE Ultralight / NTAG tag.\n" + "The tag must already be NDEF formatted, ie carry a Capability Container in block 3.\n" + "\n" + "Combine several of --uri, --text and --aar to build a multi record message,\n" + "records are added in that order. Alternatively supply raw NDEF bytes with -d\n" + "or -f, those get wrapped in a TLV container automatically when they are not\n" + "already. Use `nfc encode` to build such raw bytes offline.\n" + "\n" + "Note: the tag is re-selected and re-authenticated for every block written,\n" + "so a large message takes a while.", + "hf mfu ndefwrite --uri https://proxmark.com\n" + "hf mfu ndefwrite --uri tel:+123456789\n" + "hf mfu ndefwrite --text \"hello world\"\n" + "hf mfu ndefwrite --aar com.example.app\n" + "hf mfu ndefwrite --uri https://proxmark.com --aar com.example.app\n" + "hf mfu ndefwrite --uri https://proxmark.com -k ffffffff\n" + "hf mfu ndefwrite -d 0311D1010D550270726F786D61726B2E636F6DFE\n" + "hf mfu ndefwrite -f myfilename" + ); + + void *argtable[] = { + arg_param_begin, + arg_str0("k", "key", "", "Authentication key (UL-C/UL-AES 16 bytes, EV1/NTAG 4 bytes)"), + arg_lit0("l", NULL, "Swap entered key endianness"), + arg_str0(NULL, "uri", "", "URI record. URL, tel:, mailto:, ..."), + arg_str0(NULL, "text", "", "Text record"), + arg_str0(NULL, "lang", "", "language code for the text record (default: en)"), + arg_str0(NULL, "aar", "", "Android Application Record, ie an app package name"), + arg_str0("d", "data", "", "Raw NDEF bytes to write"), + arg_str0("f", "file", "", "Raw NDEF file to write"), + arg_lit0("v", "verbose", "Verbose output"), + arg_lit0(NULL, "schann", "use secure channel. Must have key"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + + CLIGetHexWithReturn(ctx, 1, authenticationkey, &ak_len); + swap_endian = arg_get_lit(ctx, 2); + + // CLIParamStrToBuf copies the trailing NUL as well but only rejects lengths + // strictly above maxdatalen, so leave room for that byte + int urilen = 0; + char uri[1024] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 3), (uint8_t *)uri, sizeof(uri) - 1, &urilen); + + int textlen = 0; + char text[1024] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 4), (uint8_t *)text, sizeof(text) - 1, &textlen); + + int langlen = 0; + char lang[32] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 5), (uint8_t *)lang, sizeof(lang) - 1, &langlen); + + int aarlen = 0; + char aar[256] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 6), (uint8_t *)aar, sizeof(aar) - 1, &aarlen); + + int rawlen = 0; + uint8_t raw[MFU_NDEF_MAX_BYTES] = {0}; + CLIGetHexWithReturn(ctx, 7, raw, &rawlen); + + int fnlen = 0; + char filename[FILE_PATH_SIZE] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 8), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); + + bool verbose = arg_get_lit(ctx, 9); + bool use_schann = arg_get_lit(ctx, 10); + CLIParserFree(ctx); + + bool has_records = (urilen || textlen || aarlen); + int sources = (has_records ? 1 : 0) + (rawlen ? 1 : 0) + (fnlen ? 1 : 0); + if (sources == 0) { + PrintAndLogEx(ERR, "Nothing to write. See `" _YELLOW_("hf mfu ndefwrite -h") "`"); + return PM3_EINVARG; + } + if (sources > 1) { + PrintAndLogEx(ERR, "Use either the record options, -d or -f, not a mix of them"); + return PM3_EINVARG; + } + + if ((langlen != 0) && (textlen == 0)) { + PrintAndLogEx(WARNING, "--lang only applies to a text record, ignoring"); + } + + switch (ak_len) { + case 0: + break; + case 4: + has_pwd = true; + break; + case 16: + has_auth_key = true; + break; + default: + PrintAndLogEx(WARNING, "ERROR: Key is incorrect length\n"); + return PM3_EINVARG; + } + + if (use_schann && (has_auth_key == false)) { + PrintAndLogEx(WARNING, "Secure channel must be called with key"); + return PM3_EINVARG; + } + + // ------------------------------------------------------------------ + // build the TLV block that goes onto the tag + // ------------------------------------------------------------------ + uint8_t tlv[MFU_NDEF_MAX_BYTES] = {0}; + size_t tlv_len = 0; + int res = PM3_SUCCESS; + + if (has_records) { + + NDEFRecordDesc_t recs[3] = {{0}}; + size_t count = 0; + + uint8_t p_uri[sizeof(uri) + 1] = {0}; + size_t p_uri_len = 0; + if (urilen) { + res = NDEFEncodePayloadURI(uri, p_uri, sizeof(p_uri), &p_uri_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode URI record"); + return res; + } + recs[count].tnf = tnfWellKnownRecord; + recs[count].type = (const uint8_t *)NDEF_TYPE_URI; + recs[count].typeLen = strlen(NDEF_TYPE_URI); + recs[count].payload = p_uri; + recs[count].payloadLen = p_uri_len; + count++; + } + + uint8_t p_text[sizeof(text) + sizeof(lang) + 1] = {0}; + size_t p_text_len = 0; + if (textlen) { + res = NDEFEncodePayloadText(text, lang, p_text, sizeof(p_text), &p_text_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode Text record"); + return res; + } + recs[count].tnf = tnfWellKnownRecord; + recs[count].type = (const uint8_t *)NDEF_TYPE_TEXT; + recs[count].typeLen = strlen(NDEF_TYPE_TEXT); + recs[count].payload = p_text; + recs[count].payloadLen = p_text_len; + count++; + } + + uint8_t p_aar[sizeof(aar)] = {0}; + size_t p_aar_len = 0; + if (aarlen) { + res = NDEFEncodePayloadAAR(aar, p_aar, sizeof(p_aar), &p_aar_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode Android Application Record"); + return res; + } + recs[count].tnf = tnfExternalRecord; + recs[count].type = (const uint8_t *)NDEF_ANDROID_AAR; + recs[count].typeLen = strlen(NDEF_ANDROID_AAR); + recs[count].payload = p_aar; + recs[count].payloadLen = p_aar_len; + count++; + } + + uint8_t msg[MFU_NDEF_MAX_BYTES] = {0}; + size_t msg_len = 0; + res = NDEFEncodeMessage(recs, count, msg, sizeof(msg), &msg_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode NDEF message"); + return res; + } + + res = NDEFEncodeTLV(msg, msg_len, tlv, sizeof(tlv), &tlv_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to wrap NDEF message in a TLV container"); + return res; + } + + } else { + + uint8_t *src = raw; + size_t src_len = (size_t)rawlen; + uint8_t *dump = NULL; + + if (fnlen) { + size_t bytes_read = 0; + res = pm3_load_dump(filename, (void **)&dump, &bytes_read, sizeof(raw)); + if (res != PM3_SUCCESS) { + return res; + } + src = dump; + src_len = bytes_read; + } + + if (src_len == 0) { + PrintAndLogEx(ERR, "No NDEF data supplied"); + free(dump); + return PM3_EINVARG; + } + + // is it a TLV block already? + bool is_tlv = false; + switch (src[0]) { + case 0x00: + case 0x01: + case 0x02: + case 0x03: + case 0xFD: + case 0xFE: + is_tlv = true; + break; + default: + break; + } + + if (is_tlv) { + if (src_len > sizeof(tlv)) { + PrintAndLogEx(ERR, "NDEF data too large, %zu bytes", src_len); + free(dump); + return PM3_EINVARG; + } + memcpy(tlv, src, src_len); + tlv_len = src_len; + } else { + if (verbose) { + PrintAndLogEx(INFO, "Raw data is not TLV wrapped, adding container"); + } + res = NDEFEncodeTLV(src, src_len, tlv, sizeof(tlv), &tlv_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to wrap NDEF message in a TLV container"); + free(dump); + return res; + } + } + + free(dump); + } + + if (verbose) { + PrintAndLogEx(INFO, "TLV block [%zu]...", tlv_len); + print_hex_noascii_break(tlv, tlv_len, 32); + } + + // ------------------------------------------------------------------ + // find the tag and check the message fits + // ------------------------------------------------------------------ + uint64_t tagtype = GetHF14AMfU_Type(); + if (tagtype == MFU_TT_UL_ERROR) { + PrintAndLogEx(WARNING, "No Ultralight / NTAG based tag found"); + return PM3_ESOFT; + } + + ul_print_type(tagtype, 0); + + if (swap_endian) { + if (ak_len == 16) { + if (((tagtype & MFU_TT_UL_C) == MFU_TT_UL_C)) { + auth_key_ptr = SwapEndian64(authenticationkey, ak_len, 8); + } else if (((tagtype & MFU_TT_UL_AES) == MFU_TT_UL_AES)) { + auth_key_ptr = SwapEndian64(authenticationkey, ak_len, 16); + } + } else if (ak_len == 4) { + auth_key_ptr = SwapEndian64(authenticationkey, ak_len, 4); + } + } + + if (ul_auth_select(&card, tagtype, (has_auth_key || has_pwd), auth_key_ptr, pack, sizeof(pack), use_schann) == PM3_ESOFT) { + return PM3_ESOFT; + } + + // read blocks 0..3 to get at the Capability Container + int status = ul_read(0, data, sizeof(data), use_schann); + if (status <= 0) { + DropField(); + PrintAndLogEx(ERR, "Error: tag didnt answer to READ"); + return PM3_ESOFT; + } + + if (status != 16) { + DropField(); + PrintAndLogEx(ERR, "Error: tag returned %d bytes, need 16 to read the NDEF Container", status); + return PM3_ESOFT; + } + + if (ndef_print_CC(data + 12) == PM3_ESOFT) { + DropField(); + PrintAndLogEx(ERR, "Error: tag didnt contain a NDEF Container"); + PrintAndLogEx(HINT, "Hint: the tag needs to be NDEF formatted first"); + return PM3_ESOFT; + } + + // size of the NDEF data area + uint16_t ndef_size = ndef_get_maxsize(data + 12); + if (ndef_size == 0) { + DropField(); + PrintAndLogEx(ERR, "Error: tag announces an empty NDEF data area"); + return PM3_ESOFT; + } + + // The data area starts at block 4, so cap the announced size to what the + // identified tag can physically hold. UL_MEMORY_ARRAY holds the last valid + // block number, hence the +1. + for (uint8_t idx = 1; idx < ARRAYLEN(UL_TYPES_ARRAY); idx++) { + if ((tagtype & UL_TYPES_ARRAY[idx]) == UL_TYPES_ARRAY[idx]) { + + int avail = (UL_MEMORY_ARRAY[idx] + 1 - MFU_NDEF_FIRST_BLOCK) * MFU_BLOCK_SIZE; + if (avail > 0 && ndef_size > avail) { + PrintAndLogEx(INFO, "NDEF data area (%u bytes) is larger than the tag (%d bytes), using tag size" + , ndef_size + , avail + ); + ndef_size = avail; + } + break; + } + } + + // MLEN can announce up to 2040 bytes but WRITE addresses blocks with a single + // byte, so block 255 is the last one we can reach. + if (ndef_size > MFU_NDEF_MAX_BYTES) { + ndef_size = MFU_NDEF_MAX_BYTES; + } + + if (tlv_len > ndef_size) { + DropField(); + PrintAndLogEx(ERR, "NDEF message is too large for this tag"); + PrintAndLogEx(ERR, " message..... " _RED_("%zu") " bytes", tlv_len); + PrintAndLogEx(ERR, " tag holds... " _GREEN_("%u") " bytes", ndef_size); + return PM3_EINVARG; + } + + DropField(); + + // ------------------------------------------------------------------ + // write it out, one block at a time + // ------------------------------------------------------------------ + uint8_t keytype = 0; + if (has_auth_key || has_pwd) { + if ((tagtype & MFU_TT_UL_C) == MFU_TT_UL_C) { + keytype = 1; // UL_C auth + } else if ((tagtype & MFU_TT_UL_AES) == MFU_TT_UL_AES) { + keytype = 3; // UL_AES auth + } else { + keytype = 2; // UL_EV1/NTAG auth + } + } + + // pad the tail so the last block is complete + size_t padded_len = (tlv_len + (MFU_BLOCK_SIZE - 1)) & ~((size_t)MFU_BLOCK_SIZE - 1); + uint16_t blocks = (uint16_t)(padded_len / MFU_BLOCK_SIZE); + + PrintAndLogEx(INFO, "Writing " _YELLOW_("%u") " blocks ( %zu bytes ) from block " _YELLOW_("%d") + , blocks + , padded_len + , MFU_NDEF_FIRST_BLOCK + ); + PrintAndLogEx(INFO, "Press " _GREEN_("") " to abort"); + + for (uint16_t i = 0; i < blocks; i++) { + + if (kbd_enter_pressed()) { + PrintAndLogEx(NORMAL, ""); + PrintAndLogEx(WARNING, "aborted via keyboard!"); + if (i > 0) { + PrintAndLogEx(WARNING, "tag holds a partially written NDEF message, blocks %d..%u" + , MFU_NDEF_FIRST_BLOCK + , MFU_NDEF_FIRST_BLOCK + i - 1 + ); + } + return PM3_EOPABORTED; + } + + uint8_t blockno = (uint8_t)(MFU_NDEF_FIRST_BLOCK + i); + + res = mfu_write_block(tlv + (i * MFU_BLOCK_SIZE), MFU_BLOCK_SIZE, keytype, auth_key_ptr, blockno, use_schann); + if (res != PM3_SUCCESS) { + PrintAndLogEx(NORMAL, ""); + + // a protected tag simply stops answering, so the write times out + // rather than coming back with an explicit error + if (res == PM3_ETIMEOUT) { + PrintAndLogEx(FAILED, "Write block %u ( " _RED_("timeout") " )", blockno); + } else { + PrintAndLogEx(FAILED, "Write block %u ( " _RED_("fail") " )", blockno); + } + PrintAndLogEx(HINT, "Hint: Check password / key!"); + + if (i > 0) { + PrintAndLogEx(WARNING, "tag holds a partially written NDEF message, blocks %d..%u" + , MFU_NDEF_FIRST_BLOCK + , blockno - 1 + ); + } + return PM3_ESOFT; + } + + PrintAndLogEx(INPLACE, "Block %u / %u", i + 1, blocks); + } + + DropField(); + + PrintAndLogEx(NORMAL, ""); + PrintAndLogEx(SUCCESS, "Write ( " _GREEN_("ok") " )"); + PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("hf mfu ndefread") "` to verify"); + PrintAndLogEx(NORMAL, ""); + return PM3_SUCCESS; +} // utility function. Retrieves emulator memory static int GetMfuDumpFromEMul(mfu_dump_t **buf) { @@ -8274,6 +8699,7 @@ static command_t CommandTable[] = { {"incr", CmdHF14AMfUIncr, IfPm3Iso14443a, "Increments Ev1/NTAG counter"}, {"info", CmdHF14AMfUInfo, IfPm3Iso14443a, "Tag information"}, {"ndefread", CmdHF14MfuNDEFRead, IfPm3Iso14443a, "Prints NDEF records from card"}, + {"ndefwrite", CmdHF14MfuNDEFWrite, IfPm3Iso14443a, "Write NDEF records to card"}, {"rdbl", CmdHF14AMfURdBl, IfPm3Iso14443a, "Read block"}, {"restore", CmdHF14AMfURestore, IfPm3Iso14443a, "Restore a dump file onto a tag"}, {"tamper", CmdHF14MfUTamper, IfPm3Iso14443a, "NTAG 213TT - Configure the tamper feature"}, diff --git a/client/src/cmdhfmfu.h b/client/src/cmdhfmfu.h index d283665ad..1eb49488b 100644 --- a/client/src/cmdhfmfu.h +++ b/client/src/cmdhfmfu.h @@ -57,7 +57,8 @@ int mfu_get_version_uid(uint8_t *version, uint8_t *uid); int mfuc_test_authentication_support(void); int CmdHFMFUltra(const char *Cmd); -int CmdHF14MfuNDEFRead(const char *Cmd); +int CmdHF14MfuNDEFRead(const char *Cmd); // used by cmdnfc.c +int CmdHF14MfuNDEFWrite(const char *Cmd); // used by cmdnfc.c int CmdHF14MfUTamper(const char *Cmd); #define MFU_TT_UNKNOWN 0x0ULL diff --git a/client/src/cmdnfc.c b/client/src/cmdnfc.c index fe58e5aba..67dfa2720 100644 --- a/client/src/cmdnfc.c +++ b/client/src/cmdnfc.c @@ -178,6 +178,183 @@ static int CmdNfcDecode(const char *Cmd) { return res; } +static int CmdNfcEncode(const char *Cmd) { + +#ifndef MAX_NDEF_LEN +#define MAX_NDEF_LEN 2048 +#endif + + CLIParserContext *ctx; + CLIParserInit(&ctx, "nfc encode", + "Encode NFC Data Exchange Format (NDEF) records.\n" + "Combine several options to build a multi record message,\n" + "records are added in the order listed below.\n" + "\n" + "By default a bare NDEF message is emitted. Use `--tlv` to wrap it in a\n" + "NFC Forum Type 2 tag container ( 03 ... FE ), which is what the\n" + "`-d` parameter of `hf mf ndefwrite` and `hf 14a ndefwrite` expects.\n" + "`hf mfu ndefwrite` adds the container itself, so it does not need `--tlv`", + "nfc encode --uri https://proxmark.com\n" + "nfc encode --uri tel:+123456789\n" + "nfc encode --text \"hello world\"\n" + "nfc encode --aar com.example.app\n" + "nfc encode --uri https://proxmark.com --aar com.example.app\n" + "nfc encode --uri https://proxmark.com --tlv -f myfilename" + ); + + void *argtable[] = { + arg_param_begin, + arg_str0(NULL, "uri", "", "URI record. URL, tel:, mailto:, ..."), + arg_str0(NULL, "text", "", "Text record"), + arg_str0(NULL, "lang", "", "language code for the text record (default: en)"), + arg_str0(NULL, "aar", "", "Android Application Record, ie an app package name"), + arg_lit0(NULL, "tlv", "wrap message in a NFC Forum Type 2 tag TLV container"), + arg_str0("f", "file", "", "save raw bytes to file"), + arg_lit0("v", "verbose", "verbose output"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, false); + + // CLIParamStrToBuf copies the trailing NUL as well but only rejects lengths + // strictly above maxdatalen, so leave room for that byte + int urilen = 0; + char uri[1024] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)uri, sizeof(uri) - 1, &urilen); + + int textlen = 0; + char text[1024] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 2), (uint8_t *)text, sizeof(text) - 1, &textlen); + + int langlen = 0; + char lang[32] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 3), (uint8_t *)lang, sizeof(lang) - 1, &langlen); + + int aarlen = 0; + char aar[256] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 4), (uint8_t *)aar, sizeof(aar) - 1, &aarlen); + + bool use_tlv = arg_get_lit(ctx, 5); + + int fnlen = 0; + char filename[FILE_PATH_SIZE] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 6), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); + + bool verbose = arg_get_lit(ctx, 7); + CLIParserFree(ctx); + + if ((urilen == 0) && (textlen == 0) && (aarlen == 0)) { + PrintAndLogEx(ERR, "Must specify at least one record. See `" _YELLOW_("nfc encode -h") "`"); + return PM3_EINVARG; + } + + if ((langlen != 0) && (textlen == 0)) { + PrintAndLogEx(WARNING, "`--lang` only applies to a text record, ignoring"); + } + + NDEFRecordDesc_t recs[3] = {{0}}; + size_t count = 0; + int res = PM3_SUCCESS; + + uint8_t p_uri[sizeof(uri) + 1] = {0}; + size_t p_uri_len = 0; + if (urilen) { + res = NDEFEncodePayloadURI(uri, p_uri, sizeof(p_uri), &p_uri_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode URI record"); + return res; + } + recs[count].tnf = tnfWellKnownRecord; + recs[count].type = (const uint8_t *)NDEF_TYPE_URI; + recs[count].typeLen = strlen(NDEF_TYPE_URI); + recs[count].payload = p_uri; + recs[count].payloadLen = p_uri_len; + count++; + } + + uint8_t p_text[sizeof(text) + sizeof(lang) + 1] = {0}; + size_t p_text_len = 0; + if (textlen) { + res = NDEFEncodePayloadText(text, lang, p_text, sizeof(p_text), &p_text_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode Text record"); + return res; + } + recs[count].tnf = tnfWellKnownRecord; + recs[count].type = (const uint8_t *)NDEF_TYPE_TEXT; + recs[count].typeLen = strlen(NDEF_TYPE_TEXT); + recs[count].payload = p_text; + recs[count].payloadLen = p_text_len; + count++; + } + + uint8_t p_aar[sizeof(aar)] = {0}; + size_t p_aar_len = 0; + if (aarlen) { + res = NDEFEncodePayloadAAR(aar, p_aar, sizeof(p_aar), &p_aar_len); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode Android Application Record"); + return res; + } + recs[count].tnf = tnfExternalRecord; + recs[count].type = (const uint8_t *)NDEF_ANDROID_AAR; + recs[count].typeLen = strlen(NDEF_ANDROID_AAR); + recs[count].payload = p_aar; + recs[count].payloadLen = p_aar_len; + count++; + } + + uint8_t msg[MAX_NDEF_LEN] = {0}; + size_t msglen = 0; + res = NDEFEncodeMessage(recs, count, msg, sizeof(msg), &msglen); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to encode NDEF message"); + return res; + } + + uint8_t tlv[MAX_NDEF_LEN] = {0}; + uint8_t *out = msg; + size_t outlen = msglen; + + if (use_tlv) { + size_t tlvlen = 0; + res = NDEFEncodeTLV(msg, msglen, tlv, sizeof(tlv), &tlvlen); + if (res != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Failed to wrap NDEF message in a TLV container"); + return res; + } + out = tlv; + outlen = tlvlen; + } + + PrintAndLogEx(NORMAL, ""); + PrintAndLogEx(INFO, "--- " _CYAN_("NDEF encoding") " ----------------"); + PrintAndLogEx(SUCCESS, "Records......... " _YELLOW_("%zu"), count); + PrintAndLogEx(SUCCESS, "Message size.... " _YELLOW_("%zu") " bytes", msglen); + if (use_tlv) { + PrintAndLogEx(SUCCESS, "TLV size........ " _YELLOW_("%zu") " bytes", outlen); + } + + PrintAndLogEx(NORMAL, ""); + if (outlen > 64) { + print_hex_noascii_break(out, outlen, 32); + } else { + PrintAndLogEx(SUCCESS, _GREEN_("%s"), sprint_hex_inrow(out, outlen)); + } + + if (fnlen) { + saveFile(filename, ".bin", out, outlen); + } + + // round trip it back through the decoder, so the user can see what a reader will see + if (use_tlv) { + NDEFDecodeAndPrint(out, outlen, verbose); + } else { + NDEFRecordsDecodeAndPrint(out, outlen, verbose); + } + + return PM3_SUCCESS; +} + static int CmdNFCType1Read(const char *Cmd) { return CmdHFTopazInfo(Cmd); } @@ -210,6 +387,10 @@ static int CmdNFCType2Read(const char *Cmd) { return CmdHF14MfuNDEFRead(Cmd); } +static int CmdNFCType2Write(const char *Cmd) { + return CmdHF14MfuNDEFWrite(Cmd); +} + static int CmdNFCType2Help(const char *Cmd); static command_t CommandNFCType2Table[] = { @@ -217,7 +398,7 @@ static command_t CommandNFCType2Table[] = { {"--------", CmdNFCType2Help, AlwaysAvailable, "-------------- " _CYAN_("NFC Forum Tag Type 2") " ---------------"}, // {"format", CmdNFCType2Format, IfPm3Iso14443a, "format ISO-14443-a tag as NFC Tag"}, {"read", CmdNFCType2Read, IfPm3Iso14443a, "read NFC Forum Tag Type 2"}, -// {"write", CmdNFCType2Write, IfPm3Iso14443a, "write NFC Forum Tag Type 2"}, + {"write", CmdNFCType2Write, IfPm3Iso14443a, "write NFC Forum Tag Type 2"}, {"--------", CmdNFCType2Help, AlwaysAvailable, "--------------------- " _CYAN_("General") " ---------------------"}, {"help", CmdNFCType2Help, AlwaysAvailable, "This help"}, {NULL, NULL, NULL, NULL} @@ -459,7 +640,7 @@ static command_t CommandTable[] = { {"--------", CmdHelp, AlwaysAvailable, "--------------------- " _CYAN_("General") " ---------------------"}, {"help", CmdHelp, AlwaysAvailable, "This help"}, {"decode", CmdNfcDecode, AlwaysAvailable, "Decode NDEF records"}, -// {"encode", CmdNfcEncode, AlwaysAvailable, "Encode NDEF records"}, + {"encode", CmdNfcEncode, AlwaysAvailable, "Encode NDEF records"}, {NULL, NULL, NULL, NULL} }; diff --git a/client/src/nfc/ndef.c b/client/src/nfc/ndef.c index 6acf53cc0..d02f050d5 100644 --- a/client/src/nfc/ndef.c +++ b/client/src/nfc/ndef.c @@ -998,6 +998,17 @@ static int ndefDecodeExternal_record(NDEFHeader_t *ndef) { return PM3_SUCCESS; } + // Android Application Record + if ((ndef->TypeLen == strlen(NDEF_ANDROID_AAR)) && + (strncmp((char *)ndef->Type, NDEF_ANDROID_AAR, ndef->TypeLen) == 0)) { + PrintAndLogEx(INFO + , " Android app... " _GREEN_("%.*s") + , (int)ndef->PayloadLen + , ndef->Payload + ); + return PM3_SUCCESS; + } + PrintAndLogEx(INFO , " URN... " _GREEN_("urn:nfc:ext:%.*s") , (int)ndef->TypeLen @@ -1393,3 +1404,257 @@ int NDEFGetTotalLength(uint8_t *ndef, size_t ndeflen, size_t *outlen) { *outlen = idx; return PM3_SUCCESS; } + +//----------------------------------------------------------------------------- +// NDEF encoding +//----------------------------------------------------------------------------- + +// Find the longest matching abbreviation from URI_s[]. +// Returns the prefix code and sets prefixLen to how many bytes of uri it covers. +// Code 0x00 means "no abbreviation", the whole string gets stored verbatim. +static uint8_t ndefEncodeURIPrefix(const char *uri, size_t *prefixLen) { + + uint8_t code = 0; + size_t best = 0; + + for (uint8_t i = 1; i < ARRAYLEN(URI_s); i++) { + size_t n = strlen(URI_s[i]); + if ((n > best) && (strncmp(uri, URI_s[i], n) == 0)) { + best = n; + code = i; + } + } + + *prefixLen = best; + return code; +} + +int NDEFEncodePayloadURI(const char *uri, uint8_t *buf, size_t bufLen, size_t *outLen) { + + if ((uri == NULL) || (buf == NULL) || (outLen == NULL)) { + return PM3_EINVARG; + } + + size_t uri_len = strlen(uri); + if (uri_len == 0) { + return PM3_EINVARG; + } + + size_t prefix_len = 0; + uint8_t code = ndefEncodeURIPrefix(uri, &prefix_len); + + size_t n = 1 + (uri_len - prefix_len); + if (n > bufLen) { + return PM3_EOVFLOW; + } + + buf[0] = code; + memcpy(buf + 1, uri + prefix_len, uri_len - prefix_len); + + *outLen = n; + return PM3_SUCCESS; +} + +int NDEFEncodePayloadText(const char *text, const char *lang, uint8_t *buf, size_t bufLen, size_t *outLen) { + + if ((text == NULL) || (buf == NULL) || (outLen == NULL)) { + return PM3_EINVARG; + } + + if ((lang == NULL) || (strlen(lang) == 0)) { + lang = "en"; + } + + size_t lang_len = strlen(lang); + size_t text_len = strlen(text); + + // the status byte carries the language code length in its lower 6 bits + if (lang_len > 0x3F) { + return PM3_EINVARG; + } + + size_t n = 1 + lang_len + text_len; + if (n > bufLen) { + return PM3_EOVFLOW; + } + + // bit 7 clear == UTF-8 + buf[0] = (uint8_t)(lang_len & 0x3F); + memcpy(buf + 1, lang, lang_len); + memcpy(buf + 1 + lang_len, text, text_len); + + *outLen = n; + return PM3_SUCCESS; +} + +int NDEFEncodePayloadAAR(const char *pkg, uint8_t *buf, size_t bufLen, size_t *outLen) { + + if ((pkg == NULL) || (buf == NULL) || (outLen == NULL)) { + return PM3_EINVARG; + } + + size_t n = strlen(pkg); + if (n == 0) { + return PM3_EINVARG; + } + + if (n > bufLen) { + return PM3_EOVFLOW; + } + + memcpy(buf, pkg, n); + + *outLen = n; + return PM3_SUCCESS; +} + +int NDEFEncodeRecord(const NDEFRecordDesc_t *rec, bool mb, bool me, uint8_t *buf, size_t bufLen, size_t *outLen) { + + if ((rec == NULL) || (buf == NULL) || (outLen == NULL)) { + return PM3_EINVARG; + } + + if ((rec->typeLen > 255) || (rec->idLen > 255)) { + return PM3_EINVARG; + } + +#if SIZE_MAX > 0xFFFFFFFF + // the long form payload length field is only four bytes wide, a larger payload + // cannot be expressed. unreachable where size_t is no wider than the field. + if (rec->payloadLen > 0xFFFFFFFF) { + return PM3_EINVARG; + } +#endif + + if ((rec->typeLen && (rec->type == NULL)) || + (rec->idLen && (rec->id == NULL)) || + (rec->payloadLen && (rec->payload == NULL))) { + return PM3_EINVARG; + } + + bool sr = (rec->payloadLen < 256); + bool il = (rec->idLen > 0); + + size_t head = 1 + 1 + (sr ? 1 : 4) + (il ? 1 : 0) + rec->typeLen + rec->idLen; + + // keep the total from wrapping before it reaches the bufLen check below + if (rec->payloadLen > SIZE_MAX - head) { + return PM3_EINVARG; + } + + size_t n = head + rec->payloadLen; + if (n > bufLen) { + return PM3_EOVFLOW; + } + + size_t idx = 0; + + // MB | ME | CF | SR | IL | TNF. chunked records are never emitted + buf[idx] = (uint8_t)(rec->tnf & 0x07); + if (mb) { + buf[idx] |= 0x80; + } + if (me) { + buf[idx] |= 0x40; + } + if (sr) { + buf[idx] |= 0x10; + } + if (il) { + buf[idx] |= 0x08; + } + idx++; + + buf[idx++] = (uint8_t)rec->typeLen; + + if (sr) { + buf[idx++] = (uint8_t)rec->payloadLen; + } else { + buf[idx++] = (uint8_t)(rec->payloadLen >> 24); + buf[idx++] = (uint8_t)(rec->payloadLen >> 16); + buf[idx++] = (uint8_t)(rec->payloadLen >> 8); + buf[idx++] = (uint8_t)(rec->payloadLen); + } + + if (il) { + buf[idx++] = (uint8_t)rec->idLen; + } + + if (rec->typeLen) { + memcpy(buf + idx, rec->type, rec->typeLen); + idx += rec->typeLen; + } + + if (rec->idLen) { + memcpy(buf + idx, rec->id, rec->idLen); + idx += rec->idLen; + } + + if (rec->payloadLen) { + memcpy(buf + idx, rec->payload, rec->payloadLen); + idx += rec->payloadLen; + } + + *outLen = idx; + return PM3_SUCCESS; +} + +int NDEFEncodeMessage(const NDEFRecordDesc_t *recs, size_t count, uint8_t *buf, size_t bufLen, size_t *outLen) { + + if ((recs == NULL) || (buf == NULL) || (outLen == NULL) || (count == 0)) { + return PM3_EINVARG; + } + + size_t idx = 0; + for (size_t i = 0; i < count; i++) { + + size_t n = 0; + int res = NDEFEncodeRecord(&recs[i], (i == 0), (i == (count - 1)), buf + idx, bufLen - idx, &n); + if (res != PM3_SUCCESS) { + return res; + } + idx += n; + } + + *outLen = idx; + return PM3_SUCCESS; +} + +int NDEFEncodeTLV(const uint8_t *msg, size_t msgLen, uint8_t *buf, size_t bufLen, size_t *outLen) { + + if ((msg == NULL) || (buf == NULL) || (outLen == NULL) || (msgLen == 0)) { + return PM3_EINVARG; + } + + // 0xFFFF is reserved, and the terminator has to fit as well + if (msgLen > 0xFFFE) { + return PM3_EINVARG; + } + + // one byte length form up to 254, three byte form above that + size_t hdr = (msgLen < 0xFF) ? 2 : 4; + + size_t n = hdr + msgLen + 1; + if (n > bufLen) { + return PM3_EOVFLOW; + } + + size_t idx = 0; + buf[idx++] = 0x03; + + if (msgLen < 0xFF) { + buf[idx++] = (uint8_t)msgLen; + } else { + buf[idx++] = 0xFF; + buf[idx++] = (uint8_t)(msgLen >> 8); + buf[idx++] = (uint8_t)(msgLen); + } + + memcpy(buf + idx, msg, msgLen); + idx += msgLen; + + buf[idx++] = 0xFE; + + *outLen = idx; + return PM3_SUCCESS; +} diff --git a/client/src/nfc/ndef.h b/client/src/nfc/ndef.h index 31967c61a..ddc78dc9f 100644 --- a/client/src/nfc/ndef.h +++ b/client/src/nfc/ndef.h @@ -77,4 +77,35 @@ typedef struct { int NDEFDecodeAndPrint(uint8_t *ndef, size_t ndefLen, bool verbose); int NDEFRecordsDecodeAndPrint(uint8_t *ndefRecord, size_t ndefRecordLen, bool verbose); int NDEFGetTotalLength(uint8_t *ndef, size_t ndeflen, size_t *outlen); + +// NFC Forum well known types +#define NDEF_TYPE_URI "U" +#define NDEF_TYPE_TEXT "T" + +// Android Application Record, TNF external +#define NDEF_ANDROID_AAR "android.com:pkg" + +// Describes one record to be encoded. +// Field order intentionally matches gst_ndef_record_t in cmdhfgst.c so the two +// can eventually be folded together. +typedef struct { + TypeNameFormat_t tnf; + const uint8_t *type; + size_t typeLen; + const uint8_t *id; + size_t idLen; + const uint8_t *payload; + size_t payloadLen; +} NDEFRecordDesc_t; + +// payload builders +int NDEFEncodePayloadURI(const char *uri, uint8_t *buf, size_t bufLen, size_t *outLen); +int NDEFEncodePayloadText(const char *text, const char *lang, uint8_t *buf, size_t bufLen, size_t *outLen); +int NDEFEncodePayloadAAR(const char *pkg, uint8_t *buf, size_t bufLen, size_t *outLen); + +// record / message / TLV assembly +int NDEFEncodeRecord(const NDEFRecordDesc_t *rec, bool mb, bool me, uint8_t *buf, size_t bufLen, size_t *outLen); +int NDEFEncodeMessage(const NDEFRecordDesc_t *recs, size_t count, uint8_t *buf, size_t bufLen, size_t *outLen); +int NDEFEncodeTLV(const uint8_t *msg, size_t msgLen, uint8_t *buf, size_t bufLen, size_t *outLen); + #endif // _NDEF_H_ From 5174a54cbc1c0f22c5e0b1266b19cab3501df98a Mon Sep 17 00:00:00 2001 From: dxl <64101226@qq.com> Date: Sat, 22 Aug 2026 02:35:50 +0800 Subject: [PATCH 02/12] Fixed hitag2 sniffing. 1. Fixed a bug where old data caused incorrect bitwise operation results. 2. Do not call ResetLoEdgeCapture(), as this will prevent the condition rb >= HITAG_T_EOF from ever being met. 3. PM5 and RDV4 have been tested and have good compatibility. 4. FPGA_LF_EDGE_DETECT_TOGGLE_MODE seems to be useless. --- armsrc/hitag2.c | 59 +++++++++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 26 deletions(-) diff --git a/armsrc/hitag2.c b/armsrc/hitag2.c index 477c43414..038cb3a4d 100644 --- a/armsrc/hitag2.c +++ b/armsrc/hitag2.c @@ -1007,10 +1007,8 @@ void hitag_sniff(void) { // Set up eavesdropping mode, frequency divisor which will drive the FPGA // and analog mux selection. FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT | FPGA_LF_EDGE_DETECT_TOGGLE_MODE); - FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); // 125Khz + FpgaSendCommand(FPGA_CMD_SET_DIVISOR, LF_DIVISOR_125); // 125Khz SetAdcMuxFor(ADC_MUXSEL_LOPKD); - RELAY_OFF(); - } @@ -1167,19 +1165,15 @@ void SniffHitag2(bool ledcontrol) { } */ + // Dont use the FPGA modulation output, we only want to capture the tag/reader comms + gpio_fpga_mod_only_setup(); + Gpio_SSC_DOUT_Low(); + // Set up eavesdropping mode, frequency divisor which will drive the FPGA // and analog mux selection. - FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT | FPGA_LF_EDGE_DETECT_TOGGLE_MODE); - FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); // 125Khz + FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_EDGE_DETECT); + FpgaSendCommand(FPGA_CMD_SET_DIVISOR, LF_DIVISOR_125); // 125Khz SetAdcMuxFor(ADC_MUXSEL_LOPKD); - RELAY_OFF(); - - // Configure output pin that is connected to the FPGA (for modulating) -// AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT; -// AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT; - - // Disable modulation, we are going to eavesdrop, not modulate ;) -// Gpio_SSC_DOUT_Low(); // Configure the input capture (TC1) via the HAL: it enables the TC1 clock, routes // SSC_FRAME to the timer input, resets on each falling edge and captures RB @@ -1198,6 +1192,10 @@ void SniffHitag2(bool ledcontrol) { auth_table = (uint8_t *)BigBuf_calloc(AUTH_TABLE_LENGTH); + // Only for debug, if we want to see the edge timing of the captured frames + uint8_t edges[100]; + uint8_t e_count = 0; + while (BUTTON_PRESS() == false) { WDT_HIT(); @@ -1219,6 +1217,7 @@ void SniffHitag2(bool ledcontrol) { if (ledcontrol) LED_C_OFF(); reader_frame = true; rxlen = 0; + memset(rx, 0x00, sizeof(rx)); } } @@ -1226,6 +1225,10 @@ void SniffHitag2(bool ledcontrol) { if (lo_edge == LO_EDGE_FALLING) { int rb = GetLoEdgeCaptureFalling() / HITAG_T0; + if (e_count < sizeof(edges)) { + edges[e_count++] = rb; // Store the edge timing for debug purposes + } + if (reader_frame) { if (ledcontrol) LED_B_ON(); @@ -1233,7 +1236,9 @@ void SniffHitag2(bool ledcontrol) { if (rb >= HITAG_T_STOP) { // Capture the T0 periods that have passed since last communication or field drop (reset) response = (rb - HITAG_T_LOW); - if (rxlen != 0) { Dbprintf("rb - HITAG_T_LOW... %i", response); } + if (rxlen != 0) { + DBG Dbprintf("rb - HITAG_T_LOW... %i", response); + } } else if (rb >= HITAG_T_1_MIN) { // '1' bit @@ -1294,6 +1299,15 @@ void SniffHitag2(bool ledcontrol) { frame_count++; LogTraceBits(rx, rxlen, response, 0, reader_frame); + // Print only from tag response(No auth cmd from reader) + DBG { + if (rxlen >= 8) { + for (size_t i = 0; i < e_count; i++) { + Dbprintf("edges[%zu] = %u", i, edges[i]); + } + } + } + // Check if we recognize a valid authentication attempt if (rxlen == 64) { // Store the authentication attempt @@ -1313,28 +1327,21 @@ void SniffHitag2(bool ledcontrol) { lastbit = 1; bSkip = true; tag_sof = 4; - - if (ledcontrol) { - LED_B_OFF(); - LED_C_OFF(); - } - + e_count = 0; } - // Reset the frame length + // Reset the frame length and clear the buffer so that '0' bits written + // by the next frame don't inherit stale '1' bits from this one. rxlen = 0; - - // Reset the capture counter to restart the while-loop that receives frames. - ResetLoEdgeCapture(); + memset(rx, 0x00, sizeof(rx)); } if (ledcontrol) LEDsoff(); - StopLoEdgeCapture(); - DBG Dbprintf("frames.......... %d", frame_count); Dbprintf("Auth attempts... %d", (auth_table_len / 8)); + StopLoEdgeCapture(); switch_off(); BigBuf_free(); } From 2a11c73bbe91ca780b52acb56040cb89a196bf14 Mon Sep 17 00:00:00 2001 From: dxl <64101226@qq.com> Date: Sat, 22 Aug 2026 03:04:27 +0800 Subject: [PATCH 03/12] To expand crm_ertc_clock_select() in at32_bpr_write_dt1() for reduce code size. --- common_arm/sys/sys_hw_at32.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/common_arm/sys/sys_hw_at32.c b/common_arm/sys/sys_hw_at32.c index d09bbfed7..316913395 100644 --- a/common_arm/sys/sys_hw_at32.c +++ b/common_arm/sys/sys_hw_at32.c @@ -68,7 +68,8 @@ static void at32_bpr_write_dt1(uint32_t data) { // Select and enable an ERTC clock so the write-protection register is // writable at the full APB frequency. - crm_ertc_clock_select(CRM_ERTC_CLOCK_HEXT_DIV_20); + CRM->cfg_bit.ertcdiv = ((CRM_ERTC_CLOCK_HEXT_DIV_20 & 0x1F0) >> 4); + CRM->bpdc_bit.ertcsel = (CRM_ERTC_CLOCK_HEXT_DIV_20 & 0xF); CRM->bpdc_bit.ertcen = TRUE; ERTC->wp = SYS_SIMPLE_RESET_BPR_UNLOCK_KEY1; From f6e0119f5f4c378eb07a93db38fd3d2b0f33cfec Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Fri, 21 Aug 2026 22:32:06 +0200 Subject: [PATCH 04/12] added PACE (--can) support to emrtd commands. --- CHANGELOG.md | 6 +- client/CMakeLists.txt | 2 + client/Makefile | 2 + client/src/cmdhfemrtd.c | 1450 ++++++++++++++++++++++--------- client/src/cmdhfemrtd.h | 27 +- client/src/pm3line_vocabulary.h | 9 +- client/src/proxguiqt.cpp | 47 +- client/src/proxguiqt.h | 22 + doc/commands.json | 177 +++- doc/commands.md | 10 +- 10 files changed, 1305 insertions(+), 447 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e3e2fca2..16e10cbf2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,11 @@ All notable changes to this project will be documented in this file. This project uses the changelog in accordance with [keepchangelog](http://keepachangelog.com/). Please use this to write notable changes, which is not the same as git commit log... ## [unreleased][unreleased] -- Added `nfc encode` and `hf mfu ndefwrite` - build NDEF URI/Text/AAR records and write them to MIFARE Ultralight / NTAG tags, plus a reusable NDEF encoder in `nfc/ndef.c` (@0x6r1an0y) +- Added `nfc encode` and `hf mfu ndefwrite` - build NDEF URI/Text/AAR records and write them to Ultralight tags (@0x6r1an0y) +- Fixed `hf emrtd info` - the picture viewer now scales images to the window instead of pinning them at native size (@iceman1001) +- Added `hf emrtd` - PACE-CAM (Chip Authentication Mapping) session support. The anti-clone proof itself is not yet verified (@iceman1001) +- Added `hf emrtd test` - offline regression tests for the PACE / secure messaging primitives (@iceman1001) +- Added `hf emrtd info/dump --can/--pace/--bac` - PACE-ECDH-GM support with MRZ or CAN passwords, AES-CMAC-128/192/256 and 3DES-CBC-CBC secure messaging (@iceman1001) - Changed `hf emrtd info` - now shows EF_DG2 portraits for JPREG2000 via new dependecy lib (@iceman1001) - Changed `hf emrtd info`- now shows portrait, signature and other biometrics at the same time (@iceman1001) - Fixed `pm3_grabbed_output_get` - heap overflow (@jonyen) diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index 585edfd8a..75d0058db 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -358,6 +358,8 @@ set (TARGET_SOURCES ${PM3_ROOT}/client/src/cipurse/cipursecrypto.c ${PM3_ROOT}/client/src/cipurse/cipursecore.c ${PM3_ROOT}/client/src/cipurse/cipursetest.c + ${PM3_ROOT}/client/src/emrtd/emrtd_pace.c + ${PM3_ROOT}/client/src/emrtd/emrtd_pacetest.c ${PM3_ROOT}/client/src/loclass/cipher.c ${PM3_ROOT}/client/src/loclass/cipher_bs.c ${PM3_ROOT}/client/src/loclass/cipher_bs_avx2.c diff --git a/client/Makefile b/client/Makefile index 31b3d5b4c..b7e462785 100644 --- a/client/Makefile +++ b/client/Makefile @@ -860,6 +860,8 @@ SRCS = mifare/aiddesfire.c \ cipurse/cipursecore.c \ cipurse/cipursecrypto.c \ cipurse/cipursetest.c \ + emrtd/emrtd_pace.c \ + emrtd/emrtd_pacetest.c \ fileutils.c \ flash.c \ frame_progress.c \ diff --git a/client/src/cmdhfemrtd.c b/client/src/cmdhfemrtd.c index d097569c1..d42d5f141 100644 --- a/client/src/cmdhfemrtd.c +++ b/client/src/cmdhfemrtd.c @@ -28,6 +28,8 @@ #include "iso7816/apduinfo.h" // GetAPDUCodeDescription #include "iso7816/iso7816core.h" // Iso7816ExchangeEx etc #include "crypto/libpcrypto.h" // Hash calculation (sha1, sha256, sha512), des_encrypt/des_decrypt +#include "emrtd/emrtd_pace.h" // PACE primitives and secure messaging session +#include "emrtd/emrtd_pacetest.h" // emrtd_test #include "des.h" // mbedtls_des_key_set_parity #include "crapto1/crapto1.h" // prng_successor #include "commonutil.h" // num_to_bytes @@ -181,46 +183,6 @@ static emrtd_hashalg_t hashalg_table[] = { {NULL, NULL, 0, 0, {0}} }; -static emrtd_pacealg_t pacealg_table[] = { -// name keygen descriptor - {"DH, Generic Mapping, 3DES-CBC-CBC", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x01}}, - {"DH, Generic Mapping, AES-CMAC-128", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x02}}, - {"DH, Generic Mapping, AES-CMAC-192", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x03}}, - {"DH, Generic Mapping, AES-CMAC-256", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x04}}, - {"ECDH, Generic Mapping, 3DES-CBC-CBC", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x01}}, - {"ECDH, Generic Mapping, AES-CMAC-128", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x02}}, - {"ECDH, Generic Mapping, AES-CMAC-192", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x03}}, - {"ECDH, Generic Mapping, AES-CMAC-256", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x04}}, - {"DH, Integrated Mapping, 3DES-CBC-CBC", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x01}}, - {"DH, Integrated Mapping, AES-CMAC-128", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x02}}, - {"DH, Integrated Mapping, AES-CMAC-192", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x03}}, - {"DH, Integrated Mapping, AES-CMAC-256", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x04}}, - {"ECDH, Integrated Mapping, 3DES-CBC-CBC", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x01}}, - {"ECDH, Integrated Mapping, AES-CMAC-128", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x02}}, - {"ECDH, Integrated Mapping, AES-CMAC-192", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x03}}, - {"ECDH, Integrated Mapping, AES-CMAC-256", NULL, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x04}}, - {NULL, NULL, {0}} -}; - -static emrtd_pacesdp_t pacesdp_table[] = { -// id name size - {0, "1024-bit MODP Group with 160-bit Prime Order Subgroup", 1024}, - {1, "2048-bit MODP Group with 224-bit Prime Order Subgroup", 2048}, - {2, "2048-bit MODP Group with 256-bit Prime Order Subgroup", 2048}, - {8, "NIST P-192 (secp192r1)", 192}, - {10, "NIST P-224 (secp224r1)", 224}, - {12, "NIST P-256 (secp256r1)", 256}, - {15, "NIST P-384 (secp384r1)", 384}, - {18, "NIST P-521 (secp521r1)", 521}, - {9, "BrainpoolP192r1", 192}, - {11, "BrainpoolP224r1", 224}, - {13, "BrainpoolP256r1", 256}, - {14, "BrainpoolP320r1", 320}, - {16, "BrainpoolP384r1", 384}, - {17, "BrainpoolP521r1", 521}, - {32, NULL, 0} -}; - static emrtd_dg_t *emrtd_tag_to_dg(uint8_t tag) { for (int dgi = 0; dg_table[dgi].filename != NULL; dgi++) { if (dg_table[dgi].tag == tag) { @@ -261,26 +223,6 @@ static int emrtd_exchange_commands_noout(sAPDU_t apdu, bool activate_field, bool return emrtd_exchange_commands(apdu, false, 0, response, 0, &resplen, activate_field, keep_field_on); } -static char emrtd_calculate_check_digit(char *data) { - const int mrz_weight[] = {7, 3, 1}; - int value, cd = 0; - - for (int i = 0; i < strlen(data); i++) { - char d = data[i]; - if ('A' <= d && d <= 'Z') { - value = d - 55; - } else if ('a' <= d && d <= 'z') { - value = d - 87; - } else if (d == '<') { - value = 0; - } else { // Numbers - value = d - 48; - } - cd += value * mrz_weight[i % 3]; - } - return cd % 10; -} - static int emrtd_get_asn1_data_length(uint8_t *datain, int datainlen, int offset) { PrintAndLogEx(DEBUG, "asn1 datalength, datain: %s", sprint_hex_inrow(datain, datainlen)); int lenfield = (int) * (datain + offset); @@ -327,86 +269,6 @@ static int emrtd_get_asn1_field_length(uint8_t *datain, int datainlen, int offse return 0; } -static void des3_encrypt_cbc(uint8_t *iv, uint8_t *key, uint8_t *input, int inputlen, uint8_t *output) { - mbedtls_des3_context ctx; - mbedtls_des3_set2key_enc(&ctx, key); - - mbedtls_des3_crypt_cbc(&ctx // des3_context - , MBEDTLS_DES_ENCRYPT // int mode - , inputlen // length - , iv // iv[8] - , input // input - , output // output - ); - mbedtls_des3_free(&ctx); -} - -static void des3_decrypt_cbc(uint8_t *iv, uint8_t *key, uint8_t *input, int inputlen, uint8_t *output) { - mbedtls_des3_context ctx; - mbedtls_des3_set2key_dec(&ctx, key); - - mbedtls_des3_crypt_cbc(&ctx // des3_context - , MBEDTLS_DES_DECRYPT // int mode - , inputlen // length - , iv // iv[8] - , input // input - , output // output - ); - mbedtls_des3_free(&ctx); -} - -static int pad_block(uint8_t *input, int inputlen, uint8_t *output) { - const uint8_t padding[8] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; - - memcpy(output, input, inputlen); - - int to_pad = (8 - (inputlen % 8)); - - for (int i = 0; i < to_pad; i++) { - output[inputlen + i] = padding[i]; - } - - return inputlen + to_pad; -} - -static void retail_mac(uint8_t *key, uint8_t *input, int inputlen, uint8_t *output) { - // This code assumes blocklength (n) = 8, and input len of up to 240 or so chars - // This code takes inspirations from https://github.com/devinvenable/iso9797algorithm3 - uint8_t k0[8]; - uint8_t k1[8]; - uint8_t intermediate[8] = {0x00}; - uint8_t intermediate_des[256]; - uint8_t block[8]; - uint8_t message[256]; - - // Populate keys - memcpy(k0, key, 8); - memcpy(k1, key + 8, 8); - - // Prepare message - int blocksize = pad_block(input, inputlen, message); - - // Do chaining and encryption - for (int i = 0; i < (blocksize / 8); i++) { - memcpy(block, message + (i * 8), 8); - - // XOR - for (int x = 0; x < 8; x++) { - intermediate[x] = intermediate[x] ^ block[x]; - } - - des_encrypt(intermediate_des, intermediate, k0); - memcpy(intermediate, intermediate_des, 8); - } - - - des_decrypt(intermediate_des, intermediate, k1); - memcpy(intermediate, intermediate_des, 8); - - des_encrypt(intermediate_des, intermediate, k0); - memcpy(output, intermediate_des, 8); -} - static void emrtd_deskey(uint8_t *seed, const uint8_t *type, int length, uint8_t *dataout) { PrintAndLogEx(DEBUG, "seed.............. %s", sprint_hex_inrow(seed, 16)); @@ -457,193 +319,205 @@ static int _emrtd_read_binary(int offset, int bytes_to_read, uint8_t *dataout, s return emrtd_exchange_commands((sAPDU_t) {0, ISO7816_READ_BINARY, offset >> 8, offset & 0xFF, 0, NULL}, true, bytes_to_read, dataout, maxdataoutlen, dataoutlen, false, true); } -static void emrtd_bump_ssc(uint8_t *ssc) { - PrintAndLogEx(DEBUG, "ssc-b: %s", sprint_hex_inrow(ssc, 8)); - for (int i = 7; i > 0; i--) { - if ((*(ssc + i)) == 0xFF) { - // Set anything already FF to 0, we'll do + 1 on num to left anyways - (*(ssc + i)) = 0; - } else { - (*(ssc + i)) += 1; - PrintAndLogEx(DEBUG, "ssc-a: %s", sprint_hex_inrow(ssc, 8)); - return; +// Walks the secure messaging response DOs. Returns the offset of DO'8E' and, +// when present, the offset and length of the encrypted data object DO'87'. +static bool emrtd_sm_split_rapdu(const uint8_t *rapdu, size_t rapdulen, size_t *off8e, + const uint8_t **do87, size_t *do87len) { + const uint8_t *cur = rapdu; + const uint8_t *end = rapdu + rapdulen; + uint32_t tag = 0; + const uint8_t *val = NULL; + size_t vlen = 0; + + *do87 = NULL; + *do87len = 0; + + while (cur < end) { + const uint8_t *tlvstart = cur; + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + PrintAndLogEx(DEBUG, "SM: malformed response DO at offset %zu", (size_t)(tlvstart - rapdu)); + return false; + } + + if (tag == 0x8E) { + if (vlen != 8) { + PrintAndLogEx(DEBUG, "SM: DO'8E' has unexpected length %zu", vlen); + return false; + } + *off8e = (size_t)(tlvstart - rapdu); + return true; + } + + if (tag == 0x87) { + *do87 = val; + *do87len = vlen; } } + + PrintAndLogEx(DEBUG, "SM: response has no DO'8E'"); + return false; } -static bool emrtd_check_cc(uint8_t *ssc, uint8_t *key, uint8_t *rapdu, int rapdulength) { +// ICAO 9303-11 9.8.6: MAC over SSC || every response DO that precedes DO'8E' +static bool emrtd_check_cc(emrtd_session_t *ssn, uint8_t *rapdu, size_t rapdulength) { // https://elixi.re/i/clarkson.png - uint8_t k[500] = { 0x00 }; - uint8_t cc[500] = { 0x00 }; + uint8_t k[EMRTD_SM_MAX_BLOCK_LEN + 512] = { 0x00 }; + uint8_t cc[8] = { 0x00 }; + size_t off8e = 0; + const uint8_t *do87 = NULL; + size_t do87len = 0; - emrtd_bump_ssc(ssc); + emrtd_sm_bump_ssc(ssn); - memcpy(k, ssc, 8); - int length = 0; - int length2 = 0; - - if (*(rapdu) == 0x87) { - length += 2 + (*(rapdu + 1)); - memcpy(k + 8, rapdu, length); - PrintAndLogEx(DEBUG, "len1: %i", length); - } - - if ((*(rapdu + length)) == 0x99) { - length2 += 2 + (*(rapdu + (length + 1))); - memcpy(k + length + 8, rapdu + length, length2); - PrintAndLogEx(DEBUG, "len2: %i", length2); - } - - int klength = length + length2 + 8; - - retail_mac(key, k, klength, cc); - PrintAndLogEx(DEBUG, "cc: %s", sprint_hex_inrow(cc, 8)); - PrintAndLogEx(DEBUG, "rapdu: %s", sprint_hex_inrow(rapdu, rapdulength)); - PrintAndLogEx(DEBUG, "rapdu cut: %s", sprint_hex_inrow(rapdu + (rapdulength - 8), 8)); - PrintAndLogEx(DEBUG, "k: %s", sprint_hex_inrow(k, klength)); - - return memcmp(cc, rapdu + (rapdulength - 8), 8) == 0; -} - -static bool emrtd_secure_select_file_by_ef(uint8_t *kenc, uint8_t *kmac, uint8_t *ssc, uint16_t file) { - uint8_t response[PM3_CMD_DATA_SIZE] = { 0x00 }; - size_t resplen = 0; - - // convert fileid to bytes - uint8_t file_id[2] = { 0x00 }; - _emrtd_convert_fileid(file, file_id); - - uint8_t iv[8] = { 0x00 }; - uint8_t cmd[8] = { 0x00 }; - uint8_t data[21] = { 0x00 }; - uint8_t temp[8] = {0x0c, 0xa4, EMRTD_P1_SELECT_BY_EF, 0x0c}; - - int cmdlen = pad_block(temp, 4, cmd); - int datalen = pad_block(file_id, 2, data); - PrintAndLogEx(DEBUG, "cmd: %s", sprint_hex_inrow(cmd, cmdlen)); - PrintAndLogEx(DEBUG, "data: %s", sprint_hex_inrow(data, datalen)); - - des3_encrypt_cbc(iv, kenc, data, datalen, temp); - PrintAndLogEx(DEBUG, "temp: %s", sprint_hex_inrow(temp, datalen)); - uint8_t do87[11] = {0x87, 0x09, 0x01}; - memcpy(do87 + 3, temp, datalen); - PrintAndLogEx(DEBUG, "do87: %s", sprint_hex_inrow(do87, datalen + 3)); - - uint8_t m[19]; - memcpy(m, cmd, cmdlen); - memcpy(m + cmdlen, do87, (datalen + 3)); - PrintAndLogEx(DEBUG, "m: %s", sprint_hex_inrow(m, datalen + cmdlen + 3)); - - emrtd_bump_ssc(ssc); - - uint8_t n[27]; - memcpy(n, ssc, 8); - memcpy(n + 8, m, (cmdlen + datalen + 3)); - PrintAndLogEx(DEBUG, "n: %s", sprint_hex_inrow(n, (cmdlen + datalen + 11))); - - uint8_t cc[8]; - retail_mac(kmac, n, (cmdlen + datalen + 11), cc); - PrintAndLogEx(DEBUG, "cc: %s", sprint_hex_inrow(cc, 8)); - - uint8_t do8e[10] = {0x8E, 0x08}; - memcpy(do8e + 2, cc, 8); - PrintAndLogEx(DEBUG, "do8e: %s", sprint_hex_inrow(do8e, 10)); - - int lc = datalen + 3 + 10; - PrintAndLogEx(DEBUG, "lc: %i", lc); - - memcpy(data, do87, datalen + 3); - memcpy(data + (datalen + 3), do8e, 10); - PrintAndLogEx(DEBUG, "data: %s", sprint_hex_inrow(data, lc)); - - if (emrtd_exchange_commands((sAPDU_t) {0x0C, ISO7816_SELECT_FILE, EMRTD_P1_SELECT_BY_EF, 0x0C, lc, data}, true, 0, response, sizeof(response), &resplen, false, true) == false) { + if (emrtd_sm_split_rapdu(rapdu, rapdulength, &off8e, &do87, &do87len) == false) { return false; } - return emrtd_check_cc(ssc, kmac, response, resplen); + if ((ssn->ssclen + off8e) > sizeof(k)) { + PrintAndLogEx(ERR, "error (emrtd_check_cc) response out-of-bounds"); + return false; + } + + memcpy(k, ssn->ssc, ssn->ssclen); + memcpy(k + ssn->ssclen, rapdu, off8e); + size_t klength = ssn->ssclen + off8e; + + if (emrtd_sm_mac(ssn, k, klength, cc) != PM3_SUCCESS) { + return false; + } + + PrintAndLogEx(DEBUG, "cc: %s", sprint_hex_inrow(cc, 8)); + PrintAndLogEx(DEBUG, "rapdu: %s", sprint_hex_inrow(rapdu, rapdulength)); + PrintAndLogEx(DEBUG, "rapdu cc: %s", sprint_hex_inrow(rapdu + off8e + 2, 8)); + PrintAndLogEx(DEBUG, "k: %s", sprint_hex_inrow(k, klength)); + + return memcmp(cc, rapdu + off8e + 2, 8) == 0; } -static bool _emrtd_secure_read_binary(uint8_t *kmac, uint8_t *ssc, int offset, int bytes_to_read, uint8_t *dataout, size_t maxdataoutlen, size_t *dataoutlen) { - uint8_t cmd[8] = { 0x00 }; - uint8_t data[21] = { 0x00 }; - uint8_t temp[8] = {0x0c, 0xb0}; +// Builds the trailing DO'8E' of a protected command over +// SSC || padded command header || the command DOs +static bool emrtd_sm_finish_command(emrtd_session_t *ssn, const uint8_t *header, const uint8_t *dos, + size_t doslen, uint8_t *out, size_t outlen, size_t *lc) { + uint8_t n[EMRTD_SM_MAX_BLOCK_LEN * 2 + 64] = { 0x00 }; + size_t blocksize = emrtd_sm_blocksize(ssn); + size_t nlen = 0; - PrintAndLogEx(DEBUG, "kmac: %s", sprint_hex_inrow(kmac, EMRTD_KMAC_LEN)); + if ((ssn->ssclen + blocksize + doslen) > sizeof(n)) { + PrintAndLogEx(ERR, "error (emrtd_sm_finish_command) command out-of-bounds"); + return false; + } - // Set p1 and p2 - temp[2] = (uint8_t)(offset >> 8); - temp[3] = (uint8_t)(offset >> 0); - - int cmdlen = pad_block(temp, 4, cmd); - PrintAndLogEx(DEBUG, "cmd: %s", sprint_hex_inrow(cmd, cmdlen)); - - uint8_t do97[3] = {0x97, 0x01, bytes_to_read}; - - uint8_t m[11] = { 0x00 }; - memcpy(m, cmd, 8); - memcpy(m + 8, do97, 3); - - emrtd_bump_ssc(ssc); - - uint8_t n[19] = { 0x00 }; - memcpy(n, ssc, 8); - memcpy(n + 8, m, 11); - PrintAndLogEx(DEBUG, "n: %s", sprint_hex_inrow(n, sizeof(n))); + memcpy(n, ssn->ssc, ssn->ssclen); + nlen += ssn->ssclen; + nlen += emrtd_pad_block(header, 4, blocksize, n + nlen); + memcpy(n + nlen, dos, doslen); + nlen += doslen; + PrintAndLogEx(DEBUG, "n: %s", sprint_hex_inrow(n, nlen)); uint8_t cc[8] = { 0x00 }; - retail_mac(kmac, n, 19, cc); - PrintAndLogEx(DEBUG, "cc: %s", sprint_hex_inrow(cc, sizeof(cc))); + if (emrtd_sm_mac(ssn, n, nlen, cc) != PM3_SUCCESS) { + return false; + } + PrintAndLogEx(DEBUG, "cc: %s", sprint_hex_inrow(cc, 8)); - uint8_t do8e[10] = {0x8E, 0x08}; - memcpy(do8e + 2, cc, 8); - PrintAndLogEx(DEBUG, "do8e: %s", sprint_hex_inrow(do8e, sizeof(do8e))); + if ((doslen + 10) > outlen) { + PrintAndLogEx(ERR, "error (emrtd_sm_finish_command) data out-of-bounds"); + return false; + } - int lc = 13; - PrintAndLogEx(DEBUG, "lc: %i", lc); + memcpy(out, dos, doslen); + out[doslen] = 0x8E; + out[doslen + 1] = 0x08; + memcpy(out + doslen + 2, cc, 8); + *lc = doslen + 10; + PrintAndLogEx(DEBUG, "data: %s", sprint_hex_inrow(out, *lc)); + return true; +} - memcpy(data, do97, 3); - memcpy(data + 3, do8e, 10); - PrintAndLogEx(DEBUG, "data: %s", sprint_hex_inrow(data, lc)); +static bool emrtd_secure_select(emrtd_session_t *ssn, uint8_t p1, const uint8_t *sel, size_t sellen); + +static bool emrtd_secure_select_file_by_ef(emrtd_session_t *ssn, uint16_t file) { + uint8_t file_id[2] = { 0x00 }; + _emrtd_convert_fileid(file, file_id); + return emrtd_secure_select(ssn, EMRTD_P1_SELECT_BY_EF, file_id, sizeof(file_id)); +} + +static bool _emrtd_secure_read_binary(emrtd_session_t *ssn, int offset, int bytes_to_read, uint8_t *dataout, size_t maxdataoutlen, size_t *dataoutlen) { + const uint8_t header[4] = {0x0C, ISO7816_READ_BINARY, (uint8_t)(offset >> 8), (uint8_t)(offset & 0xFF)}; + uint8_t do97[3] = {0x97, 0x01, (uint8_t)bytes_to_read}; + + emrtd_sm_bump_ssc(ssn); + + uint8_t data[16] = { 0x00 }; + size_t lc = 0; + if (emrtd_sm_finish_command(ssn, header, do97, sizeof(do97), data, sizeof(data), &lc) == false) { + return false; + } if (emrtd_exchange_commands((sAPDU_t) {0x0C, ISO7816_READ_BINARY, offset >> 8, offset & 0xFF, lc, data}, true, 0, dataout, maxdataoutlen, dataoutlen, false, true) == false) { return false; } - return emrtd_check_cc(ssc, kmac, dataout, *dataoutlen); + return emrtd_check_cc(ssn, dataout, *dataoutlen); } -static bool _emrtd_secure_read_binary_decrypt(uint8_t *kenc, uint8_t *kmac, uint8_t *ssc, int offset, int bytes_to_read, uint8_t *dataout, size_t *dataoutlen) { +static bool _emrtd_secure_read_binary_decrypt(emrtd_session_t *ssn, int offset, int bytes_to_read, uint8_t *dataout, size_t *dataoutlen) { uint8_t response[500] = { 0x00 }; uint8_t temp[500] = { 0x00 }; - size_t resplen, cutat = 0; - uint8_t iv[8] = { 0x00 }; + size_t resplen = 0; + size_t off8e = 0; + const uint8_t *do87 = NULL; + size_t do87len = 0; - if (_emrtd_secure_read_binary(kmac, ssc, offset, bytes_to_read, response, sizeof(response), &resplen) == false) { + if (_emrtd_secure_read_binary(ssn, offset, bytes_to_read, response, sizeof(response), &resplen) == false) { return false; } PrintAndLogEx(DEBUG, "secreadbindec, offset %i on read %i: encrypted: %s", offset, bytes_to_read, sprint_hex_inrow(response, resplen)); - cutat = ((int) response[1]) - 1; + if (emrtd_sm_split_rapdu(response, resplen, &off8e, &do87, &do87len) == false) { + return false; + } + + // DO'87' content is 01 || cryptogram + if ((do87 == NULL) || (do87len < 2) || (do87[0] != 0x01)) { + PrintAndLogEx(ERR, "error (emrtd_secure_read_binary_decrypt) no encrypted data in response"); + return false; + } + + size_t cryptolen = do87len - 1; + if ((cryptolen > sizeof(temp)) || ((cryptolen % emrtd_sm_blocksize(ssn)) != 0)) { + PrintAndLogEx(ERR, "error (emrtd_secure_read_binary_decrypt) cryptogram out-of-bounds, %zu bytes", cryptolen); + return false; + } + + if ((size_t)bytes_to_read > cryptolen) { + PrintAndLogEx(ERR, "error (emrtd_secure_read_binary_decrypt) short read, wanted %i got %zu", bytes_to_read, cryptolen); + return false; + } + + if (emrtd_sm_decrypt(ssn, do87 + 1, cryptolen, temp) != PM3_SUCCESS) { + return false; + } - des3_decrypt_cbc(iv, kenc, response + 3, cutat, temp); memcpy(dataout, temp, bytes_to_read); - PrintAndLogEx(DEBUG, "secreadbindec, offset %i on read %i: decrypted: %s", offset, bytes_to_read, sprint_hex_inrow(temp, cutat)); + PrintAndLogEx(DEBUG, "secreadbindec, offset %i on read %i: decrypted: %s", offset, bytes_to_read, sprint_hex_inrow(temp, cryptolen)); PrintAndLogEx(DEBUG, "secreadbindec, offset %i on read %i: decrypted and cut: %s", offset, bytes_to_read, sprint_hex_inrow(dataout, bytes_to_read)); *dataoutlen = bytes_to_read; return true; } -static int emrtd_read_file(uint8_t *dataout, size_t *dataoutlen, uint8_t *kenc, uint8_t *kmac, uint8_t *ssc, bool use_secure) { +static int emrtd_read_file(uint8_t *dataout, size_t *dataoutlen, emrtd_session_t *ssn) { uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; size_t resplen = 0; uint8_t tempresponse[500] = { 0x00 }; size_t tempresplen = 0; int toread = 4; int offset = 0; + bool use_secure = (ssn->type != EMRTD_SM_NONE); if (use_secure) { - if (_emrtd_secure_read_binary_decrypt(kenc, kmac, ssc, offset, toread, response, &resplen) == false) { + if (_emrtd_secure_read_binary_decrypt(ssn, offset, toread, response, &resplen) == false) { return false; } } else { @@ -665,7 +539,7 @@ static int emrtd_read_file(uint8_t *dataout, size_t *dataoutlen, uint8_t *kenc, } if (use_secure) { - if (_emrtd_secure_read_binary_decrypt(kenc, kmac, ssc, offset, toread, tempresponse, &tempresplen) == false) { + if (_emrtd_secure_read_binary_decrypt(ssn, offset, toread, tempresponse, &tempresplen) == false) { PrintAndLogEx(NORMAL, ""); return false; } @@ -745,9 +619,9 @@ static bool emrtd_lds_get_data_by_tag(uint8_t *datain, size_t datainlen, uint8_t return false; } -static bool emrtd_select_and_read(uint8_t *dataout, size_t *dataoutlen, uint16_t file, uint8_t *ks_enc, uint8_t *ks_mac, uint8_t *ssc, bool use_secure) { - if (use_secure) { - if (emrtd_secure_select_file_by_ef(ks_enc, ks_mac, ssc, file) == false) { +static bool emrtd_select_and_read(uint8_t *dataout, size_t *dataoutlen, uint16_t file, emrtd_session_t *ssn) { + if (ssn->type != EMRTD_SM_NONE) { + if (emrtd_secure_select_file_by_ef(ssn, file) == false) { PrintAndLogEx(ERR, "Failed to secure select %04X", file); return false; } @@ -758,7 +632,7 @@ static bool emrtd_select_and_read(uint8_t *dataout, size_t *dataoutlen, uint16_t } } - if (emrtd_read_file(dataout, dataoutlen, ks_enc, ks_mac, ssc, use_secure) == false) { + if (emrtd_read_file(dataout, dataoutlen, ssn) == false) { PrintAndLogEx(ERR, "Failed to read %04X", file); return false; } @@ -899,14 +773,7 @@ static int emrtd_dump_ef_sod(uint8_t *file_contents, size_t file_length, const c return PM3_ESOFT; } -static bool emrtd_dump_file(uint8_t *ks_enc, uint8_t *ks_mac, uint8_t *ssc, uint16_t file, const char *name, bool use_secure, const char *path) { - uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; - size_t resplen = 0; - - if (emrtd_select_and_read(response, &resplen, file, ks_enc, ks_mac, ssc, use_secure) == false) { - return false; - } - +static bool emrtd_save_file(uint8_t *response, size_t resplen, uint16_t file, const char *name, const char *path) { char *filepath = calloc(strlen(path) + 100, sizeof(char)); if (filepath == NULL) { PrintAndLogEx(WARNING, "Failed to allocate memory"); @@ -933,15 +800,28 @@ static bool emrtd_dump_file(uint8_t *ks_enc, uint8_t *ks_mac, uint8_t *ssc, uint return true; } -static void rng(int length, uint8_t *dataout) { - // Do very very secure prng operations - //for (int i = 0; i < (length / 4); i++) { - // num_to_bytes(prng_successor(msclock() + i, 32), 4, &dataout[i * 4]); - //} - memset(dataout, 0x00, length); +static bool emrtd_dump_file(emrtd_session_t *ssn, uint16_t file, const char *name, const char *path) { + uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; + size_t resplen = 0; + + if (emrtd_select_and_read(response, &resplen, file, ssn) == false) { + return false; + } + + return emrtd_save_file(response, resplen, file, name, path); } -static bool emrtd_do_bac(char *documentnumber, char *dob, char *expiry, uint8_t *ssc, uint8_t *ks_enc, uint8_t *ks_mac) { +static void rng(int length, uint8_t *dataout) { + // Zero nonces are fatal for PACE and were never a good idea for BAC either, + // so this is a real CSPRNG (mbedtls CTR_DRBG seeded from mbedtls entropy). + if (pcrypto_rng_fill_oneshot(dataout, length, "emrtd") != PM3_SUCCESS) { + // Never hand back a predictable nonce, the caller has to fail instead + memset(dataout, 0x00, length); + PrintAndLogEx(ERR, "Failed to generate random data"); + } +} + +static bool emrtd_do_bac(const char *documentnumber, const char *dob, const char *expiry, emrtd_session_t *ssn) { uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; size_t resplen = 0; @@ -951,7 +831,8 @@ static bool emrtd_do_bac(char *documentnumber, char *dob, char *expiry, uint8_t uint8_t k_icc[16] = { 0x00 }; uint8_t S[32] = { 0x00 }; - uint8_t rnd_ifd[8], k_ifd[16]; + uint8_t rnd_ifd[8] = { 0x00 }; + uint8_t k_ifd[16] = { 0x00 }; rng(8, rnd_ifd); rng(16, k_ifd); @@ -959,12 +840,11 @@ static bool emrtd_do_bac(char *documentnumber, char *dob, char *expiry, uint8_t PrintAndLogEx(DEBUG, "dob............... " _GREEN_("%s"), dob); PrintAndLogEx(DEBUG, "exp............... " _GREEN_("%s"), expiry); - char documentnumbercd = emrtd_calculate_check_digit(documentnumber); - char dobcd = emrtd_calculate_check_digit(dob); - char expirycd = emrtd_calculate_check_digit(expiry); - char kmrz[25] = { 0x00 }; - snprintf(kmrz, sizeof(kmrz), "%s%i%s%i%s%i", documentnumber, documentnumbercd, dob, dobcd, expiry, expirycd); + if (emrtd_pace_kmrz(documentnumber, dob, expiry, kmrz, sizeof(kmrz)) != PM3_SUCCESS) { + PrintAndLogEx(ERR, "Couldn't build the MRZ information string."); + return false; + } PrintAndLogEx(DEBUG, "kmrz.............. " _GREEN_("%s"), kmrz); uint8_t kseed[20] = { 0x00 }; @@ -992,12 +872,12 @@ static bool emrtd_do_bac(char *documentnumber, char *dob, char *expiry, uint8_t uint8_t iv[8] = { 0x00 }; uint8_t e_ifd[32] = { 0x00 }; - des3_encrypt_cbc(iv, kenc, S, sizeof(S), e_ifd); + emrtd_des3_encrypt_cbc(iv, kenc, S, sizeof(S), e_ifd); PrintAndLogEx(DEBUG, "e_ifd............. %s", sprint_hex_inrow(e_ifd, 32)); uint8_t m_ifd[8] = { 0x00 }; - retail_mac(kmac, e_ifd, 32, m_ifd); + emrtd_retail_mac(kmac, e_ifd, 32, m_ifd); PrintAndLogEx(DEBUG, "m_ifd............. %s", sprint_hex_inrow(m_ifd, 8)); uint8_t cmd_data[40]; @@ -1012,7 +892,7 @@ static bool emrtd_do_bac(char *documentnumber, char *dob, char *expiry, uint8_t PrintAndLogEx(INFO, "External authentication with BAC successful"); uint8_t dec_output[32] = { 0x00 }; - des3_decrypt_cbc(iv, kenc, response, 32, dec_output); + emrtd_des3_decrypt_cbc(iv, kenc, response, 32, dec_output); PrintAndLogEx(DEBUG, "dec_output........ %s", sprint_hex_inrow(dec_output, 32)); if (memcmp(rnd_ifd, dec_output + 8, 8) != 0) { @@ -1029,16 +909,22 @@ static bool emrtd_do_bac(char *documentnumber, char *dob, char *expiry, uint8_t PrintAndLogEx(DEBUG, "kseed............ %s", sprint_hex_inrow(kseed, 16)); + uint8_t ks_enc[EMRTD_KMAC_LEN] = { 0x00 }; + uint8_t ks_mac[EMRTD_KMAC_LEN] = { 0x00 }; emrtd_deskey(kseed, KENC_type, 16, ks_enc); emrtd_deskey(kseed, KMAC_type, 16, ks_mac); PrintAndLogEx(DEBUG, "ks_enc........ %s", sprint_hex_inrow(ks_enc, 16)); PrintAndLogEx(DEBUG, "ks_mac........ %s", sprint_hex_inrow(ks_mac, 16)); - memcpy(ssc, rnd_ic + 4, 4); - memcpy(ssc + 4, rnd_ifd + 4, 4); + if (emrtd_sm_setup(ssn, EMRTD_PACE_CIPHER_3DES, ks_enc, ks_mac) != PM3_SUCCESS) { + return false; + } - PrintAndLogEx(DEBUG, "ssc........... %s", sprint_hex_inrow(ssc, 8)); + memcpy(ssn->ssc, rnd_ic + 4, 4); + memcpy(ssn->ssc + 4, rnd_ifd + 4, 4); + + PrintAndLogEx(DEBUG, "ssc........... %s", sprint_hex_inrow(ssn->ssc, ssn->ssclen)); return true; } @@ -1048,10 +934,627 @@ static bool emrtd_connect(void) { return res == PM3_SUCCESS; } -static bool emrtd_do_auth(char *documentnumber, char *dob, char *expiry, bool BAC_available, bool *BAC, uint8_t *ssc, uint8_t *ks_enc, uint8_t *ks_mac) { +//----------------------------------------------------------------------------- +// PACE, ICAO 9303-11 4.4 and TR-03110 part 3, 3.2 +//----------------------------------------------------------------------------- + +#define EMRTD_INS_MSE 0x22 +#define EMRTD_INS_GENERAL_AUTHENTICATE 0x86 + +#define EMRTD_PACE_PWD_MRZ 0x01 +#define EMRTD_PACE_PWD_CAN 0x02 + +// Like emrtd_exchange_commands(), but hands the status word back so that the +// caller can report the 63CX retry counter of a wrong PACE password. +static bool emrtd_exchange_commands_sw(sAPDU_t apdu, bool include_le, uint16_t le, uint8_t *dataout, + size_t maxdataoutlen, size_t *dataoutlen, uint16_t *sw) { + uint16_t lsw = 0; + int res = Iso7816ExchangeEx(CC_CONTACTLESS, false, true, apdu, include_le, le, dataout, maxdataoutlen, dataoutlen, &lsw); + + *sw = lsw; + + if ((res != PM3_SUCCESS) && (lsw == 0)) { + return false; + } + + if (lsw != ISO7816_OK) { + PrintAndLogEx(DEBUG, "Command failed (%04x - %s).", lsw, GetAPDUCodeDescription(lsw >> 8, lsw & 0xff)); + return false; + } + return true; +} + +static bool emrtd_secure_select(emrtd_session_t *ssn, uint8_t p1, const uint8_t *sel, size_t sellen) { + uint8_t response[PM3_CMD_DATA_SIZE] = { 0x00 }; + size_t resplen = 0; + + size_t blocksize = emrtd_sm_blocksize(ssn); + const uint8_t header[4] = {0x0C, ISO7816_SELECT_FILE, p1, 0x0C}; + + uint8_t plain[EMRTD_SM_MAX_BLOCK_LEN * 2] = { 0x00 }; + if ((sellen + 1) > sizeof(plain)) { + return false; + } + size_t plainlen = emrtd_pad_block(sel, sellen, blocksize, plain); + + // the AES IV depends on the SSC, so it has to be bumped before encrypting + emrtd_sm_bump_ssc(ssn); + + uint8_t cryptogram[sizeof(plain)] = { 0x00 }; + if (emrtd_sm_encrypt(ssn, plain, plainlen, cryptogram) != PM3_SUCCESS) { + return false; + } + + uint8_t do87[sizeof(plain) + 3] = {0x87, 0x00, 0x01}; + do87[1] = (uint8_t)(plainlen + 1); + memcpy(do87 + 3, cryptogram, plainlen); + PrintAndLogEx(DEBUG, "do87: %s", sprint_hex_inrow(do87, plainlen + 3)); + + uint8_t data[sizeof(do87) + 16] = { 0x00 }; + size_t lc = 0; + if (emrtd_sm_finish_command(ssn, header, do87, plainlen + 3, data, sizeof(data), &lc) == false) { + return false; + } + + uint16_t sw = 0; + if (emrtd_exchange_commands_sw((sAPDU_t) {0x0C, ISO7816_SELECT_FILE, p1, 0x0C, lc, data}, true, 0, response, sizeof(response), &resplen, &sw) == false) { + if (sw != 0) { + PrintAndLogEx(ERR, "Secure select rejected by the document (%04X - %s)", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xFF)); + } else { + PrintAndLogEx(ERR, "Secure select got no response"); + } + return false; + } + + if (emrtd_check_cc(ssn, response, resplen) == false) { + PrintAndLogEx(ERR, "Secure select response failed the MAC check"); + PrintAndLogEx(ERR, "response.......... %s", sprint_hex_inrow(response, resplen)); + return false; + } + return true; +} + +// MSE:Set AT, ICAO 9303-11 4.4.4.1 +static bool emrtd_mse_set_at(const emrtd_paceinfo_t *info, uint8_t password_ref) { + uint8_t data[32] = { 0x00 }; + size_t o = 0; + + data[o++] = 0x80; + data[o++] = (uint8_t)info->oidlen; + memcpy(data + o, info->oid, info->oidlen); + o += info->oidlen; + + data[o++] = 0x83; + data[o++] = 0x01; + data[o++] = password_ref; + + if (info->has_param) { + data[o++] = 0x84; + data[o++] = 0x01; + data[o++] = info->param_id; + } + + PrintAndLogEx(DEBUG, "MSE:Set AT........ %s", sprint_hex_inrow(data, o)); + + uint8_t response[16] = { 0x00 }; + size_t resplen = 0; + uint16_t sw = 0; + + if (emrtd_exchange_commands_sw((sAPDU_t) {0x00, EMRTD_INS_MSE, 0xC1, 0xA4, o, data}, false, 0, response, sizeof(response), &resplen, &sw)) { + return true; + } + + if ((sw & 0xFFF0) == 0x63C0) { + PrintAndLogEx(ERR, "PACE: wrong password, " _RED_("%i") " attempt(s) left before the password is blocked", sw & 0x000F); + } else if (sw == 0x6A80) { + PrintAndLogEx(ERR, "PACE: the document rejected the algorithm we selected (6A80)"); + } else if (sw != 0) { + PrintAndLogEx(ERR, "PACE: MSE:Set AT failed (%04X - %s)", sw, GetAPDUCodeDescription(sw >> 8, sw & 0xFF)); + } else { + PrintAndLogEx(ERR, "PACE: MSE:Set AT got no response"); + } + return false; +} + +// One step of the GENERAL AUTHENTICATE chain. inner_tag 0 sends an empty 7C. +// Pulls one data object out of the dynamic authentication data of a response +static bool emrtd_ga_get(const uint8_t *dyn, size_t dynlen, uint8_t wanted, + uint8_t *out, size_t maxout, size_t *outlen) { + const uint8_t *cur = dyn; + const uint8_t *end = dyn + dynlen; + uint32_t tag = 0; + const uint8_t *val = NULL; + size_t vlen = 0; + + while (emrtd_tlv_next(&cur, end, &tag, &val, &vlen)) { + if (tag != wanted) { + continue; + } + if (vlen > maxout) { + PrintAndLogEx(ERR, "PACE: response object %02X is too large (%zu bytes)", wanted, vlen); + return false; + } + memcpy(out, val, vlen); + *outlen = vlen; + return true; + } + return false; +} + +// Runs one step of the chain and hands back the content of the response's 7C +static bool emrtd_general_authenticate(const char *step, bool more, uint8_t inner_tag, const uint8_t *payload, size_t payloadlen, + uint8_t *out, size_t maxout, size_t *outlen) { + uint8_t inner[EMRTD_EC_POINT_MAXLEN + 8] = { 0x00 }; + size_t innerlen = 0; + + if (inner_tag != 0) { + innerlen = emrtd_tlv_write_header(inner, sizeof(inner), inner_tag, payloadlen); + if ((innerlen == 0) || ((innerlen + payloadlen) > sizeof(inner))) { + PrintAndLogEx(ERR, "PACE: general authenticate payload out-of-bounds"); + return false; + } + memcpy(inner + innerlen, payload, payloadlen); + innerlen += payloadlen; + } + + uint8_t data[sizeof(inner) + 8] = { 0x00 }; + size_t datalen = emrtd_tlv_write_header(data, sizeof(data), 0x7C, innerlen); + if (datalen == 0) { + return false; + } + memcpy(data + datalen, inner, innerlen); + datalen += innerlen; + + if (datalen > 0xFF) { + PrintAndLogEx(ERR, "PACE: general authenticate command too long for a short APDU"); + return false; + } + + PrintAndLogEx(DEBUG, "GA >>............. %s", sprint_hex_inrow(data, datalen)); + + uint8_t response[PM3_CMD_DATA_SIZE] = { 0x00 }; + size_t resplen = 0; + uint16_t sw = 0; + + // CLA 0x10 marks every step of the chain except the last one + uint8_t cla = more ? 0x10 : 0x00; + + if (emrtd_exchange_commands_sw((sAPDU_t) {cla, EMRTD_INS_GENERAL_AUTHENTICATE, 0x00, 0x00, datalen, data}, true, 0, response, sizeof(response), &resplen, &sw) == false) { + if ((sw & 0xFFF0) == 0x63C0) { + PrintAndLogEx(ERR, "PACE: wrong password, " _RED_("%i") " attempt(s) left before the password is blocked", sw & 0x000F); + } else if (sw == 0x6300) { + // no counter given, but at the mutual authentication step this can + // only mean our token did not match, i.e. the password is wrong + PrintAndLogEx(ERR, "PACE: %s failed (6300), the document rejected it", step); + } else if (sw != 0) { + PrintAndLogEx(ERR, "PACE: %s failed (%04X - %s)", step, sw, GetAPDUCodeDescription(sw >> 8, sw & 0xFF)); + } else { + PrintAndLogEx(ERR, "PACE: %s got no response", step); + } + return false; + } + + PrintAndLogEx(DEBUG, "GA <<............. %s", sprint_hex_inrow(response, resplen)); + + const uint8_t *cur = response; + const uint8_t *end = response + resplen; + uint32_t tag = 0; + const uint8_t *val = NULL; + size_t vlen = 0; + + if ((emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) || (tag != 0x7C)) { + PrintAndLogEx(ERR, "PACE: %s returned malformed dynamic authentication data", step); + return false; + } + + if (vlen > maxout) { + PrintAndLogEx(ERR, "PACE: %s response is too large (%zu bytes)", step, vlen); + return false; + } + + memcpy(out, val, vlen); + *outlen = vlen; + return true; +} + +// Runs one step and picks a single expected data object out of the response +static bool emrtd_general_authenticate_one(const char *step, bool more, uint8_t inner_tag, + const uint8_t *payload, size_t payloadlen, + uint8_t expect_tag, uint8_t *out, size_t maxout, size_t *outlen) { + uint8_t dyn[PM3_CMD_DATA_SIZE] = { 0x00 }; + size_t dynlen = 0; + + if (emrtd_general_authenticate(step, more, inner_tag, payload, payloadlen, dyn, sizeof(dyn), &dynlen) == false) { + return false; + } + + if (emrtd_ga_get(dyn, dynlen, expect_tag, out, maxout, outlen) == false) { + PrintAndLogEx(ERR, "PACE: %s response is missing data object %02X", step, expect_tag); + return false; + } + return true; +} + +static int emrtd_do_pace(const emrtd_paceinfo_t *info, const uint8_t *password, size_t passwordlen, + uint8_t password_ref, emrtd_session_t *ssn) { + const emrtd_pacealg_t *alg = info->alg; + mbedtls_ecp_group_id curve = info->sdp->curve; + + uint8_t kpi[EMRTD_SM_MAX_KEY_LEN] = { 0x00 }; + size_t kpilen = 0; + + // Kpi = KDF(K, 3) + if (emrtd_pace_kdf(alg->cipher, password, passwordlen, 3, kpi, &kpilen) != PM3_SUCCESS) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "kpi............... %s", sprint_hex_inrow(kpi, kpilen)); + + if (emrtd_mse_set_at(info, password_ref) == false) { + return PM3_ESOFT; + } + + uint8_t response[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t resplen = 0; + + // Step 1, encrypted nonce + if (emrtd_general_authenticate_one("step 1 (encrypted nonce)", true, 0x00, NULL, 0, 0x80, response, sizeof(response), &resplen) == false) { + return PM3_ESOFT; + } + + uint8_t s[32] = { 0x00 }; + if (emrtd_pace_decrypt_nonce(alg->cipher, kpi, response, resplen, s) != PM3_SUCCESS) { + return PM3_ESOFT; + } + size_t slen = resplen; + PrintAndLogEx(DEBUG, "nonce s........... %s", sprint_hex_inrow(s, slen)); + + // Step 2, map the nonce + uint8_t priv1[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + uint8_t pub1[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t priv1len = 0, pub1len = 0; + + if (emrtd_pace_ec_keygen(curve, NULL, 0, priv1, &priv1len, pub1, &pub1len) != PM3_SUCCESS) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "PK.Map.IFD........ %s", sprint_hex_inrow(pub1, pub1len)); + + if (emrtd_general_authenticate_one("step 2 (map nonce)", true, 0x81, pub1, pub1len, 0x82, response, sizeof(response), &resplen) == false) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "PK.Map.IC......... %s", sprint_hex_inrow(response, resplen)); + + // Chip Authentication Mapping proves this key belongs to the chip's static + // CA key, which can only be checked once EF_DG14 is readable + if (alg->mapping == EMRTD_PACE_MAP_CAM) { + ssn->cam.negotiated = true; + ssn->cam.curve = curve; + memcpy(ssn->cam.pk_map_ic, response, resplen); + ssn->cam.pk_map_iclen = resplen; + // the terminal half of the Chip Authentication ECDH + memcpy(ssn->cam.sk_map_ifd, priv1, priv1len); + ssn->cam.sk_map_ifdlen = priv1len; + } + + uint8_t mapped[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t mappedlen = 0; + if (emrtd_pace_ec_gm(curve, s, slen, priv1, priv1len, response, resplen, mapped, &mappedlen) != PM3_SUCCESS) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "mapped generator.. %s", sprint_hex_inrow(mapped, mappedlen)); + + // Step 3, key agreement over the mapped generator + uint8_t priv2[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + uint8_t pub2[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t priv2len = 0, pub2len = 0; + + if (emrtd_pace_ec_keygen(curve, mapped, mappedlen, priv2, &priv2len, pub2, &pub2len) != PM3_SUCCESS) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "PK.DH.IFD......... %s", sprint_hex_inrow(pub2, pub2len)); + + if (ssn->cam.negotiated) { + memcpy(ssn->cam.sk_dh_ifd, priv2, priv2len); + ssn->cam.sk_dh_ifdlen = priv2len; + } + + uint8_t pk2_ic[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t pk2_iclen = 0; + if (emrtd_general_authenticate_one("step 3 (key agreement)", true, 0x83, pub2, pub2len, 0x84, pk2_ic, sizeof(pk2_ic), &pk2_iclen) == false) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "PK.DH.IC.......... %s", sprint_hex_inrow(pk2_ic, pk2_iclen)); + + if (ssn->cam.negotiated) { + memcpy(ssn->cam.pk_dh_ic, pk2_ic, pk2_iclen); + ssn->cam.pk_dh_iclen = pk2_iclen; + } + + // ICAO 9303-11 4.4.3.3, the two ephemeral keys must differ + if ((pk2_iclen == pub2len) && (memcmp(pk2_ic, pub2, pub2len) == 0)) { + PrintAndLogEx(ERR, "PACE: the document echoed our ephemeral public key back, aborting"); + return PM3_ESOFT; + } + + uint8_t shared[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + size_t sharedlen = 0; + if (emrtd_pace_ec_shared_x(curve, priv2, priv2len, pk2_ic, pk2_iclen, shared, &sharedlen) != PM3_SUCCESS) { + return PM3_ESOFT; + } + + // Step 4, session keys and mutual authentication tokens + uint8_t ks_enc[EMRTD_SM_MAX_KEY_LEN] = { 0x00 }; + uint8_t ks_mac[EMRTD_SM_MAX_KEY_LEN] = { 0x00 }; + size_t kslen = 0; + + if ((emrtd_pace_kdf(alg->cipher, shared, sharedlen, 1, ks_enc, &kslen) != PM3_SUCCESS) || + (emrtd_pace_kdf(alg->cipher, shared, sharedlen, 2, ks_mac, &kslen) != PM3_SUCCESS)) { + return PM3_ESOFT; + } + PrintAndLogEx(DEBUG, "ks_enc............ %s", sprint_hex_inrow(ks_enc, kslen)); + PrintAndLogEx(DEBUG, "ks_mac............ %s", sprint_hex_inrow(ks_mac, kslen)); + + uint8_t t_ifd[8] = { 0x00 }; + if (emrtd_pace_token(alg, ks_mac, pk2_ic, pk2_iclen, t_ifd) != PM3_SUCCESS) { + return PM3_ESOFT; + } + + uint8_t dyn[PM3_CMD_DATA_SIZE] = { 0x00 }; + size_t dynlen = 0; + if (emrtd_general_authenticate("step 4 (mutual authentication)", false, 0x85, t_ifd, sizeof(t_ifd), dyn, sizeof(dyn), &dynlen) == false) { + return PM3_ESOFT; + } + + uint8_t t_ic[8] = { 0x00 }; + size_t t_iclen = 0; + if (emrtd_ga_get(dyn, dynlen, 0x86, t_ic, sizeof(t_ic), &t_iclen) == false) { + PrintAndLogEx(ERR, "PACE: step 4 (mutual authentication) response is missing data object 86"); + return PM3_ESOFT; + } + + if (ssn->cam.negotiated) { + // DO'8A', TR-03110 part 3, 3.4.4 + if (emrtd_ga_get(dyn, dynlen, 0x8A, ssn->cam.enc_data, sizeof(ssn->cam.enc_data), &ssn->cam.enc_datalen) == false) { + PrintAndLogEx(WARNING, "PACE-CAM: the document returned no encrypted chip authentication data"); + ssn->cam.negotiated = false; + } else { + PrintAndLogEx(DEBUG, "CAM data.......... %s", sprint_hex_inrow(ssn->cam.enc_data, ssn->cam.enc_datalen)); + } + } + + uint8_t t_ic_expected[8] = { 0x00 }; + if (emrtd_pace_token(alg, ks_mac, pub2, pub2len, t_ic_expected) != PM3_SUCCESS) { + return PM3_ESOFT; + } + + if ((t_iclen != sizeof(t_ic_expected)) || (memcmp(t_ic, t_ic_expected, sizeof(t_ic_expected)) != 0)) { + PrintAndLogEx(ERR, "PACE: the document's authentication token is wrong, aborting"); + PrintAndLogEx(DEBUG, "T_IC got.......... %s", sprint_hex_inrow(t_ic, t_iclen)); + PrintAndLogEx(DEBUG, "T_IC expected..... %s", sprint_hex_inrow(t_ic_expected, sizeof(t_ic_expected))); + return PM3_ESOFT; + } + + if (emrtd_sm_setup(ssn, alg->cipher, ks_enc, ks_mac) != PM3_SUCCESS) { + return PM3_ESOFT; + } + + // SSC starts at zero after PACE, ICAO 9303-11 9.8.6.3 + ssn->pace = true; + ssn->pace_alg = alg->name; + ssn->pace_curve = info->sdp->name; + + PrintAndLogEx(INFO, "Authentication with PACE successful ( " _GREEN_("%s") ", %s )", alg->name, info->sdp->name); + return PM3_SUCCESS; +} + +// Picks the PACE password out of what the user supplied +static int emrtd_pace_password(const emrtd_auth_t *auth, uint8_t *k, size_t *klen, uint8_t *password_ref) { + if (auth->can_available) { + if (emrtd_pace_password_can(auth->can, k, klen) != PM3_SUCCESS) { + PrintAndLogEx(ERR, "PACE: invalid CAN"); + return PM3_EINVARG; + } + *password_ref = EMRTD_PACE_PWD_CAN; + return PM3_SUCCESS; + } + + if (auth->mrz_available) { + if (emrtd_pace_password_mrz(auth->documentnumber, auth->dob, auth->expiry, k, klen) != PM3_SUCCESS) { + PrintAndLogEx(ERR, "PACE: invalid MRZ data"); + return PM3_EINVARG; + } + *password_ref = EMRTD_PACE_PWD_MRZ; + return PM3_SUCCESS; + } + + PrintAndLogEx(ERR, "PACE needs a password, supply `" _YELLOW_("--can") "` or `" _YELLOW_("-n") "` `" _YELLOW_("-d") "` `" _YELLOW_("-e") "`"); + return PM3_EINVARG; +} + +// Orders every usable SecurityInfo strongest first, returns how many there are +static size_t emrtd_pace_candidates(const emrtd_cardaccess_t *ca, size_t *order, size_t maxorder) { + size_t count = 0; + + for (size_t i = 0; i < ca->count; i++) { + + if (emrtd_pace_rank(&ca->infos[i]) <= 0) { + continue; + } + + if (count >= maxorder) { + break; + } + + // insertion sort, the list is never longer than EMRTD_PACE_MAX_INFOS + size_t pos = count; + while ((pos > 0) && (emrtd_pace_rank(&ca->infos[order[pos - 1]]) < emrtd_pace_rank(&ca->infos[i]))) { + order[pos] = order[pos - 1]; + pos--; + } + order[pos] = i; + count++; + } + + return count; +} + +// Reads EF_DG14 over the freshly established session and checks the chip's +// Chip Authentication Mapping proof against the key it publishes there. +// +// Note: while no encoding of DO'8A' has been confirmed against real hardware, a +// check that does not come out is reported as "unverified" rather than as a +// failure, because our own support is the far likelier culprit. Once a document +// verifies, drop the probing in emrtd_pace_cam_verify(), keep only the encoding +// that worked, and make a mismatch loud again: at that point it means a clone. +static void emrtd_check_cam(emrtd_session_t *ssn) { + uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; + size_t resplen = 0; + + PrintAndLogEx(INFO, "Verifying Chip Authentication Mapping"); + + if (emrtd_select_and_read(response, &resplen, dg_table[EF_DG14].fileid, ssn) == false) { + PrintAndLogEx(WARNING, "Chip Authentication.. " _YELLOW_("unverified") " ( couldn't read EF_DG14 )"); + return; + } + + uint8_t pk_icc[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t pk_icclen = 0; + size_t expected = emrtd_pace_ec_pointlen(ssn->cam.curve); + bool found_any = false; + + // a document may publish more than one chip authentication key + for (size_t i = 0; i < EMRTD_PACE_MAX_INFOS; i++) { + + if (emrtd_pace_find_ca_pubkey(response, resplen, i, pk_icc, &pk_icclen) != PM3_SUCCESS) { + break; + } + + found_any = true; + PrintAndLogEx(DEBUG, "PK.CA.IC[%zu]....... %s", i, sprint_hex_inrow(pk_icc, pk_icclen)); + + if (pk_icclen != expected) { + PrintAndLogEx(DEBUG, "CAM: key %zu is %zu bytes, the PACE curve needs %zu, skipping", i, pk_icclen, expected); + continue; + } + + const char *mode = NULL; + if (emrtd_pace_cam_verify(ssn, pk_icc, pk_icclen, &mode) == PM3_SUCCESS) { + PrintAndLogEx(SUCCESS, "Chip Authentication.. " _GREEN_("verified") " ( the chip is genuine, not a clone )"); + PrintAndLogEx(INFO, "CAM encoding...... %s", mode); + return; + } + } + + if (found_any == false) { + PrintAndLogEx(WARNING, "Chip Authentication.. " _YELLOW_("unverified") " ( no EC chip authentication key in EF_DG14 )"); + return; + } + + PrintAndLogEx(WARNING, "Chip Authentication.. " _YELLOW_("not verified") " ( we cannot check this document's CAM proof )"); + PrintAndLogEx(HINT, "Hint: the secure channel is valid and every file is authentic. Only the anti-clone"); + PrintAndLogEx(HINT, "Hint: proof is unchecked, which is a known gap, not a sign of a bad document"); + PrintAndLogEx(HINT, "Hint: if you want to help close it, please report everything below"); + emrtd_pace_cam_dump(ssn, pk_icc, pk_icclen); +} + +static bool emrtd_do_auth(const emrtd_auth_t *auth, const emrtd_cardaccess_t *ca, bool ca_valid, + bool *BAC, emrtd_session_t *ssn) { + uint8_t aid[] = EMRTD_AID_MRTD; + + *BAC = false; + + //------------------------------------------------------------------------- + // PACE. EF_CardAccess lives on the MF, so this runs before the LDS applet + // is selected. On success the applet is selected under secure messaging. + //------------------------------------------------------------------------- + bool try_pace = (auth->force_bac == false) && ca_valid; + + if (auth->force_pace && (ca_valid == false)) { + PrintAndLogEx(ERR, "PACE was forced but this document has no usable EF_CardAccess."); + return false; + } + + if (try_pace) { + + size_t order[EMRTD_PACE_MAX_INFOS] = { 0 }; + size_t candidates = emrtd_pace_candidates(ca, order, ARRAYLEN(order)); + + uint8_t k[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + size_t klen = 0; + uint8_t password_ref = 0; + + if (candidates == 0) { + PrintAndLogEx(ERR, "PACE: this document offers no algorithm we can do"); + for (size_t i = 0; i < ca->count; i++) { + if (ca->infos[i].reason != NULL) { + PrintAndLogEx(ERR, " %s: %s", + (ca->infos[i].alg != NULL) ? ca->infos[i].alg->name : "unknown protocol", + ca->infos[i].reason); + } + } + } + + if ((candidates != 0) && (emrtd_pace_password(auth, k, &klen, &password_ref) == PM3_SUCCESS)) { + + PrintAndLogEx(INFO, "Trying PACE with the %s", (password_ref == EMRTD_PACE_PWD_CAN) ? "CAN" : "MRZ"); + + // strongest first, and drop down a rung if the document does not + // actually honour what it advertised + for (size_t i = 0; i < candidates; i++) { + + const emrtd_paceinfo_t *info = &ca->infos[order[i]]; + + if (i != 0) { + PrintAndLogEx(INFO, "Retrying with " _YELLOW_("%s"), info->alg->name); + DropField(); + msleep(50); + if (emrtd_connect() == false) { + PrintAndLogEx(ERR, "Couldn't reconnect to the document."); + return false; + } + } + + if (emrtd_do_pace(info, k, klen, password_ref, ssn) != PM3_SUCCESS) { + emrtd_sm_clear(ssn); + continue; + } + + if (emrtd_secure_select(ssn, EMRTD_P1_SELECT_BY_NAME, aid, sizeof(aid)) == false) { + PrintAndLogEx(ERR, "Couldn't select the MRTD application over PACE."); + emrtd_sm_clear(ssn); + continue; + } + + if (ssn->cam.negotiated) { + emrtd_check_cam(ssn); + } + + *BAC = true; + return true; + } + } + + emrtd_sm_clear(ssn); + + if (auth->force_pace) { + PrintAndLogEx(ERR, "PACE was forced, not falling back to BAC."); + return false; + } + + PrintAndLogEx(INFO, "PACE failed, falling back to BAC"); + // the document is in an undefined state after a failed PACE run + DropField(); + msleep(50); + if (emrtd_connect() == false) { + PrintAndLogEx(ERR, "Couldn't reconnect to the document."); + return false; + } + } + + //------------------------------------------------------------------------- + // BAC + //------------------------------------------------------------------------- // Select MRTD applet - uint8_t aid[] = EMRTD_AID_MRTD; if (emrtd_select_file_by_name(sizeof(aid), aid) == false) { PrintAndLogEx(ERR, "Couldn't select the MRTD application."); return false; @@ -1069,7 +1572,9 @@ static bool emrtd_do_auth(char *documentnumber, char *dob, char *expiry, bool BA size_t resplen = 0; uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; - if (emrtd_read_file(response, &resplen, NULL, NULL, NULL, false) == false) { + emrtd_session_t plain; + emrtd_sm_clear(&plain); + if (emrtd_read_file(response, &resplen, &plain) == false) { *BAC = true; PrintAndLogEx(INFO, "Authentication is enforced"); PrintAndLogEx(INFO, "Switching to external authentication"); @@ -1081,47 +1586,58 @@ static bool emrtd_do_auth(char *documentnumber, char *dob, char *expiry, bool BA // Do Basic Access Control if (*BAC) { // If BAC isn't available, exit out and warn user. - if (BAC_available == false) { + if (auth->mrz_available == false) { PrintAndLogEx(ERR, "This eMRTD enforces authentication, but you didn't supply MRZ data. Cannot proceed."); PrintAndLogEx(HINT, "Hint: Check out `" _YELLOW_("hf emrtd info/dump --h") "`, supply data with `-n` `-d` and `-e`"); return false; } - if (emrtd_do_bac(documentnumber, dob, expiry, ssc, ks_enc, ks_mac) == false) { + if (emrtd_do_bac(auth->documentnumber, auth->dob, auth->expiry, ssn) == false) { return false; } } return true; } -int dumpHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_available, const char *path) { +int dumpHF_EMRTD(const emrtd_auth_t *auth, const char *path) { uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; size_t resplen = 0; - uint8_t ssc[8] = { 0x00 }; - uint8_t ks_enc[EMRTD_KMAC_LEN] = { 0x00 }; - uint8_t ks_mac[EMRTD_KMAC_LEN] = { 0x00 }; + emrtd_session_t ssn; + emrtd_cardaccess_t ca; + bool ca_valid = false; bool BAC = false; + emrtd_sm_clear(&ssn); + memset(&ca, 0, sizeof(ca)); + ca.best = -1; + // Select the eMRTD if (emrtd_connect() == false) { DropField(); return PM3_ESOFT; } - // Dump EF_CardAccess (if available) - if (emrtd_dump_file(ks_enc, ks_mac, ssc, dg_table[EF_CardAccess].fileid, dg_table[EF_CardAccess].filename, BAC, path) == false) { - PrintAndLogEx(INFO, "Couldn't dump EF_CardAccess, card does not support PACE"); + // Read and dump EF_CardAccess (if available). This lives on the MF and is + // readable without authentication, so it has to happen before anything else. + if (emrtd_select_and_read(response, &resplen, dg_table[EF_CardAccess].fileid, &ssn) == false) { + PrintAndLogEx(INFO, "Couldn't read EF_CardAccess, card does not support PACE"); PrintAndLogEx(HINT, "Hint: This is expected behavior for cards without PACE and isn't something to be worried about"); + } else { + emrtd_save_file(response, resplen, dg_table[EF_CardAccess].fileid, dg_table[EF_CardAccess].filename, path); + ca_valid = (emrtd_pace_parse_cardaccess(response, resplen, &ca) == PM3_SUCCESS); + if (ca_valid == false) { + PrintAndLogEx(WARNING, "Couldn't parse EF_CardAccess, PACE is not available"); + } } // Authenticate with the eMRTD - if (emrtd_do_auth(documentnumber, dob, expiry, BAC_available, &BAC, ssc, ks_enc, ks_mac) == false) { + if (emrtd_do_auth(auth, &ca, ca_valid, &BAC, &ssn) == false) { DropField(); return PM3_ESOFT; } // Select EF_COM - if (emrtd_select_and_read(response, &resplen, dg_table[EF_COM].fileid, ks_enc, ks_mac, ssc, BAC) == false) { + if (emrtd_select_and_read(response, &resplen, dg_table[EF_COM].fileid, &ssn) == false) { PrintAndLogEx(ERR, "Failed to read EF_COM"); DropField(); return PM3_ESOFT; @@ -1164,8 +1680,10 @@ int dumpHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_availab continue; } PrintAndLogEx(DEBUG, "Current file... %s", dg->filename); - if (!dg->pace && !dg->eac) { - emrtd_dump_file(ks_enc, ks_mac, ssc, dg->fileid, dg->filename, BAC, path); + // dg->pace files are only reachable once a PACE session is up, dg->eac + // files need EAC which we do not implement at all + if ((!dg->pace || ssn.pace) && !dg->eac) { + emrtd_dump_file(&ssn, dg->fileid, dg->filename, path); } } DropField(); @@ -1893,7 +2411,13 @@ static int emrtd_print_ef_sod_info(uint8_t *dg_hashes_calc, uint8_t *dg_hashes_s if (calc_all_zero == true) { - if (fastdump && !dg_table[i].fastdump && !dg_table[i].pace && !dg_table[i].eac) { + if (dg_table[i].eac) { + // Terminal Authentication with a country signed inspection + // system certificate, which we neither have nor implement + PrintAndLogEx(SUCCESS, _YELLOW_("EF_DG%-2i") " %s%.*s " _YELLOW_("Needs EAC"), i, dg_table[i].desc, n, pad); + } else if (dg_table[i].pace) { + PrintAndLogEx(SUCCESS, _YELLOW_("EF_DG%-2i") " %s%.*s " _YELLOW_("Needs PACE"), i, dg_table[i].desc, n, pad); + } else if (fastdump && !dg_table[i].fastdump) { PrintAndLogEx(SUCCESS, _YELLOW_("EF_DG%-2i") " %s%.*s File was skipped, but is in EF_SOD", i, dg_table[i].desc, n, pad); } else { PrintAndLogEx(SUCCESS, _YELLOW_("EF_DG%-2i") " %s%.*s File couldn't be read, but is in EF_SOD", i, dg_table[i].desc, n, pad); @@ -1912,72 +2436,80 @@ static int emrtd_print_ef_sod_info(uint8_t *dg_hashes_calc, uint8_t *dg_hashes_s return PM3_SUCCESS; } -static int emrtd_print_ef_cardaccess_info(uint8_t *data, size_t datalen) { - uint8_t dataset[100] = { 0x00 }; - size_t datasetlen = 0; - uint8_t datafromtag[100] = { 0x00 }; - size_t datafromtaglen = 0; - uint8_t parsednum = 0; - +static void emrtd_print_cardaccess(const emrtd_cardaccess_t *ca) { PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "--------------------- " _CYAN_("EF_CardAccess") " --------------------"); - if (emrtd_lds_get_data_by_tag(data, datalen, dataset, &datasetlen, 0x30, 0x00, false, true, 0) == false) { - PrintAndLogEx(ERR, "Failed to read set from EF_CardAccess."); - return PM3_ESOFT; - } + for (size_t i = 0; i < ca->count; i++) { + const emrtd_paceinfo_t *info = &ca->infos[i]; - // Get PACE version - if (emrtd_lds_get_data_by_tag(dataset, datasetlen, datafromtag, &datafromtaglen, 0x02, 0x00, false, false, 0) == false) { - PrintAndLogEx(ERR, "Failed to read PACE version from EF_CardAccess."); - return PM3_ESOFT; - } - // TODO: hack!!! - memcpy(&parsednum, datafromtag, datafromtaglen); - PrintAndLogEx(SUCCESS, "PACE version............. " _YELLOW_("%i"), parsednum); + if (i != 0) { + PrintAndLogEx(SUCCESS, ""); + } - // Get PACE algorithm - if (emrtd_lds_get_data_by_tag(dataset, datasetlen, datafromtag, &datafromtaglen, 0x06, 0x00, false, false, 0) == false) { - PrintAndLogEx(ERR, "Failed to read PACE algorithm from EF_CardAccess."); - return PM3_ESOFT; - } + if (info->alg != NULL) { + PrintAndLogEx(SUCCESS, "PACE algorithm........... " _YELLOW_("%s"), info->alg->name); + } else { + PrintAndLogEx(SUCCESS, "PACE algorithm........... " _YELLOW_("unknown") " ( OID %s )", + sprint_hex_inrow((uint8_t *)info->oid, info->oidlen)); + } - for (int pacei = 0; pacealg_table[pacei].name != NULL; pacei++) { - PrintAndLogEx(DEBUG, "Trying: %s", pacealg_table[pacei].name); + if (info->version != 0) { + PrintAndLogEx(SUCCESS, "PACE version............. " _YELLOW_("%u"), info->version); + } - if (memcmp(pacealg_table[pacei].descriptor, datafromtag, datafromtaglen) == 0) { - PrintAndLogEx(SUCCESS, "PACE algorithm........... " _YELLOW_("%s"), pacealg_table[pacei].name); + if (info->has_param) { + if (info->sdp != NULL) { + PrintAndLogEx(SUCCESS, "PACE parameter........... " _YELLOW_("%s") " ( id %u )", info->sdp->name, info->param_id); + } else { + // TR-03110 part 3, table A.2 leaves 3-7 and 19-31 reserved + PrintAndLogEx(SUCCESS, "PACE parameter........... " _YELLOW_("RFU / unknown") " ( id %u )", info->param_id); + } + } + + if (info->supported) { + PrintAndLogEx(SUCCESS, "Supported by this client. " _GREEN_("yes") + "%s", ((int)i == ca->best) ? _GREEN_(" (selected)") : ""); + } else { + PrintAndLogEx(SUCCESS, "Supported by this client. " _YELLOW_("no") " ( %s )", + (info->reason != NULL) ? info->reason : "unsupported"); } } - // Get PACE parameter ID - if (emrtd_lds_get_data_by_tag(dataset, datasetlen, datafromtag, &datafromtaglen, 0x02, 0x00, false, false, 1) == false) { - PrintAndLogEx(ERR, "Failed to read PACE parameter ID from EF_CardAccess."); - return PM3_ESOFT; + if (ca->best < 0) { + PrintAndLogEx(NORMAL, ""); + PrintAndLogEx(WARNING, "None of the offered PACE algorithms is supported by this client"); } +} - // TODO: hack!!! - memcpy(&parsednum, datafromtag, datafromtaglen); - for (int pacepari = 0; pacesdp_table[pacepari].id != 32; pacepari++) { - PrintAndLogEx(DEBUG, "Trying: %s", pacesdp_table[pacepari].name); +// dg_table parser entry point, used by the offline path +static int emrtd_print_ef_cardaccess_info(uint8_t *data, size_t datalen) { + emrtd_cardaccess_t ca; - if (pacesdp_table[pacepari].id == parsednum) { - PrintAndLogEx(SUCCESS, "PACE parameter........... " _YELLOW_("%s"), pacesdp_table[pacepari].name); - } - // TODO: account for RFU + int res = emrtd_pace_parse_cardaccess(data, datalen, &ca); + if (res != PM3_SUCCESS) { + PrintAndLogEx(NORMAL, ""); + PrintAndLogEx(INFO, "--------------------- " _CYAN_("EF_CardAccess") " --------------------"); + PrintAndLogEx(ERR, "Failed to parse EF_CardAccess."); + return res; } + emrtd_print_cardaccess(&ca); return PM3_SUCCESS; } -int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_available, bool only_fast) { +int infoHF_EMRTD(const emrtd_auth_t *auth, bool only_fast) { uint8_t response[EMRTD_MAX_FILE_SIZE] = { 0x00 }; size_t resplen = 0; - uint8_t ssc[8] = { 0x00 }; - uint8_t ks_enc[16] = { 0x00 }; - uint8_t ks_mac[16] = { 0x00 }; - bool BAC = false; + emrtd_session_t ssn; + emrtd_cardaccess_t ca; + bool ca_valid = false; bool PACE_available = true; + bool BAC = false; + + emrtd_sm_clear(&ssn); + memset(&ca, 0, sizeof(ca)); + ca.best = -1; // Select the eMRTD if (emrtd_connect() == false) { @@ -1987,13 +2519,18 @@ int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_availab bool use14b = (GetISODEPState() == ISODEP_NFCB); // Read EF_CardAccess - if (emrtd_select_and_read(response, &resplen, dg_table[EF_CardAccess].fileid, ks_enc, ks_mac, ssc, BAC) == false) { + if (emrtd_select_and_read(response, &resplen, dg_table[EF_CardAccess].fileid, &ssn) == false) { PACE_available = false; PrintAndLogEx(HINT, "Hint: The error above this is normal. It just means that your eMRTD lacks PACE."); + } else { + ca_valid = (emrtd_pace_parse_cardaccess(response, resplen, &ca) == PM3_SUCCESS); + if (ca_valid == false) { + PrintAndLogEx(WARNING, "Couldn't parse EF_CardAccess, PACE is not available"); + } } // Select and authenticate with the eMRTD - bool auth_result = emrtd_do_auth(documentnumber, dob, expiry, BAC_available, &BAC, ssc, ks_enc, ks_mac); + bool auth_result = emrtd_do_auth(auth, &ca, ca_valid, &BAC, &ssn); PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "---------------------- " _CYAN_("Basic Info") " ----------------------"); @@ -2002,8 +2539,18 @@ int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_availab PrintAndLogEx(SUCCESS, "PACE..................... %s", PACE_available ? _GREEN_("Available") : _YELLOW_("Not available")); PrintAndLogEx(SUCCESS, "Authentication result.... %s", auth_result ? _GREEN_("Successful") : _RED_("Failed")); - if (PACE_available) { - emrtd_print_ef_cardaccess_info(response, resplen); + if (auth_result) { + if (ssn.pace) { + PrintAndLogEx(SUCCESS, "Session.................. " _GREEN_("PACE") " ( %s, %s )", ssn.pace_alg, ssn.pace_curve); + } else if (ssn.type == EMRTD_SM_3DES) { + PrintAndLogEx(SUCCESS, "Session.................. " _GREEN_("BAC") " ( 3DES-CBC-CBC )"); + } else { + PrintAndLogEx(SUCCESS, "Session.................. " _YELLOW_("plain") " ( no secure messaging )"); + } + } + + if (ca_valid) { + emrtd_print_cardaccess(&ca); } if (auth_result == false) { @@ -2012,7 +2559,7 @@ int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_availab } // Read EF_COM to get file list - if (emrtd_select_and_read(response, &resplen, dg_table[EF_COM].fileid, ks_enc, ks_mac, ssc, BAC) == false) { + if (emrtd_select_and_read(response, &resplen, dg_table[EF_COM].fileid, &ssn) == false) { PrintAndLogEx(ERR, "Failed to read EF_COM"); DropField(); return PM3_ESOFT; @@ -2038,7 +2585,7 @@ int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_availab uint8_t dg_hashes_calc[17][64] = { { 0 } }; int hash_algo = 0; - if (!emrtd_select_and_read(response, &resplen, dg_table[EF_SOD].fileid, ks_enc, ks_mac, ssc, BAC)) { + if (!emrtd_select_and_read(response, &resplen, dg_table[EF_SOD].fileid, &ssn)) { PrintAndLogEx(ERR, "Failed to read EF_SOD."); DropField(); return PM3_ESOFT; @@ -2061,8 +2608,10 @@ int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_availab continue; } - if (((dg->fastdump && only_fast) || !only_fast) && !dg->pace && !dg->eac) { - if (emrtd_select_and_read(response, &resplen, dg->fileid, ks_enc, ks_mac, ssc, BAC)) { + // dg->pace files are only reachable once a PACE session is up, dg->eac + // files need EAC which we do not implement at all + if (((dg->fastdump && only_fast) || !only_fast) && (!dg->pace || ssn.pace) && !dg->eac) { + if (emrtd_select_and_read(response, &resplen, dg->fileid, &ssn)) { if (dg->parser != NULL) dg->parser(response, resplen); @@ -2217,13 +2766,74 @@ static bool validate_date(uint8_t *data, int datalen) { return !(day <= 0 || day > 31 || month <= 0 || month > 12); } +static bool emrtd_validate_can(const char *can, int canlen) { + if ((canlen < 1) || (canlen > 14)) { + PrintAndLogEx(ERR, "CAN length is incorrect, it should be 1 to 14 chars, not %i", canlen); + return false; + } + + for (int i = 0; i < canlen; i++) { + if (isdigit((unsigned char)can[i]) == false) { + PrintAndLogEx(ERR, "CAN has to be numeric."); + return false; + } + } + + if (canlen != 6) { + PrintAndLogEx(WARNING, "CAN is usually 6 digits, yours is %i. Continuing anyway.", canlen); + } + return true; +} + +static bool emrtd_check_auth_args(bool mrz, bool can, bool force_pace, bool force_bac) { + if (mrz && can) { + PrintAndLogEx(ERR, "`" _YELLOW_("--can") "` and the MRZ arguments are mutually exclusive as PACE passwords."); + PrintAndLogEx(HINT, "Hint: pick one, the CAN with `" _YELLOW_("--can") "` or the MRZ with `" _YELLOW_("-n") "` `" _YELLOW_("-d") "` `" _YELLOW_("-e") "`"); + return false; + } + + if (force_pace && force_bac) { + PrintAndLogEx(ERR, "`" _YELLOW_("--pace") "` and `" _YELLOW_("--bac") "` are mutually exclusive."); + return false; + } + + if (force_bac && can && (mrz == false)) { + PrintAndLogEx(ERR, "BAC needs MRZ data, the CAN is a PACE only password."); + return false; + } + + if (force_pace && (mrz == false) && (can == false)) { + PrintAndLogEx(ERR, "PACE needs a password, supply `" _YELLOW_("--can") "` or `" _YELLOW_("-n") "` `" _YELLOW_("-d") "` `" _YELLOW_("-e") "`"); + return false; + } + + return true; +} + +static void emrtd_fill_auth(emrtd_auth_t *auth, const char *docnum, const char *dob, const char *expiry, + const char *can, bool mrz_available, bool can_available, + bool force_pace, bool force_bac) { + memset(auth, 0, sizeof(emrtd_auth_t)); + strncpy(auth->documentnumber, docnum, sizeof(auth->documentnumber) - 1); + strncpy(auth->dob, dob, sizeof(auth->dob) - 1); + strncpy(auth->expiry, expiry, sizeof(auth->expiry) - 1); + strncpy(auth->can, can, sizeof(auth->can) - 1); + auth->mrz_available = mrz_available; + auth->can_available = can_available; + auth->force_pace = force_pace; + auth->force_bac = force_bac; +} + static int CmdHFeMRTDDump(const char *Cmd) { CLIParserContext *ctx; CLIParserInit(&ctx, "hf emrtd dump", "Dump all files on an eMRTD", "hf emrtd dump\n" "hf emrtd dump --dir ../dump\n" - "hf emrtd dump -n 123456789 -d 890101 -e 250401" + "hf emrtd dump -n 123456789 -d 890101 -e 250401\n" + "hf emrtd dump --can 123456 -> PACE with the Card Access Number\n" + "hf emrtd dump --can 123456 --pace -> PACE only, no BAC fallback\n" + "hf emrtd dump -n 123456789 -d 890101 -e 250401 --bac -> force BAC" ); void *argtable[] = { @@ -2232,6 +2842,9 @@ static int CmdHFeMRTDDump(const char *Cmd) { arg_str0("d", "date", "", "date of birth in YYMMDD format"), arg_str0("e", "expiry", "", "expiry in YYMMDD format"), arg_str0("m", "mrz", "<[0-9A-Z<]>", "2nd line of MRZ, 44 chars"), + arg_str0(NULL, "can", "", "Card Access Number, PACE password instead of the MRZ"), + arg_lit0(NULL, "pace", "force PACE, fail instead of falling back to BAC"), + arg_lit0(NULL, "bac", "force BAC, skip PACE"), arg_str0(NULL, "dir", "", "save dump to the given dirpath"), arg_param_end }; @@ -2299,12 +2912,29 @@ static int CmdHFeMRTDDump(const char *Cmd) { } } + uint8_t can[15] = { 0x00 }; + bool CAN = false; + if (CLIParamStrToBuf(arg_get_str(ctx, 5), can, sizeof(can) - 1, &slen) == 0 && slen != 0) { + CAN = true; + if (emrtd_validate_can((const char *)can, slen) == false) { + error = true; + } + } + + bool force_pace = arg_get_lit(ctx, 6); + bool force_bac = arg_get_lit(ctx, 7); + uint8_t path[FILENAME_MAX] = { 0x00 }; - if (CLIParamStrToBuf(arg_get_str(ctx, 5), path, sizeof(path), &slen) != 0 || slen == 0) { + if (CLIParamStrToBuf(arg_get_str(ctx, 8), path, sizeof(path), &slen) != 0 || slen == 0) { path[0] = '.'; } CLIParserFree(ctx); + + if (emrtd_check_auth_args(BAC, CAN, force_pace, force_bac) == false) { + error = true; + } + if (error) { return PM3_ESOFT; } @@ -2315,7 +2945,11 @@ static int CmdHFeMRTDDump(const char *Cmd) { uint64_t t1 = msclock(); - int res = dumpHF_EMRTD((char *)docnum, (char *)dob, (char *)expiry, BAC, (const char *)path); + emrtd_auth_t auth; + emrtd_fill_auth(&auth, (const char *)docnum, (const char *)dob, (const char *)expiry, + (const char *)can, BAC, CAN, force_pace, force_bac); + + int res = dumpHF_EMRTD(&auth, (const char *)path); PrintAndLogEx(SUCCESS, "time: %" PRIu64 " seconds\n", (msclock() - t1) / 1000); @@ -2330,7 +2964,9 @@ static int CmdHFeMRTDInfo(const char *Cmd) { "hf emrtd info\n" "hf emrtd info --dir ../dumps\n" "hf emrtd info -n 123456789 -d 890101 -e 250401\n" - "hf emrtd info -n 123456789 -d 890101 -e 250401 -i" + "hf emrtd info -n 123456789 -d 890101 -e 250401 -i\n" + "hf emrtd info --can 123456 -> PACE with the Card Access Number\n" + "hf emrtd info --can 123456 --pace -> PACE only, no BAC fallback" ); void *argtable[] = { @@ -2339,6 +2975,9 @@ static int CmdHFeMRTDInfo(const char *Cmd) { arg_str0("d", "date", "", "date of birth in YYMMDD format"), arg_str0("e", "expiry", "", "expiry in YYMMDD format"), arg_str0("m", "mrz", "<[0-9A-Z<]>", "2nd line of MRZ, 44 chars (passports only)"), + arg_str0(NULL, "can", "", "Card Access Number, PACE password instead of the MRZ"), + arg_lit0(NULL, "pace", "force PACE, fail instead of falling back to BAC"), + arg_lit0(NULL, "bac", "force BAC, skip PACE"), arg_str0(NULL, "dir", "", "display info from offline dump stored in dirpath"), arg_lit0("i", "images", "show images"), arg_param_end @@ -2405,9 +3044,21 @@ static int CmdHFeMRTDInfo(const char *Cmd) { } } } + uint8_t can[15] = { 0x00 }; + bool CAN = false; + if (CLIParamStrToBuf(arg_get_str(ctx, 5), can, sizeof(can) - 1, &slen) == 0 && slen != 0) { + CAN = true; + if (emrtd_validate_can((const char *)can, slen) == false) { + error = true; + } + } + + bool force_pace = arg_get_lit(ctx, 6); + bool force_bac = arg_get_lit(ctx, 7); + uint8_t path[FILENAME_MAX] = { 0x00 }; - bool is_offline = CLIParamStrToBuf(arg_get_str(ctx, 5), path, sizeof(path), &slen) == 0 && slen > 0; - bool show_images = arg_get_lit(ctx, 6); + bool is_offline = CLIParamStrToBuf(arg_get_str(ctx, 8), path, sizeof(path), &slen) == 0 && slen > 0; + bool show_images = arg_get_lit(ctx, 9); CLIParserFree(ctx); if ((IfPm3Iso14443() == false) && (is_offline == false)) { @@ -2415,6 +3066,10 @@ static int CmdHFeMRTDInfo(const char *Cmd) { error = true; } + if ((is_offline == false) && (emrtd_check_auth_args(BAC, CAN, force_pace, force_bac) == false)) { + error = true; + } + if (error) { return PM3_ESOFT; } @@ -2426,12 +3081,32 @@ static int CmdHFeMRTDInfo(const char *Cmd) { if (g_debugMode >= 2) { SetAPDULogging(true); } - int res = infoHF_EMRTD((char *)docnum, (char *)dob, (char *)expiry, BAC, !show_images); + emrtd_auth_t auth; + emrtd_fill_auth(&auth, (const char *)docnum, (const char *)dob, (const char *)expiry, + (const char *)can, BAC, CAN, force_pace, force_bac); + + int res = infoHF_EMRTD(&auth, !show_images); SetAPDULogging(restore_apdu_logging); return res; } } +static int CmdHFeMRTDTest(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf emrtd test", + "Regression tests for the PACE and secure messaging primitives", + "hf emrtd test"); + + void *argtable[] = { + arg_param_begin, + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + CLIParserFree(ctx); + + return emrtd_test(true) ? PM3_SUCCESS : PM3_ESOFT; +} + static int CmdHFeMRTDList(const char *Cmd) { return CmdTraceListAlias(Cmd, "hf emrtd", "7816"); } @@ -2442,6 +3117,7 @@ static command_t CommandTable[] = { {"dump", CmdHFeMRTDDump, IfPm3Iso14443, "Dump eMRTD files to binary files"}, {"info", CmdHFeMRTDInfo, AlwaysAvailable, "Tag information"}, {"list", CmdHFeMRTDList, AlwaysAvailable, "List ISO 14443A/7816 history"}, + {"test", CmdHFeMRTDTest, AlwaysAvailable, "Regression tests"}, {NULL, NULL, NULL, NULL} }; diff --git a/client/src/cmdhfemrtd.h b/client/src/cmdhfemrtd.h index 962501331..e8ce57709 100644 --- a/client/src/cmdhfemrtd.h +++ b/client/src/cmdhfemrtd.h @@ -47,23 +47,22 @@ typedef struct emrtd_hashalg_s { const uint8_t descriptor[15]; } emrtd_hashalg_t; -typedef struct emrtd_pacealg_s { - const char *name; - int (*keygenerator)(uint8_t *datain, int datainlen, uint8_t *dataout); - const uint8_t descriptor[10]; -} emrtd_pacealg_t; - -// Standardized Domain Parameters -typedef struct emrtd_pacesdp_s { - uint8_t id; - const char *name; - size_t size; -} emrtd_pacesdp_t; +// Everything needed to authenticate to a document, either with BAC or with PACE +typedef struct emrtd_auth_s { + char documentnumber[10]; + char dob[7]; + char expiry[7]; + char can[15]; + bool mrz_available; + bool can_available; + bool force_pace; // fail rather than falling back to BAC + bool force_bac; // skip PACE even when EF_CardAccess is present +} emrtd_auth_t; int CmdHFeMRTD(const char *Cmd); -int dumpHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_available, const char *path); -int infoHF_EMRTD(char *documentnumber, char *dob, char *expiry, bool BAC_available, bool only_fast); +int dumpHF_EMRTD(const emrtd_auth_t *auth, const char *path); +int infoHF_EMRTD(const emrtd_auth_t *auth, bool only_fast); int infoHF_EMRTD_offline(const char *path); #ifdef __cplusplus diff --git a/client/src/pm3line_vocabulary.h b/client/src/pm3line_vocabulary.h index 7638788e7..8f562b806 100644 --- a/client/src/pm3line_vocabulary.h +++ b/client/src/pm3line_vocabulary.h @@ -222,6 +222,7 @@ const static vocabulary_t vocabulary[] = { { 0, "hf 15 writeafi" }, { 0, "hf 15 writedsfid" }, { 0, "hf 15 csetuid" }, + { 0, "hf 15 cfinalize" }, { 1, "hf aliro help" }, { 1, "hf aliro list" }, { 0, "hf aliro info" }, @@ -254,15 +255,16 @@ const static vocabulary_t vocabulary[] = { { 0, "hf emrtd dump" }, { 1, "hf emrtd info" }, { 1, "hf emrtd list" }, + { 1, "hf emrtd test" }, { 1, "hf felica help" }, { 1, "hf felica list" }, { 0, "hf felica info" }, - { 0, "hf felica seacauth1" }, { 0, "hf felica raw" }, { 0, "hf felica rdbl" }, { 0, "hf felica reader" }, { 0, "hf felica sniff" }, { 0, "hf felica wrbl" }, + { 0, "hf felica seacauth1" }, { 0, "hf felica dump" }, { 0, "hf felica discnodes" }, { 0, "hf felica sim" }, @@ -676,7 +678,11 @@ const static vocabulary_t vocabulary[] = { { 0, "hw bootloader" }, { 1, "hw connect" }, { 0, "hw dbg" }, + { 0, "hw fpga" }, { 0, "hw fpgaoff" }, + { 0, "hw ant_pm5" }, + { 0, "hw qc_pm5" }, + { 0, "hw factorydata" }, { 0, "hw lcd" }, { 0, "hw lcdreset" }, { 0, "hw ping" }, @@ -1117,6 +1123,7 @@ const static vocabulary_t vocabulary[] = { { 0, "script run lf_em_tearoff_protect.lua" }, { 0, "script run lf_hid_bulkclone.lua" }, { 0, "script run lf_hid_bulkclone_v2.lua" }, + { 0, "script run lf_ht2_paxton.lua" }, { 0, "script run lf_ident_json.lua" }, { 0, "script run lf_ioprox_bulkclone.lua" }, { 0, "script run lf_t55xx_chk.lua" }, diff --git a/client/src/proxguiqt.cpp b/client/src/proxguiqt.cpp index df810aef9..11cadfdca 100644 --- a/client/src/proxguiqt.cpp +++ b/client/src/proxguiqt.cpp @@ -270,6 +270,40 @@ const PictureItem *PictureWidget::pictureAt(int i) const { return &m_images.at(i); } +ScaledPictureLabel::ScaledPictureLabel(const QImage &img, QWidget *parent) + : QLabel(parent), m_image(img) { + + setAlignment(Qt::AlignCenter); + setMinimumSize(1, 1); + // let the layout hand us whatever is going, we adapt to it + setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); + rescale(); +} + +QSize ScaledPictureLabel::sizeHint(void) const { + return m_image.size(); +} + +void ScaledPictureLabel::resizeEvent(QResizeEvent *event) { + QLabel::resizeEvent(event); + rescale(); +} + +void ScaledPictureLabel::rescale(void) { + + if (m_image.isNull()) + return; + + QSize room = size(); + if (room.width() < 1 || room.height() < 1) + return; + + // Qt::KeepAspectRatio fits the image inside the box without distorting it. + // Scaling up is wanted here, a 240x320 portrait in a 400x400 window should + // fill the window rather than sit in the middle of it. + setPixmap(QPixmap::fromImage(m_image.scaled(room, Qt::KeepAspectRatio, Qt::SmoothTransformation))); +} + // Append one image to the array and give it its own tab void PictureWidget::addPicture(const QString &title, const QImage &img) { @@ -281,17 +315,8 @@ void PictureWidget::addPicture(const QString &title, const QImage &img) { QWidget *page = new QWidget(); QVBoxLayout *layout = new QVBoxLayout(page); - QLabel *lbl_pm = new QLabel(); - lbl_pm->setPixmap(QPixmap::fromImage(img)); - lbl_pm->setScaledContents(false); - lbl_pm->setAlignment(Qt::AlignCenter); - - // large images (fingerprints, high res portraits) shouldn't blow up the window - QScrollArea *scroll = new QScrollArea(page); - scroll->setWidget(lbl_pm); - scroll->setWidgetResizable(true); - scroll->setAlignment(Qt::AlignCenter); - layout->addWidget(scroll); + ScaledPictureLabel *lbl_pm = new ScaledPictureLabel(img, page); + layout->addWidget(lbl_pm, 1); QLabel *lbl_sz = new QLabel(page); lbl_sz->setText(QString("w: %1 h: %2") diff --git a/client/src/proxguiqt.h b/client/src/proxguiqt.h index 6da86e1ca..060ed9a73 100644 --- a/client/src/proxguiqt.h +++ b/client/src/proxguiqt.h @@ -27,6 +27,7 @@ #include #include #include +#include #include #include "proxgui.h" @@ -101,6 +102,27 @@ class PictureItem { QImage image; }; +/** + * @brief A label that keeps its image scaled to whatever room it is given + * + * Portraits in EF_DG2 are small (often 240x320) and signatures in EF_DG7 are + * wide and short. Painting either one at native size in a fixed window leaves + * it stranded in a corner, so the pixmap is rebuilt from the original image on + * every resize, fitted to the widget and keeping the aspect ratio. + */ +class ScaledPictureLabel : public QLabel { + public: + explicit ScaledPictureLabel(const QImage &img, QWidget *parent = nullptr); + QSize sizeHint(void) const override; + + protected: + void resizeEvent(QResizeEvent *event) override; + + private: + void rescale(void); + QImage m_image; +}; + // Picture viewer window. Holds an array of images, one tab per image, so that // several pictures of the same document (portrait, signature, other biometrics) // can be shown side by side diff --git a/doc/commands.json b/doc/commands.json index 6e0e1657c..6e66ebb33 100644 --- a/doc/commands.json +++ b/doc/commands.json @@ -1891,20 +1891,35 @@ ], "usage": "hf 14b wrbl [-h] [-b ] -d [--512] [--4k] [--sb] [--force]" }, + "hf 15 cfinalize": { + "command": "hf 15 cfinalize", + "description": "Finalize a magic ISO15693 'V3' tag. This operation is irreversible. After finalize the configuration area is erased and the UID can no longer be changed. Set the UID with `hf 15 csetuid --v3` first, then lock it in with this command.", + "notes": [ + "hf 15 cfinalize -y" + ], + "offline": false, + "options": [ + "-h, --help This help", + "-y, --yes Confirm the irreversible finalize operation" + ], + "usage": "hf 15 cfinalize [-hy]" + }, "hf 15 csetuid": { "command": "hf 15 csetuid", - "description": "Set UID for magic Chinese card (only works with such cards)", + "description": "Set UID for magic Chinese card (only works with such cards) For magic 'V3' tags this writes the UID configuration only and is repeatable; run `hf 15 cfinalize` afterwards to lock the UID permanently.", "notes": [ "hf 15 csetuid -u E011223344556677 -> use gen1 command", - "hf 15 csetuid -u E011223344556677 --v2 -> use gen2 command" + "hf 15 csetuid -u E011223344556677 --v2 -> use gen2 command", + "hf 15 csetuid -u E011223344556677 --v3 -> use gen3 (V3) magic tag" ], "offline": false, "options": [ "-h, --help This help", "-u, --uid UID, 8 hex bytes", - "-2, --v2 Use gen2 magic command" + "-2, --v2 Use gen2 magic command", + "-3, --v3 Use gen3 (V3) magic tag (repeatable, needs cfinalize)" ], - "usage": "hf 15 csetuid [-h2] -u " + "usage": "hf 15 csetuid [-h23] -u " }, "hf 15 demod": { "command": "hf 15 demod", @@ -2836,11 +2851,14 @@ }, "hf emrtd help": { "command": "hf emrtd help", - "description": "help This help info Tag information list List ISO 14443A/7816 history --------------------------------------------------------------------------------------- hf emrtd dump available offline: no Dump all files on an eMRTD", + "description": "help This help info Tag information list List ISO 14443A/7816 history test Regression tests --------------------------------------------------------------------------------------- hf emrtd dump available offline: no Dump all files on an eMRTD", "notes": [ "hf emrtd dump", "hf emrtd dump --dir ../dump", - "hf emrtd dump -n 123456789 -d 890101 -e 250401" + "hf emrtd dump -n 123456789 -d 890101 -e 250401", + "hf emrtd dump --can 123456 -> PACE with the Card Access Number", + "hf emrtd dump --can 123456 --pace -> PACE only, no BAC fallback", + "hf emrtd dump -n 123456789 -d 890101 -e 250401 --bac -> force BAC" ], "offline": true, "options": [ @@ -2849,9 +2867,12 @@ "-d, --date date of birth in YYMMDD format", "-e, --expiry expiry in YYMMDD format", "-m, --mrz <[0-9A-Z<]> 2nd line of MRZ, 44 chars", + "--can Card Access Number, PACE password instead of the MRZ", + "--pace force PACE, fail instead of falling back to BAC", + "--bac force BAC, skip PACE", "--dir save dump to the given dirpath" ], - "usage": "hf emrtd dump [-h] [-n ] [-d ] [-e ] [-m <[0-9A-Z<]>] [--dir ]" + "usage": "hf emrtd dump [-h] [-n ] [-d ] [-e ] [-m <[0-9A-Z<]>] [--can ] [--pace] [--bac] [--dir ]" }, "hf emrtd info": { "command": "hf emrtd info", @@ -2860,7 +2881,9 @@ "hf emrtd info", "hf emrtd info --dir ../dumps", "hf emrtd info -n 123456789 -d 890101 -e 250401", - "hf emrtd info -n 123456789 -d 890101 -e 250401 -i" + "hf emrtd info -n 123456789 -d 890101 -e 250401 -i", + "hf emrtd info --can 123456 -> PACE with the Card Access Number", + "hf emrtd info --can 123456 --pace -> PACE only, no BAC fallback" ], "offline": true, "options": [ @@ -2869,10 +2892,13 @@ "-d, --date date of birth in YYMMDD format", "-e, --expiry expiry in YYMMDD format", "-m, --mrz <[0-9A-Z<]> 2nd line of MRZ, 44 chars (passports only)", + "--can Card Access Number, PACE password instead of the MRZ", + "--pace force PACE, fail instead of falling back to BAC", + "--bac force BAC, skip PACE", "--dir display info from offline dump stored in dirpath", "-i, --images show images" ], - "usage": "hf emrtd info [-hi] [-n ] [-d ] [-e ] [-m <[0-9A-Z<]>] [--dir ]" + "usage": "hf emrtd info [-hi] [-n ] [-d ] [-e ] [-m <[0-9A-Z<]>] [--can ] [--pace] [--bac] [--dir ]" }, "hf emrtd list": { "command": "hf emrtd list", @@ -2895,6 +2921,18 @@ ], "usage": "hf emrtd list [-h1crux] [--frame] [-f ]" }, + "hf emrtd test": { + "command": "hf emrtd test", + "description": "Regression tests for the PACE and secure messaging primitives", + "notes": [ + "hf emrtd test" + ], + "offline": true, + "options": [ + "-h, --help This help" + ], + "usage": "hf emrtd test [-h]" + }, "hf epa help": { "command": "hf epa help", "description": "help This help --------------------------------------------------------------------------------------- hf epa cnonces available offline: no Tries to collect nonces when doing part of PACE protocol.", @@ -3020,7 +3058,7 @@ }, "hf felica help": { "command": "hf felica help", - "description": "----------- ----------------------- General ----------------------- help This help list List ISO 18092/FeliCa history ----------- ----------------------- Operations ----------------------- ----------- ----------------------- FeliCa Standard ----------------------- ----------- ----------------------- FeliCa Light ----------------------- --------------------------------------------------------------------------------------- hf felica list available offline: yes Alias of `trace list -t felica` with selected protocol data to annotate trace buffer You can load a trace from file (see `trace load -h`) or it be downloaded from device by default It accepts all other arguments of `trace list`. Note that some might not be relevant for this specific protocol", + "description": "----------- ----------------------- General ----------------------- help This help list List ISO 18092/FeliCa history ----------- ----------------------- Operations ----------------------- ----------- ----------------------- FeliCa SEAC ----------------------- ----------- ----------------------- FeliCa Standard ----------------------- ----------- ----------------------- FeliCa Light ----------------------- --------------------------------------------------------------------------------------- hf felica list available offline: yes Alias of `trace list -t felica` with selected protocol data to annotate trace buffer You can load a trace from file (see `trace load -h`) or it be downloaded from device by default It accepts all other arguments of `trace list`. Note that some might not be relevant for this specific protocol", "notes": [ "hf felica list --frame -> show frame delay times", "hf felica list -1 -> use trace buffer" @@ -3248,17 +3286,22 @@ ], "usage": "hf felica scsvcode [-h] [-r ] [--idm ]" }, - "hf felica seacinfo": { - "command": "hf felica seacinfo", - "description": "Get info about FeliCa SEAC cards", + "hf felica seacauth1": { + "command": "hf felica seacauth1", + "description": "Send FeliCa SEAC Authentication1", "notes": [ - "hf felica seacinfo" + "hf felica seacauth1", + "hf felica seacauth1 --selector 0F", + "hf felica seacauth1 --challenge 0001020304050607", + "hf felica seacauth1 -s 0F -c FFFFFFFFFFFFFFFF" ], "offline": false, "options": [ - "-h, --help This help" + "-h, --help This help", + "-s, --selector selector, 1 byte (default 01)", + "-c, --challenge Challenge1a, 8 bytes (default all zero)" ], - "usage": "hf felica seacinfo [-h]" + "usage": "hf felica seacauth1 [-h] [-s ] [-c ]" }, "hf felica sim": { "command": "hf felica sim", @@ -4835,16 +4878,30 @@ }, "hf iclass sam": { "command": "hf iclass sam", - "description": "hf iclass sam - HID SAM operations Secure-channel subcommands: Legacy PACS-extraction flags (no subcommand, applied to hf iclass sam directly): --info get SAM version + serial number (also warms up the SAM) -d, --data DER-encoded SAMCommand to send (raw, no SC) -s, --snmp --data is in SNMP format without the A0/94 headers -p, --prevent fake the e-purse update during PACS extraction --break stop tag interaction at nr-mac (for SIO extract) -f, --file emulate from a dump file instead of a real card -n, --nodetect skip card detect + SetDetectedCardInfo -k, --keep keep the field active after the command -t, --tlv decode the response as TLV --shallow shallow modulation -v, --verbose verbose output Examples: hf iclass sam extract PACS via SAM (defaults) hf iclass sam --info get SAM version + serial (warmup ping) hf iclass sam scopen open Artemis secure channel hf iclass sam scsend --payload 8200 send wrapped SAMCommand hf iclass sam scclose terminate the SC session ======================================================================================= hf ict { ICT MFC/DESfire RFIDs... } --------------------------------------------------------------------------------------- hf ict help available offline: yes help This help list List ICT history reader Act like an IS14443-a reader --------------------------------------------------------------------------------------- hf ict credential available offline: no Read ICT sector from tag and decode", + "description": "Extract PACS via a HID SAM", "notes": [ - "hf ict credential" + "hf iclass sam", + "hf iclass sam -p -d a005a103800104 -> get PACS data, prevent epurse update", + "hf iclass sam --break -> get Nr-MAC for extracting encrypted SIO", + "hf iclass sam -f hf-iclass-dump.bin -> emulate card from dump file to SAM", + "hf iclass sam --info -> get SAM version + serial (also warms up the SAM)" ], "offline": false, "options": [ "-h, --help This help", - "-v, --verbose verbose output" + "-v, --verbose verbose output", + "-k, --keep keep the field active after command executed", + "-n, --nodetect skip selecting the card and sending card details to SAM", + "-t, --tlv decode TLV", + "--break stop tag interaction on nr-mac", + "-p, --prevent fake epurse update", + "--shallow shallow mod", + "-d, --data DER encoded command to send to SAM", + "-s, --snmp data is in snmp format without headers", + "--info get SAM infos (version, serial number)", + "-f, --file dump file to emulate to SAM instead of a real card" ], - "usage": "hf ict credential [-hv]" + "usage": "hf iclass sam [-hvkntps] [--break] [--shallow] [-d ]... [--info] [-f ]" }, "hf iclass sim": { "command": "hf iclass sim", @@ -5003,6 +5060,19 @@ ], "usage": "hf iclass wrbl [-hv@] [-k ] [--ki ] --blk -d [-m ] [--credit] [--elite] [--raw] [--nr] [--shallow]" }, + "hf ict help": { + "command": "hf ict help", + "description": "help This help list List ICT history reader Act like an IS14443-a reader --------------------------------------------------------------------------------------- hf ict credential available offline: no Read ICT sector from tag and decode", + "notes": [ + "hf ict credential" + ], + "offline": true, + "options": [ + "-h, --help This help", + "-v, --verbose verbose output" + ], + "usage": "hf ict credential [-hv]" + }, "hf ict info": { "command": "hf ict info", "description": "Get info from ICT encoded credential tags (MIFARE Classic / DESfire)", @@ -8252,6 +8322,7 @@ "notes": [ "hf mfdes pc --key 00000000000000000000000000000000", "hf mfdes pc --key 00112233445566778899aabbccddeeff --rounds 4", + "hf mfdes pc --aid 123456 --key 00112233445566778899aabbccddeeff", "hf mfdes pc --key 00112233445566778899aabbccddeeff -c native -a" ], "offline": false, @@ -8261,9 +8332,10 @@ "-v, --verbose Verbose output", "-k, --key Key (AES-128, exactly 16 bytes)", "-r, --rounds Number of rounds (1..8), default 8", - "-c, --ccset Communication command set (default from `hf mfdes default`)" + "-c, --ccset Communication command set (default from `hf mfdes default`)", + "--aid Application ID (3 hex bytes, big endian)" ], - "usage": "hf mfdes pc [-hav] -k [-r ] [-c ]" + "usage": "hf mfdes pc [-hav] -k [-r ] [-c ] [--aid ]" }, "hf mfdes read": { "command": "hf mfdes read", @@ -10465,9 +10537,10 @@ "--bar bar style", "--mix mixed style", "--value values style", - "-v, --verbose verbose output" + "-v, --verbose verbose output", + "--rgb (PM5) mirror the tuning level on the antenna RGB LED" ], - "usage": "hf tune [-hv] [-n ] [--bar] [--mix] [--value]" + "usage": "hf tune [-hv] [-n ] [--bar] [--mix] [--value] [--rgb]" }, "hf vas decrypt": { "command": "hf vas decrypt", @@ -10652,6 +10725,21 @@ ], "usage": "hints [-h10]" }, + "hw ant_pm5": { + "command": "hw ant_pm5", + "description": "Control the antennal of pm5", + "notes": [ + "hw ant_pm5 --set -> Write the data of IO data register", + "hw ant_pm5 -m --set -> Write the data of IO map register" + ], + "offline": false, + "options": [ + "-h, --help This help", + "-m, --map Write the IO map register", + "-s, --set Set PM5 antenna" + ], + "usage": "hw ant_pm5 [-hm] [-s ]" + }, "hw bootloader": { "command": "hw bootloader", "description": "Reboot Proxmark3 into bootloader mode", @@ -10725,9 +10813,23 @@ ], "usage": "hw decay [-h] [--ms ] [--us ]" }, - "hw fpgaoff": { - "command": "hw fpgaoff", - "description": "Turn of fpga and antenna field", + "hw factorydata": { + "command": "hw factorydata", + "description": "Get/Set the factory data for Device", + "notes": [ + "hw factorydata --load -> Write the factory data to device from file", + "hw factorydata -> Read and parse the factory data from device" + ], + "offline": false, + "options": [ + "-h, --help This help", + "--load Load factory data from file to device" + ], + "usage": "hw factorydata [-h] [--load ]" + }, + "hw fpga": { + "command": "hw fpga", + "description": "help This help ------------- ----------------------- Operation ----------------------- --------------------------------------------------------------------------------------- hw fpgaoff available offline: no Turn of fpga and antenna field", "notes": [ "hw fpgaoff" ], @@ -10792,6 +10894,18 @@ ], "usage": "hw ping [-h] [-l ]" }, + "hw qc_pm5": { + "command": "hw qc_pm5", + "description": "QC Test for the PM5", + "notes": [ + "hf qcpm5" + ], + "offline": false, + "options": [ + "-h, --help This help" + ], + "usage": "hw qcpm5 [-h]" + }, "hw readmem": { "command": "hw readmem", "description": "Reads processor flash memory into a file or views on console", @@ -14388,9 +14502,10 @@ "--bar bar style", "--mix mixed style", "--value values style", - "-v, --verbose verbose output" + "-v, --verbose verbose output", + "--rgb (PM5) mirror the tuning level on the antenna RGB LED" ], - "usage": "lf tune [-hv] [-n ] [-q ] [-f ] [--bar] [--mix] [--value]" + "usage": "lf tune [-hv] [-n ] [-q ] [-f ] [--bar] [--mix] [--value] [--rgb]" }, "lf viking clone": { "command": "lf viking clone", @@ -16023,8 +16138,8 @@ } }, "metadata": { - "commands_extracted": 896, + "commands_extracted": 902, "extracted_by": "PM3Help2JSON v1.00", - "extracted_on": "2026-07-30T14:44:57+00:00" + "extracted_on": "2026-08-21T18:43:14+00:00" } } diff --git a/doc/commands.md b/doc/commands.md index 07bed6008..6b42e6bcc 100644 --- a/doc/commands.md +++ b/doc/commands.md @@ -281,6 +281,7 @@ Check column "offline" for their availability. |`hf 15 writeafi `|N |`Writes the AFI on an ISO-15693 tag` |`hf 15 writedsfid `|N |`Writes the DSFID on an ISO-15693 tag` |`hf 15 csetuid `|N |`Set UID for magic card` +|`hf 15 cfinalize `|N |`Finalize a magic V3 tag (irreversible)` ### hf aliro @@ -353,6 +354,7 @@ Check column "offline" for their availability. |`hf emrtd dump `|N |`Dump eMRTD files to binary files` |`hf emrtd info `|Y |`Tag information` |`hf emrtd list `|Y |`List ISO 14443A/7816 history` +|`hf emrtd test `|Y |`Regression tests` ### hf felica @@ -364,12 +366,12 @@ Check column "offline" for their availability. |`hf felica help `|Y |`This help` |`hf felica list `|Y |`List ISO 18092/FeliCa history` |`hf felica info `|N |`Tag information` -|`hf felica seacinfo `|N |`FeliCa SEAC tag information` |`hf felica raw `|N |`Send raw hex data to tag` |`hf felica rdbl `|N |`read block data from authentication-not-required Service.` |`hf felica reader `|N |`Act like an ISO18092/FeliCa reader` |`hf felica sniff `|N |`Sniff ISO 18092/FeliCa traffic` |`hf felica wrbl `|N |`write block data to an authentication-not-required Service.` +|`hf felica seacauth1 `|N |`FeliCa SEAC Authentication1` |`hf felica dump `|N |`Wait for and try dumping FeliCa` |`hf felica discnodes `|N |`discover Area Code and Service Code nodes.` |`hf felica sim `|N |`Emulate FeliCa Standard from dump file` @@ -537,7 +539,7 @@ Check column "offline" for their availability. |`hf iclass decrypt `|Y |`Decrypt given block data or tag dump file` |`hf iclass managekeys `|Y |`Manage keys to use with iclass commands` |`hf iclass permutekey `|Y |`Permute function from 'heart of darkness' paper` -|`hf iclass sam `|N |`SAM ops: PACS extract + secure channel (scopen/scsend/scclose)` +|`hf iclass sam `|N |`Extract PACS from a HID SAM` ### hf ict @@ -1007,7 +1009,11 @@ Check column "offline" for their availability. |`hw bootloader `|N |`Reboot into bootloader mode` |`hw connect `|Y |`Connect to the device via serial port` |`hw dbg `|N |`Set device side debug level` +|`hw fpga `|N |`Fpga commands` |`hw fpgaoff `|N |`Turn off FPGA on device` +|`hw ant_pm5 `|N |`Control the antennal of pm5` +|`hw qc_pm5 `|N |`Perform QC test for the PM5` +|`hw factorydata `|N |`Get/Set the factory data for Device` |`hw lcd `|N |`Send command/data to LCD` |`hw lcdreset `|N |`Hardware reset LCD` |`hw ping `|N |`Test if the Proxmark3 is responsive` From 20a5cb5e7f8379eb1b5850111a2fc5e5ef449a5a Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Fri, 21 Aug 2026 22:33:05 +0200 Subject: [PATCH 05/12] missing pace files and tests --- client/src/emrtd/emrtd_pace.c | 1488 +++++++++++++++++++++++++++++ client/src/emrtd/emrtd_pace.h | 245 +++++ client/src/emrtd/emrtd_pacetest.c | 682 +++++++++++++ client/src/emrtd/emrtd_pacetest.h | 26 + 4 files changed, 2441 insertions(+) create mode 100644 client/src/emrtd/emrtd_pace.c create mode 100644 client/src/emrtd/emrtd_pace.h create mode 100644 client/src/emrtd/emrtd_pacetest.c create mode 100644 client/src/emrtd/emrtd_pacetest.h diff --git a/client/src/emrtd/emrtd_pace.c b/client/src/emrtd/emrtd_pace.c new file mode 100644 index 000000000..1af3a8674 --- /dev/null +++ b/client/src/emrtd/emrtd_pace.c @@ -0,0 +1,1488 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- +// PACE (Password Authenticated Connection Establishment) primitives for eMRTD +//----------------------------------------------------------------------------- + +#include "emrtd_pace.h" + +#include +#include + +#include +#include +#include +#include +#include + +#include "crypto/libpcrypto.h" // sha1hash, sha256hash, des_encrypt/decrypt, pcrypto_rng_* +#include "ui.h" // PrintAndLogEx +#include "util.h" // sprint_hex_inrow +#include "commonutil.h" // ARRAYLEN + +//----------------------------------------------------------------------------- +// Tables +//----------------------------------------------------------------------------- + +// TR-03110 part 3, table A.1. The OID bodies are what follows the "06 " +// header, i.e. 0.4.0.127.0.7.2.2.4.x.y +static const emrtd_pacealg_t pacealg_table[] = { +// name key agreement mapping cipher keylen oidlen oid + {"DH, Generic Mapping, 3DES-CBC-CBC", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_3DES, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x01}}, + {"DH, Generic Mapping, AES-CMAC-128", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_AES128, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x02}}, + {"DH, Generic Mapping, AES-CMAC-192", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_AES192, 24, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x03}}, + {"DH, Generic Mapping, AES-CMAC-256", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_AES256, 32, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01, 0x04}}, + {"ECDH, Generic Mapping, 3DES-CBC-CBC", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_3DES, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x01}}, + {"ECDH, Generic Mapping, AES-CMAC-128", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_AES128, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x02}}, + {"ECDH, Generic Mapping, AES-CMAC-192", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_AES192, 24, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x03}}, + {"ECDH, Generic Mapping, AES-CMAC-256", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_GM, EMRTD_PACE_CIPHER_AES256, 32, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x04}}, + {"DH, Integrated Mapping, 3DES-CBC-CBC", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_3DES, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x01}}, + {"DH, Integrated Mapping, AES-CMAC-128", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_AES128, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x02}}, + {"DH, Integrated Mapping, AES-CMAC-192", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_AES192, 24, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x03}}, + {"DH, Integrated Mapping, AES-CMAC-256", EMRTD_PACE_KA_DH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_AES256, 32, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x03, 0x04}}, + {"ECDH, Integrated Mapping, 3DES-CBC-CBC", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_3DES, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x01}}, + {"ECDH, Integrated Mapping, AES-CMAC-128", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_AES128, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x02}}, + {"ECDH, Integrated Mapping, AES-CMAC-192", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_AES192, 24, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x03}}, + {"ECDH, Integrated Mapping, AES-CMAC-256", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_IM, EMRTD_PACE_CIPHER_AES256, 32, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x04, 0x04}}, + // Chip Authentication Mapping, TR-03110 part 3, A.1.1 + {"ECDH, CA Mapping, AES-CMAC-128", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_CAM, EMRTD_PACE_CIPHER_AES128, 16, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x06, 0x02}}, + {"ECDH, CA Mapping, AES-CMAC-192", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_CAM, EMRTD_PACE_CIPHER_AES192, 24, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x06, 0x03}}, + {"ECDH, CA Mapping, AES-CMAC-256", EMRTD_PACE_KA_ECDH, EMRTD_PACE_MAP_CAM, EMRTD_PACE_CIPHER_AES256, 32, 10, {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x06, 0x04}}, + {NULL, 0, 0, 0, 0, 0, {0}} +}; + +// TR-03110 part 3, table A.2. +// The curve column is MBEDTLS_ECP_DP_NONE for every curve this tree's mbedtls +// does not carry, see common/mbedtls/config.h. That must stay an explicit +// "unsupported" instead of silently picking a near neighbour. +static const emrtd_pacesdp_t pacesdp_table[] = { +// id name size is_ec mbedtls curve + {0, "1024-bit MODP Group with 160-bit Prime Order Subgroup", 1024, false, MBEDTLS_ECP_DP_NONE}, + {1, "2048-bit MODP Group with 224-bit Prime Order Subgroup", 2048, false, MBEDTLS_ECP_DP_NONE}, + {2, "2048-bit MODP Group with 256-bit Prime Order Subgroup", 2048, false, MBEDTLS_ECP_DP_NONE}, + {8, "NIST P-192 (secp192r1)", 192, true, MBEDTLS_ECP_DP_SECP192R1}, + {9, "BrainpoolP192r1", 192, true, MBEDTLS_ECP_DP_NONE}, + {10, "NIST P-224 (secp224r1)", 224, true, MBEDTLS_ECP_DP_SECP224R1}, + {11, "BrainpoolP224r1", 224, true, MBEDTLS_ECP_DP_NONE}, + {12, "NIST P-256 (secp256r1)", 256, true, MBEDTLS_ECP_DP_SECP256R1}, + {13, "BrainpoolP256r1", 256, true, MBEDTLS_ECP_DP_BP256R1}, + {14, "BrainpoolP320r1", 320, true, MBEDTLS_ECP_DP_NONE}, + {15, "NIST P-384 (secp384r1)", 384, true, MBEDTLS_ECP_DP_SECP384R1}, + {16, "BrainpoolP384r1", 384, true, MBEDTLS_ECP_DP_BP384R1}, + {17, "BrainpoolP512r1", 512, true, MBEDTLS_ECP_DP_BP512R1}, + {18, "NIST P-521 (secp521r1)", 521, true, MBEDTLS_ECP_DP_SECP521R1}, + {32, NULL, 0, false, MBEDTLS_ECP_DP_NONE} +}; + +const emrtd_pacealg_t *emrtd_pace_alg_by_oid(const uint8_t *oid, size_t oidlen) { + for (int i = 0; pacealg_table[i].name != NULL; i++) { + if (pacealg_table[i].oidlen == oidlen && memcmp(pacealg_table[i].oid, oid, oidlen) == 0) { + return &pacealg_table[i]; + } + } + return NULL; +} + +const emrtd_pacesdp_t *emrtd_pace_sdp_by_id(uint8_t id) { + for (int i = 0; pacesdp_table[i].id != 32; i++) { + if (pacesdp_table[i].id == id) { + return &pacesdp_table[i]; + } + } + return NULL; +} + +const char *emrtd_pace_cipher_name(emrtd_pace_cipher_t cipher) { + switch (cipher) { + case EMRTD_PACE_CIPHER_3DES: + return "3DES-CBC-CBC"; + case EMRTD_PACE_CIPHER_AES128: + return "AES-CMAC-128"; + case EMRTD_PACE_CIPHER_AES192: + return "AES-CMAC-192"; + case EMRTD_PACE_CIPHER_AES256: + return "AES-CMAC-256"; + } + return "unknown"; +} + +//----------------------------------------------------------------------------- +// 3DES / ISO 9797-1 helpers +//----------------------------------------------------------------------------- + +void emrtd_des3_encrypt_cbc(uint8_t *iv, const uint8_t *key, const uint8_t *input, size_t inputlen, uint8_t *output) { + mbedtls_des3_context ctx; + mbedtls_des3_set2key_enc(&ctx, key); + mbedtls_des3_crypt_cbc(&ctx, MBEDTLS_DES_ENCRYPT, inputlen, iv, input, output); + mbedtls_des3_free(&ctx); +} + +void emrtd_des3_decrypt_cbc(uint8_t *iv, const uint8_t *key, const uint8_t *input, size_t inputlen, uint8_t *output) { + mbedtls_des3_context ctx; + mbedtls_des3_set2key_dec(&ctx, key); + mbedtls_des3_crypt_cbc(&ctx, MBEDTLS_DES_DECRYPT, inputlen, iv, input, output); + mbedtls_des3_free(&ctx); +} + +size_t emrtd_pad_block(const uint8_t *input, size_t inputlen, size_t blocksize, uint8_t *output) { + if (inputlen) { + memmove(output, input, inputlen); + } + output[inputlen] = 0x80; + size_t padded = inputlen + 1; + while ((padded % blocksize) != 0) { + output[padded++] = 0x00; + } + return padded; +} + +#define EMRTD_RETAIL_MAC_MAXLEN 512 +#define EMRTD_SM_MAC_MAXLEN 576 + +int emrtd_retail_mac(const uint8_t *key, const uint8_t *input, size_t inputlen, uint8_t *output) { + // ISO 9797-1 MAC algorithm 3 with padding method 2, block length 8. + // Takes inspiration from https://github.com/devinvenable/iso9797algorithm3 + uint8_t message[EMRTD_RETAIL_MAC_MAXLEN] = { 0x00 }; + + if (inputlen + 8 > sizeof(message)) { + PrintAndLogEx(ERR, "error (emrtd_retail_mac) input out-of-bounds, %zu bytes", inputlen); + return PM3_EOUTOFBOUND; + } + + const uint8_t *k0 = key; + const uint8_t *k1 = key + 8; + + size_t blocksize = emrtd_pad_block(input, inputlen, 8, message); + + uint8_t intermediate[8] = { 0x00 }; + uint8_t intermediate_des[8] = { 0x00 }; + + for (size_t i = 0; i < (blocksize / 8); i++) { + for (int x = 0; x < 8; x++) { + intermediate[x] ^= message[(i * 8) + x]; + } + des_encrypt(intermediate_des, intermediate, k0); + memcpy(intermediate, intermediate_des, 8); + } + + des_decrypt(intermediate_des, intermediate, k1); + des_encrypt(output, intermediate_des, k0); + return PM3_SUCCESS; +} + +//----------------------------------------------------------------------------- +// Secure messaging session +//----------------------------------------------------------------------------- + +void emrtd_sm_clear(emrtd_session_t *ssn) { + memset(ssn, 0, sizeof(emrtd_session_t)); + ssn->type = EMRTD_SM_NONE; +} + +int emrtd_sm_setup(emrtd_session_t *ssn, emrtd_pace_cipher_t cipher, const uint8_t *ks_enc, const uint8_t *ks_mac) { + size_t keylen; + switch (cipher) { + case EMRTD_PACE_CIPHER_3DES: + ssn->type = EMRTD_SM_3DES; + ssn->ssclen = 8; + keylen = 16; + break; + case EMRTD_PACE_CIPHER_AES128: + ssn->type = EMRTD_SM_AES; + ssn->ssclen = 16; + keylen = 16; + break; + case EMRTD_PACE_CIPHER_AES192: + ssn->type = EMRTD_SM_AES; + ssn->ssclen = 16; + keylen = 24; + break; + case EMRTD_PACE_CIPHER_AES256: + ssn->type = EMRTD_SM_AES; + ssn->ssclen = 16; + keylen = 32; + break; + default: + return PM3_EINVARG; + } + + ssn->keylen = keylen; + memcpy(ssn->ks_enc, ks_enc, keylen); + memcpy(ssn->ks_mac, ks_mac, keylen); + memset(ssn->ssc, 0x00, sizeof(ssn->ssc)); + return PM3_SUCCESS; +} + +size_t emrtd_sm_blocksize(const emrtd_session_t *ssn) { + return (ssn->type == EMRTD_SM_AES) ? 16 : 8; +} + +void emrtd_sm_bump_ssc(emrtd_session_t *ssn) { + PrintAndLogEx(DEBUG, "ssc-b: %s", sprint_hex_inrow(ssn->ssc, ssn->ssclen)); + for (int i = (int)ssn->ssclen - 1; i >= 0; i--) { + ssn->ssc[i]++; + if (ssn->ssc[i] != 0x00) { + break; + } + } + PrintAndLogEx(DEBUG, "ssc-a: %s", sprint_hex_inrow(ssn->ssc, ssn->ssclen)); +} + +static int emrtd_aes_setkey_enc(mbedtls_aes_context *aes, const emrtd_session_t *ssn, const uint8_t *key) { + return mbedtls_aes_setkey_enc(aes, key, ssn->keylen * 8); +} + +// IV for AES secure messaging: E(KSenc, SSC) in ECB mode, ICAO 9303-11 9.8.6.1 +static int emrtd_sm_aes_iv(const emrtd_session_t *ssn, uint8_t *iv) { + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + int res = emrtd_aes_setkey_enc(&aes, ssn, ssn->ks_enc); + if (res == 0) { + res = mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, ssn->ssc, iv); + } + mbedtls_aes_free(&aes); + return (res == 0) ? PM3_SUCCESS : PM3_ESOFT; +} + +// The MAC algorithm that belongs to a cipher, applied to the data as given. +// 3DES is ISO 9797-1 MAC algorithm 3, which pads internally; AES is CMAC, which +// takes any length. Used directly for the PACE authentication tokens. +static int emrtd_mac_raw(emrtd_pace_cipher_t cipher, const uint8_t *key, size_t keylen, + const uint8_t *input, size_t inputlen, uint8_t *mac) { + if (cipher == EMRTD_PACE_CIPHER_3DES) { + return emrtd_retail_mac(key, input, inputlen, mac); + } + + // Note: libpcrypto's aes_cmac()/aes_cmac8() are not usable here. The former + // is AES-CMAC-PRF-128 (RFC 4615) and the latter truncates by taking every + // second byte, neither of which is what ICAO 9303-11 asks for. + mbedtls_cipher_type_t ct; + switch (keylen) { + case 16: + ct = MBEDTLS_CIPHER_AES_128_ECB; + break; + case 24: + ct = MBEDTLS_CIPHER_AES_192_ECB; + break; + case 32: + ct = MBEDTLS_CIPHER_AES_256_ECB; + break; + default: + return PM3_EINVARG; + } + + const mbedtls_cipher_info_t *ci = mbedtls_cipher_info_from_type(ct); + if (ci == NULL) { + return PM3_ESOFT; + } + + uint8_t full[16] = { 0x00 }; + if (mbedtls_cipher_cmac(ci, key, keylen * 8, input, inputlen, full) != 0) { + return PM3_ESOFT; + } + + // ICAO 9303-11 9.8.6 asks for a MAC length of 8 bytes + memcpy(mac, full, 8); + return PM3_SUCCESS; +} + +int emrtd_sm_mac(const emrtd_session_t *ssn, const uint8_t *input, size_t inputlen, uint8_t *mac) { + if (ssn->type == EMRTD_SM_3DES) { + // the retail MAC pads the input itself, which is step e.2 + return emrtd_mac_raw(EMRTD_PACE_CIPHER_3DES, ssn->ks_mac, ssn->keylen, input, inputlen, mac); + } + + if (ssn->type != EMRTD_SM_AES) { + return PM3_EINVARG; + } + + // ICAO 9303-11 9.8.6.1 step e.2: "Concatenate SSC and M and add padding". + // CMAC does not need the padding, but the step applies to AES all the same, + // verified against a document doing PACE with AES-CMAC-256 (a chip that is + // sent the unpadded input answers 6988, incorrect SM data object). + uint8_t padded[EMRTD_SM_MAC_MAXLEN] = { 0x00 }; + if ((inputlen + 16) > sizeof(padded)) { + PrintAndLogEx(ERR, "error (emrtd_sm_mac) input out-of-bounds, %zu bytes", inputlen); + return PM3_EOUTOFBOUND; + } + + size_t paddedlen = emrtd_pad_block(input, inputlen, 16, padded); + return emrtd_mac_raw(EMRTD_PACE_CIPHER_AES128, ssn->ks_mac, ssn->keylen, padded, paddedlen, mac); +} + +int emrtd_sm_encrypt(const emrtd_session_t *ssn, const uint8_t *input, size_t inputlen, uint8_t *output) { + if (ssn->type == EMRTD_SM_3DES) { + uint8_t iv[8] = { 0x00 }; + emrtd_des3_encrypt_cbc(iv, ssn->ks_enc, input, inputlen, output); + return PM3_SUCCESS; + } + + if (ssn->type != EMRTD_SM_AES) { + return PM3_EINVARG; + } + + uint8_t iv[16] = { 0x00 }; + int res = emrtd_sm_aes_iv(ssn, iv); + if (res != PM3_SUCCESS) { + return res; + } + + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + res = emrtd_aes_setkey_enc(&aes, ssn, ssn->ks_enc); + if (res == 0) { + res = mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, inputlen, iv, input, output); + } + mbedtls_aes_free(&aes); + return (res == 0) ? PM3_SUCCESS : PM3_ESOFT; +} + +int emrtd_sm_decrypt(const emrtd_session_t *ssn, const uint8_t *input, size_t inputlen, uint8_t *output) { + if (ssn->type == EMRTD_SM_3DES) { + uint8_t iv[8] = { 0x00 }; + emrtd_des3_decrypt_cbc(iv, ssn->ks_enc, input, inputlen, output); + return PM3_SUCCESS; + } + + if (ssn->type != EMRTD_SM_AES) { + return PM3_EINVARG; + } + + uint8_t iv[16] = { 0x00 }; + int res = emrtd_sm_aes_iv(ssn, iv); + if (res != PM3_SUCCESS) { + return res; + } + + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + res = mbedtls_aes_setkey_dec(&aes, ssn->ks_enc, ssn->keylen * 8); + if (res == 0) { + res = mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, inputlen, iv, input, output); + } + mbedtls_aes_free(&aes); + return (res == 0) ? PM3_SUCCESS : PM3_ESOFT; +} + +//----------------------------------------------------------------------------- +// BER-TLV +//----------------------------------------------------------------------------- + +bool emrtd_tlv_next(const uint8_t **cur, const uint8_t *end, uint32_t *tag, const uint8_t **value, size_t *valuelen) { + const uint8_t *p = *cur; + + if (p >= end) { + return false; + } + + uint32_t t = *p++; + if ((t & 0x1F) == 0x1F) { + // multi byte tag + do { + if (p >= end || (t > 0x00FFFFFF)) { + return false; + } + t = (t << 8) | *p; + } while ((*p++ & 0x80) != 0); + } + + if (p >= end) { + return false; + } + + size_t len = *p++; + if (len > 0x80) { + size_t lenlen = len & 0x7F; + if ((lenlen > 4) || ((size_t)(end - p) < lenlen)) { + return false; + } + len = 0; + for (size_t i = 0; i < lenlen; i++) { + len = (len << 8) | *p++; + } + } else if (len == 0x80) { + // indefinite length, not valid in the structures we parse + return false; + } + + if ((size_t)(end - p) < len) { + return false; + } + + *tag = t; + *value = p; + *valuelen = len; + *cur = p + len; + return true; +} + +size_t emrtd_tlv_write_header(uint8_t *out, size_t outlen, uint32_t tag, size_t len) { + size_t taglen = (tag > 0xFF) ? 2 : 1; + size_t lenlen; + + if (len < 0x80) { + lenlen = 1; + } else if (len <= 0xFF) { + lenlen = 2; + } else if (len <= 0xFFFF) { + lenlen = 3; + } else { + return 0; + } + + if (outlen < taglen + lenlen) { + return 0; + } + + size_t o = 0; + if (taglen == 2) { + out[o++] = (tag >> 8) & 0xFF; + } + out[o++] = tag & 0xFF; + + if (lenlen == 1) { + out[o++] = (uint8_t)len; + } else if (lenlen == 2) { + out[o++] = 0x81; + out[o++] = (uint8_t)len; + } else { + out[o++] = 0x82; + out[o++] = (uint8_t)(len >> 8); + out[o++] = (uint8_t)len; + } + return o; +} + +//----------------------------------------------------------------------------- +// EF_CardAccess +//----------------------------------------------------------------------------- + +#define ASN1_TAG_INTEGER 0x02 +#define ASN1_TAG_OID 0x06 +#define ASN1_TAG_SEQUENCE 0x30 +#define ASN1_TAG_SET 0x31 + +static bool emrtd_asn1_uint(const uint8_t *value, size_t valuelen, uint32_t *out) { + if ((valuelen == 0) || (valuelen > 5)) { + return false; + } + // skip a single leading zero used to keep the value positive + if ((valuelen == 5) && (value[0] != 0x00)) { + return false; + } + uint32_t v = 0; + for (size_t i = 0; i < valuelen; i++) { + v = (v << 8) | value[i]; + } + *out = v; + return true; +} + +// The PACEDomainParameterInfo protocol OIDs, TR-03110 part 3, A.1.1. +// 0.4.0.127.0.7.2.2.4.1 (DH) and .2 (ECDH) +static const uint8_t oid_pace_dh_dp[] = {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x01}; +static const uint8_t oid_pace_ecdh_dp[] = {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02}; + +static void emrtd_pace_classify(emrtd_paceinfo_t *info) { + info->supported = false; + + if (info->alg == NULL) { + info->reason = "unknown protocol OID"; + return; + } + + if (info->alg->ka == EMRTD_PACE_KA_DH) { + // MBEDTLS_DHM_C is deliberately left out of common/mbedtls/config.h and + // enabling it is out of scope, so DH (MODP) mapping cannot be done here. + info->reason = "unsupported (DH not compiled in)"; + return; + } + + if (info->alg->mapping == EMRTD_PACE_MAP_IM) { + info->reason = "unsupported (Integrated Mapping not implemented)"; + return; + } + + if (info->has_param == false) { + info->reason = "no standardized domain parameter id"; + return; + } + + if (info->sdp == NULL) { + info->reason = "unknown domain parameter id"; + return; + } + + if (info->sdp->is_ec == false) { + info->reason = "unsupported (MODP group, DH not compiled in)"; + return; + } + + if (info->sdp->curve == MBEDTLS_ECP_DP_NONE) { + info->reason = "unsupported curve (not compiled into mbedtls)"; + return; + } + + info->supported = true; + info->reason = NULL; +} + +static int emrtd_pace_cipher_rank(emrtd_pace_cipher_t cipher) { + switch (cipher) { + case EMRTD_PACE_CIPHER_3DES: + return 1; + case EMRTD_PACE_CIPHER_AES128: + return 2; + case EMRTD_PACE_CIPHER_AES192: + return 3; + case EMRTD_PACE_CIPHER_AES256: + return 4; + } + return 0; +} + +// Chip Authentication Mapping would be the stronger choice, since it proves the +// chip is not a clone. We cannot complete that proof yet (see +// emrtd_pace_cam_verify), so a CAM session buys nothing over a Generic Mapping +// one and costs an EF_DG14 read. Prefer GM until the proof works, and fall back +// to CAM only for documents that offer nothing else. +int emrtd_pace_rank(const emrtd_paceinfo_t *info) { + if ((info->supported == false) || (info->alg == NULL)) { + return 0; + } + int rank = emrtd_pace_cipher_rank(info->alg->cipher) * 2; + if (info->alg->mapping == EMRTD_PACE_MAP_GM) { + rank += 1; + } + return rank; +} + +// One SecurityInfo: SEQUENCE { OID protocol, ... } +static void emrtd_pace_parse_securityinfo(const uint8_t *seq, size_t seqlen, emrtd_cardaccess_t *out) { + const uint8_t *cur = seq; + const uint8_t *end = seq + seqlen; + uint32_t tag; + const uint8_t *val; + size_t vlen; + + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + return; + } + + if ((tag != ASN1_TAG_OID) || (vlen == 0) || (vlen > EMRTD_PACE_OID_MAXLEN)) { + return; + } + + // PACEDomainParameterInfo carries the algorithm identifier instead of a + // version number. We only report it, the parameters we act on come from + // the PACEInfo entries. + bool is_domain_param = ((vlen == sizeof(oid_pace_dh_dp)) && + ((memcmp(val, oid_pace_dh_dp, vlen) == 0) || + (memcmp(val, oid_pace_ecdh_dp, vlen) == 0))); + + if (out->count >= EMRTD_PACE_MAX_INFOS) { + return; + } + + emrtd_paceinfo_t *info = &out->infos[out->count]; + memset(info, 0, sizeof(emrtd_paceinfo_t)); + memcpy(info->oid, val, vlen); + info->oidlen = vlen; + info->alg = emrtd_pace_alg_by_oid(val, vlen); + + if (is_domain_param) { + // SEQUENCE { OID, AlgorithmIdentifier, INTEGER parameterId OPTIONAL } + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + return; + } + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) && (tag == ASN1_TAG_INTEGER)) { + uint32_t v = 0; + if (emrtd_asn1_uint(val, vlen, &v) && (v <= 0xFF)) { + info->has_param = true; + info->param_id = (uint8_t)v; + info->sdp = emrtd_pace_sdp_by_id(info->param_id); + } + } + info->supported = false; + info->reason = "domain parameter definition, informational"; + out->count++; + return; + } + + // PACEInfo ::= SEQUENCE { protocol OID, version INTEGER, parameterId INTEGER OPTIONAL } + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + return; + } + if (tag != ASN1_TAG_INTEGER) { + return; + } + if (emrtd_asn1_uint(val, vlen, &info->version) == false) { + return; + } + + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) && (tag == ASN1_TAG_INTEGER)) { + uint32_t v = 0; + if (emrtd_asn1_uint(val, vlen, &v) && (v <= 0xFF)) { + info->has_param = true; + info->param_id = (uint8_t)v; + info->sdp = emrtd_pace_sdp_by_id(info->param_id); + } + } + + emrtd_pace_classify(info); + out->count++; +} + +int emrtd_pace_parse_cardaccess(const uint8_t *data, size_t datalen, emrtd_cardaccess_t *out) { + memset(out, 0, sizeof(emrtd_cardaccess_t)); + out->best = -1; + + if ((data == NULL) || (datalen == 0)) { + return PM3_EINVARG; + } + + const uint8_t *cur = data; + const uint8_t *end = data + datalen; + uint32_t tag; + const uint8_t *val; + size_t vlen; + + // EF_CardAccess is a SET OF SecurityInfo. Accept a SEQUENCE too, some + // documents in the wild get this wrong. + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + PrintAndLogEx(DEBUG, "EF_CardAccess: not a valid TLV"); + return PM3_ESOFT; + } + + if ((tag != ASN1_TAG_SET) && (tag != ASN1_TAG_SEQUENCE)) { + PrintAndLogEx(DEBUG, "EF_CardAccess: unexpected top level tag %02X", tag); + return PM3_ESOFT; + } + + const uint8_t *icur = val; + const uint8_t *iend = val + vlen; + + while (emrtd_tlv_next(&icur, iend, &tag, &val, &vlen)) { + if (tag != ASN1_TAG_SEQUENCE) { + continue; + } + emrtd_pace_parse_securityinfo(val, vlen, out); + } + + if (out->count == 0) { + return PM3_ESOFT; + } + + // Pick the strongest usable algorithm + int bestrank = 0; + for (size_t i = 0; i < out->count; i++) { + int rank = emrtd_pace_rank(&out->infos[i]); + if (rank > bestrank) { + bestrank = rank; + out->best = (int)i; + } + } + + return PM3_SUCCESS; +} + +//----------------------------------------------------------------------------- +// PACE key derivation +//----------------------------------------------------------------------------- + +char emrtd_calculate_check_digit(const char *data) { + const int mrz_weight[] = {7, 3, 1}; + int value, cd = 0; + + for (size_t i = 0; i < strlen(data); i++) { + char d = data[i]; + if ('A' <= d && d <= 'Z') { + value = d - 55; + } else if ('a' <= d && d <= 'z') { + value = d - 87; + } else if (d == '<') { + value = 0; + } else { // Numbers + value = d - 48; + } + cd += value * mrz_weight[i % 3]; + } + return cd % 10; +} + +int emrtd_pace_kmrz(const char *documentnumber, const char *dob, const char *expiry, char *out, size_t outlen) { + if ((documentnumber == NULL) || (dob == NULL) || (expiry == NULL)) { + return PM3_EINVARG; + } + + char docnumcd = emrtd_calculate_check_digit(documentnumber); + char dobcd = emrtd_calculate_check_digit(dob); + char expirycd = emrtd_calculate_check_digit(expiry); + + int n = snprintf(out, outlen, "%s%i%s%i%s%i", documentnumber, docnumcd, dob, dobcd, expiry, expirycd); + if ((n < 0) || ((size_t)n >= outlen)) { + return PM3_EOUTOFBOUND; + } + return PM3_SUCCESS; +} + +int emrtd_pace_password_mrz(const char *documentnumber, const char *dob, const char *expiry, uint8_t *k, size_t *klen) { + char kmrz[25] = { 0x00 }; + + int res = emrtd_pace_kmrz(documentnumber, dob, expiry, kmrz, sizeof(kmrz)); + if (res != PM3_SUCCESS) { + return res; + } + + PrintAndLogEx(DEBUG, "kmrz.............. %s", kmrz); + sha1hash((uint8_t *)kmrz, strlen(kmrz), k); + *klen = 20; + return PM3_SUCCESS; +} + +int emrtd_pace_password_can(const char *can, uint8_t *k, size_t *klen) { + if (can == NULL) { + return PM3_EINVARG; + } + + size_t len = strlen(can); + if ((len == 0) || (len > EMRTD_PACE_SECRET_MAXLEN)) { + return PM3_EINVARG; + } + + // The CAN is used as is, ICAO 9303-11 9.7.2 + memcpy(k, can, len); + *klen = len; + return PM3_SUCCESS; +} + +int emrtd_pace_kdf(emrtd_pace_cipher_t cipher, const uint8_t *k, size_t klen, uint32_t counter, uint8_t *out, size_t *outlen) { + // TR-03110 part 3, A.2.3 + uint8_t buf[EMRTD_PACE_SECRET_MAXLEN + 4] = { 0x00 }; + + if (klen > EMRTD_PACE_SECRET_MAXLEN) { + PrintAndLogEx(ERR, "error (emrtd_pace_kdf) secret out-of-bounds, %zu bytes", klen); + return PM3_EOUTOFBOUND; + } + + memcpy(buf, k, klen); + buf[klen + 0] = (counter >> 24) & 0xFF; + buf[klen + 1] = (counter >> 16) & 0xFF; + buf[klen + 2] = (counter >> 8) & 0xFF; + buf[klen + 3] = counter & 0xFF; + + uint8_t hash[64] = { 0x00 }; + size_t keylen; + + switch (cipher) { + case EMRTD_PACE_CIPHER_3DES: + case EMRTD_PACE_CIPHER_AES128: + sha1hash(buf, klen + 4, hash); + keylen = 16; + break; + case EMRTD_PACE_CIPHER_AES192: + sha256hash(buf, klen + 4, hash); + keylen = 24; + break; + case EMRTD_PACE_CIPHER_AES256: + sha256hash(buf, klen + 4, hash); + keylen = 32; + break; + default: + return PM3_EINVARG; + } + + memcpy(out, hash, keylen); + + if (cipher == EMRTD_PACE_CIPHER_3DES) { + // two key 3DES, odd parity per byte + mbedtls_des_key_set_parity(out); + mbedtls_des_key_set_parity(out + 8); + } + + *outlen = keylen; + return PM3_SUCCESS; +} + +int emrtd_pace_decrypt_nonce(emrtd_pace_cipher_t cipher, const uint8_t *kpi, const uint8_t *z, size_t zlen, uint8_t *s) { + size_t blocksize = (cipher == EMRTD_PACE_CIPHER_3DES) ? 8 : 16; + + if ((zlen == 0) || ((zlen % blocksize) != 0) || (zlen > 32)) { + PrintAndLogEx(ERR, "PACE: bad encrypted nonce length %zu", zlen); + return PM3_EINVARG; + } + + if (cipher == EMRTD_PACE_CIPHER_3DES) { + uint8_t iv[8] = { 0x00 }; + emrtd_des3_decrypt_cbc(iv, kpi, z, zlen, s); + return PM3_SUCCESS; + } + + size_t keybits; + switch (cipher) { + case EMRTD_PACE_CIPHER_3DES: + // handled above + return PM3_EINVARG; + case EMRTD_PACE_CIPHER_AES128: + keybits = 128; + break; + case EMRTD_PACE_CIPHER_AES192: + keybits = 192; + break; + case EMRTD_PACE_CIPHER_AES256: + keybits = 256; + break; + default: + return PM3_EINVARG; + } + + uint8_t iv[16] = { 0x00 }; + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + int res = mbedtls_aes_setkey_dec(&aes, kpi, keybits); + if (res == 0) { + res = mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, zlen, iv, z, s); + } + mbedtls_aes_free(&aes); + return (res == 0) ? PM3_SUCCESS : PM3_ESOFT; +} + +//----------------------------------------------------------------------------- +// ECDH with Generic Mapping +//----------------------------------------------------------------------------- + +size_t emrtd_pace_ec_pointlen(mbedtls_ecp_group_id curve) { + mbedtls_ecp_group grp; + mbedtls_ecp_group_init(&grp); + + size_t len = 0; + if (mbedtls_ecp_group_load(&grp, curve) == 0) { + len = 1 + (2 * ((grp.pbits + 7) / 8)); + } + + mbedtls_ecp_group_free(&grp); + return len; +} + +static int emrtd_ecp_write(const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt, uint8_t *out, size_t *outlen) { + size_t written = 0; + int res = mbedtls_ecp_point_write_binary(grp, pt, MBEDTLS_ECP_PF_UNCOMPRESSED, &written, out, EMRTD_EC_POINT_MAXLEN); + if (res != 0) { + return PM3_ESOFT; + } + *outlen = written; + return PM3_SUCCESS; +} + +// Note: mbedtls builds the standard groups out of static const MPI limbs, so +// grp->G must never be written to. A caller supplied generator is parsed into +// a point of its own and handed back through *out instead. +static int emrtd_ecp_group_with_base(mbedtls_ecp_group *grp, mbedtls_ecp_group_id curve, + const uint8_t *base, size_t baselen, + mbedtls_ecp_point *custom, const mbedtls_ecp_point **out) { + if (mbedtls_ecp_group_load(grp, curve) != 0) { + PrintAndLogEx(ERR, "PACE: failed to load curve"); + return PM3_ESOFT; + } + + if (out == NULL) { + return PM3_SUCCESS; + } + + if (base == NULL) { + *out = &grp->G; + return PM3_SUCCESS; + } + + if (mbedtls_ecp_point_read_binary(grp, custom, base, baselen) != 0) { + PrintAndLogEx(ERR, "PACE: failed to parse mapped generator"); + return PM3_ESOFT; + } + + if (mbedtls_ecp_check_pubkey(grp, custom) != 0) { + PrintAndLogEx(ERR, "PACE: mapped generator is not on the curve"); + return PM3_ESOFT; + } + + *out = custom; + return PM3_SUCCESS; +} + +int emrtd_pace_ec_pubkey(mbedtls_ecp_group_id curve, const uint8_t *base, size_t baselen, + const uint8_t *priv, size_t privlen, uint8_t *pub, size_t *publen) { + mbedtls_ecp_group grp; + mbedtls_mpi d; + mbedtls_ecp_point Q, custom; + const mbedtls_ecp_point *G = NULL; + + mbedtls_ecp_group_init(&grp); + mbedtls_mpi_init(&d); + mbedtls_ecp_point_init(&Q); + mbedtls_ecp_point_init(&custom); + + int res = emrtd_ecp_group_with_base(&grp, curve, base, baselen, &custom, &G); + if (res != PM3_SUCCESS) { + goto out; + } + + res = PM3_ESOFT; + if (mbedtls_mpi_read_binary(&d, priv, privlen) != 0) { + goto out; + } + if (mbedtls_ecp_mul(&grp, &Q, &d, G, NULL, NULL) != 0) { + goto out; + } + res = emrtd_ecp_write(&grp, &Q, pub, publen); + +out: + mbedtls_ecp_point_free(&custom); + mbedtls_ecp_point_free(&Q); + mbedtls_mpi_free(&d); + mbedtls_ecp_group_free(&grp); + return res; +} + +int emrtd_pace_ec_keygen(mbedtls_ecp_group_id curve, const uint8_t *base, size_t baselen, + uint8_t *priv, size_t *privlen, uint8_t *pub, size_t *publen) { + mbedtls_ecp_group grp; + mbedtls_mpi d; + mbedtls_ecp_point Q, custom; + const mbedtls_ecp_point *G = NULL; + pcrypto_rng_t rng = {0}; + + mbedtls_ecp_group_init(&grp); + mbedtls_mpi_init(&d); + mbedtls_ecp_point_init(&Q); + mbedtls_ecp_point_init(&custom); + + int res = pcrypto_rng_init(&rng, (const uint8_t *)"emrtd-pace", 10); + if (res != PM3_SUCCESS) { + goto out; + } + + res = emrtd_ecp_group_with_base(&grp, curve, base, baselen, &custom, &G); + if (res != PM3_SUCCESS) { + goto out; + } + + res = PM3_ESOFT; + if (mbedtls_ecp_gen_keypair_base(&grp, G, &d, &Q, mbedtls_ctr_drbg_random, &rng.ctr_drbg) != 0) { + PrintAndLogEx(ERR, "PACE: ephemeral key generation failed"); + goto out; + } + + *privlen = (grp.nbits + 7) / 8; + if (mbedtls_mpi_write_binary(&d, priv, *privlen) != 0) { + goto out; + } + + res = emrtd_ecp_write(&grp, &Q, pub, publen); + +out: + pcrypto_rng_free(&rng); + mbedtls_ecp_point_free(&custom); + mbedtls_ecp_point_free(&Q); + mbedtls_mpi_free(&d); + mbedtls_ecp_group_free(&grp); + return res; +} + +int emrtd_pace_ec_gm(mbedtls_ecp_group_id curve, const uint8_t *s, size_t slen, + const uint8_t *priv, size_t privlen, const uint8_t *pk_ic, size_t pk_ic_len, + uint8_t *mapped, size_t *mappedlen) { + mbedtls_ecp_group grp; + mbedtls_mpi d, sm, one; + mbedtls_ecp_point PK, H, G; + + mbedtls_ecp_group_init(&grp); + mbedtls_mpi_init(&d); + mbedtls_mpi_init(&sm); + mbedtls_mpi_init(&one); + mbedtls_ecp_point_init(&PK); + mbedtls_ecp_point_init(&H); + mbedtls_ecp_point_init(&G); + + int res = emrtd_ecp_group_with_base(&grp, curve, NULL, 0, NULL, NULL); + if (res != PM3_SUCCESS) { + goto out; + } + + res = PM3_ESOFT; + if (mbedtls_ecp_point_read_binary(&grp, &PK, pk_ic, pk_ic_len) != 0) { + PrintAndLogEx(ERR, "PACE: chip mapping key is not a valid point"); + goto out; + } + if (mbedtls_ecp_check_pubkey(&grp, &PK) != 0) { + PrintAndLogEx(ERR, "PACE: chip mapping key is not on the curve"); + goto out; + } + if (mbedtls_mpi_read_binary(&d, priv, privlen) != 0) { + goto out; + } + if (mbedtls_mpi_read_binary(&sm, s, slen) != 0) { + goto out; + } + if (mbedtls_mpi_lset(&one, 1) != 0) { + goto out; + } + + // H = x * PK_IC + if (mbedtls_ecp_mul(&grp, &H, &d, &PK, NULL, NULL) != 0) { + goto out; + } + + // G' = s*G + H + if (mbedtls_ecp_muladd(&grp, &G, &sm, &grp.G, &one, &H) != 0) { + goto out; + } + + if (mbedtls_ecp_is_zero(&G)) { + PrintAndLogEx(ERR, "PACE: mapped generator is the point at infinity"); + goto out; + } + + res = emrtd_ecp_write(&grp, &G, mapped, mappedlen); + +out: + mbedtls_ecp_point_free(&G); + mbedtls_ecp_point_free(&H); + mbedtls_ecp_point_free(&PK); + mbedtls_mpi_free(&one); + mbedtls_mpi_free(&sm); + mbedtls_mpi_free(&d); + mbedtls_ecp_group_free(&grp); + return res; +} + +int emrtd_pace_ec_shared_x(mbedtls_ecp_group_id curve, const uint8_t *priv, size_t privlen, + const uint8_t *pk_ic, size_t pk_ic_len, uint8_t *out, size_t *outlen) { + mbedtls_ecp_group grp; + mbedtls_mpi d; + mbedtls_ecp_point PK, K; + + mbedtls_ecp_group_init(&grp); + mbedtls_mpi_init(&d); + mbedtls_ecp_point_init(&PK); + mbedtls_ecp_point_init(&K); + + int res = emrtd_ecp_group_with_base(&grp, curve, NULL, 0, NULL, NULL); + if (res != PM3_SUCCESS) { + goto out; + } + + res = PM3_ESOFT; + if (mbedtls_ecp_point_read_binary(&grp, &PK, pk_ic, pk_ic_len) != 0) { + goto out; + } + if (mbedtls_ecp_check_pubkey(&grp, &PK) != 0) { + PrintAndLogEx(ERR, "PACE: chip agreement key is not on the curve"); + goto out; + } + if (mbedtls_mpi_read_binary(&d, priv, privlen) != 0) { + goto out; + } + if (mbedtls_ecp_mul(&grp, &K, &d, &PK, NULL, NULL) != 0) { + goto out; + } + if (mbedtls_ecp_is_zero(&K)) { + PrintAndLogEx(ERR, "PACE: shared secret is the point at infinity"); + goto out; + } + + // ICAO 9303-11 4.4.3.3, only the x coordinate is used + *outlen = (grp.pbits + 7) / 8; + if (mbedtls_mpi_write_binary(&K.X, out, *outlen) != 0) { + goto out; + } + res = PM3_SUCCESS; + +out: + mbedtls_ecp_point_free(&K); + mbedtls_ecp_point_free(&PK); + mbedtls_mpi_free(&d); + mbedtls_ecp_group_free(&grp); + return res; +} + +int emrtd_pace_token(const emrtd_pacealg_t *alg, const uint8_t *ks_mac, + const uint8_t *pubkey, size_t pubkeylen, uint8_t *token) { + // ICAO 9303-11 4.4.3.4: + // T = MAC(KSmac, 7F49 || 06 || 86 ) + uint8_t inner[EMRTD_EC_POINT_MAXLEN + 32] = { 0x00 }; + size_t o = 0; + + o += emrtd_tlv_write_header(inner + o, sizeof(inner) - o, 0x06, alg->oidlen); + memcpy(inner + o, alg->oid, alg->oidlen); + o += alg->oidlen; + + size_t hdr = emrtd_tlv_write_header(inner + o, sizeof(inner) - o, 0x86, pubkeylen); + if ((hdr == 0) || (o + hdr + pubkeylen > sizeof(inner))) { + return PM3_EOUTOFBOUND; + } + o += hdr; + memcpy(inner + o, pubkey, pubkeylen); + o += pubkeylen; + + uint8_t data[sizeof(inner) + 8] = { 0x00 }; + size_t dlen = emrtd_tlv_write_header(data, sizeof(data), 0x7F49, o); + if (dlen == 0) { + return PM3_EOUTOFBOUND; + } + memcpy(data + dlen, inner, o); + dlen += o; + + PrintAndLogEx(DEBUG, "token input....... %s", sprint_hex_inrow(data, dlen)); + + // The token is the plain MAC of the data block, it carries no SSC and gets + // none of the secure messaging padding of ICAO 9303-11 9.8.6.1 step e.2 + return emrtd_mac_raw(alg->cipher, ks_mac, alg->keylen, data, dlen, token); +} + +//----------------------------------------------------------------------------- +// Chip Authentication Mapping +//----------------------------------------------------------------------------- + +// TR-03110 part 3, A.1.1.1: id-PK-ECDH is 0.4.0.127.0.7.2.2.1.2 +static const uint8_t oid_pk_ecdh[] = {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x01, 0x02}; + +#define ASN1_TAG_BITSTRING 0x03 + +int emrtd_pace_find_ca_pubkey(const uint8_t *data, size_t datalen, size_t index, uint8_t *pub, size_t *publen) { + if ((data == NULL) || (datalen == 0)) { + return PM3_EINVARG; + } + + const uint8_t *cur = data; + const uint8_t *end = data + datalen; + uint32_t tag = 0; + const uint8_t *val = NULL; + size_t vlen = 0; + + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + return PM3_ESOFT; + } + + // EF_DG14 wraps the SET in tag 6E, EF_CardSecurity hands us the SET directly + if (tag == 0x6E) { + cur = val; + end = val + vlen; + if (emrtd_tlv_next(&cur, end, &tag, &val, &vlen) == false) { + return PM3_ESOFT; + } + } + + if ((tag != ASN1_TAG_SET) && (tag != ASN1_TAG_SEQUENCE)) { + return PM3_ESOFT; + } + + const uint8_t *icur = val; + const uint8_t *iend = val + vlen; + size_t seen = 0; + + // SET OF SecurityInfo, we want ChipAuthenticationPublicKeyInfo + while (emrtd_tlv_next(&icur, iend, &tag, &val, &vlen)) { + + if (tag != ASN1_TAG_SEQUENCE) { + continue; + } + + const uint8_t *scur = val; + const uint8_t *send = val + vlen; + const uint8_t *sval = NULL; + size_t svlen = 0; + uint32_t stag = 0; + + if (emrtd_tlv_next(&scur, send, &stag, &sval, &svlen) == false) { + continue; + } + if ((stag != ASN1_TAG_OID) || (svlen != sizeof(oid_pk_ecdh)) || + (memcmp(sval, oid_pk_ecdh, svlen) != 0)) { + continue; + } + + // chipAuthenticationPublicKey ::= SubjectPublicKeyInfo + if ((emrtd_tlv_next(&scur, send, &stag, &sval, &svlen) == false) || (stag != ASN1_TAG_SEQUENCE)) { + continue; + } + + const uint8_t *kcur = sval; + const uint8_t *kend = sval + svlen; + + // AlgorithmIdentifier, skipped. The curve has to match the one PACE + // negotiated anyway, and that is what the caller checks against. + if (emrtd_tlv_next(&kcur, kend, &stag, &sval, &svlen) == false) { + continue; + } + + if ((emrtd_tlv_next(&kcur, kend, &stag, &sval, &svlen) == false) || (stag != ASN1_TAG_BITSTRING)) { + continue; + } + + // first byte of a BIT STRING is the number of unused bits + if ((svlen < 2) || (sval[0] != 0x00)) { + continue; + } + + if ((svlen - 1) > EMRTD_EC_POINT_MAXLEN) { + PrintAndLogEx(ERR, "error (emrtd_pace_find_ca_pubkey) key out-of-bounds, %zu bytes", svlen - 1); + return PM3_EOUTOFBOUND; + } + + if (seen++ < index) { + continue; + } + + memcpy(pub, sval + 1, svlen - 1); + *publen = svlen - 1; + return PM3_SUCCESS; + } + + return PM3_ESOFT; +} + +static const char *cam_encnames[] = { "CBC zero IV", "ECB", "CBC IV=E(KSenc,0)", "CBC IV=E(KSenc,1)", "not encrypted" }; +#define CAM_ENC_VARIANTS 5 + +// One candidate decryption of DO'8A'. Returns PM3_SUCCESS when it produced +// something, which says nothing about whether it is the right something. +static int emrtd_cam_decrypt(const emrtd_session_t *ssn, int variant, uint8_t *plain) { + + if (variant == 4) { + memcpy(plain, ssn->cam.enc_data, ssn->cam.enc_datalen); + return PM3_SUCCESS; + } + + mbedtls_aes_context aes; + mbedtls_aes_init(&aes); + + int mres = mbedtls_aes_setkey_dec(&aes, ssn->ks_enc, ssn->keylen * 8); + + if ((mres == 0) && (variant == 1)) { + for (size_t o = 0; (o < ssn->cam.enc_datalen) && (mres == 0); o += 16) { + mres = mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_DECRYPT, ssn->cam.enc_data + o, plain + o); + } + } else if (mres == 0) { + uint8_t iv[16] = { 0x00 }; + + if (variant >= 2) { + // the secure messaging IV construction, over the first two SSC values + uint8_t ssc[16] = { 0x00 }; + ssc[15] = (variant == 3) ? 0x01 : 0x00; + + mbedtls_aes_context ecb; + mbedtls_aes_init(&ecb); + if (mbedtls_aes_setkey_enc(&ecb, ssn->ks_enc, ssn->keylen * 8) == 0) { + mbedtls_aes_crypt_ecb(&ecb, MBEDTLS_AES_ENCRYPT, ssc, iv); + } + mbedtls_aes_free(&ecb); + } + + mres = mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, ssn->cam.enc_datalen, iv, + ssn->cam.enc_data, plain); + } + + mbedtls_aes_free(&aes); + return (mres == 0) ? PM3_SUCCESS : PM3_ESOFT; +} + +// Compares the part of a CBC plaintext that does not depend on the IV. +// Decrypting block i>0 uses only ciphertext, so everything past the first block +// is fixed no matter what IV the chip used. That makes it possible to confirm +// what CA_IC contains while still not knowing how the IV is built. +static bool emrtd_cam_tail_matches(const uint8_t *a, const uint8_t *b, size_t len) { + return (len > 16) && (memcmp(a + 16, b + 16, len - 16) == 0); +} + +void emrtd_pace_cam_dump(const emrtd_session_t *ssn, const uint8_t *pk_icc, size_t pk_icc_len) { + const emrtd_cam_t *cam = &ssn->cam; + + PrintAndLogEx(INFO, "CAM DO'8A' (%zu)... %s", cam->enc_datalen, + sprint_hex_inrow(cam->enc_data, cam->enc_datalen)); + PrintAndLogEx(INFO, "CAM PK.Map.IC..... %s", sprint_hex_inrow(cam->pk_map_ic, cam->pk_map_iclen)); + PrintAndLogEx(INFO, "CAM PK.DH.IC...... %s", sprint_hex_inrow(cam->pk_dh_ic, cam->pk_dh_iclen)); + PrintAndLogEx(INFO, "CAM PK.CA.IC...... %s", sprint_hex_inrow((uint8_t *)pk_icc, pk_icc_len)); + PrintAndLogEx(INFO, "CAM SK.Map.IFD.... %s", sprint_hex_inrow((uint8_t *)cam->sk_map_ifd, cam->sk_map_ifdlen)); + PrintAndLogEx(INFO, "CAM SK.DH.IFD..... %s", sprint_hex_inrow((uint8_t *)cam->sk_dh_ifd, cam->sk_dh_ifdlen)); + PrintAndLogEx(INFO, "CAM KSenc......... %s", sprint_hex_inrow((uint8_t *)ssn->ks_enc, ssn->keylen)); + + uint8_t plain[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + if (emrtd_cam_decrypt(ssn, 0, plain) != PM3_SUCCESS) { + return; + } + + size_t content = FindISO9797M2PaddingDataLen(plain, cam->enc_datalen); + if (content == 0) { + content = cam->enc_datalen; + } + + PrintAndLogEx(INFO, "CAM plaintext..... %s", sprint_hex_inrow(plain, content)); + PrintAndLogEx(INFO, " (first block depends on the IV, the rest does not)"); + + // Two readings of what the chip is proving, both testable on the tail alone + struct { + const char *name; + const uint8_t *priv; + size_t privlen; + } guesses[] = { + { "x( SK.Map.IFD * PK.CA.IC )", cam->sk_map_ifd, cam->sk_map_ifdlen }, + { "x( SK.DH.IFD * PK.CA.IC )", cam->sk_dh_ifd, cam->sk_dh_ifdlen }, + }; + + for (size_t i = 0; i < ARRAYLEN(guesses); i++) { + + if (guesses[i].privlen == 0) { + continue; + } + + uint8_t expected[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + size_t expectedlen = 0; + + if (emrtd_pace_ec_shared_x(cam->curve, guesses[i].priv, guesses[i].privlen, + pk_icc, pk_icc_len, expected, &expectedlen) != PM3_SUCCESS) { + continue; + } + + PrintAndLogEx(INFO, "CAM %s = %s", guesses[i].name, sprint_hex_inrow(expected, expectedlen)); + + if ((expectedlen == content) && emrtd_cam_tail_matches(expected, plain, content)) { + + // The content is confirmed, so the only thing still wrong is the + // IV, and it can be read straight off: with a zero IV the first + // plaintext block is D(C1), so IV = D(C1) xor the real first block. + uint8_t iv[16] = { 0x00 }; + for (int b = 0; b < 16; b++) { + iv[b] = plain[b] ^ expected[b]; + } + + PrintAndLogEx(SUCCESS, "CAM " _GREEN_("content confirmed") ", the chip proves %s", guesses[i].name); + PrintAndLogEx(SUCCESS, "CAM required IV... %s", sprint_hex_inrow(iv, sizeof(iv))); + return; + } + } + + PrintAndLogEx(WARNING, "CAM neither reading matches, the content is something else"); +} + +// The chip's proof, US 9215230 (Kuegler / Bender) and TR-03110 part 3: +// it sends t = SK.Map.IC * SK.CA.IC^-1 mod n, so that t * PK.CA.IC reproduces +// the ephemeral PACE key it used. Only a chip holding the static Chip +// Authentication private key can produce such a t. +static int emrtd_cam_check_scalar(mbedtls_ecp_group_id curve, const uint8_t *t, size_t tlen, + const uint8_t *pk_icc, size_t pk_icc_len, + const uint8_t *ephemeral, size_t ephemerallen) { + mbedtls_ecp_group grp; + mbedtls_mpi d; + mbedtls_ecp_point PK, R, expected; + + if ((ephemerallen == 0) || (pk_icc_len == 0)) { + return PM3_EINVARG; + } + + mbedtls_ecp_group_init(&grp); + mbedtls_mpi_init(&d); + mbedtls_ecp_point_init(&PK); + mbedtls_ecp_point_init(&R); + mbedtls_ecp_point_init(&expected); + + int res = emrtd_ecp_group_with_base(&grp, curve, NULL, 0, NULL, NULL); + if (res != PM3_SUCCESS) { + goto out; + } + + res = PM3_EWRONGANSWER; + + if (mbedtls_ecp_point_read_binary(&grp, &PK, pk_icc, pk_icc_len) != 0) { + goto out; + } + if (mbedtls_ecp_point_read_binary(&grp, &expected, ephemeral, ephemerallen) != 0) { + goto out; + } + if (mbedtls_mpi_read_binary(&d, t, tlen) != 0) { + goto out; + } + // a t outside [1, n-1] can never be the right answer + if (mbedtls_ecp_check_privkey(&grp, &d) != 0) { + goto out; + } + if (mbedtls_ecp_mul(&grp, &R, &d, &PK, NULL, NULL) != 0) { + goto out; + } + + res = (mbedtls_ecp_point_cmp(&R, &expected) == 0) ? PM3_SUCCESS : PM3_EWRONGANSWER; + +out: + mbedtls_ecp_point_free(&expected); + mbedtls_ecp_point_free(&R); + mbedtls_ecp_point_free(&PK); + mbedtls_mpi_free(&d); + mbedtls_ecp_group_free(&grp); + return res; +} + +int emrtd_pace_cam_verify(const emrtd_session_t *ssn, const uint8_t *pk_icc, size_t pk_icc_len, + const char **mode) { + const emrtd_cam_t *cam = &ssn->cam; + + if ((cam->negotiated == false) || (cam->enc_datalen == 0)) { + return PM3_EINVARG; + } + + if ((cam->enc_datalen % 16) != 0) { + PrintAndLogEx(ERR, "CAM: encrypted authentication data is not a whole number of blocks (%zu)", cam->enc_datalen); + return PM3_ESOFT; + } + + static char modebuf[80]; + uint8_t plain[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + + // "the chip's private ephemeral key from PACE" is ambiguous: PACE generates + // two of them, the mapping key of step 2 and the agreement key of step 3. + struct { + const char *name; + const uint8_t *key; + size_t keylen; + } ephemerals[] = { + { "PK.Map.IC", cam->pk_map_ic, cam->pk_map_iclen }, + { "PK.DH.IC", cam->pk_dh_ic, cam->pk_dh_iclen }, + }; + + for (int enc = 0; enc < CAM_ENC_VARIANTS; enc++) { + + if (emrtd_cam_decrypt(ssn, enc, plain) != PM3_SUCCESS) { + continue; + } + + size_t tlen = FindISO9797M2PaddingDataLen(plain, cam->enc_datalen); + if (tlen == 0) { + tlen = cam->enc_datalen; + } + + PrintAndLogEx(DEBUG, "CAM candidate (%s)... %s", cam_encnames[enc], sprint_hex_inrow(plain, tlen)); + + for (size_t e = 0; e < ARRAYLEN(ephemerals); e++) { + + if (emrtd_cam_check_scalar(cam->curve, plain, tlen, pk_icc, pk_icc_len, + ephemerals[e].key, ephemerals[e].keylen) == PM3_SUCCESS) { + snprintf(modebuf, sizeof(modebuf), "%s, t * PK.CA.IC == %s", cam_encnames[enc], ephemerals[e].name); + if (mode != NULL) { + *mode = modebuf; + } + return PM3_SUCCESS; + } + } + } + + return PM3_EWRONGANSWER; +} diff --git a/client/src/emrtd/emrtd_pace.h b/client/src/emrtd/emrtd_pace.h new file mode 100644 index 000000000..e42f8189d --- /dev/null +++ b/client/src/emrtd/emrtd_pace.h @@ -0,0 +1,245 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- +// PACE (Password Authenticated Connection Establishment) primitives for eMRTD +// +// ICAO Doc 9303 Part 11, section 4.4 and BSI TR-03110 part 3, section 3.2. +// Everything in here is pure crypto / parsing so that it can be regression +// tested offline by `hf emrtd test` without a card on the reader. +//----------------------------------------------------------------------------- + +#ifndef EMRTD_PACE_H__ +#define EMRTD_PACE_H__ + +#include "common.h" +#include + +// Longest OID body (the bytes after the 06 header) we know about +#define EMRTD_PACE_OID_MAXLEN 10 +// AES-256 +#define EMRTD_SM_MAX_KEY_LEN 32 +// AES block, and the SSC length for AES secure messaging +#define EMRTD_SM_MAX_BLOCK_LEN 16 +// Uncompressed EC point of the largest curve we support (P-521): 04 || X || Y +#define EMRTD_EC_POINT_MAXLEN (1 + (2 * 66)) +// Largest raw secret fed to the KDF (a P-521 x-coordinate) +#define EMRTD_PACE_SECRET_MAXLEN 66 +// Number of SecurityInfos we keep out of EF_CardAccess +#define EMRTD_PACE_MAX_INFOS 16 + +typedef enum { + EMRTD_PACE_KA_DH = 0, + EMRTD_PACE_KA_ECDH, +} emrtd_pace_ka_t; + +typedef enum { + EMRTD_PACE_MAP_GM = 0, // Generic Mapping + EMRTD_PACE_MAP_IM, // Integrated Mapping + EMRTD_PACE_MAP_CAM, // Chip Authentication Mapping +} emrtd_pace_map_t; + +typedef enum { + EMRTD_PACE_CIPHER_3DES = 0, + EMRTD_PACE_CIPHER_AES128, + EMRTD_PACE_CIPHER_AES192, + EMRTD_PACE_CIPHER_AES256, +} emrtd_pace_cipher_t; + +typedef struct emrtd_pacealg_s { + const char *name; + emrtd_pace_ka_t ka; + emrtd_pace_map_t mapping; + emrtd_pace_cipher_t cipher; + size_t keylen; // 16 / 24 / 32 + size_t oidlen; + const uint8_t oid[EMRTD_PACE_OID_MAXLEN]; +} emrtd_pacealg_t; + +// Standardized Domain Parameters, TR-03110 part 3, table A.2 +typedef struct emrtd_pacesdp_s { + uint8_t id; + const char *name; + size_t size; + bool is_ec; + // MBEDTLS_ECP_DP_NONE when the curve is not compiled into our mbedtls + mbedtls_ecp_group_id curve; +} emrtd_pacesdp_t; + +// One parsed SecurityInfo out of EF_CardAccess +typedef struct { + const emrtd_pacealg_t *alg; // NULL when the OID is unknown to us + uint8_t oid[EMRTD_PACE_OID_MAXLEN]; + size_t oidlen; + uint32_t version; + bool has_param; + uint8_t param_id; + const emrtd_pacesdp_t *sdp; // NULL when param_id is unknown/absent + bool supported; + const char *reason; // why not supported, NULL when it is +} emrtd_paceinfo_t; + +typedef struct { + emrtd_paceinfo_t infos[EMRTD_PACE_MAX_INFOS]; + size_t count; + int best; // index into infos[], -1 when none usable +} emrtd_cardaccess_t; + +typedef enum { + EMRTD_SM_NONE = 0, + EMRTD_SM_3DES, + EMRTD_SM_AES, +} emrtd_sm_t; + +// State captured during a PACE run with Chip Authentication Mapping, verified +// once the LDS applet is readable and EF_DG14 can be fetched. +typedef struct { + bool negotiated; // PACE-CAM was the chosen protocol + mbedtls_ecp_group_id curve; + uint8_t enc_data[EMRTD_EC_POINT_MAXLEN]; // DO'8A' as returned by the chip + size_t enc_datalen; + // our own mapping private key. PACE-CAM reuses it as the terminal side of + // an ECDH with the chip's static Chip Authentication key, which is what + // makes the chip prove itself without any extra round trip. + uint8_t sk_map_ifd[EMRTD_PACE_SECRET_MAXLEN]; + size_t sk_map_ifdlen; + uint8_t sk_dh_ifd[EMRTD_PACE_SECRET_MAXLEN]; // the step 3 key, over G' + size_t sk_dh_ifdlen; + uint8_t pk_map_ic[EMRTD_EC_POINT_MAXLEN]; // the chip's step 2 mapping key + size_t pk_map_iclen; + uint8_t pk_dh_ic[EMRTD_EC_POINT_MAXLEN]; // the chip's step 3 agreement key + size_t pk_dh_iclen; +} emrtd_cam_t; + +typedef struct { + emrtd_sm_t type; + uint8_t ks_enc[EMRTD_SM_MAX_KEY_LEN]; + uint8_t ks_mac[EMRTD_SM_MAX_KEY_LEN]; + size_t keylen; + uint8_t ssc[EMRTD_SM_MAX_BLOCK_LEN]; + size_t ssclen; // 8 for 3DES, 16 for AES + bool pace; // session was established with PACE + const char *pace_alg; // algorithm name, for reporting + const char *pace_curve; // domain parameter name, for reporting + emrtd_cam_t cam; +} emrtd_session_t; + +//----------------------------------------------------------------------------- +// Shared 3DES / ISO 9797-1 helpers (also used by the BAC path) +//----------------------------------------------------------------------------- +void emrtd_des3_encrypt_cbc(uint8_t *iv, const uint8_t *key, const uint8_t *input, size_t inputlen, uint8_t *output); +void emrtd_des3_decrypt_cbc(uint8_t *iv, const uint8_t *key, const uint8_t *input, size_t inputlen, uint8_t *output); + +// ISO 9797-1 padding method 2 +size_t emrtd_pad_block(const uint8_t *input, size_t inputlen, size_t blocksize, uint8_t *output); + +// ISO 9797-1 MAC algorithm 3 with padding method 2 ("retail MAC") +int emrtd_retail_mac(const uint8_t *key, const uint8_t *input, size_t inputlen, uint8_t *output); + +//----------------------------------------------------------------------------- +// Table lookups +//----------------------------------------------------------------------------- +const emrtd_pacealg_t *emrtd_pace_alg_by_oid(const uint8_t *oid, size_t oidlen); +const emrtd_pacesdp_t *emrtd_pace_sdp_by_id(uint8_t id); +const char *emrtd_pace_cipher_name(emrtd_pace_cipher_t cipher); + +//----------------------------------------------------------------------------- +// Secure messaging session +//----------------------------------------------------------------------------- +void emrtd_sm_clear(emrtd_session_t *ssn); +int emrtd_sm_setup(emrtd_session_t *ssn, emrtd_pace_cipher_t cipher, const uint8_t *ks_enc, const uint8_t *ks_mac); +size_t emrtd_sm_blocksize(const emrtd_session_t *ssn); +void emrtd_sm_bump_ssc(emrtd_session_t *ssn); +int emrtd_sm_mac(const emrtd_session_t *ssn, const uint8_t *input, size_t inputlen, uint8_t *mac); +int emrtd_sm_encrypt(const emrtd_session_t *ssn, const uint8_t *input, size_t inputlen, uint8_t *output); +int emrtd_sm_decrypt(const emrtd_session_t *ssn, const uint8_t *input, size_t inputlen, uint8_t *output); + +//----------------------------------------------------------------------------- +// BER-TLV +//----------------------------------------------------------------------------- +// Reads one TLV starting at *cur. On success *cur is advanced past it. +bool emrtd_tlv_next(const uint8_t **cur, const uint8_t *end, uint32_t *tag, const uint8_t **value, size_t *valuelen); +// Writes tag (1 or 2 bytes, big endian) + length, returns bytes written, 0 on overflow +size_t emrtd_tlv_write_header(uint8_t *out, size_t outlen, uint32_t tag, size_t len); + +//----------------------------------------------------------------------------- +// EF_CardAccess +//----------------------------------------------------------------------------- +int emrtd_pace_parse_cardaccess(const uint8_t *data, size_t datalen, emrtd_cardaccess_t *out); +// Higher is better, 0 means unusable. Used to order the algorithms we try. +int emrtd_pace_rank(const emrtd_paceinfo_t *info); + +//----------------------------------------------------------------------------- +// PACE key derivation +//----------------------------------------------------------------------------- +// MRZ check digit, ICAO 9303-3 4.9. Returns the digit as a value 0-9, not ASCII. +char emrtd_calculate_check_digit(const char *data); + +// The MRZ information string that BAC and PACE both hash: docnr||cd||dob||cd||exp||cd +int emrtd_pace_kmrz(const char *documentnumber, const char *dob, const char *expiry, char *out, size_t outlen); +// K for the MRZ password: SHA-1 of the above +int emrtd_pace_password_mrz(const char *documentnumber, const char *dob, const char *expiry, uint8_t *k, size_t *klen); +// K for the CAN password: the CAN as raw ASCII +int emrtd_pace_password_can(const char *can, uint8_t *k, size_t *klen); +// TR-03110 part 3, A.2.3 +int emrtd_pace_kdf(emrtd_pace_cipher_t cipher, const uint8_t *k, size_t klen, uint32_t counter, uint8_t *out, size_t *outlen); + +// s = D(Kpi, z), zero IV +int emrtd_pace_decrypt_nonce(emrtd_pace_cipher_t cipher, const uint8_t *kpi, const uint8_t *z, size_t zlen, uint8_t *s); + +//----------------------------------------------------------------------------- +// ECDH with Generic Mapping +//----------------------------------------------------------------------------- +size_t emrtd_pace_ec_pointlen(mbedtls_ecp_group_id curve); + +// Public key for a caller supplied private scalar over a caller supplied base point. +// base may be NULL to use the nominal generator of the curve. +int emrtd_pace_ec_pubkey(mbedtls_ecp_group_id curve, const uint8_t *base, size_t baselen, + const uint8_t *priv, size_t privlen, uint8_t *pub, size_t *publen); + +// Fresh ephemeral keypair over base (NULL == nominal generator) +int emrtd_pace_ec_keygen(mbedtls_ecp_group_id curve, const uint8_t *base, size_t baselen, + uint8_t *priv, size_t *privlen, uint8_t *pub, size_t *publen); + +// G' = s*G + (priv * pk_ic) +int emrtd_pace_ec_gm(mbedtls_ecp_group_id curve, const uint8_t *s, size_t slen, + const uint8_t *priv, size_t privlen, const uint8_t *pk_ic, size_t pk_ic_len, + uint8_t *mapped, size_t *mappedlen); + +// x-coordinate of priv * pk_ic +int emrtd_pace_ec_shared_x(mbedtls_ecp_group_id curve, const uint8_t *priv, size_t privlen, + const uint8_t *pk_ic, size_t pk_ic_len, uint8_t *out, size_t *outlen); + +// T = MAC(ks_mac, 7F49 || 06 || 86 ) truncated to 8 bytes +int emrtd_pace_token(const emrtd_pacealg_t *alg, const uint8_t *ks_mac, + const uint8_t *pubkey, size_t pubkeylen, uint8_t *token); + +//----------------------------------------------------------------------------- +// Chip Authentication Mapping +//----------------------------------------------------------------------------- +// Pulls the index'th EC ChipAuthenticationPublicKey out of a SET of +// SecurityInfos, i.e. out of the body of EF_DG14 or the eContent of +// EF_CardSecurity. A document may publish more than one. +int emrtd_pace_find_ca_pubkey(const uint8_t *data, size_t datalen, size_t index, uint8_t *pub, size_t *publen); + +// Prints everything a failed CAM check depends on, so it can be reported +void emrtd_pace_cam_dump(const emrtd_session_t *ssn, const uint8_t *pk_icc, size_t pk_icc_len); + +// Recovers the Chip Authentication Data out of the DO'8A' the chip returns and +// checks it against the ECDH the terminal can do for itself. Returns +// PM3_SUCCESS when the document has proven it holds the CA private key. +int emrtd_pace_cam_verify(const emrtd_session_t *ssn, const uint8_t *pk_icc, size_t pk_icc_len, + const char **mode); + +#endif /* emrtd_pace.h */ diff --git a/client/src/emrtd/emrtd_pacetest.c b/client/src/emrtd/emrtd_pacetest.c new file mode 100644 index 000000000..463a790b9 --- /dev/null +++ b/client/src/emrtd/emrtd_pacetest.c @@ -0,0 +1,682 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- +// Offline regression tests for the eMRTD PACE / secure messaging primitives +// +// Unless noted otherwise every vector below is the worked example from +// ICAO Doc 9303 Part 11 (7th edition) Appendix G, "PACE-ECDH-GM-AES-CMAC-128 +// with BrainpoolP256r1", which is the same example as BSI TR-SAC 1.01 +// Appendix D.3. The BAC / 3DES secure messaging vectors are from +// ICAO Doc 9303 Part 11 Appendix D.4. +//----------------------------------------------------------------------------- + +#include "emrtd_pacetest.h" + +#include +#include + +#include "emrtd/emrtd_pace.h" +#include "crypto/libpcrypto.h" +#include "ui.h" +#include "util.h" + +static bool hexeq(const uint8_t *data, size_t datalen, const char *expected) { + char buf[512] = { 0x00 }; + + if ((datalen * 2) + 1 > sizeof(buf)) { + return false; + } + + for (size_t i = 0; i < datalen; i++) { + snprintf(buf + (i * 2), 3, "%02X", data[i]); + } + + return (strlen(expected) == (datalen * 2)) && (strcmp(buf, expected) == 0); +} + +static size_t unhex(const char *in, uint8_t *out, size_t outlen) { + size_t len = strlen(in) / 2; + if (len > outlen) { + return 0; + } + for (size_t i = 0; i < len; i++) { + unsigned int v = 0; + if (sscanf(in + (i * 2), "%2x", &v) != 1) { + return 0; + } + out[i] = (uint8_t)v; + } + return len; +} + +// ICAO 9303-11 Appendix G, the MRZ of the sample document +#define ICAO_DOCNR "T22000129" +#define ICAO_DOB "640812" +#define ICAO_EXPIRY "101031" +#define ICAO_KMRZ "T22000129364081251010318" +#define ICAO_K "7E2D2A41C74EA0B38CD36F863939BFA8E9032AAD" + +static bool test_mrz_password(void) { + char kmrz[25] = { 0x00 }; + bool res = (emrtd_pace_kmrz(ICAO_DOCNR, ICAO_DOB, ICAO_EXPIRY, kmrz, sizeof(kmrz)) == PM3_SUCCESS); + res = res && (strcmp(kmrz, ICAO_KMRZ) == 0); + + uint8_t k[64] = { 0x00 }; + size_t klen = 0; + res = res && (emrtd_pace_password_mrz(ICAO_DOCNR, ICAO_DOB, ICAO_EXPIRY, k, &klen) == PM3_SUCCESS); + res = res && (klen == 20) && hexeq(k, klen, ICAO_K); + + // Kpi = KDF(K, 3) + uint8_t kpi[32] = { 0x00 }; + size_t kpilen = 0; + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, k, klen, 3, kpi, &kpilen) == PM3_SUCCESS); + res = res && (kpilen == 16) && hexeq(kpi, kpilen, "89DED1B26624EC1E634C1989302849DD"); + + PrintAndLogEx(SUCCESS, "MRZ password..... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_can_password(void) { + uint8_t k[64] = { 0x00 }; + size_t klen = 0; + + // ICAO 9303-11 9.7.2, the CAN is used as its plain ASCII representation + bool res = (emrtd_pace_password_can("123456", k, &klen) == PM3_SUCCESS); + res = res && (klen == 6) && hexeq(k, klen, "313233343536"); + + uint8_t kpi[32] = { 0x00 }; + size_t kpilen = 0; + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, k, klen, 3, kpi, &kpilen) == PM3_SUCCESS); + // SHA-1("123456" || 00000003), first 16 bytes + res = res && (kpilen == 16) && hexeq(kpi, kpilen, "591468CDA83D65219CCCB8560233600F"); + + PrintAndLogEx(SUCCESS, "CAN password..... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_kdf(void) { + uint8_t k[20] = { 0x00 }; + unhex(ICAO_K, k, sizeof(k)); + + uint8_t out[32] = { 0x00 }; + size_t outlen = 0; + bool res = true; + + // SHA-1 based, 16 byte keys + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, k, sizeof(k), 1, out, &outlen) == PM3_SUCCESS); + res = res && (outlen == 16) && hexeq(out, outlen, "3CC5F8872F8B1471B47EEFDDFFC43F46"); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, k, sizeof(k), 2, out, &outlen) == PM3_SUCCESS); + res = res && hexeq(out, outlen, "BD651C6B2FA9B4704553332007771E84"); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, k, sizeof(k), 3, out, &outlen) == PM3_SUCCESS); + res = res && hexeq(out, outlen, "89DED1B26624EC1E634C1989302849DD"); + + // Same hash, but 3DES adds odd parity to both halves (ICAO 9303-11 9.7.1.1) + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_3DES, k, sizeof(k), 3, out, &outlen) == PM3_SUCCESS); + res = res && (outlen == 16) && hexeq(out, outlen, "89DFD0B36725EC1F624C1989312949DC"); + + // SHA-256 based, truncated to 24 bytes + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES192, k, sizeof(k), 1, out, &outlen) == PM3_SUCCESS); + res = res && (outlen == 24) && hexeq(out, outlen, "11504483F04A10A66A8FCD6D348C75A961809C54EDAA2117"); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES192, k, sizeof(k), 2, out, &outlen) == PM3_SUCCESS); + res = res && hexeq(out, outlen, "1F35D576CE54BA775A391F9749E388C48215B7D544D62D96"); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES192, k, sizeof(k), 3, out, &outlen) == PM3_SUCCESS); + res = res && hexeq(out, outlen, "D79A23C126202AC9051FEBFBC0E8A03B1C6645D85752B4B7"); + + // SHA-256 based, full 32 bytes + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES256, k, sizeof(k), 1, out, &outlen) == PM3_SUCCESS); + res = res && (outlen == 32) && hexeq(out, outlen, "11504483F04A10A66A8FCD6D348C75A961809C54EDAA21174726A97FB37DEF52"); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES256, k, sizeof(k), 2, out, &outlen) == PM3_SUCCESS); + res = res && hexeq(out, outlen, "1F35D576CE54BA775A391F9749E388C48215B7D544D62D96470ABA7B19F051A3"); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES256, k, sizeof(k), 3, out, &outlen) == PM3_SUCCESS); + res = res && hexeq(out, outlen, "D79A23C126202AC9051FEBFBC0E8A03B1C6645D85752B4B71408FA229AB6D56B"); + + PrintAndLogEx(SUCCESS, "KDF.............. ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_nonce(void) { + uint8_t kpi[16] = { 0x00 }; + uint8_t z[16] = { 0x00 }; + uint8_t s[16] = { 0x00 }; + + unhex("89DED1B26624EC1E634C1989302849DD", kpi, sizeof(kpi)); + unhex("95A3A016522EE98D01E76CB6B98B42C3", z, sizeof(z)); + + bool res = (emrtd_pace_decrypt_nonce(EMRTD_PACE_CIPHER_AES128, kpi, z, sizeof(z), s) == PM3_SUCCESS); + res = res && hexeq(s, sizeof(s), "3F00C4D39D153F2B2A214A078D899B22"); + + PrintAndLogEx(SUCCESS, "Nonce decrypt.... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +// ICAO 9303-11 Appendix G, PACE-ECDH-GM-AES-CMAC-128 over BrainpoolP256r1 +#define ICAO_S "3F00C4D39D153F2B2A214A078D899B22" +#define ICAO_SK_MAP_IFD "7F4EF07B9EA82FD78AD689B38D0BC78CF21F249D953BC46F4C6E19259C010F99" +#define ICAO_PK_MAP_IFD "047ACF3EFC982EC45565A4B155129EFBC74650DCBFA6362D896FC70262E0C2CC5E544552DCB6725218799115B55C9BAA6D9F6BC3A9618E70C25AF71777A9C4922D" +#define ICAO_PK_MAP_IC "04824FBA91C9CBE26BEF53A0EBE7342A3BF178CEA9F45DE0B70AA601651FBA3F5730D8C879AAA9C9F73991E61B58F4D52EB87A0A0C709A49DC63719363CCD13C54" +#define ICAO_G_MAPPED "048CED63C91426D4F0EB1435E7CB1D74A46723A0AF21C89634F65A9AE87A9265E28C879506743F8611AC33645C5B985C80B5F09A0B83407C1B6A4D857AE76FE522" +#define ICAO_SK_DH_IFD "A73FB703AC1436A18E0CFA5ABB3F7BEC7A070E7A6788486BEE230C4A22762595" +#define ICAO_PK_DH_IFD "042DB7A64C0355044EC9DF190514C625CBA2CEA48754887122F3A5EF0D5EDD301C3556F3B3B186DF10B857B58F6A7EB80F20BA5DC7BE1D43D9BF850149FBB36462" +#define ICAO_PK_DH_IC "049E880F842905B8B3181F7AF7CAA9F0EFB743847F44A306D2D28C1D9EC65DF6DB7764B22277A2EDDC3C265A9F018F9CB852E111B768B326904B59A0193776F094" +#define ICAO_SHARED_X "28768D20701247DAE81804C9E780EDE582A9996DB4A315020B2733197DB84925" +#define ICAO_KSENC "F5F0E35C0D7161EE6724EE513A0D9A7F" +#define ICAO_KSMAC "FE251C7858B356B24514B3BD5F4297D1" + +static bool test_gm(void) { + uint8_t s[16], x1[32], pk_map_ic[65], x2[32], pk_dh_ic[65]; + uint8_t pub[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + uint8_t mapped[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + uint8_t shared[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + size_t publen = 0, mappedlen = 0, sharedlen = 0; + + unhex(ICAO_S, s, sizeof(s)); + unhex(ICAO_SK_MAP_IFD, x1, sizeof(x1)); + unhex(ICAO_PK_MAP_IC, pk_map_ic, sizeof(pk_map_ic)); + unhex(ICAO_SK_DH_IFD, x2, sizeof(x2)); + unhex(ICAO_PK_DH_IC, pk_dh_ic, sizeof(pk_dh_ic)); + + const mbedtls_ecp_group_id curve = MBEDTLS_ECP_DP_BP256R1; + + bool res = (emrtd_pace_ec_pointlen(curve) == 65); + + // PK.Map.IFD = x1 * G + res = res && (emrtd_pace_ec_pubkey(curve, NULL, 0, x1, sizeof(x1), pub, &publen) == PM3_SUCCESS); + res = res && hexeq(pub, publen, ICAO_PK_MAP_IFD); + + // G' = s*G + x1 * PK.Map.IC + res = res && (emrtd_pace_ec_gm(curve, s, sizeof(s), x1, sizeof(x1), pk_map_ic, sizeof(pk_map_ic), + mapped, &mappedlen) == PM3_SUCCESS); + res = res && hexeq(mapped, mappedlen, ICAO_G_MAPPED); + + // PK.DH.IFD = x2 * G' + res = res && (emrtd_pace_ec_pubkey(curve, mapped, mappedlen, x2, sizeof(x2), pub, &publen) == PM3_SUCCESS); + res = res && hexeq(pub, publen, ICAO_PK_DH_IFD); + + // K = x-coordinate of x2 * PK.DH.IC + res = res && (emrtd_pace_ec_shared_x(curve, x2, sizeof(x2), pk_dh_ic, sizeof(pk_dh_ic), + shared, &sharedlen) == PM3_SUCCESS); + res = res && hexeq(shared, sharedlen, ICAO_SHARED_X); + + // KSenc = KDF(K, 1), KSmac = KDF(K, 2) + uint8_t ks[32] = { 0x00 }; + size_t kslen = 0; + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, shared, sharedlen, 1, ks, &kslen) == PM3_SUCCESS); + res = res && hexeq(ks, kslen, ICAO_KSENC); + res = res && (emrtd_pace_kdf(EMRTD_PACE_CIPHER_AES128, shared, sharedlen, 2, ks, &kslen) == PM3_SUCCESS); + res = res && hexeq(ks, kslen, ICAO_KSMAC); + + PrintAndLogEx(SUCCESS, "ECDH GM mapping.. ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_ec_keygen(void) { + // Not a published vector, just a sanity check that the ephemeral key we + // generate is a real key on the mapped generator and is not all zeroes. + uint8_t mapped[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t mappedlen = unhex(ICAO_G_MAPPED, mapped, sizeof(mapped)); + + uint8_t priv[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + uint8_t pub[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + uint8_t check[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t privlen = 0, publen = 0, checklen = 0; + + bool res = (emrtd_pace_ec_keygen(MBEDTLS_ECP_DP_BP256R1, mapped, mappedlen, + priv, &privlen, pub, &publen) == PM3_SUCCESS); + res = res && (privlen == 32) && (publen == 65) && (pub[0] == 0x04); + + uint8_t zeroes[EMRTD_PACE_SECRET_MAXLEN] = { 0x00 }; + res = res && (memcmp(priv, zeroes, privlen) != 0); + + // the generated public key has to be priv * G' + res = res && (emrtd_pace_ec_pubkey(MBEDTLS_ECP_DP_BP256R1, mapped, mappedlen, + priv, privlen, check, &checklen) == PM3_SUCCESS); + res = res && (checklen == publen) && (memcmp(check, pub, publen) == 0); + + PrintAndLogEx(SUCCESS, "Ephemeral keygen. ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_token(void) { + uint8_t ks_mac[16] = { 0x00 }; + uint8_t pk_dh_ic[65] = { 0x00 }; + uint8_t pk_dh_ifd[65] = { 0x00 }; + uint8_t token[8] = { 0x00 }; + + unhex(ICAO_KSMAC, ks_mac, sizeof(ks_mac)); + unhex(ICAO_PK_DH_IC, pk_dh_ic, sizeof(pk_dh_ic)); + unhex(ICAO_PK_DH_IFD, pk_dh_ifd, sizeof(pk_dh_ifd)); + + const uint8_t oid[10] = {0x04, 0x00, 0x7F, 0x00, 0x07, 0x02, 0x02, 0x04, 0x02, 0x02}; + const emrtd_pacealg_t *alg = emrtd_pace_alg_by_oid(oid, sizeof(oid)); + + bool res = (alg != NULL); + res = res && (alg->cipher == EMRTD_PACE_CIPHER_AES128); + res = res && (alg->mapping == EMRTD_PACE_MAP_GM); + res = res && (alg->ka == EMRTD_PACE_KA_ECDH); + + // T_IFD is computed over the chip's key + res = res && (emrtd_pace_token(alg, ks_mac, pk_dh_ic, sizeof(pk_dh_ic), token) == PM3_SUCCESS); + res = res && hexeq(token, sizeof(token), "C2B0BD78D94BA866"); + + // T_IC is computed over our key + res = res && (emrtd_pace_token(alg, ks_mac, pk_dh_ifd, sizeof(pk_dh_ifd), token) == PM3_SUCCESS); + res = res && hexeq(token, sizeof(token), "3ABB9674BCE93C08"); + + PrintAndLogEx(SUCCESS, "Auth tokens...... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_ssc(void) { + emrtd_session_t ssn; + uint8_t ks[32] = { 0x00 }; + + emrtd_sm_clear(&ssn); + bool res = (emrtd_sm_setup(&ssn, EMRTD_PACE_CIPHER_AES128, ks, ks) == PM3_SUCCESS); + res = res && (ssn.ssclen == 16) && (emrtd_sm_blocksize(&ssn) == 16); + + emrtd_sm_bump_ssc(&ssn); + res = res && hexeq(ssn.ssc, ssn.ssclen, "00000000000000000000000000000001"); + + // carry across the whole SSC + memset(ssn.ssc, 0xFF, ssn.ssclen); + ssn.ssc[ssn.ssclen - 1] = 0xFF; + emrtd_sm_bump_ssc(&ssn); + res = res && hexeq(ssn.ssc, ssn.ssclen, "00000000000000000000000000000000"); + + memset(ssn.ssc, 0x00, ssn.ssclen); + ssn.ssc[ssn.ssclen - 1] = 0xFF; + emrtd_sm_bump_ssc(&ssn); + res = res && hexeq(ssn.ssc, ssn.ssclen, "00000000000000000000000000000100"); + + // 3DES sessions carry an 8 byte SSC + emrtd_sm_clear(&ssn); + res = res && (emrtd_sm_setup(&ssn, EMRTD_PACE_CIPHER_3DES, ks, ks) == PM3_SUCCESS); + res = res && (ssn.ssclen == 8) && (emrtd_sm_blocksize(&ssn) == 8); + unhex("887022120C06C2FF", ssn.ssc, sizeof(ssn.ssc)); + emrtd_sm_bump_ssc(&ssn); + res = res && hexeq(ssn.ssc, ssn.ssclen, "887022120C06C300"); + + PrintAndLogEx(SUCCESS, "SSC increment.... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_padding(void) { + uint8_t out[32] = { 0x00 }; + + bool res = (emrtd_pad_block((const uint8_t *)"\x01\x1E", 2, 8, out) == 8); + res = res && hexeq(out, 8, "011E800000000000"); + + res = res && (emrtd_pad_block((const uint8_t *)"\x01\x1E", 2, 16, out) == 16); + res = res && hexeq(out, 16, "011E8000000000000000000000000000"); + + // a full block always gets a whole block of padding added + res = res && (emrtd_pad_block((const uint8_t *)"\x0C\xA4\x02\x0C", 4, 8, out) == 8); + res = res && hexeq(out, 8, "0CA4020C80000000"); + + uint8_t full[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88}; + res = res && (emrtd_pad_block(full, 8, 8, out) == 16); + res = res && hexeq(out, 16, "11223344556677888000000000000000"); + + PrintAndLogEx(SUCCESS, "ISO 9797-1 pad... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +// ICAO 9303-11 Appendix D.4, the BAC secure messaging worked example. +// This is the regression test for the 3DES path, it has to keep passing +// byte for byte after any refactor of the session handling. +static bool test_sm_3des(void) { + emrtd_session_t ssn; + uint8_t ks_enc[16], ks_mac[16]; + + unhex("979EC13B1CBFE9DCD01AB0FED307EAE5", ks_enc, sizeof(ks_enc)); + unhex("F1CB1F1FB5ADF208806B89DC579DC1F8", ks_mac, sizeof(ks_mac)); + + emrtd_sm_clear(&ssn); + bool res = (emrtd_sm_setup(&ssn, EMRTD_PACE_CIPHER_3DES, ks_enc, ks_mac) == PM3_SUCCESS); + unhex("887022120C06C226", ssn.ssc, sizeof(ssn.ssc)); + + // SELECT EF.COM, protected + emrtd_sm_bump_ssc(&ssn); + res = res && hexeq(ssn.ssc, ssn.ssclen, "887022120C06C227"); + + uint8_t pt[16] = { 0x00 }; + uint8_t ct[16] = { 0x00 }; + size_t ptlen = emrtd_pad_block((const uint8_t *)"\x01\x1E", 2, 8, pt); + res = res && (emrtd_sm_encrypt(&ssn, pt, ptlen, ct) == PM3_SUCCESS); + res = res && hexeq(ct, ptlen, "6375432908C044F6"); + + uint8_t n[64] = { 0x00 }; + size_t nlen = 0; + memcpy(n, ssn.ssc, ssn.ssclen); + nlen += ssn.ssclen; + nlen += emrtd_pad_block((const uint8_t *)"\x0C\xA4\x02\x0C", 4, 8, n + nlen); + memcpy(n + nlen, "\x87\x09\x01", 3); + nlen += 3; + memcpy(n + nlen, ct, ptlen); + nlen += ptlen; + + uint8_t cc[8] = { 0x00 }; + res = res && (emrtd_sm_mac(&ssn, n, nlen, cc) == PM3_SUCCESS); + res = res && hexeq(cc, sizeof(cc), "BF8B92D635FF24F8"); + + // Response 99 02 90 00 8E 08 FA855A5D4C50A8ED + emrtd_sm_bump_ssc(&ssn); + res = res && hexeq(ssn.ssc, ssn.ssclen, "887022120C06C228"); + + nlen = 0; + memcpy(n, ssn.ssc, ssn.ssclen); + nlen += ssn.ssclen; + memcpy(n + nlen, "\x99\x02\x90\x00", 4); + nlen += 4; + res = res && (emrtd_sm_mac(&ssn, n, nlen, cc) == PM3_SUCCESS); + res = res && hexeq(cc, sizeof(cc), "FA855A5D4C50A8ED"); + + PrintAndLogEx(SUCCESS, "3DES SM.......... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +// AES secure messaging, ICAO 9303-11 9.8.6. +// The session keys are the ones the PACE example above produces. ICAO publishes +// no AES secure messaging trace, so the protected APDUs below were computed +// independently (OpenSSL / PyCryptodome) from those keys. The one judgement +// call they encode is that step e.2, "concatenate SSC and M and add padding", +// applies to AES as well as to 3DES; that was confirmed on a document doing +// PACE with AES-CMAC-256, which answers 6988 to an unpadded MAC input. +static bool test_sm_aes(void) { + emrtd_session_t ssn; + uint8_t ks_enc[16], ks_mac[16]; + + unhex(ICAO_KSENC, ks_enc, sizeof(ks_enc)); + unhex(ICAO_KSMAC, ks_mac, sizeof(ks_mac)); + + emrtd_sm_clear(&ssn); + bool res = (emrtd_sm_setup(&ssn, EMRTD_PACE_CIPHER_AES128, ks_enc, ks_mac) == PM3_SUCCESS); + // SSC starts at zero after PACE + res = res && hexeq(ssn.ssc, ssn.ssclen, "00000000000000000000000000000000"); + + //--------------------------------------------------------------------- + // SELECT EF.COM -> 0CA4020C1D 871101 8E08 00 + //--------------------------------------------------------------------- + emrtd_sm_bump_ssc(&ssn); + + uint8_t pt[32] = { 0x00 }; + uint8_t ct[32] = { 0x00 }; + size_t ptlen = emrtd_pad_block((const uint8_t *)"\x01\x1E", 2, 16, pt); + res = res && (emrtd_sm_encrypt(&ssn, pt, ptlen, ct) == PM3_SUCCESS); + res = res && hexeq(ct, ptlen, "EE0E4724F4465C1BE9C2F73ABDD73A3D"); + + uint8_t n[128] = { 0x00 }; + size_t nlen = 0; + memcpy(n, ssn.ssc, ssn.ssclen); + nlen += ssn.ssclen; + nlen += emrtd_pad_block((const uint8_t *)"\x0C\xA4\x02\x0C", 4, 16, n + nlen); + memcpy(n + nlen, "\x87\x11\x01", 3); + nlen += 3; + memcpy(n + nlen, ct, ptlen); + nlen += ptlen; + + uint8_t cc[8] = { 0x00 }; + res = res && (emrtd_sm_mac(&ssn, n, nlen, cc) == PM3_SUCCESS); + res = res && hexeq(cc, sizeof(cc), "835D1B54575C955F"); + + // response 99 02 90 00 8E 08 + emrtd_sm_bump_ssc(&ssn); + nlen = 0; + memcpy(n, ssn.ssc, ssn.ssclen); + nlen += ssn.ssclen; + memcpy(n + nlen, "\x99\x02\x90\x00", 4); + nlen += 4; + res = res && (emrtd_sm_mac(&ssn, n, nlen, cc) == PM3_SUCCESS); + res = res && hexeq(cc, sizeof(cc), "BEA7B381C494A079"); + + //--------------------------------------------------------------------- + // READ BINARY offset 0, 4 bytes -> 0CB000000D 970104 8E08 00 + //--------------------------------------------------------------------- + emrtd_sm_bump_ssc(&ssn); + nlen = 0; + memcpy(n, ssn.ssc, ssn.ssclen); + nlen += ssn.ssclen; + nlen += emrtd_pad_block((const uint8_t *)"\x0C\xB0\x00\x00", 4, 16, n + nlen); + memcpy(n + nlen, "\x97\x01\x04", 3); + nlen += 3; + res = res && (emrtd_sm_mac(&ssn, n, nlen, cc) == PM3_SUCCESS); + res = res && hexeq(cc, sizeof(cc), "AA6BA54F44DF8364"); + + // response 87 11 01 99 02 90 00 8E 08 + emrtd_sm_bump_ssc(&ssn); + + uint8_t rct[16] = { 0x00 }; + unhex("645C0B1F998A088278D07942BBE94B60", rct, sizeof(rct)); + + nlen = 0; + memcpy(n, ssn.ssc, ssn.ssclen); + nlen += ssn.ssclen; + memcpy(n + nlen, "\x87\x11\x01", 3); + nlen += 3; + memcpy(n + nlen, rct, sizeof(rct)); + nlen += sizeof(rct); + memcpy(n + nlen, "\x99\x02\x90\x00", 4); + nlen += 4; + res = res && (emrtd_sm_mac(&ssn, n, nlen, cc) == PM3_SUCCESS); + res = res && hexeq(cc, sizeof(cc), "94A33C6AA2D8CCC8"); + + // and the response data has to decrypt back to the start of EF_COM + uint8_t plain[16] = { 0x00 }; + res = res && (emrtd_sm_decrypt(&ssn, rct, sizeof(rct), plain) == PM3_SUCCESS); + res = res && hexeq(plain, sizeof(plain), "60145F01800000000000000000000000"); + res = res && hexeq(plain, 4, "60145F01"); + + PrintAndLogEx(SUCCESS, "AES SM........... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_cardaccess(void) { + // A SET of four PACEInfos: + // ECDH-GM-AES-CMAC-128 / BrainpoolP256r1 (supported) + // ECDH-GM-AES-CMAC-256 / BrainpoolP384r1 (supported) + // DH-GM-AES-CMAC-128 / 1024-bit MODP (not supported, no DHM) + // ECDH-CAM-AES-CMAC-256 / BrainpoolP384r1 (supported, but ranked below + // GM while its proof cannot + // be checked) + const char *blob = + "3150" + "3012" "060A04007F0007020204020202010202010D" + "3012" "060A04007F00070202040204020102020110" + "3012" "060A04007F00070202040101020102020100" + "3012" "060A04007F00070202040604020102020110"; + + uint8_t data[128] = { 0x00 }; + size_t datalen = unhex(blob, data, sizeof(data)); + + emrtd_cardaccess_t ca; + bool res = (datalen > 0); + res = res && (emrtd_pace_parse_cardaccess(data, datalen, &ca) == PM3_SUCCESS); + res = res && (ca.count == 4); + // GM wins ties over CAM for now, see emrtd_pace_rank() + res = res && (ca.best == 1); + res = res && (ca.infos[3].supported); + res = res && (ca.infos[3].alg != NULL) && (ca.infos[3].alg->mapping == EMRTD_PACE_MAP_CAM); + res = res && (emrtd_pace_rank(&ca.infos[3]) < emrtd_pace_rank(&ca.infos[1])); + // but CAM still has to be usable when it is all a document offers + res = res && (emrtd_pace_rank(&ca.infos[3]) > 0); + + res = res && (ca.infos[0].supported) && (ca.infos[0].version == 2); + res = res && (ca.infos[0].alg != NULL) && (ca.infos[0].alg->cipher == EMRTD_PACE_CIPHER_AES128); + res = res && (ca.infos[0].sdp != NULL) && (ca.infos[0].sdp->curve == MBEDTLS_ECP_DP_BP256R1); + + res = res && (ca.infos[1].supported); + res = res && (ca.infos[1].alg != NULL) && (ca.infos[1].alg->cipher == EMRTD_PACE_CIPHER_AES256); + res = res && (ca.infos[1].sdp != NULL) && (ca.infos[1].sdp->curve == MBEDTLS_ECP_DP_BP384R1); + + res = res && (ca.infos[2].supported == false) && (ca.infos[2].reason != NULL); + + // curves that this tree's mbedtls does not carry must never resolve + const emrtd_pacesdp_t *sdp = emrtd_pace_sdp_by_id(14); // BrainpoolP320r1 + res = res && (sdp != NULL) && (sdp->curve == MBEDTLS_ECP_DP_NONE); + sdp = emrtd_pace_sdp_by_id(9); // BrainpoolP192r1 + res = res && (sdp != NULL) && (sdp->curve == MBEDTLS_ECP_DP_NONE); + sdp = emrtd_pace_sdp_by_id(12); // NIST P-256 + res = res && (sdp != NULL) && (sdp->curve == MBEDTLS_ECP_DP_SECP256R1); + + // truncated input must be rejected, not walked off the end of the buffer + emrtd_cardaccess_t bad; + for (size_t cut = 1; cut < datalen; cut++) { + if (emrtd_pace_parse_cardaccess(data, cut, &bad) == PM3_SUCCESS) { + // a shorter but still well formed prefix is only possible if it + // parses to fewer entries than the full blob + if (bad.count >= ca.count) { + res = false; + break; + } + } + } + + PrintAndLogEx(SUCCESS, "EF_CardAccess.... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +// Chip Authentication Mapping. +// +// The chip sends t = SK.Map.IC * SK.CA.IC^-1 mod n encrypted with KSenc, so +// that t * PK.CA.IC reproduces the ephemeral PACE key it used. Only a chip +// holding the static Chip Authentication private key can produce such a t. +// See US 9215230 (Kuegler / Bender) and TR-03110 part 3. +// +// No published vector exists, so this one is constructed the way a genuine +// chip would: t is derived from a chosen static key and mapping key, padded +// and encrypted. t is 32 bytes here and DO'8A' is 48, mirroring a real +// BrainpoolP384r1 document where a 48 byte t arrives as 64 bytes. +#define CAM_PK_ICC "048DF71464547FC82DCF1650BBC5B72DCD2CC3D9A71283F6E374C0958F316026DB0E1F619B0FBBD54B130E9D04B5201A0522D4CC199888B6D76C9A22BDD79F2D45" +#define CAM_PK_MAP_IC "041D840F08CE75DDA65326277A850039892B9A399614221865EDC0DCD27DE1B4EEA5E8B3CB9560F08D09DDB3B4DE4D936FF1311A9F6D20047E94B3E458BCA5778B" +#define CAM_KSENC "0102030405060708090A0B0C0D0E0F10" +#define CAM_DO8A "25887095A78FA691E074800EF9B097F96EBFA89ED8350BCAEDFD309DE91878ADCE249F1253D13483C441B1A08DFD74DE" + +static bool test_cam(void) { + uint8_t pk_icc[65], ks[16]; + + size_t pk_icclen = unhex(CAM_PK_ICC, pk_icc, sizeof(pk_icc)); + unhex(CAM_KSENC, ks, sizeof(ks)); + + emrtd_session_t ssn; + emrtd_sm_clear(&ssn); + bool res = (emrtd_sm_setup(&ssn, EMRTD_PACE_CIPHER_AES128, ks, ks) == PM3_SUCCESS); + + ssn.cam.negotiated = true; + ssn.cam.curve = MBEDTLS_ECP_DP_BP256R1; + ssn.cam.pk_map_iclen = unhex(CAM_PK_MAP_IC, ssn.cam.pk_map_ic, sizeof(ssn.cam.pk_map_ic)); + ssn.cam.enc_datalen = unhex(CAM_DO8A, ssn.cam.enc_data, sizeof(ssn.cam.enc_data)); + res = res && (ssn.cam.enc_datalen == 48); + + const char *mode = NULL; + res = res && (emrtd_pace_cam_verify(&ssn, pk_icc, pk_icclen, &mode) == PM3_SUCCESS); + res = res && (mode != NULL) && (strstr(mode, "PK.Map.IC") != NULL); + + // a chip that returns the wrong blob must not verify under any encoding + ssn.cam.enc_data[0] ^= 0x01; + res = res && (emrtd_pace_cam_verify(&ssn, pk_icc, pk_icclen, &mode) != PM3_SUCCESS); + ssn.cam.enc_data[0] ^= 0x01; + + // nor may a different, perfectly valid, chip authentication key pass + uint8_t other[65] = { 0x00 }; + size_t otherlen = unhex(CAM_PK_MAP_IC, other, sizeof(other)); + res = res && (emrtd_pace_cam_verify(&ssn, other, otherlen, &mode) != PM3_SUCCESS); + + // and the chip's own public key has to come out of EF_DG14 + const char *dg14 = + "6E5E315C305A060904007F000702020102304D300706052B8104002203420004" + "8DF71464547FC82DCF1650BBC5B72DCD2CC3D9A71283F6E374C0958F316026DB" + "0E1F619B0FBBD54B130E9D04B5201A0522D4CC199888B6D76C9A22BDD79F2D45"; + + uint8_t dg14bin[128] = { 0x00 }; + size_t dg14len = unhex(dg14, dg14bin, sizeof(dg14bin)); + + uint8_t found[EMRTD_EC_POINT_MAXLEN] = { 0x00 }; + size_t foundlen = 0; + res = res && (emrtd_pace_find_ca_pubkey(dg14bin, dg14len, 0, found, &foundlen) == PM3_SUCCESS); + res = res && (foundlen == pk_icclen) && hexeq(found, foundlen, CAM_PK_ICC); + + // truncated EF_DG14 must be refused, not walked off the end + for (size_t cut = 1; cut < dg14len; cut++) { + if (emrtd_pace_find_ca_pubkey(dg14bin, cut, 0, found, &foundlen) == PM3_SUCCESS) { + res = false; + break; + } + } + + PrintAndLogEx(SUCCESS, "CA mapping....... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +static bool test_tlv(void) { + const uint8_t data[] = {0x7F, 0x49, 0x04, 0x06, 0x02, 0xAA, 0xBB}; + const uint8_t *cur = data; + const uint8_t *end = data + sizeof(data); + uint32_t tag = 0; + const uint8_t *val = NULL; + size_t vlen = 0; + + bool res = emrtd_tlv_next(&cur, end, &tag, &val, &vlen); + res = res && (tag == 0x7F49) && (vlen == 4); + + const uint8_t *icur = val; + const uint8_t *iend = val + vlen; + res = res && emrtd_tlv_next(&icur, iend, &tag, &val, &vlen); + res = res && (tag == 0x06) && (vlen == 2) && (val[0] == 0xAA) && (val[1] == 0xBB); + res = res && (emrtd_tlv_next(&icur, iend, &tag, &val, &vlen) == false); + + // a length that runs past the buffer must be rejected + const uint8_t bad[] = {0x30, 0x10, 0x01}; + cur = bad; + res = res && (emrtd_tlv_next(&cur, bad + sizeof(bad), &tag, &val, &vlen) == false); + + uint8_t out[8] = { 0x00 }; + res = res && (emrtd_tlv_write_header(out, sizeof(out), 0x7F49, 0x4F) == 3); + res = res && hexeq(out, 3, "7F494F"); + res = res && (emrtd_tlv_write_header(out, sizeof(out), 0x86, 0x41) == 2); + res = res && hexeq(out, 2, "8641"); + res = res && (emrtd_tlv_write_header(out, sizeof(out), 0x87, 0x81) == 3); + res = res && hexeq(out, 3, "878181"); + res = res && (emrtd_tlv_write_header(out, 1, 0x87, 0x81) == 0); + + PrintAndLogEx(SUCCESS, "BER-TLV.......... ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + return res; +} + +bool emrtd_test(bool verbose) { + (void)verbose; + bool res = true; + + PrintAndLogEx(INFO, "------ " _CYAN_("eMRTD PACE tests") " ------"); + + res = test_padding() && res; + res = test_tlv() && res; + res = test_mrz_password() && res; + res = test_can_password() && res; + res = test_kdf() && res; + res = test_nonce() && res; + res = test_cardaccess() && res; + res = test_gm() && res; + res = test_ec_keygen() && res; + res = test_token() && res; + res = test_cam() && res; + res = test_ssc() && res; + res = test_sm_3des() && res; + res = test_sm_aes() && res; + + PrintAndLogEx(INFO, "---------------------------"); + PrintAndLogEx(SUCCESS, "Tests ( %s )", (res) ? _GREEN_("ok") : _RED_("fail")); + PrintAndLogEx(NORMAL, ""); + return res; +} diff --git a/client/src/emrtd/emrtd_pacetest.h b/client/src/emrtd/emrtd_pacetest.h new file mode 100644 index 000000000..1e7eb00be --- /dev/null +++ b/client/src/emrtd/emrtd_pacetest.h @@ -0,0 +1,26 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- +// Offline regression tests for the eMRTD PACE / secure messaging primitives +//----------------------------------------------------------------------------- + +#ifndef EMRTD_PACETEST_H__ +#define EMRTD_PACETEST_H__ + +#include "common.h" + +bool emrtd_test(bool verbose); + +#endif /* emrtd_pacetest.h */ From 26c23f68085ee8e57de6fb33a96741542e45042a Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Fri, 21 Aug 2026 23:15:01 +0200 Subject: [PATCH 06/12] fix missing files --- client/experimental_lib/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/client/experimental_lib/CMakeLists.txt b/client/experimental_lib/CMakeLists.txt index f6e8e89b8..f20b74400 100644 --- a/client/experimental_lib/CMakeLists.txt +++ b/client/experimental_lib/CMakeLists.txt @@ -251,6 +251,8 @@ set (TARGET_SOURCES ${PM3_ROOT}/client/src/crypto/duoxcrypto.c ${PM3_ROOT}/client/src/crypto/libpcrypto.c ${PM3_ROOT}/client/src/crypto/originality.c + ${PM3_ROOT}/client/src/emrtd/emrtd_pace.c + ${PM3_ROOT}/client/src/emrtd/emrtd_pacetest.c ${PM3_ROOT}/client/src/emv/test/cda_test.c ${PM3_ROOT}/client/src/emv/test/crypto_test.c ${PM3_ROOT}/client/src/emv/test/cryptotest.c From 95db5477472f4335dd7c3479b7128c09450481eb Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Sat, 22 Aug 2026 00:16:25 +0200 Subject: [PATCH 07/12] Remove object file --- client/deps/openjpeg/openjpeg.a | Bin 717158 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 client/deps/openjpeg/openjpeg.a diff --git a/client/deps/openjpeg/openjpeg.a b/client/deps/openjpeg/openjpeg.a deleted file mode 100644 index a30067f91dca8352daf5986c1307a16fd975bc54..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 717158 zcmeFae|%KMxj()qS;B&mvuLiSZCbazTW_{dnjqC|rR|>NY;qPil9o_n#Rd$Cpg>}> ztJqRRH$kSyLusp5@29=3{oLNx`}*{UpW9yRuh!iJk^qVcR0R}`h?)hFD2fpw`M#f- zIlCuI=#P8v_w)Vy@!i*J_ndiV=9y<^o_Xe(XP%k;?-)S$mxSZeV{spf8^7pZ;UDMC?9sHDQ`hU;2we7~n>sPfl zHnle|k2SmO;ELvsSbOVjnef{9n(J?iHFsnHtJbcHH8!tpnh03YoCUPSW7n^WW#Vsb zU**7$(pF@mT2{w9R%Sx0)-GSY>V~yE3?iDBuW6*zjUCO+H#vbTnp>8~SI2ndWblrg zR<%tE&%q;*pCfUWYW~*98=%n>_5Q32w}CM0q|WEzoeMQi-})y)%8NthGY#AF=V z#8d)X%j(wUv5Ck8$cbx0B93Z88rj$mPLL2$L~eUZXijU|y>d1dCre4h9nGTq8e8IP zn_{b4Cv-YRQlFnQQr7%jS<$2C%o^`#Zf{(%Jht4)AXH!`qH%Te+8bhmE1g`Jn<>k? z6B;WwS*&^WYG+wDpe!0wAcMFCrL~BmVz*2VKjt$3%H4Y@X&@n%Bk} z*L2(K1b#pt9ZEJ6BYF-gl#_ggU7bEqpVB{@P52aa!nR0xTqbRMt$GDstH|dvlZbb zcx)v}649&#YhJs8<5|;2C1ncW;>J-2nH`0$0ai>Ttt(co60O&|o7 zT+zHPgWK7@lvFedYCRbZyxDRH5%p}Os0>o7n}Dz2m|E9@v$OTdMmH`;-7?u^*_2b3 z&WVqsdu7*Wds@^h8zrf-Gw^6)OSs(OF>*_cO+{TvWO|jN& zkINS4J=?r4*1o*4wT;qcD=t!G>Py|7sVZp?RCq^hIk@dCun^c;s@mqt78ckLM62eq zVJ6Wz*iht}$c7nAHUn|O0Cf`2gJ<)q1WzQM5KdAjfY0J<8+I0-A>y13;OHtOo50Tq zXL;>xR-6#+U`45Slo!$72rA-y*T)bxG4t&mb07ANyIt$2k8Dh|IkpU0_jQf zk>IMcpxNmpBOAoHq@Wm+oGh6!GqYt=PsAXHH@Zs9c8+`#6AJ1Zo8ld@Rxw#-OLRhM zR*bKPkapJM<|aO)XSC!s08G%532^;wZOc14&ItzrqGs8o)LvpFW)*M;Ca!-_vuE<5 zb2zJ>RW=8pEwU+>-zq2(z?&NhZwr!jtfXenrfWv$1F5b5Q!*PeG0_AV*>-oAWIGw2fxN`jTwc!HEc#vEB?XD5`o(`Bxl5XBPav&OVQ z!%5Dj$_{OgDOb9PJY0-q^;%*b5wRjGV6rGzfcYnz2PT_7MJ}=65~Jj-RzecAhm7RZ z+X*T2*^|j60##&?d2{BKN%RWBTU%An)8~lRjJ7~s#}kmm!<1wP9db_!xl9(JU`VJV zoju#;B(%ZEMr&2sdM%`#2@o%SVyw+@xv8YSh=obx^3|(b1?3K4OMA0a3=t`m&NbPD z5KDF*zJvyAIbv-PiNV}tm(86lC7_cf&Jf{@%mBH(lIk1=QqxW7q^8#RS|JD8R@n{Y z=xYF-Q(iWWU|!yS0FwM#g<5npOD?k`gu*OeVqJt^+M|1L;qOI$_HiXY0_ z-ppqmlI&2QGe~kJQzNY^GqIxEvm%QS$v)v*UGCPAsb@vt+yq|#Y$z9?$v2SA#DEn6vUbdATR%5YCh z%N+HRPKtD?mxOqF!>sWdv!?cB!&4}l?J?LDhVqWVZuJ^$iN|0y#XW@YtcbpvV#)vn z9G|(c#H=aq+7Y`TkyiG;&K8zT>t(kVbNs0x&!bb3_Aw8B)ZZt8^NX%=mn$}hEh#a~ zC0^soC7zC*hP6O3*h25-Pnk6(mN5=|6A-x`BP5R&;Kz}#z5nReN$RK7FJ5GQeLV5u zCAZEt*cpwzn{5NOUuUly?D*cd60a-6K<7#vRXWnwUZ*YXF|6|m@YuiL$FM$6?}qh7 zdhmqmCAy2(x9g`ab;U+2?XyQ?b;Wm_q85rzf0C;E2*qkFR1z^m-pG|9 zPseWz%TOZB@Tw2Hrgc+>qd#h~`xtcStiPwuuFJ2Hdy=|j(o_GUvCH?MqtHFPZ_r2T zz1@lKsg9=Z_}YXnN{mj86+S|Y+5=Q*7jsGRqf`adNB#XCQ3JN5SPiFG4f+`jcV&&I zVX*;iA7r%NOzel<+atDJK{XL*wI&tb!=1l}4n zN#4e%#u0IJJB`XFSLs^cmwaW51HMZy_2GT~7k!t_T^z`Oxv-!e6h7IbBvK?OEGBp= z+vTEqQIAkhxN54ZzThied_8ocxUYQPoVjz#K07bYgL5~`oj0d!-kkD)j6ia1*2^ z6gprH^4;fvt(NZ}cfdBv_dDdX6wiC)`?d6}p5eVaPn%J^DPNo6OSs#n&nVVrcq?ak zwDXAeB&ETpkACtVoIy0wcOQlENr(rp=bQ3H})e+)oPtl-`cB`QaA8ZJ0C9?J|9t1lqi^Rl-9O?vu}-;z{_I z$*^6If0yu$5^nQNO2WOe3Y>QUdj{Xh=s76Ux5@OJe*ilo;UNqZ`q=z4ig%)CK*BRT zB!+ooW8GK7_4U^@RxiG~sy?#t>c+-7<*vz~Wv)5VD*jVWZ*%GAGWwa98T$@Z#IXV+ zso>NEGHVNp`0v_bZES>riH!X%%U20=7h%t=L@1Emv!al_-zxYDLlEsmym)$Ce7+>x zmt@Wb4){U|r}V_tHa}eJfYT_j@m%kKlRUKHH#qQuxQ|0cyGfKBGA{>i^RSTvx5v}c z9C%2E+j8K`WVka2zEOtn&w<~ZH+b0!94d_ z*oR=^5aAov#^+#bt_^&B8!}QU%_|#Q$Vw-v{Lepp$Vx1jD}O_P(dVP~L@R}mdM-ewm*`~3<(iE*!kL@=ugzbM zyo7TuzRr)GpXhUb?DFkr2$A&egegkm(-I?^I+y>3bZ>L?07m`D{^&gV?eRe|mwCT3N zoA5&A=jP{3MTv5V%guiWl1#>b8%YS_V~=CvKUxCX`ECB2v~0>KRh5t=jAY(q`Kg%6 znkqz%f{!PM{+ytT^p45$w@E>~m1D{NDlh_?v)Q*GC=SPd3M716-aOcmIYkkR$R?Vn4(fJC6j zFyk(Ry*$3S)JTkutDQ7=7=fOMvK`6PE&oA5GrTOS3>(TmBN+B}JZ)Hi2dL|h#G+C5 zMtO3Wf|Lr#yis-t4TSU&_MXAQ%OZj8JU&s|<|c|Rr6!89VOm{l*YzM_RA~)m>8n|W zRPh6pD$=)|+UZ)P7KuS`B=DZ0j2OzTp(tx@;ANl{CZObNB{2Q1d4lM_$GQ4SQX zc3q1y)9dkLua}=igHN(v&aC}&`;!emLT!T%D^46yj6gq&`3nsz<}OT}%D?q|gY6V8 zme^LDu`iHiVUjY0?FNY0fVE&;;L+XZB|gZ%b&mS5XS13(rNk~#A2!A}FH{nz@?sa_ zeQfi>yu>MYe5(3z=*;Gtd^AtCpwQ$6Ir+`198Zkq-&)EB`uG%T1bU4`ue)nctf)N6 zQi-IZs}H+XeY1N;aG?FItYINKIc}%zgWHa%E{3HSj8i?zL?PSm9u%|d0fF)nMf zFmJOlCTp`Ke{V6f+mY5T(J!+RpBbg?1g5Zn<-4g0P&Qg4+;rwt&SG*am@$`?`}K8fh) zw0;Ujry*j9IW>Tj4+4ORe(bU}~$@YK!K=&TxLb9Dh8d7G=J z;E}(%+Kq>Mb9Fu*Q#M!U;Zd-;TES!LW=H-Lx%ET!P&+mV%0Nph?VUCP3h_FvpQsVU zbW(E&TisMn%|<)S>7g<~50wdesLXtn$@x*MhxzP}>yR9h^30PYzDYXyPN*CB41*_M zQmYs7pn8!A1>Al$5cPWn^LHiHPFjE(Y~@M_41@IuIIF5KAXpm>RuwX<+QMCj<5wCc z$6%OT@Fe<`7PYm=kDsM}FRN-Z*gk_@Wf*KxojP+-u{!fw2(xWIVZY1Cns-#RJ7k_c z2z})*00U1g_=SxWWYKOLeuFXo0Fwb*Ig%GhQprmQDxtEKb`PwzWt`cg-Fa1|N7h6dCt68w{zXhC0!Iiv({5%zR#*I_ZA80PI22K!d%=prFUQGHg0 zeBEN&5c5PwC>k756Dvtxvf~kDn`j=ilVL7G;%|iv<=IH!IU|43GW6CmqpwO%tQ{*2 zv#QuIFN_3Fw*O0%ouo-t6oF|eb`A1lcKKEXa2iTCFNNkifpU8!(0lYZQofrsGtd+y z%Lb8DzFm@1g_4O5o@vw8iSxm6IhiG{YIECJ&;+p{=Aa=y2Wj7s{4+^8N)_+|zbp$G z<9(67ZF~;94hU$%bLOvQ@7i=m6|@~2iUv9w@VZP)j!3(enh6n{W{EcwN&Q=^yc=aO z&x`7w3r$uZA^9^=zd^s69inr(PR1`e`V}sh&}bnJSNcf&Qr4V#P-W9AJ_D2+OEM42?i7L%daSq3)O0J|%0dolg1z%H=iD2kP z9-}YJ2kOyYn}0x{ts>hb&chJS4m9wEc^S1PbY=9^#iS(@Vw(x%e9Ue#zY!QH-(z&`FjO6KXqzXaO)bcSY&d(j##ZRA znmjryFHf$^AHTuKY?##lRq5+8={x^IdbwW_tSM9PO+uCEp%qV)tBvn)`@Zx=UzuwW z_dW5!%Gb2Ad4+FPtiuO?8Q&+TyTarW?=k9)F^Hu6l4(g;6~;J$Z_I7~6| zlM`P#S-kK}nj8V;cg7Qfzj1qr6GRILvXhVo^|$O1kD~c(~@{>60)V4VC+K5!$bd(0-jhBb4{u>AWxOZMzjSeAV_Q9;b1c z%ujUChw2%Vupj|=JzILHqLgN59zMGS7 zBVZnBXgW#l0^Zw_7oJgU{^zBMUmWwGzv&2 zP33v@Igs#q-{6@tNw|&jZb<{5(I%&5y-KYd1pF{2DMLd`Oz8|O96sL;*=SM~Hh z_4Mv%`2Jxj2@-rBqMvh(O^AgFWAp5BN5hEMb)CeQl`S<=wyZ@}Mg5HP47=96&wnZN zILAy9IMpNFUq*t6jwXLOR$j~81b2#gd;u|iN~M)CHDB+_l~E!LJ})q zdE))!_$rWoNeRDDK537b;1A@$BNDz*!fl&)ql7QZfyX7>C*k(flyGVb`qDvT21NTe#MhUlDaK40Zm2f_% z;r%OsJKI)9yBf~{UnB99NttESvq{2j8$6$@fb5^nf#(64-j=U?{zCfSO1N!kua^XE zm+)m$zBEbr^AbKF;r3WOD&a#C&gU@X8MpDsac9q87oa}8Jtf?p!#*wH4@tOr0E=;cc=5`Fw`B43FY(TiE=spT*2K@#HvoLVsh6=_Avxn;y4rA z@Z2?22A*^1JG*wG1x@x0@Y%j7k{TP4@R6Hj6||;#O;elj$ab!eoTu5viV7>HoJE*S zBeG3AK0g8G#5FM)ug?FOQ}&HD(S?;-v~gi|^`dZnW4%@x4L9-{HDym}I9!Ni`-zI= zc8`SGos)4d%4u|mb5bS-FVde}g0S=#JoEn_&Hv9H&4;YI6!Ri|AkMj{vVDd=FX0eN zu8-hr!xuZ?B-?HHtLMP;jw8Jjk4gpNLk|+2w8o>4)2E6yNo@R|a-^rZ!-m_wRzxTH zKiTjbWO{;=j%&j^9C)Z)p(narw>#j@ayL2PssoSd!0#;gMMrwV|08_qGwgsn@gH}< zo%rpwVQ#%DFb~m(vJw9E6u?J!z@7N7a=@MV>m)oE|1TWr3I9@#9r~FA?!^C?1MbBC zz%q`pJ*C#^y3elZ+yn)__{LI?a~4*1s`@QWSr6%tPMn&p76cfe`RwejCC;hzEQ zvkv%A9Pl{~_+AH`YzQ`<0}i-zT)ZjaM9=3O>C2=(k_%rb6?cL=`F7Vi;3p)U_<>Xh zo1Q$W*AO1(xVy{&cjE6j2b`a20FGRGE|&@rl}kFIU2dg>=a%~m2b^?8JN+vTxRajq zq;C!3ai+i00e7bVo&)Yo-z(unC+UiIxz9S%JKJX-F+D!H<)$Ru9(N@ond@l>+&M1( zoqFjM86ZiSL&5E{W9n(aloDU|K0(2 z%G**2&&3~dq$d(=dZG@v6aOLy+=;*89QbdL@Xr9ZbG#Qi#!1^2#goD2JdVhTm+$ZIN-9L8vjS{{sC%wI%9m;|8 zNe1P-n*+DkvmQC$+4z^qar@uolPz4d;f*akw*SBM%0?sL4DML;m-j_+IATEejnnTAG`l;*k-&C&fNUNGJmlg zk9PXp{0T%%#(#C67CF{QxkJrKqQcHkx-WeuE1O5yhCj)_L=J&+^OO1~i{RNZKcu|i zbDfkkB6N29kxn;R{{B*tW{`hLEJ_*;jrT%@j!NCr1MA>(><=zwxCe=HiKst@QLz7zSNM0m$ zXi7xscDOFVS5H%0J@nJyjUP-vKb*NwtIaZv5uwOQ@$+uWj#rPSWN2V2zk zA$TvI8qn04Um2+lcE=yna1uB%bh^eWa#dS?CDL>tY%RzOTMbHW)8VK!@1Lm!YMXZG z=IZ<13#`>;aM_9aM|86mi`c^ZwZRXVw zAB9$%^;_M8XSBePYF4yG5B6=qdFCs1GkSlCru0|luP^h}HYEqgwZI3}tZ) zyISin$P2U6TH>&xcK#h$+A!Dq_v!3ZV5gCKBQI*XzZ5n-HCA+5o|gI`PgltESKadW zXmZ{9>KNOr@&0@qIdNz^YBjhGYw13B)N1oYf-kVWQ7if-gl69#Qh%_$Hu#o?hvqq^ zb~5Cs4eW{}J}gu>tw#We(C5Fvn+~jhq+uT}e<5`=uSHYWK4+v}b+@Q(dtArZhSoJqiB#74gpktAz8>)z<8Pl`LB3)~tnMzzxD*H+D(134<@%G^p%Aj!JXh7AtmnUTQ2af8ORwHgBuZ zwC7qw>ATKI9m>;|Mp-YpMQV*{B9z)$H>Xnfciw|>&35YS1ASJ=J($+m4lq6jXptqV zH2)%xCQct(EF%5p}>L$|ttW}(CFka4A7FbI!0t3zdbtHJS@Q(2-cV`E$I@1j%=!UD|k$4}ZXX3Tf zXg_vDOPo<|xhkThqt=RHx0ZNqjE~bTe4K7^>&g)lEcJfRStAzULinub4A}>DYu-%V zntg%MbR^LYk$6pzP)n?(t)%nqfQBH~rN(3Hs>#Pt%^T4-1q3nz{?W{D5wp8ZV zZ*gPrV(jAe!NN*b?{jy(5WlR-D*BkN>_`7%%+cUkU=`kvdGB7*5~59z$;kdktNsF! zwaCL}Vv>tA4P0xmvCQ~v{Na$@@WNMgGZR*0d%eVD&EPt7WMu$q

e_2-&?!7+so|O8V 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%0As68Ua|tt4x0|(1el%?Y7UZSRG1OvB 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�ivTuwCw+j4 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 dur!pgPkw({^WB&)em@%)+<&*X?0 Date: Sat, 22 Aug 2026 00:54:36 +0200 Subject: [PATCH 08/12] Try to fix MSYS2 compilation with openjpeg --- client/Makefile | 2 ++ client/deps/openjpeg.cmake | 2 ++ client/deps/openjpeg/Makefile | 3 ++- 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/client/Makefile b/client/Makefile index b7e462785..00e23363f 100644 --- a/client/Makefile +++ b/client/Makefile @@ -961,6 +961,8 @@ ifeq ($(QT_FOUND),1) CXXSRCS = proxgui.cpp proxguiqt.cpp proxguiqt.moc.cpp # Qt has no JPEG2000 image handler, so we decode EF_DG2 & friends ourselves SRCS += imgjp2.c + # openjpeg.a is a static lib, avoid __declspec(dllimport) on its Windows API decls + PM3CFLAGS += -DOPJ_STATIC STATICLIBS += $(OPENJPEGLIB) LDLIBS += $(OPENJPEGLIBLD) else diff --git a/client/deps/openjpeg.cmake b/client/deps/openjpeg.cmake index 403f6c32f..e1b5f489e 100644 --- a/client/deps/openjpeg.cmake +++ b/client/deps/openjpeg.cmake @@ -28,6 +28,8 @@ add_library(pm3rrg_rdv4_openjpeg STATIC target_include_directories(pm3rrg_rdv4_openjpeg INTERFACE openjpeg) target_include_directories(pm3rrg_rdv4_openjpeg PRIVATE openjpeg) +# openjpeg.a is a static lib, avoid __declspec(dllimport) on its Windows API decls +target_compile_definitions(pm3rrg_rdv4_openjpeg PUBLIC OPJ_STATIC) # Third party code, don't hold it to our warning settings target_compile_options(pm3rrg_rdv4_openjpeg PRIVATE -w -O3) set_property(TARGET pm3rrg_rdv4_openjpeg PROPERTY POSITION_INDEPENDENT_CODE ON) diff --git a/client/deps/openjpeg/Makefile b/client/deps/openjpeg/Makefile index 8fd3ed6b1..dbc696bbe 100644 --- a/client/deps/openjpeg/Makefile +++ b/client/deps/openjpeg/Makefile @@ -2,7 +2,8 @@ MYSRCPATHS = MYINCLUDES = # Third party code, don't fail the build on upstream's warnings MYCFLAGS = -w -O3 -MYDEFS = +# Avoid __declspec(dllimport/dllexport) on Windows, we always link this in statically +MYDEFS = -DOPJ_STATIC MYSRCS = \ bio.c \ cio.c \ From dafce323b468b5edd1bba6d47fb4f3c7bc25cef7 Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Sat, 22 Aug 2026 09:51:18 +0200 Subject: [PATCH 09/12] fix strncpy warnings on proxspace --- client/src/cmdhfemrtd.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/client/src/cmdhfemrtd.c b/client/src/cmdhfemrtd.c index d42d5f141..727ea58ab 100644 --- a/client/src/cmdhfemrtd.c +++ b/client/src/cmdhfemrtd.c @@ -2814,10 +2814,10 @@ static void emrtd_fill_auth(emrtd_auth_t *auth, const char *docnum, const char * const char *can, bool mrz_available, bool can_available, bool force_pace, bool force_bac) { memset(auth, 0, sizeof(emrtd_auth_t)); - strncpy(auth->documentnumber, docnum, sizeof(auth->documentnumber) - 1); - strncpy(auth->dob, dob, sizeof(auth->dob) - 1); - strncpy(auth->expiry, expiry, sizeof(auth->expiry) - 1); - strncpy(auth->can, can, sizeof(auth->can) - 1); + snprintf(auth->documentnumber, sizeof(auth->documentnumber), "%s", docnum); + snprintf(auth->dob, sizeof(auth->dob), "%s", dob); + snprintf(auth->expiry, sizeof(auth->expiry), "%s", expiry); + snprintf(auth->can, sizeof(auth->can), "%s", can); auth->mrz_available = mrz_available; auth->can_available = can_available; auth->force_pace = force_pace; From 6a35aec1ba349ffe86cd8a08befd74d560ee515c Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Sat, 22 Aug 2026 10:03:03 +0200 Subject: [PATCH 10/12] fix code scanning warning of potential overflow --- client/deps/openjpeg/j2k.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/client/deps/openjpeg/j2k.c b/client/deps/openjpeg/j2k.c index a2014c89b..29ce1c735 100644 --- a/client/deps/openjpeg/j2k.c +++ b/client/deps/openjpeg/j2k.c @@ -8129,14 +8129,15 @@ OPJ_BOOL opj_j2k_setup_encoder(opj_j2k_t *p_j2k, /* initialize the multiple tiles */ /* ---------------------------- */ - cp->tcps = (opj_tcp_t*) opj_calloc(cp->tw * cp->th, sizeof(opj_tcp_t)); + const size_t num_tiles = (size_t)cp->tw * (size_t)cp->th; + cp->tcps = (opj_tcp_t*) opj_calloc(num_tiles, sizeof(opj_tcp_t)); if (!cp->tcps) { opj_event_msg(p_manager, EVT_ERROR, "Not enough memory to allocate tile coding parameters\n"); return OPJ_FALSE; } - for (tileno = 0; tileno < cp->tw * cp->th; tileno++) { + for (tileno = 0; tileno < num_tiles; tileno++) { opj_tcp_t *tcp = &cp->tcps[tileno]; const OPJ_BOOL fixed_distoratio = cp->m_specific_param.m_enc.m_quality_layer_alloc_strategy == From 74f2dcc52ccf1cc5908b5de2c6dc91203bf5802a Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Sat, 22 Aug 2026 10:03:49 +0200 Subject: [PATCH 11/12] fix warning of comparision of narrow type ... in loop --- client/src/cmdhfsaflok.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/client/src/cmdhfsaflok.c b/client/src/cmdhfsaflok.c index d7fe63b51..61219d771 100644 --- a/client/src/cmdhfsaflok.c +++ b/client/src/cmdhfsaflok.c @@ -673,7 +673,7 @@ static saflok_mfc_datetime_t add_offset(const saflok_mfc_datetime_t *base, const // variable days per month ... loop is simplest option uint8_t curr_days_in_month = get_days_in_month(tm.tm_year + 1900, tm.tm_mon + 1); - for (; ((tm.tm_mday & 0xFF) > curr_days_in_month); curr_days_in_month = get_days_in_month(tm.tm_year + 1900, tm.tm_mon + 1)) { + for (; (tm.tm_mday > (int)curr_days_in_month); curr_days_in_month = get_days_in_month(tm.tm_year + 1900, tm.tm_mon + 1)) { tm.tm_mon ++; tm.tm_mday -= curr_days_in_month; From 26571b5efe929742f3b951d2d41fe33c76a4a99b Mon Sep 17 00:00:00 2001 From: dxl <64101226@qq.com> Date: Sat, 22 Aug 2026 18:37:39 +0800 Subject: [PATCH 12/12] Updated Changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 16e10cbf2..6a063367e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,8 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac - Fixed `hw version` / `hw status` (PM5) - now showing correct information for fpga images (@nemanjan00) - Fixed `hw status` [Model] section reporting "PM3 GENERIC" firmware on Proxmark5 (PM5/AT32); it now reports `PM5` (@nemanjan00) - Added `hw version` / `hw status` - now reports Proxmark5 (PM5/AT32) correct MCU (AT32F437) (@nemanjan00) +- Added CMake support for armsrc and bootrom (@xianglin1998) +- Added HAL support for ARM firmware (@xianglin1998) - Fixed `hf mf dump` - preserving readable sector trailer Key B data (@oSPANNERo) - Changed `magic_cards_notes.md` - documented the USCUID-UL helper scripts (`hf_mfu_uscuid` / `hf_mf_uscuid_prog`) (@c-barron) - Fixed `hf_mf_uscuid_prog.lua` - corrected the script name shown in its usage text (@c-barron)