Merge remote-tracking branch 'upstream/master' into fix/psk-fc2-bandpass

# Conflicts:
#	CHANGELOG.md
This commit is contained in:
Matthew Carroll committed 2026-10-17 23:47:19 -07:00
commit 1bc32bff15
28 files changed
+2057 -109

No files matched your search

+4 -1
View File
@@ -3,6 +3,9 @@ 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 PM5 tick-count reads across RTC second rollovers to prevent false receive timeouts
- Added `lf cotag sim` - simulate COTAG tag (@towelbyte)
- Added standalone mode `GDB_GATEWAY` (PM5): GDB Remote Serial Protocol server on the USB CDC link, flash and SRAM access, no probe needed (@nieldk)
- Fixed weak fc/2 PSK tags (Indala, NexWatch, IDTECK, ...) misreading or failing: when the wave tracker has errors, the PSK demod falls back to `pm3_psk_demod` (@mfcarroll)
- Fixed `lf t55xx detect -p` - the password is no longer sent to a tag whose PWD bit could not be confirmed, which could set it and destroy the tag's data; pass `-o` to override (@mfcarroll)
- Fixed `hf mf hardnested`/`hf mf autopwn` on PM5 with hardened MIFARE Classic EV1 (#3595, #3664) (@ByteOrderMarc)
@@ -293,7 +296,7 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
- Add support for parsing Finnish Helsinki Regional Transport (HRT) travel cards (@sanduuz)
- Added standalone mode `HF_DOEGOX_COMMIT` - DESFire suspended commit without relay (@doegox)
- Changed `hf 14b info`- now support Innovatron protocol detection (@kormax)
- Improved `lf cotag reader` and `lf cotag demod` - Reimplementation and enhancement of proxmark3 COTAG support
- Improved `lf cotag reader` and `lf cotag demod` - Reimplementation and enhancement of proxmark3 COTAG support (@towelbyte)
- Added `hf felica sim` command (@kormax)
- Added `mad read`, `mad write`, `mad verify`, `mad decode`, `mad encode` commands with typed struct MAD API (@AlxCzl)
- Added `hf mfdes getversion` command (@kormax)
+1
View File
@@ -24,6 +24,7 @@ PLATFORM=PM3RDV4
#PLATFORM_EXTRAS=BWM
#PLATFORM_EXTRAS=NO_LOWBATT_SHUTDOWN
#PLATFORM_EXTRAS=NO_LOWBATT_BEEP
#STANDALONE=GDB_GATEWAY
# If you want more than one PLATFORM_EXTRAS option, separate them by spaces:
#PLATFORM_EXTRAS=BTADDON
+4 -1
View File
@@ -149,13 +149,16 @@ define KNOWN_STANDALONE_DEFINITIONS
| DANKARMULTI | Load multiple standalone modes. |
| | - Daniel Karling |
+-----------------------------------------------------------+
| GDB_GATEWAY | Read-only GDB server over USB CDC |
| | (PM5) |
+-----------------------------------------------------------+
endef
STANDALONE_MODES := LF_SKELETON
STANDALONE_MODES += LF_EM4100EMUL LF_EM4100RSWB LF_EM4100RSWW LF_EM4100RWC LF_HIDBRUTE LF_HIDFCBRUTE LF_ICEHID LF_MULTIHID LF_NEDAP_SIM LF_NEXID LF_PROXBRUTE LF_PROX2BRUTE LF_SAMYRUN LF_THAREXDE
STANDALONE_MODES += HF_14ASNIFF HF_14BSNIFF HF_15SIM HF_15SNIFF HF_AVEFUL HF_BOG HF_CARDHOPPER HF_COLIN HF_CRAFTBYTE HF_DOEGOX_AUTH0 HF_DOEGOX_COMMIT HF_EMVPNG HF_ICECLASS HF_LEGIC HF_LEGIC_RDV4 HF_LEGICSIM HF_MATTYRUN HF_MFCSIM HF_MSDSAL HF_REBLAY HF_ST25_TEAROFF HF_TCPRST HF_TMUDFORD HF_UNISNIFF HF_YOUNG
STANDALONE_MODES += DANKARMULTI
STANDALONE_MODES += DANKARMULTI GDB_GATEWAY
STANDALONE_MODES_REQ_BT := HF_CARDHOPPER HF_REBLAY
STANDALONE_MODES_REQ_SMARTCARD :=
STANDALONE_MODES_REQ_FLASH := LF_HIDFCBRUTE LF_ICEHID LF_NEXID LF_THAREXDE HF_BOG HF_COLIN HF_ICECLASS HF_LEGIC_RDV4 HF_LEGICSIM HF_MFCSIM HF_ST25_TEAROFF
+4
View File
@@ -89,6 +89,10 @@ endif
ifneq (,$(findstring WITH_STANDALONE_HF_15SNIFF,$(APP_CFLAGS)))
SRC_STANDALONE = hf_15sniff.c
endif
# WITH_STANDALONE_GDB_GATEWAY
ifneq (,$(findstring WITH_STANDALONE_GDB_GATEWAY,$(APP_CFLAGS)))
SRC_STANDALONE = gdb_gateway.c
endif
# WITH_STANDALONE_HF_15SIM
ifneq (,$(findstring WITH_STANDALONE_HF_15SIM,$(APP_CFLAGS)))
SRC_STANDALONE = hf_15sim.c
+4 -1
View File
@@ -118,6 +118,9 @@
| HF_EMVPNG | Read and emulate EMV Visa cards |
| | - Davi Mikael (Penegui) |
+----------------------------------------------------------+
| GDB_GATEWAY | Read-only GDB server over USB CDC |
| | (PM5) |
+----------------------------------------------------------+
]]
# Default standalone if no standalone specified
@@ -137,7 +140,7 @@ set(STANDALONE_MODES
HF_14ASNIFF HF_14BSNIFF HF_15SNIFF HF_15SIM
HF_AVEFUL HF_BOG HF_CARDHOPPER HF_COLIN HF_CRAFTBYTE HF_ICECLASS
HF_LEGIC HF_LEGIC_RDV4 HF_LEGICSIM HF_MATTYRUN HF_MFCSIM HF_MSDSAL HF_REBLAY
HF_ST25_TEAROFF HF_TCPRST HF_TMUDFORD HF_UNISNIFF HF_YOUNG HF_EMVPNG DANKARMULTI)
HF_ST25_TEAROFF HF_TCPRST HF_TMUDFORD HF_UNISNIFF HF_YOUNG HF_EMVPNG DANKARMULTI GDB_GATEWAY)
# List of modes that require bluetooth
set(STANDALONE_MODES_REQ_BT HF_CARDHOPPER HF_REBLAY)
# List of modes that require smartcard
+4
View File
@@ -76,6 +76,10 @@ if ("${APP_CFLAGS}" MATCHES "WITH_STANDALONE_HF_15SNIFF")
set(SRC_STANDALONE "${DIR_STANDALONE}/hf_15sniff.c")
endif ()
if ("${APP_CFLAGS}" MATCHES "WITH_STANDALONE_GDB_GATEWAY")
set(SRC_STANDALONE "${DIR_STANDALONE}/gdb_gateway.c")
endif ()
if ("${APP_CFLAGS}" MATCHES "WITH_STANDALONE_HF_15SIM")
set(SRC_STANDALONE "${DIR_STANDALONE}/hf_15sim.c")
endif ()
+552
View File
@@ -0,0 +1,552 @@
//-----------------------------------------------------------------------------
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
// Standalone GDB gateway: GDB Remote Serial Protocol over the USB CDC link.
// Reads flash and SRAM, writes SRAM and flash (gdb 'load'), no execution control.
// Flash writes are limited to the space above the running image; the bootrom is
// never writable. 'monitor unlock-app' opens the app area, 'monitor lock' closes it.
// Start with 'hw standalone', quit the client, then:
// arm-none-eabi-gdb -ex 'target remote /dev/ttyACM0'
// Leave with 'monitor exit' or a button press.
//-----------------------------------------------------------------------------
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#define GDB_PKT_MAX 0x400u // advertised PacketSize
#define GDB_MEM_MAX ((GDB_PKT_MAX - 8u) / 2u)
#define GDB_NREGS 17u // r0-r12, sp, lr, pc, xpsr
#define GW_FLASH_BASE 0x08000000u
#define GW_FLASH_SIZE 0x00100000u
#define GW_APP_BASE 0x08004000u // bootrom below this is never writable
#define GW_SECTOR 0x800u // 1 MB part: 2 KB sectors
#define GW_SRAM_BASE 0x20000000u
#define GW_SRAM_SIZE 0x00080000u // 512K, set by Extend_SRAM() in the bootrom
typedef struct {
void (*tx)(const uint8_t *data, size_t len);
// Copy up to len bytes from addr; return bytes copied, 0 if addr is unreadable.
size_t (*mem_read)(uint32_t addr, uint8_t *out, size_t len);
// The engine checks the address window before calling these.
bool (*ram_write)(uint32_t addr, const uint8_t *data, size_t len);
bool (*flash_erase)(uint32_t sector_addr);
bool (*flash_write)(uint32_t addr, const uint8_t *data, size_t len);
uint32_t app_end; // first sector above the running image
} gdb_ops_t;
static const gdb_ops_t *s_ops;
static const char TARGET_XML[] =
"<?xml version=\"1.0\"?>"
"<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
"<target version=\"1.0\">"
"<architecture>armv7e-m</architecture>"
"<feature name=\"org.gnu.gdb.arm.m-profile\">"
"<reg name=\"r0\" bitsize=\"32\"/><reg name=\"r1\" bitsize=\"32\"/>"
"<reg name=\"r2\" bitsize=\"32\"/><reg name=\"r3\" bitsize=\"32\"/>"
"<reg name=\"r4\" bitsize=\"32\"/><reg name=\"r5\" bitsize=\"32\"/>"
"<reg name=\"r6\" bitsize=\"32\"/><reg name=\"r7\" bitsize=\"32\"/>"
"<reg name=\"r8\" bitsize=\"32\"/><reg name=\"r9\" bitsize=\"32\"/>"
"<reg name=\"r10\" bitsize=\"32\"/><reg name=\"r11\" bitsize=\"32\"/>"
"<reg name=\"r12\" bitsize=\"32\"/>"
"<reg name=\"sp\" bitsize=\"32\" type=\"data_ptr\"/>"
"<reg name=\"lr\" bitsize=\"32\"/>"
"<reg name=\"pc\" bitsize=\"32\" type=\"code_ptr\"/>"
"<reg name=\"xpsr\" bitsize=\"32\" regnum=\"25\"/>"
"</feature></target>";
static const char MEMORY_MAP_XML[] =
"<?xml version=\"1.0\"?>"
"<!DOCTYPE memory-map PUBLIC \"+//IDN gnu.org//DTD GDB Memory Map V1.0//EN\""
" \"http://sourceware.org/gdb/gdb-memory-map.dtd\">"
"<memory-map>"
"<memory type=\"flash\" start=\"0x08000000\" length=\"0x100000\">"
"<property name=\"blocksize\">0x800</property></memory>"
"<memory type=\"ram\" start=\"0x20000000\" length=\"0x80000\"/>"
"</memory-map>";
static const char HEXD[] = "0123456789abcdef";
typedef enum { ST_IDLE, ST_DATA, ST_CS1, ST_CS2 } rx_state_t;
static rx_state_t s_state;
static uint8_t s_rx[GDB_PKT_MAX + 1];
static uint16_t s_rxlen;
static uint8_t s_sum;
static int s_cs_hi;
static bool s_ovf;
static bool s_ack_pending;
static bool s_exit;
static bool s_unlocked; // app area writable
static uint8_t s_out[GDB_PKT_MAX]; // reply payload
static uint8_t s_frame[GDB_PKT_MAX + 5]; // '+' '$' payload '#' cs cs
static uint16_t s_frame_len;
static uint16_t s_frame_off; // start of the resendable part (after any ack)
static int hexval(uint8_t c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'a' && c <= 'f') return c - 'a' + 10;
if (c >= 'A' && c <= 'F') return c - 'A' + 10;
return -1;
}
static bool parse_hex(const char **p, const char *end, uint32_t *v) {
uint32_t r = 0;
int n = 0;
while (*p < end && hexval((uint8_t) * *p) >= 0) {
if (n++ >= 8) return false;
r = (r << 4) | (uint32_t)hexval((uint8_t) * *p);
(*p)++;
}
*v = r;
return n > 0;
}
static bool starts_with(const char *s, size_t len, const char *pre) {
size_t n = strlen(pre);
return len >= n && memcmp(s, pre, n) == 0;
}
static void send_payload(const uint8_t *pl, size_t len) {
size_t j = 0;
uint8_t cs = 0;
if (len > GDB_PKT_MAX) len = GDB_PKT_MAX;
if (s_ack_pending) {
s_frame[j++] = '+';
s_ack_pending = false;
}
s_frame_off = (uint16_t)j;
s_frame[j++] = '$';
for (size_t i = 0; i < len; i++) {
s_frame[j++] = pl[i];
cs = (uint8_t)(cs + pl[i]);
}
s_frame[j++] = '#';
s_frame[j++] = (uint8_t)HEXD[cs >> 4];
s_frame[j++] = (uint8_t)HEXD[cs & 0xF];
s_frame_len = (uint16_t)j;
s_ops->tx(s_frame, j);
}
static void send_str(const char *s) {
send_payload((const uint8_t *)s, strlen(s));
}
static void send_err(uint8_t e) {
char b[4] = { 'E', HEXD[e >> 4], HEXD[e & 0xF], 0 };
send_str(b);
}
static bool flash_window_ok(uint32_t addr, uint32_t len) {
uint32_t floor = s_unlocked ? GW_APP_BASE : s_ops->app_end;
uint32_t end = addr + len;
return len && addr >= floor && end > addr && end <= GW_FLASH_BASE + GW_FLASH_SIZE;
}
static bool sram_ok(uint32_t addr, uint32_t len) {
uint32_t end = addr + len;
return len && addr >= GW_SRAM_BASE && end > addr && end <= GW_SRAM_BASE + GW_SRAM_SIZE;
}
// Undo gdb binary escaping ('}' then byte ^ 0x20). Returns -1 on a dangling '}'.
static int unescape(const uint8_t *in, size_t n, uint8_t *out) {
size_t o = 0;
for (size_t i = 0; i < n; i++) {
if (in[i] == '}') {
if (++i >= n) return -1;
out[o++] = in[i] ^ 0x20;
} else {
out[o++] = in[i];
}
}
return (int)o;
}
// Serve a qXfer document slice for "OFF,LEN".
static void send_qxfer(const char *doc, const char *p, const char *end) {
uint32_t off, len;
if (!parse_hex(&p, end, &off) || p >= end || *p++ != ',' || !parse_hex(&p, end, &len)) {
send_err(0x16);
return;
}
size_t total = strlen(doc);
if (off >= total) {
send_str("l");
return;
}
size_t n = total - off;
if (n > len) n = len;
if (n > GDB_PKT_MAX - 1u) n = GDB_PKT_MAX - 1u;
s_out[0] = (off + n < total) ? 'm' : 'l';
memcpy(&s_out[1], doc + off, n);
send_payload(s_out, n + 1);
}
static void do_mem_read(const char *p, const char *end) {
uint32_t addr, len;
if (!parse_hex(&p, end, &addr) || p >= end || *p++ != ',' || !parse_hex(&p, end, &len)) {
send_err(0x16);
return;
}
if (len > GDB_MEM_MAX) len = GDB_MEM_MAX;
uint8_t tmp[GDB_MEM_MAX];
size_t n = len ? s_ops->mem_read(addr, tmp, len) : 0;
if (len && n == 0) {
send_err(0x14); // EFAULT
return;
}
for (size_t i = 0; i < n; i++) {
s_out[2 * i] = (uint8_t)HEXD[tmp[i] >> 4];
s_out[2 * i + 1] = (uint8_t)HEXD[tmp[i] & 0xF];
}
send_payload(s_out, 2 * n);
}
static void do_mem_write(const char *p, const char *end) {
uint32_t addr, len;
if (!parse_hex(&p, end, &addr) || p >= end || *p++ != ',' || !parse_hex(&p, end, &len) ||
p >= end || *p++ != ':' || len > GDB_MEM_MAX || (size_t)(end - p) != 2 * (size_t)len) {
send_err(0x16);
return;
}
if (len == 0) {
send_str("OK");
return;
}
uint8_t tmp[GDB_MEM_MAX];
for (uint32_t i = 0; i < len; i++) {
int hi = hexval((uint8_t)p[2 * i]), lo = hexval((uint8_t)p[2 * i + 1]);
if (hi < 0 || lo < 0) {
send_err(0x16);
return;
}
tmp[i] = (uint8_t)((hi << 4) | lo);
}
if (!sram_ok(addr, len)) {
send_err(0x02); // flash goes through vFlashWrite
return;
}
send_str(s_ops->ram_write(addr, tmp, len) ? "OK" : "E01");
}
static void do_vflash(const char *s, size_t len) {
const char *end = s + len;
uint32_t addr, n;
if (starts_with(s, len, "vFlashErase:")) {
const char *p = s + strlen("vFlashErase:");
if (!parse_hex(&p, end, &addr) || p >= end || *p++ != ',' || !parse_hex(&p, end, &n) ||
n == 0 || (addr % GW_SECTOR) || (n % GW_SECTOR)) {
send_err(0x16);
return;
}
if (!flash_window_ok(addr, n)) {
send_err(0x02);
return;
}
for (uint32_t a = addr; a < addr + n; a += GW_SECTOR) {
if (!s_ops->flash_erase(a)) {
send_err(0x01);
return;
}
}
send_str("OK");
} else if (starts_with(s, len, "vFlashWrite:")) {
const char *p = s + strlen("vFlashWrite:");
if (!parse_hex(&p, end, &addr) || p >= end || *p++ != ':') {
send_err(0x16);
return;
}
uint8_t data[GDB_PKT_MAX];
int dn = unescape((const uint8_t *)p, (size_t)(end - p), data);
if (dn < 0) {
send_err(0x16);
return;
}
if (!flash_window_ok(addr, (uint32_t)dn)) {
send_err(0x02);
return;
}
send_str(dn == 0 || s_ops->flash_write(addr, data, (size_t)dn) ? "OK" : "E01");
} else if (starts_with(s, len, "vFlashDone")) {
send_str("OK");
} else {
send_str("");
}
}
// monitor <cmd>: reply is the hex-encoded console text.
static void do_monitor(const char *p, const char *end) {
char cmd[24] = {0};
size_t n = 0;
while (p + 1 < end && n < sizeof(cmd) - 1) {
int hi = hexval((uint8_t)p[0]), lo = hexval((uint8_t)p[1]);
if (hi < 0 || lo < 0) break;
cmd[n++] = (char)((hi << 4) | lo);
p += 2;
}
const char *txt;
if (strcmp(cmd, "unlock-app") == 0) {
s_unlocked = true;
txt = "app area writable; erasing the running image crashes the PM5\n";
} else if (strcmp(cmd, "lock") == 0) {
s_unlocked = false;
txt = "writes limited to flash above the running image\n";
} else if (strcmp(cmd, "exit") == 0) {
s_exit = true;
txt = "leaving gdb gateway\n";
} else if (strcmp(cmd, "info") == 0) {
txt = s_unlocked ? "flash 0x08000000+1M sram 0x20000000+512K app-write on\n"
: "flash 0x08000000+1M sram 0x20000000+512K app-write off\n";
} else if (strcmp(cmd, "help") == 0) {
txt = "monitor info | unlock-app | lock | exit\n";
} else {
txt = "unknown command\n";
}
size_t t = strlen(txt);
for (size_t i = 0; i < t; i++) {
s_out[2 * i] = (uint8_t)HEXD[(uint8_t)txt[i] >> 4];
s_out[2 * i + 1] = (uint8_t)HEXD[(uint8_t)txt[i] & 0xF];
}
send_payload(s_out, 2 * t);
}
static void do_query(const char *s, size_t len) {
const char *end = s + len;
if (starts_with(s, len, "qSupported")) {
send_str("PacketSize=400;qXfer:features:read+;qXfer:memory-map:read+");
} else if (starts_with(s, len, "qXfer:features:read:target.xml:")) {
send_qxfer(TARGET_XML, s + strlen("qXfer:features:read:target.xml:"), end);
} else if (starts_with(s, len, "qXfer:memory-map:read::")) {
send_qxfer(MEMORY_MAP_XML, s + strlen("qXfer:memory-map:read::"), end);
} else if (starts_with(s, len, "qRcmd,")) {
do_monitor(s + 6, end);
} else if (starts_with(s, len, "qAttached")) {
send_str("1");
} else if (starts_with(s, len, "qfThreadInfo")) {
send_str("m1");
} else if (starts_with(s, len, "qsThreadInfo")) {
send_str("l");
} else if (len == 2 && starts_with(s, len, "qC")) {
send_str("QC1");
} else {
send_str("");
}
}
static void handle_packet(const char *s, size_t len) {
if (len == 0) {
send_str("");
return;
}
switch (s[0]) {
case '?':
case 'c': case 'C': case 's': case 'S': // no execution control
send_str("S05");
break;
case 'g': // registers are not available
memset(s_out, '0', GDB_NREGS * 8);
send_payload(s_out, GDB_NREGS * 8);
break;
case 'p':
memset(s_out, '0', 8);
send_payload(s_out, 8);
break;
case 'H': case 'T': case 'D':
send_str("OK");
break;
case 'm':
do_mem_read(s + 1, s + len);
break;
case 'M':
do_mem_write(s + 1, s + len);
break;
case 'G': case 'P': // registers are read-only
send_err(0x01);
break;
case 'v':
do_vflash(s, len);
break;
case 'q':
do_query(s, len);
break;
default: // X, Z, z, unknown
send_str("");
break;
}
}
static void gdb_reset(const gdb_ops_t *ops) {
s_ops = ops;
s_state = ST_IDLE;
s_rxlen = 0;
s_ack_pending = false;
s_exit = false;
s_unlocked = false;
s_frame_len = 0;
s_frame_off = 0;
}
static void gdb_feed(uint8_t b) {
switch (s_state) {
case ST_IDLE:
if (b == '$') {
s_rxlen = 0;
s_sum = 0;
s_ovf = false;
s_state = ST_DATA;
} else if (b == '-' && s_frame_len) {
s_ops->tx(s_frame + s_frame_off, s_frame_len - s_frame_off); // resend
} else if (b == 0x03) {
send_str("S05"); // Ctrl-C, nothing to stop
}
break;
case ST_DATA:
if (b == '#') {
s_state = ST_CS1;
} else if (b == '$') {
s_rxlen = 0;
s_sum = 0;
s_ovf = false;
} else {
if (s_rxlen < GDB_PKT_MAX) s_rx[s_rxlen++] = b;
else s_ovf = true;
s_sum = (uint8_t)(s_sum + b);
}
break;
case ST_CS1:
s_cs_hi = hexval(b);
s_state = ST_CS2;
break;
case ST_CS2: {
int lo = hexval(b);
s_state = ST_IDLE;
if (s_ovf || s_cs_hi < 0 || lo < 0 || (uint8_t)((s_cs_hi << 4) | lo) != s_sum) {
s_ops->tx((const uint8_t *)"-", 1);
} else {
s_ack_pending = true;
s_rx[s_rxlen] = 0;
handle_packet((const char *)s_rx, s_rxlen);
if (s_ack_pending) { // handler sent no reply
s_ops->tx((const uint8_t *)"+", 1);
s_ack_pending = false;
}
}
break;
}
}
}
#ifndef GDB_GATEWAY_HOST_TEST
#include "appmain.h"
#include "dbprint.h"
#include "proxmark3_arm.h"
#include "standalone.h"
#include "ticks_apis.h"
#include "util.h"
#include "usb_cdc_apis.h"
#include "usb_read_ng.h"
#include "at32f435_437_flash.h"
extern const char __os_size__[]; // linker: size of the OS image
static void usb_tx(const uint8_t *data, size_t len) {
usb_write(data, len);
}
static size_t at32_mem_read(uint32_t addr, uint8_t *out, size_t len) {
uint32_t end;
if (addr - GW_FLASH_BASE < GW_FLASH_SIZE) {
end = GW_FLASH_BASE + GW_FLASH_SIZE;
} else if (addr - GW_SRAM_BASE < GW_SRAM_SIZE) {
end = GW_SRAM_BASE + GW_SRAM_SIZE;
} else {
return 0;
}
if (len > end - addr) len = end - addr;
for (size_t i = 0; i < len; i++) {
out[i] = *(const volatile uint8_t *)(addr + i);
}
return len;
}
static bool at32_ram_write(uint32_t addr, const uint8_t *data, size_t len) {
for (size_t i = 0; i < len; i++) {
*(volatile uint8_t *)(addr + i) = data[i];
}
return true;
}
static bool at32_flash_erase(uint32_t addr) {
WDT_HIT();
flash_unlock();
flash_status_type st = flash_sector_erase(addr);
flash_lock();
return st == FLASH_OPERATE_DONE;
}
// Words are merged with the current flash content, so partial words work
// on erased sectors. Read back to verify.
static bool at32_flash_write(uint32_t addr, const uint8_t *data, size_t len) {
bool ok = true;
uint32_t end = addr + (uint32_t)len;
flash_unlock();
for (uint32_t w = addr & ~3u; w < end && ok; w += 4) {
uint32_t v = *(volatile uint32_t *)w;
for (uint32_t i = 0; i < 4; i++) {
if (w + i >= addr && w + i < end) {
v = (v & ~(0xFFu << (8 * i))) | ((uint32_t)data[w + i - addr] << (8 * i));
}
}
if (v != *(volatile uint32_t *)w) {
ok = flash_word_program(w, v) == FLASH_OPERATE_DONE && *(volatile uint32_t *)w == v;
}
}
flash_lock();
WDT_HIT();
return ok;
}
static gdb_ops_t s_at32_ops = { usb_tx, at32_mem_read, at32_ram_write, at32_flash_erase, at32_flash_write, 0 };
void ModInfo(void) {
DbpString(" GDB gateway, RSP over USB CDC");
}
// No Dbprintf here: debug frames would corrupt the RSP stream.
void RunMod(void) {
s_at32_ops.app_end = (GW_APP_BASE + (uint32_t)(uintptr_t)__os_size__ + GW_SECTOR - 1) & ~(GW_SECTOR - 1);
gdb_reset(&s_at32_ops);
LED_A_ON();
while (!s_exit && !BUTTON_PRESS()) {
WDT_HIT();
while (usb_read_ng_has_buffered_data() || usb_poll_validate_length()) {
uint8_t b;
if (usb_read_ng(&b, 1) != 1) break;
gdb_feed(b);
}
}
LED_A_OFF();
while (BUTTON_PRESS()) { // keep the main loop from reading the press as power-off
WDT_HIT();
SpinDelay(10);
}
}
#endif // GDB_GATEWAY_HOST_TEST
+1
View File
@@ -81,6 +81,7 @@ As such the information inside may be false or hallucinated.
| Mode ID | Document | Description |
|---------|----------|-------------|
| DANKARMULTI | [Dankarmulti Loader](../../doc/standalone/dankarmulti.md) | Combine multiple standalone modes into one firmware image |
| GDB_GATEWAY | [GDB Gateway](../../doc/standalone/gdb_gateway.md) | Read-only GDB server over USB CDC | PM5 |
# Developing Standalone Modes
This contains functionality for different StandAlone modes. The fullimage will be built given the correct compiler flags used. Build targets for these files are contained in `Makefile.inc` and `Makefile.hal`
+5
View File
@@ -1865,6 +1865,11 @@ static void PacketReceived(PacketCommandNG *packet) {
Cotag(payload->mode, true);
break;
}
case CMD_LF_COTAG_SIMULATE: {
SimulateCotag((const lf_cotagsim_t *)packet->data.asBytes, true);
reply_ng(CMD_LF_COTAG_SIMULATE, PM3_EOPABORTED, NULL, 0);
break;
}
#endif
#ifdef WITH_HITAG
+237
View File
@@ -2980,6 +2980,243 @@ void Cotag(uint32_t arg0, bool ledcontrol) {
if (ledcontrol) LEDsoff();
}
#define COTAG_STEP_K 32 // samples per box of the step filter
// a detected activation, for debug output
typedef struct {
uint32_t dt; // samples between the two rises
int32_t thr; // threshold the second rise crossed
} cotag_detect_val_t;
// Block until the reader's activation sequence is detected. Return false on button press or USB data.
static bool cotag_activation_sequence_detect(const lf_cotagsim_t *params, cotag_detect_val_t *out) {
// Reader's tag activation sequence:
// - ON 800 us, OFF 2200 us
// - ON ~5800 us (the tag is expected to respond in this window)
// - OFF ~16500 us (reader's pause if no tag detected, then repeat)
//
// We detect 2 rising edges between ON(800),OFF(2200),ON(5800), i.e. approx 3000us apart.
// Plus minus some tolerance, thus win_lo and win_hi.
// Number of samples between 2 rising edges to look for an activation sequence
const uint32_t win_lo = (3000 - 300) * 12 / (LF_COTAG_DIVISOR + 1);
const uint32_t win_hi = (3000 + 300) * 12 / (LF_COTAG_DIVISOR + 1);
// Samples ring buffer
uint8_t ring[2 * COTAG_STEP_K] = {0};
uint8_t idx = 0; // points to the oldest sample
int32_t sum_new = 0, sum_old = 0; // sum of the newest (oldest) COTAG_STEP_K samples
int32_t peak_recent_step = 0; // peak of step, scaled by 65536 so the decay below cannot truncate to zero
uint32_t sample_cnt = 0;
uint32_t last_rise = 0; // sample_cnt at the previous detected rising edge
bool armed = true;
uint16_t checked = 0;
for (;;) {
WDT_HIT();
if (++checked >= 4000) {
checked = 0;
if (BUTTON_PRESS() || data_available()) {
return false;
}
}
if (FPGA_SSC_RX_Ready() == false) {
continue;
}
uint8_t sample = FPGA_SSC_RX_Value();
// Recalculate sum_new and sum_old.
// sample (new) added to sum_new; mid subtracted from sum_new and added to sum_old,
// ring[idx] (oldest) subtracted from sum_old and discarded.
uint8_t mid = ring[(idx + COTAG_STEP_K) % (2 * COTAG_STEP_K)];
sum_new += sample - mid;
sum_old += mid - ring[idx];
ring[idx] = sample;
idx = (idx + 1) % (2 * COTAG_STEP_K);
if (++sample_cnt < 2 * COTAG_STEP_K) {
continue; // wait for the ring buffer to fill up first
}
// Step filter
int32_t step = sum_new - sum_old;
if (step * 65536 > peak_recent_step) {
peak_recent_step = step * 65536; // attack at once
} else {
peak_recent_step -= peak_recent_step >> 13; // release slowly, tau 2^13 samples
}
// use threshold as half the recent peak step (adapting to reader distance)
// (undo scaling by 65536 aka 2^16, then divide by 2: thus >> 17)
int32_t thr = MAX(params->thr_floor, peak_recent_step >> 17);
// Rising edge detection: Schmitt trigger so that we get one event per rise:
// trigger once when step >= thr, then disarm, only re-arm if step falls below thr/4
if (armed && step >= thr) {
armed = false;
uint32_t dt = sample_cnt - last_rise; // number of samples since the previous rise
if (last_rise && dt >= win_lo && dt <= win_hi) {
// Activation sequence detected
out->dt = dt;
out->thr = thr;
return true;
}
last_rise = sample_cnt;
} else if (step <= thr / 4) {
// step enough below the thr, re-arm Schmitt trigger
armed = true;
}
}
}
#define COTAG_TX_HALFBIT_CYCLES (384 / 2) // Number of samples per half bit
#define COTAG_TX_SYNC_HALFBITS 4 // two leading sync 0 bits
#define COTAG_TX_MAX_HALFBITS (COTAG_TX_SYNC_HALFBITS + 2 * 8 * LF_COTAG_SIM_DATA_LEN)
#define COTAG_SSC_STALL 100000
#define COTAG_SETTLE_US 10000
// Discard count samples ("wait count samples"). Return false on error.
static bool cotag_skip_samples(uint32_t count) {
while (count--) {
uint32_t guard = 0;
while (FPGA_SSC_RX_Ready() == false) {
if (++guard > COTAG_SSC_STALL) {
return false;
}
}
(void)FPGA_SSC_RX_Value();
}
return true;
}
static uint16_t cotag_build_halfbits(uint8_t *half_bits, const uint8_t *data, uint8_t nbits) {
// Two leading/sync 0 bits, manchester encoded
half_bits[0] = 0;
half_bits[1] = 1;
half_bits[2] = 0;
half_bits[3] = 1;
uint16_t nhb = COTAG_TX_SYNC_HALFBITS;
for (uint8_t i = 0; i < nbits; i++) {
// bits in reverse order:
uint8_t src = nbits - 1 - i;
uint8_t bit = (data[src >> 3] >> (7 - (src & 7))) & 1;
// manchester encode the bit:
half_bits[nhb++] = bit;
half_bits[nhb++] = bit ^ 1;
}
return nhb;
}
// Send COTAG frame's half bits. Return false on button press, USB data, or error.
static bool cotag_tx_frame(const uint8_t *half_bits, uint16_t nhb, uint8_t repeats, uint16_t hb_delay_us) {
Gpio_SSC_DOUT_High();
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, LF_COTAG_TX_DIVISOR);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
bool ok = true;
for (uint8_t r = 0; r < repeats && ok; r++) {
// Send precomputed half bits. Leading sync bits are sent only at first repetition
for (uint16_t i = (r == 0) ? 0 : COTAG_TX_SYNC_HALFBITS; i < nhb; i++) {
if (half_bits[i]) {
Gpio_SSC_DOUT_Low();
} else {
Gpio_SSC_DOUT_High();
}
if (hb_delay_us) {
SpinDelayUsPrecision(hb_delay_us);
} else if (cotag_skip_samples(COTAG_TX_HALFBIT_CYCLES) == false) {
ok = false;
break;
}
if (BUTTON_PRESS()) {
ok = false;
break;
}
}
WDT_HIT();
if (data_available()) {
ok = false;
break;
}
}
Gpio_SSC_DOUT_High();
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC);
Gpio_SSC_DOUT_Low(); // back to "listening"
return ok;
}
void SimulateCotag(const lf_cotagsim_t *params, bool ledcontrol) {
LFSetupFPGAForADC(LF_COTAG_DIVISOR, false);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC);
gpio_fpga_mod_only_setup();
Gpio_SSC_DOUT_Low();
BigBuf_free();
BigBuf_Clear_ext(false);
uint8_t *half_bits = BigBuf_calloc(COTAG_TX_MAX_HALFBITS);
if (half_bits == NULL) {
if (g_dbglevel >= DBG_ERROR) DbpString("SimulateCotag: failed to allocate buffer");
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
return;
}
uint8_t nbits = MIN(params->nbits, 8 * LF_COTAG_SIM_DATA_LEN);
// Precompute the Manchester halfbits to send
uint16_t nhb = cotag_build_halfbits(half_bits, params->data, nbits);
const uint32_t settle = COTAG_SETTLE_US * 12 / (LF_COTAG_DIVISOR + 1);
cotag_detect_val_t val;
while (cotag_activation_sequence_detect(params, &val)) {
if (nbits) {
if (ledcontrol) LED_C_ON();
// Transmit frame
bool ok = cotag_tx_frame(half_bits, nhb, params->repeats, params->hb_delay_us);
if (ledcontrol) LED_C_OFF();
if (ok == false) {
break;
}
// Done transmitting. Back to our RX sampling divisor:
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, LF_COTAG_DIVISOR);
cotag_skip_samples(settle);
}
// Debug print only after done TXing frame
if (params->verbose || nbits == 0) {
Dbprintf("COTAG reader activation sequence detected (rise-to-rise " _YELLOW_("%u") " us, threshold %d)",
val.dt * (LF_COTAG_DIVISOR + 1) / 12, val.thr);
}
}
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
if (ledcontrol) LEDsoff();
BigBuf_free();
}
/*
* EM4305 support
*/
+1
View File
@@ -79,6 +79,7 @@ void EM4xProtectWord(uint32_t data, uint32_t pwd, uint8_t usepwd, bool ledcontro
void cotag_start_pulse(void);
void Cotag(uint32_t arg0, bool ledcontrol);
void SimulateCotag(const lf_cotagsim_t *params, bool ledcontrol);
void setT55xxConfig(uint8_t persist, const t55xx_configurations_t *c);
t55xx_configurations_t *getT55xxConfig(void);
void printT55xxConfig(void);
+6
View File
@@ -387,6 +387,12 @@ bool cep_spi_data_available(void) {
}
s_last_spi_activity_tick = GetTickCount(); // FAP is still polling, valid frame or not
uint16_t data_len = (len_header[1] << 8) | len_header[0];
if (data_len == 0xFFFF) {
// FAP's reply-poll drives 0xFF dummy bytes when it has nothing to
// send (furi_hal_spi_bus_trx with a NULL tx buffer) - not a desync,
// same treatment as a CEP_SYNC_BYTE run, no resync needed.
return false;
}
if (data_len > PM3_CMD_DATA_SIZE * 2) {
// Same reasoning: an implausible length is itself evidence of a
// desynced read, not just "no frame yet."
+625
View File
@@ -0,0 +1,625 @@
#!/usr/bin/env python3
# Licensed at MIT license
# Tool to analyze and patch Niimbot label printers RFID tags or clone them into other tags.
# Tag contents (NTAG) are encrypted are contain a security record computed from card UUID,
# therefore cloning a card contents to another one will not work and such tag will be rejected by a printer.
# You need a Proxmark3 card dump in PM3 bin or json file. Patching will modify this dump so you need to
# upload it again to a card.
# Note that Niimbot mobile app keeps copy of those values on their servers so resetting the tag print counter
# may not work in the long term.
# Usage:
# python3 niimbot_tag_patcher.py --help
# python3 niimbot_tag_patcher.py analyze -i tag-dump.json -f pm3-json
# Patch the print counter, set it back to 0 and write the file to patched.json
# (format of the pached file is always the same as input file)
# python3 niimtag.py patch -i tag-dump.json -f pm3-json --print-counter 0 -w patched.json
# (C) 2026 PhaseLoop
import argparse
import binascii
import json
from ctypes import c_uint32 as uint32
from dataclasses import dataclass, field
from struct import pack, unpack
from typing import Self
CRYPTO_KEY = bytes(
[
0xA1,
0xCC,
0x00,
0x00,
0xB7,
0x72,
0x00,
0x00,
0x58,
0x67,
0x00,
0x00,
0xC9,
0x65,
0x00,
0x00,
]
)
# from Proxmark3 bin dump file format
PM3_MFU_DUMP_PREFIX_LENGTH = 56
# Tag research and structures based on open research here:
# https://printers.niim.blue/other/rfig-tags/
# security check value at 0x08 presented there is computed wrong
# tea_decrypt and tea_encrypt shamelessly stolen from
# https://github.com/devsli/tea_cipher/tree/master
# licensed as MIT license.
# Modified to unpack/pack integers as little endian to match
# ARM architecture in printers
def tea_decrypt(ciphertext, key, delta=0x9E3779B9):
"""
Decrypt a ciphertext using TEA algorithm.
ciphertext: 64 bits length bytes-like object.
key: 128 bits length bytes-like object.
Return a 64 bits length bytes object.
"""
v0, v1 = map(uint32, unpack("<2I", ciphertext))
k0, k1, k2, k3 = map(uint32, unpack("<4I", key))
sm, delta = uint32(0xC6EF3720), uint32(delta)
for i in range(32):
v1.value -= (
((v0.value << 4) + k2.value)
^ (v0.value + sm.value)
^ ((v0.value >> 5) + k3.value)
)
v0.value -= (
((v1.value << 4) + k0.value)
^ (v1.value + sm.value)
^ ((v1.value >> 5) + k1.value)
)
sm.value -= delta.value
return pack("<2I", v0.value, v1.value)
def tea_encrypt(plaintext, key, delta=0x9E3779B9):
"""
Encrypt a plaintext using TEA algorithm.
plaintext: 64 bits length bytes-like object.
key: 128 bits length bytes-like object.
Return a 64 bits length bytes object.
"""
v0, v1 = map(uint32, unpack("<2I", plaintext))
k0, k1, k2, k3 = map(uint32, unpack("<4I", key))
sm, delta = uint32(0), uint32(delta)
for i in range(32):
sm.value += delta.value
v0.value += (
((v1.value << 4) + k0.value)
^ (v1.value + sm.value)
^ ((v1.value >> 5) + k1.value)
)
v1.value += (
((v0.value << 4) + k2.value)
^ (v0.value + sm.value)
^ ((v0.value >> 5) + k3.value)
)
return pack("<2I", v0.value, v1.value)
class CardLoadError(Exception): ...
class LabelValueError(Exception): ...
class CLIError(Exception): ...
@dataclass
class LabelTag:
PRINT_COUNTER_OFFSET = 0x02 # 16 bit LE
PRINT_COUNTER_CRC32_OFFSET = 0x04
LABEL_SECURITY_RECORD_OFFSET = 0x08
LABEL_SECURITY_RECORD_LENGTH = 7
VENDOR_DATA_OFFSET = 0x14
VENDOR_DATA_LENGTH = 0x78
SERIAL_OFFSET = 0x10
SERIAL_FIELD_SIZE = 16
BARCODE_OFFSET = 0x28
BARCODE_FIELD_SIZE = 13
NAME_OFFSET = 0x46
NAME_FIELD_SIZE = 20
PAPER_WIDTH_OFFSET = 0x5A
PAPER_HEIGHT_OFFSET = 0x5B
PRINT_LIMIT_OFFSET = 0x5C
card_data: bytearray = field(
default_factory=bytearray
) # full NTAG card data, starting from sector 0
encrypted_data: bytearray = field(
default_factory=bytearray
) # encrypted data, sectors 5-34
vendor_data: bytearray = field(
default_factory=bytearray
) # decrypted data from sectors 5-34
def field_to_uint8(self, offset) -> int:
return unpack(
"<B",
bytes(self.vendor_data[offset : offset + 1]),
)[0]
def uint8_to_field(self, offset, value: int) -> None:
assert 0 <= value <= 255, "value must be between 0 and 255"
field_value = pack("<B", value)
self.vendor_data[offset : offset + 1] = field_value
def uint32_to_field(self, offset, value: int) -> None:
field_value = pack("<I", value)
self.vendor_data[offset : offset + 4] = field_value
def field_to_text(self, offset, max_size) -> str:
text = ""
for i in range(max_size):
char_byte = self.vendor_data[offset + i]
if char_byte == 0x00: # end of string
break
else:
text += bytes([char_byte]).decode("utf-8")
return text
def text_to_field(self, offset: int, max_size: int, value: str) -> None:
encoded_text = value.encode("utf-8")
# cut text to match max_size - 1 byte to keep \0 termination
encoded_text = bytes(encoded_text[0 : max_size - 1])
# zeroed buffer is filled with encoded text minus one so string is always terminated with \0
# it will probably break unicode if it gets cut in the middle of a 16/32 bit value
buffer = bytearray(max_size)
buffer[0 : len(encoded_text)] = encoded_text
self.vendor_data[offset:offset+max_size] = buffer
@property
def barcode(self) -> str:
barcode_text = ""
for i in range(self.BARCODE_FIELD_SIZE):
char_byte = self.vendor_data[self.BARCODE_OFFSET + i]
if char_byte == 0x00: # end of string
break
else:
barcode_text += bytes([char_byte]).decode("utf-8")
return barcode_text
@property
def name(self) -> str:
return self.field_to_text(self.NAME_OFFSET, self.NAME_FIELD_SIZE)
@name.setter
def name(self, value) -> None:
self.text_to_field(self.NAME_OFFSET, self.NAME_FIELD_SIZE, value)
@property
def paper_width(self) -> int:
return self.field_to_uint8(self.PAPER_WIDTH_OFFSET)
@paper_width.setter
def paper_width(self, value: int) -> None:
self.uint8_to_field(self.PAPER_WIDTH_OFFSET, value)
@property
def paper_height(self) -> int:
return self.field_to_uint8(self.PAPER_HEIGHT_OFFSET)
@paper_height.setter
def paper_height(self, value: int) -> None:
self.uint8_to_field(self.PAPER_HEIGHT_OFFSET, value)
@property
def print_counter(self) -> int:
print_count = unpack(
"<H",
bytes(
self.vendor_data[
self.PRINT_COUNTER_OFFSET : self.PRINT_COUNTER_OFFSET + 2
]
),
)
return print_count[0]
@print_counter.setter
def print_counter(self, value:int):
self.uint8_to_field(self.PRINT_COUNTER_OFFSET, value)
@property
def print_counter_crc32(self) -> int:
print_counter_crc32 = unpack(
"<I",
bytes(
self.vendor_data[
self.PRINT_COUNTER_CRC32_OFFSET : self.PRINT_COUNTER_CRC32_OFFSET
+ 4
]
),
)
return print_counter_crc32[0]
@print_counter_crc32.setter
def print_counter_crc32(self, value:int):
return self.uint32_to_field(self.PRINT_COUNTER_CRC32_OFFSET, value)
@property
def print_limit(self) -> int:
print_limit = unpack(
"<B",
bytes(
self.vendor_data[self.PRINT_LIMIT_OFFSET : self.PRINT_LIMIT_OFFSET + 1]
),
)
return print_limit[0]
@property
def reencrypted_data(self) -> bytes:
# reencrypt card data using current "vendor_data" buffer which may have been
# modified by us
buffer = bytearray()
# encrypt self.vendor_data in 8 byte increments (because that's how TEA works)
for vendor_block in (
self.vendor_data[pos : pos + 8]
for pos in range(0, len(self.encrypted_data), 8)
):
buffer += bytearray(tea_encrypt(vendor_block, CRYPTO_KEY))
assert len(buffer) == len(
self.vendor_data
), f"Internal error - vendor data len {len(buffer)} != ciphertext len ({len(self.vendor_data)})"
return bytes(buffer)
@property
def security_record(self) -> bytes:
return bytes(
self.vendor_data[
self.LABEL_SECURITY_RECORD_OFFSET : self.LABEL_SECURITY_RECORD_OFFSET
+ self.LABEL_SECURITY_RECORD_LENGTH
]
)
@security_record.setter
def security_record(self, value: bytes) -> None:
assert len(value) == self.LABEL_SECURITY_RECORD_LENGTH
self.vendor_data[
self.LABEL_SECURITY_RECORD_OFFSET : self.LABEL_SECURITY_RECORD_OFFSET
+ self.LABEL_SECURITY_RECORD_LENGTH
] = bytearray(value)
@property
def serial(self) -> str:
return self.field_to_text(self.SERIAL_OFFSET, self.SERIAL_FIELD_SIZE)
@property
def uuid(self) -> str:
return bytes(self.card_data[0:8]).hex().upper()
def compute_security_record(self, card_uuid: bytes | None = None) -> bytes:
# note that UUID byte with index 3 is skipped
record_uuid = card_uuid or bytes(self.card_data[0:7])
return bytes(
[
0x88,
record_uuid[0],
record_uuid[1],
record_uuid[2],
record_uuid[4],
record_uuid[5],
record_uuid[6],
]
)
def compute_print_counter_crc32(self) -> int:
data = self.vendor_data[
0:4
] # CRC32 is computed over first 4 bytes of a card - unknown field and a 16 bit print counter
return binascii.crc32(data)
def process_card_data(self):
# copy vendor data to encrypted_data array
self.encrypted_data = self.card_data[
self.VENDOR_DATA_OFFSET : self.VENDOR_DATA_OFFSET + self.VENDOR_DATA_LENGTH
]
# decrypt encrypted_data into vendor_data in 8 byte increments (because that's how TEA works)
for encrypted_block in (
self.encrypted_data[pos : pos + 8]
for pos in range(0, len(self.encrypted_data), 8)
):
self.vendor_data += bytearray(tea_decrypt(encrypted_block, CRYPTO_KEY))
assert len(self.vendor_data) == len(
self.encrypted_data
), "Internal error - vendor data len != ciphertext len"
@classmethod
def validate_pm3json_dump(cls, dump: dict):
if not "Created" in dump and not "blocks" in dump:
raise CardLoadError(
"File does not look like Proxmark3-compatible json dump"
)
if dump.get("FileType") != "mfu":
raise CardLoadError("File is not an mfu card dump")
if not isinstance(dump["blocks"], dict):
raise CardLoadError(
"'blocks' object in file is not a list, probably wrong file format"
)
if len(dump["blocks"]) < int(
(cls.VENDOR_DATA_LENGTH + cls.VENDOR_DATA_OFFSET) / 4
):
raise CardLoadError(
"card dump does not look like Niimbot RFID card - size too small"
)
@classmethod
def from_pm3json(cls, input: str) -> Self:
dump = json.loads(input)
cls.validate_pm3json_dump(dump)
tag = cls()
for block_num in range(35):
block_hex = dump["blocks"].get(f"{block_num}")
if block_hex is None:
raise CardLoadError(f"No block {block_num} found in loaded card dump")
block = bytes.fromhex(block_hex)
tag.card_data += bytearray(block)
tag.process_card_data()
return tag
def patch_pm3json(self, input: str) -> str:
# we can't really generate PM3 dump from scratch so we just load the same dump
# and replace vendor sectors with updated ones
dump = json.loads(input)
self.validate_pm3json_dump(dump)
start_block = int(self.VENDOR_DATA_OFFSET / 4)
number_of_blocks = int(self.VENDOR_DATA_LENGTH / 4)
encrypted_data = self.reencrypted_data
for block_num in range(start_block, start_block + number_of_blocks):
# beginning of encrypted data is block 5 in a card dump so when accessing it by block_num we need to offset that
new_block = bytes(encrypted_data[(block_num-start_block) * 4 : ((block_num-start_block) * 4) + 4]).hex().upper()
dump["blocks"][str(block_num)] = new_block
return json.dumps(dump, indent=2)
@classmethod
def from_pm3bin(cls, input: bytes) -> Self:
if len(input) < PM3_MFU_DUMP_PREFIX_LENGTH + (
cls.VENDOR_DATA_LENGTH + cls.VENDOR_DATA_OFFSET
):
raise CardLoadError(
"card dump does not look like Niimbot RFID card - size too small"
)
tag = cls()
tag.card_data = bytearray(input[PM3_MFU_DUMP_PREFIX_LENGTH:])
tag.process_card_data()
return tag
def load_tag(args: argparse.Namespace) -> LabelTag:
open_mode = "r"
if args.file_format == "pm3-bin":
open_mode += "b"
tag_contents = None
with open(args.input_file, open_mode) as tag_file:
tag_contents = tag_file.read()
if args.file_format == "pm3-json":
return LabelTag.from_pm3json(tag_contents)
elif args.file_format == "pm3-bin":
return LabelTag.from_pm3bin(tag_contents)
else:
raise CLIError("Unknown file format specified")
def save_tag(args: argparse.Namespace, tag: LabelTag) -> None:
open_mode_read = "r"
open_mode_write = "w"
if args.file_format == "pm3-bin":
open_mode_read += "b"
open_mode_write += "b"
with open(args.input_file, open_mode_read) as input_tag_file:
tag_contents = input_tag_file.read()
if args.file_format == "pm3-json":
patched_tag = tag.patch_pm3json(tag_contents)
elif args.file_format == "pm3-bin":
raise CLIError("bin not yet supported for patching")
else:
raise CLIError("Unknown file format specified")
with open(args.write_file, open_mode_write) as output_tag_file:
output_tag_file.write(patched_tag)
def tag_analyze(args: argparse.Namespace) -> None:
tag = load_tag(args)
print("==== Decoded RFID tag contents: ====")
print(f"Card UUID: {tag.uuid}")
print(f"Tag name: {tag.name}")
print(f"Label print counter: {tag.print_counter}")
print(f"Label paper width: {tag.paper_width}")
print(f"Label paper width: {tag.paper_height}")
print(f"Label print limit: {tag.print_limit}")
print(f"Label serial number: {tag.serial}")
print(f"Label barcode: {tag.barcode}")
print()
if tag.compute_security_record() == tag.security_record:
print("Security record value valid")
else:
print("Security record value INVALID")
print(
f"Security record field value computed for current card UUID: {tag.compute_security_record().hex()}"
)
print(f"Security record field retrieved from dump: {tag.security_record.hex()}")
if tag.compute_print_counter_crc32() == tag.print_counter_crc32:
print("Print counter CRC32 checksum valid")
else:
print("Print counter CRC32 checksum INVALID")
def tag_patch(args: argparse.Namespace) -> None:
if not args.write_file:
raise CLIError("You need specify a file to write the patched RFID dump.")
tag = load_tag(args)
if args.name is not None:
tag.name = args.name
if args.width is not None:
if args.width < 0 or args.width > 255:
raise LabelValueError("Paper width must be between 0 and 255 mm")
tag.paper_width = args.width
if args.height is not None:
if args.height < 0 or args.height > 255:
raise LabelValueError("Paper height must be between 0 and 255 mm")
tag.paper_heigth = args.height
if args.print_counter is not None:
tag.print_counter = args.print_counter
tag.print_counter_crc32 = tag.compute_print_counter_crc32()
if args.fix_security_record:
card_uuid = bytes.fromhex(args.uuid) if args.uuid else None
tag.security_record = tag.compute_security_record(card_uuid=card_uuid)
save_tag(args, tag)
def main():
parser = argparse.ArgumentParser(
prog="ProgramName", description="Analyze and patch Niimbot label RFID chips"
)
parser.add_argument(
"-i", "--input-file", help="RFID dump file to read", required=True
)
parser.add_argument(
"-f",
"--file-format",
help="RFID dump file format",
choices=["pm3-json", "pm3-bin"],
required=True,
)
parser.add_argument(
"-w", "--write-file", help="RFID dump file to write (same format as input)"
)
parser.add_argument("--name", "--name", help="set roll name")
parser.add_argument("--width", "--width", help="set paper width (in mm)", type=int)
parser.add_argument(
"--height", "--height", help="set paper height (in mm)", type=int
)
parser.add_argument(
"--print-counter",
"--print-counter",
help="set label print counter (counter of already printed labels) <0, 255>",
type=int,
)
parser.add_argument(
"--print-limit",
"--print-limit",
help="set label print limit <0, 255>",
type=int,
)
parser.add_argument(
"--fix-security-record",
"--fix-security-record",
help="fix security record to match card UUID",
action='store_true',
)
parser.add_argument(
"--uuid",
"--uuid",
help="use this card UUID instead of one in dump file to calculate security check",
type=str,
)
parser.add_argument(
"command", help="Command to execute", choices=["analyze", "patch"]
)
args = parser.parse_args()
if args.command == "analyze":
return tag_analyze(args)
elif args.command == "patch":
return tag_patch(args)
else:
print(f"Unknown command: {args.command}")
if __name__ == "__main__":
main()
+163 -86
View File
@@ -9680,7 +9680,7 @@ static int gdm_write_config(uint8_t wakeup, uint8_t auth_cmd, const uint8_t *key
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write config. Status: %d", resp.status);
return PM3_EFAILED;
return resp.status;
}
return PM3_SUCCESS;
}
@@ -10052,10 +10052,12 @@ static int CmdHF14AGen4_GDM_SetCfg(const char *Cmd) {
if (resp.status == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "Write ( " _GREEN_("ok") " )");
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("hf mf gdmgetcfg") "` to verify");
} else if (resp.status == PM3_ETEAROFF) {
PrintAndLogEx(INFO, "Tear off triggered");
} else {
PrintAndLogEx(FAILED, "Write ( " _RED_("fail") " )");
}
return PM3_SUCCESS;
return resp.status;
}
// Config flag mode
@@ -10128,8 +10130,9 @@ static int CmdHF14AGen4_GDM_SetCfg(const char *Cmd) {
}
// Step 2: Write config
if (gdm_write_config(wakeup_type, auth_cmd, key, config) != PM3_SUCCESS) {
return PM3_EFAILED;
int res = gdm_write_config(wakeup_type, auth_cmd, key, config);
if (res != PM3_SUCCESS) {
return res;
}
PrintAndLogEx(SUCCESS, "Config updated successfully");
@@ -10234,7 +10237,7 @@ static int CmdHF14AGen4_GDM_SetBlk(const char *Cmd) {
} else {
PrintAndLogEx(FAILED, "Write ( " _RED_("fail") " )");
}
return PM3_SUCCESS;
return resp.status;
}
static int CmdHF14AGen4_GDM_SetHidBlk(const char *Cmd) {
@@ -10379,7 +10382,7 @@ static int CmdHF14AGen4_GDM_SetHidBlk(const char *Cmd) {
} else {
PrintAndLogEx(FAILED, "Write ( " _RED_("fail") " )");
}
return PM3_SUCCESS;
return resp.status;
}
// Shared worker for gdmgetblk / gdmgethidblk: reads a single block (--blk) or a
@@ -10631,8 +10634,9 @@ static int CmdHF14AGen4_GDM_SetUid(const char *Cmd) {
// Step 3: Write config if needed
if (update_config) {
if (gdm_write_config(wakeup_type, auth_cmd, key, config) != PM3_SUCCESS) {
return PM3_EFAILED;
int res = gdm_write_config(wakeup_type, auth_cmd, key, config);
if (res != PM3_SUCCESS) {
return res;
}
PrintAndLogEx(SUCCESS, "Config updated successfully");
}
@@ -10647,7 +10651,7 @@ static int CmdHF14AGen4_GDM_SetUid(const char *Cmd) {
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write hidden block 0. Status: %d", resp.status);
return PM3_EFAILED;
return resp.status;
}
PrintAndLogEx(SUCCESS, "Hidden block 0 updated successfully");
}
@@ -10661,18 +10665,73 @@ static int CmdHF14AGen4_GDM_SetUid(const char *Cmd) {
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write real block %d. Status: %d", write_payload.block_no, resp.status);
return PM3_EFAILED;
return resp.status;
}
PrintAndLogEx(SUCCESS, "Real block %d updated successfully", write_payload.block_no);
return PM3_SUCCESS;
}
static int gdm_wipe_write_block(const gdm_wakeup_t *w, uint8_t write_cmd, uint8_t block_no, const uint8_t *data) {
mf_writeblock_ex_t payload = {
.wakeup = w->wakeup_type,
.auth_cmd = w->auth_cmd,
.write_cmd = write_cmd,
.block_no = block_no
};
memcpy(payload.key, w->key, sizeof(payload.key));
memcpy(payload.block_data, data, sizeof(payload.block_data));
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&payload, sizeof(payload));
PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false) {
PrintAndLogEx(FAILED, "Block %u write timed out", block_no);
return PM3_ETIMEOUT;
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Block %u write failed. Status: %d", block_no, resp.status);
return resp.status;
}
return PM3_SUCCESS;
}
static int gdm_wipe_verify_uid(const uint8_t *expected_uid) {
clearCommandBuffer();
SendIso14aReader(ISO14A_CONNECT | ISO14A_CLEARTRACE | ISO14A_NO_DISCONNECT, NULL, 0);
PacketResponseNG resp;
uint8_t select_status = 0;
if (WaitForIso14aReply(&resp, 2500, NULL, &select_status) == false) {
DropField();
PrintAndLogEx(FAILED, "Could not select the card after writing the clean config");
return PM3_ETIMEOUT;
}
iso14a_card_select_t card;
memcpy(&card, resp.data.asBytes, sizeof(card));
DropField();
if (select_status == 0 || card.uidlen != 4 || memcmp(card.uid, expected_uid, 4) != 0) {
PrintAndLogEx(FAILED, "Clean UID verification failed");
if (select_status != 0) {
PrintAndLogEx(INFO, "Expected UID: %s", sprint_hex(expected_uid, 4));
PrintAndLogEx(INFO, "Selected UID: %s", sprint_hex(card.uid, card.uidlen));
}
return PM3_EFAILED;
}
PrintAndLogEx(SUCCESS, "Selected clean UID: %s", sprint_hex(card.uid, card.uidlen));
return PM3_SUCCESS;
}
static int CmdHF14AGen4_GDM_Wipe(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "hf mf gdmwipe",
"Wipe a GDM card to factory defaults.\n"
"With no wakeup flag it auto-detects a backdoor (gen1a or gdm alt); a WUPA-only card is rejected.",
"Wipe a GDM card to a known clean 4-byte template.\n"
"Sets UID to 11223344, clears real and hidden data blocks, and sets sector trailers to default values.\n"
"With no wakeup flag it auto-detects a backdoor; a WUPA-only card is rejected.",
"hf mf gdmwipe --gdm"
);
void *argtable[] = {
@@ -10706,51 +10765,49 @@ static int CmdHF14AGen4_GDM_Wipe(const char *Cmd) {
if (wres != PM3_SUCCESS) {
return wres;
}
if (gw.wakeup_type == MF_WAKE_WUPA) {
PrintAndLogEx(WARNING, "hf mf gdmwipe needs a gen1a/gdm backdoor; WUPA magic auth is insufficient");
PrintAndLogEx(HINT, "Hint: enable one first: " _YELLOW_("hf mf gdmsetcfg --wakestyle gen1a --wupa -k <key>"));
return PM3_EFAILED;
}
uint8_t wakeup_type = gw.wakeup_type;
uint8_t auth_cmd = gw.auth_cmd;
memcpy(key, gw.key, sizeof(key));
// Step 1: Write Config (gen1a + wupa + 4B UID)
uint8_t standard_config[MFBLOCK_SIZE] = {0x7A, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0x00, 0x00, 0x00, 0x08};
uint8_t clean_config[MFBLOCK_SIZE] = {0x7A, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0x00, 0x00, 0x00, 0x08};
uint8_t cur_config[MFBLOCK_SIZE] = {0};
if (gdm_read_config(wakeup_type, auth_cmd, key, cur_config) == PM3_SUCCESS) {
standard_config[2] = cur_config[2];
if (gdm_read_config(wakeup_type, auth_cmd, key, cur_config) != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Cannot preserve the current wakeup style; no data was changed");
return PM3_EFAILED;
}
if (cur_config[2] == 0x00 || cur_config[2] == 0x85) {
clean_config[2] = cur_config[2];
} else {
PrintAndLogEx(WARNING, "Could not read current config, keeping the default wakeup style");
clean_config[2] = (wakeup_type == MF_WAKE_GDM_ALT) ? 0x85 : 0x00;
PrintAndLogEx(WARNING, "Unknown wakeup style %02X; using %s", cur_config[2],
clean_config[2] == 0x85 ? "gdm alt (20/23)" : "gen1a (40/43)");
}
mf_writeblock_ex_t config_payload = {
.wakeup = wakeup_type,
.auth_cmd = auth_cmd,
.write_cmd = MIFARE_MAGIC_GDM_WRITE_CFG, // 0xE1
.block_no = 0
};
memcpy(config_payload.key, key, 6);
memcpy(config_payload.block_data, standard_config, MFBLOCK_SIZE);
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&config_payload, sizeof(config_payload));
PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false || resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write standard config. Status: %d", resp.status);
} else {
PrintAndLogEx(SUCCESS, "Standard config written");
}
// Step 2: Wipe sectors
int max_sector = wipe_4k ? 40 : 16;
uint8_t default_data[MFBLOCK_SIZE] = {0};
uint8_t default_trailer[MFBLOCK_SIZE] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x80, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t block0_data[MFBLOCK_SIZE] = {0xDE, 0x77, 0x15, 0xB8, 0x04, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
mf_writeblock_ex_t write_payload = {
.wakeup = wakeup_type,
.auth_cmd = auth_cmd
};
memcpy(write_payload.key, key, 6);
uint8_t default_trailer[MFBLOCK_SIZE] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x80, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t block0_data[MFBLOCK_SIZE] = {0x11, 0x22, 0x33, 0x44, 0x44, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int failed_blocks = 0;
int total_blocks = 0;
uint8_t verify_data[MFBLOCK_SIZE] = {0};
// Stage a valid 4-byte UID before changing the active UID source.
if (gdm_wipe_write_block(&gw, ISO14443A_CMD_WRITEBLOCK, 0, block0_data) != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Could not stage the clean block 0; config was not changed");
return PM3_EFAILED;
}
if (gdm_try_read(ISO14443A_CMD_READBLOCK, 0, &gw, verify_data) != PM3_SUCCESS ||
memcmp(verify_data, block0_data, MFBLOCK_SIZE) != 0) {
PrintAndLogEx(FAILED, "Clean block 0 readback failed; config was not changed");
return PM3_EPARTIAL;
}
total_blocks++;
for (int sec = 0; sec < max_sector; sec++) {
int first_blk = mfFirstBlockOfSector(sec);
@@ -10761,49 +10818,56 @@ static int CmdHF14AGen4_GDM_Wipe(const char *Cmd) {
bool is_trailer = (blk == trailer_blk);
uint8_t *data_to_write = is_trailer ? default_trailer : default_data;
// Real block writes
write_payload.write_cmd = ISO14443A_CMD_WRITEBLOCK; // 0xA0
write_payload.block_no = blk;
if (blk == 0) {
memcpy(write_payload.block_data, block0_data, MFBLOCK_SIZE);
} else {
memcpy(write_payload.block_data, data_to_write, MFBLOCK_SIZE);
if (blk != 0) {
if (gdm_wipe_write_block(&gw, ISO14443A_CMD_WRITEBLOCK, blk, data_to_write) != PM3_SUCCESS) {
failed_blocks++;
}
total_blocks++;
}
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&write_payload, sizeof(write_payload));
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false || resp.status != PM3_SUCCESS) {
failed_blocks++;
// Hidden blocks 0 and 1 can still hold the active 7-byte/F3 UID.
if (blk > 1) {
const uint8_t *hidden_data = (blk == 7) ? MF_SIGNATURE_KEYS : data_to_write;
if (gdm_wipe_write_block(&gw, MIFARE_MAGIC_GDM_WRITEBLOCK, blk, hidden_data) != PM3_SUCCESS) {
failed_blocks++;
}
total_blocks++;
}
// Hidden block writes
write_payload.write_cmd = MIFARE_MAGIC_GDM_WRITEBLOCK; // 0xA8
if (blk == 7) {
memcpy(write_payload.block_data, MF_SIGNATURE_KEYS, MFBLOCK_SIZE);
}
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&write_payload, sizeof(write_payload));
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false || resp.status != PM3_SUCCESS) {
failed_blocks++;
}
total_blocks += 2;
}
PrintAndLogEx(INFO, "Wiping sector %d...", sec);
}
// report write failures instead of always printing "Wipe completed!"
if (failed_blocks == 0) {
PrintAndLogEx(SUCCESS, "Wipe completed!");
return PM3_SUCCESS;
if (failed_blocks != 0) {
PrintAndLogEx(FAILED, "Wipe incomplete - " _RED_("%d") " of %d pre-commit block writes failed", failed_blocks, total_blocks);
PrintAndLogEx(HINT, "Hint: config and active UID mode were left unchanged");
return PM3_EPARTIAL;
}
PrintAndLogEx(FAILED, "Wipe incomplete - " _RED_("%d") " of %d block writes failed", failed_blocks, total_blocks);
if (failed_blocks == total_blocks) {
PrintAndLogEx(HINT, "Hint: the card did not accept any data write. Check that the wakeup still matches");
PrintAndLogEx(HINT, " the card's config (`" _YELLOW_("hf mf gdmgetcfg") "`), then retry");
// Commit the 4-byte personality only after its UID source is valid.
if (gdm_write_config(wakeup_type, auth_cmd, key, clean_config) != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Clean config was not committed; the card was partially wiped");
return PM3_EPARTIAL;
}
return PM3_EFAILED;
PrintAndLogEx(SUCCESS, "Clean config written");
if (gdm_wipe_verify_uid(block0_data) != PM3_SUCCESS) {
PrintAndLogEx(HINT, "Hint: the magic wakeup remains enabled for recovery");
return PM3_EPARTIAL;
}
// The clean 4-byte personality no longer uses hidden UID data.
for (uint8_t blk = 0; blk <= 1; blk++) {
if (gdm_wipe_write_block(&gw, MIFARE_MAGIC_GDM_WRITEBLOCK, blk, default_data) != PM3_SUCCESS) {
failed_blocks++;
}
}
if (failed_blocks != 0) {
PrintAndLogEx(FAILED, "Clean 4-byte mode is active, but hidden UID cleanup failed");
return PM3_EPARTIAL;
}
PrintAndLogEx(SUCCESS, "Wipe completed using the clean 4-byte template");
return PM3_SUCCESS;
}
static int CmdHF14AGen4_GDM_SetSig(const char *Cmd) {
@@ -10867,9 +10931,13 @@ static int CmdHF14AGen4_GDM_SetSig(const char *Cmd) {
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&write_payload, sizeof(write_payload));
PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false || resp.status != PM3_SUCCESS) {
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false) {
PrintAndLogEx(FAILED, "Failed to write signature part 1 (block 5): timeout");
return PM3_ETIMEOUT;
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write signature part 1 (block 5). Status: %d", resp.status);
return PM3_EFAILED;
return resp.status;
}
PrintAndLogEx(SUCCESS, "Signature part 1 written to block 5");
@@ -10879,9 +10947,13 @@ static int CmdHF14AGen4_GDM_SetSig(const char *Cmd) {
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&write_payload, sizeof(write_payload));
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false || resp.status != PM3_SUCCESS) {
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false) {
PrintAndLogEx(FAILED, "Failed to write signature part 2 (block 6): timeout");
return PM3_ETIMEOUT;
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write signature part 2 (block 6). Status: %d", resp.status);
return PM3_EFAILED;
return resp.status;
}
PrintAndLogEx(SUCCESS, "Signature part 2 written to block 6");
@@ -10893,8 +10965,9 @@ static int CmdHF14AGen4_GDM_SetSig(const char *Cmd) {
if (config[13] != 0x5A) {
config[13] = 0x5A;
if (gdm_write_config(wakeup_type, auth_cmd, key, config) != PM3_SUCCESS) {
return PM3_EFAILED;
int res = gdm_write_config(wakeup_type, auth_cmd, key, config);
if (res != PM3_SUCCESS) {
return res;
}
PrintAndLogEx(SUCCESS, "Enabled signature sector in config (config[13] = 0x5A)");
} else {
@@ -10913,9 +10986,13 @@ static int CmdHF14AGen4_GDM_SetSig(const char *Cmd) {
clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_WRITEBL_EX, (uint8_t *)&trailer_payload, sizeof(trailer_payload));
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false || resp.status != PM3_SUCCESS) {
if (WaitForResponseTimeout(CMD_HF_MIFARE_WRITEBL_EX, &resp, 1500) == false) {
PrintAndLogEx(FAILED, "Failed to write signature sector trailer (hidden block 7): timeout");
return PM3_ETIMEOUT;
}
if (resp.status != PM3_SUCCESS) {
PrintAndLogEx(FAILED, "Failed to write signature sector trailer (hidden block 7). Status: %d", resp.status);
return PM3_EFAILED;
return resp.status;
}
PrintAndLogEx(SUCCESS, "Signature sector trailer written to hidden block 7");
@@ -12345,7 +12422,7 @@ static command_t CommandTable[] = {
{"gdmgethidblk", CmdHF14AGen4_GDM_GetHidBlk, IfPm3Iso14443a, "Read hidden block from GDM card"},
{"gdmsethidblk", CmdHF14AGen4_GDM_SetHidBlk, IfPm3Iso14443a, "Write hidden block to GDM card"},
{"gdmsetuid", CmdHF14AGen4_GDM_SetUid, IfPm3Iso14443a, "Set UID on GDM card"},
{"gdmwipe", CmdHF14AGen4_GDM_Wipe, IfPm3Iso14443a, "Wipe GDM card to factory defaults"},
{"gdmwipe", CmdHF14AGen4_GDM_Wipe, IfPm3Iso14443a, "Wipe GDM card to a clean template"},
{"gdmsetsig", CmdHF14AGen4_GDM_SetSig, IfPm3Iso14443a, "Set MFC EV1 signature on GDM card"},
{"-----------", CmdHelp, IfPm3Iso14443a, "----------------------- " _CYAN_("ndef") " -----------------------"},
{"ndefformat", CmdHFMFNDEFFormat, IfPm3Iso14443a, "Format MIFARE Classic Tag as NFC Tag"},
+79 -1
View File
@@ -38,12 +38,15 @@
#define XSTR(x) #x
#define STR(x) XSTR(x)
#define LF_COTAG_DIVISOR 90 // 132 kHz
#define LF_COTAG_CLOCK 768
#define LF_COTAG_DATA_LEN 128
#define LF_COTAG_DEF_SAMPLES_READ 500000
#define LF_COTAG_SIM_FLOOR 128
#define LF_COTAG_SIM_MIN_BYTES 8
#define LF_COTAG_SIM_MAX_REPEATS 16
static int CmdHelp(const char *Cmd);
static int demod_cotag(int32_t *samples, int num_samples, int clock, int clock_start, double threshold, bool verbose);
@@ -540,10 +543,85 @@ static int CmdCOTAGReader(const char *Cmd) {
return ret;
}
static int CmdCOTAGSim(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "lf cotag sim",
"Enables simulation of a COTAG tag.\n"
"Simulation runs until the button is pressed or another USB command is issued.\n"
"Without " _YELLOW_("`-r`") _CYAN_(" it only reports detected reader activation sequence.\n")
_CYAN_("Note: COTAG tag full repeating sequence is 128 bits, but readers seem to care about LSB 64 bits only."),
"lf cotag sim --> only detect the reader\n"
"lf cotag sim -r A37E0D37000C1337 --> send 64 bits\n"
"lf cotag sim -r 0000000000000002A37E0D37000C1337\n"
"lf cotag sim --floor 32 --> more sensitive, for a reader further away\n"
"lf cotag sim -r A37E0D37000C1337 --hb_delay_us 2909 --> time the half bit instead of counting cycles\n"
);
void *argtable[] = {
arg_param_begin,
arg_str0("r", "raw", "<hex>", "raw data to answer with, " STR(LF_COTAG_SIM_MIN_BYTES) " to " STR(LF_COTAG_SIM_DATA_LEN) " bytes (64-128 bits)"),
arg_int0("n", "repeat", "<1-" STR(LF_COTAG_SIM_MAX_REPEATS) ">", "repeat data frame this many times per answer (def 1)"),
arg_int0(NULL, "floor", "<16-65535>", "minimum rise threshold (def " STR(LF_COTAG_SIM_FLOOR) ")"),
arg_int0(NULL, "hb_delay_us", "<2900-2918>", "custom half bit delay [us] (should be around 2909)"),
arg_lit0("v", "verbose", "report detected reader activation sequence while answering"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, true);
uint8_t data[LF_COTAG_SIM_DATA_LEN] = {0};
int dlen = 0;
CLIGetHexWithReturn(ctx, 1, data, &dlen);
int repeats = arg_get_int_def(ctx, 2, 1);
int thr_floor = arg_get_int_def(ctx, 3, LF_COTAG_SIM_FLOOR);
int hb_delay = arg_get_int_def(ctx, 4, 0);
bool verbose = arg_get_lit(ctx, 5);
CLIParserFree(ctx);
if (dlen && (dlen < LF_COTAG_SIM_MIN_BYTES || dlen > LF_COTAG_SIM_DATA_LEN)) {
PrintAndLogEx(ERR, "data must be %d to %d bytes (64 to 128 bits), got %d"
, LF_COTAG_SIM_MIN_BYTES, LF_COTAG_SIM_DATA_LEN, dlen);
return PM3_EINVARG;
}
if (repeats < 1 || repeats > LF_COTAG_SIM_MAX_REPEATS) {
PrintAndLogEx(ERR, "repeat must be between 1 and %d", LF_COTAG_SIM_MAX_REPEATS);
return PM3_EINVARG;
}
if (thr_floor < 16 || thr_floor > 0xFFFF) {
PrintAndLogEx(ERR, "floor must be between 16 and 65535");
return PM3_EINVARG;
}
if (hb_delay && (hb_delay < 2900 || hb_delay > 2918)) {
PrintAndLogEx(ERR, "hb_delay_us must be between 2900 and 2918 us");
return PM3_EINVARG;
}
lf_cotagsim_t payload = {
.thr_floor = (uint16_t)thr_floor,
.hb_delay_us = (uint16_t)hb_delay,
.nbits = (uint8_t)(dlen * 8),
.repeats = (uint8_t)repeats,
.verbose = verbose,
};
memcpy(payload.data, data, dlen);
PrintAndLogEx(INFO, "Simulating COTAG tag");
if (dlen == 0) {
PrintAndLogEx(INFO, "No " _YELLOW_("`-r`") " given, detecting reader activation sequence only");
}
clearCommandBuffer();
SendCommandNG(CMD_LF_COTAG_SIMULATE, (uint8_t *)&payload, sizeof(payload));
return lfsim_wait_check(CMD_LF_COTAG_SIMULATE);
}
static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdCOTAGDemod, AlwaysAvailable, "demodulate a COTAG tag"},
{"reader", CmdCOTAGReader, IfPm3Lf, "attempt to read and extract tag data"},
{"sim", CmdCOTAGSim, IfPm3Lf, "simulate a COTAG tag"},
{NULL, NULL, NULL, NULL}
};
+3 -1
View File
@@ -148,6 +148,8 @@ void StartTickCount(void) {
// Get the current count.
uint32_t RAMFUNC GetTickCount(void) {
ertc_time_type time;
// Read SBS first to latch TIME/DATE until the calendar getter reads DATE.
uint32_t subsecond = ERTC->sbs;
ertc_calendar_get(&time);
return mktime_utc_fast(
// time.year is short length, not full, so 2025 is 25.
@@ -156,7 +158,7 @@ uint32_t RAMFUNC GetTickCount(void) {
time.month, time.day, time.hour, time.min, time.sec,
// this ms is from 0 -> 1000 of second, not timestamp value
// ms = ((divb + 1) - subsecond * 1000) / (divb + 1)
(3125 - ertc_sub_second_get()) * 1000 / 3125) - tick_start_val; // current - start = tick
(3125 - subsecond) * 1000 / 3125) - tick_start_val; // current - start = tick
}
// -------------------------------------------------------------------------
+24 -3
View File
@@ -6393,7 +6393,7 @@
},
"hf mf gdmwipe": {
"command": "hf mf gdmwipe",
"description": "Wipe a GDM card to factory defaults. With no wakeup flag it auto-detects a backdoor (gen1a or gdm alt); a WUPA-only card is rejected.",
"description": "Wipe a GDM card to a known clean 4-byte template. Sets UID to 11223344, clears real and hidden data blocks, and sets sector trailers to default values. With no wakeup flag it auto-detects a backdoor; a WUPA-only card is rejected.",
"notes": [
"hf mf gdmwipe --gdm"
],
@@ -11760,6 +11760,27 @@
],
"usage": "lf cotag reader [-hv@] [-s <dec>] [--divisor <19-255>]"
},
"lf cotag sim": {
"command": "lf cotag sim",
"description": "Enables simulation of a COTAG tag. Simulation runs until the button is pressed or another USB command is issued. Without `-r` it only reports detected reader activation sequence. Note: COTAG tag full repeating sequence is 128 bits, but readers seem to care about LSB 64 bits only.",
"notes": [
"lf cotag sim -> only detect the reader",
"lf cotag sim -r A37E0D37000C1337 -> send 64 bits",
"lf cotag sim -r 0000000000000002A37E0D37000C1337",
"lf cotag sim --floor 32 -> more sensitive, for a reader further away",
"lf cotag sim -r A37E0D37000C1337 --hb_delay_us 2909 -> time the half bit instead of counting cycles"
],
"offline": false,
"options": [
"-h, --help This help",
"-r, --raw <hex> raw data to answer with, 8 to 16 bytes (64-128 bits)",
"-n, --repeat <1-16> repeat data frame this many times per answer (def 1)",
"--floor <16-65535> minimum rise threshold (def 128)",
"--hb_delay_us <2900-2918> custom half bit delay [us] (should be around 2909)",
"-v, --verbose report detected reader activation sequence while answering"
],
"usage": "lf cotag sim [-hv] [-r <hex>] [-n <1-16>] [--floor <16-65535>] [--hb_delay_us <2900-2918>]"
},
"lf destron clone": {
"command": "lf destron clone",
"description": "clone a Destron tag to a T55x7, Q5/T5555 or EM4305/4469 tag.",
@@ -16785,8 +16806,8 @@
}
},
"metadata": {
"commands_extracted": 935,
"commands_extracted": 936,
"extracted_by": "PM3Help2JSON v1.00",
"extracted_on": "2026-09-27T19:09:12+00:00"
"extracted_on": "2026-10-14T15:56:50+00:00"
}
}
+2 -1
View File
@@ -698,7 +698,7 @@ Check column "offline" for their availability.
|`hf mf gdmgethidblk `|N |`Read hidden block from GDM card`
|`hf mf gdmsethidblk `|N |`Write hidden block to GDM card`
|`hf mf gdmsetuid `|N |`Set UID on GDM card`
|`hf mf gdmwipe `|N |`Wipe GDM card to factory defaults`
|`hf mf gdmwipe `|N |`Wipe GDM card to a clean template`
|`hf mf gdmsetsig `|N |`Set MFC EV1 signature on GDM card`
|`hf mf ndefformat `|N |`Format MIFARE Classic Tag as NFC Tag`
|`hf mf ndefread `|N |`Read and print NDEF records from card`
@@ -1119,6 +1119,7 @@ Check column "offline" for their availability.
|`lf cotag help `|Y |`This help`
|`lf cotag demod `|Y |`demodulate a COTAG tag`
|`lf cotag reader `|N |`attempt to read and extract tag data`
|`lf cotag sim `|N |`simulate a COTAG tag`
### lf destron
+1 -1
View File
@@ -1171,7 +1171,7 @@ Sectors 2-15
| `gdmgethidblk` | Read hidden block |
| `gdmsethidblk` | Write a hidden block |
| `gdmsetuid` | Set 4-byte / 7-byte UID, or F3 perso (`--f3d`) |
| `gdmwipe` | Restore card to factory defaults (`-a` for 4K) |
| `gdmwipe` | Wipe to a known clean 4-byte template (`-a` for 4K) |
| `gdmsetsig` | Write EV1 signature (hidden blocks 5/6), enable sigsec, write default signature key sector |
### libnfc commands
@@ -42,6 +42,9 @@ Build as usual, CEP is available by default. (`SKIP_CEP=1` to remove CEP support
- `hf`/`lf` reads in general, same as over USB, once the device's one-time
FPGA bitstream step is done (see `Getting_Started_With_PM5.md`) — CEP
itself doesn't block RF.
- The link survives idle periods cleanly — the FAP's idle dummy-poll bytes
(`0xFFFF` length header, no data pending) no longer trigger a false SPI
resync.
## What doesn't (yet)
@@ -49,6 +52,10 @@ Build as usual, CEP is available by default. (`SKIP_CEP=1` to remove CEP support
replies `PM3_EFAILED` with stale cached UID data, even though the same
reader succeeds moments later over plain USB against the same tag.
Firmware-side, root cause open, out of scope for the CEP transport itself.
- `CMD_MAIN_CHIP_UNIQUEID` intermittently times out on its first attempt
(Hardware Status page, occasionally slow/incomplete on first load),
always recovers on the FAP's retry. PM5 handler and FAP cache both
confirmed clean — likely a transport/timing-layer race, root cause open.
---
@@ -70,3 +77,6 @@ Build as usual, CEP is available by default. (`SKIP_CEP=1` to remove CEP support
- CEP uses its own reply-routing flag (`g_reply_via_cep`).
- SPI bit-order/clock-phase settings are confirmed correct against real
Flipper traffic (logic analyzer): MSB-first, mode 0, CS active-low.
- FAP-side: a short fast-poll window after sending a command, and blocking
deep-sleep for the life of the RX thread (fixes unreliable reads on
battery), both merged in the FAP's own repo.
+61
View File
@@ -0,0 +1,61 @@
# GDB_GATEWAY
GDB Remote Serial Protocol server on the USB CDC link (PM5).
No probe or extra wiring. Reads flash and SRAM, writes SRAM and flash. No breakpoints, no step.
## Build
```
PLATFORM=PM5
STANDALONE=GDB_GATEWAY
```
## Use
```
pm3 --> hw standalone
```
Quit the client (the port stays up), then:
```
arm-none-eabi-gdb -ex 'target remote /dev/ttyACM0'
(gdb) x/16xw 0x08000000
(gdb) dump memory flash.bin 0x08000000 0x08100000
(gdb) monitor info
(gdb) load patch.elf # flash above the running image
(gdb) monitor unlock-app # allow writes to the app area
(gdb) monitor lock
(gdb) monitor exit
```
Leave with `monitor exit` or a button press.
## Readable ranges
| Range | Size |
|-------|------|
| `0x08000000` | 1 MB flash |
| `0x20000000` | 512 KB SRAM |
Other addresses return `E14`. Peripheral space is not exposed.
## Writes
| Target | Allowed |
|--------|---------|
| SRAM (`M`) | always |
| Flash above the running image (`load`, `vFlashErase`/`vFlashWrite`) | always |
| Flash from `0x08004000` (app area) | after `monitor unlock-app` |
| Bootrom, `0x08000000`-`0x08003fff` | never |
Refused writes return `E02`. `monitor lock` restores the default; the gateway starts locked.
Erasing the running image crashes the PM5, recover it through the bootrom.
## Notes
- Flash is erased in 2 KB sectors.
- Register reads return zeros, the core is not halted.
- `c`/`s` return an immediate stop reply; nothing is executed.
- Debug output is off while running, it would corrupt the RSP stream.
- Set `remotetimeout 60` in gdb for large dumps.
+17
View File
@@ -1,3 +1,20 @@
//-----------------------------------------------------------------------------
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
module fpga_top (
input ck_1356meg,
input ck_1356meg_b, // B is for close range wiring
+15 -8
View File
@@ -1,11 +1,18 @@
//Copyright (C)2014-2023 Gowin Semiconductor Corporation.
//All rights reserved.
//File Title: IP file
//Tool Version: V1.9.9 (64-bit)
//Part Number: GW1N-UV4QN48C6/I5
//Device: GW1N-4
//Device Version: D
//Created Time: Mon Jul 6 18:07:08 2026
//-----------------------------------------------------------------------------
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
module Gowin_rPLL (clkout, clkin);
+5 -5
View File
@@ -1,11 +1,11 @@
# 手动综合脚本,等价于 proxmark5_fpga.mk 自动生成的步骤。
# 在 fpga 目录下运行:yosys -s pm5/run.ys (构建时请用 make pm5)
# Manual synthesis script, equivalent to the steps automatically generated by proxmark5_fpga.mk.
# Run in the fpga directory: yosys -s pm5/run.ys (use make pm5 for building)
# 1. 读取源代码和宏定义
# 1. Read source code and macro definitions
read_verilog -D PM5 -D WITH_TIMODE -D WITH_HF_15 -D WITH_FELICA_PROBE common/define.v common/mux8.v common/clk_divider.v common/lp20khz_1MSa_iir_filter.v common/min_max_tracker.v common/hi_flite.v common/hi_get_trace.v common/hi_iso14443a.v common/hi_reader.v common/hi_simulate.v common/hi_sniffer.v common/lf_edge_detect.v common/lo_adc.v common/lo_edge_detect.v common/lo_passthru.v common/lo_read.v pm5/gowin_rpll.v pm5/fpga_pm5_hf.v pm5/fpga_pm5_lf.v pm5/fpga_pm5_top.v
# 2. 检查并强制指定顶层
# 2. Check and explicitly specify the top level
hierarchy -top fpga_top
# 3. 进行综合
# 3. Perform synthesis
synth_gowin -nolutram -json output.json
+13
View File
@@ -0,0 +1,13 @@
# Python packages the fpga/ scripts import.
#
# fs2bin.py is the only one the build needs, and it normally runs under the
# python bundled in oss-cad-suite, which already ships apycula - so this file
# matters when building with an external interpreter instead. apycula owns the
# .fs bitstream format and its CRC; gowin_devid.py re-derives one of those CRCs
# and fails loudly if the format ever changes, so bump deliberately.
apycula>=0.34
# tests/plot_edgedetect.py, the offline plot helper for the edge detect
# testbenches. Not needed to build an image.
numpy
matplotlib
+15
View File
@@ -380,6 +380,20 @@ typedef struct {
uint8_t data[];
} PACKED lf_hitag_t;
#define LF_COTAG_DIVISOR 90
#define LF_COTAG_TX_DIVISOR 181
// For CMD_LF_COTAG_SIMULATE
#define LF_COTAG_SIM_DATA_LEN 16 // 128 bits, the longest repeating COTAG frame
typedef struct {
uint16_t thr_floor; // minimum rise threshold
uint16_t hb_delay_us; // optional custom half bit delay [us]
uint8_t repeats; // repeat data frame this many times per answer
bool verbose;
uint8_t nbits; // number of data bits
uint8_t data[LF_COTAG_SIM_DATA_LEN];
} PACKED lf_cotagsim_t;
// For CMD_LF_SNIFF_RAW_ADC and CMD_LF_ACQ_RAW_ADC
#define LF_SAMPLES_BITS 30
#define MAX_LF_SAMPLES ((((uint32_t)1u) << LF_SAMPLES_BITS) - 1)
@@ -1092,6 +1106,7 @@ typedef struct {
#define CMD_LF_VIKING_CLONE 0x0222
#define CMD_LF_T55XX_WAKEUP 0x0224
#define CMD_LF_COTAG_READ 0x0225
#define CMD_LF_COTAG_SIMULATE 0x022B
#define CMD_LF_T55XX_SET_CONFIG 0x0226
#define CMD_LF_SAMPLING_PRINT_CONFIG 0x0227
#define CMD_LF_SAMPLING_GET_CONFIG 0x0228
+1
View File
@@ -298,6 +298,7 @@ while true; do
if ! CheckExecute "findbits test" "$PYTHON tools/findbits.py 73 0110010101110011" "Match at bit 9: 011001010"; then break; fi
if ! CheckExecute "findbits_test test" "$PYTHON tools/findbits_test.py 2>&1" "OK"; then break; fi
if ! CheckExecute "dfc_converter test" "$PYTHON tools/dfc_converter_test.py 2>&1" "OK"; then break; fi
if ! CheckExecute "PM5 RTC tick test" "$PYTHON tools/pm5_rtc_tick_test.py 2>&1" "RTC tick snapshot test: OK"; then break; fi
if ! CheckExecute "pm3_eml_mfd test" "$PYTHON tools/mfc/pm3_eml_mfd_test.py 2>&1" "OK"; then break; fi
if ! CheckExecute "recover_pk test" "$PYTHON tools/recover_pk.py selftests 2>&1" "Tests:.*\(.*ok.*"; then break; fi
if ! CheckExecute "mkversion create test" "tools/mkversion.sh --short" 'Iceman/'; then break; fi
+200
View File
@@ -0,0 +1,200 @@
#!/usr/bin/env python3
# Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""Test the actual PM5 tick getter with the AN0047 section 2.4 shadow-lock model."""
import argparse
import os
from pathlib import Path
import shlex
import subprocess
import tempfile
PREAMBLE = r'''
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#define RAMFUNC
typedef struct { int year, month, day, hour, min, sec; } ertc_time_type;
typedef struct { volatile uint32_t sbs; } fake_ertc_t;
static fake_ertc_t registers;
static ertc_time_type live_calendar, frozen_calendar, next_calendar;
static uint32_t live_sbs;
static bool locked;
static volatile uint64_t tick_start_val;
static unsigned sbs_reads, time_reads, date_reads;
static int rollover;
enum { NEVER, AFTER_SBS, AFTER_TIME, AFTER_DATE };
static void advance(int position) {
if (rollover == position) {
live_calendar = next_calendar;
live_sbs = 3124;
rollover = NEVER;
}
}
static void read_date(void) {
date_reads++;
locked = false;
advance(AFTER_DATE);
}
fake_ertc_t *read_subsecond(void) {
sbs_reads++;
registers.sbs = live_sbs;
if (!locked) frozen_calendar = live_calendar;
locked = true;
advance(AFTER_SBS);
return &registers;
}
#define ERTC read_subsecond()
void ertc_calendar_get(ertc_time_type *time) {
time_reads++;
if (!locked) frozen_calendar = live_calendar;
locked = true;
*time = frozen_calendar;
advance(AFTER_TIME);
read_date();
}
uint32_t ertc_sub_second_get(void) {
uint32_t value = ERTC->sbs;
read_date(); // Vendor helper releases the shadow lock before returning.
return value;
}
'''
TEST = r'''
typedef struct {
const char *name;
ertc_time_type before, after;
} transition_t;
static const transition_t transitions[] = {
{"second", {25, 8, 15, 13, 0, 0}, {25, 8, 15, 13, 0, 1}},
{"minute", {25, 8, 15, 13, 0, 59}, {25, 8, 15, 13, 1, 0}},
{"hour", {25, 8, 15, 13, 59, 59}, {25, 8, 15, 14, 0, 0}},
{"day", {25, 8, 15, 23, 59, 59}, {25, 8, 16, 0, 0, 0}},
{"month", {25, 8, 31, 23, 59, 59}, {25, 9, 1, 0, 0, 0}},
{"year", {25, 12, 31, 23, 59, 59}, {26, 1, 1, 0, 0, 0}},
{"leap-day-start", {28, 2, 28, 23, 59, 59}, {28, 2, 29, 0, 0, 0}},
{"leap-day-end", {28, 2, 29, 23, 59, 59}, {28, 3, 1, 0, 0, 0}},
};
static void setup(const transition_t *transition, uint32_t sbs, int position) {
live_calendar = transition->before;
next_calendar = transition->after;
live_sbs = sbs;
locked = false;
rollover = position;
sbs_reads = time_reads = date_reads = 0;
ertc_time_type t = transition->before;
tick_start_val = mktime_utc_fast(t.year + 2000, t.month, t.day, t.hour, t.min, t.sec, 0);
}
static int test_transition(const transition_t *transition, int position) {
setup(transition, 0, NEVER);
uint32_t before = GetTickCount();
rollover = position;
uint32_t after = GetTickCount();
setup(transition, 0, position);
uint32_t delta = GetTickCountDelta(before);
// Existing rounding maps the final subsecond tick to 1000 ms.
if (before != 1000 || after != 1000 || delta != 0 || locked) {
printf("RED %s position=%d before=%u after=%u delta=%u\n",
transition->name, position, before, after, delta);
return 1;
}
return 0;
}
int main(void) {
int failures = 0;
unsigned cases = 0;
for (unsigned i = 0; i < sizeof(transitions) / sizeof(transitions[0]); i++) {
for (int position = AFTER_SBS; position <= AFTER_DATE; position++) {
failures += test_transition(&transitions[i], position);
cases++;
}
}
for (uint32_t sbs = 0; sbs <= 3124; sbs++) {
setup(&transitions[0], sbs, NEVER);
uint32_t count = GetTickCount();
uint32_t expected = (3125 - sbs) * 1000 / 3125;
if (count != expected || locked) failures++;
}
setup(&transitions[0], 2500, NEVER);
uint32_t before = GetTickCount();
live_sbs = 2497;
uint32_t after = GetTickCount();
if (after < before || after - before > 1) failures++;
// A coherent snapshot needs one read of each register, ending with DATE.
setup(&transitions[0], 1000, NEVER);
(void)GetTickCount();
if (sbs_reads != 1 || time_reads != 1 || date_reads != 1 || locked) {
printf("RED register reads SBS=%u TIME=%u DATE=%u\n", sbs_reads, time_reads, date_reads);
failures++;
}
printf("RTC tick snapshot test: %s; %u rollover cases, 3125 subsecond values\n",
failures ? "RED" : "OK", cases);
return failures ? 1 : 0;
}
'''
def function(text, marker):
start = text.index(marker)
brace = text.index("{", start)
depth = 1
end = brace + 1
while depth:
if text[end] == "{":
depth += 1
elif text[end] == "}":
depth -= 1
end += 1
return text[start:end] + "\n"
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--source", type=Path, help="alternate getter source for a negative control")
parser.add_argument("--optimization", choices=("0", "2", "s"), default="2")
args = parser.parse_args()
root = Path(__file__).resolve().parent.parent
hardware = (args.source or root / "common_arm/ticks/ticks_hw_at32.c").read_text()
core = (root / "common_arm/ticks/ticks_core.c").read_text()
calendar_math = function(hardware, "static uint64_t mktime_utc_fast(")
getter = function(hardware, "uint32_t RAMFUNC GetTickCount(void)")
delta = function(core, "uint32_t RAMFUNC GetTickCountDelta(")
with tempfile.TemporaryDirectory(prefix="rtc-tick-test-") as directory:
executable = Path(directory) / ("rtc_tick_test.exe" if os.name == "nt" else "rtc_tick_test")
command = shlex.split(os.environ.get("CC", "cc")) + ["-std=c99", "-O" + args.optimization, "-Wall", "-Wextra", "-Werror", "-x", "c", "-", "-o", str(executable)]
subprocess.run(command, input=PREAMBLE + calendar_math + getter + delta + TEST, text=True, check=True)
result = subprocess.run([str(executable)])
raise SystemExit(result.returncode)
if __name__ == "__main__":
main()