diff --git a/CHANGELOG.md b/CHANGELOG.md index 4700683d0..44f0c9c16 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,9 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac - Added `hw bwm wifipower` - turn the BWM WiFi fully off, or set its modem power-save type (none/min/max), persisted on the module (@Msprg) - Added `hw bwm powersave` - show/set the BWM (ESP32) power-save switch: DFS, light sleep and slow advertising after 30 s, or the stock always-on behaviour, persisted on the module (@Msprg) - Added `hw powersave` - PM5 low-power idle, on by default: between commands the core drops to 48 MHz with the PLL off, the FPGA clock stopped and the CPU halted (WFI); USB now runs crystal-less off HICK. Ported from the Fantasi firmware (@Msprg) +- Fixed `lf t55xx dump -p` - reuses the password already confirmed by `lf t55xx detect` (@iceman1001) +- Fixed `lf t55xx p1detect`, `lf search` - T5577 clones with a non-Atmel manufacturer byte now recognised (@iceman1001) +- Added `PLATFORM_EXTRAS=CEP` on PM5 - wires up the Flipper Zero link on the Type-C extended port (handshake + NG frames over SPI, independent transport flag so it can run alongside BWM); RF-dependent functionality still needs the FPGA side, tracked in #3667 (@TomHarkness) - Fixed `hf mf autopwn` on FM11RF08S - static encrypted nonce is now detected via the backdoor key (@iceman1001) - Added `hf mfu view -v` - prints the UL-C 3DES key or UL-AES key stored in the dump file (@iceman1001) - Added `hf mf sen --ns` - skip writing the key and dump files (@iceman1001) diff --git a/armsrc/Makefile b/armsrc/Makefile index 4f68a5569..7778cd88d 100644 --- a/armsrc/Makefile +++ b/armsrc/Makefile @@ -124,6 +124,12 @@ else SRC_BWM = endif +ifneq (,$(findstring WITH_CEP,$(APP_CFLAGS))) + SRC_CEP = pm5_cep.c +else + SRC_CEP = +endif + # BWM charger (AW32001) + fuel gauge (BQ27427), incl. the optional low-batt beep ifneq (,$(findstring WITH_BWM_STATUS,$(APP_CFLAGS))$(findstring WITH_BWM_CHARGERKICK,$(APP_CFLAGS))) SRC_BWM_CHARGER = bwm_charger.c @@ -209,6 +215,7 @@ THUMBSRC = start.c \ $(SRC_SMARTCARD) \ $(SRC_FPC) \ $(SRC_BWM) \ + $(SRC_CEP) \ $(SRC_BWM_CHARGER) \ $(SRC_BUZZER) \ $(SRC_PM5_POWER) \ diff --git a/armsrc/appmain.c b/armsrc/appmain.c index 5cc53c3cb..1678a10cb 100644 --- a/armsrc/appmain.c +++ b/armsrc/appmain.c @@ -27,6 +27,9 @@ #include "bwm_forward.h" // bwm_fwd_negotiate_baud() #include "bwm_wifi.h" #endif +#ifdef WITH_CEP +#include "pm5_cep.h" +#endif #include "pm3_cmd.h" #include "proxmark3_arm.h" #include "dbprint.h" @@ -770,6 +773,9 @@ static void SendStatus(uint32_t wait) { #endif #ifdef WITH_PM5_AUTOOFF pm5_autooff_print_status(); +#endif +#ifdef WITH_CEP + Dbprintf(" CEP (Flipper) link.. " _YELLOW_("%s"), cep_is_active() ? "attached" : "not attached"); #endif printConnSpeed(wait); DbpString(_CYAN_("Various")); @@ -970,6 +976,11 @@ static void SendCapabilities(void) { #else capabilities.compiled_with_bwm = false; #endif +#ifdef WITH_CEP + capabilities.compiled_with_cep = true; +#else + capabilities.compiled_with_cep = false; +#endif #ifdef WITH_EM4x50 capabilities.compiled_with_em4x50 = true; #else @@ -2202,6 +2213,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]; @@ -4697,6 +4720,10 @@ void __attribute__((noreturn)) AppMain(void) { pm5_power_init(); #endif +#ifdef WITH_CEP + cep_init(); // USART1/SPI1 + CC-controller I2C bring-up; AFTER usb_enable() +#endif + for (;;) { WDT_HIT(); @@ -4709,6 +4736,9 @@ void __attribute__((noreturn)) AppMain(void) { #ifdef WITH_BWM_LOWBATT_BEEP bwm_lowbatt_check(); #endif +#ifdef WITH_CEP + cep_attach_poll(); +#endif if (*_stack_start != 0xdeadbeef) { Dbprintf("DEBUG: increase stack size, currently " _YELLOW_("%d") " bytes", (uint32_t)_stack_end - (uint32_t)_stack_start); diff --git a/armsrc/cmd.c b/armsrc/cmd.c index ab8d81b5b..6f59a5942 100644 --- a/armsrc/cmd.c +++ b/armsrc/cmd.c @@ -20,6 +20,9 @@ #ifdef WITH_BWM_FORWARD #include "bwm_forward.h" #endif +#ifdef WITH_CEP +#include "pm5_cep.h" +#endif #include "crc16.h" #include "string.h" #include "BigBuf.h" @@ -29,6 +32,8 @@ bool g_reply_with_crc_on_usb = false; bool g_reply_with_crc_on_fpc = true; // "Session" flag, to tell via which interface next msgs should be sent: USB or FPC USART bool g_reply_via_fpc = false; +// Independent of via_fpc - CEP (Flipper Zero, over SPI1) may be live at the same time as BWM/FPC. +bool g_reply_via_cep = false; // Largest NG payload the device will put on the CURRENT reply link. Over FPC the // BWM buffers are smaller than a full frame, so cap there; USB uses the full size. @@ -63,6 +68,9 @@ int reply_old(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, const v #if defined(WITH_FPC_USART_HOST) || defined(WITH_BWM_FORWARD) int resultfpc = PM3_EUNDEF; +#endif +#if defined(WITH_CEP) + int resultcep = PM3_EUNDEF; #endif int resultusb = PM3_EUNDEF; // Send frame and make sure all bytes are transmitted @@ -80,17 +88,24 @@ int reply_old(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, const v return PM3_EDEVNOTSUPP; #endif } - // we got two results, let's prioritize the faulty one and USB over FPC. + if (g_reply_via_cep) { +#if defined(WITH_CEP) + resultcep = cep_spi_write_sync((uint8_t *)&txcmd, sizeof(PacketResponseOLD)); +#else + return PM3_EDEVNOTSUPP; +#endif + } + // we got multiple results, let's prioritize the faulty one and USB over FPC over CEP. if (g_reply_via_usb && (resultusb != PM3_SUCCESS)) return resultusb; #if defined(WITH_FPC_USART_HOST) || defined(WITH_BWM_FORWARD) if (g_reply_via_fpc && (resultfpc != PM3_SUCCESS)) return resultfpc; +#endif +#if defined(WITH_CEP) + if (g_reply_via_cep && (resultcep != PM3_SUCCESS)) return resultcep; #endif return PM3_SUCCESS; } -// TODO DXL 测试阶段,暂时通过SPI应答 -extern int cep_spi_write_sync(uint8_t *data, size_t len); - static int reply_ng_internal(uint16_t cmd, int8_t status, uint8_t reason, const uint8_t *data, size_t len, bool ng) { // The NG preamble is 10 bytes, so data[] would sit 2 past a word boundary // and memcpy could never take its word path. Offsetting the whole frame by @@ -136,6 +151,9 @@ static int reply_ng_internal(uint16_t cmd, int8_t status, uint8_t reason, const #if defined(WITH_FPC_USART_HOST) || defined(WITH_BWM_FORWARD) int resultfpc = PM3_EUNDEF; +#endif +#if defined(WITH_CEP) + int resultcep = PM3_EUNDEF; #endif int resultusb = PM3_EUNDEF; // Send frame and make sure all bytes are transmitted @@ -144,10 +162,6 @@ static int reply_ng_internal(uint16_t cmd, int8_t status, uint8_t reason, const resultusb = usb_write((uint8_t *)tx, txBufferNGLen); } if (g_reply_via_fpc) { - - // TODO DXL 测试阶段,暂时通过SPI应答 - // resultusb = cep_spi_write_sync((uint8_t *)tx, txBufferNGLen); - #if defined(WITH_BWM_FORWARD) resultfpc = bwm_fwd_writebuffer_sync((uint8_t *)tx, txBufferNGLen); #elif defined(WITH_FPC_USART_HOST) @@ -156,7 +170,14 @@ static int reply_ng_internal(uint16_t cmd, int8_t status, uint8_t reason, const return PM3_EDEVNOTSUPP; #endif } - // we got two results, let's prioritize the faulty one and USB over FPC. + if (g_reply_via_cep) { +#if defined(WITH_CEP) + resultcep = cep_spi_write_sync((uint8_t *)tx, txBufferNGLen); +#else + return PM3_EDEVNOTSUPP; +#endif + } + // we got multiple results, let's prioritize the faulty one and USB over FPC over CEP. if (g_reply_via_usb && (resultusb != PM3_SUCCESS)) { return resultusb; } @@ -165,6 +186,11 @@ static int reply_ng_internal(uint16_t cmd, int8_t status, uint8_t reason, const if (g_reply_via_fpc && (resultfpc != PM3_SUCCESS)) { return resultfpc; } +#endif +#if defined(WITH_CEP) + if (g_reply_via_cep && (resultcep != PM3_SUCCESS)) { + return resultcep; + } #endif return PM3_SUCCESS; } @@ -178,7 +204,7 @@ int reply_reason(uint16_t cmd, int8_t status, int8_t reason, const uint8_t *data return reply_ng_internal(cmd, status, reason, data, len, true); } -static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *data, size_t len), bool usb, bool fpc) { +static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *data, size_t len), bool usb, bool fpc, bool cep) { PacketCommandNGRaw rx_raw; size_t bytes = read_ng((uint8_t *)&rx_raw.pre, sizeof(PacketCommandNGPreamble)); @@ -250,6 +276,7 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da g_reply_via_usb = usb; g_reply_via_fpc = fpc; + g_reply_via_cep = cep; } else { // Old style command PacketCommandOLD rx_old; @@ -261,6 +288,7 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da g_reply_via_usb = usb; g_reply_via_fpc = fpc; + g_reply_via_cep = cep; rx->ng = false; rx->magic = 0; rx->crc = 0; @@ -274,29 +302,28 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da return PM3_SUCCESS; } -// TODO DXL 临时在此处定义外部实现的CEP端口的SPI通信实现,做视频通信测试用的,后期需要重构设计 -// extern uint32_t cep_spi_read_ng(uint8_t *data, size_t len); -// extern bool cep_spi_data_available(void); - int receive_ng(PacketCommandNG *rx) { // Check if there is a packet available if (usb_poll_validate_length()) { - return receive_ng_internal(rx, usb_read_ng, true, false); + return receive_ng_internal(rx, usb_read_ng, true, false, false); } - // if (cep_spi_data_available()) { - // return receive_ng_internal(rx, cep_spi_read_ng, false, true); // TODO DXL 临时用fpc这种标志 - // } +#if defined(WITH_CEP) + // cep_is_active() gates this so an unattached/idle CEP link doesn't cost + // an SPI-timeout poll every single main-loop iteration. + if (cep_is_active() && cep_spi_data_available()) + return receive_ng_internal(rx, cep_spi_read_ng, false, false, true); +#endif #if defined(WITH_BWM_FORWARD) // De-frame inbound BWM app_com DATA_FORWARD packets into a raw NG stream. if (bwm_fwd_rxdata_available() > 0) - return receive_ng_internal(rx, bwm_read_ng, false, true); + return receive_ng_internal(rx, bwm_read_ng, false, true, false); #elif defined(WITH_FPC_USART_HOST) // Check if there is a FPC packet available if (usart_rxdata_available() > 0) - return receive_ng_internal(rx, usart_read_ng, false, true); + return receive_ng_internal(rx, usart_read_ng, false, true, false); #endif return PM3_ENODATA; } diff --git a/armsrc/iso15693.c b/armsrc/iso15693.c index 44572bac9..618f2e04f 100644 --- a/armsrc/iso15693.c +++ b/armsrc/iso15693.c @@ -3202,51 +3202,322 @@ 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}; + +// true when every byte is zero +static bool magic_15_is_blank(const uint8_t *data, uint8_t len) { + for (uint8_t i = 0; i < len; i++) { + if (data[i] != 0x00) { + return false; + } + } + return true; +} + +// PM3_SUCCESS means the tag answered with block data, *data then points into +// the receive buffer and stays valid until the next command overwrites it. +static int magic_15_read_blk(uint8_t blockno, uint8_t **data, uint8_t *len, 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; + } + + // flags + at least four data bytes + crc + if (recvlen < 7) { + return PM3_EWRONGANSWER; + } + + // GetIso15693AnswerFromTag() doesn't check the crc, so do it here + if (CheckCrc15(s_iso15_recvbuf, recvlen) == false) { + return PM3_ECRC; + } + + if ((s_iso15_recvbuf[0] & ISO15_RES_ERROR) == ISO15_RES_ERROR) { + return PM3_EWRONGANSWER; + } + + // the option flag makes the tag prepend a lock byte, blocks can be wider than four bytes + uint8_t offset = (recvlen > 7) ? 2 : 1; + *data = s_iso15_recvbuf + offset; + *len = recvlen - offset - 2; + 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; + } + + // flags + crc + if (recvlen < 3) { + return PM3_EWRONGANSWER; + } + + if (CheckCrc15(s_iso15_recvbuf, recvlen) == false) { + return PM3_ECRC; + } + + if ((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 *data = NULL; + uint8_t len = 0; + + if (magic_15_read_blk(blocks[i], &data, &len, start_time, eof_time) != PM3_SUCCESS) { + continue; + } + + if (magic_15_is_blank(data, len)) { + continue; + } + + // leftover of the unlock write of an earlier attempt on this same tag + if (blocks[i] == ISO15_MAGIC_GEN1_BLK_UNLOCK_B && len >= 4 && + memcmp(data, 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. +// PM3_SUCCESS means both signature blocks were read, *in_config says what they hold. +static int magic_v3_read_config(bool *in_config, uint32_t *start_time, uint32_t *eof_time) { + + uint8_t *data = NULL; + uint8_t len = 0; + + *in_config = false; + + // the second read overwrites the buffer, so compare 0x14 before asking for 0x15 + int res = magic_15_read_blk(ISO15_MAGIC_V3_BLK_SIG_A, &data, &len, start_time, eof_time); + if (res != PM3_SUCCESS) { + return res; + } + + bool sig_a = (len >= 4 && memcmp(data, g_magic_v3_sig_a, 4) == 0); + + res = magic_15_read_blk(ISO15_MAGIC_V3_BLK_SIG_B, &data, &len, start_time, eof_time); + if (res != PM3_SUCCESS) { + return res; + } + + *in_config = (sig_a && len >= 4 && memcmp(data, g_magic_v3_sig_b, 4) == 0); + return PM3_SUCCESS; +} + +// 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; + + bool in_config = false; + if (magic_v3_read_config(&in_config, &start_time, &eof_time) != PM3_SUCCESS || in_config == 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; + + bool in_config = false; + if (magic_v3_read_config(&in_config, &start_time, &eof_time) != PM3_SUCCESS || in_config == 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); + } + + // finalize wipes the memory, so the signature blocks must read back as something + // else. a read that fails proves nothing and counts as a failure too + if (res == PM3_SUCCESS) { + if (magic_v3_read_config(&in_config, &start_time, &eof_time) != PM3_SUCCESS || in_config) { + 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/armsrc/mifarecmd.c b/armsrc/mifarecmd.c index 9abecc666..bdc6dbf1e 100644 --- a/armsrc/mifarecmd.c +++ b/armsrc/mifarecmd.c @@ -1015,11 +1015,13 @@ void MifareAcquireNonces(const mf_acquire_nonces_t *payload) { while (num_nonces < MFC_MAX_NONCES) { // Test if the action was cancelled - if (BUTTON_PRESS()) { + if (BUTTON_PRESS() || data_available()) { isOK = PM3_EOPABORTED; field_off = true; break; } + + WDT_HIT(); if (!have_uid) { // need a full select cycle to get the uid first iso14a_card_select_t card_info; @@ -1144,12 +1146,14 @@ void MifareAcquireEncryptedNonces(const mf_acquire_nonces_t *payload) { while (num_pairs < MFC_MAX_NONCE_PAIRS) { // Test if the action was cancelled - if (BUTTON_PRESS()) { + if (BUTTON_PRESS() || data_available()) { isOK = PM3_EOPABORTED; field_off = true; break; } + WDT_HIT(); + if (have_uid == false) { // need a full select cycle to get the uid first iso14a_card_select_t card_info; if (iso14443a_select_card(uid, &card_info, &cuid, true, 0, true) == 0) { diff --git a/armsrc/pm5_cep.c b/armsrc/pm5_cep.c new file mode 100644 index 000000000..8ac4e271a --- /dev/null +++ b/armsrc/pm5_cep.c @@ -0,0 +1,324 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- +// See pm5_cep.h. Extracted from the dead test_f0_com_by_usb_cep() / +// cep_spi_*() code in at32_unit_test.c (GH issue #3667) - the register-level +// handshake and SPI logic is dxl's original work, carried over near-verbatim +// except where noted below. +// +// Hardware-verified (real Flipper Zero, repeated app relaunches without a +// physical cable replug): USART1 handshake, the SPI1 mode below for the +// handshake reply, and the CC-controller I2C address 0x47 all confirmed +// working. Not yet exercised: the post-handshake NG-frame SPI transport +// (cep_spi_read_ng/write_sync) under an actual client command. +//----------------------------------------------------------------------------- + +#include "pm5_cep.h" + +#include "at32f435_437.h" +#include "at32f435_437_crm.h" +#include "at32f435_437_gpio.h" +#include "at32f435_437_usart.h" +#include "at32f435_437_spi.h" +#include "gpio_apis.h" +#include "i2c.h" +#include "ticks_apis.h" +#include "dbprint.h" +#include "pm3_cmd.h" +#include "string.h" + +#define CEP_CC_CONTROLLER_ADDR 0x47 +#define CEP_CC_STATUS_REG 0x09 +#define CEP_ATTACH_POLL_MS 50 // CC-controller I2C poll interval +#define CEP_HANDSHAKE_STRING "iamf0rupm5" +#define CEP_HANDSHAKE_STX 0x02 +#define CEP_SPI_BYTE_TIMEOUT 100000 // spin-wait iterations per byte (matches source) +#define CEP_SPI_RESPONSE_TIMEOUT_US (1000 * 1000) // 1s, matches source +#define CEP_HANDSHAKE_RX_TIMEOUT_MS 2000 // bail out of the receive loop rather than ever hang the main loop + +static bool s_cep_active = false; // handshake completed, SPI transport live + +bool cep_is_active(void) { + return s_cep_active; +} + +// --------------------------------------------------------------------------- +// One-time peripheral bring-up +// --------------------------------------------------------------------------- + +static void cep_usart_init(void) { + crm_periph_clock_enable(CRM_USART1_PERIPH_CLOCK, TRUE); + crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE); + + gpio_init_type gpio_init_struct; + gpio_default_para_init(&gpio_init_struct); + gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; + gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN; + gpio_init_struct.gpio_mode = GPIO_MODE_MUX; + gpio_init_struct.gpio_pins = GPIO_PINS_9; + gpio_init_struct.gpio_pull = GPIO_PULL_UP; + gpio_init(GPIOA, &gpio_init_struct); + gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE9, GPIO_MUX_7); + + usart_init(USART1, 2400, USART_DATA_8BITS, USART_STOP_1_BIT); + usart_parity_selection_config(USART1, USART_PARITY_NONE); + usart_transmitter_enable(USART1, FALSE); // RX only - the reply goes over SPI, not this UART + usart_receiver_enable(USART1, TRUE); + usart_single_line_halfduplex_select(USART1, TRUE); + usart_enable(USART1, TRUE); + + // PA10 (USB1_ID): read once to pick master/slave role for the SPI pin mux. + gpio_init_struct.gpio_pull = GPIO_PULL_NONE; + gpio_init_struct.gpio_mode = GPIO_MODE_INPUT; + gpio_init_struct.gpio_pins = GPIO_PINS_10; + gpio_init(GPIOA, &gpio_init_struct); +} + +static spi_master_slave_mode_type s_spi_mode; + +static void cep_spi_init(void) { + bool is_slave_mode = GpioInputStatus(GPIOA, GPIO_PINS_10); + gpio_inter_usb_spi_role_setup(); + if (is_slave_mode) { + Gpio_Inter_USB_SPI_Role_High(); + } else { + Gpio_Inter_USB_SPI_Role_Low(); + } + s_spi_mode = is_slave_mode ? SPI_MODE_SLAVE : SPI_MODE_MASTER; + + gpio_init_type gpio_init_struct; + crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE); + + // CS (PA4) + gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL; + gpio_init_struct.gpio_pull = GPIO_PULL_UP; + gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; + if (s_spi_mode == SPI_MODE_MASTER) { + gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT; + } else { + gpio_init_struct.gpio_mode = GPIO_MODE_MUX; + gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE4, GPIO_MUX_5); + } + gpio_init_struct.gpio_pins = GPIO_PINS_4; + gpio_init(GPIOA, &gpio_init_struct); + + // SCK (PA5) + gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL; + gpio_init_struct.gpio_pull = GPIO_PULL_DOWN; + gpio_init_struct.gpio_mode = GPIO_MODE_MUX; + gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; + gpio_init_struct.gpio_pins = GPIO_PINS_5; + gpio_init(GPIOA, &gpio_init_struct); + gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE5, GPIO_MUX_5); + + // MISO (PA6) + gpio_init_struct.gpio_pull = GPIO_PULL_UP; + gpio_init_struct.gpio_pins = GPIO_PINS_6; + gpio_init(GPIOA, &gpio_init_struct); + gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE6, GPIO_MUX_5); + + // MOSI (PA7) + gpio_init_struct.gpio_pull = GPIO_PULL_UP; + gpio_init_struct.gpio_pins = GPIO_PINS_7; + gpio_init(GPIOA, &gpio_init_struct); + gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE7, GPIO_MUX_5); + + if (s_spi_mode == SPI_MODE_MASTER) { + gpio_bits_set(GPIOA, GPIO_PINS_4); // idle CS high, release the slave + } + + spi_init_type spi_init_struct; + crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE); + spi_default_para_init(&spi_init_struct); + spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX; + spi_init_struct.master_slave_mode = s_spi_mode; + spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_1024; + // NOT YET HARDWARE-VERIFIED - see file header comment. + spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB; + spi_init_struct.frame_bit_num = SPI_FRAME_8BIT; + spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_LOW; + spi_init_struct.clock_phase = SPI_CLOCK_PHASE_1EDGE; + spi_init_struct.cs_mode_selection = (s_spi_mode == SPI_MODE_MASTER) ? SPI_CS_SOFTWARE_MODE : SPI_CS_HARDWARE_MODE; + spi_init(SPI1, &spi_init_struct); + spi_enable(SPI1, TRUE); +} + +void cep_init(void) { + cep_usart_init(); + cep_spi_init(); + I2C_init(true); +} + +// --------------------------------------------------------------------------- +// Handshake +// --------------------------------------------------------------------------- + +// Blocking (bounded by the Flipper's own ~1.1s handshake timeout budget): +// waits for STX then the literal ASCII string, replies "yes" over SPI on a +// match. Only called once, right after cep_attach_poll() sees a fresh attach. +static bool cep_do_handshake(void) { + uint8_t data[sizeof(CEP_HANDSHAKE_STRING) - 1]; + uint8_t rx_len = 0; + uint32_t start_tick = GetTickCount(); + + while (1) { + if (GetTickCountDelta(start_tick) > CEP_HANDSHAKE_RX_TIMEOUT_MS) { + return false; + } + + if (usart_flag_get(USART1, USART_RDBF_FLAG) != RESET) { + uint8_t rx_data = usart_data_receive(USART1); + if (rx_data == CEP_HANDSHAKE_STX) { + // STX: restart the frame. Unlike the original unit-test code, + // do NOT discard an extra byte here - the FAP protocol has no + // byte between STX and the literal string, and doing an + // unconditional second usart_data_receive() without + // re-checking RDBF risked reading stale data and ate what + // should have been the string's first byte. + rx_len = 0; + continue; + } + if (rx_len < sizeof(data)) { + data[rx_len++] = rx_data; + } + } + + if (rx_len == sizeof(data)) { + if (memcmp(CEP_HANDSHAKE_STRING, data, sizeof(data)) == 0) { + break; + } + rx_len = 0; // no match, resync on the next STX + } + } + + uint8_t response[] = {0x04, 0x00, 'y', 'e', 's', 0x00}; + for (size_t i = 0; i < sizeof(response); i++) { + uint32_t wait_start = GetTicks(); + while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET) { + if (GetTicks() - wait_start > CEP_SPI_RESPONSE_TIMEOUT_US) { + uint8_t cc_ctrl_data; + bool ret = I2C_BufferReadRaw(&cc_ctrl_data, 1, CEP_CC_STATUS_REG, CEP_CC_CONTROLLER_ADDR << 1); + if (ret && ((cc_ctrl_data >> 6 & 0x03) == 0)) { + return false; // disconnected mid-reply + } + } + } + spi_i2s_data_transmit(SPI1, response[i]); + } + + return true; +} + +// --------------------------------------------------------------------------- +// Attach polling (non-blocking, rate-limited) +// --------------------------------------------------------------------------- + +void cep_attach_poll(void) { + static uint32_t last_tick = 0; + + if ((last_tick != 0) && (GetTickCountDelta(last_tick) < CEP_ATTACH_POLL_MS)) { + return; + } + last_tick = GetTickCount(); + + uint8_t cc_ctrl_data; + bool ret = I2C_BufferReadRaw(&cc_ctrl_data, 1, CEP_CC_STATUS_REG, CEP_CC_CONTROLLER_ADDR << 1); + if (!ret) { + return; + } + + bool attached = ((cc_ctrl_data >> 6 & 0x03) != 0); + + if (!attached) { + s_cep_active = false; + } else { + // The FAP re-runs its handshake on every app launch, not just on a + // fresh physical attach - the CC controller's attach bits don't + // reliably blip on every relaunch (confirmed on hardware: sometimes + // they do, sometimes they don't), so gating the handshake listener on + // that edge alone missed real handshake attempts and required a + // physical unplug/replug to recover (GH #3667). Instead, watch for a + // fresh incoming byte any time we're attached, regardless of edge. + // cep_do_handshake() itself is timeout-bounded so a spurious byte + // can't hang the main loop. + if (usart_flag_get(USART1, USART_RDBF_FLAG) != RESET) { + s_cep_active = cep_do_handshake(); + } + } + + uint8_t int_state = cc_ctrl_data >> 4 & 0x01; + if (int_state) { + cc_ctrl_data |= 1 << 4; // clear the CC controller's interrupt latch + I2C_BufferWrite(&cc_ctrl_data, 1, CEP_CC_STATUS_REG, CEP_CC_CONTROLLER_ADDR << 1); + } +} + +// --------------------------------------------------------------------------- +// SPI NG-frame transport (verbatim from the unit test - already correct) +// --------------------------------------------------------------------------- + +bool cep_spi_data_available(void) { + uint8_t len_header[2] = {0x00}; + for (size_t i = 0; i < sizeof(len_header); ++i) { + uint64_t timeout = 0; + while (spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET) { + if (timeout++ > CEP_SPI_BYTE_TIMEOUT) { + return false; + } + } + len_header[i] = spi_i2s_data_receive(SPI1); + } + uint16_t data_len = (len_header[1] << 8) | len_header[0]; + if (data_len > PM3_CMD_DATA_SIZE * 2) { + return false; + } + return true; +} + +uint32_t cep_spi_read_ng(uint8_t *data, size_t len) { + for (size_t i = 0; i < len; ++i) { + uint64_t timeout = 0; + while (spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET) { + if (timeout++ > CEP_SPI_BYTE_TIMEOUT) { + return i; + } + } + data[i] = spi_i2s_data_receive(SPI1); + } + return len; +} + +int cep_spi_write_sync(uint8_t *data, size_t len) { + while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET); + spi_i2s_data_transmit(SPI1, len & 0xFF); + + while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET); + spi_i2s_data_transmit(SPI1, (len >> 8) & 0xFF); + + for (size_t i = 0; i < len; ++i) { + while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET); + spi_i2s_data_transmit(SPI1, data[i]); + } + + // Two trailing zero bytes: the agreed "no more data" idle marker. + while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET); + spi_i2s_data_transmit(SPI1, 0x00); + while (spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET); + spi_i2s_data_transmit(SPI1, 0x00); + + while (spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) == SET); + + return PM3_SUCCESS; +} diff --git a/armsrc/pm5_cep.h b/armsrc/pm5_cep.h new file mode 100644 index 000000000..fafbd33d1 --- /dev/null +++ b/armsrc/pm5_cep.h @@ -0,0 +1,63 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- +// Proxmark5 CEP (Type-C Extended Port) transport to the Flipper Zero FAP. +// +// USART1 (PA9, single-wire half-duplex, 2400 8N1) carries a one-shot ASCII +// handshake ("iamf0rupm5" -> "yes"); once attached, standard PM3 NG frames +// ride length-prefixed over SPI1 (PA4-7). See GH issue #3667 for the full +// protocol writeup this was extracted from (armsrc/at32_unit_test.c, dxl). +// +// Enabled by -DWITH_CEP. Independent of -DWITH_BWM_FORWARD - both may be +// compiled and running at the same time. +//----------------------------------------------------------------------------- + +#ifndef __PM5_CEP_H +#define __PM5_CEP_H + +#include "common.h" + +// Bring up the CC-controller I2C polling state. Call once from AppMain(), +// after usb_enable() (mirrors bwm_uart_init() placement). Never blocks. +void cep_init(void); + +// True once the Flipper handshake has completed and the SPI transport is +// expected to be live. Gate for receive_ng()/reply_ng_internal() so they +// don't pay an SPI-timeout poll on every idle main-loop iteration when no +// Flipper is attached. +bool cep_is_active(void); + +// Rate-limited (see PM5_CEP_ATTACH_POLL_MS), non-blocking. Call once per +// AppMain() main-loop iteration, alongside bwm_autooff_check(). Detects the +// Flipper attach/detach transition via the CC controller and, on a fresh +// attach, runs the one-shot UART handshake. Safe no-op the rest of the time. +void cep_attach_poll(void); + +// Gate for receive_ng(): true once the length header of an inbound SPI frame +// has been seen. Blocks (with an internal timeout) waiting for the 2-byte +// length header - mirrors usart_rxdata_available()'s call shape, not a +// simple non-blocking peek. +bool cep_spi_data_available(void); + +// Read up to `len` raw NG bytes off SPI1. Returns the number of bytes +// actually read before an internal per-byte timeout gave up early. +uint32_t cep_spi_read_ng(uint8_t *data, size_t len); + +// Write `len` raw NG bytes (a whole PacketResponseNG/OLD frame) out over +// SPI1 as one length-prefixed packet. Always returns PM3_SUCCESS today (the +// underlying spi_i2s_data_transmit() calls are blocking-until-ready). +int cep_spi_write_sync(uint8_t *data, size_t len); + +#endif // __PM5_CEP_H diff --git a/client/src/cmdhf15.c b/client/src/cmdhf15.c index b2f450699..3bfa55a05 100644 --- a/client/src/cmdhf15.c +++ b/client/src/cmdhf15.c @@ -3324,79 +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}; - -// Read one 4-byte block from a magic V3 tag in unaddressed mode. -static int hf15_magic_v3_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) { - PrintAndLogEx(WARNING, "Failed to allocate memory"); - 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) { - PrintAndLogEx(DEBUG, "iso15693 timeout"); - return PM3_ETIMEOUT; - } - - ISO15_ERROR_HANDLING_RESPONSE - - uint8_t *d = resp.data.asBytes; - - ISO15_ERROR_HANDLING_CARD_RESPONSE(d, resp.length) - - memcpy(out, d + 2, 4); - return PM3_SUCCESS; -} - -// Write one 4-byte block to a magic V3 tag in unaddressed mode. -static int hf15_magic_v3_write_blk(uint8_t blockno, const uint8_t *data) { - uint16_t flags = arg_get_raw_flag(0, true, false, false); - return hf_15_write_blk(NULL, 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_v3_read_blk(ISO15_MAGIC_V3_BLK_SIG_A, a) != PM3_SUCCESS) { - return false; - } - if (hf15_magic_v3_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); -} - /** * Commandline handling: HF15 CMD CSETUID * Set UID for magic Chinese card @@ -3406,6 +3333,8 @@ 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 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.", "hf 15 csetuid -u E011223344556677 -> use gen1 command\n" @@ -3459,38 +3388,50 @@ static int CmdHF15CSetUID(const char *Cmd) { PrintAndLogEx(INFO, "Writing..."); - if (use_v3) { - /* - 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); + PacketResponseNG resp; + clearCommandBuffer(); - if (hf15_magic_v3_write_blk(ISO15_MAGIC_V3_BLK_UID_LO, blk_lo) != PM3_SUCCESS || - hf15_magic_v3_write_blk(ISO15_MAGIC_V3_BLK_UID_HI, blk_hi) != PM3_SUCCESS) { - PrintAndLogEx(FAILED, "Setting new UID ( " _RED_("fail") " )"); - PrintAndLogEx(NORMAL, ""); - return PM3_ESOFT; - } + 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; + } - } else { - PacketResponseNG resp; - clearCommandBuffer(); + SendCommandNG(cmd, (uint8_t *)&payload, sizeof(payload)); + if (WaitForResponseTimeout(cmd, &resp, 2000) == false) { + PrintAndLogEx(WARNING, "timeout while waiting for reply"); + DropField(); + return PM3_ESOFT; + } - uint16_t cmd = CMD_HF_ISO15693_CSETUID; - if (use_v2) { - cmd = CMD_HF_ISO15693_CSETUID_V2; - } + // Gen1 and V3 identify the tag and verify the new UID on the device, V2 has neither + if (use_v2 == false) { - SendCommandNG(cmd, (uint8_t *)&payload, sizeof(payload)); - if (WaitForResponseTimeout(cmd, &resp, 2000) == false) { - PrintAndLogEx(WARNING, "timeout while waiting for reply"); - DropField(); - return PM3_ESOFT; + switch (resp.status) { + case PM3_SUCCESS: + break; + + case PM3_ETIMEOUT: + PrintAndLogEx(FAILED, "no tag found"); + return PM3_ESOFT; + + case 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"); + PrintAndLogEx(HINT, "already finalized or not a V3 tag"); + } 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; + + default: + PrintAndLogEx(FAILED, "Setting new UID ( " _RED_("fail") " )"); + PrintAndLogEx(NORMAL, ""); + return PM3_ESOFT; } } @@ -3525,10 +3466,10 @@ static int CmdHF15CFinalize(const char *Cmd) { CLIParserContext *ctx; CLIParserInit(&ctx, "hf 15 cfinalize", "Finalize a magic ISO15693 'V3' tag.\n" - _RED_("This operation is irreversible.") " After finalize the configuration\n" - "area is erased and the UID can no longer be changed. Set the UID with\n" - "`" _YELLOW_("hf 15 csetuid --v3") "` first, then lock it in with this command.", - "hf 15 cfinalize -y" + _RED_("This operation is irreversible.") " It locks the UID for good,\n" + "clears the configuration blocks and shifts the block numbering. Set it with\n" + "`" _YELLOW_("hf 15 csetuid --v3") "` first, then lock it in with this command.", + "hf 15 cfinalize -y" ); void *argtable[] = { @@ -3540,34 +3481,36 @@ 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, _RED_("This operation is irreversible!") " The UID is locked and the blocks move."); PrintAndLogEx(WARNING, "Add " _YELLOW_("-y") " to confirm and proceed."); return PM3_EINVARG; } PrintAndLogEx(INFO, "Finalizing..."); - if (hf15_magic_v3_write_blk(ISO15_MAGIC_V3_BLK_SIG_A, iso15_magic_v3_fin_a) != PM3_SUCCESS || - hf15_magic_v3_write_blk(ISO15_MAGIC_V3_BLK_SIG_B, iso15_magic_v3_fin_b) != 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/client/src/cmdlft55xx.c b/client/src/cmdlft55xx.c index 7f5d4b1a0..43689d3cd 100644 --- a/client/src/cmdlft55xx.c +++ b/client/src/cmdlft55xx.c @@ -820,17 +820,22 @@ int T55xxReadBlockEx(uint8_t block, bool page1, bool usepwd, uint8_t override, u // override = 1 (override and display) // override = 2 (override and no display) if (override == 0) { - if (AcquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, false, 0, downlink_mode) == false) - return PM3_ERFTRANS; + // A live detect (lf t55xx detect -p) that recovered this password already confirmed the PWD bit is set. + bool detect_confirmed_pwd = (config.pwd_known && config.usepwd && config.pwd == password); - if (t55xxTryDetectModulationEx(downlink_mode, false, 0, password) == false) { - PrintAndLogEx(WARNING, "Safety check: Could not detect if PWD bit is set in config block. Exits."); - PrintAndLogEx(HINT, "Hint: Consider using the override parameter to force read."); - return PM3_EWRONGANSWER; - } else { - PrintAndLogEx(WARNING, "Safety check: PWD bit is NOT set in config block. Reading without password..."); - usepwd = false; - page1 = false; // ?? + if (detect_confirmed_pwd == false) { + if (AcquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, false, 0, downlink_mode) == false) + return PM3_ERFTRANS; + + if (t55xxTryDetectModulationEx(downlink_mode, false, 0, password) == false) { + PrintAndLogEx(WARNING, "Safety check: Could not detect if PWD bit is set in config block. Exits."); + PrintAndLogEx(HINT, "Hint: Consider using the override parameter to force read."); + return PM3_EWRONGANSWER; + } else { + PrintAndLogEx(WARNING, "Safety check: PWD bit is NOT set in config block. Reading without password..."); + usepwd = false; + page1 = false; + } } } else if (override == 1) { PrintAndLogEx(INFO, "Safety check overridden - proceeding despite risk"); @@ -5100,13 +5105,37 @@ out: return PM3_SUCCESS; } -// note length of data returned is different for different chips. -// some return all page 1 (64 bits) and others return just that block (32 bits) -// unfortunately the 64 bits makes this more likely to get a false positive... -bool tryDetectP1(bool getData) { - uint8_t preamble_atmel[] = {1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1}; +// Page-1 trace data opens with allocation class ACL = 0xE0, then a manufacturer code. +// Genuine Atmel silicon carries manufacturer 0x15 / 0x39 (the atmel / silicon preambles). +// Cloned T5577s keep the 0xE0 ACL but use another manufacturer byte, +// also accept a bare 8-bit ACL match +static bool t55xx_trace_preamble_match(void) { + uint8_t preamble_atmel[] = {1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1}; uint8_t preamble_silicon[] = {1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1}; + uint8_t preamble_acl[] = {1, 1, 1, 0, 0, 0, 0, 0}; size_t startIdx = 0; + + if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && + (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + return true; + } + + startIdx = 0; + if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && + (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + return true; + } + + startIdx = 0; + if (preambleSearchEx(g_DemodBuffer, preamble_acl, sizeof(preamble_acl), &g_DemodBufferLen, &startIdx, false) && + (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + return true; + } + + return false; +} + +bool tryDetectP1(bool getData) { uint8_t fc1 = 0, fc2 = 0, ans = 0; int clk = 0, firstClockEdge = 0; bool st = true; @@ -5116,30 +5145,18 @@ bool tryDetectP1(bool getData) { return false; } - // try fsk clock detect. if successful it cannot be any other type of modulation... (in theory...) + // try fsk clock detect. if successful it cannot be any other type of modulation. ans = fskClocks(&fc1, &fc2, (uint8_t *)&clk, &firstClockEdge); if (ans && ((fc1 == 10 && fc2 == 8) || (fc1 == 8 && fc2 == 5))) { if (FSKrawDemod(0, 0, 0, 0, false) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } if (FSKrawDemod(0, 1, 0, 0, false) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } @@ -5151,113 +5168,60 @@ bool tryDetectP1(bool getData) { if (clk > 0) { if (ASKDemod_ext(0, 0, 1, 0, false, false, false, 1, &st) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } st = true; if (ASKDemod_ext(0, 1, 1, 0, false, false, false, 1, &st) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } if (ASKbiphaseDemod(0, 0, 0, 2, false) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } if (ASKbiphaseDemod(0, 0, 1, 2, false) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } } // try NRZ clock detect. it could be another type even if successful. - clk = GetNrzClock("", false); //has the most false positives :( + clk = GetNrzClock("", false); // has the most false positives if (clk > 0) { if (NRZrawDemod(0, 0, 1, false) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } if (NRZrawDemod(0, 1, 1, false) == PM3_SUCCESS) { - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } } // Fewer card uses PSK - // try psk clock detect. if successful it cannot be any other type of modulation... (in theory...) + // try psk clock detect. if successful it cannot be any other type of modulation. clk = GetPskClock("", false); if (clk > 0) { - // allow undo - // save_restoreGB(GRAPH_SAVE); - // skip first 160 samples to allow antenna to settle in (psk gets inverted occasionally otherwise) - //CmdLtrim("-i 160"); - if (PSKDemod(0, 0, 6, false) == PM3_SUCCESS) { - //save_restoreGB(GRAPH_RESTORE); - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (PSKDemod(0, 0, 6, false) == PM3_SUCCESS) { + if (t55xx_trace_preamble_match()) { return true; } } if (PSKDemod(0, 1, 6, false) == PM3_SUCCESS) { - //save_restoreGB(GRAPH_RESTORE); - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } @@ -5266,19 +5230,11 @@ bool tryDetectP1(bool getData) { if (PSKDemod(0, 0, 6, false) == PM3_SUCCESS) { psk1TOpsk2(g_DemodBuffer, g_DemodBufferLen); - //save_restoreGB(GRAPH_RESTORE); - if (preambleSearchEx(g_DemodBuffer, preamble_atmel, sizeof(preamble_atmel), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { - return true; - } - - if (preambleSearchEx(g_DemodBuffer, preamble_silicon, sizeof(preamble_silicon), &g_DemodBufferLen, &startIdx, false) && - (g_DemodBufferLen == 32 || g_DemodBufferLen == 64)) { + if (t55xx_trace_preamble_match()) { return true; } } // inverse waves does not affect PSK2 demod - //undo trim samples - //save_restoreGB(GRAPH_RESTORE); + // no other modulation clocks = 2 or 4 so quit searching if (fc1 != 8) { return false; diff --git a/common_arm/Makefile.hal b/common_arm/Makefile.hal index c0a97b486..bf1f8f2a6 100644 --- a/common_arm/Makefile.hal +++ b/common_arm/Makefile.hal @@ -16,11 +16,11 @@ # Default platform if no platform specified PLATFORM?=PM3RDV4 -# Standalone Mode info (path depends if make is called at top or from armsrc) +# Standalone Mode info (path depends if make is called at top, from armsrc, or from a sibling dir like recovery/bootrom) # Guard Makefile.hal against implicit rules: (with % to avoid being first goal) %/Makefile.hal: ; -include armsrc/Standalone/Makefile.hal --include Standalone/Makefile.hal +-include ../armsrc/Standalone/Makefile.hal ifndef DEFAULT_STANDALONE $(error Could not find armsrc/Standalone/Makefile.hal) endif @@ -50,6 +50,8 @@ Known definitions: +--------------------------------------------+ | BWM | PM5 Battery Wireless Mod | +--------------------------------------------+ +| CEP | PM5 Flipper Zero (CEP) | ++--------------------------------------------+ | NO_LOWBATT_BEEP | PM5 disable low-batt beep| +--------------------------------------------+ |NO_LOWBATT_SHUTDOWN| PM5 no low-batt cutoff | @@ -227,6 +229,15 @@ ifneq (,$(findstring BWM,$(PLATFORM_EXTRAS_TMP))) PLATFORM_DEFS += -DWITH_BWM_FORWARD -DWITH_BWM_STATUS -DWITH_PM5_PWR_LED -DWITH_PM5_AUTOOFF -DWITH_BWM_LOWBATT_BEEP -DWITH_PM5_LOWBATT_SHUTDOWN PLATFORM_EXTRAS_TMP := $(strip $(filter-out BWM,$(PLATFORM_EXTRAS_TMP))) endif +# Flipper Zero over the Type-C extended port (CEP). Independent of BWM - both +# may be enabled together (unlike e.g. BTADDON/FPC_USART_DEV above). +ifneq (,$(findstring CEP,$(PLATFORM_EXTRAS_TMP))) + ifneq ($(PLATFORM),PM5) + $(error PLATFORM_EXTRAS token CEP is only valid on PLATFORM=PM5) + endif + PLATFORM_DEFS += -DWITH_CEP + PLATFORM_EXTRAS_TMP := $(strip $(filter-out CEP,$(PLATFORM_EXTRAS_TMP))) +endif ifneq (,$(findstring NO_LOWBATT_SHUTDOWN,$(PLATFORM_EXTRAS_TMP))) ifneq ($(PLATFORM),PM5) $(error PLATFORM_EXTRAS token NO_LOWBATT_SHUTDOWN is only valid on PLATFORM=PM5) diff --git a/doc/commands.json b/doc/commands.json index 104290840..00d9339b0 100644 --- a/doc/commands.json +++ b/doc/commands.json @@ -1913,7 +1913,7 @@ }, "hf 15 cfinalize": { "command": "hf 15 cfinalize", - "description": "Finalize a magic ISO15693 'V3' tag. This operation is irreversible. After finalize the configuration area is erased and the UID can no longer be changed. Set the UID with `hf 15 csetuid --v3` first, then lock it in with this command.", + "description": "Finalize a magic ISO15693 'V3' tag. This operation is irreversible. It locks the UID for good, clears the configuration blocks and shifts the block numbering. Set it with `hf 15 csetuid --v3` first, then lock it in with this command.", "notes": [ "hf 15 cfinalize -y" ], @@ -1926,7 +1926,7 @@ }, "hf 15 csetuid": { "command": "hf 15 csetuid", - "description": "Set UID for magic Chinese card (only works with such cards) For magic 'V3' tags this writes the UID configuration only and is repeatable; run `hf 15 cfinalize` afterwards to lock the UID permanently.", + "description": "Set UID for magic Chinese card (only works with such cards) Gen1 and V3 probe their backdoor blocks first and refuse to write if they read back real data, to avoid corrupting a normal (non-magic) tag. For magic 'V3' tags this writes the UID configuration only and is repeatable; run `hf 15 cfinalize` afterwards to lock the UID permanently.", "notes": [ "hf 15 csetuid -u E011223344556677 -> use gen1 command", "hf 15 csetuid -u E011223344556677 --v2 -> use gen2 command", diff --git a/doc/magic_cards_notes.md b/doc/magic_cards_notes.md index d3f49444a..09a9ee771 100644 --- a/doc/magic_cards_notes.md +++ b/doc/magic_cards_notes.md @@ -2716,7 +2716,7 @@ V3: blocks `0x14` and `0x15` hold a signature while the tag is not finalized. ``` hf 15 raw -ac -d 022014 # A5 2B 44 2C -hf 15 raw -ac -d 022015 # 21 AE 93 00 (69 E2 5D 00 after finalize) +hf 15 raw -ac -d 022015 # 21 AE 93 00 (00 00 00 00 after finalize) ``` @@ -2765,7 +2765,10 @@ hf 15 raw -acw -d 02211077665544 hf 15 raw -acw -d 022111332211E0 ``` -Finalize locks the UID for good and can't be undone, block `0x15` changes to `69 E2 5D 00`: +Finalize locks the UID for good and can't be undone. It clears the configuration +blocks and changes the block numbering: on the tag tested, data written to block +`0x38` before finalize read back at block `0x20` afterwards, a shift of `0x18`. +User data is moved, not erased. Note down what is where before finalizing: ``` hf 15 raw -acw -d 022114A52B442C diff --git a/doc/md/PM5_Start_Here/PM5-FLIPPER-USAGE.md b/doc/md/PM5_Start_Here/PM5-FLIPPER-USAGE.md new file mode 100644 index 000000000..5e1271409 --- /dev/null +++ b/doc/md/PM5_Start_Here/PM5-FLIPPER-USAGE.md @@ -0,0 +1,97 @@ +# Proxmark5 CEP — Flipper Zero link + +The **CEP (Type-C Extended Port)** is the side USB-C port on the PM5 — the one +**not** used for flashing/DFU. It lets a Flipper Zero, running the +[Proxmark5_FlipperZero_FAP](https://github.com/RfidResearchGroup/Proxmark5_FlipperZero_FAP) +app, talk to the PM5 over a one-shot UART handshake followed by standard PM3 +NG command/response frames carried over SPI. Everything below is **PM5-only** +and is compiled in with the `CEP` platform extra. + +See [GH issue #3667](https://github.com/RfidResearchGroup/proxmark3/issues/3667) +for the full protocol writeup and open hardware-verification items. + +## Contents + +- [Build](#build) +- [Physical hookup](#physical-hookup) +- [What works today](#what-works-today) +- [What doesn't (yet)](#what-doesnt-yet) +- [Status / debugging](#status--debugging) +- [Notes](#notes) + +--- + +## Build + +``` +make clean +make PLATFORM=PM5 PLATFORM_EXTRAS=CEP +make client # or your usual client build +``` + +`CEP` is independent of `BWM` — both may be enabled together: + +``` +make PLATFORM=PM5 PLATFORM_EXTRAS="BWM CEP" +``` + +Or set it persistently in `Makefile.platform`: + +``` +PLATFORM=PM5 +PLATFORM_EXTRAS=CEP +``` + +> [!NOTE] +> Without `PLATFORM_EXTRAS=CEP` the firmware ignores the Flipper entirely — the +> CEP port stays inert, same as before this feature existed. + +--- + +## Physical hookup + +- Use the **side** USB-C port (the button-side port stays reserved for + flashing/DFU). +- Attach a Flipper Zero fitted with the Flipper transfer module/cable, running + the Proxmark5_FlipperZero_FAP app. +- The Flipper supplies 5V to the PM5 via USB OTG when the app launches. + +--- + +## What works today + +- The FAP handshake completing (app leaves "connecting"). +- Standard PM3 NG commands that don't touch the antenna frontend — `hw + version`, `hw status`, memory/flash operations, etc. + +## What doesn't (yet) + +- Any RF operation over this link — `hf`/`lf` reads, the FAP's "Read Hitag2" + menu item. These need the real PM5 FPGA/RF configuration, which isn't + shipped in this repo. Tracked separately, out of scope for the CEP + transport itself — see GH issue #3667. + +--- + +## Status / debugging + +- `hw status` reports a **CEP (Flipper) link** line: `attached` / + `not attached`. +- **Flipper side**: `./fbt cli` → `log debug`, then watch the + `Proxmark5_COM` tag while the FAP runs. +- **PM5 side**: keep the normal button-side USB-C cable attached to a PC + running the standard client at the same time as the Flipper is on CEP — + `Dbprintf()` output in the new CEP code surfaces there as usual, regardless + of what's happening over CEP. + +--- + +## Notes + +- CEP uses its own reply-routing flag (`g_reply_via_cep`), independent of + BWM's (`g_reply_via_fpc`) — this is what lets both transports run + concurrently on hardware that has both fitted. +- The SPI bit-order/clock-phase settings are a best-effort port from prior + bring-up code, pending confirmation against real Flipper traffic (logic + analyzer). If the handshake never completes, this is the first thing to + check — see GH issue #3667. diff --git a/include/pm3_cmd.h b/include/pm3_cmd.h index dee23a9ff..33f0564ce 100644 --- a/include/pm3_cmd.h +++ b/include/pm3_cmd.h @@ -287,13 +287,17 @@ typedef struct { // Appended in version 12. bool compiled_with_bwm : 1; // PM5 built with PLATFORM_EXTRAS=BWM (battery/wireless module) + + // Appended in version 13. + bool compiled_with_cep : 1; // PM5 built with PLATFORM_EXTRAS=CEP (Flipper Zero, Type-C extended port) } PACKED capabilities_t; // Bump this whenever a command payload changes shape, so a mismatched client and // firmware refuse to talk instead of misparsing each other. // 10: CMD_HF_MIFARE_EML_MEMSET gained a flags byte // 11: capabilities_t gained em_size / em_allocated // 12: capabilities_t gained compiled_with_bwm -#define CAPABILITIES_VERSION 12 +// 13: capabilities_t gained compiled_with_cep +#define CAPABILITIES_VERSION 13 // what a pre-v9 device would have used, it could not tell us #define CAPABILITIES_LEGACY_CMD_DATA_SIZE 512 extern capabilities_t g_pm3_capabilities; @@ -1089,6 +1093,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 diff --git a/recovery/Makefile b/recovery/Makefile index 22425bb1e..d3f23ee19 100644 --- a/recovery/Makefile +++ b/recovery/Makefile @@ -1,3 +1,15 @@ + +# This Makefile might have been called directly, not via the root Makefile, so: +ifeq ($(PLTNAME),) + PLATFORM_FILE ?= ../Makefile.platform + -include $(PLATFORM_FILE) + -include ../.Makefile.options.cache + include ../common_arm/Makefile.hal + ifeq ($(PLATFORM_CHANGED), true) + $(error platform definitions have been changed, please "make clean" at the root of the project) + endif +endif + include ../common_arm/Makefile.common INSTALLFW = recovery.bin