diff --git a/client/src/cmdhffmcos.c b/client/src/cmdhffmcos.c index 891e25f6c..3f19c6094 100644 --- a/client/src/cmdhffmcos.c +++ b/client/src/cmdhffmcos.c @@ -3073,6 +3073,519 @@ static int CmdHFFmcosHistory(const char *Cmd) { return PM3_SUCCESS; } +// --------------------------------------------------------------------------- +// TID card provisioning +// --------------------------------------------------------------------------- + +#define FMCOS_TID_AUTH_LOCKED 0xAA +#define FMCOS_TID_AUTH_UNLOCKED 0x55 + +static const uint8_t g_fmcos_tid_setcard_data[39] = { + 0x00, 0x90, 0x80, 0xEC, 0xFF, 0xED, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, + 0x08, 0x74, 0x11, 0x00, 0x02, 0x5A, 0x54, 0x40, 0xBD +}; + +static const uint8_t g_fmcos_tid_keyfile_data[11] = { + 0x1E, 0x00, 0x00, 0x00, 0x30, 0xFF, 0xFF, 0x00, 0x30, 0x00, 0x00 +}; + +// "1PAY.SYS.DDF01" +static const uint8_t g_fmcos_tid_mf_name[] = { + 0x31, 0x50, 0x41, 0x59, 0x2E, 0x53, 0x59, 0x53, + 0x2E, 0x44, 0x44, 0x46, 0x30, 0x31 +}; + +static int CmdHFFmcosTidSetCard(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid setcard", + "Send the TID SET CARD configuration APDU (fixed 39-byte payload).", + "hf fmcos tid setcard"); + void *argtable[] = { + arg_param_begin, + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + bool keep = arg_get_lit(ctx, 1); + CLIParserFree(ctx); + + uint8_t apdu[44] = {0x00, 0xEF, 0x00, 0x00, 0x27}; + memcpy(apdu + 5, g_fmcos_tid_setcard_data, 39); + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, sizeof(apdu), true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, "SET CARD " _GREEN_("OK")); + else + PrintAndLogEx(FAILED, "SET CARD " _RED_("failed")); + + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static int CmdHFFmcosTidSetUID(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid setuid", + "Program the TID card UID (4-7 bytes).", + "hf fmcos tid setuid --uid 13371337\n" + "hf fmcos tid setuid --uid 0102030405060708"); + void *argtable[] = { + arg_param_begin, + arg_str1(NULL, "uid", "", "UID bytes (4-7 bytes)"), + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, false); + uint8_t uid[7] = {0}; int uid_len = 0; + CLIGetHexWithReturn(ctx, 1, uid, &uid_len); + bool keep = arg_get_lit(ctx, 2); + CLIParserFree(ctx); + + if (uid_len < 4 || uid_len > 7) { + PrintAndLogEx(ERR, "--uid must be 4-7 bytes"); + return PM3_EINVARG; + } + + uint8_t apdu[12] = {0x00, 0x85, 0x00, 0x00, (uint8_t)uid_len}; + memcpy(apdu + 5, uid, (size_t)uid_len); + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, 5 + (size_t)uid_len, true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, "SET UID " _GREEN_("OK")); + else + PrintAndLogEx(FAILED, "SET UID " _RED_("failed")); + + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static int CmdHFFmcosTidSetAuth(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid setauth", + "Write the TID internal authentication key and set the lock state.\n" + "Lock byte: 0xAA = locked (permanent), 0x55 = unlocked (default).", + "hf fmcos tid setauth --key 1122334455667788\n" + "hf fmcos tid setauth --key 1122334455667788 --lock"); + void *argtable[] = { + arg_param_begin, + arg_str1(NULL, "key", "", "internal auth key (8 bytes)"), + arg_lit0(NULL, "lock", "lock the key permanently (0xAA); default unlocked (0x55)"), + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, false); + uint8_t key[8] = {0}; int key_len = 0; + CLIGetHexWithReturn(ctx, 1, key, &key_len); + bool lock = arg_get_lit(ctx, 2); + bool keep = arg_get_lit(ctx, 3); + CLIParserFree(ctx); + + if (key_len != 8) { + PrintAndLogEx(ERR, "--key must be 8 bytes"); + return PM3_EINVARG; + } + + // 00 21 00 00 0A [key[8]] [lock_byte] 00 + uint8_t apdu[15] = {0x00, 0x21, 0x00, 0x00, 0x0A}; + memcpy(apdu + 5, key, 8); + apdu[13] = lock ? FMCOS_TID_AUTH_LOCKED : FMCOS_TID_AUTH_UNLOCKED; + apdu[14] = 0x00; + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, sizeof(apdu), true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, "SET INTERNAL AUTH " _GREEN_("OK") " (key %s)", + lock ? _RED_("locked") : "unlocked"); + else + PrintAndLogEx(FAILED, "SET INTERNAL AUTH " _RED_("failed")); + + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static int CmdHFFmcosTidErase(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid erase", + "Erase the TID card file system (CLA=E0 INS=EC -- irreversible).", + "hf fmcos tid erase"); + void *argtable[] = { + arg_param_begin, + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + bool keep = arg_get_lit(ctx, 1); + CLIParserFree(ctx); + + PrintAndLogEx(WARNING, "Erasing TID card file system -- this is irreversible"); + + uint8_t apdu[5] = {0xE0, 0xEC, 0x00, 0x00, 0x00}; + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, sizeof(apdu), true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, "ERASE " _GREEN_("OK")); + else + PrintAndLogEx(FAILED, "ERASE " _RED_("failed")); + + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static int CmdHFFmcosTidProvision(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid provision", + "Full TID card provisioning sequence:\n" + " SET CARD -> SET UID -> SET INTERNAL AUTH -> ERASE\n" + " -> SELECT MF -> CREATE MF (3F00, 1PAY.SYS.DDF01) -> SELECT MF -> CREATE KEYFILE", + "hf fmcos tid provision --uid 13371337 --key 1122334455667788\n" + "hf fmcos tid provision --uid 13371337 --key 1122334455667788 --lock"); + void *argtable[] = { + arg_param_begin, + arg_str1(NULL, "uid", "", "UID bytes (4-7 bytes)"), + arg_str1(NULL, "key", "", "internal auth key (8 bytes)"), + arg_lit0(NULL, "lock", "lock the auth key permanently"), + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, false); + uint8_t uid[7] = {0}; int uid_len = 0; + CLIGetHexWithReturn(ctx, 1, uid, &uid_len); + uint8_t key[8] = {0}; int key_len = 0; + CLIGetHexWithReturn(ctx, 2, key, &key_len); + bool lock = arg_get_lit(ctx, 3); + bool keep = arg_get_lit(ctx, 4); + CLIParserFree(ctx); + + if (uid_len < 4 || uid_len > 7) { PrintAndLogEx(ERR, "--uid must be 4-7 bytes"); return PM3_EINVARG; } + if (key_len != 8) { PrintAndLogEx(ERR, "--key must be 8 bytes"); return PM3_EINVARG; } + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + +#define TID_STEP(label, apdu_ptr, apdu_sz, act, lon) \ + do { \ + if (fmcos_send_apdu((apdu_ptr), (apdu_sz), (act), (lon), resp, &resp_len) != PM3_SUCCESS || \ + resp_len < 2 || resp[resp_len-2] != 0x90 || resp[resp_len-1] != 0x00) { \ + PrintAndLogEx(FAILED, label " " _RED_("failed") " (SW:%02X%02X)", \ + resp_len >= 2 ? resp[resp_len-2] : 0, \ + resp_len >= 2 ? resp[resp_len-1] : 0); \ + goto tid_provision_fail; \ + } \ + PrintAndLogEx(SUCCESS, label " " _GREEN_("OK")); \ + } while (0) + + // 1 — SET CARD + { uint8_t a[44] = {0x00, 0xEF, 0x00, 0x00, 0x27}; + memcpy(a + 5, g_fmcos_tid_setcard_data, 39); + TID_STEP("SET CARD", a, sizeof(a), true, true); } + + // 2 — SET UID + { uint8_t a[12] = {0x00, 0x85, 0x00, 0x00, (uint8_t)uid_len}; + memcpy(a + 5, uid, (size_t)uid_len); + TID_STEP("SET UID", a, 5 + (size_t)uid_len, true, true); } + + // 3 — SET INTERNAL AUTH + { uint8_t a[15] = {0x00, 0x21, 0x00, 0x00, 0x0A}; + memcpy(a + 5, key, 8); + a[13] = lock ? FMCOS_TID_AUTH_LOCKED : FMCOS_TID_AUTH_UNLOCKED; + a[14] = 0x00; + TID_STEP("SET INTERNAL AUTH", a, sizeof(a), true, true); } + + // 4 — ERASE + PrintAndLogEx(WARNING, "Erasing card file system..."); + { uint8_t a[5] = {0xE0, 0xEC, 0x00, 0x00, 0x00}; + TID_STEP("ERASE", a, sizeof(a), true, true); } + + // 5 — SELECT MF (3F00) + { uint8_t a[7] = {0x00, 0xA4, 0x00, 0x00, 0x02, 0x3F, 0x00}; + TID_STEP("SELECT MF", a, sizeof(a), true, true); } + + // 6 — CREATE DF (3F00, SFI=02, name="1PAY.SYS.DDF01") + { uint8_t name_len = (uint8_t)sizeof(g_fmcos_tid_mf_name); + uint8_t a[32] = {0x80, 0xE0, 0x00, 0x00, (uint8_t)(name_len + 9), + 0x3F, 0x00, 0x6F, 0xFF, 0xF0, 0xF0, 0x02, 0x01, 0x00}; + memcpy(a + 14, g_fmcos_tid_mf_name, name_len); + TID_STEP("CREATE DF (3F00)", a, 14 + name_len, true, true); } + + // 7 — SELECT DF 3F00 + { uint8_t a[7] = {0x00, 0xA4, 0x00, 0x00, 0x02, 0x3F, 0x00}; + TID_STEP("SELECT DF (3F00)", a, sizeof(a), true, true); } + + // 8 — CREATE KEYFILE + { uint8_t a[16] = {0x80, 0xE0, 0x02, 0x00, 0x0B}; + memcpy(a + 5, g_fmcos_tid_keyfile_data, 11); + TID_STEP("CREATE KEYFILE", a, sizeof(a), true, keep); } + +#undef TID_STEP + + PrintAndLogEx(SUCCESS, "TID provisioning " _GREEN_("complete")); + if (!keep) DropField(); + return PM3_SUCCESS; + +tid_provision_fail: + DropField(); + return PM3_ESOFT; +} + +static int CmdHFFmcosTidCreateDF(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid createdf", + "CREATE sub-DF using TID format (P1=01, FID in data).\n" + "Note: TID CREATE DF has a different layout from standard 'hf fmcos create dir'.", + "hf fmcos tid createdf --id 3f01 --size 0f00 --sfi 96 --name 44444630 31"); + void *argtable[] = { + arg_param_begin, + arg_str1(NULL, "id", "<4hex>", "2-byte file ID"), + arg_str1(NULL, "size", "", "DF space in bytes (hex, e.g. 0f00)"), + arg_str1(NULL, "sfi", "", "short file ID (1 byte)"), + arg_str0(NULL, "name", "", "DF name bytes (variable, 0-16 bytes)"), + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, false); + uint8_t id_buf[2] = {0}; int id_len = 0; + CLIGetHexWithReturn(ctx, 1, id_buf, &id_len); + int size = (int)strtol(arg_get_str(ctx, 2)->sval[0], NULL, 16); + uint8_t sfi_buf[1] = {0}; int sfi_len = 0; + CLIGetHexWithReturn(ctx, 3, sfi_buf, &sfi_len); + uint8_t name[16] = {0}; int name_len = 0; + CLIGetHexWithReturn(ctx, 4, name, &name_len); + bool keep = arg_get_lit(ctx, 5); + CLIParserFree(ctx); + + if (id_len != 2) { PrintAndLogEx(ERR, "--id must be 2 bytes"); return PM3_EINVARG; } + if (sfi_len != 1) { PrintAndLogEx(ERR, "--sfi must be 1 byte"); return PM3_EINVARG; } + if (size < 1 || size > 0xFFFF) { PrintAndLogEx(ERR, "--size out of range"); return PM3_EINVARG; } + + // 80 E0 01 00 [fid_hi][fid_lo] [size_hi][size_lo] F0 F0 [sfi] 01 FF [name...] + uint8_t apdu[32] = { + 0x80, 0xE0, 0x01, 0x00, (uint8_t)(name_len + 9), + id_buf[0], id_buf[1], + (size >> 8) & 0xFF, size & 0xFF, + 0xF0, 0xF0, + sfi_buf[0], + 0x01, 0xFF + }; + memcpy(apdu + 14, name, (size_t)name_len); + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, 14 + (size_t)name_len, true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, "CREATE DF " _GREEN_("OK")); + else + PrintAndLogEx(FAILED, "CREATE DF " _RED_("failed")); + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static const CLIParserOption g_fmcos_tid_create_opts[] = { + {0, "bin"}, + {1, "keyfile"}, + {0, NULL} +}; + +static int CmdHFFmcosTidCreateBin(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid createbin", + "CREATE binary EF or KEYFILE using TID format (P1=02, FID in data, fixed Lc=11).\n" + "Use --type keyfile to create the fixed TID keyfile in the currently selected DF.\n" + "Note: TID CREATE EF has a different layout from standard 'hf fmcos create file'.", + "hf fmcos tid createbin --id 0001 --size 0100 --sfi 01\n" + "hf fmcos tid createbin --id 0002 --size 0040 --sfi 02 --rperm 20 --wperm f0\n" + "hf fmcos tid createbin --type keyfile"); + void *argtable[] = { + arg_param_begin, + arg_str0(NULL, "type", "", "file type: bin (default) or keyfile"), + arg_str0(NULL, "id", "<4hex>", "2-byte file ID (required for type bin)"), + arg_str0(NULL, "size", "", "file size in bytes (required for type bin)"), + arg_str0(NULL, "sfi", "", "short file ID, 1 byte (required for type bin)"), + arg_str0(NULL, "rperm", "", "read permission byte (default F0, bin only)"), + arg_str0(NULL, "wperm", "", "write permission byte (default F0, bin only)"), + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + + int ftype = 0; + if (CLIGetOptionList(arg_get_str(ctx, 1), g_fmcos_tid_create_opts, &ftype)) { CLIParserFree(ctx); return PM3_EINVARG; } + bool is_keyfile = (ftype == 1); + + uint8_t id_buf[2] = {0}; int id_len = 0; + CLIGetHexWithReturn(ctx, 2, id_buf, &id_len); + int size = 0; + if (arg_get_str(ctx, 3)->count > 0) + size = (int)strtol(arg_get_str(ctx, 3)->sval[0], NULL, 16); + uint8_t sfi_buf[1] = {0}; int sfi_len = 0; + CLIGetHexWithReturn(ctx, 4, sfi_buf, &sfi_len); + uint8_t rperm_buf[1] = {0}; int rperm_len = 0; + CLIGetHexWithReturn(ctx, 5, rperm_buf, &rperm_len); + uint8_t wperm_buf[1] = {0}; int wperm_len = 0; + CLIGetHexWithReturn(ctx, 6, wperm_buf, &wperm_len); + bool keep = arg_get_lit(ctx, 7); + CLIParserFree(ctx); + + uint8_t apdu[16] = {0x80, 0xE0, 0x02, 0x00, 0x0B}; + + if (is_keyfile) { + // Fixed TID keyfile: 80 E0 02 00 0B 1E 00 00 00 30 FF FF 00 30 00 00 + memcpy(apdu + 5, g_fmcos_tid_keyfile_data, 11); + } else { + if (rperm_len == 0) rperm_buf[0] = 0xF0; + if (wperm_len == 0) wperm_buf[0] = 0xF0; + if (id_len != 2) { PrintAndLogEx(ERR, "--id must be 2 bytes"); return PM3_EINVARG; } + if (sfi_len != 1) { PrintAndLogEx(ERR, "--sfi must be 1 byte"); return PM3_EINVARG; } + if (size < 1 || size > 0xFFFF) { PrintAndLogEx(ERR, "--size out of range"); return PM3_EINVARG; } + // 80 E0 02 00 0B 00 [fid_hi][fid_lo] [size_hi][size_lo] [rperm][wperm] [sfi] 00 FF 00 + apdu[5] = 0x00; + apdu[6] = id_buf[0]; apdu[7] = id_buf[1]; + apdu[8] = (size >> 8) & 0xFF; apdu[9] = size & 0xFF; + apdu[10] = rperm_buf[0]; apdu[11] = wperm_buf[0]; + apdu[12] = sfi_buf[0]; + apdu[13] = 0x00; apdu[14] = 0xFF; apdu[15] = 0x00; + } + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, sizeof(apdu), true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, is_keyfile ? "CREATE KEYFILE " _GREEN_("OK") : "CREATE binary EF " _GREEN_("OK")); + else + PrintAndLogEx(FAILED, is_keyfile ? "CREATE KEYFILE " _RED_("failed") : "CREATE binary EF " _RED_("failed")); + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static int CmdHFFmcosTidCreateRec(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hf fmcos tid createrec", + "CREATE fixed-length record EF using TID format (P1=02, subtype=01, FID in data, fixed Lc=11).\n" + "Note: TID CREATE EF has a different layout from standard 'hf fmcos create file'.", + "hf fmcos tid createrec --id 0003 --count 04 --reclen 08 --sfi 03\n" + "hf fmcos tid createrec --id 0003 --count 04 --reclen 10 --sfi 03 --rperm 20 --wperm f0"); + void *argtable[] = { + arg_param_begin, + arg_str1(NULL, "id", "<4hex>", "2-byte file ID"), + arg_str1(NULL, "count", "", "number of records (1 byte)"), + arg_str1(NULL, "reclen", "", "bytes per record (1 byte)"), + arg_str1(NULL, "sfi", "", "short file ID (1 byte)"), + arg_str0(NULL, "rperm", "", "read permission byte (default F0)"), + arg_str0(NULL, "wperm", "", "write permission byte (default F0)"), + arg_lit0("k", "keep", "keep field ON after command"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, false); + uint8_t id_buf[2] = {0}; int id_len = 0; + CLIGetHexWithReturn(ctx, 1, id_buf, &id_len); + uint8_t cnt_buf[1] = {0}; int cnt_len = 0; + CLIGetHexWithReturn(ctx, 2, cnt_buf, &cnt_len); + uint8_t rlen_buf[1] = {0}; int rlen_len = 0; + CLIGetHexWithReturn(ctx, 3, rlen_buf, &rlen_len); + uint8_t sfi_buf[1] = {0}; int sfi_len = 0; + CLIGetHexWithReturn(ctx, 4, sfi_buf, &sfi_len); + uint8_t rperm_buf[1] = {0}; int rperm_len = 0; + CLIGetHexWithReturn(ctx, 5, rperm_buf, &rperm_len); + uint8_t wperm_buf[1] = {0}; int wperm_len = 0; + CLIGetHexWithReturn(ctx, 6, wperm_buf, &wperm_len); + bool keep = arg_get_lit(ctx, 7); + CLIParserFree(ctx); + + if (rperm_len == 0) rperm_buf[0] = 0xF0; + if (wperm_len == 0) wperm_buf[0] = 0xF0; + + if (id_len != 2) { PrintAndLogEx(ERR, "--id must be 2 bytes"); return PM3_EINVARG; } + if (cnt_len != 1) { PrintAndLogEx(ERR, "--count must be 1 byte"); return PM3_EINVARG; } + if (rlen_len != 1) { PrintAndLogEx(ERR, "--reclen must be 1 byte"); return PM3_EINVARG; } + if (sfi_len != 1) { PrintAndLogEx(ERR, "--sfi must be 1 byte"); return PM3_EINVARG; } + + // 80 E0 02 00 0B 01 [fid_hi][fid_lo] [count][reclen] [rperm][wperm] [sfi] 00 FF 00 + uint8_t apdu[16] = { + 0x80, 0xE0, 0x02, 0x00, 0x0B, + 0x01, + id_buf[0], id_buf[1], + cnt_buf[0], rlen_buf[0], + rperm_buf[0], wperm_buf[0], + sfi_buf[0], + 0x00, 0xFF, 0x00 + }; + + uint8_t resp[APDU_RES_LEN] = {0}; + int resp_len = 0; + if (fmcos_send_apdu(apdu, sizeof(apdu), true, keep, resp, &resp_len) != PM3_SUCCESS) + return PM3_ESOFT; + if (resp_len < 2) { if (!keep) DropField(); return PM3_ESOFT; } + uint8_t sw1 = resp[resp_len - 2], sw2 = resp[resp_len - 1]; + fmcos_print_sw(sw1, sw2); + if (sw1 == 0x90 && sw2 == 0x00) + PrintAndLogEx(SUCCESS, "CREATE record EF " _GREEN_("OK")); + else + PrintAndLogEx(FAILED, "CREATE record EF " _RED_("failed")); + if (!keep) DropField(); + return (sw1 == 0x90 && sw2 == 0x00) ? PM3_SUCCESS : PM3_ESOFT; +} + +static int CmdHFFmcosTidHelp(const char *Cmd); + +static command_t TidCommandTable[] = { + {"help", CmdHFFmcosTidHelp, AlwaysAvailable, "This help"}, + {"setcard", CmdHFFmcosTidSetCard, IfPm3Iso14443a, "SET CARD configuration block"}, + {"setuid", CmdHFFmcosTidSetUID, IfPm3Iso14443a, "SET UID"}, + {"setauth", CmdHFFmcosTidSetAuth, IfPm3Iso14443a, "SET INTERNAL AUTH key"}, + {"erase", CmdHFFmcosTidErase, IfPm3Iso14443a, "ERASE card file system"}, + {"provision", CmdHFFmcosTidProvision, IfPm3Iso14443a, "Full provisioning sequence"}, + {"--------", CmdHFFmcosTidHelp, AlwaysAvailable, "--------- " _CYAN_("File creation") " ----------"}, + {"createdf", CmdHFFmcosTidCreateDF, IfPm3Iso14443a, "CREATE sub-DF (TID format)"}, + {"createbin", CmdHFFmcosTidCreateBin, IfPm3Iso14443a, "CREATE binary EF (TID format)"}, + {"createrec", CmdHFFmcosTidCreateRec, IfPm3Iso14443a, "CREATE record EF (TID format)"}, + {NULL, NULL, NULL, NULL} +}; + +static int CmdHFFmcosTidHelp(const char *Cmd) { + (void)Cmd; + CmdsHelp(TidCommandTable); + return PM3_SUCCESS; +} + +static int CmdHFFmcosTid(const char *Cmd) { + clearCommandBuffer(); + return CmdsParse(TidCommandTable, Cmd); +} + // --------------------------------------------------------------------------- // Top-level command table // --------------------------------------------------------------------------- @@ -3102,6 +3615,8 @@ static command_t CommandTable[] = { {"history", CmdHFFmcosHistory, IfPm3Iso14443a, "READ transaction history from loop EF"}, {"block", CmdHFFmcosBlock, IfPm3Iso14443a, "BLOCK card or application"}, {"unblock", CmdHFFmcosUnblock, IfPm3Iso14443a, "UNBLOCK application"}, + {"--------", CmdHelp, AlwaysAvailable, "--------- " _CYAN_("TID provisioning") " ----------"}, + {"tid", CmdHFFmcosTid, IfPm3Iso14443a, "{ TID card provisioning }"}, {NULL, NULL, NULL, NULL} }; diff --git a/doc/fmcos.md b/doc/fmcos.md index 98b34eee2..15ce878ef 100644 --- a/doc/fmcos.md +++ b/doc/fmcos.md @@ -47,6 +47,16 @@ All commands in this family are reachable via `hf fmcos `. - [File Protection Modes](#file-protection-modes) - [Access Rights Byte](#access-rights-byte) - [Complete Wallet Session Walkthrough](#complete-wallet-session-walkthrough) +- [TID Tag Provisioning](#tid-tag-provisioning) + - [tid setcard](#tid-setcard) + - [tid setuid](#tid-setuid) + - [tid setauth](#tid-setauth) + - [tid erase](#tid-erase) + - [tid provision](#tid-provision) + - [tid createdf](#tid-createdf) + - [tid createbin](#tid-createbin) + - [tid createrec](#tid-createrec) +- [TID Vendor Card Templates](#tid-vendor-card-templates) --- @@ -880,3 +890,386 @@ Common values: | `ff` | No protection required, key0 for both read/write | | `7f` | Protection required, key0 for both read/write | | `f0` | No protection required (permission byte for directories/keys) | + +--- + +## TID Tag Provisioning + +A TID tag is a magic FMCOS tag that bypasses certain authentication mechanisms and +allows custom UID. These commands below allow a TID tag to be provisioned — UID, +auth key, and file system, these commands are not the same as the standard fmcos commands. + +These cards can often be found on taobao by searching for (CPU卡TID卡) +When hf fmcos auth external is called with any key, the card will always return +[+] SW: 9000 - Success +[+] External authentication successful + +All TID subcommands are reached via `hf fmcos tid `. + +| Subcommand | Description | +|------------|-------------| +| `setcard` | Write fixed card configuration block (`INS 0xEF`) | +| `setuid` | Program the ISO14443-A UID (`INS 0x85`) | +| `setauth` | Write the internal auth key and lock state (`INS 0x21`) | +| `erase` | Erase the card file system (`CLA 0xE0 INS 0xEC`) | +| `provision` | Full provisioning sequence in one command | + +> **Order matters.** When provisioning manually, always run `setcard` → `setuid` → `setauth` +> → `erase` → create file structure. `provision` does this automatically. + +--- + +### tid setcard + +Send the fixed 39-byte SET CARD configuration APDU. The payload is hardcoded — there is +limited information on what the fields do. This must be sent before any other provisioning step. + +``` +hf fmcos tid setcard +``` + +| Flag | Description | +|------|-------------| +| `-k` / `--keep` | Keep field on after command | + +**APDU:** `00 EF 00 00 27 <39-byte config>` + +--- + +### tid setuid + +Program the card's ISO14443-A UID. + +``` +hf fmcos tid setuid --uid 13371337 +hf fmcos tid setuid --uid 0102030405060708 +``` + +| Flag | Description | +|------|-------------| +| `--uid ` | UID bytes (4–7 bytes, i.e. 8–14 hex chars) | +| `-k` / `--keep` | Keep field on after command | + +**APDU:** `00 85 00 00 ` + +--- + +### tid setauth + +Write the 8-byte internal authentication key and set the lock state. + +``` +hf fmcos tid setauth --key 1122334455667788 +hf fmcos tid setauth --key 1122334455667788 --lock +``` + +| Flag | Description | +|------|-------------| +| `--key ` | Internal auth key (8 bytes) | +| `--lock` | Lock the key permanently (`0xAA`); default is unlocked (`0x55`) | +| `-k` / `--keep` | Keep field on after command | + +**APDU:** `00 21 00 00 0A 00` + +> **Warning:** `--lock` not much is known about how this functions, use with care. + +--- + +### tid erase + +Erase the card's file system. Uses `CLA=0xE0` (not `0x80` as in standard FMCOS erase). + +``` +hf fmcos tid erase +``` + +| Flag | Description | +|------|-------------| +| `-k` / `--keep` | Keep field on after command | + +**APDU:** `E0 EC 00 00 00` + +--- + +### tid provision + +Full provisioning sequence in a single command. Chains all steps with the RF field held on +and aborts with an error message if any step fails. + +Steps performed: +1. SET CARD (fixed config block) +2. SET UID +3. SET INTERNAL AUTH +4. ERASE +5. SELECT MF (`3F00`) +6. CREATE MF (`3F00`, name `1PAY.SYS.DDF01`) +7. SELECT MF (`3F00`) +8. CREATE KEYFILE + +``` +hf fmcos tid provision --uid 13371337 --key 1122334455667788 +hf fmcos tid provision --uid 13371337 --key 1122334455667788 --lock +``` + +| Flag | Description | +|------|-------------| +| `--uid ` | UID bytes (4–7 bytes) | +| `--key ` | Internal auth key (8 bytes) | +| `--lock` | Lock the auth key permanently after writing | +| `-k` / `--keep` | Keep field on after completion | + +After `provision`, use `tid createdf` / `tid createbin` / `tid createrec` to build +the file structure, then `hf fmcos write binary` / `hf fmcos write record` to populate data. + +--- + +### tid createdf + +CREATE a sub-DF using the TID APDU format. The standard `hf fmcos create dir` uses a +different data layout (FID in P1/P2, leading `0x38` byte); this command uses the TID layout +where P1=`0x01` and the FID is the first field in the data. + +``` +hf fmcos tid createdf --id 3f01 --size 0f00 --sfi 96 --name 444446303133 +``` + +| Flag | Description | +|------|-------------| +| `--id <4hex>` | 2-byte file ID | +| `--size ` | DF space to allocate in bytes (hex) | +| `--sfi ` | Short file ID (1 byte) | +| `--name ` | DF name bytes (0–16 bytes, optional) | +| `-k` / `--keep` | Keep field on after command | + +**APDU:** `80 E0 01 00 [fid_hi][fid_lo] [size_hi][size_lo] F0 F0 [sfi] 01 FF [name...]` + +--- + +### tid createbin + +CREATE a binary EF or KEYFILE using the TID APDU format. The standard `hf fmcos create file --type bin` +uses a different layout (FID in P1/P2, 7-byte payload); this command uses the TID layout +where P1=`0x02` and the FID is in the data with a fixed 11-byte payload. + +Use `--type keyfile` to create the fixed TID keyfile (subtype `1E`) in the currently selected DF. +Every sub-DF needs a keyfile before EFs can be created inside it. + +``` +hf fmcos tid createbin --id 0001 --size 0100 --sfi 01 +hf fmcos tid createbin --id 0002 --size 0040 --sfi 02 --rperm 20 --wperm f0 +hf fmcos tid createbin --type keyfile +``` + +| Flag | Description | +|------|-------------| +| `--type ` | `bin` (default) or `keyfile` | +| `--id <4hex>` | 2-byte file ID (required for `bin`) | +| `--size ` | File size in bytes, hex (required for `bin`) | +| `--sfi ` | Short file ID, 1 byte (required for `bin`) | +| `--rperm ` | Read permission byte (default `F0`, `bin` only) | +| `--wperm ` | Write permission byte (default `F0`, `bin` only) | +| `-k` / `--keep` | Keep field on after command | + +**APDU (bin):** `80 E0 02 00 0B 00 [fid_hi][fid_lo] [size_hi][size_lo] [rperm][wperm] [sfi] 00 FF 00` + +**APDU (keyfile):** `80 E0 02 00 0B 1E 00 00 00 30 FF FF 00 30 00 00` + +--- + +### tid createrec + +CREATE a fixed-length record EF using the TID APDU format. The standard `hf fmcos create file --type fix` +uses a different layout; this command uses the TID layout where P1=`0x02`, subtype=`0x01`, +and count+reclen replace the size field. + +``` +hf fmcos tid createrec --id 0003 --count 04 --reclen 08 --sfi 03 +hf fmcos tid createrec --id 0003 --count 04 --reclen 10 --sfi 03 --rperm 20 --wperm f0 +``` + +| Flag | Description | +|------|-------------| +| `--id <4hex>` | 2-byte file ID | +| `--count ` | Number of records (1 byte) | +| `--reclen ` | Bytes per record (1 byte) | +| `--sfi ` | Short file ID (1 byte) | +| `--rperm ` | Read permission byte (default `F0`) | +| `--wperm ` | Write permission byte (default `F0`) | +| `-k` / `--keep` | Keep field on after command | + +**APDU:** `80 E0 02 00 0B 01 [fid_hi][fid_lo] [count][reclen] [rperm][wperm] [sfi] 00 FF 00` + +> **Note**: To write data into TID EFs after creation, use the standard `hf fmcos write binary` +> and `hf fmcos write record` — those APDUs (`00 D6` / `00 DC`) are identical in TID and standard FMCOS. + +--- + +## TID Vendor Card Templates + +Six real-world Chinese access-control layouts were translated from the app that is +normally provided when you buy these TID cards. + +### Provisioning notes + +- Replace `--uid` and `--key` in the `provision` call with your actual values. +- `-k` keeps the RF field on between commands, preserving the card's file context. When a + command finishes without `-k` the field drops and the card resets to MF context on the + next activation. +- Each sub-DF requires a TID-format keyfile created immediately after selecting it. Use + `hf fmcos tid createbin --type keyfile` — the standard `hf fmcos create keyfile` uses a + different APDU layout and cannot create TID keyfiles. + +--- + +### 01 — Dingbo (鼎博) + +``` +MF 3F00 "1PAY.SYS.DDF01" SFI 0x02 +└── DF 7572 39 01 30 99 08 07 SFI 0x02 (proprietary 6-byte name) + └── EF-rec 0001 SFI 0x03 6 records × 16 bytes +``` + +``` +hf fmcos tid provision --uid 13371337 --key 0001020304050607 +hf fmcos tid createdf --id 7572 --size 0200 --sfi 02 --name 390130990807 -k +hf fmcos select --id 7572 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createrec --id 0001 --count 06 --reclen 10 --sfi 03 -k +hf fmcos write record --rec 01 --fid 03 --data 018609DD110000000000010100000000 -k +hf fmcos write record --rec 02 --fid 03 --data 00000000000000000000000000000000 -k +hf fmcos write record --rec 03 --fid 03 --data 0000000000070A0D1707120000008800 -k +hf fmcos write record --rec 04 --fid 03 --data 00000000000000000000000000000000 -k +hf fmcos write record --rec 05 --fid 03 --data 00000000000000000000000000000000 -k +hf fmcos write record --rec 06 --fid 03 --data 00000000000000000000000000000000 +``` + +--- + +### 02 — Anjubao (安居宝) + +``` +MF 3F00 "1PAY.SYS.DDF01" SFI 0x02 +└── DF 1001 A0 00 00 00 03 86 98 07 01 SFI 0x02 (9-byte AID) + ├── EF-bin 0018 SFI 0x18 140 bytes (wallet balance file) + └── EF-bin 0019 SFI 0x19 140 bytes (passbook balance file) +``` + +``` +hf fmcos tid provision --uid 13371337 --key 0001020304050607 +hf fmcos tid createdf --id 1001 --size 0200 --sfi 02 --name A00000000386980701 -k +hf fmcos select --id 1001 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createbin --id 0018 --size 008C --sfi 18 -k +hf fmcos select --id 0018 -k +hf fmcos write binary --p1 00 --p2 00 --data 001FD921090700000001000023590000000000E0FFFFFF7F0700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 -k +hf fmcos tid createbin --id 0019 --size 008C --sfi 19 -k +hf fmcos select --id 0019 -k +hf fmcos write binary --p1 00 --p2 00 --data 001FD921090700000001000023590000FFFFFFFFFFFF010000000000E0FFFFFF0F0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +``` + +--- + +### 03 — Jinbo (金博) + +``` +MF 3F00 "1PAY.SYS.DDF01" SFI 0x02 +└── DF 4A54 6A 69 6E 00 00 00 62 6F A5 04 9F 08 01 02 SFI 0x02 (14-byte name, starts "jin") + └── EF-bin 4200 SFI 0x01 624 bytes (32 B payload at offset 592, remainder zeros) +``` + +``` +hf fmcos tid provision --uid 13371337 --key 0001020304050607 +hf fmcos tid createdf --id 4A54 --size 0300 --sfi 02 --name 6A696E00000000626FA5049F080102 -k +hf fmcos select --id 4A54 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createbin --id 4200 --size 0270 --sfi 01 -k +hf fmcos select --id 4200 -k +hf fmcos write binary --p1 02 --p2 50 --data 530030FFFFFFFFFFFFFF3A2B0000000022012200002403081106000000007F00 +``` + +--- + +### 04 — Jingkong (晶控) + +``` +MF 3F00 "1PAY.SYS.DDF01" SFI 0x02 +└── DF 3F01 "DDF01" SFI 0x02 + ├── EF-bin 0001 SFI 0x01 1 byte (placeholder) + ├── EF-bin 0003 SFI 0x03 28 bytes (key / config data) + ├── EF-bin 0004 SFI 0x04 120 bytes (zeroed) + ├── EF-bin 0005 SFI 0x05 36 bytes (key / config data) + ├── EF-bin 0006 SFI 0x06 132 bytes (key / config data) + └── EF-bin 0007 SFI 0x07 102 bytes (zeroed) +``` + +``` +hf fmcos tid provision --uid 13371337 --key 0001020304050607 +hf fmcos tid createdf --id 3F01 --size 0400 --sfi 02 --name 4444463031 -k +hf fmcos select --id 3F01 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createbin --id 0001 --size 0001 --sfi 01 -k +hf fmcos tid createbin --id 0003 --size 001C --sfi 03 -k +hf fmcos select --id 0003 -k +hf fmcos write binary --p1 00 --p2 00 --data FE937B922D7EDEF50000000000000000000000000000000000000000 -k +hf fmcos tid createbin --id 0004 --size 0078 --sfi 04 -k +hf fmcos select --id 0004 -k +hf fmcos write binary --p1 00 --p2 00 --data 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 -k +hf fmcos tid createbin --id 0005 --size 0024 --sfi 05 -k +hf fmcos select --id 0005 -k +hf fmcos write binary --p1 00 --p2 00 --data 6403FE9C7434FCBC6E00FC9F2802F1448F06F3BA8CF6F0B98DF7F1B84D0BF60000000000 -k +hf fmcos tid createbin --id 0006 --size 0084 --sfi 06 -k +hf fmcos select --id 0006 -k +hf fmcos write binary --p1 00 --p2 00 --data 616BEACE7705FCBD7604FDBC7107F2BB7006F3BA7309F0B97208F1B84D0B09B74C0AF7494F0DF4B5B10CF5B449F0EAB3480E14B24B31E84E4A30E9B0BA33EEAF44CDEFAE473513AD4634ED534137E2ABBF36E3AA43C6E0A942381EA85D3BE6585C3AE7A6A03DE4A55E000000000000000000000000000000000000000000000000000000 -k +hf fmcos tid createbin --id 0007 --size 0066 --sfi 07 -k +hf fmcos select --id 0007 -k +hf fmcos write binary --p1 00 --p2 00 --data 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +``` + +--- + +### 05 — Kangtuo (康拓) + +``` +MF 3F00 "1PAY.SYS.DDF01" SFI 0x02 +├── DF D0F1 "XL123" SFI 0x02 +│ └── EF-bin 0005 SFI 0x05 64 bytes +└── DF D0F2 "XL456" SFI 0x02 + └── EF-bin 0005 SFI 0x05 64 bytes +``` + +``` +hf fmcos tid provision --uid 13371337 --key 0001020304050607 +hf fmcos tid createdf --id D0F1 --size 0100 --sfi 02 --name 584C313233 -k +hf fmcos select --id D0F1 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createbin --id 0005 --size 0040 --sfi 05 -k +hf fmcos select --id 0005 -k +hf fmcos write binary --p1 00 --p2 00 --data 0200FC20006200000000000000000000000000272E2C6A0000000000000000080000000000000000000000000000000000000000000000000000000000000000 +hf fmcos tid createdf --id D0F2 --size 0100 --sfi 02 --name 584C343536 -k +hf fmcos select --id D0F2 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createbin --id 0005 --size 0040 --sfi 05 -k +hf fmcos select --id 0005 -k +hf fmcos write binary --p1 00 --p2 00 --data 0200FC20006200000000000000000000000000272E2C6A0000000000000000080000000000000000000000000000000000000000000000000000000000000000 +``` + +--- + +### 06 — Youhe (友禾) + +``` +MF 3F00 "1PAY.SYS.DDF01" SFI 0x02 +└── DF 3F01 "ADF01" SFI 0x02 + └── EF-bin 0003 SFI 0x03 250 bytes (key / credential data) +``` + +``` +hf fmcos tid provision --uid 13371337 --key 0001020304050607 +hf fmcos tid createdf --id 3F01 --size 0200 --sfi 02 --name 4144463031 -k +hf fmcos select --id 3F01 -k +hf fmcos tid createbin --type keyfile -k +hf fmcos tid createbin --id 0003 --size 00FA --sfi 03 -k +hf fmcos select --id 0003 -k +hf fmcos write binary --p1 00 --p2 00 --data D15190D7E1E379732295C97D62A3172BE3BBA1D1B32CE32FED72CB3DCDB115E7DC2670978E241822F298C9951260FC55D54F9988C7FCAC5032F94281DFC39C973E570101764D5BBF367F84EBDA1B012ABD4568F35D5BC08BAFD76B988CA916C985692337FCF02C9FD2C8BDD583BC05EF55582C3921FA2CAFAE26308FBADE0598DB750EE1F0522D29EAB6FA5D0F3971F785692337FCF02C9FD2C8BDD583BC05EF55582C3921FA2CAFAE26308FBADE0598DB750EE1F0522D29EAB6FA5D0F3971F7EA545FC5B27B7F40DF6D0F71FCEE2A1BCED2DEDE67BB57B1C1F98C8CDA5259CC7BD83158086F215F5E1E0246EE0504760000000000 -k +hf fmcos write binary --p1 00 --p2 F5 --data 0000000000 +```