hf 14b view: decode MyKey / COGES keys on SRIX4K

The SRIX4K block scrambler in cmdhf14b.c was a three entry lookup table with
its callers commented out, so `hf 14b valid` printed hard coded values and
nothing ever decoded. The scrambler is a 4x4 transpose of the block read as
sixteen crumbs. A transpose is its own inverse and it reproduces all three
entries of the old table, so the stub is replaced by a working parser.

client/src/parsers/parsemykey.c reads the application off a dump: key id,
production date, operations counter, vendor code, lock id, current and
previous credit, and the eight slot transaction ring. Every block carries a
checksum in its top byte and the parser reports how many hold up, which
catches a wrong UID or a torn write. The credit blocks are XORed with a
session key derived from the UID, the vendor code and the count down counter
in block 6, so the file name has to carry the UID.

`hf 14b valid` is removed. Checking that the maths holds is now
`hf 14b view --selftest`, following `hf mf view --selftest`, and it runs
against traces/hf-14b-D0021F673CB26556-dump.json, a dump of a real reset key.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
iceman1001andClaude Opus 5 committed 2026-09-16 10:58:57 +02:00
1 parent 199c3f107c
commit e648438306
9 files changed
+630 -151

No files matched your search

+1
View File
@@ -512,6 +512,7 @@ set (TARGET_SOURCES
${PM3_ROOT}/client/src/parsers/parsehid.c
${PM3_ROOT}/client/src/parsers/parsevigik.c
${PM3_ROOT}/client/src/parsers/parsehexact.c
${PM3_ROOT}/client/src/parsers/parsemykey.c
${PM3_ROOT}/client/src/parsers/parseproac.c
${PM3_ROOT}/client/src/parsers/hrtparser/hrtparser.c
${PM3_ROOT}/client/src/pla.c
+1
View File
@@ -910,6 +910,7 @@ SRCS = mifare/aiddesfire.c \
parsers/parsehid.c \
parsers/parsevigik.c \
parsers/parsehexact.c \
parsers/parsemykey.c \
parsers/parseproac.c \
parsers/hrtparser/hrtparser.c \
pm3.c \
+1
View File
@@ -439,6 +439,7 @@ set (TARGET_SOURCES
${PM3_ROOT}/client/src/parsers/parsehid.c
${PM3_ROOT}/client/src/parsers/parsevigik.c
${PM3_ROOT}/client/src/parsers/parsehexact.c
${PM3_ROOT}/client/src/parsers/parsemykey.c
${PM3_ROOT}/client/src/parsers/parseproac.c
${PM3_ROOT}/client/src/parsers/hrtparser/hrtparser.c
${PM3_ROOT}/client/src/pla.c
+21 -151
View File
@@ -37,6 +37,7 @@
#include "cmdhf.h" // handle HF plot
#include "atrs.h" // atqbToEmulatedAtr
#include "pla.h" // ECP parsing
#include "parsers/parsemykey.h" // MyKey / COGES
#define MAX_14B_TIMEOUT_MS (4949U)
@@ -2619,153 +2620,6 @@ static int CmdHF14BRestore(const char *Cmd) {
return PM3_SUCCESS;
}
/*
static uint32_t srix4kEncode(uint32_t value) {
// vv = value
// pp = position
// vv vv vv pp
// 4 bytes : 00 1A 20 01
// only the lower crumbs.
uint8_t block = (value & 0xFF);
uint8_t i = 0;
uint8_t valuebytes[] = {0, 0, 0};
Uint3byteToMemBe(valuebytes, value >> 8);
uint32_t value_x = (value >> 8);
PrintAndLogEx(INFO, "value...... %08x %06x", value, value_x);
PrintAndLogEx(INFO, "3b value... %s", sprint_hex_inrow(valuebytes, sizeof(valuebytes)));
PrintAndLogEx(INFO, "block no... %02x", block);
// Scrambled part
// Crumb swapping of value.
uint32_t foo = 0;
foo |= CRUMB(value_x, 22) << 28;
foo |= CRUMB(value_x, 14) << 26;
foo |= CRUMB(value_x, 6) << 24;
foo |= CRUMB(value_x, 20) << 20;
foo |= CRUMB(value_x, 12) << 18;
foo |= CRUMB(value_x, 4) << 16;
foo |= CRUMB(value_x, 18) << 12;
foo |= CRUMB(value_x, 10) << 10;
foo |= CRUMB(value_x, 2) << 8;
foo |= CRUMB(value_x, 16) << 4;
foo |= CRUMB(value_x, 8) << 2;
foo |= CRUMB(value_x, 0) << 0;
PrintAndLogEx(INFO, "hex........ %02x %02x %02x", CRUMB(value_x, 22), CRUMB(value_x, 14), CRUMB(value_x, 6));
PrintAndLogEx(INFO, "hex........ %02x %02x %02x", CRUMB(value_x, 20), CRUMB(value_x, 12), CRUMB(value_x, 4));
PrintAndLogEx(INFO, "hex........ %02x %02x %02x", CRUMB(value_x, 18), CRUMB(value_x, 10), CRUMB(value_x, 2));
PrintAndLogEx(INFO, "hex........ %02x %02x %02x", CRUMB(value_x, 16), CRUMB(value_x, 8), CRUMB(value_x, 0));
PrintAndLogEx(INFO, "hex........ %08x", foo);
// chksum part
uint32_t chksum = 0xFF - block;
// chksum is reduced by each nibbles of value.
for (i = 0; i < 3; ++i) {
chksum -= NIBBLE_HIGH(valuebytes[i]);
chksum -= NIBBLE_LOW(valuebytes[i]);
}
// base4 conversion and left shift twice
i = 3;
uint8_t base4[] = {0, 0, 0, 0};
while (chksum != 0) {
base4[i--] = (chksum % 4 << 2);
chksum /= 4;
}
PrintAndLogEx(INFO, "%s", sprint_hex_inrow(base4, sizeof(base4)));
// merge scambled and chksum parts
uint32_t encvalue = 0;
(NIBBLE_LOW(base4[0]) << 28) |
(NIBBLE_HIGH(temp[0]) << 24) |
(NIBBLE_LOW(base4[1]) << 20) |
(NIBBLE_LOW(temp[0]) << 16) |
(NIBBLE_LOW(base4[2]) << 12) |
(NIBBLE_HIGH(temp[1]) << 8) |
(NIBBLE_LOW(base4[3]) << 4) |
NIBBLE_LOW(temp[1]);
PrintAndLogEx(NORMAL, "ICE encoded | %08X -> %08X", value, encvalue);
return encvalue;
}
*/
static uint32_t srix4k_decode_counter(uint32_t num) {
uint32_t value = ~num;
++value;
return value;
}
/*
static uint32_t srix4kDecode(uint32_t value) {
switch (value) {
case 0xC04F42C5:
return 0x003139;
case 0xC1484807:
return 0x002943;
case 0xC0C60848:
return 0x001A20;
}
return 0;
}
*/
static uint32_t srix4k_get_magicbytes(uint64_t uid, uint32_t block6, uint32_t block18, uint32_t block19) {
#define MASK 0xFFFFFFFF;
uint32_t uid32 = uid & MASK;
uint32_t counter = srix4k_decode_counter(block6);
uint32_t decodedBlock18 = 0;
uint32_t decodedBlock19 = 0;
// uint32_t decodedBlock18 = srix4kDecode(block18);
// uint32_t decodedBlock19 = srix4kDecode(block19);
uint32_t doubleBlock = (decodedBlock18 << 16 | decodedBlock19) + 1;
uint32_t result = (uid32 * doubleBlock * counter) & MASK;
PrintAndLogEx(SUCCESS, "Magic bytes | %08X", result);
return result;
}
static int CmdSRIX4kValid(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "hf 14b valid",
"SRIX checksum test",
"hf 14b valid\n"
);
void *argtable[] = {
arg_param_begin,
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
CLIParserFree(ctx);
uint64_t uid = 0xD00202501A4532F9;
uint32_t block6 = 0xFFFFFFFF;
uint32_t block18 = 0xC04F42C5;
uint32_t block19 = 0xC1484807;
uint32_t block21 = 0xD1BCABA4;
uint32_t test_b18 = 0x001A2001; // 0x00313918;
uint32_t test_b18_enc = 0;
// uint32_t test_b18_enc = srix4kEncode(test_b18);
// uint32_t test_b18_dec = srix4kDecode(test_b18_enc);
PrintAndLogEx(SUCCESS, "ENCODE & CHECKSUM | %08X -> %08X (%s)", test_b18, test_b18_enc, "");
uint32_t magic = srix4k_get_magicbytes(uid, block6, block18, block19);
PrintAndLogEx(SUCCESS, "BLOCK 21 | %08X -> %08X (no XOR)", block21, magic ^ block21);
return PM3_SUCCESS;
}
int select_card_14443b_4(bool disconnect, iso14b_card_select_t *card) {
if (card) {
memset(card, 0, sizeof(iso14b_card_select_t));
@@ -3471,13 +3325,15 @@ static int CmdHF14BView(const char *Cmd) {
"note:\n"
" - command expects the filename to contain a UID\n"
" which is needed to determine card memory type",
"hf 14b view -f hf-14b-01020304-dump.bin"
"hf 14b view -f hf-14b-01020304-dump.bin\n"
"hf 14b view --selftest"
);
void *argtable[] = {
arg_param_begin,
arg_str1("f", "file", "<fn>", "Specify a filename for dump file"),
arg_str0("f", "file", "<fn>", "Specify a filename for dump file"),
arg_lit0("v", "verbose", "verbose output"),
arg_lit0("z", "dense", "dense dump output style"),
arg_lit0(NULL, "selftest", "Run the dump parsers self tests and exit"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, false);
@@ -3486,8 +3342,18 @@ static int CmdHF14BView(const char *Cmd) {
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
bool verbose = arg_get_lit(ctx, 2);
bool dense_output = (g_session.dense_output || arg_get_lit(ctx, 3));
bool selftest = arg_get_lit(ctx, 4);
CLIParserFree(ctx);
if (selftest) {
return mykey_selftest();
}
if (fnlen == 0) {
PrintAndLogEx(ERR, "Specify a filename with `" _YELLOW_("-f") "` or run `" _YELLOW_("--selftest") "`");
return PM3_EINVARG;
}
// read dump file
uint8_t *dump = NULL;
size_t bytes_read = (ST25TB_SR_BLOCK_SIZE * 0x100);
@@ -3504,7 +3370,12 @@ static int CmdHF14BView(const char *Cmd) {
// figure out a way to identify the different dump files.
// STD/SR/CT is difference
print_sr_blocks(dump, bytes_read, get_uid_from_filename(filename), dense_output);
const uint8_t *uid = get_uid_from_filename(filename);
print_sr_blocks(dump, bytes_read, uid, dense_output);
if (is_valid_mykey_card(dump, bytes_read)) {
(void)mykey_parser_parse(dump, bytes_read, uid);
}
//print_std_blocks(dump, bytes_read);
//print_ct_blocks(dump, bytes_read);
@@ -3739,7 +3610,6 @@ static command_t CommandTable[] = {
{"wrbl", CmdHF14BSriWrbl, IfPm3Iso14443b, "Write data to a SRI512/SRIX4 tag"},
{"tearoff", CmdHF14BSriTearoff, IfPm3Iso14443b, "Tear-off attack on ST25TB/SRx counter blocks"},
{"view", CmdHF14BView, AlwaysAvailable, "Display content from tag dump file"},
{"valid", CmdSRIX4kValid, AlwaysAvailable, "SRIX4 checksum test"},
{"---------", CmdHelp, IfPm3Iso14443b, "------------------ " _CYAN_("ASK CTS / C-ticket") " ------------------"},
{"ctdump", CmdHF14BCtsDump, IfPm3Iso14443b, "Dump ASK CTS/C-ticket"},
{"ctrdbl", CmdHF14BCtRdBl, IfPm3Iso14443b, "Read ASK CTS/C-ticket block"},
+419
View File
@@ -0,0 +1,419 @@
//-----------------------------------------------------------------------------
// 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.
//-----------------------------------------------------------------------------
// MyKey / COGES parser for SRIX4K - ST25TB04K dumps
//-----------------------------------------------------------------------------
#include "parsemykey.h"
#include "commonutil.h" // ARRAYLEN, MemBeToUint4byte, MemLeToUint4byte
#include "ui.h" // PrintAndLogEx
// Blocks below 0x10 are written by the chip maker and the key issuer
#define MYKEY_BLK_LOCKID 0x05 // lock id marker in the low byte
#define MYKEY_BLK_OTP 0x06 // count down counter, feeds the session key
#define MYKEY_BLK_KEYID 0x07 // key id, low three bytes
#define MYKEY_BLK_PRODUCED 0x08 // production date, BCD
// The application itself starts at 0x10 and keeps most fields in duplicate
#define MYKEY_BLK_APP_FIRST 0x10
#define MYKEY_BLK_ELAPSED 0x10 // key id top byte + days since 1995-01-01
#define MYKEY_BLK_KEYID_A 0x11 // mirror of block 7
#define MYKEY_BLK_OPS 0x12 // operations counter
#define MYKEY_BLK_KEYID_B 0x15 // mirror of block 7
#define MYKEY_BLK_VENDOR_HI 0x18
#define MYKEY_BLK_VENDOR_LO 0x19
#define MYKEY_BLK_CREDIT_A 0x21 // current credit, XORed with the session key
#define MYKEY_BLK_PREV_A 0x23 // credit before the last transaction
#define MYKEY_BLK_CREDIT_B 0x25
#define MYKEY_BLK_PREV_B 0x27
#define MYKEY_BLK_TXN_FIRST 0x34 // eight slot transaction ring
#define MYKEY_BLK_TXN_CNT 8
#define MYKEY_BLK_TXN_PTR 0x3C
// Vendor code a key carries when it is not bound to any vendor
#define MYKEY_VENDOR_RESET 0xFEDC0123
#define MYKEY_LOCKID_MARK 0x7F
#define MYKEY_BLANK 0xFFFFFFFF
static uint8_t mykey_bcd(uint8_t v) {
return (NIBBLE_HIGH(v) * 10) + NIBBLE_LOW(v);
}
static uint32_t mykey_scramble(uint32_t block) {
uint32_t res = 0;
for (uint8_t i = 0; i < 16; i++) {
uint8_t dst = ((i % 4) * 4) + (i / 4);
res |= (uint32_t)CRUMB(block, i * 2) << (dst * 2);
}
return res;
}
static uint8_t mykey_crc(uint32_t block, uint8_t blockno) {
uint8_t crc = 0xFF - blockno;
for (uint8_t i = 0; i < 24; i += 4) {
crc -= NIBBLE_LOW(block >> i);
}
return crc;
}
static bool mykey_crc_ok(uint32_t block, uint8_t blockno) {
return (mykey_crc(block, blockno) == (block >> 24));
}
static uint32_t mykey_block(const uint8_t *dump, uint8_t blockno) {
return MemBeToUint4byte(dump + (blockno * MYKEY_BLOCK_SIZE));
}
static uint32_t mykey_vendor(const uint8_t *dump) {
uint32_t hi = mykey_scramble(mykey_block(dump, MYKEY_BLK_VENDOR_HI));
uint32_t lo = mykey_scramble(mykey_block(dump, MYKEY_BLK_VENDOR_LO));
return ((hi & 0xFFFF) << 16) | (lo & 0xFFFF);
}
static uint32_t mykey_session_key(const uint8_t *dump, const uint8_t *uid) {
uint32_t otp = ~BSWAP_32(mykey_block(dump, MYKEY_BLK_OTP)) + 1;
return MemLeToUint4byte(uid) * (mykey_vendor(dump) + 1) * otp;
}
bool is_valid_mykey_card(const uint8_t *dump, size_t dumplen) {
if (dump == NULL || dumplen < MYKEY_BYTES) {
return false;
}
uint32_t keyid = mykey_block(dump, MYKEY_BLK_KEYID);
if (keyid == MYKEY_BLANK || keyid == 0) {
return false;
}
const uint8_t mirrors[2] = { MYKEY_BLK_KEYID_A, MYKEY_BLK_KEYID_B };
for (uint8_t i = 0; i < ARRAYLEN(mirrors); i++) {
uint32_t b = mykey_block(dump, mirrors[i]);
if ((b & 0x00FFFFFF) != (keyid & 0x00FFFFFF)) {
return false;
}
if (mykey_crc_ok(b, mirrors[i]) == false) {
return false;
}
}
return true;
}
static int32_t mykey_credit(const uint8_t *dump, uint8_t blockno, uint32_t sk) {
uint32_t v = mykey_scramble(mykey_block(dump, blockno) ^ sk);
if (mykey_crc_ok(v, blockno) == false) {
return PM3_ECRC;
}
return (int32_t)(v & 0xFFFF);
}
static uint16_t mykey_check_blocks(const uint8_t *dump, uint32_t sk, uint16_t *total) {
uint16_t ok = 0;
*total = 0;
uint32_t keymask = mykey_block(dump, MYKEY_BLK_KEYID) & 0x00FFFFFF;
for (uint16_t i = MYKEY_BLK_APP_FIRST; i < MYKEY_NUM_BLOCKS; i++) {
uint32_t b = mykey_block(dump, i);
if (b == MYKEY_BLANK) {
continue;
}
if ((i >= MYKEY_BLK_TXN_FIRST) && (i < (MYKEY_BLK_TXN_FIRST + MYKEY_BLK_TXN_CNT))) {
continue;
}
(*total)++;
if (mykey_crc_ok(b, i) ||
mykey_crc_ok(mykey_scramble(b), i) ||
mykey_crc_ok(mykey_scramble(b ^ sk), i) ||
mykey_crc_ok(mykey_scramble(b ^ keymask), i)) {
ok++;
}
}
return ok;
}
static void mykey_print_produced(uint32_t blk) {
uint8_t day = mykey_bcd((blk >> 24) & 0xFF);
uint8_t month = mykey_bcd((blk >> 16) & 0xFF);
uint16_t year = (mykey_bcd(SWAP_NIBBLE(blk & 0xFF)) * 100) + mykey_bcd((blk >> 8) & 0xFF);
PrintAndLogEx(INFO, "Produced........... " _YELLOW_("%04u-%02u-%02u"), year, month, day);
}
static void mykey_print_transactions(const uint8_t *dump) {
uint32_t ptrblk = mykey_block(dump, MYKEY_BLK_TXN_PTR);
int32_t ptr = -1;
if (ptrblk != MYKEY_BLANK) {
uint32_t v = mykey_scramble(ptrblk ^ (mykey_block(dump, MYKEY_BLK_KEYID) & 0x00FFFFFF));
if (mykey_crc_ok(v, MYKEY_BLK_TXN_PTR)) {
ptr = (int32_t)((v >> 16) & 0xFF);
}
if (ptr > (MYKEY_BLK_TXN_CNT - 1)) {
ptr = -1;
}
}
uint8_t used = 0;
for (uint8_t i = 0; i < MYKEY_BLK_TXN_CNT; i++) {
if (mykey_block(dump, MYKEY_BLK_TXN_FIRST + i) != MYKEY_BLANK) {
used++;
}
}
if (used == 0) {
PrintAndLogEx(INFO, "Transactions....... " _YELLOW_("none"));
return;
}
PrintAndLogEx(INFO, "Transactions....... %u of %u slots used", used, MYKEY_BLK_TXN_CNT);
for (uint8_t i = 0; i < MYKEY_BLK_TXN_CNT; i++) {
uint32_t t = mykey_block(dump, MYKEY_BLK_TXN_FIRST + i);
if (t == MYKEY_BLANK) {
continue;
}
PrintAndLogEx(INFO, " %s slot %u........ %04u-%02u-%02u " _GREEN_("%u.%02u") " EUR",
(i == ptr) ? ">" : " ",
i,
2000 + ((t >> 16) & 0x7F),
NIBBLE_LOW(t >> 23),
(t >> 27) & 0x1F,
(t & 0xFFFF) / 100,
(t & 0xFFFF) % 100
);
}
}
int mykey_parser_parse(const uint8_t *dump, size_t dumplen, const uint8_t *uid) {
if (is_valid_mykey_card(dump, dumplen) == false) {
return PM3_EINVARG;
}
PrintAndLogEx(NORMAL, "");
PrintAndLogEx(INFO, "--- " _CYAN_("MyKey / COGES") " ------------------------");
PrintAndLogEx(INFO, "Key ID............. " _YELLOW_("%06X"), mykey_block(dump, MYKEY_BLK_KEYID) & 0x00FFFFFF);
mykey_print_produced(mykey_block(dump, MYKEY_BLK_PRODUCED));
uint32_t elapsed = mykey_block(dump, MYKEY_BLK_ELAPSED) & 0xFFFF;
if (elapsed) {
PrintAndLogEx(INFO, "Days since 1995.... %04X", elapsed);
}
uint32_t ops = mykey_block(dump, MYKEY_BLK_OPS);
if (mykey_crc_ok(ops, MYKEY_BLK_OPS)) {
PrintAndLogEx(INFO, "Operations......... " _YELLOW_("%u"), ops & 0x00FFFFFF);
}
uint32_t vendor = mykey_vendor(dump);
if (vendor == MYKEY_VENDOR_RESET) {
PrintAndLogEx(INFO, "Vendor............. " _YELLOW_("reset") ", not bound to a vendor");
} else {
PrintAndLogEx(INFO, "Vendor............. " _YELLOW_("%08X"), vendor);
}
bool lockid = ((mykey_block(dump, MYKEY_BLK_LOCKID) & 0xFF) == MYKEY_LOCKID_MARK);
PrintAndLogEx(INFO, "Lock ID............ %s", lockid ? _RED_("yes") : _GREEN_("no"));
bool have_uid = false;
for (uint8_t i = 0; (uid != NULL) && (i < 8); i++) {
if (uid[i]) {
have_uid = true;
break;
}
}
if (have_uid == false) {
PrintAndLogEx(INFO, "Session key........ " _YELLOW_("unknown") ", UID needed to decrypt the credit");
PrintAndLogEx(INFO, "Credit............. %08X " _YELLOW_("still encrypted"), mykey_block(dump, MYKEY_BLK_CREDIT_A));
mykey_print_transactions(dump);
return PM3_SUCCESS;
}
uint32_t sk = mykey_session_key(dump, uid);
PrintAndLogEx(INFO, "Session key........ " _YELLOW_("%08X"), sk);
int32_t credit = mykey_credit(dump, MYKEY_BLK_CREDIT_A, sk);
int32_t copy = mykey_credit(dump, MYKEY_BLK_CREDIT_B, sk);
if (credit == PM3_ECRC) {
PrintAndLogEx(INFO, "Credit............. " _RED_("checksum failed") ", wrong UID or unknown vendor");
} else {
PrintAndLogEx(INFO, "Credit............. " _GREEN_("%u.%02u") " EUR", credit / 100, credit % 100);
if (copy != credit) {
PrintAndLogEx(INFO, " block %02X disagrees, a torn write", MYKEY_BLK_CREDIT_B);
}
}
// The previous credit is scrambled but not XORed with the session key
int32_t prev = mykey_credit(dump, MYKEY_BLK_PREV_A, 0);
int32_t prev_copy = mykey_credit(dump, MYKEY_BLK_PREV_B, 0);
if (prev != PM3_ECRC) {
PrintAndLogEx(INFO, "Previous credit.... " _GREEN_("%u.%02u") " EUR", prev / 100, prev % 100);
if (prev_copy != prev) {
PrintAndLogEx(INFO, " block %02X disagrees, a torn write", MYKEY_BLK_PREV_B);
}
}
if (lockid && (credit == PM3_ECRC)) {
PrintAndLogEx(WARNING, "Lock id set and the credit does not check out");
}
mykey_print_transactions(dump);
uint16_t total = 0;
uint16_t ok = mykey_check_blocks(dump, sk, &total);
PrintAndLogEx(INFO, "Block checksums.... %u / %u ( %s )"
, ok
, total
, (ok == total) ? _GREEN_("ok") : _RED_("fail")
);
return PM3_SUCCESS;
}
// A reset key read off an ST25TB04K. Every written block checksums, the vendor
// is the reset code and the credit is zero.
static const uint8_t mykey_selftest_uid[8] = { 0x56, 0x65, 0xB2, 0x3C, 0x67, 0x1F, 0x02, 0xD0 };
static const uint8_t mykey_selftest_dump[MYKEY_BYTES] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x64, 0x95, 0x43, 0x19, 0x27, 0x10, 0x21, 0x02,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xE5, 0x64, 0x00, 0x00, 0xCF, 0x95, 0x43, 0x19,
0xEC, 0x00, 0x00, 0x01, 0xE4, 0x04, 0x00, 0x13, 0xE1, 0x64, 0x00, 0x00,
0xCB, 0x95, 0x43, 0x19, 0xE8, 0x00, 0x00, 0x01, 0xE0, 0x04, 0x00, 0x13,
0x8F, 0xCD, 0x0F, 0x48, 0xC0, 0x82, 0x00, 0x07, 0xC0, 0x80, 0x40, 0x40,
0xC0, 0x80, 0x40, 0x00, 0x8F, 0x8D, 0xCF, 0x48, 0xC0, 0x42, 0xC0, 0x07,
0xC0, 0x80, 0x00, 0x40, 0xC0, 0x80, 0x00, 0x00, 0xC0, 0x40, 0xC0, 0x90,
0x65, 0x23, 0x56, 0x98, 0xC0, 0x66, 0x01, 0x13, 0xC0, 0x40, 0xC0, 0x00,
0xC0, 0x40, 0x80, 0x90, 0x65, 0x23, 0x16, 0x98, 0xC0, 0x26, 0xC1, 0x13,
0xC0, 0x40, 0x80, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xB6, 0x64, 0x00, 0x00, 0xA0, 0x95, 0x43, 0x19, 0xBD, 0x00, 0x00, 0x01,
0xB5, 0x04, 0x00, 0x13, 0xB2, 0x64, 0x00, 0x00, 0x9C, 0x95, 0x43, 0x19,
0xB9, 0x00, 0x00, 0x01, 0xB1, 0x04, 0x00, 0x13, 0x8F, 0x0D, 0x0F, 0x88,
0x80, 0xC2, 0x00, 0x47, 0x80, 0xC0, 0x40, 0x80, 0x80, 0xC0, 0x40, 0x40,
0x4F, 0xCD, 0xCF, 0x88, 0x80, 0x82, 0xC0, 0x47, 0x80, 0xC0, 0x00, 0x80,
0x80, 0xC0, 0x00, 0x40, 0x80, 0x80, 0xC0, 0xD0, 0x80, 0x80, 0xC0, 0xC0,
0x80, 0xA6, 0x01, 0x53, 0x80, 0x80, 0xC0, 0x40, 0x80, 0x80, 0x80, 0xD0,
0x80, 0x80, 0x80, 0xC0, 0x80, 0x66, 0xC1, 0x53, 0x80, 0x80, 0x80, 0x40,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
static const struct {
uint32_t enc;
uint32_t dec;
} mykey_selftest_vectors[] = {
{ 0xC04F42C5, 0xD7003139 },
{ 0xC1484807, 0xD4002943 },
{ 0xC0C60848, 0xF1001A20 },
};
int mykey_selftest(void) {
PrintAndLogEx(INFO, "Testing MyKey block scrambler and session key");
for (uint8_t i = 0; i < ARRAYLEN(mykey_selftest_vectors); i++) {
uint32_t enc = mykey_selftest_vectors[i].enc;
uint32_t dec = mykey_selftest_vectors[i].dec;
if (mykey_scramble(enc) != dec) {
PrintAndLogEx(FAILED, " %08X descrambled to %08X, expected %08X ( " _RED_("fail") " )"
, enc
, mykey_scramble(enc)
, dec
);
return PM3_ESOFT;
}
if (mykey_scramble(dec) != enc) {
PrintAndLogEx(FAILED, " scrambler is not its own inverse on %08X ( " _RED_("fail") " )", dec);
return PM3_ESOFT;
}
}
PrintAndLogEx(INFO, " scrambler.......... %u vectors, self inverse ( " _GREEN_("ok") " )", (unsigned)ARRAYLEN(mykey_selftest_vectors));
if (is_valid_mykey_card(mykey_selftest_dump, sizeof(mykey_selftest_dump)) == false) {
PrintAndLogEx(FAILED, " known good dump not recognised ( " _RED_("fail") " )");
return PM3_ESOFT;
}
uint32_t vendor = mykey_vendor(mykey_selftest_dump);
if (vendor != MYKEY_VENDOR_RESET) {
PrintAndLogEx(FAILED, " vendor %08X, expected the reset code %08X ( " _RED_("fail") " )", vendor, MYKEY_VENDOR_RESET);
return PM3_ESOFT;
}
uint32_t sk = mykey_session_key(mykey_selftest_dump, mykey_selftest_uid);
PrintAndLogEx(INFO, " session key........ %08X", sk);
int32_t credit = mykey_credit(mykey_selftest_dump, MYKEY_BLK_CREDIT_A, sk);
if (credit != 0) {
PrintAndLogEx(FAILED, " credit read back as %d, expected 0 ( " _RED_("fail") " )", credit);
return PM3_ESOFT;
}
uint16_t total = 0;
uint16_t ok = mykey_check_blocks(mykey_selftest_dump, sk, &total);
if (ok != total || total == 0) {
PrintAndLogEx(FAILED, " %u of %u block checksums ( " _RED_("fail") " )", ok, total);
return PM3_ESOFT;
}
PrintAndLogEx(INFO, " block checksums.... %u / %u ( " _GREEN_("ok") " )", ok, total);
PrintAndLogEx(SUCCESS, "MyKey parser selftest ( " _GREEN_("ok") " )");
return PM3_SUCCESS;
}
+32
View File
@@ -0,0 +1,32 @@
//-----------------------------------------------------------------------------
// 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.
//-----------------------------------------------------------------------------
// MyKey / COGES parser for SRIX4K - ST25TB04K dumps
//-----------------------------------------------------------------------------
#ifndef PARSEMYKEY_H__
#define PARSEMYKEY_H__
#include "common.h"
#define MYKEY_BLOCK_SIZE 4
#define MYKEY_NUM_BLOCKS 128
#define MYKEY_BYTES (MYKEY_NUM_BLOCKS * MYKEY_BLOCK_SIZE)
bool is_valid_mykey_card(const uint8_t *dump, size_t dumplen);
int mykey_parser_parse(const uint8_t *dump, size_t dumplen, const uint8_t *uid);
int mykey_selftest(void);
#endif