diff --git a/armsrc/appmain.c b/armsrc/appmain.c index 7b5eabc7b..63229979b 100644 --- a/armsrc/appmain.c +++ b/armsrc/appmain.c @@ -2032,6 +2032,18 @@ static void PacketReceived(PacketCommandNG *packet) { SetTag15693Uid_v2(payload->uid); break; } + case CMD_HF_ISO15693_CSETUID_V3: { + struct p { + uint8_t uid[8]; + } PACKED; + struct p *payload = (struct p *) packet->data.asBytes; + SetTag15693Uid_v3(payload->uid); + break; + } + case CMD_HF_ISO15693_CFINALIZE_V3: { + FinalizeTag15693_v3(); + break; + } case CMD_HF_ISO15693_SLIX_DISABLE_EAS: { struct p { uint8_t pwd[4]; diff --git a/armsrc/iso15693.c b/armsrc/iso15693.c index 44572bac9..8eecbffcf 100644 --- a/armsrc/iso15693.c +++ b/armsrc/iso15693.c @@ -3202,51 +3202,277 @@ void LockPassSlixIso15693(uint32_t pass_id, uint32_t password) { // //----------------------------------------------------------------------------- +// Backdoor blocks of a magic "Gen1" tag, see doc/magic_cards_notes.md +#define ISO15_MAGIC_GEN1_BLK_UID_LO 0x38 +#define ISO15_MAGIC_GEN1_BLK_UID_HI 0x39 +#define ISO15_MAGIC_GEN1_BLK_UNLOCK_A 0x3E +#define ISO15_MAGIC_GEN1_BLK_UNLOCK_B 0x3F + +static const uint8_t g_magic_gen1_blank[4] = {0x00, 0x00, 0x00, 0x00}; +static const uint8_t g_magic_gen1_unlock_b[4] = {0x69, 0x96, 0x00, 0x00}; + +// Unaddressed block read, leaves the field on for the next command +static int magic_15_read_blk(uint8_t blockno, uint8_t *out, uint32_t *start_time, uint32_t *eof_time) { + + uint8_t cmd[5] = {ISO15_REQ_DATARATE_HIGH | ISO15_REQ_OPTION, ISO15693_READBLOCK, blockno, 0x00, 0x00}; + AddCrc15(cmd, 3); + + uint16_t recvlen = 0; + int res = SendDataTag(cmd, sizeof(cmd), false, true, s_iso15_recvbuf, sizeof(s_iso15_recvbuf), + *start_time, ISO15693_READER_TIMEOUT, eof_time, &recvlen); + + *start_time = *eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; + + if (res != PM3_SUCCESS) { + return res; + } + + // 8 bytes when the tag honours the option flag and prepends a lock byte, 7 when it doesn't + if (recvlen != 7 && recvlen != 8) { + return PM3_EWRONGANSWER; + } + + if ((s_iso15_recvbuf[0] & ISO15_RES_ERROR) == ISO15_RES_ERROR) { + return PM3_EWRONGANSWER; + } + + memcpy(out, s_iso15_recvbuf + ((recvlen == 8) ? 2 : 1), 4); + return PM3_SUCCESS; +} + +// Unaddressed block write, leaves the field on for the next command +static int magic_15_write_blk(uint8_t blockno, const uint8_t *data, uint32_t *start_time, uint32_t *eof_time) { + + uint8_t cmd[9] = {ISO15_REQ_DATARATE_HIGH, ISO15693_WRITEBLOCK, blockno, data[0], data[1], data[2], data[3], 0x00, 0x00}; + AddCrc15(cmd, 7); + + uint16_t recvlen = 0; + int res = SendDataTag(cmd, sizeof(cmd), false, true, s_iso15_recvbuf, sizeof(s_iso15_recvbuf), + *start_time, ISO15693_READER_TIMEOUT_WRITE, eof_time, &recvlen); + + *start_time = *eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; + + if (res != PM3_SUCCESS) { + return res; + } + + if (recvlen < 3 || (s_iso15_recvbuf[0] & ISO15_RES_ERROR) == ISO15_RES_ERROR) { + return PM3_EWRONGANSWER; + } + return PM3_SUCCESS; +} + +// On a real Gen1 tag these four blocks sit outside the readable memory and the read fails. +// A tag that answers with data is a normal tag and we must not overwrite it. +static bool magic_gen1_is_backdoor(uint32_t *start_time, uint32_t *eof_time) { + + static const uint8_t blocks[4] = { + ISO15_MAGIC_GEN1_BLK_UID_LO, + ISO15_MAGIC_GEN1_BLK_UID_HI, + ISO15_MAGIC_GEN1_BLK_UNLOCK_A, + ISO15_MAGIC_GEN1_BLK_UNLOCK_B + }; + + for (uint8_t i = 0; i < ARRAYLEN(blocks); i++) { + + uint8_t buf[4] = {0}; + if (magic_15_read_blk(blocks[i], buf, start_time, eof_time) != PM3_SUCCESS) { + continue; + } + + if (memcmp(buf, g_magic_gen1_blank, 4) == 0) { + continue; + } + + // leftover of the unlock write of an earlier attempt on this same tag + if (blocks[i] == ISO15_MAGIC_GEN1_BLK_UNLOCK_B && memcmp(buf, g_magic_gen1_unlock_b, 4) == 0) { + continue; + } + + if (g_dbglevel >= DBG_ERROR) { + Dbprintf("SetTag15693Uid: block 0x%02X holds data, not a magic Gen1 tag", blocks[i]); + } + return false; + } + return true; +} + +// Blank the four blocks again so a failed attempt leaves no unlock values behind +static void magic_gen1_rollback(uint32_t *start_time, uint32_t *eof_time) { + magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UID_LO, g_magic_gen1_blank, start_time, eof_time); + magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UID_HI, g_magic_gen1_blank, start_time, eof_time); + magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UNLOCK_A, g_magic_gen1_blank, start_time, eof_time); + magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UNLOCK_B, g_magic_gen1_blank, start_time, eof_time); +} + // Set the UID on Magic ISO15693 tag (based on Iceman's LUA-script). void SetTag15693Uid(const uint8_t *uid) { LED_A_ON(); - uint8_t cmd[4][9] = { - {ISO15_REQ_DATARATE_HIGH, ISO15693_WRITEBLOCK, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xE9, 0x8F}, - {ISO15_REQ_DATARATE_HIGH, ISO15693_WRITEBLOCK, 0x3f, 0x69, 0x96, 0x00, 0x00, 0x8A, 0xBB}, - - // Command 3 : 02 21 38 u8u7u6u5 (where uX = uid byte X) - {ISO15_REQ_DATARATE_HIGH, ISO15693_WRITEBLOCK, 0x38, uid[7], uid[6], uid[5], uid[4]}, - - // Command 4 : 02 21 39 u4u3u2u1 (where uX = uid byte X) - {ISO15_REQ_DATARATE_HIGH, ISO15693_WRITEBLOCK, 0x39, uid[3], uid[2], uid[1], uid[0]} - }; - - - AddCrc15(cmd[2], 7); - AddCrc15(cmd[3], 7); - memset(s_iso15_recvbuf, 0, sizeof(s_iso15_recvbuf)); - uint32_t start_time = 0; - uint32_t eof_time = 0; - uint16_t recvlen = 0; + Iso15693InitReader(); + StartCountSspClk(); + uint32_t start_time = 0, eof_time = 0; - int res = PM3_SUCCESS; + uint8_t origuid[8] = {0}; + if (get_uid_slix(start_time, &eof_time, origuid) != PM3_SUCCESS) { + reply_ng(CMD_HF_ISO15693_CSETUID, PM3_ETIMEOUT, NULL, 0); + switch_off(); + return; + } + start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; - for (int i = 0; i < 4; i++) { - res = SendDataTag( - cmd[i], - sizeof(cmd[i]), - (i == 0) ? true : false, - true, - s_iso15_recvbuf, - sizeof(s_iso15_recvbuf), - start_time, - ISO15693_READER_TIMEOUT_WRITE, - &eof_time, - &recvlen - ); - - start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; + if (magic_gen1_is_backdoor(&start_time, &eof_time) == false) { + reply_ng(CMD_HF_ISO15693_CSETUID, PM3_EWRONGANSWER, NULL, 0); + switch_off(); + return; } - reply_ng(CMD_HF_ISO15693_CSETUID, res, NULL, 0); + const uint8_t uid_lo[4] = {uid[7], uid[6], uid[5], uid[4]}; + const uint8_t uid_hi[4] = {uid[3], uid[2], uid[1], uid[0]}; + + // the unlock writes are best-effort, a tag already unlocked rejects them + magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UNLOCK_A, g_magic_gen1_blank, &start_time, &eof_time); + magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UNLOCK_B, g_magic_gen1_unlock_b, &start_time, &eof_time); + + int res = magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UID_LO, uid_lo, &start_time, &eof_time); + if (res == PM3_SUCCESS) { + res = magic_15_write_blk(ISO15_MAGIC_GEN1_BLK_UID_HI, uid_hi, &start_time, &eof_time); + } + + // get_uid_slix answers LSB first, the requested uid is MSB first + uint8_t newuid[8] = {0}, revuid[8] = {0}; + int res_uid = get_uid_slix(start_time, &eof_time, newuid); + reverse_array_copy(newuid, sizeof(newuid), revuid); + start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; + + if (res == PM3_SUCCESS && res_uid == PM3_SUCCESS && memcmp(revuid, uid, sizeof(revuid)) == 0) { + reply_ng(CMD_HF_ISO15693_CSETUID, PM3_SUCCESS, NULL, 0); + switch_off(); + return; + } + + // only roll back while the tag still shows its original UID, blanking the + // blocks after a UID change would destroy what we just wrote + if (res_uid == PM3_SUCCESS && memcmp(newuid, origuid, sizeof(newuid)) == 0) { + magic_gen1_rollback(&start_time, &eof_time); + } + + reply_ng(CMD_HF_ISO15693_CSETUID, PM3_ESOFT, NULL, 0); + switch_off(); +} + +// Magic "V3" tags answer with a signature in 0x14/0x15 while the UID is still changeable +#define ISO15_MAGIC_V3_BLK_UID_LO 0x10 +#define ISO15_MAGIC_V3_BLK_UID_HI 0x11 +#define ISO15_MAGIC_V3_BLK_SIG_A 0x14 +#define ISO15_MAGIC_V3_BLK_SIG_B 0x15 + +static const uint8_t g_magic_v3_sig_a[4] = {0xA5, 0x2B, 0x44, 0x2C}; +static const uint8_t g_magic_v3_sig_b[4] = {0x21, 0xAE, 0x93, 0x00}; +static const uint8_t g_magic_v3_fin_a[4] = {0xA5, 0x2B, 0x44, 0x2C}; +static const uint8_t g_magic_v3_fin_b[4] = {0x69, 0xE2, 0x5D, 0x00}; + +// Writing the finalize values to anything that is not an un-finalized V3 tag bricks it +static bool magic_v3_in_config_mode(uint32_t *start_time, uint32_t *eof_time) { + + uint8_t a[4] = {0}; + uint8_t b[4] = {0}; + + if (magic_15_read_blk(ISO15_MAGIC_V3_BLK_SIG_A, a, start_time, eof_time) != PM3_SUCCESS) { + return false; + } + + if (magic_15_read_blk(ISO15_MAGIC_V3_BLK_SIG_B, b, start_time, eof_time) != PM3_SUCCESS) { + return false; + } + + return (memcmp(a, g_magic_v3_sig_a, 4) == 0) && (memcmp(b, g_magic_v3_sig_b, 4) == 0); +} + +// Set the UID on a magic "V3" tag, repeatable until the tag is finalized +void SetTag15693Uid_v3(const uint8_t *uid) { + + LED_A_ON(); + memset(s_iso15_recvbuf, 0, sizeof(s_iso15_recvbuf)); + + Iso15693InitReader(); + StartCountSspClk(); + uint32_t start_time = 0, eof_time = 0; + + uint8_t curuid[8] = {0}; + if (get_uid_slix(start_time, &eof_time, curuid) != PM3_SUCCESS) { + reply_ng(CMD_HF_ISO15693_CSETUID_V3, PM3_ETIMEOUT, NULL, 0); + switch_off(); + return; + } + start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; + + if (magic_v3_in_config_mode(&start_time, &eof_time) == false) { + reply_ng(CMD_HF_ISO15693_CSETUID_V3, PM3_EWRONGANSWER, NULL, 0); + switch_off(); + return; + } + + const uint8_t uid_lo[4] = {uid[7], uid[6], uid[5], uid[4]}; + const uint8_t uid_hi[4] = {uid[3], uid[2], uid[1], uid[0]}; + + int res = magic_15_write_blk(ISO15_MAGIC_V3_BLK_UID_LO, uid_lo, &start_time, &eof_time); + if (res == PM3_SUCCESS) { + res = magic_15_write_blk(ISO15_MAGIC_V3_BLK_UID_HI, uid_hi, &start_time, &eof_time); + } + + if (res == PM3_SUCCESS) { + // get_uid_slix answers LSB first, the requested uid is MSB first + uint8_t newuid[8] = {0}, revuid[8] = {0}; + res = get_uid_slix(start_time, &eof_time, newuid); + reverse_array_copy(newuid, sizeof(newuid), revuid); + + if (res == PM3_SUCCESS && memcmp(revuid, uid, sizeof(revuid)) != 0) { + res = PM3_ESOFT; + } + } + + reply_ng(CMD_HF_ISO15693_CSETUID_V3, (res == PM3_SUCCESS) ? PM3_SUCCESS : PM3_ESOFT, NULL, 0); + switch_off(); +} + +// Lock the UID of a magic "V3" tag, irreversible +void FinalizeTag15693_v3(void) { + + LED_A_ON(); + memset(s_iso15_recvbuf, 0, sizeof(s_iso15_recvbuf)); + + Iso15693InitReader(); + StartCountSspClk(); + uint32_t start_time = 0, eof_time = 0; + + uint8_t curuid[8] = {0}; + if (get_uid_slix(start_time, &eof_time, curuid) != PM3_SUCCESS) { + reply_ng(CMD_HF_ISO15693_CFINALIZE_V3, PM3_ETIMEOUT, NULL, 0); + switch_off(); + return; + } + start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER; + + if (magic_v3_in_config_mode(&start_time, &eof_time) == false) { + reply_ng(CMD_HF_ISO15693_CFINALIZE_V3, PM3_EWRONGANSWER, NULL, 0); + switch_off(); + return; + } + + int res = magic_15_write_blk(ISO15_MAGIC_V3_BLK_SIG_A, g_magic_v3_fin_a, &start_time, &eof_time); + if (res == PM3_SUCCESS) { + res = magic_15_write_blk(ISO15_MAGIC_V3_BLK_SIG_B, g_magic_v3_fin_b, &start_time, &eof_time); + } + + // the signature must be gone now, otherwise the tag is still changeable + if (res == PM3_SUCCESS && magic_v3_in_config_mode(&start_time, &eof_time)) { + res = PM3_ESOFT; + } + + reply_ng(CMD_HF_ISO15693_CFINALIZE_V3, (res == PM3_SUCCESS) ? PM3_SUCCESS : PM3_ESOFT, NULL, 0); switch_off(); } diff --git a/armsrc/iso15693.h b/armsrc/iso15693.h index a3197bbd8..5a419e293 100644 --- a/armsrc/iso15693.h +++ b/armsrc/iso15693.h @@ -59,6 +59,8 @@ int SendDataTagEOF(uint8_t *recv, uint16_t max_recv_len, uint32_t start_time, ui void SetTag15693Uid(const uint8_t *uid); void SetTag15693Uid_v2(const uint8_t *uid); +void SetTag15693Uid_v3(const uint8_t *uid); +void FinalizeTag15693_v3(void); void WritePasswordSlixIso15693(const uint8_t *old_password, const uint8_t *new_password, uint8_t pwd_id); void DisablePrivacySlixIso15693(const uint8_t *password); diff --git a/client/src/cmdhf15.c b/client/src/cmdhf15.c index 22f712b48..9e9397bfb 100644 --- a/client/src/cmdhf15.c +++ b/client/src/cmdhf15.c @@ -3324,180 +3324,6 @@ static int CmdHF15Restore(const char *Cmd) { return PM3_SUCCESS; } -// ISO15693 magic "V3" tag support -#define ISO15_MAGIC_V3_BLK_UID_LO 0x10 -#define ISO15_MAGIC_V3_BLK_UID_HI 0x11 -#define ISO15_MAGIC_V3_BLK_SIG_A 0x14 -#define ISO15_MAGIC_V3_BLK_SIG_B 0x15 - -// signature check in block 0x14/0x15 -static const uint8_t iso15_magic_v3_sig_a[4] = {0xA5, 0x2B, 0x44, 0x2C}; -static const uint8_t iso15_magic_v3_sig_b[4] = {0x21, 0xAE, 0x93, 0x00}; - -// finalize command write in block 0x14/0x15 -// hf 15 raw -wac -d 022114A52B442C -// hf 15 raw -wac -d 02211569E25D00 -static const uint8_t iso15_magic_v3_fin_a[4] = {0xA5, 0x2B, 0x44, 0x2C}; -static const uint8_t iso15_magic_v3_fin_b[4] = {0x69, 0xE2, 0x5D, 0x00}; - -// Unaddressed 4-byte block read, silent because failed probes are expected -static int hf15_magic_read_blk(uint8_t blockno, uint8_t out[4]) { - - uint16_t approxlen = 2 + 1 + 2; - iso15_raw_cmd_t *packet = (iso15_raw_cmd_t *)calloc(1, sizeof(iso15_raw_cmd_t) + approxlen); - if (packet == NULL) { - return PM3_EMALLOC; - } - - // enforce OPTION flag so we get the lock byte, keeping data at offset 2 - packet->raw[packet->rawlen++] = arg_get_raw_flag(0, true, false, true); - packet->raw[packet->rawlen++] = ISO15693_READBLOCK; - packet->raw[packet->rawlen++] = blockno; - AddCrc15(packet->raw, packet->rawlen); - packet->rawlen += 2; - packet->flags = (ISO15_CONNECT | ISO15_READ_RESPONSE); - - clearCommandBuffer(); - SendCommandNG(CMD_HF_ISO15693_COMMAND, (uint8_t *)packet, ISO15_RAW_LEN(packet->rawlen)); - free(packet); - - PacketResponseNG resp; - if (WaitForResponseTimeout(CMD_HF_ISO15693_COMMAND, &resp, 2000) == false) { - return PM3_ETIMEOUT; - } - - if (resp.status == PM3_ETEAROFF) { - return resp.status; - } - if (resp.length < 2) { - return PM3_EWRONGANSWER; - } - - uint8_t *d = resp.data.asBytes; - - if (check_crc(CRC_15693, d, resp.length) == false) { - return PM3_ECRC; - } - if ((d[0] & ISO15_RES_ERROR) == ISO15_RES_ERROR) { - if (d[1] == 0x0F || d[1] == 0x10) { - return PM3_EOUTOFBOUND; - } - return PM3_EFAILED; - } - - memcpy(out, d + 2, 4); - return PM3_SUCCESS; -} - -// Write one 4-byte block to a magic tag in unaddressed mode. -static int hf15_magic_write_blk(uint8_t blockno, const uint8_t *data, const uint8_t *pm3flags) { - uint16_t flags = arg_get_raw_flag(0, true, false, false); - return hf_15_write_blk(pm3flags, flags, NULL, true, blockno, data, 4); -} - -// Detect an un-finalized magic V3 tag by its configuration-mode signature. -static bool hf15_magic_v3_is_config_mode(void) { - uint8_t a[4] = {0}; - uint8_t b[4] = {0}; - if (hf15_magic_read_blk(ISO15_MAGIC_V3_BLK_SIG_A, a) != PM3_SUCCESS) { - return false; - } - if (hf15_magic_read_blk(ISO15_MAGIC_V3_BLK_SIG_B, b) != PM3_SUCCESS) { - return false; - } - return (memcmp(a, iso15_magic_v3_sig_a, 4) == 0) && (memcmp(b, iso15_magic_v3_sig_b, 4) == 0); -} - -// ISO15693 magic "Gen1" (backdoor) tag support -#define ISO15_MAGIC_GEN1_BLK_UID_LO 0x38 -#define ISO15_MAGIC_GEN1_BLK_UID_HI 0x39 -#define ISO15_MAGIC_GEN1_BLK_UNLOCK_A 0x3E -#define ISO15_MAGIC_GEN1_BLK_UNLOCK_B 0x3F - -// Gen1 unlock values for blocks 0x3E/0x3F -static const uint8_t iso15_magic_gen1_unlock_a[4] = {0x00, 0x00, 0x00, 0x00}; -static const uint8_t iso15_magic_gen1_unlock_b[4] = {0x69, 0x96, 0x00, 0x00}; - -// Gen1 backdoor blocks -static const uint8_t iso15_magic_gen1_blocks[] = { - ISO15_MAGIC_GEN1_BLK_UID_LO, - ISO15_MAGIC_GEN1_BLK_UID_HI, - ISO15_MAGIC_GEN1_BLK_UNLOCK_A, - ISO15_MAGIC_GEN1_BLK_UNLOCK_B, -}; - -// Refuse if a Gen1 backdoor block reads real data or fails in an unexpected way -static bool hf15_magic_gen1_is_safe_to_write(void) { - uint8_t buf[4] = {0}; - static const uint8_t zero[4] = {0x00, 0x00, 0x00, 0x00}; - for (size_t i = 0; i < ARRAYLEN(iso15_magic_gen1_blocks); i++) { - uint8_t blockno = iso15_magic_gen1_blocks[i]; - int res = hf15_magic_read_blk(blockno, buf); - - // no answer or block not available is what a Gen1 backdoor block does - if (res == PM3_EWRONGANSWER || res == PM3_EOUTOFBOUND) { - continue; - } - if (res != PM3_SUCCESS) { - PrintAndLogEx(WARNING, "block 0x%02X read failed unexpectedly ( " _RED_("%d") " )", blockno, res); - return false; - } - - // blank, or 69960000 in 0x3F which an earlier unlock write left behind - if (memcmp(buf, zero, 4) == 0 || - (blockno == ISO15_MAGIC_GEN1_BLK_UNLOCK_B && memcmp(buf, iso15_magic_gen1_unlock_b, 4) == 0)) { - continue; - } - PrintAndLogEx(WARNING, "block 0x%02X reads back real data ( " _RED_("%s") " )", blockno, sprint_hex(buf, 4)); - return false; - } - return true; -} - -// Silent write, real Gen1 tags reject 0x3E/0x3F once they were written before -static void hf15_magic_write_blk_quiet(uint8_t blockno, const uint8_t *data, const uint8_t *pm3flags) { - uint8_t old_printAndLog = g_printAndLog; - g_printAndLog &= ~PRINTANDLOG_PRINT; - hf15_magic_write_blk(blockno, data, pm3flags); - g_printAndLog = old_printAndLog; -} - -// One RF session for all four writes, the unlock writes are best-effort -static int hf15_magic_gen1_write_uid(const uint8_t *uid) { - uint8_t blk_lo[4] = {0}; - uint8_t blk_hi[4] = {0}; - reverse_array_copy(uid + 4, 4, blk_lo); - reverse_array_copy(uid, 4, blk_hi); - - uint8_t pm3flags = (ISO15_CONNECT | ISO15_READ_RESPONSE | ISO15_LONG_WAIT | ISO15_HIGH_SPEED | ISO15_NO_DISCONNECT); - hf15_magic_write_blk_quiet(ISO15_MAGIC_GEN1_BLK_UNLOCK_A, iso15_magic_gen1_unlock_a, &pm3flags); - pm3flags &= ~ISO15_CONNECT; - hf15_magic_write_blk_quiet(ISO15_MAGIC_GEN1_BLK_UNLOCK_B, iso15_magic_gen1_unlock_b, &pm3flags); - - int res = hf15_magic_write_blk(ISO15_MAGIC_GEN1_BLK_UID_LO, blk_lo, &pm3flags); - if (res == PM3_SUCCESS) { - res = hf15_magic_write_blk(ISO15_MAGIC_GEN1_BLK_UID_HI, blk_hi, &pm3flags); - } - DropField(); - return (res == PM3_SUCCESS) ? PM3_SUCCESS : PM3_ESOFT; -} - -// Blank the four blocks again, only if the tag still shows its original UID -static void hf15_magic_gen1_rollback_uid(const uint8_t *origuid) { - uint8_t curuid[ISO15693_UID_LENGTH] = {0}; - if (getUID(false, false, curuid) != PM3_SUCCESS || memcmp(curuid, origuid, ISO15693_UID_LENGTH) != 0) { - PrintAndLogEx(WARNING, "UID changed or tag not found, skipping rollback"); - return; - } - - PrintAndLogEx(INFO, "Rolling back block 0x38/0x39/0x3E/0x3F to blank..."); - uint8_t zero[4] = {0x00, 0x00, 0x00, 0x00}; - hf15_magic_write_blk(ISO15_MAGIC_GEN1_BLK_UID_LO, zero, NULL); - hf15_magic_write_blk(ISO15_MAGIC_GEN1_BLK_UID_HI, zero, NULL); - hf15_magic_write_blk_quiet(ISO15_MAGIC_GEN1_BLK_UNLOCK_A, zero, NULL); - hf15_magic_write_blk_quiet(ISO15_MAGIC_GEN1_BLK_UNLOCK_B, zero, NULL); -} - /** * Commandline handling: HF15 CMD CSETUID * Set UID for magic Chinese card @@ -3507,7 +3333,7 @@ static int CmdHF15CSetUID(const char *Cmd) { CLIParserContext *ctx; CLIParserInit(&ctx, "hf 15 csetuid", "Set UID for magic Chinese card (only works with such cards)\n" - "Gen1 and V3 first probe their backdoor blocks and refuse to write if they\n" + "Gen1 and V3 probe their backdoor blocks first and refuse to write if they\n" "read back real data, to avoid corrupting a normal (non-magic) tag.\n" "For magic 'V3' tags this writes the UID configuration only and is repeatable;\n" "run `" _YELLOW_("hf 15 cfinalize") "` afterwards to lock the UID permanently.", @@ -3560,66 +3386,36 @@ static int CmdHF15CSetUID(const char *Cmd) { return PM3_ESOFT; } - uint8_t origuid[ISO15693_UID_LENGTH] = {0}; - memcpy(origuid, carduid, sizeof(origuid)); - PrintAndLogEx(INFO, "Writing..."); - bool used_gen1 = false; + PacketResponseNG resp; + clearCommandBuffer(); - if (use_v3) { - // Only proceed on an un-finalized magic V3 tag - if (hf15_magic_v3_is_config_mode() == false) { + uint16_t cmd = CMD_HF_ISO15693_CSETUID; + if (use_v2) { + cmd = CMD_HF_ISO15693_CSETUID_V2; + } else if (use_v3) { + cmd = CMD_HF_ISO15693_CSETUID_V3; + } + + SendCommandNG(cmd, (uint8_t *)&payload, sizeof(payload)); + if (WaitForResponseTimeout(cmd, &resp, 2000) == false) { + PrintAndLogEx(WARNING, "timeout while waiting for reply"); + DropField(); + return PM3_ESOFT; + } + + // the device identifies the tag before it writes, V2 has no such check + if (resp.status == PM3_EWRONGANSWER) { + if (use_v3) { PrintAndLogEx(FAILED, "tag is not an un-finalized magic " _YELLOW_("V3") " tag"); PrintAndLogEx(HINT, "Hint: signature in blocks 0x14/0x15 not found - already finalized or not a V3 tag"); - return PM3_ESOFT; - } - - /* - for example id: E011223344556677 - [=] 16 | 77 66 55 44 | 0 | wfUD - [=] 17 | 33 22 11 E0 | 0 | 3".. - */ - uint8_t blk_lo[4] = {0}; - uint8_t blk_hi[4] = {0}; - reverse_array_copy(payload.uid + 4, 4, blk_lo); - reverse_array_copy(payload.uid, 4, blk_hi); - - if (hf15_magic_write_blk(ISO15_MAGIC_V3_BLK_UID_LO, blk_lo, NULL) != PM3_SUCCESS || - hf15_magic_write_blk(ISO15_MAGIC_V3_BLK_UID_HI, blk_hi, NULL) != PM3_SUCCESS) { - PrintAndLogEx(FAILED, "Setting new UID ( " _RED_("fail") " )"); - PrintAndLogEx(NORMAL, ""); - return PM3_ESOFT; - } - - } else if (use_v2) { - PacketResponseNG resp; - clearCommandBuffer(); - - SendCommandNG(CMD_HF_ISO15693_CSETUID_V2, (uint8_t *)&payload, sizeof(payload)); - if (WaitForResponseTimeout(CMD_HF_ISO15693_CSETUID_V2, &resp, 2000) == false) { - PrintAndLogEx(WARNING, "timeout while waiting for reply"); - DropField(); - return PM3_ESOFT; - } - - } else { - // Bail out before writing if the Gen1 backdoor blocks hold real data - if (hf15_magic_gen1_is_safe_to_write() == false) { + } else { PrintAndLogEx(FAILED, "tag doesn't look like a blank/magic " _YELLOW_("Gen1") " tag ( " _RED_("fail") " )"); PrintAndLogEx(HINT, "Hint: block 0x38/0x39/0x3E/0x3F must be unreadable or blank"); PrintAndLogEx(HINT, "refusing to risk overwriting a normal tag"); - return PM3_ESOFT; - } - - used_gen1 = true; - - if (hf15_magic_gen1_write_uid(payload.uid) != PM3_SUCCESS) { - hf15_magic_gen1_rollback_uid(origuid); - PrintAndLogEx(FAILED, "Setting new UID ( " _RED_("fail") " )"); - PrintAndLogEx(NORMAL, ""); - return PM3_ESOFT; } + return PM3_ESOFT; } PrintAndLogEx(INFO, "Verifying..."); @@ -3639,10 +3435,6 @@ static int CmdHF15CSetUID(const char *Cmd) { return PM3_SUCCESS;; } - if (used_gen1) { - hf15_magic_gen1_rollback_uid(origuid); - } - PrintAndLogEx(FAILED, "Setting new UID ( " _RED_("fail") " )"); PrintAndLogEx(NORMAL, ""); return PM3_ESOFT; @@ -3672,24 +3464,6 @@ static int CmdHF15CFinalize(const char *Cmd) { bool confirmed = arg_get_lit(ctx, 1); CLIParserFree(ctx); - PrintAndLogEx(INFO, "Get current tag"); - - uint8_t carduid[ISO15693_UID_LENGTH] = {0x00}; - if (getUID(true, false, carduid) != PM3_SUCCESS) { - PrintAndLogEx(FAILED, "no tag found"); - return PM3_ESOFT; - } - - // Safety: only proceed on a tag that is actually an un-finalized magic V3. - // Writing the finalize values to any other tag may permanently brick it. - if (hf15_magic_v3_is_config_mode() == false) { - PrintAndLogEx(FAILED, "tag is not an un-finalized magic " _YELLOW_("V3") " tag"); - PrintAndLogEx(HINT, "Hint: signature in blocks 0x14/0x15 not found - already finalized or not a V3 tag"); - return PM3_ESOFT; - } - - PrintAndLogEx(SUCCESS, "Magic " _GREEN_("V3") " tag in configuration mode ( " _GREEN_("ok") " )"); - if (confirmed == false) { PrintAndLogEx(WARNING, _RED_("This operation is irreversible!") " The UID will be locked permanently."); PrintAndLogEx(WARNING, "Add " _YELLOW_("-y") " to confirm and proceed."); @@ -3698,8 +3472,28 @@ static int CmdHF15CFinalize(const char *Cmd) { PrintAndLogEx(INFO, "Finalizing..."); - if (hf15_magic_write_blk(ISO15_MAGIC_V3_BLK_SIG_A, iso15_magic_v3_fin_a, NULL) != PM3_SUCCESS || - hf15_magic_write_blk(ISO15_MAGIC_V3_BLK_SIG_B, iso15_magic_v3_fin_b, NULL) != PM3_SUCCESS) { + PacketResponseNG resp; + clearCommandBuffer(); + SendCommandNG(CMD_HF_ISO15693_CFINALIZE_V3, NULL, 0); + if (WaitForResponseTimeout(CMD_HF_ISO15693_CFINALIZE_V3, &resp, 2000) == false) { + PrintAndLogEx(WARNING, "timeout while waiting for reply"); + DropField(); + return PM3_ESOFT; + } + + if (resp.status == PM3_ETIMEOUT) { + PrintAndLogEx(FAILED, "no tag found"); + return PM3_ESOFT; + } + + if (resp.status == PM3_EWRONGANSWER) { + PrintAndLogEx(FAILED, "tag is not an un-finalized magic " _YELLOW_("V3") " tag"); + PrintAndLogEx(HINT, "Hint: signature in blocks 0x14/0x15 not found"); + PrintAndLogEx(HINT, "already finalized or not a V3 tag"); + return PM3_ESOFT; + } + + if (resp.status != PM3_SUCCESS) { PrintAndLogEx(FAILED, "Finalize ( " _RED_("fail") " )"); PrintAndLogEx(NORMAL, ""); return PM3_ESOFT; diff --git a/include/pm3_cmd.h b/include/pm3_cmd.h index a27b69940..86cbdc341 100644 --- a/include/pm3_cmd.h +++ b/include/pm3_cmd.h @@ -1026,6 +1026,8 @@ typedef struct { #define CMD_HF_ISO15693_CSETUID 0x0316 #define CMD_HF_ISO15693_CSETUID_V2 0x0333 +#define CMD_HF_ISO15693_CSETUID_V3 0x0334 +#define CMD_HF_ISO15693_CFINALIZE_V3 0x0335 #define CMD_LF_SNIFF_RAW_ADC 0x0360