apply some style and consts

This commit is contained in:
iceman1001 committed 2026-06-29 22:42:37 +02:00
1 parent cc7984d4ed
commit 2b51280725
10 files changed
+836 -239

No files matched your search

+226 -145
View File
@@ -35,43 +35,38 @@
// --- Card transport adapters ---
static int mfc_read_sector(uint8_t sector_no, uint8_t key_type,
const uint8_t *key, uint8_t *buf, bool verbose) {
static int mfc_read_sector(uint8_t sector_no, uint8_t key_type, const uint8_t *key, uint8_t *buf, bool verbose) {
// function pointer is used to call this fct, hence the need to match fct signature
(void)verbose;
return mf_read_sector(sector_no, key_type, key, buf);
}
static int mfc_write_sector_data(uint8_t sector_no, uint8_t key_type,
const uint8_t *key, const uint8_t *data, bool verbose) {
static int mfc_write_sector_data(uint8_t sector_no, uint8_t key_type, const uint8_t *key, const uint8_t *data, bool verbose) {
(void)verbose;
uint8_t first = mfFirstBlockOfSector(sector_no);
uint8_t ndata = mfNumBlocksPerSector(sector_no) - 1;
for (int i = 0; i < ndata; i++) {
int res = mf_write_block(first + i, key_type, key, data + i * MFBLOCK_SIZE);
if (res != PM3_SUCCESS)
if (res != PM3_SUCCESS) {
return res;
}
}
return PM3_SUCCESS;
}
static int mfp_read_sector(uint8_t sector_no, uint8_t key_type,
const uint8_t *key, uint8_t *buf, bool verbose) {
return mfpReadSector(sector_no, key_type, (uint8_t *)key, buf, verbose);
static int mfp_read_sector(uint8_t sector_no, uint8_t key_type, const uint8_t *key, uint8_t *buf, bool verbose) {
return mfpReadSector(sector_no, key_type, key, buf, verbose);
}
static int mfp_write_sector_data(uint8_t sector_no, uint8_t key_type,
const uint8_t *key, const uint8_t *data, bool verbose) {
return mfpWriteSector(sector_no, key_type, (uint8_t *)key, data, verbose);
static int mfp_write_sector_data(uint8_t sector_no, uint8_t key_type, const uint8_t *key, const uint8_t *data, bool verbose) {
return mfpWriteSector(sector_no, key_type, key, data, verbose);
}
// --- Card type detection ---
typedef enum {
MAD_CARD_CLASSIC,
MAD_CARD_PLUS,
} mad_card_type_t;
static int mad_detect_card(mad_card_type_t *out) {
uint8_t sector0[MFBLOCK_SIZE * 4] = {0};
if (mf_read_sector(MF_MAD1_SECTOR, MF_KEY_A, g_mifare_mad_key, sector0) == PM3_SUCCESS) {
@@ -84,13 +79,12 @@ static int mad_detect_card(mad_card_type_t *out) {
return PM3_SUCCESS;
}
PrintAndLogEx(ERR, "Could not authenticate to MAD sector with default keys (Classic or Plus)");
PrintAndLogEx(ERR, "Could not authenticate to MAD sector with default keys");
return PM3_ESOFT;
}
static void mad_fill_ops(mad_ops_t *ops, mad_card_type_t card_type,
const uint8_t *mad_key, const uint8_t *app_key,
uint8_t key_type, bool verbose) {
static void mad_fill_ops(mad_ops_t *ops, mad_card_type_t card_type, const uint8_t *mad_key, const uint8_t *app_key, uint8_t key_type, bool verbose) {
if (card_type == MAD_CARD_CLASSIC) {
ops->read_sector = mfc_read_sector;
ops->write_sector_data = mfc_write_sector_data;
@@ -109,18 +103,22 @@ static void mad_fill_ops(mad_ops_t *ops, mad_card_type_t card_type,
// Determine card type from key length, or auto-detect
static int mad_resolve_card(int keylen, int madkeylen, mad_card_type_t *out, bool force_classic, bool force_plus) {
if (force_classic) {
*out = MAD_CARD_CLASSIC;
return PM3_SUCCESS;
}
if (force_plus) {
*out = MAD_CARD_PLUS;
return PM3_SUCCESS;
}
if (keylen == AES_KEY_LEN || madkeylen == AES_KEY_LEN) {
*out = MAD_CARD_PLUS;
return PM3_SUCCESS;
}
if (keylen == MIFARE_KEY_SIZE || madkeylen == MIFARE_KEY_SIZE) {
*out = MAD_CARD_CLASSIC;
return PM3_SUCCESS;
@@ -134,68 +132,82 @@ static int mad_cmd_read(const char *Cmd, const char *cmd_name, bool force_classi
CLIParserContext *ctx;
CLIParserInit(&ctx, cmd_name,
"Read application data from sectors matching a MAD AID",
"mad read --aid e103 -> read NDEF data (auto-detect card)\n"
"mad read --aid e103 -k ffffffffffff -b -> Classic, key B\n"
"mad read --aid e103 -k d3f7d3f7d3f7d3f7d3f7d3f7d3f7d3f7 -> Plus\n"
"mad read --aid e103 -v -f mydata.bin -> verbose, save to file");
"mad read --aid e103 -> read NDEF data\n"
"mad read --aid e103 -k ffffffffffff -b -> Classic, key B\n"
"mad read --aid e103 -k d3f7d3f7d3f7d3f7d3f7d3f7d3f7d3f7 -> Plus\n"
"mad read --aid e103 -v -f mydata.bin");
void *argtable[] = {
arg_param_begin,
arg_lit0("v", "verbose", "verbose output"),
arg_str1(NULL, "aid", "<hex>", "application ID (2 hex bytes)"),
arg_str0("k", "key", "<hex>", "key for data sectors"),
arg_lit0("b", "keyb", "use key B (def: key A)"),
arg_str0(NULL, "mad-key", "<hex>", "key for MAD sectors"),
arg_lit0("b", "keyb", "use key B"),
arg_str0(NULL, "madkey", "<hex>", "key for MAD sectors"),
arg_lit0(NULL, "be", "big-endian AID byte swap"),
arg_lit0(NULL, "override", "override failed CRC check"),
arg_str0("f", "file", "<fn>", "save raw data to file"),
arg_lit0("v", "verbose", "verbose output"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
bool verbose = arg_get_lit(ctx, 1);
uint8_t aid[2] = {0};
int aidlen = 0;
CLIGetHexWithReturn(ctx, 2, aid, &aidlen);
CLIGetHexWithReturn(ctx, 1, aid, &aidlen);
uint8_t userkey[AES_KEY_LEN] = {0};
int keylen = 0;
CLIGetHexWithReturn(ctx, 3, userkey, &keylen);
bool keyB = arg_get_lit(ctx, 4);
CLIGetHexWithReturn(ctx, 2, userkey, &keylen);
bool keyB = arg_get_lit(ctx, 3);
uint8_t madkey[AES_KEY_LEN] = {0};
int madkeylen = 0;
CLIGetHexWithReturn(ctx, 5, madkey, &madkeylen);
bool swapmad = arg_get_lit(ctx, 6);
bool override = arg_get_lit(ctx, 7);
CLIGetHexWithReturn(ctx, 4, madkey, &madkeylen);
bool swapmad = arg_get_lit(ctx, 5);
bool override = arg_get_lit(ctx, 6);
int fnlen = 0;
char filename[FILE_PATH_SIZE] = {0};
CLIParamStrToBuf(arg_get_str(ctx, 8), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
CLIParamStrToBuf(arg_get_str(ctx, 7), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
bool verbose = arg_get_lit(ctx, 8);
CLIParserFree(ctx);
mad_card_type_t card_type;
int res = mad_resolve_card(keylen, madkeylen, &card_type, force_classic, force_plus);
if (res != PM3_SUCCESS)
if (res != PM3_SUCCESS) {
return res;
}
if (verbose)
PrintAndLogEx(INFO, "Using %s transport", card_type == MAD_CARD_CLASSIC ? "MIFARE Classic" : "MIFARE Plus");
if (verbose) {
PrintAndLogEx(INFO, "Using %s transport", (card_type == MAD_CARD_CLASSIC) ? "MIFARE Classic" : "MIFARE Plus");
}
mad_ops_t ops = {0};
mad_fill_ops(&ops, card_type,
madkeylen > 0 ? madkey : NULL,
keylen > 0 ? userkey : NULL,
keyB ? MF_KEY_B : MF_KEY_A, verbose);
mad_fill_ops(&ops,
card_type,
madkeylen > 0 ? madkey : NULL,
keylen > 0 ? userkey : NULL,
keyB ? MF_KEY_B : MF_KEY_A,
verbose
);
uint16_t aaid = (aid[0] << 8) | aid[1];
uint8_t data[MIFARE_4K_MAX_BYTES] = {0};
size_t datalen = 0;
res = mad_app_read(&ops, aaid, swapmad, override, data, sizeof(data), &datalen);
if (res != PM3_SUCCESS)
return res;
uint16_t aaid = MemBeToUint2byte(aid);
uint8_t data[MIFARE_4K_MAX_BYTES] = {0};
PrintAndLogEx(INFO, "read %zu bytes from AID 0x%04X", datalen, aaid);
res = mad_app_read(&ops, aaid, swapmad, override, data, sizeof(data), &datalen);
if (res != PM3_SUCCESS) {
return res;
}
PrintAndLogEx(INFO, "read " _YELLOW_("%zu") " bytes from AID 0x" _YELLOW_("%04X"), datalen, aaid);
print_buffer_with_offset(data, datalen, 0, true);
if (fnlen > 0)
if (fnlen) {
pm3_save_dump(filename, data, datalen, jsfRaw);
}
return PM3_SUCCESS;
}
@@ -210,7 +222,6 @@ static int mad_cmd_write(const char *Cmd, const char *cmd_name, bool force_class
void *argtable[] = {
arg_param_begin,
arg_lit0("v", "verbose", "verbose output"),
arg_str1(NULL, "aid", "<hex>", "application ID (2 hex bytes)"),
arg_str0("k", "key", "<hex>", "key for data sectors"),
arg_lit0("b", "keyb", "use key B (def: key A)"),
@@ -219,45 +230,55 @@ static int mad_cmd_write(const char *Cmd, const char *cmd_name, bool force_class
arg_lit0(NULL, "override", "override failed CRC check"),
arg_str0("d", "data", "<hex>", "data to write"),
arg_str0("f", "file", "<fn>", "load data from file"),
arg_lit0("v", "verbose", "verbose output"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
bool verbose = arg_get_lit(ctx, 1);
uint8_t aid[2] = {0};
int aidlen = 0;
CLIGetHexWithReturn(ctx, 2, aid, &aidlen);
uint8_t userkey[AES_KEY_LEN] = {0};
int keylen = 0;
CLIGetHexWithReturn(ctx, 3, userkey, &keylen);
bool keyB = arg_get_lit(ctx, 4);
bool keyB = arg_get_lit(ctx, 3);
uint8_t madkey[AES_KEY_LEN] = {0};
int madkeylen = 0;
CLIGetHexWithReturn(ctx, 5, madkey, &madkeylen);
bool swapmad = arg_get_lit(ctx, 6);
bool override = arg_get_lit(ctx, 7);
CLIGetHexWithReturn(ctx, 4, madkey, &madkeylen);
bool swapmad = arg_get_lit(ctx, 5);
bool override = arg_get_lit(ctx, 6);
uint8_t hexdata[MIFARE_4K_MAX_BYTES] = {0};
int hexdatalen = 0;
CLIGetHexWithReturn(ctx, 8, hexdata, &hexdatalen);
CLIGetHexWithReturn(ctx, 7, hexdata, &hexdatalen);
int fnlen = 0;
char filename[FILE_PATH_SIZE] = {0};
CLIParamStrToBuf(arg_get_str(ctx, 9), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
CLIParamStrToBuf(arg_get_str(ctx, 8), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
bool verbose = arg_get_lit(ctx, 9);
CLIParserFree(ctx);
uint8_t *wdata = hexdata;
size_t wdata_len = hexdatalen;
uint8_t *dump = NULL;
if (fnlen > 0) {
if (fnlen) {
size_t bytes_read = 0;
int res = pm3_load_dump(filename, (void **)&dump, &bytes_read, MIFARE_4K_MAX_BYTES);
if (res != PM3_SUCCESS)
if (res != PM3_SUCCESS) {
return res;
}
wdata = dump;
wdata_len = bytes_read;
}
if (wdata_len == 0) {
PrintAndLogEx(ERR, "no data to write (use -d or -f)");
PrintAndLogEx(ERR, "No data to write (use `-d` or `-f`)");
free(dump);
return PM3_EINVARG;
}
@@ -269,16 +290,20 @@ static int mad_cmd_write(const char *Cmd, const char *cmd_name, bool force_class
return res;
}
if (verbose)
PrintAndLogEx(INFO, "Using %s transport", card_type == MAD_CARD_CLASSIC ? "MIFARE Classic" : "MIFARE Plus");
if (verbose) {
PrintAndLogEx(INFO, "Using " _GREEN_("%s") " transport", (card_type == MAD_CARD_CLASSIC) ? "MIFARE Classic" : "MIFARE Plus");
}
mad_ops_t ops = {0};
mad_fill_ops(&ops, card_type,
madkeylen > 0 ? madkey : NULL,
keylen > 0 ? userkey : NULL,
keyB ? MF_KEY_B : MF_KEY_A, verbose);
mad_fill_ops(&ops,
card_type,
madkeylen > 0 ? madkey : NULL,
keylen > 0 ? userkey : NULL,
keyB ? MF_KEY_B : MF_KEY_A,
verbose
);
uint16_t aaid = (aid[0] << 8) | aid[1];
uint16_t aaid = MemBeToUint2byte(aid);
res = mad_app_write(&ops, aaid, swapmad, override, wdata, wdata_len);
free(dump);
return res;
@@ -288,12 +313,11 @@ static int mad_cmd_verify(const char *Cmd, const char *cmd_name, bool force_clas
CLIParserContext *ctx;
CLIParserInit(&ctx, cmd_name,
"Read back and verify application data against expected content",
"mad verify --aid e103 -d 0102030405060708 -> verify data\n"
"mad verify --aid e103 -f mydata.bin -> verify against file");
"mad verify --aid e103 -d 0102030405060708\n"
"mad verify --aid e103 -f mydata.bin");
void *argtable[] = {
arg_param_begin,
arg_lit0("v", "verbose", "verbose output"),
arg_str1(NULL, "aid", "<hex>", "application ID (2 hex bytes)"),
arg_str0("k", "key", "<hex>", "key for data sectors"),
arg_lit0("b", "keyb", "use key B (def: key A)"),
@@ -302,45 +326,56 @@ static int mad_cmd_verify(const char *Cmd, const char *cmd_name, bool force_clas
arg_lit0(NULL, "override", "override failed CRC check"),
arg_str0("d", "data", "<hex>", "expected data"),
arg_str0("f", "file", "<fn>", "load expected data from file"),
arg_lit0("v", "verbose", "verbose output"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
bool verbose = arg_get_lit(ctx, 1);
uint8_t aid[2] = {0};
int aidlen = 0;
CLIGetHexWithReturn(ctx, 2, aid, &aidlen);
CLIGetHexWithReturn(ctx, 1, aid, &aidlen);
uint8_t userkey[AES_KEY_LEN] = {0};
int keylen = 0;
CLIGetHexWithReturn(ctx, 3, userkey, &keylen);
bool keyB = arg_get_lit(ctx, 4);
CLIGetHexWithReturn(ctx, 2, userkey, &keylen);
bool keyB = arg_get_lit(ctx, 3);
uint8_t madkey[AES_KEY_LEN] = {0};
int madkeylen = 0;
CLIGetHexWithReturn(ctx, 5, madkey, &madkeylen);
bool swapmad = arg_get_lit(ctx, 6);
bool override = arg_get_lit(ctx, 7);
CLIGetHexWithReturn(ctx, 4, madkey, &madkeylen);
bool swapmad = arg_get_lit(ctx, 5);
bool override = arg_get_lit(ctx, 6);
uint8_t hexdata[MIFARE_4K_MAX_BYTES] = {0};
int hexdatalen = 0;
CLIGetHexWithReturn(ctx, 8, hexdata, &hexdatalen);
CLIGetHexWithReturn(ctx, 7, hexdata, &hexdatalen);
int fnlen = 0;
char filename[FILE_PATH_SIZE] = {0};
CLIParamStrToBuf(arg_get_str(ctx, 9), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
CLIParamStrToBuf(arg_get_str(ctx, 8), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
bool verbose = arg_get_lit(ctx, 9);
CLIParserFree(ctx);
uint8_t *edata = hexdata;
size_t edata_len = hexdatalen;
uint8_t *dump = NULL;
if (fnlen > 0) {
if (fnlen) {
size_t bytes_read = 0;
int res = pm3_load_dump(filename, (void **)&dump, &bytes_read, MIFARE_4K_MAX_BYTES);
if (res != PM3_SUCCESS)
if (res != PM3_SUCCESS) {
return res;
}
edata = dump;
edata_len = bytes_read;
}
if (edata_len == 0) {
PrintAndLogEx(ERR, "no expected data (use -d or -f)");
PrintAndLogEx(ERR, "No expected data (use -d or -f)");
free(dump);
return PM3_EINVARG;
}
@@ -352,16 +387,19 @@ static int mad_cmd_verify(const char *Cmd, const char *cmd_name, bool force_clas
return res;
}
if (verbose)
PrintAndLogEx(INFO, "Using %s transport", card_type == MAD_CARD_CLASSIC ? "MIFARE Classic" : "MIFARE Plus");
if (verbose) {
PrintAndLogEx(INFO, "Using " _GREEN_("%s") " transport", (card_type == MAD_CARD_CLASSIC) ? "MIFARE Classic" : "MIFARE Plus");
}
mad_ops_t ops = {0};
mad_fill_ops(&ops, card_type,
madkeylen > 0 ? madkey : NULL,
keylen > 0 ? userkey : NULL,
keyB ? MF_KEY_B : MF_KEY_A, verbose);
madkeylen > 0 ? madkey : NULL,
keylen > 0 ? userkey : NULL,
keyB ? MF_KEY_B : MF_KEY_A,
verbose
);
uint16_t aaid = (aid[0] << 8) | aid[1];
uint16_t aaid = MemBeToUint2byte(aid);
res = mad_app_verify(&ops, aaid, swapmad, override, edata, edata_len);
free(dump);
return res;
@@ -369,67 +407,92 @@ static int mad_cmd_verify(const char *Cmd, const char *cmd_name, bool force_clas
// --- Auto-detect commands (mad read / mad write / mad verify) ---
static int CmdMADRead(const char *Cmd) { return mad_cmd_read(Cmd, "mad read", false, false); }
static int CmdMADWrite(const char *Cmd) { return mad_cmd_write(Cmd, "mad write", false, false); }
static int CmdMADVerify(const char *Cmd) { return mad_cmd_verify(Cmd, "mad verify", false, false); }
static int CmdMADRead(const char *Cmd) {
return mad_cmd_read(Cmd, "mad read", false, false);
}
static int CmdMADWrite(const char *Cmd) {
return mad_cmd_write(Cmd, "mad write", false, false);
}
static int CmdMADVerify(const char *Cmd) {
return mad_cmd_verify(Cmd, "mad verify", false, false);
}
// --- Card-specific wrappers (for hf mf / hf mfp aliases) ---
int CmdMADMFRead(const char *Cmd) { return mad_cmd_read(Cmd, "hf mf madread", true, false); }
int CmdMADMFWrite(const char *Cmd) { return mad_cmd_write(Cmd, "hf mf madwrite", true, false); }
int CmdMADMFVerify(const char *Cmd) { return mad_cmd_verify(Cmd, "hf mf madverify", true, false); }
int CmdMADMFPRead(const char *Cmd) { return mad_cmd_read(Cmd, "hf mfp madread", false, true); }
int CmdMADMFPWrite(const char *Cmd) { return mad_cmd_write(Cmd, "hf mfp madwrite", false, true); }
int CmdMADMFPVerify(const char *Cmd) { return mad_cmd_verify(Cmd, "hf mfp madverify", false, true); }
int CmdMADMFRead(const char *Cmd) {
return mad_cmd_read(Cmd, "hf mf madread", true, false);
}
int CmdMADMFWrite(const char *Cmd) {
return mad_cmd_write(Cmd, "hf mf madwrite", true, false);
}
int CmdMADMFVerify(const char *Cmd) {
return mad_cmd_verify(Cmd, "hf mf madverify", true, false);
}
int CmdMADMFPRead(const char *Cmd) {
return mad_cmd_read(Cmd, "hf mfp madread", false, true);
}
int CmdMADMFPWrite(const char *Cmd) {
return mad_cmd_write(Cmd, "hf mfp madwrite", false, true);
}
int CmdMADMFPVerify(const char *Cmd) {
return mad_cmd_verify(Cmd, "hf mfp madverify", false, true);
}
// --- Decode (offline) ---
static int CmdMADDecode(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "mad decode",
"Decode a MAD byte array and print the directory",
"mad decode -d <sector0 hex> -> decode MAD1\n"
"mad decode -d <sector0 hex> --mad2 <sector16 hex> -> decode MAD1 + MAD2\n");
"Decode a MAD byte array and print the directory. \n"
"Use Sector 0 == MAD 1\n"
" Sector 16 == MAD 2\n",
"mad decode --mad1 <hex>\n"
);
void *argtable[] = {
arg_param_begin,
arg_lit0("v", "verbose", "verbose output"),
arg_str1("d", "data", "<hex>", "MAD1 sector 0 data (64 bytes)"),
arg_str0(NULL, "mad2", "<hex>", "MAD2 sector 16 data (64 bytes)"),
arg_lit0(NULL, "be", "big-endian AID byte swap"),
arg_lit0("v", "verbose", "verbose output"),
arg_str1("1", "mad1", "<hex>", "MAD 1 Sector 0 data (64 bytes)"),
arg_str0("2", "mad2", "<hex>", "MAD 2 Sector 16 data (64 bytes)"),
arg_lit0(NULL, "be", "big-endian AID byte swap"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
bool verbose = arg_get_lit(ctx, 1);
uint8_t data[MFBLOCK_SIZE * 4] = {0};
int datalen = 0;
int res = CLIParamHexToBuf(arg_get_str(ctx, 2), data, sizeof(data), &datalen);
uint8_t data2[MFBLOCK_SIZE * 4] = {0};
int data2len = 0;
int res2 = CLIParamHexToBuf(arg_get_str(ctx, 3), data2, sizeof(data2), &data2len);
uint8_t s0[MFBLOCK_SIZE * 4] = {0};
int s0n = 0;
int res = CLIParamHexToBuf(arg_get_str(ctx, 2), s0, sizeof(s0), &s0n);
uint8_t s16[MFBLOCK_SIZE * 4] = {0};
int s16n = 0;
int res2 = CLIParamHexToBuf(arg_get_str(ctx, 3), s16, sizeof(s16), &s16n);
bool swapmad = arg_get_lit(ctx, 4);
CLIParserFree(ctx);
if (res) {
PrintAndLogEx(FAILED, "Error parsing MAD1 hex data");
return PM3_EINVARG;
}
if (data2len > 0 && res2) {
if (s16n > 0 && res2) {
PrintAndLogEx(FAILED, "Error parsing MAD2 hex data");
return PM3_EINVARG;
}
if (datalen < (int)sizeof(mad1_sector_t)) {
PrintAndLogEx(ERR, "Need at least %zu bytes for MAD1 (got %d)", sizeof(mad1_sector_t), datalen);
if (s0n < (int)sizeof(mad1_sector_t)) {
PrintAndLogEx(ERR, "Need at least %zu bytes for MAD1 (got %d)", sizeof(mad1_sector_t), s0n);
return PM3_EINVARG;
}
MADPrintHeader();
bool haveMAD2 = false;
MAD1DecodeAndPrint((const mad1_sector_t *)data, swapmad, verbose, &haveMAD2);
MAD1DecodeAndPrint((const mad1_sector_t *)s0, swapmad, verbose, &haveMAD2);
if (data2len >= (int)sizeof(mad2_sector_t)) {
MAD2DecodeAndPrint((const mad2_sector_t *)data2, swapmad, verbose);
} else if (haveMAD2 && data2len == 0) {
if (s16n >= (int)sizeof(mad2_sector_t)) {
MAD2DecodeAndPrint((const mad2_sector_t *)s16, swapmad, verbose);
} else if (haveMAD2 && s16n == 0) {
PrintAndLogEx(HINT, "MAD1 indicates v2, use --mad2 to provide sector 16 data");
}
@@ -444,34 +507,51 @@ static int parse_sector_ranges(const char *str, uint8_t *sectors, int max_sector
const char *p = str;
while (*p) {
while (*p == ' ' || *p == '\t') p++;
if (*p == '\0') break;
while (*p == ' ' || *p == '\t') {
p++;
}
if (*p == '\0') {
break;
}
char *end = NULL;
long start = strtol(p, &end, 10);
if (end == p || start < 0 || start > 39)
if (end == p || start < 0 || start > 39) {
return -1;
}
long stop = start;
if (*end == '-') {
p = end + 1;
stop = strtol(p, &end, 10);
if (end == p || stop < start || stop > 39)
if (end == p || stop < start || stop > 39) {
return -1;
}
}
for (long s = start; s <= stop; s++) {
if (s == 0 || s == 16) {
PrintAndLogEx(ERR, "Sector %ld is reserved for MAD directory", s);
PrintAndLogEx(ERR, "Sector " _YELLOW_("%ld") " is reserved for MAD directory", s);
return -1;
}
if (count >= max_sectors)
if (count >= max_sectors) {
return -1;
}
sectors[count++] = (uint8_t)s;
}
p = end;
if (*p == ',') p++;
if (*p == ',') {
p++;
}
}
return count;
}
@@ -482,7 +562,7 @@ static int CmdMADEncode(const char *Cmd) {
"Encode a MAD byte array from AID-to-sector mappings",
"mad encode --aid E103:1-3 --aid 484D:4 -> MAD1 with NDEF + HID\n"
"mad encode --aid E103:1-3,5 -> non-contiguous sectors\n"
"mad encode --aid E103:1-3,17-18 --aid 484D:4 -> MAD1 + MAD2\n"
"mad encode --aid E103:1-3,17-18 --aid 484D:4 -> MAD1 + MAD2 + HID\n"
"mad encode --aid E103:1-3 -q -> quiet, hex only\n");
void *argtable[] = {
@@ -493,10 +573,9 @@ static int CmdMADEncode(const char *Cmd) {
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
int aid_count = 0;
struct arg_str *aid_arg = arg_get_str(ctx, 1);
aid_count = aid_arg->count;
int aid_count = aid_arg->count;
uint16_t sector_aids[40] = {0};
bool have_mad2 = false;
@@ -513,7 +592,7 @@ static int CmdMADEncode(const char *Cmd) {
int aid_hex_len = colon - val;
if (aid_hex_len != 4) {
PrintAndLogEx(ERR, "AID must be 4 hex chars, got %d in '%s'", aid_hex_len, val);
PrintAndLogEx(ERR, "AID must be 4 hex chars, got " _YELLOW_("%d"), aid_hex_len);
CLIParserFree(ctx);
return PM3_EINVARG;
}
@@ -525,7 +604,7 @@ static int CmdMADEncode(const char *Cmd) {
uint8_t sectors[40] = {0};
int nsectors = parse_sector_ranges(colon + 1, sectors, 40);
if (nsectors <= 0) {
PrintAndLogEx(ERR, "Invalid sector range in '%s'", val);
PrintAndLogEx(ERR, "Invalid sector range in " _YELLOW_("'%s'"), val);
CLIParserFree(ctx);
return PM3_EINVARG;
}
@@ -533,7 +612,7 @@ static int CmdMADEncode(const char *Cmd) {
for (int s = 0; s < nsectors; s++) {
uint8_t sno = sectors[s];
if (sector_aids[sno] != 0) {
PrintAndLogEx(ERR, "Sector %d already assigned to AID 0x%04X", sno, sector_aids[sno]);
PrintAndLogEx(ERR, "Sector " _YELLOW_("%d") " already assigned to AID " _YELLOW_("0x%04X"), sno, sector_aids[sno]);
CLIParserFree(ctx);
return PM3_EINVARG;
}
@@ -549,38 +628,40 @@ static int CmdMADEncode(const char *Cmd) {
// build MAD1
mad1_sector_t s0;
memset(&s0, 0, sizeof(s0));
s0.mad.info = 0x00;
for (int i = 0; i < MAD1_NUM_AIDS; i++) {
uint16_t a = sector_aids[i + 1];
s0.mad.aid[i] = swapmad ? BSWAP_16(a) : a;
}
s0.mad.crc = CRC8Mad((uint8_t *)&s0.mad.info, sizeof(mad1_t) - 1);
s0.mad.info = 0x00;
s0.mad.crc = CRC8Mad((uint8_t *)&s0.mad.info, sizeof(mad1_t) - 1);
memcpy(s0.trailer.key_a, g_mifare_mad_key, MIFARE_KEY_SIZE);
s0.trailer.access[0] = 0x78;
s0.trailer.access[1] = 0x77;
s0.trailer.access[2] = 0x88;
s0.trailer.gpb = have_mad2 ? 0xC2 : 0xC1; // DA=1, MA=1, version
memcpy(s0.trailer.access, "\x78\x77\x88", 3);
s0.trailer.gpb = (have_mad2) ? 0xC2 : 0xC1; // DA=1, MA=1, version
memcpy(s0.trailer.key_b, g_mifare_mad_key_b, MIFARE_KEY_SIZE);
// build MAD2 if needed
mad2_sector_t s16;
memset(&s16, 0, sizeof(s16));
if (have_mad2) {
s16.mad.info = 0x00;
for (int i = 0; i < MAD2_NUM_AIDS; i++) {
uint16_t a = sector_aids[i + 17];
s16.mad.aid[i] = swapmad ? BSWAP_16(a) : a;
}
s16.mad.info = 0x00;
s16.mad.crc = CRC8Mad((uint8_t *)&s16.mad.info, sizeof(mad2_t) - 1);
memcpy(s16.trailer.key_a, g_mifare_mad_key, MIFARE_KEY_SIZE);
s16.trailer.access[0] = 0x78;
s16.trailer.access[1] = 0x77;
s16.trailer.access[2] = 0x88;
memcpy(s16.trailer.access, "\x78\x77\x88", 3);
s16.trailer.gpb = 0xC2;
memcpy(s16.trailer.key_b, g_mifare_mad_key_b, MIFARE_KEY_SIZE);
}
if (!quiet) {
if (quiet == false) {
MADPrintHeader();
bool dummy = false;
MAD1DecodeAndPrint(&s0, swapmad, false, &dummy);
@@ -606,9 +687,9 @@ static int CmdMADEncode(const char *Cmd) {
static int CmdMADTest(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "mad test",
"Run MAD regression tests (offline, no card needed)",
"Run MAD regression tests. Runs offline with no card needed",
"mad test\n"
"mad test -v -> verbose output");
);
void *argtable[] = {
arg_param_begin,
@@ -625,12 +706,12 @@ static int CmdMADTest(const char *Cmd) {
static int CmdHelp(const char *Cmd);
static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"},
{"--------", CmdHelp, AlwaysAvailable, "--------------- " _CYAN_("MAD") " -----------------"},
{"read", CmdMADRead, IfPm3Iso14443a, "Read data from MAD AID sectors"},
{"write", CmdMADWrite, IfPm3Iso14443a, "Write data to MAD AID sectors"},
{"verify", CmdMADVerify, IfPm3Iso14443a, "Verify data in MAD AID sectors"},
{"--------", CmdHelp, AlwaysAvailable, "------------- " _CYAN_("General") " ---------------"},
{"help", CmdHelp, AlwaysAvailable, "This help"},
{"decode", CmdMADDecode, AlwaysAvailable, "Decode MAD byte array"},
{"encode", CmdMADEncode, AlwaysAvailable, "Encode MAD byte array from AID mappings"},
{"test", CmdMADTest, AlwaysAvailable, "Run MAD regression tests"},
+6
View File
@@ -21,6 +21,12 @@
#include "common.h"
typedef enum {
MAD_CARD_CLASSIC,
MAD_CARD_PLUS,
} mad_card_type_t;
int CmdMAD(const char *Cmd);
int CmdMADMFRead(const char *Cmd);
+6 -6
View File
@@ -844,7 +844,7 @@ void des3_decrypt(void *out, const void *in, const void *key, uint8_t keycount)
}
// NIST Special Publication 800-38A — Recommendation for block cipher modes of operation: methods and techniques, 2001.
int aes_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length) {
int aes_encode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, sizeof(iiv));
@@ -862,7 +862,7 @@ int aes_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int l
return PM3_SUCCESS;
}
int aes_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length) {
int aes_decode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, 16);
@@ -881,7 +881,7 @@ int aes_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int l
}
// NIST Special Publication 800-38A — Recommendation for block cipher modes of operation: methods and techniques, 2001.
int aes256_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length) {
int aes256_encode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, sizeof(iiv));
@@ -900,7 +900,7 @@ int aes256_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, in
}
int aes256_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length) {
int aes256_decode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length) {
uint8_t iiv[16] = {0};
if (iv) {
memcpy(iiv, iv, 16);
@@ -921,14 +921,14 @@ int aes256_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, in
// NIST Special Publication 800-38B — Recommendation for block cipher modes of operation: The CMAC mode for authentication.
// https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/AES_CMAC.pdf
int aes_cmac(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *mac, int length) {
int aes_cmac(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *mac, int length) {
memset(mac, 0x00, 16);
// NIST 800-38B
return mbedtls_aes_cmac_prf_128(key, MBEDTLS_AES_BLOCK_SIZE, input, length, mac);
}
int aes_cmac8(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *mac, int length) {
int aes_cmac8(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *mac, int length) {
uint8_t cmac_tmp[16] = {0};
memset(mac, 0x00, 8);
+6 -6
View File
@@ -49,14 +49,14 @@ void des_decrypt_cbc(void *out, const void *in, const int length, const void *ke
void des3_encrypt(void *out, const void *in, const void *key, uint8_t keycount);
void des3_decrypt(void *out, const void *in, const void *key, uint8_t keycount);
int aes_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes_encode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes_decode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes256_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes256_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes256_encode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes256_decode(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *output, int length);
int aes_cmac(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *mac, int length);
int aes_cmac8(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *mac, int length);
int aes_cmac(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *mac, int length);
int aes_cmac8(uint8_t *iv, const uint8_t *key, uint8_t *input, uint8_t *mac, int length);
int sha1hash(uint8_t *input, int length, uint8_t *hash);
int sha256hash(uint8_t *input, int length, uint8_t *hash);
+418
View File
@@ -0,0 +1,418 @@
//-----------------------------------------------------------------------------
// 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.
//-----------------------------------------------------------------------------
// Flasher progress
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <math.h>
#include <pthread.h>
#include "frame_progress.h"
#include "frame_data.h"
#include "util_posix.h"
// --- platform: terminal-width detection ----------------------------------/
#ifdef _WIN32
# include <windows.h>
static int terminal_width(void) {
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
return csbi.srWindow.Right - csbi.srWindow.Left + 1;
}
const char *c = getenv("COLUMNS");
if (c) {
int w = atoi(c);
if (w > 0) {
return w;
}
}
return 80;
}
#else
# include <sys/ioctl.h>
# include <unistd.h>
static int terminal_width(void) {
struct winsize ws;
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) {
return (int)ws.ws_col;
}
const char *c = getenv("COLUMNS");
if (c) {
int w = atoi(c);
if (w > 0) {
return w;
}
}
return 80;
}
#endif
// --- wave parameters (unchanged from hadouken_wave.c) -------------------
#define ORIGIN_X 64.0
#define ORIGIN_Y 8.0
#define ASPECT 2.0
#define K 0.60
#define OMEGA 5.0
#define FLOOR 0.45
// BAR_OVERHEAD = visible fixed chars in the bar line: " Flashing [" (11) + "] 100%" (6)
#define BAR_OVERHEAD 17
#define BAR_MIN 10 // minimum inner fill width
#define BAR_MAX 512 // guard against absurdly wide terminals
#define BAR_ROW (FH + 2) // terminal row for the progress bar (1-based)
#define AFTER_ROW (FH + 3) // first free row after the animation+bar
// --- ANSI colour macros ---------------------------------------------------
#define ANSI_RESET "\x1b[0m" // reset all attributes
#define ANSI_BOLD "\x1b[1m" // bold / bright
#define ANSI_DIM "\x1b[2m" // dim / faint
// Progress-bar role colours
#define ANSI_BAR_LABEL "\x1b[36m" // label " Flashing " — cyan
#define ANSI_BAR_BRACKET "\x1b[37m" // brackets [ ] — white
#define ANSI_BAR_FILLED "\x1b[36;1m" // filled '=' — green bold
#define ANSI_BAR_EMPTY "\x1b[2;37m" // empty '-' — dim white
#define ANSI_BAR_PCT "\x1b[33;1m" // percentage number — yellow bold
// --- cursor / screen control macros --------------------------------------
// Non-colour escape sequences.
#define ESC_CURSOR_HIDE "\x1b[?25l" // hide the cursor
#define ESC_CURSOR_SHOW "\x1b[?25h" // show the cursor
#define ESC_CURSOR_HOME "\x1b[H" // move to row 1, col 1
#define ESC_CURSOR_POS "\x1b[%d;1H" // move to row %d col 1 (needs int arg)
#define ESC_ERASE_LINE "\x1b[2K" // erase entire current line
#define ESC_ERASE_SCREEN "\x1b[2J" // erase entire screen
#define ESC_SYNC_ON "\x1b[?2026h" // DEC 2026 synchronized output — on
#define ESC_SYNC_OFF "\x1b[?2026l" // DEC 2026 synchronized output — off
static const char *GLYPHS = " .:;+xX#";
// --- shared state --------------------------------------------------------
static volatile sig_atomic_t g_resize = 0; // set by SIGWINCH
static volatile int g_running = 0;
static volatile int g_progress = 0; // 0..100
static pthread_t g_thread;
// animation config – written once before hadouken_start()
static double g_fps = 30.0;
static int g_glyph_mode = 0;
static int g_wave_mode = 0; // 0 = radial, 1 = beam
void hadouken_on_sigint(int s) {
(void)s;
g_running = 0;
}
#ifndef _WIN32
void hadouken_on_sigwinch(int s) {
(void)s;
g_resize = 1;
}
#endif
/*
* Compute the inner fill width for the progress bar from the current terminal
* width, clamped to [BAR_MIN, BAR_MAX].
*/
static int bar_inner_width(void) {
int w = terminal_width() - BAR_OVERHEAD;
if (w < BAR_MIN) {
w = BAR_MIN;
}
if (w > BAR_MAX) {
w = BAR_MAX;
}
return w;
}
// --- colour helpers ------------------------------------------------------
static inline int clamp8(double v) {
if (v < 0) {
return 0;
}
if (v > 255) {
return 255;
}
return (int)(v + 0.5);
}
static void fire_color(int x, int y, const Cell *c, double t, int mode, int *r, int *g, int *b) {
double dx = x - ORIGIN_X;
double dy = (y - ORIGIN_Y) * ASPECT;
double d = sqrt(dx * dx + dy * dy);
double phase_var = mode ? (dx > 0 ? dx : 0.0) : d;
double wave = 0.5 + 0.5 * sin(phase_var * K - OMEGA * t);
double atten = 1.0 - d * 0.012;
if (atten < 0.35) {
atten = 0.35;
}
if (atten > 1.0) {
atten = 1.0;
}
double inten = (FLOOR + (1.0 - FLOOR) * wave) * atten;
double crest = wave * wave;
*r = clamp8(c->r * inten + 70 * crest);
*g = clamp8(c->g * inten + 110 * crest);
*b = clamp8(c->b * inten + 50 * crest);
}
// --- line renderers ------------------------------------------------------
// Render one animation row into dst (same logic as hadouken_wave.c).
static int render_anim_line(char *dst, int y, double t, int glyph_mode, int mode) {
int len = 0;
int last_r = -1, last_g = -1, last_b = -1, last_has = -2;
int pending_blanks = 0;
for (int x = 0; x < FW; x++) {
const Cell *c = &FRAME[y][x];
int ch = c->ch;
int has = c->has;
int r = 0;
int g = 0;
int b = 0;
if (ch == ' ' && !has) {
pending_blanks++;
continue;
}
if (c->fire) {
fire_color(x, y, c, t, mode, &r, &g, &b);
has = 1;
if (glyph_mode) {
double lum = (r + g + b) / 765.0;
int idx = (int)(lum * 8);
if (idx > 7) {
idx = 7;
}
ch = GLYPHS[idx];
if (ch == ' ') {
ch = '.';
}
}
} else if (has) {
r = c->r;
g = c->g;
b = c->b;
}
if (pending_blanks) {
memset(dst + len, ' ', pending_blanks);
len += pending_blanks;
pending_blanks = 0;
}
if (has != last_has || r != last_r || g != last_g || b != last_b) {
if (has) {
len += sprintf(dst + len, "\x1b[38;2;%d;%d;%dm", r, g, b);
} else {
len += sprintf(dst + len, ANSI_RESET);
}
last_has = has;
last_r = r;
last_g = g;
last_b = b;
}
dst[len++] = (char)ch;
}
dst[len] = '\0';
return len;
}
/*
* Render the progress bar into dst. bar_width is the inner fill width,
* computed dynamically from the current terminal width each frame.
*
* Flashing [========================================----] 100%
* ^<--------- bar_width chars ----------->^
*/
static int render_progress_bar(char *dst, int pct, int bar_width) {
int len = 0;
int filled = (bar_width * pct) / 100;
if (filled > bar_width) {
filled = bar_width;
}
// label
len += sprintf(dst + len, ANSI_BAR_LABEL " Flashing " ANSI_RESET ANSI_BAR_BRACKET "[" ANSI_RESET);
// filled portion
if (filled > 0) {
len += sprintf(dst + len, ANSI_BAR_FILLED);
for (int i = 0; i < filled; i++) {
dst[len++] = '=';
}
}
// empty portion
if (filled < bar_width) {
len += sprintf(dst + len, ANSI_BAR_EMPTY);
for (int i = filled; i < bar_width; i++) {
dst[len++] = '-';
}
}
// closing bracket + percentage
len += sprintf(dst + len, ANSI_RESET ANSI_BAR_BRACKET "] " ANSI_RESET ANSI_BAR_PCT "%3d%%" ANSI_RESET, pct);
dst[len] = '\0';
return len;
}
static double now_sec(void) {
return msclock() / 1000.0;
}
// --- animation thread ----------------------------------------------------
static void *anim_thread(void *arg) {
(void)arg;
// static keeps these off the thread stack (BSS)
static char cur [FH][FW * 24 + 16];
static char prev[FH][FW * 24 + 16];
static char out [FH * (FW * 24 + 32) + 512];
// bar buf: BAR_MAX fill chars + ANSI escapes per char + fixed overhead
static char bar [BAR_MAX + 256];
int have_prev = 0;
double frame_dt = 1.0 / g_fps;
double start = now_sec();
while (g_running) {
double t0 = now_sec();
double t = t0 - start;
int pct = g_progress; // single-read snapshot
// On terminal resize: flush the diff cache so all rows redraw cleanly
if (g_resize) {
g_resize = 0;
have_prev = 0;
}
// dynamic: re-queried every frame
int bw = bar_inner_width();
int n = 0;
// sync on, home
n += sprintf(out + n, ESC_SYNC_ON ESC_CURSOR_HOME);
// animation rows (with per-line diffing)
for (int y = 0; y < FH; y++) {
int len = render_anim_line(cur[y], y, t, g_glyph_mode, g_wave_mode);
if (have_prev && strcmp(cur[y], prev[y]) == 0) {
continue;
}
n += sprintf(out + n, ESC_CURSOR_POS ESC_ERASE_LINE, y + 1);
memcpy(out + n, cur[y], len);
n += len;
memcpy(prev[y], cur[y], len + 1);
}
// progress bar (always redrawn, width adapts to terminal)
int blen = render_progress_bar(bar, pct, bw);
n += sprintf(out + n, ESC_CURSOR_POS ESC_ERASE_LINE, BAR_ROW);
memcpy(out + n, bar, blen);
n += blen;
// reset, sync off
n += sprintf(out + n, ANSI_RESET ESC_SYNC_OFF);
have_prev = 1;
fwrite(out, 1, n, stdout);
fflush(stdout);
// fixed-timestep with render-time compensation
double remain = frame_dt - (now_sec() - t0);
if (remain > 0) {
msleep((uint32_t)(remain * 1000));
}
}
return NULL;
}
/*
* Start the animation thread.
* fps – frames per second (e.g. 30.0)
* glyph_mode – 1 = ASCII glyphs instead of colour blocks
* wave_mode – 0 = radial rings, 1 = forward beam
*/
void hadouken_start(double fps, int glyph_mode, int wave_mode) {
g_fps = (fps > 0) ? fps : 30.0;
g_glyph_mode = glyph_mode;
g_wave_mode = wave_mode;
g_progress = 0;
g_running = 1;
// hide cursor, clear screen
fputs(ESC_CURSOR_HIDE ESC_ERASE_SCREEN, stdout);
fflush(stdout);
pthread_create(&g_thread, NULL, anim_thread, NULL);
}
/*
* Update the progress bar.
* Safe to call from any thread.
* pct is clamped to [0, 100].
*/
void hadouken_set_progress(int pct) {
if (pct < 0) {
pct = 0;
}
if (pct > 100) {
pct = 100;
}
g_progress = pct;
}
/*
* Stop the animation thread, then position the cursor on the line below the
* progress bar and restore it so subsequent printf/puts output is visible.
*/
void hadouken_stop(void) {
/* Wait 2 frame durations so the thread renders at least one more frame
* with the final g_progress value (e.g. 100%) before we signal exit.
* Without this, the thread may be mid-sleep and exit before painting 100%. */
msleep((uint32_t)(2000.0 / g_fps));
g_running = 0;
pthread_join(g_thread, NULL);
// Move below the progress bar, restore cursor visibility
fprintf(stdout, ESC_CURSOR_POS ANSI_RESET ESC_CURSOR_SHOW "\n", AFTER_ROW);
fflush(stdout);
}
+33
View File
@@ -0,0 +1,33 @@
//-----------------------------------------------------------------------------
// 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.
//-----------------------------------------------------------------------------
// Flashing progress functions
//-----------------------------------------------------------------------------
#ifndef __FRAME_PROGRESS_H__
#define __FRAME_PROGRESS_H__
#include "common.h"
#include "elf.h"
void hadouken_start(double fps, int glyph_mode, int wave_mode);
void hadouken_set_progress(int pct);
void hadouken_stop(void);
void hadouken_on_sigint(int s);
void hadouken_on_sigwinch(int s);
#endif
+133 -72
View File
@@ -91,8 +91,9 @@ 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)
if (jstr == NULL) {
return NULL;
}
if (!json_is_string(jstr)) {
PrintAndLogEx(WARNING, _YELLOW_("`%s`") " is not a string", name);
@@ -100,8 +101,9 @@ static const char *mad_json_get_str(json_t *data, const char *name) {
}
const char *cstr = json_string_value(jstr);
if (strlen(cstr) == 0)
if (strlen(cstr) == 0) {
return NULL;
}
return cstr;
}
@@ -115,18 +117,24 @@ static json_t *mad_lookup_aid(json_t *root, uint16_t aid) {
snprintf(lmad, sizeof(lmad), "0x%04x", aid);
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 [%u] is not an object", idx);
continue;
}
const char *fmad = mad_json_get_str(data, "mad");
if (fmad == NULL)
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) {
return data;
}
@@ -138,6 +146,7 @@ static const char *mad_aid_description(json_t *elm) {
static char result[256];
const char *application = mad_json_get_str(elm, "application");
const char *company = mad_json_get_str(elm, "company");
if (application && company) {
snprintf(result, sizeof(result), " %s [%s]", application, company);
} else if (application) {
@@ -145,6 +154,7 @@ static const char *mad_aid_description(json_t *elm) {
} else {
snprintf(result, sizeof(result), " (unknown)");
}
return result;
}
@@ -159,12 +169,15 @@ static void mad_print_aid_verbose(json_t *elm) {
if (application) {
PrintAndLogEx(SUCCESS, " Application......... %s", application);
}
if (company) {
PrintAndLogEx(SUCCESS, " Company............. %s", company);
}
if (provider) {
PrintAndLogEx(SUCCESS, " Service provider.... %s", provider);
}
if (integrator) {
PrintAndLogEx(SUCCESS, " System integrator... %s", integrator);
}
@@ -173,8 +186,9 @@ static void mad_print_aid_verbose(json_t *elm) {
static int mad1CRCCheck(const mad1_t *mad1, bool verbose) {
uint8_t crc = CRC8Mad((uint8_t *)&mad1->info, sizeof(mad1_t) - 1);
if (crc != mad1->crc) {
if (verbose)
if (verbose) {
PrintAndLogEx(WARNING, _RED_("Wrong MAD 1 CRC") " calculated: 0x%02x != 0x%02x", crc, mad1->crc);
}
return PM3_ESOFT;
}
return PM3_SUCCESS;
@@ -183,15 +197,18 @@ static int mad1CRCCheck(const mad1_t *mad1, bool verbose) {
static int mad2CRCCheck(const mad2_t *mad2, bool verbose) {
uint8_t crc = CRC8Mad((uint8_t *)&mad2->info, sizeof(mad2_t) - 1);
if (crc != mad2->crc) {
if (verbose)
if (verbose) {
PrintAndLogEx(WARNING, _RED_("Wrong MAD 2 CRC") " calculated: 0x%02x != 0x%02x", crc, mad2->crc);
}
return PM3_ESOFT;
}
return PM3_SUCCESS;
}
static int MADInfoByteDecode(uint8_t info, int mad_ver, bool verbose) {
info &= MAD_INFO_MASK;
if (mad_ver == 1 && info >= 0xF) {
PrintAndLogEx(WARNING, "Invalid Info byte (MAD1) value " _YELLOW_("0x%02x"), info);
if (verbose) {
@@ -199,6 +216,7 @@ static int MADInfoByteDecode(uint8_t info, int mad_ver, bool verbose) {
}
return PM3_ESOFT;
}
if (mad_ver == 2 && (info == 0x10 || info >= 0x28)) {
PrintAndLogEx(WARNING, "Invalid Info byte (MAD2) value " _YELLOW_("0x%02x"), info);
return PM3_ESOFT;
@@ -207,8 +225,9 @@ static int MADInfoByteDecode(uint8_t info, int mad_ver, bool verbose) {
}
int MADCheck(const mad1_sector_t *sector0, const mad2_sector_t *mad2, bool verbose, bool *haveMAD2) {
if (sector0 == NULL)
if (sector0 == NULL) {
return PM3_EINVARG;
}
uint8_t GPB = sector0->trailer.gpb;
if (verbose) {
@@ -250,10 +269,11 @@ int MADCheck(const mad1_sector_t *sector0, const mad2_sector_t *mad2, bool verbo
}
if (verbose) {
if (GPB & MAD_GPB_MA_MASK)
if (GPB & MAD_GPB_MA_MASK) {
PrintAndLogEx(SUCCESS, "Multi application card");
else
} else {
PrintAndLogEx(SUCCESS, "Single application card");
}
}
return res;
}
@@ -269,7 +289,7 @@ int MADDecode(const mad1_sector_t *sector0, const mad2_sector_t *mad2, mad_entry
}
if (override) {
PrintAndLogEx(INFO, "overriding crc check");
PrintAndLogEx(INFO, "Overriding crc check");
}
for (int i = 0; i < MAD1_NUM_AIDS; i++) {
@@ -289,19 +309,28 @@ int MADDecode(const mad1_sector_t *sector0, const mad2_sector_t *mad2, mad_entry
}
int MADCardHolderInfoDecode(const uint8_t *data, size_t datalen, bool verbose) {
size_t idx = 0;
while (idx < datalen) {
uint8_t len = data[idx] & MAD_TLV_LEN_MASK;
uint8_t type = data[idx] >> MAD_TLV_TYPE_SHIFT;
idx++;
if (len == 0)
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))
if (type >= ARRAYLEN(holder_info_type)) {
type = ARRAYLEN(holder_info_type) - 1;
}
PrintAndLogEx(INFO, "%14s " _GREEN_("%.*s"), holder_info_type[type], len, &data[idx]);
idx += len;
}
@@ -314,6 +343,7 @@ void MADPrintHeader(void) {
}
int MAD1DecodeAndPrint(const mad1_sector_t *sector, bool swapmad, bool verbose, bool *haveMAD2) {
if (open_mad_file(&mad_known_aids, verbose) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "Could not load MAD JSON, AID names will not be resolved");
}
@@ -335,9 +365,12 @@ int MAD1DecodeAndPrint(const mad1_sector_t *sector, bool swapmad, bool verbose,
PrintAndLogEx(INFO, "---------------- " _CYAN_("Listing") " ----------------");
PrintAndLogEx(INFO, " 00 MAD v1");
uint32_t prev_aid = 0xFFFFFFFF;
for (int i = 0; i < MAD1_NUM_AIDS; i++) {
int sector_no = i + 1;
uint16_t aid = madGetAID(sector->mad.aid[i], swapmad);
if (aid <= MAD_AID_ADMIN_MAX) {
PrintAndLogEx(INFO,
@@ -362,6 +395,7 @@ int MAD1DecodeAndPrint(const mad1_sector_t *sector, bool swapmad, bool verbose,
aid,
desc
);
if (verbose && elm) {
mad_print_aid_verbose(elm);
}
@@ -373,6 +407,7 @@ int MAD1DecodeAndPrint(const mad1_sector_t *sector, bool swapmad, bool verbose,
}
int MAD2DecodeAndPrint(const mad2_sector_t *sector, bool swapmad, bool verbose) {
if (open_mad_file(&mad_known_aids, false) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "Could not load MAD JSON, AID names will not be resolved");
}
@@ -382,10 +417,11 @@ int MAD2DecodeAndPrint(const mad2_sector_t *sector, bool swapmad, bool verbose)
int res = mad2CRCCheck(&sector->mad, true);
if (verbose) {
if (res == PM3_SUCCESS)
if (res == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( " _GREEN_("%s") " )", sector->mad.crc, "ok");
else
} else {
PrintAndLogEx(SUCCESS, "CRC8...... 0x%02X ( " _RED_("%s") " )", sector->mad.crc, "fail");
}
}
int ibs = MADInfoByteDecode(sector->mad.info, 2, verbose);
@@ -402,8 +438,10 @@ int MAD2DecodeAndPrint(const mad2_sector_t *sector, bool swapmad, bool verbose)
uint32_t prev_aid = 0xFFFFFFFF;
for (int i = 0; i < MAD2_NUM_AIDS; i++) {
int sector_no = i + 17;
uint16_t aid = madGetAID(sector->mad.aid[i], swapmad);
if (aid <= MAD_AID_ADMIN_MAX) {
PrintAndLogEx(INFO,
(ibs == sector_no) ? _MAGENTA_(" %02d [%04X] %s") : " %02d [" _GREEN_("%04X") "] %s",
@@ -445,34 +483,40 @@ int MADDFDecodeAndPrint(uint32_t short_aid, bool verbose) {
json_t *elm = mad_lookup_aid(mad_known_aids, short_aid);
const char *desc = elm ? mad_aid_description(elm) : " (unknown)";
PrintAndLogEx(INFO, " MAD AID Function 0x%04X... " _YELLOW_("%s"), short_aid, desc);
if (verbose && elm) {
mad_print_aid_verbose(elm);
}
close_mad_file(mad_known_aids);
return PM3_SUCCESS;
}
bool HasMADKey(const mad1_sector_t *s0) {
if (s0 == NULL)
if (s0 == NULL) {
return false;
}
return (memcmp(s0->trailer.key_a, g_mifare_mad_key, sizeof(g_mifare_mad_key)) == 0);
}
int DetectHID(const mad1_sector_t *s0, uint16_t manufacture) {
if (s0 == NULL)
if (s0 == NULL) {
return -1;
}
for (int i = 0; i < MAD1_NUM_AIDS; i++) {
if (madGetAID(s0->mad.aid[i], false) == manufacture)
if (madGetAID(s0->mad.aid[i], false) == manufacture) {
return i + 1;
}
}
return -1;
}
int convert_mad_to_arr(const mad1_sector_t *s0, const mad2_sector_t *s16,
size_t dump_len,
uint8_t *out, size_t omax, size_t *olen, bool override) {
if (s0 == NULL || out == NULL || olen == NULL || dump_len < sizeof(mad1_sector_t) || omax == 0)
int convert_mad_to_arr(const mad1_sector_t *s0, const mad2_sector_t *s16, size_t dump_len, uint8_t *out, size_t omax, size_t *olen, bool override) {
if (s0 == NULL || out == NULL || olen == NULL || dump_len < sizeof(mad1_sector_t) || omax == 0) {
return PM3_EINVARG;
}
*olen = 0;
@@ -482,26 +526,30 @@ int convert_mad_to_arr(const mad1_sector_t *s0, const mad2_sector_t *s16,
}
mad_entry_list_t mad_list = {0};
if (MADDecode(s0, s16, &mad_list, false, override)) {
PrintAndLogEx(ERR, "can't decode MAD");
if (MADDecode(s0, s16, &mad_list, false, override) != PM3_SUCCESS) {
PrintAndLogEx(ERR, "Can't decode MAD");
return PM3_ESOFT;
}
const uint8_t *dump = (const uint8_t *)s0;
uint16_t ndef_aid = 0xE103;
for (size_t i = 0; i < mad_list.len; i++) {
if (ndef_aid != mad_list.entries[i].aid)
if (ndef_aid != mad_list.entries[i].aid) {
continue;
}
uint8_t sector_no = mad_list.entries[i].sector;
size_t offset = mfFirstBlockOfSector(sector_no) * MFBLOCK_SIZE;
size_t sector_size = mfNumBlocksPerSector(sector_no) * MFBLOCK_SIZE;
size_t data_size = sector_size - MFBLOCK_SIZE;
if (offset + sector_size > dump_len)
if ((offset + sector_size) > dump_len) {
break;
}
if (*olen + data_size > omax) {
if ((*olen + data_size) > omax) {
PrintAndLogEx(WARNING, "NDEF output buffer full");
return PM3_EOVFLOW;
}
@@ -512,20 +560,19 @@ int convert_mad_to_arr(const mad1_sector_t *s0, const mad2_sector_t *s16,
return PM3_SUCCESS;
}
static int mad_read_directory(const mad_ops_t *ops, bool swapmad, bool override,
mad_entry_list_t *mad_list) {
static int mad_read_directory(const mad_ops_t *ops, bool swapmad, bool override, mad_entry_list_t *mad_list) {
mad1_sector_t sector0 = {0};
int res = ops->read_sector(MF_MAD1_SECTOR, ops->mad_key_type,
ops->mad_key, (uint8_t *)&sector0, ops->verbose);
int res = ops->read_sector(MF_MAD1_SECTOR, ops->mad_key_type, ops->mad_key, (uint8_t *)&sector0, ops->verbose);
if (res != PM3_SUCCESS) {
PrintAndLogEx(ERR, "error reading MAD1 sector 0");
PrintAndLogEx(ERR, "Error reading MAD1 sector " _YELLOW_("0"));
return res;
}
mad2_sector_t mad2 = {0};
const mad2_sector_t *pmad2 = NULL;
res = ops->read_sector(MF_MAD2_SECTOR, ops->mad_key_type,
ops->mad_key, (uint8_t *)&mad2, ops->verbose);
res = ops->read_sector(MF_MAD2_SECTOR, ops->mad_key_type, ops->mad_key, (uint8_t *)&mad2, ops->verbose);
if (res == PM3_SUCCESS) {
pmad2 = &mad2;
} else if (ops->verbose) {
@@ -535,75 +582,85 @@ static int mad_read_directory(const mad_ops_t *ops, bool swapmad, bool override,
return MADDecode(&sector0, pmad2, mad_list, swapmad, override);
}
int mad_app_read(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool override,
uint8_t *out, size_t max_len, size_t *out_len) {
int mad_app_read(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool override, uint8_t *out, size_t max_len, size_t *out_len) {
*out_len = 0;
mad_entry_list_t mad_list = {0};
int res = mad_read_directory(ops, swapmad, override, &mad_list);
if (res != PM3_SUCCESS)
if (res != PM3_SUCCESS) {
return res;
}
for (size_t i = 0; i < mad_list.len; i++) {
if (mad_list.entries[i].aid != aid)
if (mad_list.entries[i].aid != aid) {
continue;
}
uint8_t sno = mad_list.entries[i].sector;
uint8_t sector_buf[MFBLOCK_SIZE * 16] = {0};
res = ops->read_sector(sno, ops->app_key_type,
ops->app_key, sector_buf, ops->verbose);
res = ops->read_sector(sno, ops->app_key_type, ops->app_key, sector_buf, ops->verbose);
if (res != PM3_SUCCESS) {
PrintAndLogEx(ERR, "error reading sector %u", sno);
PrintAndLogEx(ERR, "Error reading sector %u", sno);
return res;
}
uint8_t num_data_blocks = mfNumBlocksPerSector(sno) - 1;
size_t nbytes = num_data_blocks * MFBLOCK_SIZE;
if (*out_len + nbytes > max_len) {
PrintAndLogEx(ERR, "output buffer too small");
if ((*out_len + nbytes) > max_len) {
PrintAndLogEx(ERR, "Output buffer too small");
return PM3_EOVFLOW;
}
memcpy(out + *out_len, sector_buf, nbytes);
*out_len += nbytes;
if (ops->verbose)
PrintAndLogEx(INFO, "read sector %u, %zu data bytes", sno, nbytes);
if (ops->verbose) {
PrintAndLogEx(INFO, "Read sector %u, %zu bytes", sno, nbytes);
}
}
if (*out_len == 0 && ops->verbose)
PrintAndLogEx(WARNING, "no sectors found for AID 0x%04X", aid);
if (*out_len == 0 && ops->verbose) {
PrintAndLogEx(WARNING, "No sectors found for AID 0x%04X", aid);
}
return PM3_SUCCESS;
}
int mad_app_write(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool override,
const uint8_t *data, size_t data_len) {
int mad_app_write(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool override, const uint8_t *data, size_t data_len) {
mad_entry_list_t mad_list = {0};
int res = mad_read_directory(ops, swapmad, override, &mad_list);
if (res != PM3_SUCCESS)
if (res != PM3_SUCCESS) {
return res;
}
size_t capacity = 0;
for (size_t i = 0; i < mad_list.len; i++) {
if (mad_list.entries[i].aid == aid)
if (mad_list.entries[i].aid == aid) {
capacity += (mfNumBlocksPerSector(mad_list.entries[i].sector) - 1) * MFBLOCK_SIZE;
}
}
if (data_len > capacity) {
if (ops->verbose)
PrintAndLogEx(ERR, "data (%zu bytes) exceeds capacity (%zu bytes) for AID 0x%04X",
data_len, capacity, aid);
if (ops->verbose) {
PrintAndLogEx(ERR, "Data (%zu bytes) exceeds capacity (%zu bytes) for AID 0x%04X", data_len, capacity, aid);
}
return PM3_EINVARG;
}
size_t offset = 0;
for (size_t i = 0; i < mad_list.len; i++) {
if (mad_list.entries[i].aid != aid)
if (mad_list.entries[i].aid != aid) {
continue;
if (offset >= data_len)
}
if (offset >= data_len) {
break;
}
uint8_t sno = mad_list.entries[i].sector;
uint8_t num_data_blocks = mfNumBlocksPerSector(sno) - 1;
@@ -611,45 +668,50 @@ int mad_app_write(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool overrid
uint8_t sector_data[MFBLOCK_SIZE * 15] = {0};
size_t to_copy = sector_data_size;
if (data_len - offset < to_copy)
if (data_len - offset < to_copy) {
to_copy = data_len - offset;
}
memcpy(sector_data, data + offset, to_copy);
res = ops->write_sector_data(sno, ops->app_key_type,
ops->app_key, sector_data, ops->verbose);
res = ops->write_sector_data(sno, ops->app_key_type, ops->app_key, sector_data, ops->verbose);
if (res != PM3_SUCCESS) {
PrintAndLogEx(ERR, "error writing sector %u", sno);
PrintAndLogEx(ERR, "Error writing sector %u", sno);
return res;
}
if (ops->verbose)
PrintAndLogEx(INFO, "wrote sector %u, %zu bytes", sno, to_copy);
if (ops->verbose) {
PrintAndLogEx(INFO, "Wrote sector %u, %zu bytes", sno, to_copy);
}
offset += sector_data_size;
}
PrintAndLogEx(SUCCESS, "wrote %zu bytes to AID 0x%04X", data_len, aid);
PrintAndLogEx(SUCCESS, "Wrote %zu bytes to AID 0x%04X ( %s )", data_len, aid, _GREEN_("ok"));
return PM3_SUCCESS;
}
int mad_app_verify(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool override,
const uint8_t *expected, size_t expected_len) {
int mad_app_verify(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool override, const uint8_t *expected, size_t expected_len) {
uint8_t readback[MIFARE_4K_MAX_BYTES];
size_t readback_len = 0;
int res = mad_app_read(ops, aid, swapmad, override,
readback, sizeof(readback), &readback_len);
if (res != PM3_SUCCESS)
int res = mad_app_read(ops, aid, swapmad, override, readback, sizeof(readback), &readback_len);
if (res != PM3_SUCCESS) {
return res;
}
size_t cmp_len = readback_len < expected_len ? readback_len : expected_len;
if (memcmp(expected, readback, cmp_len) != 0) {
if (ops->verbose) {
PrintAndLogEx(ERR, "Verify " _RED_("FAILED") ": data mismatch");
PrintAndLogEx(ERR, "Data mismatchm, verify ( %s )", _RED_("fail"));
for (size_t j = 0; j < cmp_len; j++) {
if (expected[j] != readback[j]) {
PrintAndLogEx(ERR, "first difference at offset %zu: expected %02X, got %02X",
j, expected[j], readback[j]);
PrintAndLogEx(ERR, "first difference at offset %zu: expected %02X, got %02X", j, expected[j], readback[j]);
break;
}
}
@@ -658,10 +720,9 @@ int mad_app_verify(const mad_ops_t *ops, uint16_t aid, bool swapmad, bool overri
}
if (expected_len != readback_len) {
PrintAndLogEx(WARNING, "length mismatch: expected %zu, read %zu (data matches up to shorter)",
expected_len, readback_len);
PrintAndLogEx(WARNING, "length mismatch: expected %zu, read %zu (data matches up to shorter)", expected_len, readback_len);
}
PrintAndLogEx(SUCCESS, "Verify " _GREEN_("OK") " (%zu bytes)", cmp_len);
PrintAndLogEx(SUCCESS, "Verified %zu bytes ( %s )", cmp_len, _GREEN_("ok"));
return PM3_SUCCESS;
}
+2 -4
View File
@@ -78,13 +78,11 @@ typedef struct {
typedef struct {
// Read a full sector (all blocks including trailer) into buf.
// buf must hold mfNumBlocksPerSector(sector_no) * MFBLOCK_SIZE bytes.
int (*read_sector)(uint8_t sector_no, uint8_t key_type,
const uint8_t *key, uint8_t *buf, bool verbose);
int (*read_sector)(uint8_t sector_no, uint8_t key_type, const uint8_t *key, uint8_t *buf, bool verbose);
// Write the data blocks (non-trailer) of a sector.
// data points to (mfNumBlocksPerSector(sector_no) - 1) * MFBLOCK_SIZE bytes.
int (*write_sector_data)(uint8_t sector_no, uint8_t key_type,
const uint8_t *key, const uint8_t *data, bool verbose);
int (*write_sector_data)(uint8_t sector_no, uint8_t key_type, const uint8_t *key, const uint8_t *data, bool verbose);
const uint8_t *mad_key;
uint8_t mad_key_type;
+3 -3
View File
@@ -221,7 +221,7 @@ int CalculateMAC(mf4Session_t *mf4session, MACType_t mtype, uint8_t blockNum, ui
return aes_cmac8(NULL, mf4session->Kmac, macdata, mac, macdatalen);
}
int MifareAuth4(mf4Session_t *mf4session, const uint8_t *keyn, uint8_t *key, bool nonfirst, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode) {
int MifareAuth4(mf4Session_t *mf4session, const uint8_t *keyn, const uint8_t *key, bool nonfirst, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode) {
uint8_t data[257] = {0};
int datalen = 0;
@@ -585,7 +585,7 @@ int MFPWriteBlock(mf4Session_t *mf4session, bool plain, bool nomacres, uint8_t b
return PM3_SUCCESS;
}
int mfpReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *dataout, bool verbose) {
int mfpReadSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *dataout, bool verbose) {
// 0x4000 is the base for MFP KEY ID's. See datasheet
uint16_t uKeyNum = 0x4000 + sectorNo * 2 + (keyType ? 1 : 0);
@@ -662,7 +662,7 @@ int mfpReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *data
return PM3_SUCCESS;
}
int mfpWriteSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, const uint8_t *datain, bool verbose) {
int mfpWriteSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, const uint8_t *datain, bool verbose) {
uint16_t uKeyNum = 0x4000 + sectorNo * 2 + (keyType ? 1 : 0);
uint8_t keyn[2] = {0};
+3 -3
View File
@@ -60,14 +60,14 @@ void mfpSetVerboseMode(bool verbose);
const char *mfpGetErrorDescription(uint8_t errorCode);
int CalculateMAC(mf4Session_t *mf4session, MACType_t mtype, uint8_t blockNum, uint8_t blockCount, uint8_t *data, int datalen, uint8_t *mac, bool verbose);
int MifareAuth4(mf4Session_t *mf4session, const uint8_t *keyn, uint8_t *key, bool nonfirst, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode);
int MifareAuth4(mf4Session_t *mf4session, const uint8_t *keyn, const uint8_t *key, bool nonfirst, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode);
int MFPWritePerso(const uint8_t *keyNum, const uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
int MFPCommitPerso(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
int MFPReadBlock(mf4Session_t *mf4session, bool plain, bool nomaccmd, bool nomacres, uint8_t blockNum, uint8_t blockCount, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
int MFPWriteBlock(mf4Session_t *mf4session, bool plain, bool nomacres, uint8_t blockNum, uint8_t blockHdr, const uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
int mfpReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *dataout, bool verbose);
int mfpWriteSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, const uint8_t *datain, bool verbose);
int mfpReadSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, uint8_t *dataout, bool verbose);
int mfpWriteSector(uint8_t sectorNo, uint8_t keyType, const uint8_t *key, const uint8_t *datain, bool verbose);
int MFPGetSignature(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
int MFPGetVersion(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);