From c7ac39f37629381a39b6a021243b98126442ded8 Mon Sep 17 00:00:00 2001 From: achazal Date: Wed, 3 Jun 2026 20:21:01 +0200 Subject: [PATCH] mad: harden MAD parser with typed structs and fix memory safety bugs --- client/src/cmdhfgallagher.c | 11 +- client/src/cmdhfmf.c | 129 ++++++---- client/src/cmdhfmfp.c | 49 ++-- client/src/cmdnfc.c | 7 +- client/src/mifare/gallaghertest.c | 7 +- client/src/mifare/mad.c | 392 ++++++++++++++++++++---------- client/src/mifare/mad.h | 89 ++++++- 7 files changed, 471 insertions(+), 213 deletions(-) diff --git a/client/src/cmdhfgallagher.c b/client/src/cmdhfgallagher.c index 08ffbec17..d8ed2c73f 100644 --- a/client/src/cmdhfgallagher.c +++ b/client/src/cmdhfgallagher.c @@ -999,20 +999,19 @@ static int hfgal_update_mad(uint8_t cred_sector, uint8_t cad_sector, return res; } + mad1_sector_t *m = (mad1_sector_t *)sector0; + // Set AID for credential sector (0x4812) if (cred_sector >= 1 && cred_sector <= 15) { - sector0[16 + 2 + (cred_sector - 1) * 2] = CLASSIC_CRED_AID & 0xFF; - sector0[16 + 2 + (cred_sector - 1) * 2 + 1] = (CLASSIC_CRED_AID >> 8) & 0xFF; + mad_aid_set(&m->aid[cred_sector - 1], CLASSIC_CRED_AID); } // Set AID for CAD sector (0x4811) if (cad_sector >= 1 && cad_sector <= 15) { - sector0[16 + 2 + (cad_sector - 1) * 2] = CLASSIC_CAD_AID & 0xFF; - sector0[16 + 2 + (cad_sector - 1) * 2 + 1] = (CLASSIC_CAD_AID >> 8) & 0xFF; + mad_aid_set(&m->aid[cad_sector - 1], CLASSIC_CAD_AID); } - // Recalculate CRC over bytes 17..47 (info byte + 15 AID entries) - sector0[16] = CRC8Mad(§or0[16 + 1], 15 + 16); + m->crc = MADComputeCRC(m); // Write blocks 1 and 2 of sector 0 back (block 0 is manufacturer block, don't touch) res = mf_write_block(1, mad_key_type, mad_key, §or0[MFBLOCK_SIZE]); diff --git a/client/src/cmdhfmf.c b/client/src/cmdhfmf.c index 3065a4285..c863021e5 100644 --- a/client/src/cmdhfmf.c +++ b/client/src/cmdhfmf.c @@ -703,7 +703,8 @@ void mf_print_blocks(uint16_t n, uint8_t *d, bool verbose) { } // MAD detection - if (HasMADKey(d)) { + mad_sector_t mad_sec = {d, n * MFBLOCK_SIZE}; + if (HasMADKey(&mad_sec)) { PrintAndLogEx(HINT, "Hint: MAD key detected. Try `" _YELLOW_("hf mf mad") "` for more details"); } PrintAndLogEx(NORMAL, ""); @@ -6902,7 +6903,8 @@ static int CmdHF14AMfMAD(const char *Cmd) { } // MAD detection - if ((HasMADKey(dump) == false) && (force == false)) { + mad_sector_t dump_sec = {dump, bytes_read}; + if ((HasMADKey(&dump_sec) == false) && (force == false)) { PrintAndLogEx(FAILED, "No MAD key was detected in the dump file"); free(dump); return PM3_ESOFT; @@ -6910,9 +6912,9 @@ static int CmdHF14AMfMAD(const char *Cmd) { MADPrintHeader(); bool haveMAD2 = false; - MAD1DecodeAndPrint(dump, swapmad, verbose, &haveMAD2); + MAD1DecodeAndPrint(&dump_sec, swapmad, verbose, &haveMAD2); - int sector = DetectHID(dump, 0x484d); + int sector = DetectHID(&dump_sec, 0x484d); if (sector > -1) { // decode it @@ -6921,7 +6923,7 @@ static int CmdHF14AMfMAD(const char *Cmd) { PrintAndLogEx(INFO, _CYAN_("HID PACS detected")); uint8_t pacs_sector[MFBLOCK_SIZE * 3] = {0}; - memcpy(pacs_sector, dump + (sector * 4 * 16), sizeof(pacs_sector)); + memcpy(pacs_sector, dump + (sector * 4 * MFBLOCK_SIZE), sizeof(pacs_sector)); if (pacs_sector[16] == 0x02) { @@ -6944,7 +6946,7 @@ static int CmdHF14AMfMAD(const char *Cmd) { } } - sector = DetectHID(dump, 0x4910); + sector = DetectHID(&dump_sec, 0x4910); if (sector > -1) { // decode it PrintAndLogEx(INFO, ""); @@ -6952,13 +6954,18 @@ static int CmdHF14AMfMAD(const char *Cmd) { } if (haveMAD2) { - MAD2DecodeAndPrint(dump + (MIFARE_1K_MAXBLOCK * MF_MAD2_SECTOR), swapmad, verbose); + size_t mad2_off = MIFARE_1K_MAXBLOCK * MF_MAD2_SECTOR; + size_t mad2_len = (bytes_read > mad2_off) ? bytes_read - mad2_off : 0; + mad_sector_t mad2_sec = {dump + mad2_off, mad2_len}; + MAD2DecodeAndPrint(&mad2_sec, swapmad, verbose); } if (aidlen == 2 || decodeholder) { - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - if (MADDecode(dump, dump + (0x10 * MIFARE_1K_MAXBLOCK), mad, &madlen, swapmad, override)) { + size_t sector16_off = 0x10 * MIFARE_1K_MAXBLOCK; + size_t sector16_len = (bytes_read > sector16_off) ? bytes_read - sector16_off : 0; + mad_sector_t s16 = {dump + sector16_off, sector16_len}; + mad_t mad = {0}; + if (MADDecode(&dump_sec, &s16, &mad, swapmad, override) != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); free(dump); return PM3_ESOFT; @@ -6972,7 +6979,42 @@ static int CmdHF14AMfMAD(const char *Cmd) { PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "-------- " _CYAN_("Card Holder Info 0x%04x") " --------", aaid); - MADCardHolderInfoDecode(dump, bytes_read, verbose); + uint8_t chdata[MIFARE_4K_MAX_BYTES] = {0}; + int chdatalen = 0; + + for (size_t i = 0; i < mad.count; i++) { + if (aaid != mad.entries[i]) + continue; + + uint8_t sectorNo = i + 1; + size_t sec_off = mfFirstBlockOfSector(sectorNo) * MFBLOCK_SIZE; + uint8_t nblocks = mfNumBlocksPerSector(sectorNo); + size_t sec_size = nblocks * MFBLOCK_SIZE; + + if (sec_off + sec_size > bytes_read) + continue; + + if (aidlen == 2) { + for (int j = 0; j < (verbose ? nblocks : nblocks - 1); j++) + PrintAndLogEx(INFO, " [%03d] %s", (int)(mfFirstBlockOfSector(sectorNo) + j), sprint_hex(&dump[sec_off + j * MFBLOCK_SIZE], MFBLOCK_SIZE)); + } + + if (decodeholder) { + size_t data_size = (nblocks - 1) * MFBLOCK_SIZE; + if (chdatalen + data_size > sizeof(chdata)) + break; + memcpy(&chdata[chdatalen], dump + sec_off, data_size); + chdatalen += data_size; + } + } + + if (decodeholder) { + if (chdatalen == 0) { + PrintAndLogEx(WARNING, "no Card Holder Info data"); + } else { + MADCardHolderInfoDecode(chdata, chdatalen, verbose); + } + } } free(dump); return PM3_SUCCESS; @@ -7034,16 +7076,18 @@ static int CmdHF14AMfMAD(const char *Cmd) { MADPrintHeader(); bool haveMAD2 = false; - MAD1DecodeAndPrint(sector0, swapmad, verbose, &haveMAD2); + mad_sector_t s0 = {sector0, sizeof(sector0)}; + MAD1DecodeAndPrint(&s0, swapmad, verbose, &haveMAD2); if (haveMAD2) { - MAD2DecodeAndPrint(sector10, swapmad, verbose); + mad_sector_t s10 = {sector10, sizeof(sector10)}; + MAD2DecodeAndPrint(&s10, swapmad, verbose); } if (aidlen == 2 || decodeholder) { - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - if (MADDecode(sector0, sector10, mad, &madlen, swapmad, override)) { + mad_sector_t s10 = {sector10, sizeof(sector10)}; + mad_t mad = {0}; + if (MADDecode(&s0, &s10, &mad, swapmad, override) != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return PM3_ESOFT; } @@ -7065,17 +7109,17 @@ static int CmdHF14AMfMAD(const char *Cmd) { PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "-------------- " _CYAN_("AID 0x%04x") " ---------------", aaid); - for (int i = 0; i < madlen; i++) { - if (aaid == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (aaid == mad.entries[i]) { uint8_t vsector[MFBLOCK_SIZE * 4] = {0}; if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) { PrintAndLogEx(NORMAL, ""); - PrintAndLogEx(ERR, "error, read sector %d", i + 1); + PrintAndLogEx(ERR, "error, read sector %d", (int)(i + 1)); return PM3_ESOFT; } for (int j = 0; j < (verbose ? 4 : 3); j ++) - PrintAndLogEx(NORMAL, " [%03d] %s", (i + 1) * 4 + j, sprint_hex(&vsector[j * MFBLOCK_SIZE], MFBLOCK_SIZE)); + PrintAndLogEx(NORMAL, " [%03d] %s", (int)((i + 1) * 4 + j), sprint_hex(&vsector[j * MFBLOCK_SIZE], MFBLOCK_SIZE)); } } } @@ -7088,17 +7132,18 @@ static int CmdHF14AMfMAD(const char *Cmd) { uint8_t data[MIFARE_4K_MAX_BYTES] = {0}; int datalen = 0; - for (int i = 0; i < madlen; i++) { - if (aaid == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (aaid == mad.entries[i]) { uint8_t vsector[MFBLOCK_SIZE * 4] = {0}; if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) { PrintAndLogEx(NORMAL, ""); - PrintAndLogEx(ERR, "error, read sector %d", i + 1); + PrintAndLogEx(ERR, "error, read sector %d", (int)(i + 1)); return PM3_ESOFT; } - // skip ST block hence only 3 blocks copy + if (datalen + MFBLOCK_SIZE * 3 > (int)sizeof(data)) + break; memcpy(&data[datalen], vsector, MFBLOCK_SIZE * 3); datalen += MFBLOCK_SIZE * 3; } @@ -7209,7 +7254,9 @@ int CmdHFMFNDEFRead(const char *Cmd) { } bool haveMAD2 = false; - int res = MADCheck(sector0, sector10, verbose, &haveMAD2); + mad_sector_t s0 = {sector0, sizeof(sector0)}; + mad_sector_t s10 = {sector10, sizeof(sector10)}; + int res = MADCheck(&s0, &s10, verbose, &haveMAD2); if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "MAD error %d", res); if (override) @@ -7218,17 +7265,16 @@ int CmdHFMFNDEFRead(const char *Cmd) { return res; } - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - res = MADDecode(sector0, sector10, mad, &madlen, false, override); + mad_t mad = {0}; + res = MADDecode(&s0, &s10, &mad, false, override); if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return res; } PrintAndLogEx(INFO, "reading data from tag"); - for (int i = 0; i < madlen; i++) { - if (ndef_aid == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (ndef_aid == mad.entries[i]) { uint8_t vsector[MFBLOCK_SIZE * 4] = {0}; if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, ndefkey, vsector)) { PrintAndLogEx(ERR, "error, reading sector %d ", i + 1); @@ -7648,9 +7694,10 @@ int CmdHFMFNDEFWrite(const char *Cmd) { } // decode MAD v1 - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - res = MADDecode(sector0, sector10, mad, &madlen, false, false); + mad_sector_t s0 = {sector0, sizeof(sector0)}; + mad_sector_t s10 = {sector10, sizeof(sector10)}; + mad_t mad = {0}; + res = MADDecode(&s0, &s10, &mad, false, false); if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return res; @@ -7661,9 +7708,9 @@ int CmdHFMFNDEFWrite(const char *Cmd) { uint8_t freemem[MIFARE_4K_MAXSECTOR] = {0}; uint16_t sum = 0; uint8_t block_no = 0; - for (uint8_t i = 1; i < (madlen & 0xFF); i++) { + for (uint8_t i = 1; i < (mad.count & 0xFF); i++) { - freemem[i] = (mad[i] == NDEF_MFC_AID); + freemem[i] = (mad.entries[i] == NDEF_MFC_AID); if (freemem[i]) { @@ -8521,16 +8568,16 @@ static int CmdHF14AMfView(const char *Cmd) { mf_save_keys_from_arr(block_cnt, dump); } - int sector = DetectHID(dump, 0x4910); + mad_sector_t dump_sec = {dump, bytes_read}; + int sector = DetectHID(&dump_sec, 0x4910); if (sector > -1) { // decode it PrintAndLogEx(INFO, ""); PrintAndLogEx(INFO, _CYAN_("VIGIK PACS detected")); // decode MAD v1 - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - res = MADDecode(dump, NULL, mad, &madlen, false, true); + mad_t mad = {0}; + res = MADDecode(&dump_sec, NULL, &mad, false, true); if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return res; @@ -8557,8 +8604,8 @@ static int CmdHF14AMfView(const char *Cmd) { pdump += (MFBLOCK_SIZE * 4); // skip sectortrailer // extract memory from MAD sectors - for (int i = 0; i <= madlen; i++) { - if (0x4910 == mad[i] || 0x4916 == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (0x4910 == mad.entries[i] || 0x4916 == mad.entries[i]) { memcpy(d.bytes + dlen, pdump, MFBLOCK_SIZE * 3); dlen += MFBLOCK_SIZE * 3; } diff --git a/client/src/cmdhfmfp.c b/client/src/cmdhfmfp.c index 002742c0c..a770437ff 100644 --- a/client/src/cmdhfmfp.c +++ b/client/src/cmdhfmfp.c @@ -2610,7 +2610,8 @@ static int CmdHFMFPMAD(const char *Cmd) { } bool haveMAD2 = false; - MAD1DecodeAndPrint(sector0, swapmad, verbose, &haveMAD2); + mad_sector_t s0 = {sector0, sizeof(sector0)}; + MAD1DecodeAndPrint(&s0, swapmad, verbose, &haveMAD2); if (haveMAD2) { if (mfpReadSector(MF_MAD2_SECTOR, MF_KEY_A, (uint8_t *)g_mifarep_mad_key, sector16, verbose)) { @@ -2619,13 +2620,14 @@ static int CmdHFMFPMAD(const char *Cmd) { return PM3_ESOFT; } - MAD2DecodeAndPrint(sector16, swapmad, verbose); + mad_sector_t s16 = {sector16, sizeof(sector16)}; + MAD2DecodeAndPrint(&s16, swapmad, verbose); } if (aidlen == 2 || decodeholder) { - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - if (MADDecode(sector0, sector16, mad, &madlen, swapmad, override)) { + mad_sector_t s16 = {sector16, sizeof(sector16)}; + mad_t mad = {0}; + if (MADDecode(&s0, &s16, &mad, swapmad, override) != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return PM3_EWRONGANSWER; } @@ -2645,17 +2647,17 @@ static int CmdHFMFPMAD(const char *Cmd) { PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "-------------- " _CYAN_("AID 0x%04x") " ---------------", aaid); - for (int i = 0; i < madlen; i++) { - if (aaid == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (aaid == mad.entries[i]) { uint8_t vsector[16 * 4] = {0}; if (mfpReadSector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector, false)) { PrintAndLogEx(NORMAL, ""); - PrintAndLogEx(ERR, "error, read sector %d error", i + 1); + PrintAndLogEx(ERR, "error, read sector %d error", (int)(i + 1)); return PM3_ESOFT; } for (int j = 0; j < (verbose ? 4 : 3); j ++) - PrintAndLogEx(NORMAL, " [%03d] %s", (i + 1) * 4 + j, sprint_hex(&vsector[j * 16], 16)); + PrintAndLogEx(NORMAL, " [%03d] %s", (int)((i + 1) * 4 + j), sprint_hex(&vsector[j * 16], 16)); } } } @@ -2668,18 +2670,20 @@ static int CmdHFMFPMAD(const char *Cmd) { uint8_t data[4096] = {0}; int datalen = 0; - for (int i = 0; i < madlen; i++) { - if (aaid == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (aaid == mad.entries[i]) { uint8_t vsector[16 * 4] = {0}; if (mf_read_sector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, akey, vsector)) { PrintAndLogEx(NORMAL, ""); - PrintAndLogEx(ERR, "error, read sector %d", i + 1); + PrintAndLogEx(ERR, "error, read sector %d", (int)(i + 1)); return PM3_ESOFT; } - memcpy(&data[datalen], vsector, 16 * 3); - datalen += 16 * 3; + if (datalen + MFBLOCK_SIZE * 3 > (int)sizeof(data)) + break; + memcpy(&data[datalen], vsector, MFBLOCK_SIZE * 3); + datalen += MFBLOCK_SIZE * 3; } } @@ -2788,7 +2792,8 @@ int CmdHFMFPNDEFRead(const char *Cmd) { } bool haveMAD2 = false; - int res = MADCheck(sector0, NULL, verbose, &haveMAD2); + mad_sector_t s0 = {sector0, sizeof(sector0)}; + int res = MADCheck(&s0, NULL, verbose, &haveMAD2); if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "MAD error %d", res); if (override) @@ -2809,17 +2814,21 @@ int CmdHFMFPNDEFRead(const char *Cmd) { } } - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - res = MADDecode(sector0, (haveMAD2 ? sector16 : NULL), mad, &madlen, false, override); + mad_sector_t s16 = {0}; + if (haveMAD2) { + s16.data = sector16; + s16.len = sizeof(sector16); + } + mad_t mad = {0}; + res = MADDecode(&s0, haveMAD2 ? &s16 : NULL, &mad, false, override); if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return res; } PrintAndLogEx(INFO, "reading data from tag"); - for (int i = 0; i < madlen; i++) { - if (ndefAID == mad[i]) { + for (size_t i = 0; i < mad.count; i++) { + if (ndefAID == mad.entries[i]) { uint8_t vsector[MIFARE_1K_MAXBLOCK] = {0}; if (mfpReadSector(i + 1, keyB ? MF_KEY_B : MF_KEY_A, ndefkey, vsector, false)) { PrintAndLogEx(ERR, "error, reading sector %d", i + 1); diff --git a/client/src/cmdnfc.c b/client/src/cmdnfc.c index 639d28145..53d631c1d 100644 --- a/client/src/cmdnfc.c +++ b/client/src/cmdnfc.c @@ -138,12 +138,13 @@ static int CmdNfcDecode(const char *Cmd) { } else { // convert from MFC dump file to a pure NDEF byte array - if (HasMADKey(tmp)) { + mad_sector_t s = {tmp, bytes_read}; + if (HasMADKey(&s)) { PrintAndLogEx(SUCCESS, "MFC dump file detected. Converting..."); uint8_t ndef[4096] = {0}; - uint16_t ndeflen = 0; + size_t ndeflen = 0; - if (convert_mad_to_arr(tmp, bytes_read, ndef, &ndeflen, override) != PM3_SUCCESS) { + if (convert_mad_to_arr(tmp, bytes_read, ndef, &ndeflen, sizeof(ndef), override) != PM3_SUCCESS) { PrintAndLogEx(FAILED, "Failed converting, aborting..."); free(dump); return PM3_ESOFT; diff --git a/client/src/mifare/gallaghertest.c b/client/src/mifare/gallaghertest.c index 27508399b..aff545b41 100644 --- a/client/src/mifare/gallaghertest.c +++ b/client/src/mifare/gallaghertest.c @@ -4,6 +4,7 @@ #include // memcpy memset #include "ui.h" #include "crc.h" +#include "mad.h" #include "mifare/gallaghercore.h" @@ -137,9 +138,9 @@ static bool test_mad_crc(void) { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x77, 0x88, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }; - // MAD v1 CRC: computed over sector0[17..47] (info byte + 15 AID pairs = 31 bytes) - uint8_t expected_crc = sector0[16]; // 0xBD - uint8_t computed_crc = CRC8Mad(§or0[16 + 1], 15 + 16); + const mad1_sector_t *m = (const mad1_sector_t *)sector0; + uint8_t expected_crc = m->crc; + uint8_t computed_crc = MADComputeCRC(m); if (computed_crc != expected_crc) { PrintAndLogEx(INFO, "MAD CRC test failed: expected 0x%02X, got 0x%02X", expected_crc, computed_crc); return false; diff --git a/client/src/mifare/mad.c b/client/src/mifare/mad.c index 664a722d1..29da3c112 100644 --- a/client/src/mifare/mad.c +++ b/client/src/mifare/mad.c @@ -25,6 +25,11 @@ #include "fileutils.h" #include "jansson.h" #include "mifaredefault.h" +#include "mifare4.h" + +// Compile-time size sanity checks (force a build error if the structs don't match a 4-block sector). +typedef char mad_assert_mad1[sizeof(mad1_sector_t) == MFBLOCK_SIZE * 4 ? 1 : -1]; +typedef char mad_assert_mad2[sizeof(mad2_sector_t) == MFBLOCK_SIZE * 4 ? 1 : -1]; // https://www.nxp.com/docs/en/application-note/AN10787.pdf static json_t *mad_known_aids = NULL; @@ -45,8 +50,11 @@ static const char *aid_admin[] = { "not applicable" }; -static int open_mad_file(json_t **root, bool verbose) { +// --------------------------------------------------------------------------- +// JSON helpers +// --------------------------------------------------------------------------- +static int open_mad_file(json_t **root, bool verbose) { char *path; int res = searchFile(&path, RESOURCES_SUBDIR, "mad", ".json", true); if (res != PM3_SUCCESS) { @@ -87,7 +95,6 @@ static int close_mad_file(json_t *root) { } static const char *mad_json_get_str(json_t *data, const char *name) { - json_t *jstr = json_object_get(data, name); if (jstr == NULL) return NULL; @@ -105,6 +112,10 @@ static const char *mad_json_get_str(json_t *data, const char *name) { } static int print_aid_description(json_t *root, uint16_t aid, char *fmt, bool verbose) { + if (root == NULL || fmt == NULL) { + return PM3_EINVARG; + } + char lmad[7] = {0}; snprintf(lmad, sizeof(lmad), "0x%04x", aid); // must be lowercase @@ -113,12 +124,15 @@ static int print_aid_description(json_t *root, uint16_t aid, char *fmt, bool ver for (uint32_t idx = 0; idx < json_array_size(root); idx++) { json_t *data = json_array_get(root, idx); if (!json_is_object(data)) { - PrintAndLogEx(ERR, "data [%d] is not an object\n", idx); + PrintAndLogEx(ERR, "data [%u] is not an object", idx); continue; } const char *fmad = mad_json_get_str(data, "mad"); - char lfmad[strlen(fmad) + 1]; - strcpy(lfmad, fmad); + if (fmad == NULL) + continue; + char lfmad[16]; + strncpy(lfmad, fmad, sizeof(lfmad) - 1); + lfmad[sizeof(lfmad) - 1] = '\0'; str_lower(lfmad); if (strcmp(lmad, lfmad) == 0) { elm = data; @@ -138,14 +152,13 @@ static int print_aid_description(json_t *root, uint16_t aid, char *fmt, bool ver const char *integrator = mad_json_get_str(elm, "system_integrator"); if (application && company) { - size_t result_len = 6 + strlen(application) + strlen(company); - char result[result_len]; - snprintf(result, result_len, " %s [%s]", application, company); + char result[512]; + snprintf(result, sizeof(result), " %s [%s]", application, company); PrintAndLogEx(INFO, fmt, result); } if (verbose) { - PrintAndLogEx(SUCCESS, " MAD................. %s", vmad); + PrintAndLogEx(SUCCESS, " MAD................. %s", vmad ? vmad : "n/a"); if (application) { PrintAndLogEx(SUCCESS, " Application......... %s", application); } @@ -162,42 +175,102 @@ static int print_aid_description(json_t *root, uint16_t aid, char *fmt, bool ver return PM3_SUCCESS; } -static int madCRCCheck(uint8_t *sector, bool verbose, int MADver) { - if (MADver == 1) { - uint8_t crc = CRC8Mad(§or[16 + 1], 15 + 16); - if (crc != sector[16]) { - PrintAndLogEx(WARNING, _RED_("Wrong MAD %d CRC") " calculated: 0x%02x != 0x%02x", MADver, crc, sector[16]); +// --------------------------------------------------------------------------- +// Low-level MAD sector parsing +// --------------------------------------------------------------------------- + +static bool mad_sector_valid(const mad_sector_t *sector) { + return sector != NULL && sector->data != NULL && sector->len >= sizeof(mad1_sector_t); +} + +static int madCRCCheck(const mad_sector_t *sector, int mad_ver) { + if (!mad_sector_valid(sector)) { + return PM3_EINVARG; + } + + if (mad_ver == 1) { + const mad1_sector_t *m = (const mad1_sector_t *)sector->data; + uint8_t crc = MADComputeCRC(m); + if (crc != m->crc) { + PrintAndLogEx(WARNING, _RED_("Wrong MAD %d CRC") " calculated: 0x%02x != 0x%02x", mad_ver, crc, m->crc); return PM3_ESOFT; - }; + } } else { - uint8_t crc = CRC8Mad(§or[1], 15 + 16 + 16); - if (crc != sector[0]) { - PrintAndLogEx(WARNING, _RED_("Wrong MAD %d CRC") " calculated: 0x%02x != 0x%02x", MADver, crc, sector[0]); + const mad2_sector_t *m = (const mad2_sector_t *)sector->data; + uint8_t crc = MADComputeCRC(m); + if (crc != m->crc) { + PrintAndLogEx(WARNING, _RED_("Wrong MAD %d CRC") " calculated: 0x%02x != 0x%02x", mad_ver, crc, m->crc); return PM3_ESOFT; - }; + } } return PM3_SUCCESS; } -static uint16_t madGetAID(const uint8_t *sector, bool swapmad, int MADver, int sectorNo) { - uint16_t mad; - if (MADver == 1) - mad = (sector[16 + 2 + (sectorNo - 1) * 2 + 1] << 8) + (sector[16 + 2 + (sectorNo - 1) * 2]); - else - mad = (sector[2 + (sectorNo - 1) * 2 + 1] << 8) + (sector[2 + (sectorNo - 1) * 2]); - if (swapmad) { - return BSWAP_16(mad); - } else { - return mad; +static uint16_t madGetAID(const mad_sector_t *sector, bool swapmad, int mad_ver, int sector_no) { + if (!mad_sector_valid(sector)) { + return 0; } + + const mad_aid_t *aid = NULL; + + if (mad_ver == 1) { + const mad1_sector_t *m = (const mad1_sector_t *)sector->data; + if (sector_no >= 1 && sector_no <= 15) + aid = &m->aid[sector_no - 1]; + else + return 0; + } else { + const mad2_sector_t *m = (const mad2_sector_t *)sector->data; + if (sector_no >= 1 && sector_no <= 23) + aid = &m->aid[sector_no - 1]; + else + return 0; + } + + uint16_t val = mad_aid_get(aid); + return swapmad ? BSWAP_16(val) : val; } -int MADCheck(uint8_t *sector0, uint8_t *sector16, bool verbose, bool *haveMAD2) { - - if (sector0 == NULL) +static int MADInfoByteDecode(const mad_sector_t *sector, int mad_ver, bool verbose) { + if (!mad_sector_valid(sector)) { return PM3_EINVARG; + } + + uint8_t info; + if (mad_ver == 1) { + const mad1_sector_t *m = (const mad1_sector_t *)sector->data; + info = m->info & 0x3f; + if (info >= 0x10) { + PrintAndLogEx(WARNING, "Invalid Info byte (MAD1) value " _YELLOW_("0x%02x"), info); + if (verbose) { + PrintAndLogEx(WARNING, "MAD1 Info byte points outside of MAD1 sector space (0x%02x), report a bug?", info); + } + return PM3_ESOFT; + } + } else { + const mad2_sector_t *m = (const mad2_sector_t *)sector->data; + info = m->info & 0x3f; + if (info == 0x10 || info >= 0x28) { + PrintAndLogEx(WARNING, "Invalid Info byte (MAD2) value " _YELLOW_("0x%02x"), info); + return PM3_ESOFT; + } + } + + return info; +} + +// --------------------------------------------------------------------------- +// Public API +// --------------------------------------------------------------------------- + +int MADCheck(const mad_sector_t *sector0, const mad_sector_t *sector16, bool verbose, bool *haveMAD2) { + if (!mad_sector_valid(sector0)) { + return PM3_EINVARG; + } + + const mad1_sector_t *m1 = (const mad1_sector_t *)sector0->data; + uint8_t GPB = m1->gpb; - uint8_t GPB = sector0[(3 * 16) + 9]; if (verbose) { PrintAndLogEx(SUCCESS, "GPB....... " _GREEN_("0x%02X"), GPB); } @@ -212,29 +285,30 @@ int MADCheck(uint8_t *sector0, uint8_t *sector16, bool verbose, bool *haveMAD2) if (verbose) PrintAndLogEx(SUCCESS, "Version... " _GREEN_("%d"), mad_ver); - // MAD version + // MAD version if ((mad_ver != 0x01) && (mad_ver != 0x02)) { PrintAndLogEx(ERR, "Wrong MAD version " _RED_("0x%02X"), mad_ver); return PM3_ESOFT; - }; + } + bool mad2_available = (mad_ver == 2) && mad_sector_valid(sector16); if (haveMAD2) { - *haveMAD2 = (mad_ver == 2); + *haveMAD2 = mad2_available; } - int res = madCRCCheck(sector0, true, 1); + int res = madCRCCheck(sector0, 1); if (verbose && res == PM3_SUCCESS) { - PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( %s )", sector0[16], _GREEN_("ok")); + PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( %s )", m1->crc, _GREEN_("ok")); } - if (mad_ver == 2 && sector16) { - int res2 = madCRCCheck(sector16, true, 2); + if (mad2_available) { + int res2 = madCRCCheck(sector16, 2); if (res == PM3_SUCCESS) { res = res2; } - - if (verbose && !res2) { - PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( %s )", sector16[0], _GREEN_("ok")); + if (verbose && res2 == PM3_SUCCESS) { + const mad2_sector_t *m2 = (const mad2_sector_t *)sector16->data; + PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( %s )", m2->crc, _GREEN_("ok")); } } @@ -248,10 +322,21 @@ int MADCheck(uint8_t *sector0, uint8_t *sector16, bool verbose, bool *haveMAD2) return res; } -int MADDecode(uint8_t *sector0, uint8_t *sector16, uint16_t *mad, size_t *madlen, bool swapmad, bool override) { - *madlen = 0; +int MADDecode(const mad_sector_t *sector0, const mad_sector_t *sector16, mad_t *out, bool swapmad, bool override) { + if (out == NULL) { + return PM3_EINVARG; + } + + memset(out, 0, sizeof(mad_t)); + bool haveMAD2 = false; int res = MADCheck(sector0, sector16, false, &haveMAD2); + out->has_mad2 = haveMAD2; + + if (mad_sector_valid(sector0)) { + const mad1_sector_t *m1 = (const mad1_sector_t *)sector0->data; + out->gpb = m1->gpb; + } if (res != PM3_SUCCESS && override == false) { PrintAndLogEx(WARNING, "Not a valid MAD"); @@ -262,73 +347,73 @@ int MADDecode(uint8_t *sector0, uint8_t *sector16, uint16_t *mad, size_t *madlen PrintAndLogEx(INFO, "overriding crc check"); } - // 7 + 8 == 15 - for (int i = 1; i <= 16; i++) { - mad[*madlen] = madGetAID(sector0, swapmad, 1, i); - (*madlen)++; + out->crc1_ok = (madCRCCheck(sector0, 1) == PM3_SUCCESS); + + for (int i = 1; i <= MAD1_AID_COUNT; i++) { + if (out->count >= MAD_MAX_AID_ENTRIES) + break; + out->entries[out->count++] = madGetAID(sector0, swapmad, 1, i); } if (haveMAD2) { - // mad2 sector (0x10 == 16) here - mad[*madlen] = 0x0005; - (*madlen)++; + out->crc2_ok = (madCRCCheck(sector16, 2) == PM3_SUCCESS); - // 7 + 8 + 8 == 23 - for (int i = 1; i < 24; i++) { - mad[*madlen] = madGetAID(sector16, swapmad, 2, i); + if (out->count >= MAD_MAX_AID_ENTRIES) + return PM3_ESOFT; - (*madlen)++; + // MAD2 sector marker + out->entries[out->count++] = 0x0005; + + for (int i = 1; i <= MAD2_AID_COUNT; i++) { + if (out->count >= MAD_MAX_AID_ENTRIES) + break; + out->entries[out->count++] = madGetAID(sector16, swapmad, 2, i); } } return PM3_SUCCESS; } -int MADCardHolderInfoDecode(uint8_t *data, size_t datalen, bool verbose) { +int MADCardHolderInfoDecode(const uint8_t *data, size_t datalen, bool verbose) { + if (data == NULL) { + return PM3_EINVARG; + } + size_t idx = 0; while (idx < datalen) { uint8_t len = data[idx] & 0x3f; uint8_t type = data[idx] >> 6; idx++; - if (len > 0) { - PrintAndLogEx(INFO, "%14s " _GREEN_("%.*s"), holder_info_type[type], len, &data[idx]); - idx += len; - } else { + if (len == 0) + break; + if (idx + len > datalen) { + PrintAndLogEx(WARNING, "Card holder info truncated (need %u bytes, %zu available)", len, datalen - idx); break; } + if (type >= ARRAYLEN(holder_info_type)) { + PrintAndLogEx(WARNING, "Unknown card holder info type %u", type); + idx += len; + continue; + } + PrintAndLogEx(INFO, "%14s " _GREEN_("%.*s"), holder_info_type[type], len, &data[idx]); + idx += len; } return PM3_SUCCESS; } -static int MADInfoByteDecode(const uint8_t *sector, bool swapmad, int mad_ver, bool verbose) { - uint8_t info; - if (mad_ver == 1) { - info = sector[16 + 1] & 0x3f; - if (info >= 0xF) { - PrintAndLogEx(WARNING, "Invalid Info byte (MAD1) value " _YELLOW_("0x%02x"), info); - if (verbose) { - // I understand the spec in a way that MAD1 InfoByte should not point into MAD2 sectors, @lukaskuzmiak - PrintAndLogEx(WARNING, "MAD1 Info byte points outside of MAD1 sector space (0x%02x), report a bug?", info); - } - return PM3_ESOFT; - } - } else { - info = sector[1] & 0x3f; - if (info == 0x10 || info >= 0x28) { - PrintAndLogEx(WARNING, "Invalid Info byte (MAD2) value " _YELLOW_("0x%02x"), info); - return PM3_ESOFT; - } - } - - return info; -} - void MADPrintHeader(void) { PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "--- " _CYAN_("MIFARE App Directory Information") " ----------------"); } -int MAD1DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose, bool *haveMAD2) { - open_mad_file(&mad_known_aids, verbose); +int MAD1DecodeAndPrint(const mad_sector_t *sector, bool swapmad, bool verbose, bool *haveMAD2) { + if (!mad_sector_valid(sector)) { + return PM3_EINVARG; + } + + int res = open_mad_file(&mad_known_aids, verbose); + if (res != PM3_SUCCESS) { + mad_known_aids = NULL; + } PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "------------ " _CYAN_("MAD v1 details") " -------------"); @@ -336,7 +421,12 @@ int MAD1DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose, bool *haveMA // check MAD1 only MADCheck(sector, NULL, verbose, haveMAD2); - int ibs = MADInfoByteDecode(sector, swapmad, 1, verbose); + int ibs = MADInfoByteDecode(sector, 1, verbose); + if (ibs < 0) { + close_mad_file(mad_known_aids); + mad_known_aids = NULL; + return ibs; + } if (ibs > 0) { PrintAndLogEx(SUCCESS, "Card publisher sector " _MAGENTA_("0x%02X"), ibs); @@ -349,9 +439,9 @@ int MAD1DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose, bool *haveMA PrintAndLogEx(INFO, " 00 MAD v1"); uint32_t prev_aid = 0xFFFFFFFF; - for (int i = 1; i < 16; i++) { + for (int i = 1; i <= MAD1_AID_COUNT; i++) { uint16_t aid = madGetAID(sector, swapmad, 1, i); - if (aid < 6) { + if (aid < ARRAYLEN(aid_admin)) { PrintAndLogEx(INFO, (ibs == i) ? _MAGENTA_(" %02d [%04X] %s") : " %02d [" _GREEN_("%04X") "] %s", i, @@ -381,24 +471,39 @@ int MAD1DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose, bool *haveMA } } close_mad_file(mad_known_aids); + mad_known_aids = NULL; return PM3_SUCCESS; } -int MAD2DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose) { - open_mad_file(&mad_known_aids, false); +int MAD2DecodeAndPrint(const mad_sector_t *sector, bool swapmad, bool verbose) { + if (!mad_sector_valid(sector)) { + return PM3_EINVARG; + } + + int res = open_mad_file(&mad_known_aids, false); + if (res != PM3_SUCCESS) { + mad_known_aids = NULL; + } PrintAndLogEx(NORMAL, ""); PrintAndLogEx(INFO, "------------ " _CYAN_("MAD v2 details") " -------------"); - int res = madCRCCheck(sector, true, 2); + int crc_res = madCRCCheck(sector, 2); if (verbose) { - if (res == PM3_SUCCESS) - PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( " _GREEN_("%s") " )", sector[0], "ok"); + const mad2_sector_t *m2 = (const mad2_sector_t *)sector->data; + if (crc_res == PM3_SUCCESS) + PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( " _GREEN_("%s") " )", m2->crc, "ok"); else - PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( " _RED_("%s") " )", sector[0], "fail"); + PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( " _RED_("%s") " )", m2->crc, "fail"); + } + + int ibs = MADInfoByteDecode(sector, 2, verbose); + if (ibs < 0) { + close_mad_file(mad_known_aids); + mad_known_aids = NULL; + return ibs; } - int ibs = MADInfoByteDecode(sector, swapmad, 2, verbose); if (ibs > 0) { PrintAndLogEx(SUCCESS, "Card publisher sector " _MAGENTA_("0x%02X"), ibs); } else { @@ -411,9 +516,9 @@ int MAD2DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose) { PrintAndLogEx(INFO, " 16 MAD v2"); uint32_t prev_aid = 0xFFFFFFFF; - for (int i = 1; i < 8 + 8 + 7 + 1; i++) { + for (int i = 1; i <= MAD2_AID_COUNT; i++) { uint16_t aid = madGetAID(sector, swapmad, 2, i); - if (aid < 6) { + if (aid < ARRAYLEN(aid_admin)) { PrintAndLogEx(INFO, (ibs == i + 16) ? _MAGENTA_(" %02d [%04X] %s") : " %02d [" _GREEN_("%04X") "] %s", i + 16, @@ -442,36 +547,45 @@ int MAD2DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose) { } } close_mad_file(mad_known_aids); + mad_known_aids = NULL; return PM3_SUCCESS; } int MADDFDecodeAndPrint(uint32_t short_aid, bool verbose) { - open_mad_file(&mad_known_aids, false); + int res = open_mad_file(&mad_known_aids, false); + if (res != PM3_SUCCESS) { + mad_known_aids = NULL; + } char fmt[128]; snprintf(fmt, sizeof(fmt), " MAD AID Function 0x%04X... " _YELLOW_("%s"), short_aid, "%s"); print_aid_description(mad_known_aids, short_aid, fmt, verbose); close_mad_file(mad_known_aids); + mad_known_aids = NULL; return PM3_SUCCESS; } -bool HasMADKey(uint8_t *d) { - if (d == NULL) { +bool HasMADKey(const mad_sector_t *sector) { + if (sector == NULL || sector->data == NULL) { return false; } - return (memcmp(d + (3 * MFBLOCK_SIZE), g_mifare_mad_key, sizeof(g_mifare_mad_key)) == 0); + if (sector->len < sizeof(mad1_sector_t)) { + return false; + } + + const mad1_sector_t *m = (const mad1_sector_t *)sector->data; + return (memcmp(m->key_a, g_mifare_mad_key, sizeof(g_mifare_mad_key)) == 0); } -int DetectHID(uint8_t *d, uint16_t manufacture) { - if (d == NULL) { +int DetectHID(const mad_sector_t *sector, uint16_t manufacture) { + if (!mad_sector_valid(sector)) { return -1; } - // find HID - for (int i = 1; i < 16; i++) { - uint16_t aid = madGetAID(d, false, 1, i); + for (int i = 1; i <= MAD1_AID_COUNT; i++) { + uint16_t aid = madGetAID(sector, false, 1, i); if (aid == manufacture) { return i; } @@ -480,49 +594,63 @@ int DetectHID(uint8_t *d, uint16_t manufacture) { return -1; } -int convert_mad_to_arr(uint8_t *in, uint16_t ilen, uint8_t *out, uint16_t *olen, bool override) { - - if (in == NULL || out == NULL || ilen == 0) { +int convert_mad_to_arr(const uint8_t *in, size_t ilen, uint8_t *out, size_t *olen, size_t olen_max, bool override) { + if (in == NULL || out == NULL || olen == NULL || ilen == 0 || olen_max == 0) { return PM3_EINVARG; } - // MAD detection - if (HasMADKey(in) == false) { + *olen = 0; + + mad_sector_t dump = { in, ilen }; + if (HasMADKey(&dump) == false) { PrintAndLogEx(FAILED, "No MAD key was detected in the dump file"); return PM3_ESOFT; } - uint8_t sector0[MFBLOCK_SIZE * 4] = {0}; - uint8_t sector16[MFBLOCK_SIZE * 4] = {0}; + uint8_t sector0_buf[MFBLOCK_SIZE * 4] = {0}; + uint8_t sector16_buf[MFBLOCK_SIZE * 4] = {0}; - memcpy(sector0, in, sizeof(sector0)); - if (ilen == MIFARE_4K_MAX_BYTES) { - memcpy(sector16, in + (MF_MAD2_SECTOR * 4 * MFBLOCK_SIZE), sizeof(sector16)); + memcpy(sector0_buf, in, MIN(sizeof(sector0_buf), ilen)); + + mad_sector_t sector16 = { NULL, 0 }; + size_t sector16_offset = MF_MAD2_SECTOR * 4 * MFBLOCK_SIZE; + if (ilen >= sector16_offset + sizeof(sector16_buf)) { + memcpy(sector16_buf, in + sector16_offset, sizeof(sector16_buf)); + sector16.data = sector16_buf; + sector16.len = sizeof(sector16_buf); } - uint16_t mad[7 + 8 + 8 + 8 + 8] = {0}; - size_t madlen = 0; - if (MADDecode(sector0, sector16, mad, &madlen, false, override)) { + mad_sector_t sector0 = { sector0_buf, sizeof(sector0_buf) }; + mad_t mad = {0}; + int res = MADDecode(§or0, §or16, &mad, false, override); + if (res != PM3_SUCCESS) { PrintAndLogEx(ERR, "can't decode MAD"); return PM3_ESOFT; } uint16_t ndef_aid = 0xE103; - for (int i = 0; i < madlen; i++) { - if (ndef_aid == mad[i]) { - uint8_t tmp[MFBLOCK_SIZE * 4] = {0}; - memset(tmp, 0x00, sizeof(tmp)); + for (size_t i = 0; i < mad.count; i++) { + if (ndef_aid == mad.entries[i]) { + uint8_t sectorNo = i + 1; + uint16_t first_block = mfFirstBlockOfSector(sectorNo); + uint8_t num_blocks = mfNumBlocksPerSector(sectorNo); + uint32_t offset = first_block * MFBLOCK_SIZE; + uint16_t sector_size = num_blocks * MFBLOCK_SIZE; - // sector i dump (skip first sector +1) - memcpy(tmp, in + (i + 1) * sizeof(tmp), sizeof(tmp)); + if (offset + sector_size > ilen) { + PrintAndLogEx(WARNING, "NDEF sector %u exceeds input bounds", sectorNo); + break; + } - // debug print - // print_hex_noascii_break(tmp, sizeof(tmp) - MFBLOCK_SIZE, MFBLOCK_SIZE); + uint16_t data_size = sector_size - MFBLOCK_SIZE; + if (*olen + data_size > olen_max) { + PrintAndLogEx(WARNING, "NDEF output buffer full"); + return PM3_ESOFT; + } - // copy to out (skip ST) - memcpy(out, tmp, sizeof(tmp) - MFBLOCK_SIZE); - out += sizeof(tmp) - MFBLOCK_SIZE; - *olen += sizeof(tmp) - MFBLOCK_SIZE; + memcpy(out, in + offset, data_size); + out += data_size; + *olen += data_size; } } return PM3_SUCCESS; diff --git a/client/src/mifare/mad.h b/client/src/mifare/mad.h index 320c80453..82c41b1cf 100644 --- a/client/src/mifare/mad.h +++ b/client/src/mifare/mad.h @@ -21,14 +21,87 @@ #include "common.h" -int MADCheck(uint8_t *sector0, uint8_t *sector16, bool verbose, bool *haveMAD2); -int MADDecode(uint8_t *sector0, uint8_t *sector16, uint16_t *mad, size_t *madlen, bool swapmad, bool override); -int MAD1DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose, bool *haveMAD2); -int MAD2DecodeAndPrint(uint8_t *sector, bool swapmad, bool verbose); +// --------------------------------------------------------------------------- +// On-card layout structures +// --------------------------------------------------------------------------- + +// AID as stored on the card: low byte first, then high byte. +typedef struct PACKED { + uint8_t lo; + uint8_t hi; +} mad_aid_t; + +static inline uint16_t mad_aid_get(const mad_aid_t *a) { + return (a->hi << 8) | a->lo; +} + +static inline void mad_aid_set(mad_aid_t *a, uint16_t val) { + a->lo = val & 0xFF; + a->hi = (val >> 8) & 0xFF; +} + +// MAD1 lives in sector 0 (blocks 0-3, 64 bytes total). +typedef struct PACKED { + uint8_t manufacturer[16]; + uint8_t crc; + uint8_t info; + mad_aid_t aid[15]; // sectors 1-15 + uint8_t key_a[6]; + uint8_t access_bits[3]; + uint8_t gpb; + uint8_t key_b[6]; +} mad1_sector_t; + +// MAD2 lives in sector 0x10 (blocks 0-3 of that sector, 64 bytes total). +typedef struct PACKED { + uint8_t crc; + uint8_t info; + mad_aid_t aid[23]; // sectors 17-39 + uint8_t key_a[6]; + uint8_t access_bits[3]; + uint8_t gpb; + uint8_t key_b[6]; +} mad2_sector_t; + +// AID counts per MAD version +#define MAD1_AID_COUNT 15 +#define MAD2_AID_COUNT 23 + +// Maximum decoded AID entries: 15 (MAD1) + 1 (MAD2 marker) + 23 (MAD2) = 39 +#define MAD_MAX_AID_ENTRIES (MAD1_AID_COUNT + 1 + MAD2_AID_COUNT) + +// Wrapper for a raw sector buffer passed with explicit size. +typedef struct { + const uint8_t *data; + size_t len; +} mad_sector_t; + +// Output of MADDecode. +typedef struct { + uint16_t entries[MAD_MAX_AID_ENTRIES]; + size_t count; + bool has_mad2; + uint8_t info_byte; + uint8_t gpb; + bool crc1_ok; + bool crc2_ok; +} mad_t; + +// --------------------------------------------------------------------------- +// API +// --------------------------------------------------------------------------- + +#define MADComputeCRC(m) CRC8Mad((uint8_t *)&(m)->info, sizeof((m)->info) + sizeof((m)->aid)) + +int MADCheck(const mad_sector_t *sector0, const mad_sector_t *sector16, bool verbose, bool *haveMAD2); +int MADDecode(const mad_sector_t *sector0, const mad_sector_t *sector16, mad_t *out, bool swapmad, bool override); +int MAD1DecodeAndPrint(const mad_sector_t *sector, bool swapmad, bool verbose, bool *haveMAD2); +int MAD2DecodeAndPrint(const mad_sector_t *sector, bool swapmad, bool verbose); int MADDFDecodeAndPrint(uint32_t short_aid, bool verbose); -int MADCardHolderInfoDecode(uint8_t *data, size_t datalen, bool verbose); +int MADCardHolderInfoDecode(const uint8_t *data, size_t datalen, bool verbose); void MADPrintHeader(void); -bool HasMADKey(uint8_t *d); -int DetectHID(uint8_t *d, uint16_t manufacture); -int convert_mad_to_arr(uint8_t *in, uint16_t ilen, uint8_t *out, uint16_t *olen, bool override); +bool HasMADKey(const mad_sector_t *sector); +int DetectHID(const mad_sector_t *sector, uint16_t manufacture); +int convert_mad_to_arr(const uint8_t *in, size_t ilen, uint8_t *out, size_t *olen, size_t olen_max, bool override); + #endif // _MAD_H_