From dca419413ba72358279ae597d554bfa107c6ab02 Mon Sep 17 00:00:00 2001 From: dxl <64101226@qq.com> Date: Sat, 1 Aug 2026 15:42:40 +0800 Subject: [PATCH] Added cmd(fpga, antennal, qc...) for Proxmark5 --- client/src/cmdhf.c | 10 +- client/src/cmdhw.c | 225 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 233 insertions(+), 2 deletions(-) diff --git a/client/src/cmdhf.c b/client/src/cmdhf.c index dc1aff1e7..3bd5fed91 100644 --- a/client/src/cmdhf.c +++ b/client/src/cmdhf.c @@ -373,12 +373,18 @@ int CmdHFTune(const char *Cmd) { break; } - if ((resp.status == PM3_EOPABORTED) || (resp.length != sizeof(uint16_t))) { + if ((resp.status == PM3_EOPABORTED) || (resp.length != sizeof(uint16_t) && resp.length != sizeof(uint32_t))) { PrintAndLogEx(NORMAL, ""); break; } - uint16_t volt = resp.data.asDwords[0] & 0xFFFF; + uint32_t volt; + if (resp.length == sizeof(uint16_t)) { + volt = resp.data.asDwords[0] & 0xFFFF; + } else { + volt = resp.data.asDwords[0]; // U32. It can exceed 65.535V. + } + if (first) { v_max = volt; v_min = volt; diff --git a/client/src/cmdhw.c b/client/src/cmdhw.c index 772d0e47f..4543496c2 100644 --- a/client/src/cmdhw.c +++ b/client/src/cmdhw.c @@ -36,6 +36,7 @@ #include "ui.h" #include "fpga.h" #include "cmdhw.h" +#include "cmdfpga.h" #include "cmddata.h" #include "commonutil.h" #include "preferences.h" @@ -1701,6 +1702,215 @@ int set_fpga_mode(uint8_t mode) { return resp.status; } +static int CmdPM5Ant(const char *Cmd) { + + CLIParserContext *ctx; + CLIParserInit(&ctx, "hw ant_pm5", + "Control the antennal of pm5", + "hw ant_pm5 --set -> Write the data of IO data register\n" + "hw ant_pm5 -m --set -> Write the data of IO map register\n" + ); + + void *argtable[] = { + arg_param_begin, + arg_lit0("m", "map", "Write the IO map register"), + arg_u64_0("s", "set", "", "Set PM5 antenna"), + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + bool rw_map = arg_get_lit(ctx, 1); + uint64_t io = arg_get_u64_def(ctx, 2, -1); + CLIParserFree(ctx); + + PacketResponseNG resp; + + // Read the current value of the register before writing + struct { + uint8_t reg_type; // 0 is io reg, 1 is map reg. + } PACKED payload_read = { + .reg_type = rw_map ? 1 : 0, + }; + clearCommandBuffer(); + SendCommandNG(CMD_ANT_CONTROL_READ, (uint8_t*)&payload_read, sizeof(payload_read)); + if (WaitForResponseTimeout(CMD_ANT_CONTROL_READ, &resp, 1000) == false) { + PrintAndLogEx(WARNING, "command execution time out"); + return PM3_ETIMEOUT; + } + if (resp.status != PM3_SUCCESS) { + PrintAndLogEx(ERR, "failed to read PM5 antenna register"); + return resp.status; + } + PrintAndLogEx(INFO, "PM5 antenna register read: 0x%02X", resp.data.asBytes[0]); + + // Write the new value to the register(If need) + if (io != (uint64_t)-1) { + struct { + uint8_t data; + uint8_t reg_type; // 0 is io reg, 1 is map reg. + } PACKED payload_write = { + .reg_type = rw_map ? 1 : 0, + .data = io & 0xFF, + }; + clearCommandBuffer(); + SendCommandNG(CMD_ANT_CONTROL_WRITE, (uint8_t*)&payload_write, sizeof(payload_write)); + if (WaitForResponseTimeout(CMD_ANT_CONTROL_WRITE, &resp, 1000) == false) { + PrintAndLogEx(WARNING, "command execution time out"); + return PM3_ETIMEOUT; + } + if (resp.status != PM3_SUCCESS) { + PrintAndLogEx(ERR, "failed to write PM5 antenna register"); + return resp.status; + } + PrintAndLogEx(INFO, "PM5 antenna register written: 0x%02X", payload_write.data); + } + + return PM3_SUCCESS; +} + +static int CmdDeviceFactoryData(const char *Cmd) { + CLIParserContext *ctx; + CLIParserInit(&ctx, "hw factorydata", + "Get/Set the factory data for Device", + "hw factorydata --load -> Write the factory data to device from file\n" + "hw factorydata -> Read and parse the factory data from device\n" + ); + + void *argtable[] = { + arg_param_begin, + arg_str0(NULL, "load", "", "Load factory data from file to device"), + arg_param_end + }; + + CLIExecWithReturn(ctx, Cmd, argtable, true); + + int fnlen = 0; + char filename[FILE_PATH_SIZE] = {0}; + CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); + + CLIParserFree(ctx); + + // Read the factory data from device + clearCommandBuffer(); + SendCommandNG(CMD_EEPROM_FACTORY_INFO_READ, NULL, 0); + PacketResponseNG resp; + if (WaitForResponseTimeout(CMD_EEPROM_FACTORY_INFO_READ, &resp, 1000) == false) { + PrintAndLogEx(WARNING, "command execution time out"); + return PM3_ETIMEOUT; + } + if (resp.status != PM3_SUCCESS) { + PrintAndLogEx(ERR, "failed to read factory data, maybe eeprom unavailable."); + return resp.status; + } + // Parse the factory data + if (resp.length) { + proxmark5_factory_info_v1_t *factory = (proxmark5_factory_info_v1_t *)resp.data.asBytes; + PrintAndLogEx(INFO, "Factory data read from device:"); + PrintAndLogEx(INFO, " - Data raw(hex) : 0x%s", sprint_hex_inrow(resp.data.asBytes, resp.length)); + PrintAndLogEx(INFO, " - Version : %d", factory->factory_info_version); + PrintAndLogEx(INFO, " - Signature : %s", + sprint_hex_inrow(factory->ecdsa_secp256k1_signature, sizeof(factory->ecdsa_secp256k1_signature))); + PrintAndLogEx(INFO, " - Timestamp : %" PRIu64, factory->info.unix_timestamp); + PrintAndLogEx(INFO, " - Chip Unique ID : %s", + sprint_hex_inrow(factory->info.chip_unique_id, sizeof(factory->info.chip_unique_id))); + PrintAndLogEx(INFO, " - Production ID : %" PRIu32, factory->info.production_id); + PrintAndLogEx(INFO, " - Hardware Version : %" PRIu32, factory->info.hardware_version); + PrintAndLogEx(INFO, " - AES key : %s", + sprint_hex_inrow(factory->info.aes_key, sizeof(factory->info.aes_key))); + } + + // If data is provided, it needs to be written + if (fnlen) { + // Load the file content into data buffer + uint8_t *data = NULL; + size_t datalen = 0; + int res = loadFile_safe(filename, ".bin", (void **)&data, &datalen); + if (res != PM3_SUCCESS) { + free(data); + return PM3_EFILE; + } + + if (datalen != resp.length) { + PrintAndLogEx(WARNING, _RED_("The length of the data to write (%d) does not match the length " + "of the factory data read from device (%d)."), datalen, resp.length); + free(data); + return PM3_EINVARG; + } + // Write the data to the device + clearCommandBuffer(); + SendCommandNG(CMD_EEPROM_FACTORY_INFO_WRITE, data, datalen); + PacketResponseNG resp_write; + if (WaitForResponseTimeout(CMD_EEPROM_FACTORY_INFO_WRITE, &resp_write, 1000) == false) { + PrintAndLogEx(WARNING, "command execution time out"); + free(data); + return PM3_ETIMEOUT; + } + if (resp_write.status != PM3_SUCCESS) { + PrintAndLogEx(ERR, "failed to write factory data, maybe eeprom unavailable."); + free(data); + return resp_write.status; + } + // Verify the data write + clearCommandBuffer(); + SendCommandNG(CMD_EEPROM_FACTORY_INFO_READ, NULL, 0); + if (WaitForResponseTimeout(CMD_EEPROM_FACTORY_INFO_READ, &resp, 1000) == false) { + PrintAndLogEx(WARNING, "command execution time out"); + free(data); + return PM3_ETIMEOUT; + } + if (resp.status != PM3_SUCCESS) { + PrintAndLogEx(ERR, "failed to read factory data after write, maybe eeprom unavailable."); + free(data); + return resp.status; + } + bool verify_result = false; + if (resp.length == datalen) { + verify_result = memcmp(resp.data.asBytes, data, datalen) == 0; + } + if (verify_result) { + PrintAndLogEx(SUCCESS, "Factory data written and verified successfully."); + } else { + PrintAndLogEx(ERR, "Factory data verification failed after write."); + free(data); + return PM3_EFAILED; + } + free(data); + } + + return PM3_SUCCESS; +} + +static int CmdPM5QCTest(const char *Cmd) { + + CLIParserContext *ctx; + CLIParserInit(&ctx, "hw qcpm5", "QC Test for the PM5", "hf qcpm5"); + + void *argtable[] = { + arg_param_begin, + arg_param_end + }; + CLIExecWithReturn(ctx, Cmd, argtable, true); + CLIParserFree(ctx); + + PrintAndLogEx(INFO, "Performing QC test for the PM5..."); + + clearCommandBuffer(); + SendCommandNG(CMD_PM5_QC_TEST, NULL, 0); + + PacketResponseNG resp; + if (WaitForResponseTimeout(CMD_PM5_QC_TEST, &resp, 20 * 1000) == false) { + SendCommandNG(CMD_BREAK_LOOP, NULL, 0); + PrintAndLogEx(WARNING, "command execution time out"); + return PM3_ETIMEOUT; + } + + if (resp.status != PM3_SUCCESS) { + PrintAndLogEx(ERR, "failed to perform QC test on PM5, failed item: %d", resp.data.asBytes[0]); + return resp.status; + } + PrintAndLogEx(INFO, "PM5 QC test successful."); + return PM3_SUCCESS; +} + static command_t CommandTable[] = { {"help", CmdHelp, AlwaysAvailable, "This help"}, {"-------------", CmdHelp, AlwaysAvailable, "----------------------- " _CYAN_("Operation") " -----------------------"}, @@ -1714,7 +1924,11 @@ static command_t CommandTable[] = { {"bootloader", CmdBootloader, IfPm3Present, "Reboot into bootloader mode"}, {"connect", CmdConnect, AlwaysAvailable, "Connect to the device via serial port"}, {"dbg", CmdDbg, IfPm3Present, "Set device side debug level"}, + {"fpga", CmdFPGA, IfPm3Present, "Fpga commands"}, {"fpgaoff", CmdFPGAOff, IfPm3Present, "Turn off FPGA on device"}, + {"ant_pm5", CmdPM5Ant, IfPm3Present, "Control the antennal of pm5"}, + {"qc_pm5", CmdPM5QCTest, IfPm3Present, "Perform QC test for the PM5"}, + {"factorydata", CmdDeviceFactoryData,IfPm3Present, "Get/Set the factory data for Device"}, {"lcd", CmdLCD, IfPm3Lcd, "Send command/data to LCD"}, {"lcdreset", CmdLCDReset, IfPm3Lcd, "Hardware reset LCD"}, {"ping", CmdPing, IfPm3Present, "Test if the Proxmark3 is responsive"}, @@ -2021,6 +2235,17 @@ void pm3_version(bool verbose, bool oneliner) { } lookupChipID(payload->id, payload->section_size); + + // Get unique id of mainchip + clearCommandBuffer(); + SendCommandNG(CMD_MAIN_CHIP_UNIQUEID, NULL, 0); + if (WaitForResponseTimeout(CMD_MAIN_CHIP_UNIQUEID, &resp, 1000)) { + if (resp.length) { // Some processor maybe no unique id. + char* uniqueid_hex = sprint_hex_inrow(resp.data.asBytes, resp.length); + PrintAndLogEx(NORMAL, " --= Processor Unique ID: " _YELLOW_("0x%s"), uniqueid_hex); + } + } + if (armsrc_mismatch) { PrintAndLogEx(NORMAL, ""); PrintAndLogEx(WARNING, _RED_("ARM firmware does not match the source at the time the client was compiled"));