diff --git a/client/experimental_lib/CMakeLists.txt b/client/experimental_lib/CMakeLists.txt index 5d2d906a1..ea54e5577 100644 --- a/client/experimental_lib/CMakeLists.txt +++ b/client/experimental_lib/CMakeLists.txt @@ -56,6 +56,13 @@ if (NOT SKIPPYTHON EQUAL 1) pkg_search_module(PYTHON3EMBED QUIET ${PYTHON3_PKGCONFIG}-embed) endif (NOT SKIPPYTHON EQUAL 1) +if (MINGW) + # Prefer static archives for single-exe deployments. + set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) + set(ZLIB_USE_STATIC_LIBS ON) + set(BZIP2_USE_STATIC_LIBS ON) +endif() + # If cross-compiled, we need to init source and build. if (CMAKE_TOOLCHAIN_FILE) if (ANDROID) @@ -692,7 +699,26 @@ add_library(pm3rrg_rdv4 SHARED ${ADDITIONAL_SRC} ) -target_compile_definitions(pm3rrg_rdv4 PRIVATE LIBPM3) +add_library(pm3rrg_rdv4_static STATIC + ${PM3_ROOT}/client/src/proxmark3.c + ${PM3_ROOT}/client/src/guidummy.cpp + ${TARGET_SOURCES} + ${ADDITIONAL_SRC} +) + +set(PM3_LIBRARY_TARGETS pm3rrg_rdv4 pm3rrg_rdv4_static) +foreach (target IN LISTS PM3_LIBRARY_TARGETS) + target_compile_definitions(${target} PRIVATE LIBPM3) + target_compile_options(${target} PUBLIC -Wall -Werror -O3) + target_include_directories(${target} PRIVATE + ${PM3_ROOT}/common + ${PM3_ROOT}/common_fpga + ${PM3_ROOT}/include + ${PM3_ROOT}/client/src + ${PM3_ROOT}/client/include + ${ADDITIONAL_DIRS} + ) +endforeach() if (UNIX AND NOT APPLE) # Fail the build if a client source file is missing from TARGET_SOURCES. @@ -700,17 +726,22 @@ if (UNIX AND NOT APPLE) set_property(TARGET pm3rrg_rdv4 APPEND_STRING PROPERTY LINK_FLAGS " -Wl,--no-undefined") endif() -target_compile_options(pm3rrg_rdv4 PUBLIC -Wall -Werror -O3) if (EMBED_READLINE) if (NOT SKIPREADLINE EQUAL 1) - add_dependencies(pm3rrg_rdv4 ncurses readline) + foreach (target IN LISTS PM3_LIBRARY_TARGETS) + add_dependencies(${target} ncurses readline) + endforeach() endif (NOT SKIPREADLINE EQUAL 1) endif (EMBED_READLINE) if (EMBED_BZIP2) - add_dependencies(pm3rrg_rdv4 bzip2) + foreach (target IN LISTS PM3_LIBRARY_TARGETS) + add_dependencies(${target} bzip2) + endforeach() endif (EMBED_BZIP2) if (EMBED_LZ4) - add_dependencies(pm3rrg_rdv4 lz4) + foreach (target IN LISTS PM3_LIBRARY_TARGETS) + add_dependencies(${target} lz4) + endforeach() endif (EMBED_LZ4) if (MINGW) @@ -718,7 +749,9 @@ if (MINGW) # and setting _ISOC99_SOURCE sets internally __USE_MINGW_ANSI_STDIO=1 # FTR __USE_MINGW_ANSI_STDIO seems deprecated in Mingw32 # but not Mingw64 https://fr.osdn.net/projects/mingw/lists/archive/users/2019-January/000199.html - target_compile_definitions(pm3rrg_rdv4 PRIVATE _ISOC99_SOURCE) + foreach (target IN LISTS PM3_LIBRARY_TARGETS) + target_compile_definitions(${target} PRIVATE _ISOC99_SOURCE) + endforeach() set(CMAKE_C_FLAGS "-mno-ms-bitfields -fexec-charset=cp850 ${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "-mno-ms-bitfields -fexec-charset=cp850 ${CMAKE_CXX_FLAGS}") @@ -727,15 +760,6 @@ if (MINGW) set(ADDITIONAL_LNK ws2_32 ${ADDITIONAL_LNK}) endif (MINGW) -target_include_directories(pm3rrg_rdv4 PRIVATE - ${PM3_ROOT}/common - ${PM3_ROOT}/common_fpga - ${PM3_ROOT}/include - ${PM3_ROOT}/client/src - ${PM3_ROOT}/client/include - ${ADDITIONAL_DIRS} -) - if (NOT APPLE) # required for Raspberry Pi, but breaks with clang (OSX). Need to be at the end of the linker line. set(ADDITIONAL_LNK ${ADDITIONAL_LNK} -Wl,--as-needed -latomic -Wl,--no-as-needed) @@ -759,22 +783,26 @@ if (NOT WHEREAMI_FOUND) set(ADDITIONAL_LNK pm3rrg_rdv4_whereami ${ADDITIONAL_LNK}) endif (NOT WHEREAMI_FOUND) -target_link_libraries(pm3rrg_rdv4 PRIVATE - m - pm3rrg_rdv4_mbedtls - pm3rrg_rdv4_cliparser - pm3rrg_rdv4_lua - pm3rrg_rdv4_tinycbor - pm3rrg_rdv4_amiibo - pm3rrg_rdv4_reveng - pm3rrg_rdv4_hardnested - pm3rrg_rdv4_id48 - pm3rrg_rdv4_mqtt - pm3rrg_rdv4_vec - ${ADDITIONAL_LNK}) +foreach (target IN LISTS PM3_LIBRARY_TARGETS) + target_link_libraries(${target} PRIVATE + m + pm3rrg_rdv4_mbedtls + pm3rrg_rdv4_cliparser + pm3rrg_rdv4_lua + pm3rrg_rdv4_tinycbor + pm3rrg_rdv4_amiibo + pm3rrg_rdv4_reveng + pm3rrg_rdv4_hardnested + pm3rrg_rdv4_id48 + pm3rrg_rdv4_mqtt + pm3rrg_rdv4_vec + ${ADDITIONAL_LNK}) +endforeach() if (NOT SKIPPTHREAD EQUAL 1) - target_link_libraries(pm3rrg_rdv4 PRIVATE pthread) + foreach (target IN LISTS PM3_LIBRARY_TARGETS) + target_link_libraries(${target} PRIVATE pthread) + endforeach() endif (NOT SKIPPTHREAD EQUAL 1) if (NOT SKIPPYTHON EQUAL 1) @@ -786,4 +814,6 @@ if (NOT SKIPPYTHON EQUAL 1) endif (PYTHON3EMBED_FOUND OR PYTHON3_FOUND) endif (NOT SKIPPYTHON EQUAL 1) -target_link_directories(pm3rrg_rdv4 PRIVATE ${ADDITIONAL_LNKDIRS}) +foreach (target IN LISTS PM3_LIBRARY_TARGETS) + target_link_directories(${target} PRIVATE ${ADDITIONAL_LNKDIRS}) +endforeach() diff --git a/client/src/cmdhflegic.c b/client/src/cmdhflegic.c index 5f1780086..816a1c754 100644 --- a/client/src/cmdhflegic.c +++ b/client/src/cmdhflegic.c @@ -58,13 +58,13 @@ static bool legic_xor(uint8_t *data, uint16_t cardsize) { return true; } -static void legic_xor_with_crc(uint8_t *data, uint16_t cardsize, uint8_t crc) { +void legic_xor_with_crc(uint8_t *data, uint16_t cardsize, uint8_t crc) { for (uint16_t i = 22; i < cardsize; i++) { data[i] ^= crc; } } -static bool legic_clone_update_segment_crcs(uint8_t *data, size_t bytes_read, const uint8_t uid[4]) { +bool legic_clone_update_segment_crcs(uint8_t *data, size_t bytes_read, const uint8_t uid[4]) { // Segment headers are parsed from offset 22 everywhere else in LEGIC decoding. size_t start = 22; bool found_segment = false; @@ -96,7 +96,7 @@ static bool legic_clone_update_segment_crcs(uint8_t *data, size_t bytes_read, co return true; } -static bool legic_clone_update_kgh_crcs(uint8_t *data, size_t bytes_read, const uint8_t uid[4]) { +bool legic_clone_update_kgh_crcs(uint8_t *data, size_t bytes_read, const uint8_t uid[4]) { // Decoded segmented payload starts at byte 22. size_t start = 22; bool found_kgh = false; @@ -142,7 +142,7 @@ static bool legic_clone_update_kgh_crcs(uint8_t *data, size_t bytes_read, const return true; } -static int legic_write_bytes_to_tag(uint16_t offset, uint8_t iv, const uint8_t *data, size_t bytes_read, const char *verb) { +int legic_write_bytes_to_tag(uint16_t offset, uint8_t iv, const uint8_t *data, size_t bytes_read, const char *verb) { PrintAndLogEx(SUCCESS, "%s", verb); // fast push mode @@ -183,21 +183,68 @@ static int legic_write_bytes_to_tag(uint16_t offset, uint8_t iv, const uint8_t * PrintAndLogEx(NORMAL, ""); if (resp.status != PM3_SUCCESS) { - PrintAndLogEx(WARNING, "Failed writing tag"); + PrintAndLogEx(WARNING, "Failed writing tag at offset %zu len %zu. Status: %d", i, len, resp.status); g_conn.block_after_ACK = false; return PM3_ERFTRANS; } - PrintAndLogEx(SUCCESS, "Wrote chunk [offset %zu | len %zu | total %zu", i, len, i + len); + PrintAndLogEx(SUCCESS, "Wrote chunk [offset %zu | len %zu | end %zu of %zu]", i, len, i + len, bytes_read); } g_conn.block_after_ACK = false; return PM3_SUCCESS; } -static int legic_write_dump_to_tag(uint8_t *dump, size_t bytes_read) { +int legic_write_dump_to_tag(uint8_t *dump, size_t bytes_read) { return legic_write_bytes_to_tag(7, 0x55, dump, bytes_read, "Restoring to card"); } +int legic_migrate_dump(uint8_t *dump, size_t bytes_read, bool rewrite_kgh, const uint8_t dcf[2], bool allow_dcf) { + if (dump == NULL || bytes_read <= 22) { + return PM3_EINVARG; + } + + if (dcf != NULL && !allow_dcf) { + return PM3_EINVARG; + } + + legic_card_select_t card; + if (legic_get_type(&card) != PM3_SUCCESS) { + return PM3_ESOFT; + } + + if (card.cardsize < bytes_read) { + return PM3_EFILE; + } + + uint8_t target_uid[4] = {0}; + memcpy(target_uid, card.uid, sizeof(target_uid)); + uint8_t target_mcc = (uint8_t)CRC8Legic(target_uid, sizeof(target_uid)); + + if (!legic_clone_update_segment_crcs(dump, bytes_read, target_uid)) { + return PM3_EFAILED; + } + if (rewrite_kgh && !legic_clone_update_kgh_crcs(dump, bytes_read, target_uid)) { + return PM3_EFAILED; + } + + memcpy(dump, target_uid, sizeof(target_uid)); + dump[4] = target_mcc; + legic_xor_with_crc(dump, bytes_read, dump[4]); + + int write_res = legic_write_dump_to_tag(dump, bytes_read); + if (write_res != PM3_SUCCESS) { + return write_res; + } + + if (dcf != NULL) { + uint8_t dcf_dump[7] = {0}; + memcpy(dcf_dump + 5, dcf, 2); + return legic_write_bytes_to_tag(5, 0x55, dcf_dump, sizeof(dcf_dump), "Applying explicit DCF update"); + } + + return PM3_SUCCESS; +} + static int CmdLegicMigrate(const char *Cmd) { CLIParserContext *ctx; CLIParserInit(&ctx, "hf legic migrate", diff --git a/client/src/cmdhflegic.h b/client/src/cmdhflegic.h index 9f5681845..3ad60fe43 100644 --- a/client/src/cmdhflegic.h +++ b/client/src/cmdhflegic.h @@ -31,5 +31,11 @@ int legic_get_type(legic_card_select_t *card); void legic_chk_iv(uint32_t *iv); void legic_seteml(uint8_t *src, uint32_t offset, uint32_t numofbytes); int legic_read_mem(uint32_t offset, uint32_t len, uint32_t iv, uint8_t *out, uint16_t *outlen); +int legic_migrate_dump(uint8_t *dump, size_t bytes_read, bool rewrite_kgh, const uint8_t dcf[2], bool allow_dcf); +void legic_xor_with_crc(uint8_t *data, uint16_t cardsize, uint8_t crc); +bool legic_clone_update_segment_crcs(uint8_t *data, size_t bytes_read, const uint8_t uid[4]); +bool legic_clone_update_kgh_crcs(uint8_t *data, size_t bytes_read, const uint8_t uid[4]); +int legic_write_bytes_to_tag(uint16_t offset, uint8_t iv, const uint8_t *data, size_t bytes_read, const char *verb); +int legic_write_dump_to_tag(uint8_t *dump, size_t bytes_read); #endif diff --git a/tools/kgh/CMakeLists.txt b/tools/kgh/CMakeLists.txt new file mode 100644 index 000000000..27c62eb4f --- /dev/null +++ b/tools/kgh/CMakeLists.txt @@ -0,0 +1,35 @@ +#----------------------------------------------------------------------------- +# 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. +#----------------------------------------------------------------------------- + +cmake_minimum_required(VERSION 3.10) +project(legic_kgh_tool) + +set(PM3_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../..) + +add_subdirectory(${PM3_ROOT}/client/experimental_lib ${CMAKE_BINARY_DIR}/experimental_lib) + +add_executable(legic_kgh_tool legic_kgh_tool.c) +target_link_libraries(legic_kgh_tool PRIVATE pm3rrg_rdv4_static) +target_include_directories(legic_kgh_tool PRIVATE + ${PM3_ROOT}/common + ${PM3_ROOT}/client/include + ${PM3_ROOT}/client/src + ${PM3_ROOT}/include +) + +if (MINGW) + target_link_options(legic_kgh_tool PRIVATE -static -static-libgcc) +endif() diff --git a/tools/kgh/README.md b/tools/kgh/README.md new file mode 100644 index 000000000..d3fff500e --- /dev/null +++ b/tools/kgh/README.md @@ -0,0 +1,71 @@ +# legic_kgh_tool + +## Running + +`legic_kgh_tool` reads KGH LEGIC card information, badge numbers, and stamps, +and writes the supported KGH card layout. + +Examples: + +```bash +./legic_kgh_tool COM13 read_badge_number +./legic_kgh_tool COM13 read_info +./legic_kgh_tool COM13 read_stamp +./legic_kgh_tool COM13 read_stamp -o stamp.bin +./legic_kgh_tool COM13 write_card 600001 --stamp-file stamp.bin +``` + +Commands: + +- `read_badge_number` prints the badge number only. +- `read_info` prints one-line JSON. +- `read_stamp` prints the stamp as 8 hex chars, or writes raw 4 bytes with `-o/--output-file`. +- `write_card (--stamp-file | --stamp-hex <8hex>)` writes the supported KGH layout. + +Notes: + +- Windows ProxSpace examples use `COM13`. +- The stamp is 4 bytes and specific to your site. + It can be specified as a `.bin` file or as `--stamp-hex` (for example, `003EF417`). +- You can retrieve the stamp from a supported KGH card with `read_info` or `read_stamp`. +- Linux examples usually use `/dev/ttyACM0` or similar. +- `--verbose` can be useful for `read_badge_number` and `write_card`, if they fail for mysterious reasons. + +## Building in ProxSpace (for Windows) + +Do this in ProxSpace: + +```bash +cd ~/proxmark3/tools/kgh +rm -rf build-lite +cmake -G "MSYS Makefiles" -S . -B build-lite \ + -DSKIPPYTHON=1 \ + -DSKIPREADLINE=1 \ + -DSKIPJANSSONSYSTEM=1 \ + -DSKIPWHEREAMISYSTEM=1 \ + -DSKIPBT=1 +cmake --build build-lite --target legic_kgh_tool -j +objdump -p build-lite/legic_kgh_tool.exe | grep -i "DLL Name" +``` + +## Building Linux + +```bash +cd tools/kgh +rm -rf build-linux +cmake -S . -B build-linux \ + -DSKIPPYTHON=1 \ + -DSKIPREADLINE=1 \ + -DSKIPJANSSONSYSTEM=1 \ + -DSKIPWHEREAMISYSTEM=1 \ + -DSKIPBT=1 +cmake --build build-linux --target legic_kgh_tool -j +ldd build-linux/legic_kgh_tool +``` + +## Static Link Notes + +- `legic_kgh_tool` is linked against `pm3rrg_rdv4_static`. +- On MinGW, CMake adds `-static -static-libgcc` for the target. +- Linux builds are not the same as the ProxSpace single-EXE deployment. +- If CMakeCache paths change between ProxSpace and a native shell, delete the build dir and reconfigure. diff --git a/tools/kgh/legic_kgh_tool.c b/tools/kgh/legic_kgh_tool.c new file mode 100644 index 000000000..429eea54a --- /dev/null +++ b/tools/kgh/legic_kgh_tool.c @@ -0,0 +1,659 @@ +//----------------------------------------------------------------------------- +// 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. +//----------------------------------------------------------------------------- + +#include +#include +#include +#include +#include + +#include "pm3.h" +#include "pm3_cmd.h" +#include "legic.h" +#include "cmdhflegic.h" +#include "ui.h" +#include "util.h" +#include "util_posix.h" +#include "crc.h" + +static pm3 *open_pm3_with_retry(const char *port) { + for (int i = 0; i < 3; ++i) { + pm3 *dev = pm3_open(port); + if (g_session.pm3_present) { + return dev; + } + msleep(250); + } + return pm3_open(port); +} + +static bool has_flag(int argc, char *argv[], const char *flag) { + for (int i = 2; i < argc; ++i) { + if (strcmp(argv[i], flag) == 0) { + return true; + } + } + return false; +} + +static const uint8_t k_legic_template_head[35] = { + 0x3e, 0x00, 0x00, 0xb6, 0x00, 0x60, 0xea, 0x9f, 0xff, 0x00, 0x00, 0x00, 0x11, 0x01, 0x06, 0x80, + 0x00, 0x00, 0xeb, 0xa1, 0x00, 0x00, 0x0d, 0xc0, 0x08, 0x00, 0x2f, 0x73, 0x73, 0x73, 0x73, 0x62, + 0x62, 0x62, 0x54 +}; + +static bool encode_badge_bcd(uint32_t badge, uint8_t out[3]) { + if (badge > 999999u) { + return false; + } + + uint32_t digits[6] = {0}; + for (int i = 5; i >= 0; --i) { + digits[i] = badge % 10u; + badge /= 10u; + } + + out[0] = (uint8_t)((digits[0] << 4) | digits[1]); + out[1] = (uint8_t)((digits[2] << 4) | digits[3]); + out[2] = (uint8_t)((digits[4] << 4) | digits[5]); + return true; +} + +static bool decode_badge_bcd(const uint8_t in[3], uint32_t *badge_out) { + uint32_t digits[6] = { + (uint32_t)(in[0] >> 4), (uint32_t)(in[0] & 0x0F), + (uint32_t)(in[1] >> 4), (uint32_t)(in[1] & 0x0F), + (uint32_t)(in[2] >> 4), (uint32_t)(in[2] & 0x0F) + }; + + for (size_t i = 0; i < 6; ++i) { + if (digits[i] > 9u) { + return false; + } + } + + *badge_out = digits[0] * 100000u + digits[1] * 10000u + digits[2] * 1000u + digits[3] * 100u + digits[4] * 10u + digits[5]; + return true; +} + +static bool parse_badge_text(const char *text, uint32_t *badge_out) { + if (text == NULL || *text == '\0') { + return false; + } + + char *end = NULL; + unsigned long badge = strtoul(text, &end, 10); + if (end == text || *end != '\0' || badge > 999999UL) { + return false; + } + + *badge_out = (uint32_t)badge; + return true; +} + +static bool parse_stamp_hex(const char *text, uint8_t stamp[4]) { + if (text == NULL || strlen(text) != 8) { + return false; + } + + for (int i = 0; i < 4; ++i) { + char byte_str[3] = { text[i * 2], text[i * 2 + 1], '\0' }; + char *end = NULL; + long value = strtol(byte_str, &end, 16); + if (end == byte_str || *end != '\0' || value < 0 || value > 255) { + return false; + } + stamp[i] = (uint8_t)value; + } + + return true; +} + +static bool load_stamp_file(const char *path, uint8_t stamp[4]) { + FILE *fp = fopen(path, "rb"); + if (fp == NULL) { + return false; + } + + uint8_t buf[4] = {0}; + size_t read_len = fread(buf, 1, sizeof(buf), fp); + int extra = fgetc(fp); + fclose(fp); + + if (read_len != sizeof(buf) || extra != EOF) { + return false; + } + + memcpy(stamp, buf, sizeof(buf)); + return true; +} + +static bool save_stamp_file(const char *path, const uint8_t stamp[4]) { + FILE *fp = fopen(path, "wb"); + if (fp == NULL) { + return false; + } + + size_t written = fwrite(stamp, 1, 4, fp); + fclose(fp); + return written == 4; +} + +static bool get_arg_value(int argc, char *argv[], const char *flag, const char **value) { + for (int i = 3; i < argc - 1; ++i) { + if (strcmp(argv[i], flag) == 0) { + *value = argv[i + 1]; + return true; + } + } + return false; +} + +static void apply_stamp(uint8_t *dump, size_t dump_len, const uint8_t stamp[4]) { + if (dump_len <= 30) { + return; + } + memcpy(dump + 27, stamp, 4); +} + +static void build_migration_dump(uint32_t badge, const uint8_t stamp[4], uint8_t *dump, size_t dump_len) { + memset(dump, 0, dump_len); + memcpy(dump, k_legic_template_head, sizeof(k_legic_template_head)); + apply_stamp(dump, dump_len, stamp); + uint8_t bcd[3] = {0}; + if (!encode_badge_bcd(badge, bcd)) { + fprintf(stderr, "badge number out of range\n"); + exit(EXIT_FAILURE); + } + + dump[31] = bcd[0]; + dump[32] = bcd[1]; + dump[33] = bcd[2]; + dump[34] = 0xBD; +} + +typedef struct { + uint8_t *dump; + uint16_t len; + legic_card_select_t card; +} legic_read_result_t; + +static bool read_legic_dump(legic_read_result_t *res, bool verbose) { + memset(res, 0, sizeof(*res)); + + uint8_t prev_print = g_printAndLog; + g_printAndLog &= ~PRINTANDLOG_PRINT; + + for (int attempt = 0; attempt < 3; ++attempt) { + free(res->dump); + memset(res, 0, sizeof(*res)); + + if (legic_get_type(&res->card) != PM3_SUCCESS) { + if (verbose) { + fprintf(stderr, "read_info retry %d: legic_get_type failed\n", attempt + 1); + } + msleep(100); + continue; + } + + res->dump = calloc(res->card.cardsize, sizeof(uint8_t)); + if (res->dump == NULL) { + g_printAndLog = prev_print; + return false; + } + + int status = legic_read_mem(0, res->card.cardsize, 0x55, res->dump, &res->len); + if (status != PM3_SUCCESS || res->len < 35) { + if (verbose) { + fprintf(stderr, "read_info retry %d: legic_read_mem failed\n", attempt + 1); + } + msleep(100); + continue; + } + + uint8_t crc = res->dump[4]; + if (CRC8Legic(res->dump, 4) != crc) { + if (verbose) { + fprintf(stderr, "read_info retry %d: header crc mismatch\n", attempt + 1); + } + msleep(100); + continue; + } + + for (uint16_t i = 22; i < res->len; ++i) { + res->dump[i] ^= crc; + } + + g_printAndLog = prev_print; + return true; + } + + free(res->dump); + memset(res, 0, sizeof(*res)); + g_printAndLog = prev_print; + return false; +} + +static void free_legic_read_result(legic_read_result_t *res) { + free(res->dump); + res->dump = NULL; + res->len = 0; + memset(&res->card, 0, sizeof(res->card)); +} + +static bool is_kgh_card(const uint8_t *dump, uint16_t len) { + return len >= sizeof(k_legic_template_head) && + dump[5] == 0x60 && dump[6] == 0xEA && + dump[7] == 0x9F && dump[8] == 0xFF && + dump[22] == 0x0D && dump[23] == 0xC0 && + dump[24] == 0x08 && dump[25] == 0x00; +} + +static const char *classify_legic_card(const uint8_t *dump, uint16_t len) { + if (len < 9) { + return "unknown"; + } + + uint16_t dcf = ((uint16_t)dump[6] << 8) | dump[5]; + if (dcf == 0xFFFF) { + return "NM"; + } + + if (dcf > 60000u) { + return "IAM"; + } + + if (is_kgh_card(dump, len)) { + return "KGH"; + } + + return "unknown"; +} + +static bool check_kgh_crc_ok(const uint8_t *dump, uint16_t len) { + if (strcmp(classify_legic_card(dump, len), "KGH") != 0) { + return false; + } + + if (len <= 34) { + return false; + } + + uint8_t *copy = calloc(len, sizeof(uint8_t)); + if (copy == NULL) { + return false; + } + + memcpy(copy, dump, len); + const uint8_t uid[4] = { copy[0], copy[1], copy[2], copy[3] }; + bool ok = legic_clone_update_segment_crcs(copy, len, uid) && legic_clone_update_kgh_crcs(copy, len, uid) && (copy[34] == dump[34]); + free(copy); + return ok; +} + +static bool check_kgh_crc_calc(const uint8_t *dump, uint16_t len, uint8_t *crc_out) { + if (strcmp(classify_legic_card(dump, len), "KGH") != 0) { + return false; + } + + if (len <= 34) { + return false; + } + + uint8_t *copy = calloc(len, sizeof(uint8_t)); + if (copy == NULL) { + return false; + } + + memcpy(copy, dump, len); + const uint8_t uid[4] = { copy[0], copy[1], copy[2], copy[3] }; + if (!legic_clone_update_segment_crcs(copy, len, uid) || !legic_clone_update_kgh_crcs(copy, len, uid)) { + free(copy); + return false; + } + + *crc_out = copy[34]; + bool ok = (*crc_out == dump[34]); + free(copy); + return ok; +} + +static bool has_extra_segments(const uint8_t *dump, uint16_t len) { + size_t start = 22; + bool saw_first = false; + + while (start + 5 <= len) { + uint16_t seg_len = (((uint16_t)dump[start + 1] & 0x0F) << 8) | dump[start]; + bool is_last = ((dump[start + 1] & 0x08) != 0); + if (seg_len < 5 || start + seg_len > len) { + break; + } + + if (saw_first) { + return true; + } + + saw_first = true; + if (is_last) { + break; + } + + start += seg_len; + } + + return false; +} + +static bool check_segment_crc_ok(const uint8_t *dump, uint16_t len) { + if (len < 27) { + return false; + } + + uint8_t prev_print = g_printAndLog; + g_printAndLog &= ~PRINTANDLOG_PRINT; + + uint8_t *copy = calloc(len, sizeof(uint8_t)); + if (copy == NULL) { + g_printAndLog = prev_print; + return false; + } + + memcpy(copy, dump, len); + const uint8_t uid[4] = { copy[0], copy[1], copy[2], copy[3] }; + bool ok = legic_clone_update_segment_crcs(copy, len, uid) && (memcmp(copy, dump, len) == 0); + free(copy); + g_printAndLog = prev_print; + return ok; +} + +static bool check_segment_crc_calc(const uint8_t *dump, uint16_t len, uint8_t *crc_out) { + if (len < 27) { + return false; + } + + uint8_t prev_print = g_printAndLog; + g_printAndLog &= ~PRINTANDLOG_PRINT; + + uint8_t *copy = calloc(len, sizeof(uint8_t)); + if (copy == NULL) { + g_printAndLog = prev_print; + return false; + } + + memcpy(copy, dump, len); + const uint8_t uid[4] = { copy[0], copy[1], copy[2], copy[3] }; + if (!legic_clone_update_segment_crcs(copy, len, uid)) { + free(copy); + g_printAndLog = prev_print; + return false; + } + + *crc_out = copy[26]; + bool ok = (memcmp(copy, dump, len) == 0); + free(copy); + g_printAndLog = prev_print; + return ok; +} + +static bool decode_badge_value(const uint8_t *dump, uint16_t len, uint32_t *badge_out) { + if (len < 34) { + return false; + } + return decode_badge_bcd(&dump[31], badge_out); +} + +static bool extract_stamp(const uint8_t *dump, uint16_t len, uint8_t stamp[4]) { + if (len <= 30) { + return false; + } + + memcpy(stamp, dump + 27, 4); + return true; +} + +static void print_json_string(const char *key, const char *value, bool last) { + printf("\"%s\": \"%s\"%s", key, value, last ? "" : ","); +} + +static void print_json_bool(const char *key, bool value, bool last) { + printf("\"%s\": %s%s", key, value ? "true" : "false", last ? "" : ","); +} + +static void print_json_uint32(const char *key, uint32_t value, bool last) { + printf("\"%s\": %u%s", key, value, last ? "" : ","); +} + +static void print_json_null(const char *key, bool last) { + printf("\"%s\": null%s", key, last ? "" : ","); +} + +static void print_read_info_json(const legic_read_result_t *res) { + const uint8_t *dump = res->dump; + uint16_t len = res->len; + uint32_t calc_mcc = (uint32_t)CRC8Legic((uint8_t *)dump, 4); + bool mcc_ok = (calc_mcc == dump[4]); + bool is_kgh = (strcmp(classify_legic_card(dump, len), "KGH") == 0); + bool segment_crc_ok = check_segment_crc_ok(dump, len); + bool kgh_crc_ok = check_kgh_crc_ok(dump, len); + uint8_t segment_header_crc_calc = 0; + uint8_t kgh_segment_crc_calc = 0; + (void)check_segment_crc_calc(dump, len, &segment_header_crc_calc); + (void)(is_kgh ? check_kgh_crc_calc(dump, len, &kgh_segment_crc_calc) : false); + char segment_header_crc_calc_hex[3] = {0}; + char kgh_segment_crc_calc_hex[3] = {0}; + snprintf(segment_header_crc_calc_hex, sizeof(segment_header_crc_calc_hex), "%02X", segment_header_crc_calc); + if (is_kgh) { + snprintf(kgh_segment_crc_calc_hex, sizeof(kgh_segment_crc_calc_hex), "%02X", kgh_segment_crc_calc); + } + bool extra_segments = has_extra_segments(dump, len); + + uint32_t badge = 0; + bool badge_ok = decode_badge_value(dump, len, &badge); + char badge_raw[16] = {0}; + if (!badge_ok) { + snprintf(badge_raw, sizeof(badge_raw), "0x%02X%02X%02X", dump[31], dump[32], dump[33]); + } + + printf("{"); + print_json_string("card_type", classify_legic_card(dump, len), false); + print_json_string("mcd", sprint_hex_inrow((uint8_t *)dump, 1), false); + print_json_string("msn", sprint_hex_inrow((uint8_t *)dump + 1, 3), false); + print_json_string("mcc", sprint_hex_inrow((uint8_t *)dump + 4, 1), false); + print_json_bool("mcc_ok", mcc_ok, false); + print_json_string("dcf", sprint_hex_inrow((uint8_t *)dump + 5, 2), false); + print_json_bool("segment_header_crc_ok", segment_crc_ok, false); + print_json_string("segment_header_crc", sprint_hex_inrow((uint8_t *)dump + 26, 1), false); + print_json_string("segment_header_crc_calc", segment_header_crc_calc_hex, false); + print_json_bool("is_kgh", is_kgh, false); + print_json_bool("has_extra_segments", extra_segments, false); + + if (is_kgh) { + char stamp[16] = {0}; + snprintf(stamp, sizeof(stamp), "%02X%02X%02X%02X", dump[27], dump[28], dump[29], dump[30]); + print_json_string("stamp", stamp, false); + print_json_string("kgh_segment_crc", sprint_hex_inrow((uint8_t *)dump + 34, 1), false); + print_json_string("kgh_segment_crc_calc", kgh_segment_crc_calc_hex, false); + if (badge_ok) { + print_json_uint32("badge_number", badge, false); + print_json_null("badge_number_raw", false); + print_json_string("badge_number_format", "dec", false); + } else { + print_json_null("badge_number", false); + print_json_string("badge_number_raw", badge_raw, false); + print_json_string("badge_number_format", "hex", false); + } + print_json_bool("kgh_segment_crc_ok", kgh_crc_ok, true); + } else { + print_json_null("stamp", false); + print_json_null("kgh_segment_crc", false); + print_json_null("kgh_segment_crc_calc", false); + print_json_null("badge_number", false); + print_json_null("badge_number_raw", false); + print_json_null("badge_number_format", false); + print_json_bool("kgh_segment_crc_ok", false, true); + } + printf("}\n"); +} + +static int read_badge_from_card(uint32_t *badge_out) { + uint8_t prev_print = g_printAndLog; + g_printAndLog &= ~PRINTANDLOG_PRINT; + + legic_card_select_t card; + if (legic_get_type(&card) != PM3_SUCCESS) { + g_printAndLog = prev_print; + return 1; + } + + uint8_t *dump = calloc(card.cardsize, sizeof(uint8_t)); + if (dump == NULL) { + g_printAndLog = prev_print; + return 1; + } + + uint16_t datalen = 0; + int status = legic_read_mem(0, card.cardsize, 0x55, dump, &datalen); + if (status != PM3_SUCCESS || datalen < 35) { + free(dump); + g_printAndLog = prev_print; + return 1; + } + + uint8_t crc = dump[4]; + if (CRC8Legic(dump, 4) != crc) { + free(dump); + g_printAndLog = prev_print; + return 1; + } + + for (uint16_t i = 22; i < datalen; ++i) { + dump[i] ^= crc; + } + + bool is_kgh = is_kgh_card(dump, datalen); + bool ok = is_kgh && decode_badge_bcd(&dump[31], badge_out); + if (!is_kgh) { + fprintf(stderr, "not a supported KGH card\n"); + } + free(dump); + g_printAndLog = prev_print; + return ok ? 0 : 1; +} + +int main(int argc, char *argv[]) { + if (argc < 3) { + fprintf(stderr, "Usage:\n"); + fprintf(stderr, " %s read_badge_number [-v|--verbose]\n", argv[0]); + fprintf(stderr, " %s read_info\n", argv[0]); + fprintf(stderr, " %s read_stamp [-o|--output-file ]\n", argv[0]); + fprintf(stderr, " %s write_card (--stamp-file | --stamp-hex <8hex>)\n", argv[0]); + return EXIT_FAILURE; + } + + g_session.incognito = true; + bool verbose = has_flag(argc, argv, "-v") || has_flag(argc, argv, "--verbose"); + g_printAndLog = verbose ? PRINTANDLOG_PRINT : 0; + pm3 *dev = open_pm3_with_retry(argv[1]); + int rc = EXIT_FAILURE; + + if (strcmp(argv[2], "read_badge_number") == 0) { + uint32_t badge = 0; + if (read_badge_from_card(&badge) == 0) { + printf("%u\n", badge); + rc = EXIT_SUCCESS; + } + } else if (strcmp(argv[2], "read_info") == 0) { + legic_read_result_t res; + if (read_legic_dump(&res, verbose)) { + print_read_info_json(&res); + rc = EXIT_SUCCESS; + free_legic_read_result(&res); + } else if (verbose) { + fprintf(stderr, "failed to read card info\n"); + } + } else if (strcmp(argv[2], "read_stamp") == 0) { + const char *output_file = NULL; + bool has_output = get_arg_value(argc, argv, "-o", &output_file) || get_arg_value(argc, argv, "--output-file", &output_file); + + legic_read_result_t res; + if (read_legic_dump(&res, verbose)) { + uint8_t stamp[4] = {0}; + if (is_kgh_card(res.dump, res.len) && extract_stamp(res.dump, res.len, stamp)) { + if (has_output) { + if (save_stamp_file(output_file, stamp)) { + rc = EXIT_SUCCESS; + } else { + fprintf(stderr, "failed to write stamp file\n"); + } + } else { + printf("%02X%02X%02X%02X\n", stamp[0], stamp[1], stamp[2], stamp[3]); + rc = EXIT_SUCCESS; + } + } else { + fprintf(stderr, "not a supported KGH card\n"); + } + free_legic_read_result(&res); + } else if (verbose) { + fprintf(stderr, "failed to read stamp\n"); + } + } else if (strcmp(argv[2], "write_card") == 0) { + if (argc < 4) { + fprintf(stderr, "missing badge number\n"); + } else { + uint32_t badge = 0; + if (!parse_badge_text(argv[3], &badge)) { + fprintf(stderr, "invalid badge number\n"); + pm3_close(dev); + return EXIT_FAILURE; + } + const char *stamp_file = NULL; + const char *stamp_hex = NULL; + bool has_file = get_arg_value(argc, argv, "--stamp-file", &stamp_file); + bool has_hex = get_arg_value(argc, argv, "--stamp-hex", &stamp_hex); + if (has_file == has_hex) { + fprintf(stderr, "specify exactly one of --stamp-file or --stamp-hex\n"); + pm3_close(dev); + return EXIT_FAILURE; + } + + uint8_t stamp[4] = {0}; + if (has_file) { + if (!load_stamp_file(stamp_file, stamp)) { + fprintf(stderr, "failed to load stamp file\n"); + pm3_close(dev); + return EXIT_FAILURE; + } + } else if (!parse_stamp_hex(stamp_hex, stamp)) { + fprintf(stderr, "invalid stamp hex\n"); + pm3_close(dev); + return EXIT_FAILURE; + } + + uint8_t dump[35] = {0}; + build_migration_dump(badge, stamp, dump, sizeof(dump)); + if (legic_migrate_dump(dump, sizeof(dump), true, (const uint8_t[2]) {0x60, 0xEA}, true) == PM3_SUCCESS) { + rc = EXIT_SUCCESS; + } else { + fprintf(stderr, "failed to write card\n"); + } + } + } else { + fprintf(stderr, "unknown command: %s\n", argv[2]); + } + + pm3_close(dev); + return rc; +}