From 652ee4768d102c346fb4bbc06f6bbd8d040d8e49 Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Tue, 17 Oct 2023 21:19:23 +0200 Subject: [PATCH 1/7] doc --- docs/cli.md | 108 ++++++++++++++++++++++++++++++---------------------- 1 file changed, 63 insertions(+), 45 deletions(-) diff --git a/docs/cli.md b/docs/cli.md index beb5cc4..06f9065 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -104,33 +104,44 @@ To run again after installing, just do the following: ### Linux -1. Install the dependencies - - Ubuntu / Debian: `sudo apt install cmake make python3 python3-pip git ninja-build python3-venv build-essential` - - Arch: `sudo pacman -S cmake make python3-pip git ninja base-devel` +Install the dependencies + - Ubuntu / Debian: + `sudo apt install git cmake build-essential python3-venv` + - Arch: + `sudo pacman -S git cmake base-devel python3` -2. Clone the Repository by typing `git clone https://github.com/RfidResearchGroup/ChameleonUltra.git` +Run the following script to clone the Repository, compile the tools and install Python dependencies in a virtual environment. -3. Now go into the newly created folder with `cd ChameleonUltra/software/src` +```sh +#!/bin/bash -4. Build the required config by running `cmake .` +git clone https://github.com/RfidResearchGroup/ChameleonUltra.git +( + cd ChameleonUltra/software/src + mkdir -p out + ( + cd out + cmake .. + cmake --build . --config Release + ) +) +( + cd ChameleonUltra/software/script + python3 -m venv venv + source venv/bin/activate + pip3 install -r requirements.txt + deactivate +) +``` -5. And the binaries with `cmake --build .` +To run the client after installing, do the following: -6. Go into the script folder with `cd ../script/` - -7. Create a virtual enviroment with `python3 -m venv venv` - -8. Activate it with `source venv/bin/activate` - -9. Install python requirements with `pip3 install -r requirements.txt` - -10. Finally run the CLI with `python3 chameleon_cli_main.py` - -To run again after installing, just do the following: - -1. Activate venv by running `source venv/bin/activate` - -2. Run the CLI with `python3 chameleon_cli_main.py` +```sh +cd ChameleonUltra/software/script +source venv/bin/activate +python3 chameleon_cli_main.py +deactivate +``` ### MacOS @@ -140,31 +151,41 @@ To run again after installing, just do the following: When in the CLI, plug in your Chameleon and connect with `hw connect`. If autodetection fails, get the Serial Port used by your Chameleon and run `hw connect -p COM11` (Replace `COM11` with your serial port, on Linux it may be `/dev/ttyACM0`) -### Common activities - -- Connect to the CLI: `hw connect` -- Change slot: `hw slot change -s [1-8]` - -*More examples coming soon* - ### MFKEY32v2 walk-through Make sure to be in the `software/` directory and run the Python CLI from there. -- Connect to the CLI: `hw connect` -- Check which slot can be used: `hw slot list` -- Change the slot type, here using slot 8 for a MFC 1k emulation: `hw slot type -s 8 -t MIFARE_1024` -- Init the slot content: `hw slot init -s 8 -t MIFARE_1024` - - or load an existing dump and set UID and anticollision data, cf `hf mf eload -h` and `hf mf econfig -h` -- Enable the slot: `hw slot enable -s 8 --hf` -- Change to the new slot: `hw slot change -s 8` -- Activate the authentication logs: `hf mf econfig --enable-log` - +```sh +# Connect to the CLI +hw connect +# Check which slot can be used +hw slot list +# Change the slot type, here using slot 8 for a MFC 1k emulation +hw slot type -s 8 -t MIFARE_1024 +# Init the slot content +hw slot init -s 8 -t MIFARE_1024 +# or load an existing dump and set UID and anticollision data, +# cf 'hf mf eload' and 'hf mf econfig' +# Enable the slot +hw slot enable -s 8 --hf +# Change to the new slot +hw slot change -s 8 +# Activate the authentication logs +hf mf econfig --enable-log +``` Now disconnect, go to a reader and swipe it a few times -- Come back and connect to the CLI: `hw connect` -- See if nonces were collected: `hf mf elog` - - We need 2 nonces per key to recover -- Recover the key(s) based on the collected nonces: `hf mf elog --decrypt`. +Come back + +```sh +# connect to the CLI +hw connect +# See if nonces were collected. We need 2 nonces per key to recover +hf mf elog +# Recover the key(s) based on the collected nonces +hf mf elog --decrypt +# Clean the logged detection nonces +hf mf econfig --disable-log +``` Output example: ``` - MF1 detection log count = 6, start download. @@ -178,8 +199,5 @@ Now disconnect, go to a reader and swipe it a few times ``` -- To clean the logged detection nonces: `hf mf econfig --disable-log` then `hf mf econfig --enable-log` - - *More examples coming soon* From 82fcc76286575822573039659d7c10f40fa2cd8d Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Tue, 17 Oct 2023 21:25:16 +0200 Subject: [PATCH 2/7] Changed battery level curves based on experimental measures, thanks @spp2000 ! --- CHANGELOG.md | 3 +- firmware/application/src/ble_main.c | 53 +++++++++-------------------- 2 files changed, 19 insertions(+), 37 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0b1bffc..520f252 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,8 @@ All notable changes to this project will be documented in this file. This project uses the changelog in accordance with [keepchangelog](http://keepachangelog.com/). Please use this to write notable changes, which is not the same as git commit log... ## [unreleased][unreleased] - - Nested and StaticNested multithreaded decryption. + - Changed battery level curves based on experimental measures (@spp2000) + - Added multithreading on Nested and StaticNested (@xianglin1998) - Fixed factory reset hanging (@augustozanellato) - Changed fds_write_sync to take length in bytes instead of next multiple of 4 (@doegox) - Fixed field LED when LF reading and HF cloning (@doegox) diff --git a/firmware/application/src/ble_main.c b/firmware/application/src/ble_main.c index 79cfb7e..44346b0 100644 --- a/firmware/application/src/ble_main.c +++ b/firmware/application/src/ble_main.c @@ -226,44 +226,25 @@ __INLINE uint32_t map(uint32_t x, uint32_t in_min, uint32_t in_max, uint32_t out //Battery voltage to percentage calculation uint32_t BATVOL2PERCENT(uint16_t VOL) { - //100% 4.20V 1 - //90 % 4.06V 80%-100% white - //80 % 3.98V 1 - //70 % 3.92V 60%-80% white - //60 % 3.87V 1 - //50 % 3.82V 40%-60% white - //40 % 3.79V 1 - //30 % 3.77V 20%-40% white - //20 % 3.74V 1 - //10 % 3.68V 5%-20% red - //5 % 3.45V 1 Turn off - //0 % 3.00V - //#define P100VOL 4200 - //#define P80VOL 3980 - //#define P60VOL 3870 - //#define P40VOL 3790 - //#define P20VOL 3740 - //#define P5VOL 3450 + // Based on https://github.com/RfidResearchGroup/ChameleonUltra/issues/167#issuecomment-1766908799 - //100% 4.20V 1 - //90 % 4.00V 80%-100% white - //80 % 3.89V 1 - //70 % 3.79V 60%-80% white - //60 % 3.70V 1 - //50 % 3.62V 40%-60% white - //40 % 3.57V 1 - //30 % 3.53V 20%-40% white - //20 % 3.51V 1 - //10 % 3.46V 5%-20% red - //5 % 3.43V 1 Turn off - //0 % 3.00V +#if defined(PROJECT_CHAMELEON_ULTRA) +// Ultra #define P100VOL 4200 -#define P80VOL 3890 -#define P60VOL 3700 -#define P40VOL 3570 -#define P20VOL 3510 -#define P5VOL 3230 - +#define P80VOL 4034 +#define P60VOL 3904 +#define P40VOL 3824 +#define P20VOL 3754 +#define P5VOL 3644 +#else +// Lite +#define P100VOL 4200 +#define P80VOL 3934 +#define P60VOL 3844 +#define P40VOL 3784 +#define P20VOL 3744 +#define P5VOL 3644 +#endif if (VOL > P80VOL) { //80-100 From 2beb8f74a3fcb2034183b4a56c2dceef9b1d138f Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Tue, 17 Oct 2023 22:08:34 +0200 Subject: [PATCH 3/7] cli: check if helper tools are available --- software/script/chameleon_cli_main.py | 1 + software/script/chameleon_cli_unit.py | 15 ++++++++++++--- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/software/script/chameleon_cli_main.py b/software/script/chameleon_cli_main.py index beec263..337ca14 100755 --- a/software/script/chameleon_cli_main.py +++ b/software/script/chameleon_cli_main.py @@ -94,6 +94,7 @@ class ChameleonCLI: raise Exception("This script requires at least Python 3.9") self.print_banner() + chameleon_cli_unit.check_tools() cmd_strs = [] while True: if cmd_strs: diff --git a/software/script/chameleon_cli_unit.py b/software/script/chameleon_cli_unit.py index ec6b5b4..3c7f795 100644 --- a/software/script/chameleon_cli_unit.py +++ b/software/script/chameleon_cli_unit.py @@ -37,12 +37,21 @@ type_id_SAK_dict = {0x00: "MIFARE Ultralight Classic/C/EV1/Nano | NTAG 2xx", 0x38: "SmartMX with MIFARE Classic 4K", } -if getattr(sys, 'frozen', False): +if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'): # in pyinstaller - default_cwd = str(Path(sys._MEIPASS) / "bin") + default_cwd = Path.cwd() / Path(sys._MEIPASS) / "bin" else: # from source - default_cwd = str(Path(__file__).parent.parent / "bin") + default_cwd = Path.cwd() / Path(__file__).parent.parent / "bin" + + +def check_tools(): + tools = ['staticnested', 'nested', 'darkside', 'mfkey32v2'] + if sys.platform == "win32": + tools = [x+'.exe' for x in tools] + missing_tools = [tool for tool in tools if not (default_cwd / tool).exists()] + if len(missing_tools) > 0: + print(f'{CR}Warning, tools {", ".join(missing_tools)} not found. Corresponding commands will not work as intended.{C0}') class BaseCLIUnit: From cb1878440d2e7c72dac3e974a4747e23b6de8e13 Mon Sep 17 00:00:00 2001 From: Augusto Zanellato Date: Tue, 17 Oct 2023 23:32:51 +0200 Subject: [PATCH 4/7] Fix ATS handling in tags that NAK RATS pcd_14a_reader_ats_request didn't check for NAK so in case the tag NAKd the RATS it would return a zero length ATS which would cause an underflow in pcd_14a_reader_scan_once, that in turn resulted in HF_ERR_ATS being returned due to an invalid ATS length. --- CHANGELOG.md | 1 + .../application/src/rfid/reader/hf/rc522.c | 32 +++++++++++-------- 2 files changed, 20 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 520f252..1e89069 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ All notable changes to this project will be documented in this file. This project uses the changelog in accordance with [keepchangelog](http://keepachangelog.com/). Please use this to write notable changes, which is not the same as git commit log... ## [unreleased][unreleased] + - Fixed ATS handling in tags that NAK RATS (@augustozanellato) - Changed battery level curves based on experimental measures (@spp2000) - Added multithreading on Nested and StaticNested (@xianglin1998) - Fixed factory reset hanging (@augustozanellato) diff --git a/firmware/application/src/rfid/reader/hf/rc522.c b/firmware/application/src/rfid/reader/hf/rc522.c index 6a6bf49..94011b3 100644 --- a/firmware/application/src/rfid/reader/hf/rc522.c +++ b/firmware/application/src/rfid/reader/hf/rc522.c @@ -645,20 +645,23 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { // Tag supports 14443-4, sending RATS uint16_t ats_size; status = pcd_14a_reader_ats_request(tag->ats, &ats_size, 0xFF * 8); - ats_size -= 2; // size returned by pcd_14a_reader_ats_request includes CRC - if (ats_size > 254) { - NRF_LOG_INFO("Invalid ATS > 254!"); - return HF_ERR_ATS; - } - tag->ats_len = ats_size; - // We do not validate ATS here as we want to report ATS as it is without breaking 14a scan - if (tag->ats[0] != ats_size - 1) { - NRF_LOG_INFO("Invalid ATS! First byte doesn't match received length"); - // return HF_ERR_ATS; - } + NRF_LOG_INFO("ats status %d, length %d", status, ats_size); if (status != HF_TAG_OK) { NRF_LOG_INFO("Tag SAK claimed to support ATS but tag NAKd RATS"); + tag->ats_len = 0; // return HF_ERR_ATS; + } else { + ats_size -= 2; // size returned by pcd_14a_reader_ats_request includes CRC + if (ats_size > 254) { + NRF_LOG_INFO("Invalid ATS > 254!"); + return HF_ERR_ATS; + } + tag->ats_len = ats_size; + // We do not validate ATS here as we want to report ATS as it is without breaking 14a scan + if (tag->ats[0] != ats_size - 1) { + NRF_LOG_INFO("Invalid ATS! First byte doesn't match received length"); + // return HF_ERR_ATS; + } } /* * FIXME: If there is an issue here, it will cause the label to lose its selected state. @@ -706,11 +709,14 @@ uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAt if (status != HF_TAG_OK) { *szAts = 0; - NRF_LOG_INFO("Err at ats receive.\n"); + NRF_LOG_ERROR("ATS rx error: %d", status); return status; + } else if (*szAts == 7 && pAts[0] == 0x4) { // tag replied with NAK + *szAts = 0; + return HF_ERR_ATS; } - // NRF_LOG_INFO("Length: %d\n", *szAts); + NRF_LOG_INFO("Received ATS length: %d\n", *szAts); if (*szAts > 0) { *szAts = *szAts / 8; } return HF_TAG_OK; From aa3fe711afa010aa0ea1246d6860afdc8dadb177 Mon Sep 17 00:00:00 2001 From: Augusto Zanellato Date: Tue, 17 Oct 2023 23:33:19 +0200 Subject: [PATCH 5/7] Fix hf 14a raw always raising AttributeError --- CHANGELOG.md | 1 + software/script/chameleon_cli_unit.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1e89069..45813d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ All notable changes to this project will be documented in this file. This project uses the changelog in accordance with [keepchangelog](http://keepachangelog.com/). Please use this to write notable changes, which is not the same as git commit log... ## [unreleased][unreleased] + - Fixed `hf 14a raw` command raising `AttributeError` (@augustozanellato) - Fixed ATS handling in tags that NAK RATS (@augustozanellato) - Changed battery level curves based on experimental measures (@spp2000) - Added multithreading on Nested and StaticNested (@xianglin1998) diff --git a/software/script/chameleon_cli_unit.py b/software/script/chameleon_cli_unit.py index 3c7f795..26476ff 100644 --- a/software/script/chameleon_cli_unit.py +++ b/software/script/chameleon_cli_unit.py @@ -2046,7 +2046,7 @@ examples/notes: def on_exec(self, args: argparse.Namespace): options = { 'activate_rf_field': self.bool_to_bit(args.activate_rf), - 'wait_response': self.bool_to_bit(not args.response), + 'wait_response': self.bool_to_bit(not args.no_response), 'append_crc': self.bool_to_bit(args.crc), 'auto_select': self.bool_to_bit(args.select_tag), 'keep_rf_field': self.bool_to_bit(args.keep_rf), From fa0754aed2b5473ed0c334b4e2067a6d4a783f1c Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Tue, 17 Oct 2023 23:43:25 +0200 Subject: [PATCH 6/7] cli: make status an enum. rename some status for consistency --- docs/protocol.md | 10 +- firmware/application/src/app_cmd.c | 148 ++++++------- firmware/application/src/app_main.c | 4 +- firmware/application/src/app_status.h | 24 +-- .../src/rfid/reader/hf/mf1_toolbox.c | 152 +++++++------- .../application/src/rfid/reader/hf/rc522.c | 140 ++++++------- .../src/rfid/reader/lf/lf_reader_main.c | 12 +- firmware/application/src/settings.c | 2 +- software/script/chameleon_cli_unit.py | 17 +- software/script/chameleon_cmd.py | 196 +++++++++--------- software/script/chameleon_com.py | 20 +- software/script/chameleon_enum.py | 68 ++++++ software/script/chameleon_status.py | 73 ------- software/script/chameleon_utils.py | 13 +- 14 files changed, 440 insertions(+), 439 deletions(-) delete mode 100644 software/script/chameleon_status.py diff --git a/docs/protocol.md b/docs/protocol.md index 28b8e42..d097ef2 100644 --- a/docs/protocol.md +++ b/docs/protocol.md @@ -50,7 +50,7 @@ E.g. LRC3(DATA) == LRC3(whole frame) Each command and response have their own payload formats. -Standard response status is `STATUS_DEVICE_SUCCESS` for general commands, `HF_TAG_OK` for HF commands and `LF_TAG_OK` for LF commands. +Standard response status is `STATUS_SUCCESS` for general commands, `STATUS_HF_TAG_OK` for HF commands and `STATUS_LF_TAG_OK` for LF commands. See [Guidelines](#new-data-payloads-guidelines-for-developers) for more info. Beware, slots in protocol count from 0 to 7 (and from 1 to 8 in the CLI...). @@ -144,7 +144,7 @@ Notes: the returned string is the output of `git describe --abbrev=7 --dirty --a * CLI: cf `hw slot list` ### 1020: WIPE_FDS * Command: no data -* Response: no data. Status is `STATUS_DEVICE_SUCCESS` or `STATUS_FLASH_WRITE_FAIL`. The device will reboot shortly after this command. +* Response: no data. Status is `STATUS_SUCCESS` or `STATUS_FLASH_WRITE_FAIL`. The device will reboot shortly after this command. * CLI: cf `hw factory_reset` ### 1021: DELETE_SLOT_TAG_NICK * Command: 2 bytes. `slot_number|sense_type` with `slot_number` between 0 and 7 and `sense_type` according to `tag_sense_type_t` enum. @@ -226,7 +226,7 @@ Notes: wait about 5 seconds after wake-up, before querying the battery status, e * CLI: cf `hf 14a scan` Notes: -* remind that if no tag is present, status will be `HF_TAG_NO` and Response empty. +* remind that if no tag is present, status will be `STATUS_HF_TAG_NO` and Response empty. * at the moment, the firmware supports only one tag, but get your client ready for more! * `atslen` must not be confused with `ats[0]`==`TL`. So `atslen|ats` = `00` means no ATS while `0100` would be an empty ATS. ### 2001: MF1_DETECT_SUPPORT @@ -269,7 +269,7 @@ Notes: ### 2007: MF1_AUTH_ONE_KEY_BLOCK * Command: 8 bytes: `type|block|key[6]`. Key as 6 bytes. Type=0x60 for key A, 0x61 for key B. * Response: no data -* Status will be `HF_TAG_OK` if auth succeeded, else `MF_ERR_AUTH` +* Status will be `STATUS_HF_TAG_OK` if auth succeeded, else `STATUS_MF_ERR_AUTH` * CLI: cf `hf mf nested` ### 2008: MF1_READ_ONE_BLOCK * Command: 8 bytes: `type|block|key[6]`. Key as 6 bytes. Type=0x60 for key A, 0x61 for key B. @@ -397,7 +397,7 @@ Be verbose, explicit and reuse conventions, in order to enhance code maintainabi - Avoid hardcoding offsets, use `sizeof()`, `offsetof(struct, field)` in C and `struct.calcsize()` in Python - For complex bitfield structs, exceptionally you can use ctypes in Python. Beware ctypes.BigEndianStructure bitfield will be parsed in the firmware in the reverse order, from LSB to MSB. ### Guideline: Status -If single byte of data to return, still use a 1-byte `data`, not `status`. Standard response status is `STATUS_DEVICE_SUCCESS` for general commands, `HF_TAG_OK` for HF commands and `LF_TAG_OK` for LF commands. If the response status is different than those, the response data is empty. Response status are generic and cover things like tag disappearance or tag non-conformities with the ISO standard. If a command needs more specific response status, it is added in the first byte of the data, to avoid cluttering the 1-byte general status enum with command-specific statuses. See e.g. [MF1_DARKSIDE_ACQUIRE](#2004-mf1_darkside_acquire). +If single byte of data to return, still use a 1-byte `data`, not `status`. Standard response status is `STATUS_SUCCESS` for general commands, `STATUS_HF_TAG_OK` for HF commands and `STATUS_LF_TAG_OK` for LF commands. If the response status is different than those, the response data is empty. Response status are generic and cover things like tag disappearance or tag non-conformities with the ISO standard. If a command needs more specific response status, it is added in the first byte of the data, to avoid cluttering the 1-byte general status enum with command-specific statuses. See e.g. [MF1_DARKSIDE_ACQUIRE](#2004-mf1_darkside_acquire). ### Guideline: unambiguous types - Use unambiguous types such as `uint16_t`, not `int` or `enum`. Cast explicitly `int` and `enum` to `uint_t` of proper size - Use Network byte order for 16b and 32b integers diff --git a/firmware/application/src/app_cmd.c b/firmware/application/src/app_cmd.c index 7998ec9..00e3f54 100644 --- a/firmware/application/src/app_cmd.c +++ b/firmware/application/src/app_cmd.c @@ -39,18 +39,18 @@ static data_frame_tx_t *cmd_processor_get_app_version(uint16_t cmd, uint16_t sta } PACKED payload; payload.version_major = APP_FW_VER_MAJOR; payload.version_minor = APP_FW_VER_MINOR; - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_get_git_version(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, strlen(GIT_VERSION), (uint8_t *)GIT_VERSION); + return data_frame_make(cmd, STATUS_SUCCESS, strlen(GIT_VERSION), (uint8_t *)GIT_VERSION); } static data_frame_tx_t *cmd_processor_get_device_model(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t resp_data = hw_get_device_type(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(resp_data), &resp_data); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(resp_data), &resp_data); } @@ -62,7 +62,7 @@ static data_frame_tx_t *cmd_processor_change_device_mode(uint16_t cmd, uint16_t if (data[0] == 1) { #if defined(PROJECT_CHAMELEON_ULTRA) reader_mode_enter(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); #else return data_frame_make(cmd, STATUS_NOT_IMPLEMENTED, 0, NULL); #endif @@ -70,13 +70,13 @@ static data_frame_tx_t *cmd_processor_change_device_mode(uint16_t cmd, uint16_t #if defined(PROJECT_CHAMELEON_ULTRA) tag_mode_enter(); #endif - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } } static data_frame_tx_t *cmd_processor_get_device_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t resp_data = (get_device_mode() == DEVICE_MODE_READER); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(resp_data), &resp_data); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(resp_data), &resp_data); } static data_frame_tx_t *cmd_processor_enter_bootloader(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -90,7 +90,7 @@ static data_frame_tx_t *cmd_processor_enter_bootloader(uint16_t cmd, uint16_t st // Never into here... while (1) __NOP(); // For the compiler to be happy... - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_device_chip_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -100,7 +100,7 @@ static data_frame_tx_t *cmd_processor_get_device_chip_id(uint16_t cmd, uint16_t } PACKED payload; payload.chip_LSW = U32HTONL(NRF_FICR->DEVICEID[0]); payload.chip_HSW = U32HTONL(NRF_FICR->DEVICEID[1]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_get_device_address(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -115,7 +115,7 @@ static data_frame_tx_t *cmd_processor_get_device_address(uint16_t cmd, uint16_t } PACKED payload; payload.device_address_LSW = U32HTONL(NRF_FICR->DEVICEADDR[0]); payload.device_address_HSW = U16HTONS(NRF_FICR->DEVICEADDR[1] | 0xC000); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_save_settings(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -139,7 +139,7 @@ static data_frame_tx_t *cmd_processor_get_device_settings(uint16_t cmd, uint16_t settings[5] = settings_get_long_button_press_config('B'); // long B button press mode settings[6] = settings_get_ble_pairing_enable(); // is device require pairing memcpy(settings + 7, settings_get_ble_connect_key(), BLE_PAIRING_KEY_LEN); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 7 + BLE_PAIRING_KEY_LEN, settings); + return data_frame_make(cmd, STATUS_SUCCESS, 7 + BLE_PAIRING_KEY_LEN, settings); } static data_frame_tx_t *cmd_processor_set_animation_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -147,12 +147,12 @@ static data_frame_tx_t *cmd_processor_set_animation_mode(uint16_t cmd, uint16_t return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } settings_set_animation_config(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_animation_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t animation_mode = settings_get_animation_config(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &animation_mode); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &animation_mode); } static data_frame_tx_t *cmd_processor_get_battery_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -162,7 +162,7 @@ static data_frame_tx_t *cmd_processor_get_battery_info(uint16_t cmd, uint16_t st } PACKED payload; payload.voltage = U16HTONS(batt_lvl_in_milli_volts); payload.percent = percentage_batt_lvl; - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_get_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -170,7 +170,7 @@ static data_frame_tx_t *cmd_processor_get_button_press_config(uint16_t cmd, uint return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } uint8_t button_press_config = settings_get_button_press_config(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(button_press_config), &button_press_config); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(button_press_config), &button_press_config); } static data_frame_tx_t *cmd_processor_set_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -178,7 +178,7 @@ static data_frame_tx_t *cmd_processor_set_button_press_config(uint16_t cmd, uint return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } settings_set_button_press_config(data[0], data[1]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_long_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -186,7 +186,7 @@ static data_frame_tx_t *cmd_processor_get_long_button_press_config(uint16_t cmd, return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } uint8_t button_press_config = settings_get_long_button_press_config(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(button_press_config), &button_press_config); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(button_press_config), &button_press_config); } static data_frame_tx_t *cmd_processor_set_long_button_press_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -194,12 +194,12 @@ static data_frame_tx_t *cmd_processor_set_long_button_press_config(uint16_t cmd, return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } settings_set_long_button_press_config(data[0], data[1]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_ble_pairing_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t is_enable = settings_get_ble_pairing_enable(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &is_enable); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &is_enable); } static data_frame_tx_t *cmd_processor_set_ble_pairing_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -207,7 +207,7 @@ static data_frame_tx_t *cmd_processor_set_ble_pairing_enable(uint16_t cmd, uint1 return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } settings_set_ble_pairing_enable(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } #if defined(PROJECT_CHAMELEON_ULTRA) @@ -215,7 +215,7 @@ static data_frame_tx_t *cmd_processor_set_ble_pairing_enable(uint16_t cmd, uint1 static data_frame_tx_t *cmd_processor_hf14a_scan(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { picc_14a_tag_t taginfo; status = pcd_14a_reader_scan_auto(&taginfo); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } // uidlen[1]|uid[uidlen]|atqa[2]|sak[1]|atslen[1]|ats[atslen] @@ -231,7 +231,7 @@ static data_frame_tx_t *cmd_processor_hf14a_scan(uint16_t cmd, uint16_t status, payload[offset++] = taginfo.ats_len; memcpy(&payload[offset], taginfo.ats, taginfo.ats_len); offset += taginfo.ats_len; - return data_frame_make(cmd, HF_TAG_OK, offset, payload); + return data_frame_make(cmd, STATUS_HF_TAG_OK, offset, payload); } static data_frame_tx_t *cmd_processor_mf1_detect_support(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -242,10 +242,10 @@ static data_frame_tx_t *cmd_processor_mf1_detect_support(uint16_t cmd, uint16_t static data_frame_tx_t *cmd_processor_mf1_detect_prng(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t type; status = check_prng_type((mf1_prng_type_t *)&type); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } - return data_frame_make(cmd, HF_TAG_OK, sizeof(type), &type); + return data_frame_make(cmd, STATUS_HF_TAG_OK, sizeof(type), &type); } // We have a reusable payload structure. @@ -265,11 +265,11 @@ static data_frame_tx_t *cmd_processor_mf1_static_nested_acquire(uint16_t cmd, ui nested_common_payload_t *payload = (nested_common_payload_t *)data; status = static_nested_recover_key(bytes_to_num(payload->key_known, 6), payload->block_known, payload->type_known, payload->block_target, payload->type_target, &sncs); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } // mf1_static_nested_core_t is PACKED and comprises only bytes so we can use it directly - return data_frame_make(cmd, HF_TAG_OK, sizeof(sncs), (uint8_t *)(&sncs)); + return data_frame_make(cmd, STATUS_HF_TAG_OK, sizeof(sncs), (uint8_t *)(&sncs)); } static data_frame_tx_t *cmd_processor_mf1_darkside_acquire(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -282,13 +282,13 @@ static data_frame_tx_t *cmd_processor_mf1_darkside_acquire(uint16_t cmd, uint16_ DarksideCore_t dc; } PACKED payload; status = darkside_recover_key(data[1], data[0], data[2], data[3], &payload.dc, (mf1_darkside_status_t *)&payload.darkside_status); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } if (payload.darkside_status != DARKSIDE_OK) { - return data_frame_make(cmd, HF_TAG_OK, sizeof(payload.darkside_status), &payload.darkside_status); + return data_frame_make(cmd, STATUS_HF_TAG_OK, sizeof(payload.darkside_status), &payload.darkside_status); } - return data_frame_make(cmd, HF_TAG_OK, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_HF_TAG_OK, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_mf1_detect_nt_dist(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -309,11 +309,11 @@ static data_frame_tx_t *cmd_processor_mf1_detect_nt_dist(uint16_t cmd, uint16_t payload_t *payload = (payload_t *)data; uint32_t distance; status = nested_distance_detect(payload->block_known, payload->type_known, payload->key_known, payload_resp.uid, &distance); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } payload_resp.distance = U32HTONL(distance); - return data_frame_make(cmd, HF_TAG_OK, sizeof(payload_resp), (uint8_t *)&payload_resp); + return data_frame_make(cmd, STATUS_HF_TAG_OK, sizeof(payload_resp), (uint8_t *)&payload_resp); } static data_frame_tx_t *cmd_processor_mf1_nested_acquire(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -324,11 +324,11 @@ static data_frame_tx_t *cmd_processor_mf1_nested_acquire(uint16_t cmd, uint16_t nested_common_payload_t *payload = (nested_common_payload_t *)data; status = nested_recover_key(bytes_to_num(payload->key_known, 6), payload->block_known, payload->type_known, payload->block_target, payload->type_target, ncs); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } // mf1_nested_core_t is PACKED and comprises only bytes so we can use it directly - return data_frame_make(cmd, HF_TAG_OK, sizeof(ncs), (uint8_t *)(&ncs)); + return data_frame_make(cmd, STATUS_HF_TAG_OK, sizeof(ncs), (uint8_t *)(&ncs)); } static data_frame_tx_t *cmd_processor_mf1_auth_one_key_block(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -360,11 +360,11 @@ static data_frame_tx_t *cmd_processor_mf1_read_one_block(uint16_t cmd, uint16_t payload_t *payload = (payload_t *)data; uint8_t block[16] = { 0x00 }; status = auth_key_use_522_hw(payload->block, payload->type, payload->key); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } status = pcd_14a_reader_mf1_read(payload->block, block); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } return data_frame_make(cmd, status, sizeof(block), block); @@ -383,7 +383,7 @@ static data_frame_tx_t *cmd_processor_mf1_write_one_block(uint16_t cmd, uint16_t payload_t *payload = (payload_t *)data; status = auth_key_use_522_hw(payload->block, payload->type, payload->key); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } status = pcd_14a_reader_mf1_write(payload->block, payload->block_data); @@ -450,10 +450,10 @@ static data_frame_tx_t *cmd_processor_hf14a_raw(uint16_t cmd, uint16_t status, u static data_frame_tx_t *cmd_processor_em410x_scan(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t id_buffer[5] = { 0x00 }; status = PcdScanEM410X(id_buffer); - if (status != LF_TAG_OK) { + if (status != STATUS_LF_TAG_OK) { return data_frame_make(cmd, status, 0, NULL); } - return data_frame_make(cmd, LF_TAG_OK, sizeof(id_buffer), id_buffer); + return data_frame_make(cmd, STATUS_LF_TAG_OK, sizeof(id_buffer), id_buffer); } static data_frame_tx_t *cmd_processor_em410x_write_to_t55XX(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -479,7 +479,7 @@ static data_frame_tx_t *cmd_processor_set_active_slot(uint16_t cmd, uint16_t sta return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } change_slot_auto(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_set_slot_tag_type(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -497,7 +497,7 @@ static data_frame_tx_t *cmd_processor_set_slot_tag_type(uint16_t cmd, uint16_t s return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } tag_emulation_change_type(payload->num_slot, tag_type); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_delete_slot_sense_type(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -513,7 +513,7 @@ static data_frame_tx_t *cmd_processor_delete_slot_sense_type(uint16_t cmd, uint1 } tag_emulation_delete_data(payload->num_slot, payload->sense_type); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_set_slot_data_default(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -530,7 +530,7 @@ static data_frame_tx_t *cmd_processor_set_slot_data_default(uint16_t cmd, uint16 if (payload->num_slot >= TAG_MAX_SLOT_NUM || !is_tag_specific_type_valid(tag_type)) { return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } - status = tag_emulation_factory_data(payload->num_slot, tag_type) ? STATUS_DEVICE_SUCCESS : STATUS_NOT_IMPLEMENTED; + status = tag_emulation_factory_data(payload->num_slot, tag_type) ? STATUS_SUCCESS : STATUS_NOT_IMPLEMENTED; return data_frame_make(cmd, status, 0, NULL); } @@ -562,17 +562,17 @@ static data_frame_tx_t *cmd_processor_set_slot_enable(uint16_t cmd, uint16_t sta change_slot_auto(slot_prev); } } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_slot_data_config_save(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { tag_emulation_save(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_active_slot(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t slot = tag_emulation_get_slot(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &slot); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &slot); } static data_frame_tx_t *cmd_processor_get_slot_info(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -588,12 +588,12 @@ static data_frame_tx_t *cmd_processor_get_slot_info(uint16_t cmd, uint16_t statu payload[slot].lf_tag_type = U16HTONS(tag_types.tag_lf); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_wipe_fds(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { bool success = fds_wipe(); - status = success ? STATUS_DEVICE_SUCCESS : STATUS_FLASH_WRITE_FAIL; + status = success ? STATUS_SUCCESS : STATUS_FLASH_WRITE_FAIL; delayed_reset(50); return data_frame_make(cmd, status, 0, NULL); } @@ -605,7 +605,7 @@ static data_frame_tx_t *cmd_processor_em410x_set_emu_id(uint16_t cmd, uint16_t s tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); memcpy(buffer->buffer, data, LF_EM410X_TAG_ID_SIZE); tag_emulation_load_by_buffer(TAG_TYPE_EM410X, false); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_em410x_get_emu_id(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -617,14 +617,14 @@ static data_frame_tx_t *cmd_processor_em410x_get_emu_id(uint16_t cmd, uint16_t s tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); uint8_t responseData[LF_EM410X_TAG_ID_SIZE]; memcpy(responseData, buffer->buffer, LF_EM410X_TAG_ID_SIZE); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, LF_EM410X_TAG_ID_SIZE, responseData); + return data_frame_make(cmd, STATUS_SUCCESS, LF_EM410X_TAG_ID_SIZE, responseData); } static data_frame_tx_t *cmd_processor_hf14a_get_anti_coll_data(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { tag_slot_specific_type_t tag_types; tag_emulation_get_specific_types_by_slot(tag_emulation_get_slot(), &tag_types); if (tag_types.tag_hf == TAG_TYPE_UNDEFINED) { - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); // no data in slot, don't send garbage + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); // no data in slot, don't send garbage } nfc_tag_14a_coll_res_reference_t *info = get_saved_mifare_coll_res(); // uidlen[1]|uid[uidlen]|atqa[2]|sak[1]|atslen[1]|ats[atslen] @@ -644,7 +644,7 @@ static data_frame_tx_t *cmd_processor_hf14a_get_anti_coll_data(uint16_t cmd, uin } else { payload[offset++] = 0; } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, offset, payload); + return data_frame_make(cmd, STATUS_SUCCESS, offset, payload); } static data_frame_tx_t *cmd_processor_mf1_set_detection_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -653,12 +653,12 @@ static data_frame_tx_t *cmd_processor_mf1_set_detection_enable(uint16_t cmd, uin } nfc_tag_mf1_detection_log_clear(); nfc_tag_mf1_set_detection_enable(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_mf1_get_detection_enable(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t is_enable = nfc_tag_mf1_is_detection_enable(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, (uint8_t *)(&is_enable)); + return data_frame_make(cmd, STATUS_SUCCESS, 1, (uint8_t *)(&is_enable)); } static data_frame_tx_t *cmd_processor_mf1_get_detection_count(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -667,7 +667,7 @@ static data_frame_tx_t *cmd_processor_mf1_get_detection_count(uint16_t cmd, uint count = 0; } uint32_t payload = U32HTONL(count); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(uint32_t), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(uint32_t), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_mf1_get_detection_log(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -685,7 +685,7 @@ static data_frame_tx_t *cmd_processor_mf1_get_detection_log(uint16_t cmd, uint16 } resp = (uint8_t *)(logs + index); length = MIN(count - index, NETDATA_MAX_DATA_LENGTH / sizeof(nfc_tag_mf1_auth_log_t)) * sizeof(nfc_tag_mf1_auth_log_t); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, length, resp); + return data_frame_make(cmd, STATUS_SUCCESS, length, resp); } static data_frame_tx_t *cmd_processor_mf1_write_emu_block_data(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -703,7 +703,7 @@ static data_frame_tx_t *cmd_processor_mf1_write_emu_block_data(uint16_t cmd, uin uint8_t *p_block = &data[i]; memcpy(info->memory[j], p_block, NFC_TAG_MF1_DATA_SIZE); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_mf1_read_emu_block_data(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -719,7 +719,7 @@ static data_frame_tx_t *cmd_processor_mf1_read_emu_block_data(uint16_t cmd, uint for (int i = 0, j = block_index; i < result_length; i += NFC_TAG_MF1_DATA_SIZE, j++) { memcpy(&result_buffer[i], info->memory[j], NFC_TAG_MF1_DATA_SIZE); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, result_length, result_buffer); + return data_frame_make(cmd, STATUS_SUCCESS, result_length, result_buffer); } static data_frame_tx_t *cmd_processor_hf14a_set_anti_coll_data(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -745,7 +745,7 @@ static data_frame_tx_t *cmd_processor_hf14a_set_anti_coll_data(uint16_t cmd, uin offset ++; memcpy(info->ats->data, &data[offset], info->ats->length); offset += info->ats->length; - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_set_slot_tag_nick(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -768,7 +768,7 @@ static data_frame_tx_t *cmd_processor_set_slot_tag_nick(uint16_t cmd, uint16_t s if (!ret) { return data_frame_make(cmd, STATUS_FLASH_WRITE_FAIL, 0, NULL); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_slot_tag_nick(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -789,7 +789,7 @@ static data_frame_tx_t *cmd_processor_get_slot_tag_nick(uint16_t cmd, uint16_t s if (!ret) { return data_frame_make(cmd, STATUS_FLASH_READ_FAIL, 0, NULL); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, buffer[0], &buffer[1]); + return data_frame_make(cmd, STATUS_SUCCESS, buffer[0], &buffer[1]); } static data_frame_tx_t *cmd_processor_delete_slot_tag_nick(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -808,7 +808,7 @@ static data_frame_tx_t *cmd_processor_delete_slot_tag_nick(uint16_t cmd, uint16_ if (!ret) { return data_frame_make(cmd, STATUS_FLASH_WRITE_FAIL, 0, NULL); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_mf1_get_emulator_config(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -818,12 +818,12 @@ static data_frame_tx_t *cmd_processor_mf1_get_emulator_config(uint16_t cmd, uint mf1_info[2] = nfc_tag_mf1_is_gen2_magic_mode(); mf1_info[3] = nfc_tag_mf1_is_use_mf1_coll_res(); mf1_info[4] = nfc_tag_mf1_get_write_mode(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 5, mf1_info); + return data_frame_make(cmd, STATUS_SUCCESS, 5, mf1_info); } static data_frame_tx_t *cmd_processor_mf1_get_gen1a_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t mode = nfc_tag_mf1_is_gen1a_magic_mode(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &mode); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &mode); } static data_frame_tx_t *cmd_processor_mf1_set_gen1a_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -831,12 +831,12 @@ static data_frame_tx_t *cmd_processor_mf1_set_gen1a_mode(uint16_t cmd, uint16_t return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } nfc_tag_mf1_set_gen1a_magic_mode(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_mf1_get_gen2_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t mode = nfc_tag_mf1_is_gen2_magic_mode(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &mode); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &mode); } static data_frame_tx_t *cmd_processor_mf1_set_gen2_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -844,12 +844,12 @@ static data_frame_tx_t *cmd_processor_mf1_set_gen2_mode(uint16_t cmd, uint16_t s return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } nfc_tag_mf1_set_gen2_magic_mode(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_mf1_get_block_anti_coll_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t mode = nfc_tag_mf1_is_use_mf1_coll_res(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &mode); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &mode); } static data_frame_tx_t *cmd_processor_mf1_set_block_anti_coll_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -857,12 +857,12 @@ static data_frame_tx_t *cmd_processor_mf1_set_block_anti_coll_mode(uint16_t cmd, return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } nfc_tag_mf1_set_use_mf1_coll_res(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_mf1_get_write_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { uint8_t mode = nfc_tag_mf1_get_write_mode(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 1, &mode); + return data_frame_make(cmd, STATUS_SUCCESS, 1, &mode); } static data_frame_tx_t *cmd_processor_mf1_set_write_mode(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -870,7 +870,7 @@ static data_frame_tx_t *cmd_processor_mf1_set_write_mode(uint16_t cmd, uint16_t return data_frame_make(cmd, STATUS_PAR_ERR, 0, NULL); } nfc_tag_mf1_set_write_mode(data[0]); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_get_enabled_slots(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -882,11 +882,11 @@ static data_frame_tx_t *cmd_processor_get_enabled_slots(uint16_t cmd, uint16_t s payload[slot].enabled_hf = tag_emulation_slot_is_enabled(slot, TAG_SENSE_HF); payload[slot].enabled_lf = tag_emulation_slot_is_enabled(slot, TAG_SENSE_LF); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, sizeof(payload), (uint8_t *)&payload); + return data_frame_make(cmd, STATUS_SUCCESS, sizeof(payload), (uint8_t *)&payload); } static data_frame_tx_t *cmd_processor_get_ble_connect_key(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, BLE_PAIRING_KEY_LEN, settings_get_ble_connect_key()); + return data_frame_make(cmd, STATUS_SUCCESS, BLE_PAIRING_KEY_LEN, settings_get_ble_connect_key()); } static data_frame_tx_t *cmd_processor_set_ble_connect_key(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { @@ -906,13 +906,13 @@ static data_frame_tx_t *cmd_processor_set_ble_connect_key(uint16_t cmd, uint16_t } // Key is valid, we can update to config settings_set_ble_connect_key(data); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } static data_frame_tx_t *cmd_processor_delete_all_ble_bonds(uint16_t cmd, uint16_t status, uint16_t length, uint8_t *data) { advertising_stop(); delete_bonds_all(); - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, 0, NULL); + return data_frame_make(cmd, STATUS_SUCCESS, 0, NULL); } #if defined(PROJECT_CHAMELEON_ULTRA) @@ -1053,7 +1053,7 @@ data_frame_tx_t *cmd_processor_get_device_capabilities(uint16_t cmd, uint16_t st commands[i] = U16HTONS(m_data_cmd_map[i].cmd); } - return data_frame_make(cmd, STATUS_DEVICE_SUCCESS, count * sizeof(uint16_t), (uint8_t *)commands); + return data_frame_make(cmd, STATUS_SUCCESS, count * sizeof(uint16_t), (uint8_t *)commands); } /** diff --git a/firmware/application/src/app_main.c b/firmware/application/src/app_main.c index 8baca7b..011f4ba 100644 --- a/firmware/application/src/app_main.c +++ b/firmware/application/src/app_main.c @@ -620,7 +620,7 @@ static void btn_fn_copy_ic_uid(void) { case TAG_TYPE_EM410X: status = PcdScanEM410X(id_buffer); - if (status == LF_TAG_OK) { + if (status == STATUS_LF_TAG_OK) { tag_data_buffer_t *buffer = get_buffer_by_tag_type(TAG_TYPE_EM410X); memcpy(buffer->buffer, id_buffer, LF_EM410X_TAG_ID_SIZE); tag_emulation_load_by_buffer(TAG_TYPE_EM410X, false); @@ -680,7 +680,7 @@ static void btn_fn_copy_ic_uid(void) { status = pcd_14a_reader_scan_auto(&tag); pcd_14a_reader_antenna_off(); - if (status == HF_TAG_OK) { + if (status == STATUS_HF_TAG_OK) { // copy uid antres->size = tag.uid_len; memcpy(antres->uid, tag.uid, tag.uid_len); diff --git a/firmware/application/src/app_status.h b/firmware/application/src/app_status.h index 574768d..b0c05f6 100644 --- a/firmware/application/src/app_status.h +++ b/firmware/application/src/app_status.h @@ -5,21 +5,21 @@ ///////////////////////////////////////////////////////////////////// // 14a status ///////////////////////////////////////////////////////////////////// -#define HF_TAG_OK (0x00) // IC card operation successful -#define HF_TAG_NO (0x01) // No IC card found -#define HF_ERR_STAT (0x02) // IC Card communication error -#define HF_ERR_CRC (0x03) // IC Card communication verification error -#define HF_COLLISION (0x04) // IC card conflict -#define HF_ERR_BCC (0x05) // IC card BCC error -#define MF_ERR_AUTH (0x06) // MF card verification failed -#define HF_ERR_PARITY (0x07) // IC card parity error -#define HF_ERR_ATS (0x08) // ATS should be present but card NAKed +#define STATUS_HF_TAG_OK (0x00) // IC card operation successful +#define STATUS_HF_TAG_NO (0x01) // No IC card found +#define STATUS_HF_ERR_STAT (0x02) // IC Card communication error +#define STATUS_HF_ERR_CRC (0x03) // IC Card communication verification error +#define STATUS_HF_COLLISION (0x04) // IC card conflict +#define STATUS_HF_ERR_BCC (0x05) // IC card BCC error +#define STATUS_MF_ERR_AUTH (0x06) // MF card verification failed +#define STATUS_HF_ERR_PARITY (0x07) // IC card parity error +#define STATUS_HF_ERR_ATS (0x08) // ATS should be present but card NAKed ///////////////////////////////////////////////////////////////////// // lf status ///////////////////////////////////////////////////////////////////// -#define LF_TAG_OK (0x40) // Some of the low -frequency cards are successful! -#define EM410X_TAG_NO_FOUND (0x41) // Can't search for valid EM410X tags +#define STATUS_LF_TAG_OK (0x40) // Some of the low -frequency cards are successful! +#define STATUS_EM410X_TAG_NO_FOUND (0x41) // Can't search for valid EM410X tags ///////////////////////////////////////////////////////////////////// @@ -28,7 +28,7 @@ #define STATUS_PAR_ERR (0x60) // The parameter errors transferred by the BLE instruction, or call the parameter error transmitted by certain functions #define STATUS_DEVICE_MODE_ERROR (0x66) // The mode of the current device is wrong, and the corresponding API cannot be called #define STATUS_INVALID_CMD (0x67) // Invalid instruction -#define STATUS_DEVICE_SUCCESS (0x68) // Device -related operations successfully executed +#define STATUS_SUCCESS (0x68) // Device -related operations successfully executed #define STATUS_NOT_IMPLEMENTED (0x69) // Calling some unrealized operations, which belongs to the missed error of the developer #define STATUS_FLASH_WRITE_FAIL (0x70) // Flash writing failed #define STATUS_FLASH_READ_FAIL (0x71) // Flash read failed diff --git a/firmware/application/src/rfid/reader/hf/mf1_toolbox.c b/firmware/application/src/rfid/reader/hf/mf1_toolbox.c index d682072..f82b742 100644 --- a/firmware/application/src/rfid/reader/hf/mf1_toolbox.c +++ b/firmware/application/src/rfid/reader/hf/mf1_toolbox.c @@ -138,7 +138,7 @@ static uint8_t send_cmd(struct Crypto1State *pcs, uint8_t encrypted, uint8_t cmd } // There is a problem with communication, do not continue the next task - if (*status != HF_TAG_OK) { + if (*status != STATUS_HF_TAG_OK) { return len; } @@ -184,7 +184,7 @@ int authex(struct Crypto1State *pcs, uint32_t uid, uint8_t blockNo, uint8_t keyT len = send_cmd(pcs, isNested, keyType, blockNo, &status, answer, parity, U8ARR_BIT_LEN(answer)); if (len != 32) { NRF_LOG_INFO("No 32 data recv on send_cmd: %d\r\n", len); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // Save the tag nonce (nt) @@ -232,15 +232,15 @@ int authex(struct Crypto1State *pcs, uint32_t uid, uint8_t blockNo, uint8_t keyT ntpp = prng_successor(nt, 32) ^ crypto1_word(pcs, 0, 0); if (ntpp == BYTES4_TO_U32(answer)) { // Successful verification! - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } else { // fail - return MF_ERR_AUTH; + return STATUS_MF_ERR_AUTH; } } // fail! - return MF_ERR_AUTH; + return STATUS_MF_ERR_AUTH; } /** @@ -279,15 +279,15 @@ static uint8_t darkside_select_nonces(picc_14a_tag_t *tag, uint8_t block, uint8_ // 2. Moderate power -off time, don't be too long, it will affect efficiency, and don't be too short. reset_radio_field_with_delay(); // After the power is completely disconnected, we will select the card quickly and compress the verification time as much as possible. - if (pcd_14a_reader_fast_select(tag) != HF_TAG_OK) { + if (pcd_14a_reader_fast_select(tag) != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Tag can't select!\n"); - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, tag_auth, 4, tag_resp, &len, U8ARR_BIT_LEN(tag_resp)); // After finding the card, start collecting random numbers - if (status != HF_TAG_OK || len != 32) { + if (status != STATUS_HF_TAG_OK || len != 32) { NRF_LOG_INFO("Get nt failed.\n"); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // Converted to the type of U32 and cache nt_list[i] = bytes_to_num(tag_resp, 4); @@ -321,14 +321,14 @@ static uint8_t darkside_select_nonces(picc_14a_tag_t *tag, uint8_t block, uint8_ if (max == 0) { NRF_LOG_INFO("Can't sync nt.\n"); *darkside_status = DARKSIDE_CANT_FIX_NT; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // NT is fixed successfully, the one with the highest number of times we take out // NRF_LOG_INFO("Sync nt: %"PRIu32", max = %d\n", nt_list[m], max); if (nt) *nt = nt_list[m]; // Only when the caller needs to get NT *darkside_status = DARKSIDE_OK; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -374,10 +374,10 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, bool led_toggle = false; // We need to confirm the use of a certain card first - if (pcd_14a_reader_scan_auto(p_tag_info) == HF_TAG_OK) { + if (pcd_14a_reader_scan_auto(p_tag_info) == STATUS_HF_TAG_OK) { uid_cur = get_u32_tag_uid(p_tag_info); } else { - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } // Verification instructions need to add CRC16 @@ -401,7 +401,7 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, // Then you need to fix a random number that may appear status = darkside_select_nonces(p_tag_info, targetBlk, targetTyp, &nt_ori, darkside_status); - if ((status != HF_TAG_OK) || (*darkside_status != DARKSIDE_OK)) { + if ((status != STATUS_HF_TAG_OK) || (*darkside_status != DARKSIDE_OK)) { //The fixed random number failed, and the next step cannot be performed return status; } @@ -414,7 +414,7 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, if (uid_ori != uid_cur) { *darkside_status = DARKSIDE_TAG_CHANGED; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } } // Always collect different NACK under a large cycle @@ -437,17 +437,17 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, reset_radio_field_with_delay(); //After the power is completely disconnected, we will select the card quickly and compress the verification time as much as possible. - if (pcd_14a_reader_fast_select(p_tag_info) != HF_TAG_OK) { + if (pcd_14a_reader_fast_select(p_tag_info) != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Tag can't select!\n"); - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, tag_auth, 4, dat_recv, &len, U8ARR_BIT_LEN(dat_recv)); // After finding the card, start collecting random numbers - if (status != HF_TAG_OK || len != 32) { + if (status != STATUS_HF_TAG_OK || len != 32) { NRF_LOG_INFO("Get nt failed.\n"); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } //The byte array of the conversion response is 10 in NT @@ -462,7 +462,7 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, if (++resync_count == ntSyncMax) { NRF_LOG_INFO("Can't fix nonce."); *darkside_status = DARKSIDE_CANT_FIX_NT; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // When the clock is not synchronized, the following operation is meaningless @@ -500,7 +500,7 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, // however we dont feed key w uid it the prng.. NRF_LOG_INFO("Auth Ok, you are so lucky!\n"); *darkside_status = DARKSIDE_LUCKY_AUTH_OK; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // Receive answer. This will be a 4 Bit NACK when the 8 parity bits are OK after decoding @@ -529,7 +529,7 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, if (par == 0) { // tried all 256 possible parities without success. Card doesn't send NACK. NRF_LOG_INFO("Card doesn't send NACK.\r\n"); *darkside_status = DARKSIDE_NO_NAK_SENT; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } } else { par = ((par + 1) & 0x1F) | par_low; @@ -555,7 +555,7 @@ uint8_t darkside_recover_key(uint8_t targetBlk, uint8_t targetTyp, // NRF_LOG_INFO("Darkside done!\n"); *darkside_status = DARKSIDE_OK; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -587,19 +587,19 @@ uint8_t check_tag_response_nt(picc_14a_tag_t *tag, uint32_t *nt) { pcd_14a_reader_halt_tag(); // We will choose a fast card, and we will be compressed to verify as much as possible - if (pcd_14a_reader_fast_select(tag) != HF_TAG_OK) { + if (pcd_14a_reader_fast_select(tag) != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Tag can't select\r\n"); - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } // Send instructions and get NT return *nt = send_cmd(pcs, AUTH_FIRST, PICC_AUTHENT1A, 0x03, &status, dat_recv, par_recv, U8ARR_BIT_LEN(dat_recv)); if (*nt != 32) { // NRF_LOG_INFO("No 32 data recv on send_cmd: %d\n", *nt); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } *nt = bytes_to_num(dat_recv, 4); - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -614,8 +614,8 @@ uint8_t check_std_mifare_nt_support(void) { uint32_t nt1 = 0; // Find card, search on the field - if (pcd_14a_reader_scan_auto(p_tag_info) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_scan_auto(p_tag_info) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } // Get NT and return status @@ -633,13 +633,13 @@ uint8_t check_static_prng(bool *is_static) { uint8_t status; // Find card, search on the field - if (pcd_14a_reader_scan_auto(p_tag_info) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_scan_auto(p_tag_info) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } // Get NT in the first wave status = check_tag_response_nt(p_tag_info, &nt1); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } @@ -650,13 +650,13 @@ uint8_t check_static_prng(bool *is_static) { // Get NT in the second wave status = check_tag_response_nt(p_tag_info, &nt2); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } // Detect whether the random number is static *is_static = (nt1 == nt2); - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -673,12 +673,12 @@ uint8_t check_prng_type(mf1_prng_type_t *prng_type) { // If the judgment process is found, it is found that the StaticNested detection cannot be completed // Then return the state directly, no need to perform the following judgment logic. - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } if (is_static) { *prng_type = PRNG_STATIC; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // Non -Static card, you can continue to run down logic @@ -689,13 +689,13 @@ uint8_t check_prng_type(mf1_prng_type_t *prng_type) { pcd_14a_reader_halt_tag(); // Card search operation - if (pcd_14a_reader_scan_auto(p_tag_info) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_scan_auto(p_tag_info) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } //Get NT, just get it once status = check_tag_response_nt(p_tag_info, &nt1); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } @@ -712,7 +712,7 @@ uint8_t check_prng_type(mf1_prng_type_t *prng_type) { // ------------------------------------ // end - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -785,19 +785,19 @@ static uint8_t measure_distance(uint64_t u64Key, uint8_t block, uint8_t type, ui // Reset card communication pcd_14a_reader_halt_tag(); // We will choose a fast card, and we will be compressed to verify as much as possible - if (pcd_14a_reader_fast_select(p_tag_info) != HF_TAG_OK) { + if (pcd_14a_reader_fast_select(p_tag_info) != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Tag can't select\r\n"); - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } // Perform the first verification in order to obtain the unblocked NT1 - if (authex(pcs, uid, block, type, u64Key, AUTH_FIRST, &nt1) != HF_TAG_OK) { + if (authex(pcs, uid, block, type, u64Key, AUTH_FIRST, &nt1) != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Auth failed 1\r\n"); - return MF_ERR_AUTH; + return STATUS_MF_ERR_AUTH; } // Met the nested verification to obtain the encrypted NT2_ENC - if (authex(pcs, uid, block, type, u64Key, AUTH_NESTED, &nt2) != HF_TAG_OK) { + if (authex(pcs, uid, block, type, u64Key, AUTH_NESTED, &nt2) != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Auth failed 2\r\n"); - return MF_ERR_AUTH; + return STATUS_MF_ERR_AUTH; } // Determine whether the two random numbers are the same, under normal circumstances, // We can't bring the same random number, because PRNG is updating chip at any time @@ -805,7 +805,7 @@ static uint8_t measure_distance(uint64_t u64Key, uint8_t block, uint8_t type, ui if (nt1 == nt2) { NRF_LOG_INFO("StaticNested: %08x vs %08x\n", nt1, nt2); *distance = 0; - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // After the measurement is completed, store in the buffer distances[index++] = measure_nonces(nt1, nt2); @@ -815,7 +815,7 @@ static uint8_t measure_distance(uint64_t u64Key, uint8_t block, uint8_t type, ui //The final calculation of the distance between the two NTs and spread it directly *distance = measure_median(distances, DIST_NR); // You need to return the OK value to successfully log in - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -841,16 +841,16 @@ static uint8_t nested_recover_core(mf1_nested_core_t *pnc, uint64_t keyKnown, ui // Reset card communication pcd_14a_reader_halt_tag(); // Quickly select the card to complete the verification steps to collect NT1 and NT2_ENC - if (pcd_14a_reader_scan_auto(p_tag_info) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_scan_auto(p_tag_info) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } //The first step verification, basic verification does not require nested and encrypted - if (authex(pcs, uid, blkKnown, typKnown, keyKnown, AUTH_FIRST, &nt1) != HF_TAG_OK) { - return MF_ERR_AUTH; + if (authex(pcs, uid, blkKnown, typKnown, keyKnown, AUTH_FIRST, &nt1) != STATUS_HF_TAG_OK) { + return STATUS_MF_ERR_AUTH; } // Then there is nested verification if (send_cmd(pcs, AUTH_NESTED, targetType, targetBlock, &status, answer, parity, U8ARR_BIT_LEN(answer)) != 32) { - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; }; // The first verified explicitly random number num_to_bytes(nt1, 4, pnc->nt1); @@ -861,7 +861,7 @@ static uint8_t nested_recover_core(mf1_nested_core_t *pnc, uint64_t keyKnown, ui pnc->par |= ((oddparity8(answer[0]) != parity[0]) << 0); pnc->par |= ((oddparity8(answer[1]) != parity[1]) << 1); pnc->par |= ((oddparity8(answer[2]) != parity[2]) << 2); - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -872,14 +872,14 @@ static uint8_t nested_recover_core(mf1_nested_core_t *pnc, uint64_t keyKnown, ui * @param :targetBlock : The target sector that requires a Nested attack * @param :targetType : The target key type requires the Nested attack * @param :ncs : Nested core structure array, save related communication data -* @retval :The attack success return HF_TAG_OK, else return the error code +* @retval :The attack success return STATUS_HF_TAG_OK, else return the error code * */ uint8_t nested_recover_key(uint64_t keyKnown, uint8_t blkKnown, uint8_t typKnown, uint8_t targetBlock, uint8_t targetType, mf1_nested_core_t ncs[SETS_NR]) { uint8_t m, res; // all operations must be based on the card res = pcd_14a_reader_scan_auto(p_tag_info); - if (res != HF_TAG_OK) { + if (res != STATUS_HF_TAG_OK) { return res; } //Then collect the specified number of random array @@ -892,11 +892,11 @@ uint8_t nested_recover_key(uint64_t keyKnown, uint8_t blkKnown, uint8_t typKnown targetBlock, targetType ); - if (res != HF_TAG_OK) { + if (res != STATUS_HF_TAG_OK) { return res; } } - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -909,11 +909,11 @@ uint8_t nested_recover_key(uint64_t keyKnown, uint8_t blkKnown, uint8_t typKnown * */ uint8_t nested_distance_detect(uint8_t block, uint8_t type, uint8_t *key, uint8_t *uid, uint32_t *distance) { - uint8_t status = HF_TAG_OK; + uint8_t status = STATUS_HF_TAG_OK; *distance = 0; //Must ensure that there is a card on the court status = pcd_14a_reader_scan_auto(p_tag_info); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } else { // At least the card exists, you can copy the UID to the buffer first @@ -934,7 +934,7 @@ uint8_t nested_distance_detect(uint8_t block, uint8_t type, uint8_t *key, uint8_ * @param :targetBlock : Target sectors that require nested attacks * @param :targetType : Target key types that require nested attacks * @param :nestedAgain : StaticNested enhanced vulnerability, which can obtain two sets of encrypted random numbers based on nested verification of known keys -* @retval : Successfully collected and returned to HF_TAG_OK, otherwise an error code will be returned. +* @retval : Successfully collected and returned to STATUS_HF_TAG_OK, otherwise an error code will be returned. * */ uint8_t static_nested_recover_core(uint8_t *p_nt1, uint8_t *p_nt2, uint64_t keyKnown, uint8_t blkKnown, uint8_t typKnown, uint8_t targetBlock, uint8_t targetType, uint8_t nestedAgain) { @@ -946,28 +946,28 @@ uint8_t static_nested_recover_core(uint8_t *p_nt1, uint8_t *p_nt2, uint64_t keyK uint32_t uid, nt1, nt2; uid = get_u32_tag_uid(p_tag_info); pcd_14a_reader_halt_tag(); - if (pcd_14a_reader_fast_select(p_tag_info) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_fast_select(p_tag_info) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } status = authex(pcs, uid, blkKnown, typKnown, keyKnown, AUTH_FIRST, &nt1); - if (status != HF_TAG_OK) { - return MF_ERR_AUTH; + if (status != STATUS_HF_TAG_OK) { + return STATUS_MF_ERR_AUTH; } if (nestedAgain) { status = authex(pcs, uid, blkKnown, typKnown, keyKnown, AUTH_NESTED, NULL); - if (status != HF_TAG_OK) { - return MF_ERR_AUTH; + if (status != STATUS_HF_TAG_OK) { + return STATUS_MF_ERR_AUTH; } } len = send_cmd(pcs, AUTH_NESTED, targetType, targetBlock, &status, answer, parity, U8ARR_BIT_LEN(answer)); if (len != 32) { NRF_LOG_INFO("No 32 data recv on sendcmd: %d\r\n", len); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } nt2 = bytes_to_num(answer, 4); num_to_bytes(nt1, 4, p_nt1); num_to_bytes(nt2, 4, p_nt2); - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -979,25 +979,25 @@ uint8_t static_nested_recover_core(uint8_t *p_nt1, uint8_t *p_nt2, uint64_t keyK * @param :targetBlock : Target sectors that require nested attacks * @param :targetType : Target key type that require nested attacks * @param :sncs : StaticNested Decrypting Core Structure Array -* @retval : Successfully collected and returned to HF_TAG_OK, otherwise an error code will be returned. +* @retval : Successfully collected and returned to STATUS_HF_TAG_OK, otherwise an error code will be returned. * */ uint8_t static_nested_recover_key(uint64_t keyKnown, uint8_t blkKnown, uint8_t typKnown, uint8_t targetBlock, uint8_t targetType, mf1_static_nested_core_t *sncs) { uint8_t res; res = pcd_14a_reader_scan_auto(p_tag_info); - if (res != HF_TAG_OK) { + if (res != STATUS_HF_TAG_OK) { return res; } get_4byte_tag_uid(p_tag_info, sncs->uid); res = static_nested_recover_core(sncs->core[0].nt1, sncs->core[0].nt2, keyKnown, blkKnown, typKnown, targetBlock, targetType, false); - if (res != HF_TAG_OK) { + if (res != STATUS_HF_TAG_OK) { return res; } res = static_nested_recover_core(sncs->core[1].nt1, sncs->core[1].nt2, keyKnown, blkKnown, typKnown, targetBlock, targetType, true); - if (res != HF_TAG_OK) { + if (res != STATUS_HF_TAG_OK) { return res; } - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -1007,8 +1007,8 @@ uint8_t static_nested_recover_key(uint64_t keyKnown, uint8_t blkKnown, uint8_t t */ uint8_t auth_key_use_522_hw(uint8_t block, uint8_t type, uint8_t *key) { // Each verification of a block must re -find a card - if (pcd_14a_reader_scan_auto(p_tag_info) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_scan_auto(p_tag_info) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } // After finding the card, we start to verify! return pcd_14a_reader_mf1_auth(p_tag_info, type, block, key); diff --git a/firmware/application/src/rfid/reader/hf/rc522.c b/firmware/application/src/rfid/reader/hf/rc522.c index 6a6bf49..9b2d111 100644 --- a/firmware/application/src/rfid/reader/hf/rc522.c +++ b/firmware/application/src/rfid/reader/hf/rc522.c @@ -257,7 +257,7 @@ uint16_t pcd_14a_reader_timeout_get() { * @retval : Status value mi_ok, successful */ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t *pIn, uint8_t InLenByte, uint8_t *pOut, uint16_t *pOutLenBit, uint16_t maxOutLenBit) { - uint8_t status = HF_ERR_STAT; + uint8_t status = STATUS_HF_ERR_STAT; uint8_t waitFor = 0x00; uint8_t lastBits = 0; uint8_t n = 0; @@ -290,7 +290,7 @@ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t *pIn, uint8_t In if (pOut == NULL) { // If the developer does not need to receive data, then return directly after the sending! while ((read_register_single(Status2Reg) & 0x07) == 0x03); - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } bsp_set_timer(g_timeout_auto_timer, 0); // Before starting the operation, return to zero over time counting @@ -316,24 +316,24 @@ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t *pIn, uint8_t In if (pcd_err_val & 0x01) { // ProtocolErr Error only appears in the following two cases: if (Command == PCD_AUTHENT) { // During the execution of the MFAUTHENT command, if the number of bytes received by a data stream, the position of the place // Therefore, we need to deal with it well, assuming that there are problems during the verification process, then we need to think that this is normal - status = MF_ERR_AUTH; + status = STATUS_MF_ERR_AUTH; } else { // If the SOF is wrong, the position is set up and the receiver is automatically cleared during the start -up stage, which is effective at the rate of 106kbd NRF_LOG_INFO("Protocol error\n"); - status = HF_ERR_STAT; + status = STATUS_HF_ERR_STAT; } } else if (pcd_err_val & 0x02) { // Detecting whether there are even strange errors NRF_LOG_INFO("Parity error\n"); - status = HF_ERR_PARITY; + status = STATUS_HF_ERR_PARITY; } else if (pcd_err_val & 0x04) { // Detect whether there are CRC errors NRF_LOG_INFO("CRC error\n"); - status = HF_ERR_CRC; + status = STATUS_HF_ERR_CRC; } else if (pcd_err_val & 0x08) { // There is a conflict to detect the label NRF_LOG_INFO("Collision tag\n"); - status = HF_COLLISION; + status = STATUS_HF_COLLISION; } else { // There are other unrepaired abnormalities NRF_LOG_INFO("HF error: 0x%0x2\n", pcd_err_val); - status = HF_ERR_STAT; + status = STATUS_HF_ERR_STAT; } } else { // Occasionally occur @@ -351,25 +351,25 @@ uint8_t pcd_14a_reader_bytes_transfer(uint8_t Command, uint8_t *pIn, uint8_t In // Read all the data in FIFO read_register_buffer(FIFODataReg, pOut, n); // Transmission instructions can be considered success when reading normal data! - status = HF_TAG_OK; + status = STATUS_HF_TAG_OK; } else { NRF_LOG_INFO("pcd_14a_reader_bytes_transfer receive response overflow: %d, max = %d\n", *pOutLenBit, maxOutLenBit); // We can't pass the problem with problems, which is meaningless for the time being *pOutLenBit = 0; // Since there is a problem with the data, let's notify the upper layer and inform me - status = HF_ERR_STAT; + status = STATUS_HF_ERR_STAT; } } else { // Non -transmitted instructions, the execution is completed without errors and considered success! - status = HF_TAG_OK; + status = STATUS_HF_TAG_OK; } } } else { - status = HF_TAG_NO; + status = STATUS_HF_TAG_NO; // NRF_LOG_INFO("Tag lost(timeout).\n"); } - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { // If there are certain operations, // We may need to remove MFCrypto1On This register logo, // Because it may be because of the error encryption communication caused by verification @@ -445,7 +445,7 @@ uint8_t pcd_14a_reader_bits_transfer(uint8_t *pTx, uint16_t szTxBits, uint8_t * clear_register_mask(MfRxReg, 0x10); // Enable Qiqi school inspection // Simply judge the length of data transmission - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { // NRF_LOG_INFO("pcd_14a_reader_bytes_transfer error status: %d\n", status); return status; } @@ -465,7 +465,7 @@ uint8_t pcd_14a_reader_bits_transfer(uint8_t *pTx, uint16_t szTxBits, uint8_t * NRF_LOG_INFO("pcd_14a_reader_bits_transfer decode parity data overflow: %d, max = %d\n", *pRxLenBit, szRxLenBitMax); // There must be an overflow here, and the length of the data that is valid is reset to avoid misjudgment from external calls. *pRxLenBit = 0; - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // The process of the separation and dissection process of the unprecedented verification and the data @@ -479,25 +479,25 @@ uint8_t pcd_14a_reader_bits_transfer(uint8_t *pTx, uint16_t szTxBits, uint8_t * pRxPar[i - 1] = (buffer[i] & (1 << (i - 1))) >> (i - 1); } } - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** * @brief : ISO14443-A Fast Select * @param ：tag：tag info buffer -* @retval ：if return HF_TAG_OK，the tag is selected. +* @retval ：if return STATUS_HF_TAG_OK，the tag is selected. */ uint8_t pcd_14a_reader_fast_select(picc_14a_tag_t *tag) { uint8_t resp[5] = {0}; // theoretically. A usual RATS will be much smaller uint8_t uid_resp[4] = {0}; uint8_t sak = 0x04; // cascade uid - uint8_t status = HF_TAG_OK; + uint8_t status = STATUS_HF_TAG_OK; uint8_t cascade_level = 0; uint16_t len; // Wakeup - if (pcd_14a_reader_atqa_request(resp, NULL, U8ARR_BIT_LEN(resp)) != HF_TAG_OK) { - return HF_TAG_NO; + if (pcd_14a_reader_atqa_request(resp, NULL, U8ARR_BIT_LEN(resp)) != STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_NO; } // OK we will select at least at cascade 1, lets see if first byte of UID was 0x88 in @@ -523,9 +523,9 @@ uint8_t pcd_14a_reader_fast_select(picc_14a_tag_t *tag) { crc_14a_append(sel_uid, 7); // calculate and add CRC status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, sel_uid, sizeof(sel_uid), resp, &len, U8ARR_BIT_LEN(resp)); // Receive the SAK - if (status != HF_TAG_OK || !len) { + if (status != STATUS_HF_TAG_OK || !len) { // printf("SAK Err: %d, %d\r\n", status, recv_len); - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } sak = resp[0]; @@ -539,7 +539,7 @@ uint8_t pcd_14a_reader_fast_select(picc_14a_tag_t *tag) { uid_resp[2] = uid_resp[3]; } } - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -558,9 +558,9 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { } // wake - if (pcd_14a_reader_atqa_request(tag->atqa, NULL, U8ARR_BIT_LEN(tag->atqa)) != HF_TAG_OK) { - // NRF_LOG_INFO("pcd_14a_reader_atqa_request HF_TAG_NO\r\n"); - return HF_TAG_NO; + if (pcd_14a_reader_atqa_request(tag->atqa, NULL, U8ARR_BIT_LEN(tag->atqa)) != STATUS_HF_TAG_OK) { + // NRF_LOG_INFO("pcd_14a_reader_atqa_request STATUS_HF_TAG_NO\r\n"); + return STATUS_HF_TAG_NO; } uint8_t resp[DEF_FIFO_LENGTH] = {0}; // theoretically. A usual RATS will be much smaller @@ -585,7 +585,7 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, sel_all, sizeof(sel_all), resp, &len, U8ARR_BIT_LEN(resp)); // There is a label collision, we need to solve the collision - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { // The collision still has to be collided. Do n't have this during the decryption process. // So do not solve the collision for the time being, but directly inform the user that the user guarantees that there is only one card in the field NRF_LOG_INFO("Err at tag collision.\n"); @@ -607,16 +607,16 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { uint8_t bcc = sel_uid[2] ^ sel_uid[3] ^ sel_uid[4] ^ sel_uid[5]; // calculate BCC if (sel_uid[6] != bcc) { NRF_LOG_INFO("BCC%d incorrect, got 0x%02x, expected 0x%02x\n", cascade_level, sel_uid[6], bcc); - return HF_ERR_BCC; + return STATUS_HF_ERR_BCC; } crc_14a_append(sel_uid, 7); // calculate and add CRC // send 9x 70 Choose a card status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, sel_uid, sizeof(sel_uid), resp, &len, U8ARR_BIT_LEN(resp)); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Err at sak receive.\n"); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // Sak received by buffer @@ -648,24 +648,24 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { ats_size -= 2; // size returned by pcd_14a_reader_ats_request includes CRC if (ats_size > 254) { NRF_LOG_INFO("Invalid ATS > 254!"); - return HF_ERR_ATS; + return STATUS_HF_ERR_ATS; } tag->ats_len = ats_size; // We do not validate ATS here as we want to report ATS as it is without breaking 14a scan if (tag->ats[0] != ats_size - 1) { NRF_LOG_INFO("Invalid ATS! First byte doesn't match received length"); - // return HF_ERR_ATS; + // return STATUS_HF_ERR_ATS; } - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Tag SAK claimed to support ATS but tag NAKd RATS"); - // return HF_ERR_ATS; + // return STATUS_HF_ERR_ATS; } /* * FIXME: If there is an issue here, it will cause the label to lose its selected state. * It is necessary to reselect the card after the issue occurs here. */ } - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -678,14 +678,14 @@ uint8_t pcd_14a_reader_scan_auto(picc_14a_tag_t *tag) { // The first card search status = pcd_14a_reader_scan_once(tag); - if (status == HF_TAG_OK) { - return HF_TAG_OK; + if (status == STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_OK; } // Second card search status = pcd_14a_reader_scan_once(tag); - if (status == HF_TAG_OK) { - return HF_TAG_OK; + if (status == STATUS_HF_TAG_OK) { + return STATUS_HF_TAG_OK; } // More than the number of upper limits @@ -704,7 +704,7 @@ uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAt status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, rats, sizeof(rats), pAts, szAts, szAtsBitMax); - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { *szAts = 0; NRF_LOG_INFO("Err at ats receive.\n"); return status; @@ -713,7 +713,7 @@ uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAt // NRF_LOG_INFO("Length: %d\n", *szAts); if (*szAts > 0) { *szAts = *szAts / 8; } - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -724,7 +724,7 @@ uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAt uint8_t pcd_14a_reader_atqa_request(uint8_t *resp, uint8_t *resp_par, uint16_t resp_max_bit) { uint16_t len = 0; uint8_t retry = 0; - uint8_t status = HF_TAG_OK; + uint8_t status = STATUS_HF_TAG_OK; uint8_t wupa[] = { PICC_REQALL }; // 0x26 - REQA 0x52 - WAKE-UP // we may need several tries if we did send an unknown command or a wrong authentication before... @@ -736,13 +736,13 @@ uint8_t pcd_14a_reader_atqa_request(uint8_t *resp, uint8_t *resp_par, uint16_t r // normal ATQA It is 2 bytes, that is, 16bit, // We need to judge whether the data received is correct - if (status == HF_TAG_OK && len == 16) { + if (status == STATUS_HF_TAG_OK && len == 16) { // You can confirm that at least one 14A card exists in the current field - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // No card - return HF_TAG_NO; + return STATUS_HF_TAG_NO; } /** @@ -765,21 +765,21 @@ uint8_t pcd_14a_reader_gen1a_unlock(void) { // Unlock the first step, send 7bit 0x40 unlock = PICC_MAGICWUPC1; status = pcd_14a_reader_bits_transfer(&unlock, 7, NULL, recvbuf, NULL, &rx_length, U8ARR_BIT_LEN(recvbuf)); - if (!(status == HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { + if (!(status == STATUS_HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { NRF_LOG_INFO("UNLOCK(MAGICWUPC1) FAILED! Length: %d, Status: %02x\n", rx_length, status); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // Step in the second step, send a complete byte 0x43 unlock = PICC_MAGICWUPC2; status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, &unlock, 1, recvbuf, &rx_length, U8ARR_BIT_LEN(recvbuf)); - if (!(status == HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { + if (!(status == STATUS_HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { NRF_LOG_INFO("UNLOCK(MAGICWUPC2) FAILED! Length: %d, Status: %02x\n", rx_length, status); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // There is no problem with unlocking twice. We default this unlock operation successfully! - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -807,19 +807,19 @@ uint8_t pcd_14a_reader_gen1a_uplock(void) { uint8_t recvbuf[1] = { 0x00 }; status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, uplock_1, sizeof(uplock_1), recvbuf, &rx_length, U8ARR_BIT_LEN(recvbuf)); - if (!(status == HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { + if (!(status == STATUS_HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { NRF_LOG_INFO("UPLOCK1(UFUID) FAILED!\n"); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, uplock_2, sizeof(uplock_2), recvbuf, &rx_length, U8ARR_BIT_LEN(recvbuf)); - if (!(status == HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { + if (!(status == STATUS_HF_TAG_OK && rx_length == 4 && recvbuf[0] == 0x0A)) { NRF_LOG_INFO("UPLOCK2(UFUID) FAILED!\n"); - return HF_ERR_STAT; + return STATUS_HF_ERR_STAT; } // Successful card sealing - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } /** @@ -830,7 +830,7 @@ uint8_t pcd_14a_reader_gen1a_uplock(void) { * ucaddr: block address * pKEY: password * PSNR: Card serial number, 4 bytes -* @retval : The status value HF_TAG_OK is successful, tag_errauth fails, and other returns indicate some abnormalities related to communication errors! +* @retval : The status value STATUS_HF_TAG_OK is successful, tag_errauth fails, and other returns indicate some abnormalities related to communication errors! */ uint8_t pcd_14a_reader_mf1_auth(picc_14a_tag_t *tag, uint8_t type, uint8_t addr, uint8_t *pKey) { uint8_t dat_buff[12] = { type, addr }; @@ -844,11 +844,11 @@ uint8_t pcd_14a_reader_mf1_auth(picc_14a_tag_t *tag, uint8_t type, uint8_t addr, // In order to improve compatibility, we directly judge the implementation of the execution PCD_AUTHENT // After the instruction, whether the communication plus position in Status2reg is placed. if (read_register_single(Status2Reg) & 0x08) { - return HF_TAG_OK; + return STATUS_HF_TAG_OK; } // Other situations are considered failure! - return MF_ERR_AUTH; + return STATUS_MF_ERR_AUTH; } /** @@ -875,14 +875,14 @@ uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p) { crc_14a_append(dat_buff, 2); // Then initiate communication status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, dat_buff, 4, dat_buff, &len, U8ARR_BIT_LEN(dat_buff)); - if (status == HF_TAG_OK) { + if (status == STATUS_HF_TAG_OK) { if (len == 0x90 /* 0x90 = 144bits */) { // 16 -byte length CRC data, in order not to waste the CPU performance, // We can let 522 Calculate crc_14a_calculate(dat_buff, 16, crc_buff); // Check the CRC to avoid data errors if ((crc_buff[0] != dat_buff[16]) || (crc_buff[1] != dat_buff[17])) { - status = HF_ERR_CRC; + status = STATUS_HF_ERR_CRC; } // Although CRC After checking the problem, but we can still pass back // Read the card data, because developers may have special usage @@ -890,7 +890,7 @@ uint8_t pcd_14a_reader_mf1_read_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p) { } else { // The data passed back is wrong, which may be an environmental factors or cards that do not comply with specifications! // Or the control bit affects reading! - status = HF_ERR_STAT; + status = STATUS_HF_ERR_STAT; } } return status; @@ -928,16 +928,16 @@ uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p) { // Request to write a card, at this time, the card should reply to ACK status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, dat_buff, 4, dat_buff, &dat_len, U8ARR_BIT_LEN(dat_buff)); // The communication fails, the reason is returned directly - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } // The communication was successful, but the operation was rejected by the card! if ((dat_len != 4) || ((dat_buff[0] & 0x0F) != 0x0A)) { // NRF_LOG_INFO("1 status = %d, datalen = %d, data = %02x\n", status, dat_len, dat_buff[0]); - status = HF_ERR_STAT; + status = STATUS_HF_ERR_STAT; } // The communication was successful, the card accepted the card writing operation - if (status == HF_TAG_OK) { + if (status == STATUS_HF_TAG_OK) { // 1. Copy data and calculate CRC memcpy(dat_buff, p, 16); crc_14a_calculate(dat_buff, 16, &dat_buff[16]); @@ -948,14 +948,14 @@ uint8_t pcd_14a_reader_mf1_write_by_cmd(uint8_t cmd, uint8_t addr, uint8_t *p) { // 2. Transfer the final card writing data to complete the writing card status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, dat_buff, 18, dat_buff, &dat_len, U8ARR_BIT_LEN(dat_buff)); // The communication fails, the reason is returned directly - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { return status; } // The communication is successful, we need to determine whether the card is successfully processed after receiving the data // And reply ACK if ((dat_len != 4) || ((dat_buff[0] & 0x0F) != 0x0A)) { // NRF_LOG_INFO("2 status = %d, datalen = %d, data = %02x\n", status, dat_len, dat_buff[0]); - status = HF_ERR_STAT; + status = STATUS_HF_ERR_STAT; } } return status; @@ -983,7 +983,7 @@ uint8_t pcd_14a_reader_halt_tag(void) { // Prepare the molding data directly, and calculate a ghost CRC uint8_t data[] = { PICC_HALT, 0x00, 0x57, 0xCD }; status = pcd_14a_reader_bytes_transfer(PCD_TRANSCEIVE, data, 4, data, &unLen, U8ARR_BIT_LEN(data)); - return status == HF_TAG_NO && unLen == 0; + return status == STATUS_HF_TAG_NO && unLen == 0; } /** @@ -1205,7 +1205,7 @@ inline void pcd_14a_reader_crc_computer(uint8_t use522CalcCRC) { uint8_t pcd_14a_reader_raw_cmd(bool openRFField, bool waitResp, bool appendCrc, bool autoSelect, bool keepField, bool checkCrc, uint16_t waitRespTimeout, uint16_t szDataSendBits, uint8_t *pDataSend, uint8_t *pDataRecv, uint16_t *pszDataRecv, uint16_t szDataRecvBitMax) { // Status code, default is OK. - uint8_t status = HF_TAG_OK; + uint8_t status = STATUS_HF_TAG_OK; // Reset recv length. *pszDataRecv = 0; @@ -1244,7 +1244,7 @@ uint8_t pcd_14a_reader_raw_cmd(bool openRFField, bool waitResp, bool appendCrc, picc_14a_tag_t ti; status = pcd_14a_reader_scan_once(&ti); // Determine whether the card search was successful - if (status != HF_TAG_OK) { + if (status != STATUS_HF_TAG_OK) { pcd_14a_reader_antenna_off(); return status; } @@ -1296,7 +1296,7 @@ uint8_t pcd_14a_reader_raw_cmd(bool openRFField, bool waitResp, bool appendCrc, if (pDataRecv[finalRecvBytes - 2] != crc_buff[0] || pDataRecv[finalRecvBytes - 1] != crc_buff[1]) { // We have found an error in CRC verification and need to inform the upper computer! *pszDataRecv = 0; - status = HF_ERR_CRC; + status = STATUS_HF_ERR_CRC; } else { // If the CRC needs to be verified by the device and the device determines that the CRC is normal, // we will return the data without CRC diff --git a/firmware/application/src/rfid/reader/lf/lf_reader_main.c b/firmware/application/src/rfid/reader/lf/lf_reader_main.c index c3dab39..cf37c3b 100644 --- a/firmware/application/src/rfid/reader/lf/lf_reader_main.c +++ b/firmware/application/src/rfid/reader/lf/lf_reader_main.c @@ -19,9 +19,9 @@ uint32_t g_timeout_readem_ms = 500; * Search EM410X tag */ uint8_t PcdScanEM410X(uint8_t *uid) { - uint8_t ret = EM410X_TAG_NO_FOUND; + uint8_t ret = STATUS_EM410X_TAG_NO_FOUND; if (em410x_read(uid, g_timeout_readem_ms) == 1) { - ret = LF_TAG_OK; + ret = STATUS_LF_TAG_OK; } return ret; } @@ -32,8 +32,8 @@ uint8_t PcdScanEM410X(uint8_t *uid) { uint8_t check_write_ok(uint8_t *uid, uint8_t *newuid, uint8_t on_uid_diff_return) { // After the card is written, we need to read it once, // If the data I read is incorrect, it means that the writing fails - if (PcdScanEM410X(newuid) != LF_TAG_OK) { - return EM410X_TAG_NO_FOUND; + if (PcdScanEM410X(newuid) != STATUS_LF_TAG_OK) { + return STATUS_EM410X_TAG_NO_FOUND; } // If you read the card number the same // Explanation is successful (maybe) @@ -43,7 +43,7 @@ uint8_t check_write_ok(uint8_t *uid, uint8_t *newuid, uint8_t on_uid_diff_return uid[2] == newuid[2] && uid[3] == newuid[3] && uid[4] == newuid[4]) { - return LF_TAG_OK; + return STATUS_LF_TAG_OK; } // If you find the card, the card number is wrong, // Then we will return the abnormal value of the inlet @@ -102,7 +102,7 @@ uint8_t PcdWriteT55XX(uint8_t *uid, uint8_t *newkey, uint8_t *old_keys, uint8_t // Read the verification and return the results of the card writing // Do not read it here, you can check it by the upper machine - return LF_TAG_OK; + return STATUS_LF_TAG_OK; } /** diff --git a/firmware/application/src/settings.c b/firmware/application/src/settings.c index 4afc4a0..738e7ac 100644 --- a/firmware/application/src/settings.c +++ b/firmware/application/src/settings.c @@ -137,7 +137,7 @@ uint8_t settings_save_config(void) { NRF_LOG_INFO("Config did not change."); } - return STATUS_DEVICE_SUCCESS; + return STATUS_SUCCESS; } uint8_t settings_get_animation_config() { diff --git a/software/script/chameleon_cli_unit.py b/software/script/chameleon_cli_unit.py index 3c7f795..b28a07b 100644 --- a/software/script/chameleon_cli_unit.py +++ b/software/script/chameleon_cli_unit.py @@ -15,11 +15,10 @@ from platform import uname import chameleon_com import chameleon_cmd -import chameleon_status from chameleon_utils import ArgumentParserNoExit, ArgsParserError, UnexpectedResponseError from chameleon_utils import CLITree from chameleon_utils import CR, CG, CB, CC, CY, CM, C0 -from chameleon_enum import Command, SlotNumber, TagSenseType, TagSpecificType +from chameleon_enum import Command, Status, SlotNumber, TagSenseType, TagSpecificType from chameleon_enum import MifareClassicWriteMode, MifareClassicPrngType, MifareClassicDarksideStatus, MfcKeyType from chameleon_enum import AnimationMode, ButtonType, ButtonPressFunction @@ -51,7 +50,8 @@ def check_tools(): tools = [x+'.exe' for x in tools] missing_tools = [tool for tool in tools if not (default_cwd / tool).exists()] if len(missing_tools) > 0: - print(f'{CR}Warning, tools {", ".join(missing_tools)} not found. Corresponding commands will not work as intended.{C0}') + print(f'{CR}Warning, tools {", ".join(missing_tools)} not found. ' + f'Corresponding commands will not work as intended.{C0}') class BaseCLIUnit: @@ -1999,11 +1999,14 @@ class HWRaw(DeviceRequiredUnit): print(f" Command: {response.cmd} {command.name}") except ValueError: print(f" Command: {response.cmd} (unknown)") + status_string = f" Status: {response.status:#02x}" - if response.status in chameleon_status.Device: - status_string += f" {chameleon_status.Device[response.status]}" - if response.status in chameleon_status.message: - status_string += f": {chameleon_status.message[response.status]}" + try: + status = Status(response.status) + status_string += f" {status.name}" + status_string += f": {str(status)}" + except ValueError: + pass print(status_string) print(f" Data (HEX): {response.data.hex()}") diff --git a/software/script/chameleon_cmd.py b/software/script/chameleon_cmd.py index 07c3cf5..3d0a595 100644 --- a/software/script/chameleon_cmd.py +++ b/software/script/chameleon_cmd.py @@ -2,14 +2,14 @@ import struct import ctypes import chameleon_com -import chameleon_status from chameleon_utils import expect_response -from chameleon_enum import Command, SlotNumber, TagSenseType, TagSpecificType +from chameleon_enum import Command, Status, SlotNumber, TagSenseType, TagSpecificType from chameleon_enum import MifareClassicDarksideStatus from chameleon_enum import ButtonType, ButtonPressFunction CURRENT_VERSION_SETTINGS = 5 + class ChameleonCMD: """ Chameleon cmd function @@ -21,52 +21,52 @@ class ChameleonCMD: """ self.device = chameleon - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_app_version(self): """ Get firmware version number(application) """ resp = self.device.send_cmd_sync(Command.GET_APP_VERSION) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = struct.unpack('!BB', resp.data) # older protocol, must upgrade! if resp.status == 0 and resp.data == b'\x00\x01': print("Chameleon does not understand new protocol. Please update firmware") return chameleon_com.Response(cmd=Command.GET_APP_VERSION, - status=chameleon_status.Device.STATUS_NOT_IMPLEMENTED) + status=Status.NOT_IMPLEMENTED) return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_device_chip_id(self): """ Get device chip id """ resp = self.device.send_cmd_sync(Command.GET_DEVICE_CHIP_ID) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data.hex() return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_device_address(self): """ Get device address """ resp = self.device.send_cmd_sync(Command.GET_DEVICE_ADDRESS) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data.hex() return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_git_version(self) -> str: resp = self.device.send_cmd_sync(Command.GET_GIT_VERSION) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data.decode('utf-8') return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_device_mode(self): resp = self.device.send_cmd_sync(Command.GET_DEVICE_MODE) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data, = struct.unpack('!?', resp.data) return resp @@ -78,7 +78,7 @@ class ChameleonCMD: return self.get_device_mode() # Note: Will return NOT_IMPLEMENTED if one tries to set reader mode on Lite - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def change_device_mode(self, mode): data = struct.pack('!B', mode) return self.device.send_cmd_sync(Command.CHANGE_DEVICE_MODE, data) @@ -91,14 +91,14 @@ class ChameleonCMD: """ self.change_device_mode(reader_mode) - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def hf14a_scan(self): """ 14a tags in the scanning field :return: """ resp = self.device.send_cmd_sync(Command.HF14A_SCAN) - if resp.status == chameleon_status.Device.HF_TAG_OK: + if resp.status == Status.HF_TAG_OK: # uidlen[1]|uid[uidlen]|atqa[2]|sak[1]|atslen[1]|ats[atslen] offset = 0 data = [] @@ -119,20 +119,20 @@ class ChameleonCMD: :return: """ resp = self.device.send_cmd_sync(Command.MF1_DETECT_SUPPORT) - return resp.status == chameleon_status.Device.HF_TAG_OK + return resp.status == Status.HF_TAG_OK - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_detect_prng(self): """ detect mifare Class of classic nt vulnerabilities :return: """ resp = self.device.send_cmd_sync(Command.MF1_DETECT_PRNG) - if resp.status == chameleon_status.Device.HF_TAG_OK: + if resp.status == Status.HF_TAG_OK: resp.data = resp.data[0] return resp - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_detect_nt_dist(self, block_known, type_known, key_known): """ Detect the random number distance of the card @@ -140,12 +140,12 @@ class ChameleonCMD: """ data = struct.pack('!BB6s', type_known, block_known, key_known) resp = self.device.send_cmd_sync(Command.MF1_DETECT_NT_DIST, data) - if resp.status == chameleon_status.Device.HF_TAG_OK: + if resp.status == Status.HF_TAG_OK: uid, dist = struct.unpack('!II', resp.data) resp.data = {'uid': uid, 'dist': dist} return resp - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_nested_acquire(self, block_known, type_known, key_known, block_target, type_target): """ Collect the key NT parameters needed for Nested decryption @@ -153,12 +153,12 @@ class ChameleonCMD: """ data = struct.pack('!BB6sBB', type_known, block_known, key_known, type_target, block_target) resp = self.device.send_cmd_sync(Command.MF1_NESTED_ACQUIRE, data) - if resp.status == chameleon_status.Device.HF_TAG_OK: + if resp.status == Status.HF_TAG_OK: resp.data = [{'nt': nt, 'nt_enc': nt_enc, 'par': par} for nt, nt_enc, par in struct.iter_unpack('!IIB', resp.data)] return resp - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_darkside_acquire(self, block_target, type_target, first_recover: int or bool, sync_max): """ Collect the key parameters needed for Darkside decryption @@ -170,7 +170,7 @@ class ChameleonCMD: """ data = struct.pack('!BBBB', type_target, block_target, first_recover, sync_max) resp = self.device.send_cmd_sync(Command.MF1_DARKSIDE_ACQUIRE, data, timeout=sync_max * 10) - if resp.status == chameleon_status.Device.HF_TAG_OK: + if resp.status == Status.HF_TAG_OK: if resp.data[0] == MifareClassicDarksideStatus.OK: darkside_status, uid, nt1, par, ks1, nr, ar = struct.unpack('!BIIQQII', resp.data) resp.data = (darkside_status, {'uid': uid, 'nt1': nt1, 'par': par, 'ks1': ks1, 'nr': nr, 'ar': ar}) @@ -178,7 +178,7 @@ class ChameleonCMD: resp.data = (resp.data[0],) return resp - @expect_response([chameleon_status.Device.HF_TAG_OK, chameleon_status.Device.MF_ERR_AUTH]) + @expect_response([Status.HF_TAG_OK, Status.MF_ERR_AUTH]) def mf1_auth_one_key_block(self, block, type_value, key): """ Verify the mf1 key, only verify the specified type of key for a single sector @@ -189,10 +189,10 @@ class ChameleonCMD: """ data = struct.pack('!BB6s', type_value, block, key) resp = self.device.send_cmd_sync(Command.MF1_AUTH_ONE_KEY_BLOCK, data) - resp.data = resp.status == chameleon_status.Device.HF_TAG_OK + resp.data = resp.status == Status.HF_TAG_OK return resp - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_read_one_block(self, block, type_value, key): """ read one mf1 block @@ -204,7 +204,7 @@ class ChameleonCMD: data = struct.pack('!BB6s', type_value, block, key) return self.device.send_cmd_sync(Command.MF1_READ_ONE_BLOCK, data) - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_write_one_block(self, block, type_value, key, block_data): """ Write mf1 single block @@ -216,10 +216,10 @@ class ChameleonCMD: """ data = struct.pack('!BB6s16s', type_value, block, key, block_data) resp = self.device.send_cmd_sync(Command.MF1_WRITE_ONE_BLOCK, data) - resp.data = resp.status == chameleon_status.Device.HF_TAG_OK + resp.data = resp.status == Status.HF_TAG_OK return resp - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def hf14a_raw(self, options, resp_timeout_ms=100, data=[], bitlen=None): """ Send raw cmd to 14a tag @@ -261,7 +261,7 @@ class ChameleonCMD: data = bytes(cs)+struct.pack(f'!HH{len(data)}s', resp_timeout_ms, bitlen, bytearray(data)) return self.device.send_cmd_sync(Command.HF14A_RAW, data, timeout=(resp_timeout_ms / 1000) + 1) - @expect_response(chameleon_status.Device.HF_TAG_OK) + @expect_response(Status.HF_TAG_OK) def mf1_static_nested_acquire(self, block_known, type_known, key_known, block_target, type_target): """ Collect the key NT parameters needed for StaticNested decryption @@ -269,7 +269,7 @@ class ChameleonCMD: """ data = struct.pack('!BB6sBB', type_known, block_known, key_known, type_target, block_target) resp = self.device.send_cmd_sync(Command.MF1_STATIC_NESTED_ACQUIRE, data) - if resp.status == chameleon_status.Device.HF_TAG_OK: + if resp.status == Status.HF_TAG_OK: resp.data = { 'uid': struct.unpack('!I', resp.data[0:4])[0], 'nts': [ @@ -281,7 +281,7 @@ class ChameleonCMD: } return resp - @expect_response(chameleon_status.Device.LF_TAG_OK) + @expect_response(Status.LF_TAG_OK) def em410x_scan(self): """ Read the card number of EM410X @@ -289,7 +289,7 @@ class ChameleonCMD: """ return self.device.send_cmd_sync(Command.EM410X_SCAN) - @expect_response(chameleon_status.Device.LF_TAG_OK) + @expect_response(Status.LF_TAG_OK) def em410x_write_to_t55xx(self, id_bytes: bytes): """ Write EM410X card number into T55XX @@ -303,30 +303,30 @@ class ChameleonCMD: data = struct.pack(f'!5s4s{4*len(old_keys)}s', id_bytes, new_key, b''.join(old_keys)) return self.device.send_cmd_sync(Command.EM410X_WRITE_TO_T55XX, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_slot_info(self): """ Get slots info :return: """ resp = self.device.send_cmd_sync(Command.GET_SLOT_INFO) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = [{'hf': hf, 'lf': lf} for hf, lf in struct.iter_unpack('!HH', resp.data)] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_active_slot(self): """ Get selected slot :return: """ resp = self.device.send_cmd_sync(Command.GET_ACTIVE_SLOT) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data[0] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_active_slot(self, slot_index: SlotNumber): """ Set the card slot currently active for use @@ -337,7 +337,7 @@ class ChameleonCMD: data = struct.pack('!B', SlotNumber.to_fw(slot_index)) return self.device.send_cmd_sync(Command.SET_ACTIVE_SLOT, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_slot_tag_type(self, slot_index: SlotNumber, tag_type: TagSpecificType): """ Set the label type of the simulated card of the current card slot @@ -351,7 +351,7 @@ class ChameleonCMD: data = struct.pack('!BH', SlotNumber.to_fw(slot_index), tag_type) return self.device.send_cmd_sync(Command.SET_SLOT_TAG_TYPE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def delete_slot_sense_type(self, slot_index: SlotNumber, sense_type: TagSenseType): """ Delete a sense type for a specific slot. @@ -362,7 +362,7 @@ class ChameleonCMD: data = struct.pack('!BB', SlotNumber.to_fw(slot_index), sense_type) return self.device.send_cmd_sync(Command.DELETE_SLOT_SENSE_TYPE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_slot_data_default(self, slot_index: SlotNumber, tag_type: TagSpecificType): """ Set the data of the simulated card in the specified card slot as the default data @@ -375,7 +375,7 @@ class ChameleonCMD: data = struct.pack('!BH', SlotNumber.to_fw(slot_index), tag_type) return self.device.send_cmd_sync(Command.SET_SLOT_DATA_DEFAULT, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_slot_enable(self, slot_index: SlotNumber, sense_type: TagSenseType, enabled: bool): """ Set whether the specified card slot is enabled @@ -387,7 +387,7 @@ class ChameleonCMD: data = struct.pack('!BBB', SlotNumber.to_fw(slot_index), sense_type, enabled) return self.device.send_cmd_sync(Command.SET_SLOT_ENABLE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def em410x_set_emu_id(self, id: bytes): """ Set the card number simulated by EM410x @@ -399,14 +399,14 @@ class ChameleonCMD: data = struct.pack('5s', id) return self.device.send_cmd_sync(Command.EM410X_SET_EMU_ID, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def em410x_get_emu_id(self): """ Get the simulated EM410x card id """ return self.device.send_cmd_sync(Command.EM410X_GET_EMU_ID) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_set_detection_enable(self, enabled: bool): """ Set whether to enable the detection of the current card slot @@ -416,18 +416,18 @@ class ChameleonCMD: data = struct.pack('!B', enabled) return self.device.send_cmd_sync(Command.MF1_SET_DETECTION_ENABLE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_get_detection_count(self): """ Get the statistics of the current detection records :return: """ resp = self.device.send_cmd_sync(Command.MF1_GET_DETECTION_COUNT) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data, = struct.unpack('!I', resp.data) return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_get_detection_log(self, index: int): """ Get detection logs from the specified index position @@ -436,7 +436,7 @@ class ChameleonCMD: """ data = struct.pack('!I', index) resp = self.device.send_cmd_sync(Command.MF1_GET_DETECTION_LOG, data) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: # convert result_list = [] pos = 0 @@ -455,7 +455,7 @@ class ChameleonCMD: resp.data = result_list return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_write_emu_block_data(self, block_start: int, block_data: bytes): """ Set the block data of the analog card of MF1 @@ -467,7 +467,7 @@ class ChameleonCMD: data = struct.pack(f'!B{len(block_data)}s', block_start, block_data) return self.device.send_cmd_sync(Command.MF1_WRITE_EMU_BLOCK_DATA, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_read_emu_block_data(self, block_start: int, block_count: int): """ Gets data for selected block range @@ -475,7 +475,7 @@ class ChameleonCMD: data = struct.pack('!BB', block_start, block_count) return self.device.send_cmd_sync(Command.MF1_READ_EMU_BLOCK_DATA, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def hf14a_set_anti_coll_data(self, uid: bytes, atqa: bytes, sak: bytes, ats: bytes = b''): """ Set anti-collision data of current HF slot (UID/SAK/ATQA/ATS) @@ -488,7 +488,7 @@ class ChameleonCMD: data = struct.pack(f'!B{len(uid)}s2s1sB{len(ats)}s', len(uid), uid, atqa, sak, len(ats), ats) return self.device.send_cmd_sync(Command.HF14A_SET_ANTI_COLL_DATA, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_slot_tag_nick(self, slot: SlotNumber, sense_type: TagSenseType, name: bytes): """ Set the nick name of the slot @@ -501,7 +501,7 @@ class ChameleonCMD: data = struct.pack(f'!BB{len(name)}s', SlotNumber.to_fw(slot), sense_type, name) return self.device.send_cmd_sync(Command.SET_SLOT_TAG_NICK, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_slot_tag_nick(self, slot: SlotNumber, sense_type: TagSenseType): """ Get the nick name of the slot @@ -513,7 +513,7 @@ class ChameleonCMD: data = struct.pack('!BB', SlotNumber.to_fw(slot), sense_type) return self.device.send_cmd_sync(Command.GET_SLOT_TAG_NICK, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def delete_slot_tag_nick(self, slot: SlotNumber, sense_type: TagSenseType): """ Delete the nick name of the slot @@ -525,7 +525,7 @@ class ChameleonCMD: data = struct.pack('!BB', SlotNumber.to_fw(slot), sense_type) return self.device.send_cmd_sync(Command.DELETE_SLOT_TAG_NICK, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_get_emulator_config(self): """ Get array of Mifare Classic emulators settings: @@ -537,7 +537,7 @@ class ChameleonCMD: :return: """ resp = self.device.send_cmd_sync(Command.MF1_GET_EMULATOR_CONFIG) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: b1, b2, b3, b4, b5 = struct.unpack('!????B', resp.data) resp.data = {'detection': b1, 'gen1a_mode': b2, @@ -546,7 +546,7 @@ class ChameleonCMD: 'write_mode': b5} return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_set_gen1a_mode(self, enabled: bool): """ Set gen1a magic mode @@ -554,7 +554,7 @@ class ChameleonCMD: data = struct.pack('!B', enabled) return self.device.send_cmd_sync(Command.MF1_SET_GEN1A_MODE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_set_gen2_mode(self, enabled: bool): """ Set gen2 magic mode @@ -562,7 +562,7 @@ class ChameleonCMD: data = struct.pack('!B', enabled) return self.device.send_cmd_sync(Command.MF1_SET_GEN2_MODE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_set_block_anti_coll_mode(self, enabled: bool): """ Set 0 block anti-collision data @@ -570,7 +570,7 @@ class ChameleonCMD: data = struct.pack('!B', enabled) return self.device.send_cmd_sync(Command.MF1_SET_BLOCK_ANTI_COLL_MODE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def mf1_set_write_mode(self, mode: int): """ Set write mode @@ -578,7 +578,7 @@ class ChameleonCMD: data = struct.pack('!B', mode) return self.device.send_cmd_sync(Command.MF1_SET_WRITE_MODE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def slot_data_config_save(self): """ Update the configuration and data of the card slot to flash. @@ -593,27 +593,27 @@ class ChameleonCMD: """ self.device.send_cmd_auto(Command.ENTER_BOOTLOADER, close=True) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_animation_mode(self): """ Get animation mode value """ resp = self.device.send_cmd_sync(Command.GET_ANIMATION_MODE) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data[0] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_enabled_slots(self): """ Get enabled slots """ resp = self.device.send_cmd_sync(Command.GET_ENABLED_SLOTS) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = [{'hf': hf, 'lf': lf} for hf, lf in struct.iter_unpack('!BB', resp.data)] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_animation_mode(self, value: int): """ Set animation mode value @@ -621,56 +621,56 @@ class ChameleonCMD: data = struct.pack('!B', value) return self.device.send_cmd_sync(Command.SET_ANIMATION_MODE, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def reset_settings(self): """ Reset settings stored in flash memory """ resp = self.device.send_cmd_sync(Command.RESET_SETTINGS) - resp.data = resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS + resp.data = resp.status == Status.SUCCESS return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def save_settings(self): """ Store settings to flash memory """ resp = self.device.send_cmd_sync(Command.SAVE_SETTINGS) - resp.data = resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS + resp.data = resp.status == Status.SUCCESS return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def wipe_fds(self): """ Reset to factory settings """ resp = self.device.send_cmd_sync(Command.WIPE_FDS) - resp.data = resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS + resp.data = resp.status == Status.SUCCESS self.device.close() return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_battery_info(self): """ Get battery info """ resp = self.device.send_cmd_sync(Command.GET_BATTERY_INFO) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = struct.unpack('!HB', resp.data) return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_button_press_config(self, button: ButtonType): """ Get config of button press function """ data = struct.pack('!B', button) resp = self.device.send_cmd_sync(Command.GET_BUTTON_PRESS_CONFIG, data) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data[0] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_button_press_config(self, button: ButtonType, function: ButtonPressFunction): """ Set config of button press function @@ -678,18 +678,18 @@ class ChameleonCMD: data = struct.pack('!BB', button, function) return self.device.send_cmd_sync(Command.SET_BUTTON_PRESS_CONFIG, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_long_button_press_config(self, button: ButtonType): """ Get config of long button press function """ data = struct.pack('!B', button) resp = self.device.send_cmd_sync(Command.GET_LONG_BUTTON_PRESS_CONFIG, data) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data[0] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_long_button_press_config(self, button: ButtonType, function: ButtonPressFunction): """ Set config of long button press function @@ -697,7 +697,7 @@ class ChameleonCMD: data = struct.pack('!BB', button, function) return self.device.send_cmd_sync(Command.SET_LONG_BUTTON_PRESS_CONFIG, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_ble_connect_key(self, key: str): """ Set config of ble connect key @@ -711,21 +711,21 @@ class ChameleonCMD: data = struct.pack('6s', data_bytes) return self.device.send_cmd_sync(Command.SET_BLE_PAIRING_KEY, data) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_ble_pairing_key(self): """ Get config of ble connect key """ return self.device.send_cmd_sync(Command.GET_BLE_PAIRING_KEY) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def delete_all_ble_bonds(self): """ From peer manager delete all bonds. """ return self.device.send_cmd_sync(Command.DELETE_ALL_BLE_BONDS) - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_device_capabilities(self): """ Get list of commands that client understands @@ -735,13 +735,13 @@ class ChameleonCMD: except chameleon_com.CMDInvalidException: print("Chameleon does not understand get_device_capabilities command. Please update firmware") return chameleon_com.Response(cmd=Command.GET_DEVICE_CAPABILITIES, - status=chameleon_status.Device.STATUS_NOT_IMPLEMENTED) + status=Status.NOT_IMPLEMENTED) else: - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = [x[0] for x in struct.iter_unpack('!H', resp.data)] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_device_model(self): """ Get device model @@ -750,11 +750,11 @@ class ChameleonCMD: """ resp = self.device.send_cmd_sync(Command.GET_DEVICE_MODEL) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data = resp.data[0] return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_device_settings(self): """ Get all possible settings @@ -769,7 +769,7 @@ class ChameleonCMD: settings[7:13] = settings_get_ble_pairing_key(); // BLE pairing key """ resp = self.device.send_cmd_sync(Command.GET_DEVICE_SETTINGS) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: if resp.data[0] > CURRENT_VERSION_SETTINGS: raise ValueError("Settings version in app older than Chameleon. " "Please upgrade client") @@ -788,14 +788,14 @@ class ChameleonCMD: 'ble_pairing_key': ble_pairing_key} return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def hf14a_get_anti_coll_data(self): """ Get anti-collision data from current HF slot (UID/SAK/ATQA/ATS) :return: """ resp = self.device.send_cmd_sync(Command.HF14A_GET_ANTI_COLL_DATA) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS and len(resp.data) > 0: + if resp.status == Status.SUCCESS and len(resp.data) > 0: # uidlen[1]|uid[uidlen]|atqa[2]|sak[1]|atslen[1]|ats[atslen] offset = 0 uidlen, = struct.unpack_from('!B', resp.data, offset) @@ -807,18 +807,18 @@ class ChameleonCMD: resp.data = {'uid': uid, 'atqa': atqa, 'sak': sak, 'ats': ats} return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def get_ble_pairing_enable(self): """ Is ble pairing enable? :return: True if pairing is enable, False if pairing disabled """ resp = self.device.send_cmd_sync(Command.GET_BLE_PAIRING_ENABLE) - if resp.status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + if resp.status == Status.SUCCESS: resp.data, = struct.unpack('!?', resp.data) return resp - @expect_response(chameleon_status.Device.STATUS_DEVICE_SUCCESS) + @expect_response(Status.SUCCESS) def set_ble_pairing_enable(self, enabled: bool): data = struct.pack('!B', enabled) return self.device.send_cmd_sync(Command.SET_BLE_PAIRING_ENABLE, data) diff --git a/software/script/chameleon_com.py b/software/script/chameleon_com.py index d03176a..d4fa724 100644 --- a/software/script/chameleon_com.py +++ b/software/script/chameleon_com.py @@ -3,9 +3,8 @@ import struct import threading import time import serial -import chameleon_status from chameleon_utils import CR, CG, CB, CC, CY, CM, C0 -from chameleon_enum import Command +from chameleon_enum import Command, Status # each thread is waiting for its data for 100 ms before looping again THREAD_BLOCKING_TIMEOUT = 0.1 @@ -201,13 +200,13 @@ class ChameleonCom: command_string = f"{data_cmd} {command.name}" except ValueError: command_string = f"{data_cmd} (unknown)" - if data_status in chameleon_status.Device: - status_string = chameleon_status.Device[data_status] - if data_status == chameleon_status.Device.STATUS_DEVICE_SUCCESS: + try: + status_string = str(Status(data_status)) + if data_status == Status.SUCCESS: status_string = f'{CG}{status_string:30}{C0}' else: status_string = f'{CR}{status_string:30}{C0}' - else: + except ValueError: status_string = f"{CR}{data_status:30x}{C0}" print(f'<= {CC}{command_string:40}{C0}{status_string}' f'{CY}{data_response.hex() if data_response is not None else ""}{C0}') @@ -321,7 +320,12 @@ class ChameleonCom: del self.wait_response_map[cmd] # make data frame if DEBUG: - cmd_string = f'{cmd:4} {cmd.name}{f"[{status:04x}]" if status != 0 else ""}' + try: + command = Command(cmd) + command_name = f"{command.name}" + except ValueError: + command_name = "(UNKNOWN)" + cmd_string = f'{cmd:4} {command_name}{f"[{status:04x}]" if status != 0 else ""}' print(f'=> {CC}{cmd_string:40}{C0}' f'{CY}{data.hex() if data is not None else ""}{C0}') data_frame = self.make_data_frame_bytes(cmd, data, status) @@ -361,7 +365,7 @@ class ChameleonCom: # ok, data received. data_response = self.wait_response_map[cmd]['response'] del self.wait_response_map[cmd] - if data_response.status == chameleon_status.Device.STATUS_INVALID_CMD: + if data_response.status == Status.INVALID_CMD: raise CMDInvalidException(f"Device unsupported cmd: {cmd}") return data_response diff --git a/software/script/chameleon_enum.py b/software/script/chameleon_enum.py index cdcea90..7bac615 100644 --- a/software/script/chameleon_enum.py +++ b/software/script/chameleon_enum.py @@ -97,6 +97,74 @@ class Command(enum.IntEnum): EM410X_GET_EMU_ID = 5001 +@enum.unique +class Status(enum.IntEnum): + HF_TAG_OK = 0x00 # IC card operation is successful + HF_TAG_NO = 0x01 # IC card not found + HF_ERR_STAT = 0x02 # Abnormal IC card communication + HF_ERR_CRC = 0x03 # IC card communication verification abnormal + HF_COLLISION = 0x04 # IC card conflict + HF_ERR_BCC = 0x05 # IC card BCC error + MF_ERR_AUTH = 0x06 # MF card verification failed + HF_ERR_PARITY = 0x07 # IC card parity error + HF_ERR_ATS = 0x08 # ATS should be present but card NAKed, or ATS too large + + # Some operations with low frequency cards succeeded! + LF_TAG_OK = 0x40 + # Unable to search for a valid EM410X label + EM410X_TAG_NO_FOUND = 0x41 + + # The parameters passed by the BLE instruction are wrong, or the parameters passed + # by calling some functions are wrong + PAR_ERR = 0x60 + # The mode of the current device is wrong, and the corresponding API cannot be called + DEVICE_MODE_ERROR = 0x66 + INVALID_CMD = 0x67 + SUCCESS = 0x68 + NOT_IMPLEMENTED = 0x69 + FLASH_WRITE_FAIL = 0x70 + FLASH_READ_FAIL = 0x71 + + def __str__(self): + if self == Status.HF_TAG_OK: + return "HF tag operation succeeded" + elif self == Status.HF_TAG_NO: + return "HF tag no found or lost" + elif self == Status.HF_ERR_STAT: + return "HF tag status error" + elif self == Status.HF_ERR_CRC: + return "HF tag data crc error" + elif self == Status.HF_COLLISION: + return "HF tag collision" + elif self == Status.HF_ERR_BCC: + return "HF tag uid bcc error" + elif self == Status.MF_ERR_AUTH: + return "HF tag auth fail" + elif self == Status.HF_ERR_PARITY: + return "HF tag data parity error" + elif self == Status.HF_ERR_ATS: + return "HF tag was supposed to send ATS but didn't" + elif self == Status.LF_TAG_OK: + return "LF tag operation succeeded" + elif self == Status.EM410X_TAG_NO_FOUND: + return "EM410x tag no found" + elif self == Status.PAR_ERR: + return "API request fail, param error" + elif self == Status.DEVICE_MODE_ERROR: + return "API request fail, device mode error" + elif self == Status.INVALID_CMD: + return "API request fail, cmd invalid" + elif self == Status.SUCCESS: + return "Device operation succeeded" + elif self == Status.NOT_IMPLEMENTED: + return "Some api not implemented" + elif self == Status.FLASH_WRITE_FAIL: + return "Flash write failed" + elif self == Status.FLASH_READ_FAIL: + return "Flash read failed" + return "Invalid status" + + @enum.unique class SlotNumber(enum.IntEnum): SLOT_1 = 1 diff --git a/software/script/chameleon_status.py b/software/script/chameleon_status.py deleted file mode 100644 index da467f5..0000000 --- a/software/script/chameleon_status.py +++ /dev/null @@ -1,73 +0,0 @@ -class MetaDevice(type): - def __iter__(self): - for attr in dir(self): - if not attr.startswith("__"): - yield attr - - def __contains__(self, item): - for field in self.__dict__: - val = self.__dict__[field] - if isinstance(val, int): - if val == item: - return True - return False - - def __getitem__(self, item): - for field in self.__dict__: - val = self.__dict__[field] - if isinstance(val, int): - if val == item: - return field - return False - - -class Device(metaclass=MetaDevice): - HF_TAG_OK = 0x00 # IC card operation is successful - HF_TAG_NO = 0x01 # IC card not found - HF_ERR_STAT = 0x02 # Abnormal IC card communication - HF_ERR_CRC = 0x03 # IC card communication verification abnormal - HF_COLLISION = 0x04 # IC card conflict - HF_ERR_BCC = 0x05 # IC card BCC error - MF_ERR_AUTH = 0x06 # MF card verification failed - HF_ERR_PARITY = 0x07 # IC card parity error - HF_ERR_ATS = 0x08 # ATS should be present but card NAKed, or ATS too large - - # Some operations with low frequency cards succeeded! - LF_TAG_OK = 0x40 - # Unable to search for a valid EM410X label - EM410X_TAG_NO_FOUND = 0x41 - - # The parameters passed by the BLE instruction are wrong, or the parameters passed - # by calling some functions are wrong - STATUS_PAR_ERR = 0x60 - # The mode of the current device is wrong, and the corresponding API cannot be called - STATUS_DEVICE_MODE_ERROR = 0x66 - STATUS_INVALID_CMD = 0x67 - STATUS_DEVICE_SUCCESS = 0x68 - STATUS_NOT_IMPLEMENTED = 0x69 - STATUS_FLASH_WRITE_FAIL = 0x70 - STATUS_FLASH_READ_FAIL = 0x71 - - -message = { - Device.HF_TAG_OK: "HF tag operation succeeded", - Device.HF_TAG_NO: "HF tag no found or lost", - Device.HF_ERR_STAT: "HF tag status error", - Device.HF_ERR_CRC: "HF tag data crc error", - Device.HF_COLLISION: "HF tag collision", - Device.HF_ERR_BCC: "HF tag uid bcc error", - Device.MF_ERR_AUTH: "HF tag auth fail", - Device.HF_ERR_PARITY: "HF tag data parity error", - Device.HF_ERR_ATS: "HF tag was supposed to send ATS but didn't", - - Device.LF_TAG_OK: "LF tag operation succeeded", - Device.EM410X_TAG_NO_FOUND: "EM410x tag no found", - - Device.STATUS_PAR_ERR: "API request fail, param error", - Device.STATUS_DEVICE_MODE_ERROR: "API request fail, device mode error", - Device.STATUS_INVALID_CMD: "API request fail, cmd invalid", - Device.STATUS_DEVICE_SUCCESS: "Device operation succeeded", - Device.STATUS_NOT_IMPLEMENTED: "Some api not implemented", - Device.STATUS_FLASH_WRITE_FAIL: "Flash write failed", - Device.STATUS_FLASH_READ_FAIL: "Flash read failed" -} diff --git a/software/script/chameleon_utils.py b/software/script/chameleon_utils.py index 36e1bd9..9bf2a02 100644 --- a/software/script/chameleon_utils.py +++ b/software/script/chameleon_utils.py @@ -6,7 +6,7 @@ from prompt_toolkit.completion import Completer, NestedCompleter, WordCompleter from prompt_toolkit.completion.base import Completion from prompt_toolkit.document import Document -import chameleon_status +from chameleon_enum import Status # Colorama shorthands CR = colorama.Fore.RED @@ -110,12 +110,11 @@ def expect_response(accepted_responses: Union[int, list[int]]): def error_throwing_func(*args, **kwargs): ret = func(*args, **kwargs) if ret.status not in accepted_responses: - if ret.status in chameleon_status.Device and ret.status in chameleon_status.message: - raise UnexpectedResponseError( - chameleon_status.message[ret.status]) - else: - raise UnexpectedResponseError( - f"Unexpected response and unknown status {ret.status}") + try: + status_string = str(Status(ret.status)) + except ValueError: + status_string = f"Unexpected response and unknown status {ret.status}" + raise UnexpectedResponseError(status_string) return ret.data From 6e19d078f4cf709426fffabf70f71a87d9a29908 Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Tue, 17 Oct 2023 23:56:28 +0200 Subject: [PATCH 7/7] oops, missed sth when solving the merge conflicts --- firmware/application/src/rfid/reader/hf/rc522.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/firmware/application/src/rfid/reader/hf/rc522.c b/firmware/application/src/rfid/reader/hf/rc522.c index f3678b4..ec23e49 100644 --- a/firmware/application/src/rfid/reader/hf/rc522.c +++ b/firmware/application/src/rfid/reader/hf/rc522.c @@ -649,7 +649,7 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { if (status != STATUS_HF_TAG_OK) { NRF_LOG_INFO("Tag SAK claimed to support ATS but tag NAKd RATS"); tag->ats_len = 0; - // return HF_ERR_ATS; + // return STATUS_HF_ERR_ATS; } else { ats_size -= 2; // size returned by pcd_14a_reader_ats_request includes CRC if (ats_size > 254) { @@ -660,7 +660,7 @@ uint8_t pcd_14a_reader_scan_once(picc_14a_tag_t *tag) { // We do not validate ATS here as we want to report ATS as it is without breaking 14a scan if (tag->ats[0] != ats_size - 1) { NRF_LOG_INFO("Invalid ATS! First byte doesn't match received length"); - // return HF_ERR_ATS; + // return STATUS_HF_ERR_ATS; } } /* @@ -713,7 +713,7 @@ uint8_t pcd_14a_reader_ats_request(uint8_t *pAts, uint16_t *szAts, uint16_t szAt return status; } else if (*szAts == 7 && pAts[0] == 0x4) { // tag replied with NAK *szAts = 0; - return HF_ERR_ATS; + return STATUS_HF_ERR_ATS; } NRF_LOG_INFO("Received ATS length: %d\n", *szAts);