2937 lines
97 KiB
C
2937 lines
97 KiB
C
//-----------------------------------------------------------------------------
|
|
// 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.
|
|
//-----------------------------------------------------------------------------
|
|
// Low frequency Hitag support
|
|
//-----------------------------------------------------------------------------
|
|
#include "cmdlfhitag.h"
|
|
#include "cmdlfhitaghts.h"
|
|
#include "cmdlfhitagu.h"
|
|
#include <ctype.h>
|
|
#include "cmdparser.h" // command_t
|
|
#include "comms.h"
|
|
#include "cmdtrace.h"
|
|
#include "commonutil.h"
|
|
#include "fileutils.h" // savefile
|
|
#include "protocols.h" // defines
|
|
#include "cliparser.h"
|
|
#include "crc.h"
|
|
#include "graph.h" // MAX_GRAPH_TRACE_LEN
|
|
#include "lfdemod.h"
|
|
#include "cmddata.h" // setDemodBuff
|
|
#include "pm3_cmd.h" // return codes
|
|
#include "hitag2/hitag2_crypto.h"
|
|
#include "util_posix.h" // msclock
|
|
|
|
static int CmdHelp(const char *Cmd);
|
|
|
|
static const uint8_t ht2_default_keys[] = {
|
|
0xBD, 0xF5, 0xE8, 0x46 // PAXTON
|
|
};
|
|
|
|
static const char *getHitagTypeStr(uint32_t uid) {
|
|
//uid s/n ********
|
|
uint8_t type = (uid >> 4) & 0xF;
|
|
switch (type) {
|
|
case 1:
|
|
return "PCF 7936";
|
|
case 2:
|
|
return "PCF 7946";
|
|
case 3:
|
|
return "PCF 7947";
|
|
case 4:
|
|
return "PCF 7942/44";
|
|
case 5:
|
|
return "PCF 7943";
|
|
case 6:
|
|
return "PCF 7941";
|
|
case 7:
|
|
return "PCF 7952";
|
|
case 8:
|
|
return "PCF 7961";
|
|
case 9:
|
|
return "PCF 7945";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
uint8_t hitag1_CRC_check(uint8_t *d, uint32_t nbit) {
|
|
if (nbit < 9) {
|
|
return 2;
|
|
}
|
|
return (CRC8Hitag1Bits(d, nbit) == 0);
|
|
}
|
|
|
|
|
|
/*
|
|
static size_t nbytes(size_t nbits) {
|
|
return (nbits / 8) + ((nbits % 8) > 0);
|
|
}
|
|
*/
|
|
|
|
static int CmdLFHitagList(const char *Cmd) {
|
|
return CmdTraceListAlias(Cmd, "lf hitag", "ht2");
|
|
/*
|
|
uint8_t *got = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
|
|
if (got == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
return PM3_EMALLOC;
|
|
}
|
|
|
|
// Query for the actual size of the trace
|
|
PacketResponseNG resp;
|
|
if (!GetFromDevice(BIG_BUF, got, PM3_CMD_DATA_SIZE, 0, NULL, 0, &resp, 2500, false)) {
|
|
PrintAndLogEx(WARNING, "command execution time out");
|
|
free(got);
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
|
|
uint16_t traceLen = resp.arg[2];
|
|
if (traceLen > PM3_CMD_DATA_SIZE) {
|
|
uint8_t *p = realloc(got, traceLen);
|
|
if (p == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
free(got);
|
|
return PM3_EMALLOC;
|
|
}
|
|
got = p;
|
|
if (!GetFromDevice(BIG_BUF, got, traceLen, 0, NULL, 0, NULL, 2500, false)) {
|
|
PrintAndLogEx(WARNING, "command execution time out");
|
|
free(got);
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
}
|
|
|
|
PrintAndLogEx(NORMAL, "recorded activity (TraceLen = %d bytes):");
|
|
PrintAndLogEx(NORMAL, " ETU :nbits: who bytes");
|
|
PrintAndLogEx(NORMAL, "---------+-----+----+-----------");
|
|
|
|
int i = 0;
|
|
int prev = -1;
|
|
int len = strlen(Cmd);
|
|
|
|
char filename[FILE_PATH_SIZE] = { 0x00 };
|
|
FILE *f = NULL;
|
|
|
|
if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
|
|
|
|
memcpy(filename, Cmd, len);
|
|
|
|
if (strlen(filename) > 0) {
|
|
f = fopen(filename, "wb");
|
|
if (!f) {
|
|
PrintAndLogEx(ERR, "Error: Could not open file [%s]", filename);
|
|
return PM3_EFILE;
|
|
}
|
|
}
|
|
|
|
for (;;) {
|
|
|
|
if (i >= traceLen) { break; }
|
|
|
|
bool isResponse;
|
|
int timestamp = *((uint32_t *)(got + i));
|
|
if (timestamp & 0x80000000) {
|
|
timestamp &= 0x7fffffff;
|
|
isResponse = 1;
|
|
} else {
|
|
isResponse = 0;
|
|
}
|
|
|
|
int parityBits = *((uint32_t *)(got + i + 4));
|
|
// 4 bytes of additional information...
|
|
// maximum of 32 additional parity bit information
|
|
//
|
|
// TODO:
|
|
// at each quarter bit period we can send power level (16 levels)
|
|
// or each half bit period in 256 levels.
|
|
|
|
int bits = got[i + 8];
|
|
int len = nbytes(got[i + 8]);
|
|
|
|
if (len > 100) {
|
|
break;
|
|
}
|
|
if (i + len > traceLen) { break;}
|
|
|
|
uint8_t *frame = (got + i + 9);
|
|
|
|
// Break and stick with current result if buffer was not completely full
|
|
if (frame[0] == 0x44 && frame[1] == 0x44 && frame[3] == 0x44) { break; }
|
|
|
|
char line[1000] = "";
|
|
int j;
|
|
for (j = 0; j < len; j++) {
|
|
|
|
int offset = j * 4;
|
|
//if((parityBits >> (len - j - 1)) & 0x01) {
|
|
if (isResponse && (oddparity8(frame[j]) != ((parityBits >> (len - j - 1)) & 0x01))) {
|
|
snprintf(line + offset, sizeof(line) - offset, "%02x! ", frame[j]);
|
|
} else {
|
|
snprintf(line + offset, sizeof(line) - offset, "%02x ", frame[j]);
|
|
}
|
|
}
|
|
|
|
PrintAndLogEx(NORMAL, " +%7d: %3d: %s %s",
|
|
(prev < 0 ? 0 : (timestamp - prev)),
|
|
bits,
|
|
(isResponse ? "TAG" : " "),
|
|
line);
|
|
|
|
if (f) {
|
|
fprintf(f, " +%7d: %3d: %s %s\n",
|
|
(prev < 0 ? 0 : (timestamp - prev)),
|
|
bits,
|
|
(isResponse ? "TAG" : " "),
|
|
line);
|
|
}
|
|
|
|
prev = timestamp;
|
|
i += (len + 9);
|
|
}
|
|
|
|
if (f) {
|
|
fclose(f);
|
|
PrintAndLogEx(NORMAL, "Recorded activity successfully written to file: %s", filename);
|
|
}
|
|
|
|
free(got);
|
|
return PM3_SUCCES;
|
|
*/
|
|
}
|
|
|
|
static void print_hitag2_paxton(bool show_header, const uint8_t *data) {
|
|
|
|
// if the pwd isn't..
|
|
if (memcmp(data + 4, "\xBD\xF5\xE8\x46", 4)) {
|
|
return;
|
|
}
|
|
|
|
uint64_t num = 0;
|
|
uint64_t paxton_id = 0;
|
|
uint16_t skip = 48;
|
|
uint64_t mask = 0xF80000000000;
|
|
|
|
uint64_t bytes = bytes_to_num(data + 16, 6);
|
|
|
|
for (int j = 0; j < 8; j++) {
|
|
|
|
num = bytes & mask;
|
|
skip -= 5;
|
|
mask >>= 5;
|
|
|
|
uint8_t digit = (num >> skip & 0xF);
|
|
paxton_id = (paxton_id * 10) + digit;
|
|
|
|
if (j == 5) {
|
|
skip -= 2;
|
|
mask >>= 2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
const uint8_t isocard = 0x06;
|
|
const uint8_t fob = 0x03;
|
|
const uint8_t iso_magstripe = 0x02;
|
|
*/
|
|
|
|
// [=] 4/0x04 | 39 04 21 1C | 9.!. | RW | User
|
|
// [=] 5/0x05 | AC 3F 00 06 | .?.. | RW | User
|
|
|
|
char formfactor[16];
|
|
switch (data[23]) {
|
|
case 0x06: {
|
|
strcat(formfactor, "isocard");
|
|
break;
|
|
}
|
|
case 0x03: {
|
|
strcat(formfactor, "fob");
|
|
break;
|
|
}
|
|
case 0x02: {
|
|
strcat(formfactor, "iso magstripe");
|
|
break;
|
|
}
|
|
default: {
|
|
snprintf(formfactor, sizeof(formfactor), "unk: %02x", data[23]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (show_header) {
|
|
PrintAndLogEx(INFO, "");
|
|
PrintAndLogEx(INFO, "--- " _CYAN_("Possible de-scramble patterns") " -------------");
|
|
}
|
|
PrintAndLogEx(SUCCESS, "Paxton id... %" PRIu64 " | 0x%" PRIx64 " ( %s )", paxton_id, paxton_id, formfactor);
|
|
if (show_header) {
|
|
PrintAndLogEx(INFO, "");
|
|
}
|
|
}
|
|
|
|
static void print_hitag2_configuration(uint32_t uid, uint8_t config) {
|
|
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(INFO, "--- " _CYAN_("Tag Information") " ---------------------------");
|
|
PrintAndLogEx(SUCCESS, "UID...... " _GREEN_("%08X"), uid);
|
|
PrintAndLogEx(SUCCESS, "TYPE..... " _GREEN_("%s"), getHitagTypeStr(uid));
|
|
|
|
char msg[100];
|
|
memset(msg, 0, sizeof(msg));
|
|
|
|
uint8_t bits[8 + 1] = {0};
|
|
num_to_bytebits(config, 8, bits);
|
|
const char *bs = sprint_bytebits_bin(bits, 8);
|
|
|
|
//configuration byte
|
|
// PrintAndLogEx(SUCCESS, "");
|
|
PrintAndLogEx(SUCCESS, "Config... " _YELLOW_("0x%02X"), config);
|
|
PrintAndLogEx(SUCCESS, " %s", bs);
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 0, 4, "RFU"));
|
|
|
|
if (config & 0x8) {
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_YELLOW, bs, 8, 4, 1, "Crypto mode"));
|
|
} else {
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 4, 1, "Password mode"));
|
|
}
|
|
|
|
// version
|
|
uint8_t foo = ((config & 0x6) >> 1);
|
|
switch (foo) {
|
|
case 0:
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 5, 2, "Public mode B, Coding: biphase"));
|
|
break;
|
|
case 1:
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 5, 2, "Public mode A, Coding: manchester"));
|
|
break;
|
|
case 2:
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 5, 2, "Public mode C, Coding: biphase"));
|
|
break;
|
|
case 3:
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 5, 2, "Hitag 2"));
|
|
break;
|
|
}
|
|
|
|
// encoding
|
|
if (config & 0x01) {
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 7, 1, "Biphase"));
|
|
} else {
|
|
PrintAndLogEx(SUCCESS, " %s", sprint_breakdown_bin(C_NONE, bs, 8, 7, 1, "Manchester"));
|
|
}
|
|
PrintAndLogEx(NORMAL, "");
|
|
}
|
|
|
|
const char *annotation[] = {
|
|
"UID", "Pwd", "Key/Pwd", "Config",
|
|
"User", "User", "User", "User",
|
|
"User", "User", "User", "User"
|
|
};
|
|
|
|
static void print_hitag2_blocks(uint8_t *d, uint16_t n) {
|
|
|
|
PrintAndLogEx(INFO, "");
|
|
PrintAndLogEx(INFO, "----------------------------------------------");
|
|
PrintAndLogEx(INFO, " # | data | ascii | lck | Info");
|
|
PrintAndLogEx(INFO, "--------+-------------+-------+-----+---------");
|
|
|
|
uint8_t config = d[HITAG2_CONFIG_OFFSET];
|
|
uint8_t blocks = (n / HITAG_BLOCK_SIZE);
|
|
|
|
for (uint8_t i = 0; i < blocks; ++i) {
|
|
|
|
char lckstr[20] = {0};
|
|
sprintf(lckstr, " ");
|
|
|
|
switch (i) {
|
|
case 0:
|
|
sprintf(lckstr, "%s", _RED_("L "));
|
|
break;
|
|
case 1:
|
|
if (config & 0x80) {
|
|
sprintf(lckstr, "%s", _RED_("L "));
|
|
} else {
|
|
sprintf(lckstr, "%s", _GREEN_("RW"));
|
|
}
|
|
break;
|
|
case 2:
|
|
if (config & 0x80) {
|
|
if (config & 0x8) {
|
|
sprintf(lckstr, "%s", _RED_("L "));
|
|
} else {
|
|
sprintf(lckstr, "%s", _RED_("R "));
|
|
}
|
|
} else {
|
|
sprintf(lckstr, "%s", _GREEN_("RW"));
|
|
}
|
|
break;
|
|
case 3:
|
|
// OTP Page 3.
|
|
if (config & 0x40) {
|
|
sprintf(lckstr, "%s", _RED_("R "));
|
|
//. Configuration byte and password tag " _RED_("FIXED / IRREVERSIBLE"));
|
|
} else {
|
|
sprintf(lckstr, "%s", _GREEN_("RW"));
|
|
}
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
if (config & 0x20) {
|
|
sprintf(lckstr, "%s", _RED_("R "));
|
|
} else {
|
|
sprintf(lckstr, "%s", _GREEN_("RW"));
|
|
}
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
if (config & 0x10) {
|
|
sprintf(lckstr, "%s", _RED_("R "));
|
|
} else {
|
|
sprintf(lckstr, "%s", _GREEN_("RW"));
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
PrintAndLogEx(INFO, "%2d/0x%02X | %s| %s | %s | %s"
|
|
, i
|
|
, i
|
|
, sprint_hex(d + (i * HITAG_BLOCK_SIZE), HITAG_BLOCK_SIZE)
|
|
, sprint_ascii(d + (i * HITAG_BLOCK_SIZE), HITAG_BLOCK_SIZE)
|
|
, lckstr
|
|
, annotation[i]
|
|
);
|
|
}
|
|
PrintAndLogEx(INFO, "--------+-------------+-------+-----+---------");
|
|
PrintAndLogEx(INFO, " "_RED_("L") " = Locked, "_GREEN_("RW") " = Read Write, R = Read Only");
|
|
PrintAndLogEx(INFO, " FI = Fixed / Irreversible");
|
|
PrintAndLogEx(INFO, "----------------------------------------------");
|
|
}
|
|
|
|
// Annotate HITAG protocol
|
|
void annotateHitag1(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response) {
|
|
}
|
|
|
|
static struct {
|
|
enum {
|
|
STATE_HALT,
|
|
STATE_START_AUTH,
|
|
STATE_AUTH,
|
|
STATE_START_ENCRYPTED,
|
|
STATE_ENCRYPTED,
|
|
} state;
|
|
uint32_t uid;
|
|
uint64_t cipher_state;
|
|
uint8_t plainlen;
|
|
uint8_t plain[30];
|
|
bool found_key;
|
|
uint64_t key;
|
|
} _ht2state;
|
|
|
|
void annotateHitag2_init(void) {
|
|
_ht2state.state = STATE_HALT;
|
|
_ht2state.uid = 0;
|
|
_ht2state.cipher_state = 0;
|
|
_ht2state.plainlen = 0;
|
|
memset(_ht2state.plain, 0, sizeof(_ht2state.plain));
|
|
}
|
|
|
|
static void rev_msb_array(uint8_t *d, uint8_t n) {
|
|
for (uint8_t i = 0 ; i < n ; i++) {
|
|
d[i] = reflect8(d[i]);
|
|
}
|
|
}
|
|
|
|
// param nrar must be 8 bytes
|
|
static bool ht2_check_cryptokeys(const uint64_t *keys, const uint32_t keycount, const uint8_t *nrar) {
|
|
|
|
if (keys == NULL || keycount == 0 || nrar == NULL) {
|
|
return false;
|
|
}
|
|
|
|
uint32_t iv = REV32((nrar[3] << 24) + (nrar[2] << 16) + (nrar[1] << 8) + nrar[0]);
|
|
uint32_t ar = (nrar[4] << 24) + (nrar[5] << 16) + (nrar[6] << 8) + nrar[7];
|
|
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < keycount; i++) {
|
|
|
|
uint64_t key = keys[i];
|
|
key = BSWAP_48(key);
|
|
key = REV64(key);
|
|
|
|
hitag_state_t hs2;
|
|
ht2_hitag2_init_ex(&hs2, key, _ht2state.uid, iv);
|
|
|
|
uint32_t tbits = ht2_hitag2_nstep(&hs2, 32);
|
|
if ((ar ^ tbits) == 0xFFFFFFFF) {
|
|
_ht2state.found_key = true;
|
|
_ht2state.key = key;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
static int ht2_check_dictionary(uint32_t key_count, uint8_t *keys, uint8_t keylen, uint32_t *found_idx) {
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
|
|
uint8_t *pkeys = keys;
|
|
|
|
uint32_t toti = key_count;
|
|
uint32_t cnt = 0;
|
|
|
|
while (key_count--) {
|
|
|
|
cnt++;
|
|
|
|
if (kbd_enter_pressed()) {
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
PrintAndLogEx(WARNING, "\naborted via keyboard!");
|
|
break;
|
|
}
|
|
|
|
PrintAndLogEx(INPLACE, "Checking Keys %u / %u", cnt, toti);
|
|
|
|
msleep(30);
|
|
|
|
if (keylen == 4) {
|
|
packet.cmd = HT2F_PASSWORD;
|
|
memcpy(packet.pwd, pkeys, keylen);
|
|
} else {
|
|
packet.cmd = HT2F_CRYPTO;
|
|
memcpy(packet.key, pkeys, keylen);
|
|
}
|
|
|
|
pkeys += keylen;
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_READER, (uint8_t *)&packet, sizeof(packet));
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_READER, &resp, 4000) == false) {
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
|
|
if (resp.status != PM3_SUCCESS) {
|
|
*found_idx = *found_idx + 1;
|
|
continue;
|
|
}
|
|
return PM3_SUCCESS;
|
|
}
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
|
|
bool hitag2_get_plain(uint8_t *plain, uint8_t *plen) {
|
|
if (_ht2state.state == STATE_ENCRYPTED || _ht2state.state == STATE_START_ENCRYPTED) {
|
|
if (_ht2state.found_key) {
|
|
*plen = _ht2state.plainlen;
|
|
memcpy(plain, _ht2state.plain, _ht2state.plainlen);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// HITAG 2 commands
|
|
#define HITAG2_BINSTR_START_AUTH "11000" // get UID and/or start the authentication process
|
|
#define HITAG2_BINSTR_READ_PAGE "11" // read page after auth
|
|
#define HITAG2_BINSTR_READ_PAGE_INVERTED "01" // as read page but all bits inverted
|
|
#define HITAG2_BINSTR_WRITE_PAGE "10" // write page after auth
|
|
#define HITAG2_BINSTR_HALT "00" // silence currently authenticated tag
|
|
|
|
static uint8_t hitag2_get_page(const char *bs) {
|
|
if ((memcmp(bs + 2, "000", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "111", 3) == 0)) {
|
|
return 0;
|
|
}
|
|
if ((memcmp(bs + 2, "001", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "110", 3) == 0)) {
|
|
return 1;
|
|
}
|
|
if ((memcmp(bs + 2, "010", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "101", 3) == 0)) {
|
|
return 2;
|
|
}
|
|
if ((memcmp(bs + 2, "011", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "100", 3) == 0)) {
|
|
return 3;
|
|
}
|
|
if ((memcmp(bs + 2, "100", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "011", 3) == 0)) {
|
|
return 4;
|
|
}
|
|
if ((memcmp(bs + 2, "101", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "010", 3) == 0)) {
|
|
return 5;
|
|
}
|
|
if ((memcmp(bs + 2, "110", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "001", 3) == 0)) {
|
|
return 6;
|
|
}
|
|
if ((memcmp(bs + 2, "111", 3) == 0) && (memcmp(bs + 2 + 3 + 2, "000", 3) == 0)) {
|
|
return 7;
|
|
}
|
|
return 255;
|
|
}
|
|
|
|
void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, uint8_t bits) {
|
|
|
|
if (cmdsize == 0) {
|
|
return;
|
|
}
|
|
|
|
char *binstr = (char *)calloc((cmdsize * 8) + 1, sizeof(uint8_t));
|
|
if (binstr == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
return;
|
|
}
|
|
|
|
bytes_2_binstr(binstr, cmd, cmdsize);
|
|
|
|
size_t bn = strlen(binstr);
|
|
if (bits) {
|
|
if (cmdsize == 1) {
|
|
bn = bits;
|
|
} else if (cmdsize > 1) {
|
|
bn = ((cmdsize - 1) * 8) + bits;
|
|
}
|
|
}
|
|
|
|
switch (bn) {
|
|
case 5: {
|
|
snprintf(exp, size, " ");
|
|
break;
|
|
}
|
|
case 10: {
|
|
if (memcmp(binstr, HITAG2_BINSTR_HALT, 2) == 0) {
|
|
snprintf(exp, size, " ");
|
|
break;
|
|
}
|
|
|
|
uint8_t page = hitag2_get_page(binstr);
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_READ_PAGE, 2) == 0) {
|
|
snprintf(exp, size, "READ PAGE (" _MAGENTA_("%u") ")", page);
|
|
break;
|
|
}
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_READ_PAGE_INVERTED, 2) == 0) {
|
|
snprintf(exp, size, "READ PAGE INV (" _MAGENTA_("%u") ")", page);
|
|
break;
|
|
}
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_WRITE_PAGE, 2) == 0) {
|
|
snprintf(exp, size, "WRITE PAGE (" _MAGENTA_("%u") ")", page);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 32: { // password or data
|
|
snprintf(exp, size, " ");
|
|
break;
|
|
}
|
|
case 64: { // crypto handshake
|
|
snprintf(exp, size, " ");
|
|
break;
|
|
}
|
|
default: {
|
|
snprintf(exp, size, " ");
|
|
break;
|
|
}
|
|
}
|
|
free(binstr);
|
|
}
|
|
|
|
void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, uint8_t bits, bool is_response, const uint64_t *keys, uint32_t keycount, bool isdecrypted) {
|
|
|
|
if (cmdsize == 0) {
|
|
return;
|
|
}
|
|
|
|
char *binstr = (char *)calloc((cmdsize * 8) + 1, sizeof(uint8_t));
|
|
if (binstr == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
return;
|
|
}
|
|
|
|
bytes_2_binstr(binstr, cmd, cmdsize);
|
|
|
|
size_t bn = strlen(binstr);
|
|
if (bits) {
|
|
if (cmdsize == 1) {
|
|
bn = bits;
|
|
} else if (cmdsize > 1) {
|
|
bn = ((cmdsize - 1) * 8) + bits;
|
|
}
|
|
}
|
|
|
|
memcpy(_ht2state.plain, cmd, cmdsize);
|
|
_ht2state.plainlen = cmdsize;
|
|
|
|
if (_ht2state.state == STATE_ENCRYPTED || _ht2state.state == STATE_START_ENCRYPTED) {
|
|
|
|
if (_ht2state.found_key && isdecrypted == false) {
|
|
ht2_hitag2_cipher_transcrypt(&_ht2state.cipher_state, _ht2state.plain, bn / 8, bn % 8);
|
|
}
|
|
}
|
|
|
|
// 11000 AUTH only one with 5 bits. cmdsize 1
|
|
switch (bn) {
|
|
case 5: {
|
|
annotateHitag2_init();
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_START_AUTH, 5) == 0) {
|
|
snprintf(exp, size, "START AUTH");
|
|
_ht2state.state = STATE_START_AUTH;
|
|
} else {
|
|
snprintf(exp, size, "?");
|
|
}
|
|
break;
|
|
}
|
|
case 10: {
|
|
|
|
if (isdecrypted == false && _ht2state.state == STATE_ENCRYPTED) {
|
|
snprintf(exp, size, "ENC CMD");
|
|
break;
|
|
}
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_HALT, 2) == 0) {
|
|
snprintf(exp, size, "HALT");
|
|
_ht2state.state = STATE_HALT;
|
|
break;
|
|
}
|
|
|
|
uint8_t page = hitag2_get_page(binstr);
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_READ_PAGE, 2) == 0) {
|
|
snprintf(exp, size, "READ PAGE " _WHITE_("(") _MAGENTA_("%u") ")", page);
|
|
break;
|
|
}
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_READ_PAGE_INVERTED, 2) == 0) {
|
|
snprintf(exp, size, "READ PAGE INV " _WHITE_("(") _MAGENTA_("%u") ")", page);
|
|
break;
|
|
}
|
|
|
|
if (memcmp(binstr, HITAG2_BINSTR_WRITE_PAGE, 2) == 0) {
|
|
snprintf(exp, size, "WRITE PAGE " _WHITE_("(") _MAGENTA_("%u") ")", page);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 32: { // password or data
|
|
if (_ht2state.state == STATE_START_AUTH) {
|
|
if (is_response) {
|
|
snprintf(exp, size, "UID");
|
|
uint8_t uid[4];
|
|
memcpy(uid, cmd, 4);
|
|
rev_msb_array(uid, 4);
|
|
_ht2state.uid = MemLeToUint4byte(uid);
|
|
} else {
|
|
snprintf(exp, size, "PWD " _GREEN_("%02X%02X%02X%02X"), cmd[0], cmd[1], cmd[2], cmd[3]);
|
|
_ht2state.state = STATE_AUTH;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (_ht2state.state == STATE_AUTH) {
|
|
snprintf(exp, size, "DATA");
|
|
break;
|
|
}
|
|
|
|
if (_ht2state.state == STATE_START_ENCRYPTED) {
|
|
snprintf(exp, size, "At");
|
|
_ht2state.state = STATE_ENCRYPTED;
|
|
break;
|
|
}
|
|
|
|
if (isdecrypted == false && _ht2state.state == STATE_ENCRYPTED) {
|
|
snprintf(exp, size, "ENC DATA");
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 64: { // crypto handshake
|
|
|
|
if (_ht2state.state == STATE_START_AUTH) {
|
|
|
|
_ht2state.state = STATE_START_ENCRYPTED;
|
|
|
|
// dictionary attack
|
|
if (ht2_check_cryptokeys(keys, keycount, cmd)) {
|
|
|
|
_ht2state.cipher_state = ht2_hitag2_init(
|
|
_ht2state.key,
|
|
_ht2state.uid,
|
|
REV32((cmd[3] << 24) + (cmd[2] << 16) + (cmd[1] << 8) + cmd[0])
|
|
);
|
|
ht2_hitag2_cipher_transcrypt(&_ht2state.cipher_state, _ht2state.plain + 4, 4, 0);
|
|
|
|
uint64_t key = REV64(_ht2state.key);
|
|
key = BSWAP_48(key);
|
|
snprintf(exp, size, "NrAr " _WHITE_("( ") _GREEN_("%012" PRIx64) " )", key);
|
|
|
|
} else {
|
|
snprintf(exp, size, "AUTH NrAr");
|
|
}
|
|
} else {
|
|
snprintf(exp, size, "NrAr decrypted");
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
snprintf(exp, size, "?");
|
|
_ht2state.state = STATE_HALT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
free(binstr);
|
|
}
|
|
|
|
static const char *identify_transponder_hitag2(uint32_t uid) {
|
|
|
|
switch (uid) {
|
|
case 0x53505910:
|
|
return "IMMO Key emulator";
|
|
break;
|
|
case 0x5accc811:
|
|
case 0x5accc821:
|
|
case 0x5accc831:
|
|
case 0x5accc841:
|
|
case 0x5accc851:
|
|
case 0x5accc861:
|
|
case 0x5accc871:
|
|
case 0x5accc881:
|
|
case 0x5accc891:
|
|
case 0x5accc8B1:
|
|
return "CN3 Tango Key emulator";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
static bool ht2_get_uid(uint32_t *uid, bool verbose) {
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
packet.cmd = HT2F_UID_ONLY;
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_READER, (uint8_t *) &packet, sizeof(packet));
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_READER, &resp, 1500) == false) {
|
|
if (verbose) {
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
}
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
return false;
|
|
}
|
|
|
|
if (resp.status != PM3_SUCCESS) {
|
|
PrintAndLogEx(DEBUG, "DEBUG: Error - failed getting Hitag 2 UID");
|
|
return false;
|
|
}
|
|
|
|
if (uid) {
|
|
*uid = bytes_to_num(resp.data.asBytes, HITAG_UID_SIZE);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Try to actually read the configuration byte, rather than assume one.
|
|
//
|
|
// Returns true and fills config/uid if the tag authenticated with this key.
|
|
static bool ht2_try_auth_read(uint8_t cmdtype, const uint8_t *key, uint32_t *uid, uint8_t *config) {
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
packet.cmd = cmdtype;
|
|
|
|
if (cmdtype == HT2F_PASSWORD) {
|
|
memcpy(packet.pwd, key, HITAG_PASSWORD_SIZE);
|
|
} else {
|
|
memcpy(packet.key, key, HITAG_CRYPTOKEY_SIZE);
|
|
}
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_READER, (uint8_t *)&packet, sizeof(packet));
|
|
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_READER, &resp, 2000) == false) {
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
return false;
|
|
}
|
|
|
|
if (resp.status != PM3_SUCCESS) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t *data = resp.data.asBytes;
|
|
*uid = bytes_to_num(data, HITAG_UID_SIZE);
|
|
*config = data[HITAG_BLOCK_SIZE * 3];
|
|
return true;
|
|
}
|
|
|
|
static int CmdLFHitagInfo(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag info",
|
|
"Hitag 2 tag information\n"
|
|
"The configuration byte lives in page 3, which needs authentication.\n"
|
|
"Without a key the two factory defaults are tried.",
|
|
"lf hitag info\n"
|
|
"lf hitag info -k 4D494B52 -> 4 bytes, password mode\n"
|
|
"lf hitag info -k 4F4E4D494B52 -> 6 bytes, crypto mode"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str0("k", "key", "<hex>", "key, 4 bytes for password mode, 6 bytes for crypto mode"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
|
|
uint8_t userkey[HITAG_CRYPTOKEY_SIZE] = {0};
|
|
int ukeylen = 0;
|
|
CLIGetHexWithReturn(ctx, 1, userkey, &ukeylen);
|
|
CLIParserFree(ctx);
|
|
|
|
if ((ukeylen != 0) && (ukeylen != HITAG_PASSWORD_SIZE) && (ukeylen != HITAG_CRYPTOKEY_SIZE)) {
|
|
PrintAndLogEx(ERR, "Key must be %u bytes (password) or %u bytes (crypto), got %i",
|
|
HITAG_PASSWORD_SIZE, HITAG_CRYPTOKEY_SIZE, ukeylen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// read UID
|
|
uint32_t uid = 0;
|
|
if (ht2_get_uid(&uid, true) == false) {
|
|
return PM3_ESOFT;
|
|
}
|
|
// Read the configuration byte may need password or key.
|
|
// Check only the two factory values
|
|
static const uint8_t default_pwd[HITAG_PASSWORD_SIZE] = {0x4D, 0x49, 0x4B, 0x52}; // "MIKR"
|
|
static const uint8_t default_key[HITAG_CRYPTOKEY_SIZE] = {0x4F, 0x4E, 0x4D, 0x49, 0x4B, 0x52}; // "ONMIKR"
|
|
|
|
uint8_t config = 0;
|
|
uint32_t cfg_uid = 0;
|
|
const char *opened_with = NULL;
|
|
|
|
char opened_buf[64] = {0};
|
|
|
|
// A supplied key is tried first, and its length picks the mode: 4 bytes is a
|
|
// password, 6 bytes a crypto key. The factory defaults still follow, so
|
|
// giving a key that turns out to be wrong is no worse than giving none.
|
|
if ((ukeylen == HITAG_PASSWORD_SIZE) &&
|
|
ht2_try_auth_read(HT2F_PASSWORD, userkey, &cfg_uid, &config)) {
|
|
|
|
snprintf(opened_buf, sizeof(opened_buf), "password " _YELLOW_("%s"),
|
|
sprint_hex_inrow(userkey, HITAG_PASSWORD_SIZE));
|
|
opened_with = opened_buf;
|
|
|
|
} else if ((ukeylen == HITAG_CRYPTOKEY_SIZE) &&
|
|
ht2_try_auth_read(HT2F_CRYPTO, userkey, &cfg_uid, &config)) {
|
|
|
|
snprintf(opened_buf, sizeof(opened_buf), "key " _YELLOW_("%s"),
|
|
sprint_hex_inrow(userkey, HITAG_CRYPTOKEY_SIZE));
|
|
opened_with = opened_buf;
|
|
|
|
} else if (ht2_try_auth_read(HT2F_PASSWORD, default_pwd, &cfg_uid, &config)) {
|
|
opened_with = "default password " _YELLOW_("4D494B52");
|
|
} else if (ht2_try_auth_read(HT2F_CRYPTO, default_key, &cfg_uid, &config)) {
|
|
opened_with = "default key " _YELLOW_("4F4E4D494B52");
|
|
}
|
|
|
|
if (opened_with != NULL) {
|
|
print_hitag2_configuration(uid, config);
|
|
PrintAndLogEx(INFO, "Configuration read with %s", opened_with);
|
|
} else {
|
|
PrintAndLogEx(INFO, "--- " _CYAN_("Tag Information"));
|
|
PrintAndLogEx(SUCCESS, "UID...... " _GREEN_("%08X"), uid);
|
|
PrintAndLogEx(INFO, "Config... " _YELLOW_("unknown") " ( page 3 needs authentication )");
|
|
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("lf hitag chk") "` to search for the key");
|
|
}
|
|
|
|
PrintAndLogEx(INFO, "--- " _CYAN_("Fingerprint"));
|
|
const char *s = identify_transponder_hitag2(uid);
|
|
if (strlen(s)) {
|
|
PrintAndLogEx(SUCCESS, "Found... " _GREEN_("%s"), s);
|
|
} else {
|
|
PrintAndLogEx(INFO, _RED_("n/a"));
|
|
}
|
|
|
|
PrintAndLogEx(NORMAL, "");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagReader(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag reader",
|
|
"Act as a Hitag 2 reader. Look for Hitag 2 tags until Enter or the pm3 button is pressed\n",
|
|
"lf hitag reader\n"
|
|
"lf hitag reader -@ -> Continuous mode"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("@", NULL, "continuous reader mode"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
bool cm = arg_get_lit(ctx, 1);
|
|
CLIParserFree(ctx);
|
|
|
|
if (cm) {
|
|
PrintAndLogEx(INFO, "Press " _GREEN_("<Enter>") " to exit");
|
|
}
|
|
|
|
do {
|
|
// read UID
|
|
uint32_t uid = 0;
|
|
if (ht2_get_uid(&uid, (cm == false))) {
|
|
PrintAndLogEx(SUCCESS, "UID.... " _GREEN_("%08X"), uid);
|
|
}
|
|
} while (cm && (kbd_enter_pressed() == false));
|
|
|
|
// Stop the device before returning.
|
|
if (cm) {
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
}
|
|
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagRd(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag read",
|
|
"Read Hitag memory. It support Hitag 2\n\n"
|
|
" Password mode:\n"
|
|
" - default key 4D494B52 (MIKR)\n\n"
|
|
" Crypto mode: \n"
|
|
" - key format ISK high + ISK low\n"
|
|
" - default key 4F4E4D494B52 (ONMIKR)\n"
|
|
,
|
|
" lf hitag read --ht2 --pwd -> Hitag 2, pwd mode, def key\n"
|
|
" lf hitag read --ht2 -k 4D494B52 -> Hitag 2, pwd mode\n"
|
|
" lf hitag read --ht2 --nrar 0102030411223344 -> Hitag 2, challenge mode\n"
|
|
" lf hitag read --ht2 --crypto -> Hitag 2, crypto mode, def key\n"
|
|
" lf hitag read --ht2 -k 4F4E4D494B52 -> Hitag 2, crypto mode\n"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("2", "ht2", "Hitag 2"),
|
|
arg_lit0(NULL, "pwd", "password mode"),
|
|
arg_str0(NULL, "nrar", "<hex>", "nonce / answer writer, 8 hex bytes"),
|
|
arg_lit0(NULL, "crypto", "crypto mode"),
|
|
arg_str0("k", "key", "<hex>", "key, 4 or 6 hex bytes"),
|
|
// currently pm3 fw reads all the memory anyway
|
|
// arg_int1("p", "page", "<dec>", "page address to write to"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
|
|
bool use_ht1 = false; // not yet implemented
|
|
bool use_ht2 = arg_get_lit(ctx, 1);
|
|
bool use_htm = false; // not yet implemented
|
|
|
|
bool use_plain = false;
|
|
bool use_pwd = arg_get_lit(ctx, 2);
|
|
uint8_t nrar[8];
|
|
int nalen = 0;
|
|
int res = CLIParamHexToBuf(arg_get_str(ctx, 3), nrar, sizeof(nrar), &nalen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
bool use_nrar = nalen > 0;
|
|
bool use_crypto = arg_get_lit(ctx, 4);
|
|
|
|
uint8_t key[6];
|
|
int keylen = 0;
|
|
res = CLIParamHexToBuf(arg_get_str(ctx, 5), key, sizeof(key), &keylen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
// uint32_t page = arg_get_u32_def(ctx, 6, 0);
|
|
|
|
CLIParserFree(ctx);
|
|
|
|
// sanity checks
|
|
if ((use_ht1 + use_ht2 + use_htm) > 1) {
|
|
PrintAndLogEx(ERR, "error, specify only one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
if ((use_ht1 + use_ht2 + use_htm) == 0) {
|
|
PrintAndLogEx(ERR, "error, specify one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (keylen != 0 && keylen != 4 && keylen != 6) {
|
|
PrintAndLogEx(WARNING, "Wrong KEY len expected 0, 4 or 6, got %d", keylen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (nalen != 0 && nalen != 8) {
|
|
PrintAndLogEx(WARNING, "Wrong NR/AR len expected 0 or 8, got %d", nalen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// complete options
|
|
if (keylen == 4) {
|
|
use_pwd = true;
|
|
}
|
|
if (keylen == 6) {
|
|
use_crypto = true;
|
|
}
|
|
if ((keylen == 0) && use_pwd) {
|
|
memcpy(key, "MIKR", 4);
|
|
keylen = 4;
|
|
}
|
|
if ((keylen == 0) && use_crypto) {
|
|
memcpy(key, "ONMIKR", 6);
|
|
keylen = 6;
|
|
}
|
|
|
|
// check coherence
|
|
uint8_t foo = (use_plain + use_pwd + use_nrar + use_crypto);
|
|
if (foo > 1) {
|
|
PrintAndLogEx(WARNING, "Specify only one authentication mode");
|
|
return PM3_EINVARG;
|
|
} else if (foo == 0) {
|
|
PrintAndLogEx(WARNING, "Specify one authentication mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (use_ht2 && use_plain) { // not sure for the other types...
|
|
PrintAndLogEx(WARNING, "Chosen Hitag type does not have Plain mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
|
|
int pm3cmd;
|
|
if (use_ht2 && use_pwd) {
|
|
pm3cmd = CMD_LF_HITAG_READER;
|
|
packet.cmd = HT2F_PASSWORD;
|
|
memcpy(packet.pwd, key, sizeof(packet.pwd));
|
|
|
|
} else if (use_ht2 && use_nrar) {
|
|
pm3cmd = CMD_LF_HITAG_READER;
|
|
packet.cmd = HT2F_AUTHENTICATE;
|
|
memcpy(packet.NrAr, nrar, sizeof(packet.NrAr));
|
|
} else if (use_ht2 && use_crypto) {
|
|
|
|
pm3cmd = CMD_LF_HITAG_READER;
|
|
packet.cmd = HT2F_CRYPTO;
|
|
memcpy(packet.key, key, sizeof(packet.key));
|
|
} else {
|
|
PrintAndLogEx(WARNING, "Sorry, not yet implemented");
|
|
return PM3_ENOTIMPL;
|
|
}
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(pm3cmd, (uint8_t *)&packet, sizeof(packet));
|
|
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(pm3cmd, &resp, 2000) == false) {
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
|
|
if (resp.status != PM3_SUCCESS) {
|
|
PrintAndLogEx(DEBUG, "DEBUG: Error - hitag failed");
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
if (use_nrar) {
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
uint8_t *data = resp.data.asBytes;
|
|
uint32_t uid = bytes_to_num(data, HITAG_UID_SIZE);
|
|
print_hitag2_configuration(uid, data[HITAG_BLOCK_SIZE * 3]);
|
|
|
|
if (use_ht2) {
|
|
print_hitag2_blocks(data, HITAG2_MAX_BYTE_SIZE);
|
|
print_hitag2_paxton(true, data);
|
|
} else {
|
|
print_hex_break(data, HITAG_MAX_BYTE_SIZE, HITAG_BLOCK_SIZE);
|
|
}
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagSCheckChallenges(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag cc",
|
|
"Check challenges, load a file with saved hitag crypto challenges and test them all.\n"
|
|
"The file should be 8 * 60 bytes long, the file extension defaults to " _YELLOW_("`.cc`") " ",
|
|
"lf hitag cc -f my_hitag_challenges"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str1("f", "file", "<fn>", "filename to load ( w/o ext )"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE] = {0};
|
|
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
CLIParserFree(ctx);
|
|
|
|
uint8_t *data = NULL;
|
|
size_t datalen = 0;
|
|
int res = loadFile_safe(filename, ".cc", (void **)&data, &datalen);
|
|
if (res == PM3_SUCCESS) {
|
|
|
|
if (datalen % 8) {
|
|
PrintAndLogEx(ERR, "Error, file length mismatch. Expected multiple of 8, got " _RED_("%zu"), datalen);
|
|
free(data);
|
|
return PM3_EINVARG;
|
|
}
|
|
if (datalen != (8 * 60)) {
|
|
PrintAndLogEx(ERR, "Error, file length mismatch. Expected 480, got " _RED_("%zu"), datalen);
|
|
free(data);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAGS_TEST_TRACES, data, datalen);
|
|
}
|
|
if (data) {
|
|
free(data);
|
|
}
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitag2CheckChallenges(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag ta",
|
|
"Test recorded authentications (replay?)",
|
|
"lf hitag ta"
|
|
);
|
|
CLIParserFree(ctx);
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(lf_hitag_data_t));
|
|
packet.cmd = HT2F_TEST_AUTH_ATTEMPTS;
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_READER, (uint8_t *)&packet, sizeof(packet));
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_READER, &resp, 2000) == false) {
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
if (resp.status != PM3_SUCCESS) {
|
|
PrintAndLogEx(DEBUG, "DEBUG: Error - hitag failed");
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
// FIXME: doegox: not sure what this fct does and what it returns...
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagWriter(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag wrbl",
|
|
"Write a page in Hitag memory. It support Hitag 2\n"
|
|
" Password mode:\n"
|
|
" - default key 4D494B52 (MIKR)\n\n"
|
|
" Crypto mode: \n"
|
|
" - key format ISK high + ISK low\n"
|
|
" - default key 4F4E4D494B52 (ONMIKR)\n"
|
|
,
|
|
" lf hitag wrbl --ht2 -p 6 -d 01020304 --pwd -> Hitag 2, pwd mode, def key\n"
|
|
" lf hitag wrbl --ht2 -p 6 -d 01020304 -k 4D494B52 -> Hitag 2, pwd mode\n"
|
|
" lf hitag wrbl --ht2 -p 6 -d 01020304 --nrar 0102030411223344 -> Hitag 2, challenge mode\n"
|
|
" lf hitag wrbl --ht2 -p 6 -d 01020304 --crypto -> Hitag 2, crypto mode, def key\n"
|
|
" lf hitag wrbl --ht2 -p 6 -d 01020304 -k 4F4E4D494B52 -> Hitag 2, crypto mode\n"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("2", "ht2", "Hitag 2"),
|
|
arg_lit0(NULL, "pwd", "password mode"),
|
|
arg_str0(NULL, "nrar", "<hex>", "nonce / answer writer, 8 hex bytes"),
|
|
arg_lit0(NULL, "crypto", "crypto mode"),
|
|
arg_str0("k", "key", "<hex>", "key, 4 or 6 hex bytes"),
|
|
arg_int1("p", "page", "<dec>", "page address to write to"),
|
|
arg_str1("d", "data", "<hex>", "data, 4 hex bytes"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
|
|
bool use_ht1 = false; // not yet implemented
|
|
bool use_ht2 = arg_get_lit(ctx, 1);
|
|
bool use_htm = false; // not yet implemented
|
|
|
|
bool use_plain = false;
|
|
bool use_pwd = arg_get_lit(ctx, 2);
|
|
uint8_t nrar[8];
|
|
int nalen = 0;
|
|
int res = CLIParamHexToBuf(arg_get_str(ctx, 3), nrar, sizeof(nrar), &nalen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
bool use_nrar = nalen > 0;
|
|
bool use_crypto = arg_get_lit(ctx, 4);
|
|
|
|
uint8_t key[6];
|
|
int keylen = 0;
|
|
res = CLIParamHexToBuf(arg_get_str(ctx, 5), key, sizeof(key), &keylen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
int page = arg_get_int_def(ctx, 6, 0);
|
|
|
|
uint8_t data[4];
|
|
int dlen = 0;
|
|
res = CLIParamHexToBuf(arg_get_str(ctx, 7), data, sizeof(data), &dlen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
CLIParserFree(ctx);
|
|
|
|
// sanity checks
|
|
if ((use_ht1 + use_ht2 + use_htm) > 1) {
|
|
PrintAndLogEx(ERR, "error, specify only one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
if ((use_ht1 + use_ht2 + use_htm) == 0) {
|
|
PrintAndLogEx(ERR, "error, specify one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (keylen != 0 && keylen != 4 && keylen != 6) {
|
|
PrintAndLogEx(WARNING, "Wrong KEY len expected 0, 4 or 6, got %d", keylen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (dlen != sizeof(data)) {
|
|
PrintAndLogEx(WARNING, "Wrong DATA len expected 4, got %d", dlen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (nalen != 0 && nalen != 8) {
|
|
PrintAndLogEx(WARNING, "Wrong NR/AR len expected 0 or 8, got %d", nalen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// complete options
|
|
if (keylen == 4) {
|
|
use_pwd = true;
|
|
}
|
|
if (keylen == 6) {
|
|
use_crypto = true;
|
|
}
|
|
if ((keylen == 0) && use_pwd) {
|
|
memcpy(key, "MIKR", 4);
|
|
keylen = 4;
|
|
}
|
|
if ((keylen == 0) && use_crypto) {
|
|
memcpy(key, "ONMIKR", 6);
|
|
keylen = 6;
|
|
}
|
|
|
|
// check coherence
|
|
uint8_t foo = (use_plain + use_pwd + use_nrar + use_crypto);
|
|
if (foo > 1) {
|
|
PrintAndLogEx(WARNING, "Specify only one authentication mode");
|
|
return PM3_EINVARG;
|
|
} else if (foo == 0) {
|
|
PrintAndLogEx(WARNING, "Specify one authentication mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (use_ht2 && use_plain) { // not sure for the other types...
|
|
PrintAndLogEx(WARNING, "Chosen Hitag type does not have Plain mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
|
|
if (use_ht2 && use_pwd) {
|
|
packet.cmd = HT2F_PASSWORD;
|
|
packet.page = page;
|
|
memcpy(packet.pwd, key, sizeof(packet.pwd));
|
|
memcpy(packet.data, data, sizeof(data));
|
|
PrintAndLogEx(INFO, "Authenticating to " _YELLOW_("Hitag 2") " in Password mode");
|
|
|
|
} else if (use_ht2 && use_crypto) {
|
|
packet.cmd = HT2F_CRYPTO;
|
|
packet.page = page;
|
|
memcpy(packet.key, key, sizeof(packet.key));
|
|
memcpy(packet.data, data, sizeof(data));
|
|
PrintAndLogEx(INFO, "Authenticating to " _YELLOW_("Hitag 2") " in Crypto mode");
|
|
|
|
} else {
|
|
PrintAndLogEx(WARNING, "Sorry, not yet implemented");
|
|
return PM3_ENOTIMPL;
|
|
}
|
|
|
|
clearCommandBuffer();
|
|
|
|
if (use_ht2) {
|
|
SendCommandNG(CMD_LF_HITAG2_WRITE, (uint8_t *)&packet, sizeof(packet));
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG2_WRITE, &resp, 4000) == false) {
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
|
|
if (resp.status == PM3_ETEAROFF) {
|
|
PrintAndLogEx(INFO, "Writing tear off triggered");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
if (resp.status != PM3_SUCCESS) {
|
|
PrintAndLogEx(FAILED, "Write ( " _RED_("fail") " )");
|
|
return resp.status;
|
|
}
|
|
|
|
}
|
|
|
|
PrintAndLogEx(SUCCESS, "Write ( " _GREEN_("ok") " )");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
// Write one page, authenticating with the given credential.
|
|
//
|
|
// 4 byte credential is a password, 6 byte is a crypto key, matching every other
|
|
// Hitag 2 command here.
|
|
static int ht2_restore_write_page(uint8_t page, const uint8_t *data, const uint8_t *cred, uint8_t credlen) {
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
packet.page = page;
|
|
memcpy(packet.data, data, HITAG_BLOCK_SIZE);
|
|
|
|
if (credlen == HITAG_PASSWORD_SIZE) {
|
|
packet.cmd = HT2F_PASSWORD;
|
|
memcpy(packet.pwd, cred, HITAG_PASSWORD_SIZE);
|
|
} else {
|
|
packet.cmd = HT2F_CRYPTO;
|
|
memcpy(packet.key, cred, HITAG_CRYPTOKEY_SIZE);
|
|
}
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG2_WRITE, (uint8_t *)&packet, sizeof(packet));
|
|
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG2_WRITE, &resp, 4000) == false) {
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
return resp.status;
|
|
}
|
|
|
|
// Is this a configuration byte a Hitag 2 can actually hold?
|
|
//
|
|
// Bits 7..4 are RFU and are zero on every tag seen; bit 3 picks crypto or
|
|
// password; bits 2..1 pick Hitag 2 (11) or one of the read only public modes;
|
|
// bit 0 is the encoding. Writing rubbish here is the one page that can make a
|
|
// tag useless, so refuse rather than pass it through.
|
|
static bool ht2_config_is_sane(uint8_t cfg, const char **why) {
|
|
|
|
if ((cfg & 0xF0) != 0) {
|
|
*why = "RFU bits 7..4 are not zero";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static int CmdLFHitag2Restore(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag restore",
|
|
"Write a Hitag 2 dump file back to a tag.\n"
|
|
"Pages are written in dependency order: user pages first, then the key\n"
|
|
"material in pages 1 and 2, and the configuration in page 3 last - because\n"
|
|
"page 3 is what switches the tag's mode, and pages 1 and 2 change the very\n"
|
|
"credential needed to write it.\n"
|
|
"Page 0 holds the UID and is never written.",
|
|
"lf hitag restore -f dump.bin -k 4D494B52\n"
|
|
"lf hitag restore -f dump.bin -k 4F4E4D494B52\n"
|
|
"lf hitag restore -f dump.bin -> try the factory defaults"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str1("f", "file", "<fn>", "specify dump filename"),
|
|
arg_str0("k", "key", "<hex>", "key, 4 bytes for password mode, 6 bytes for crypto mode"),
|
|
arg_lit0(NULL, "force", "write even if the configuration byte looks wrong"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE] = {0};
|
|
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
|
|
uint8_t userkey[HITAG_CRYPTOKEY_SIZE] = {0};
|
|
int ukeylen = 0;
|
|
CLIGetHexWithReturn(ctx, 2, userkey, &ukeylen);
|
|
bool force = arg_get_lit(ctx, 3);
|
|
CLIParserFree(ctx);
|
|
|
|
if ((ukeylen != 0) && (ukeylen != HITAG_PASSWORD_SIZE) && (ukeylen != HITAG_CRYPTOKEY_SIZE)) {
|
|
|
|
PrintAndLogEx(ERR, "Key must be %u bytes (password) or %u bytes (crypto), got %i",
|
|
HITAG_PASSWORD_SIZE,
|
|
HITAG_CRYPTOKEY_SIZE,
|
|
ukeylen
|
|
);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// load the dump
|
|
uint8_t *dump = NULL;
|
|
size_t dumplen = 0;
|
|
if (loadFile_safe(filename, ".bin", (void **)&dump, &dumplen) != PM3_SUCCESS) {
|
|
return PM3_EFILE;
|
|
}
|
|
|
|
if (dumplen != HITAG2_MAX_BYTE_SIZE) {
|
|
PrintAndLogEx(ERR, "Expected %u bytes, got %zu", HITAG2_MAX_BYTE_SIZE, dumplen);
|
|
free(dump);
|
|
return PM3_EFILE;
|
|
}
|
|
|
|
const uint8_t new_cfg = dump[HITAG_BLOCK_SIZE * 3];
|
|
const char *why = NULL;
|
|
if (ht2_config_is_sane(new_cfg, &why) == false) {
|
|
PrintAndLogEx(ERR, "Configuration byte " _RED_("0x%02X") " looks wrong: %s", new_cfg, why);
|
|
if (force == false) {
|
|
PrintAndLogEx(INFO, "Use `" _YELLOW_("--force") "` to write it anyway");
|
|
free(dump);
|
|
return PM3_EINVARG;
|
|
}
|
|
PrintAndLogEx(WARNING, "--force given, writing it anyway");
|
|
}
|
|
|
|
// A public mode is read only, so say so before making it permanent.
|
|
if ((new_cfg & 0x06) != 0x06) {
|
|
PrintAndLogEx(WARNING, "Configuration " _YELLOW_("0x%02X") " selects a read only public mode", new_cfg);
|
|
PrintAndLogEx(WARNING, "The tag will not accept writes afterwards");
|
|
}
|
|
|
|
// Find a credential that opens the tag as it is NOW.
|
|
uint8_t cred[HITAG_CRYPTOKEY_SIZE] = {0};
|
|
uint8_t credlen = 0;
|
|
uint8_t cur_cfg = 0;
|
|
uint32_t cur_uid = 0;
|
|
|
|
static const uint8_t default_pwd[HITAG_PASSWORD_SIZE] = {0x4D, 0x49, 0x4B, 0x52};
|
|
static const uint8_t default_key[HITAG_CRYPTOKEY_SIZE] = {0x4F, 0x4E, 0x4D, 0x49, 0x4B, 0x52};
|
|
|
|
if ((ukeylen == HITAG_PASSWORD_SIZE) && ht2_try_auth_read(HT2F_PASSWORD, userkey, &cur_uid, &cur_cfg)) {
|
|
memcpy(cred, userkey, HITAG_PASSWORD_SIZE);
|
|
credlen = HITAG_PASSWORD_SIZE;
|
|
} else if ((ukeylen == HITAG_CRYPTOKEY_SIZE) && ht2_try_auth_read(HT2F_CRYPTO, userkey, &cur_uid, &cur_cfg)) {
|
|
memcpy(cred, userkey, HITAG_CRYPTOKEY_SIZE);
|
|
credlen = HITAG_CRYPTOKEY_SIZE;
|
|
} else if (ht2_try_auth_read(HT2F_PASSWORD, default_pwd, &cur_uid, &cur_cfg)) {
|
|
memcpy(cred, default_pwd, HITAG_PASSWORD_SIZE);
|
|
credlen = HITAG_PASSWORD_SIZE;
|
|
PrintAndLogEx(INFO, "Opened with default password " _YELLOW_("4D494B52"));
|
|
} else if (ht2_try_auth_read(HT2F_CRYPTO, default_key, &cur_uid, &cur_cfg)) {
|
|
memcpy(cred, default_key, HITAG_CRYPTOKEY_SIZE);
|
|
credlen = HITAG_CRYPTOKEY_SIZE;
|
|
PrintAndLogEx(INFO, "Opened with default key " _YELLOW_("4F4E4D494B52"));
|
|
} else {
|
|
PrintAndLogEx(FAILED, "Could not authenticate to the tag");
|
|
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("lf hitag chk") "` to search for the key");
|
|
free(dump);
|
|
return PM3_EFAILED;
|
|
}
|
|
|
|
PrintAndLogEx(INFO, "Tag UID... " _GREEN_("%08X") ", config " _GREEN_("0x%02X"), cur_uid, cur_cfg);
|
|
|
|
// What pages 1 and 2 will make the credential.
|
|
//
|
|
// The password is page 1. The crypto key is the last two bytes of page 2
|
|
// followed by page 1, which is why writing either page changes both.
|
|
uint8_t new_pwd[HITAG_PASSWORD_SIZE] = {0};
|
|
uint8_t new_key[HITAG_CRYPTOKEY_SIZE] = {0};
|
|
memcpy(new_pwd, dump + HITAG_BLOCK_SIZE, HITAG_PASSWORD_SIZE);
|
|
new_key[0] = dump[(HITAG_BLOCK_SIZE * 2) + 2];
|
|
new_key[1] = dump[(HITAG_BLOCK_SIZE * 2) + 3];
|
|
memcpy(new_key + 2, dump + HITAG_BLOCK_SIZE, HITAG_BLOCK_SIZE);
|
|
|
|
// Page 3 is written last, so the tag is still in its OLD mode at that point
|
|
// and wants the new credential expressed in that mode.
|
|
const uint8_t *new_cred = (credlen == HITAG_PASSWORD_SIZE) ? new_pwd : new_key;
|
|
|
|
// user pages, then key material, then the configuration
|
|
const uint8_t order[] = { 4, 5, 6, 7, 2, 1, 3 };
|
|
|
|
for (uint8_t i = 0; i < ARRAYLEN(order); i++) {
|
|
|
|
uint8_t page = order[i];
|
|
const uint8_t *pd = dump + (page * HITAG_BLOCK_SIZE);
|
|
|
|
// Pages 1 and 2 replace the credential, so page 3 needs the new one.
|
|
const uint8_t *use_cred = (page == 3) ? new_cred : cred;
|
|
|
|
int res = ht2_restore_write_page(page, pd, use_cred, credlen);
|
|
if (res != PM3_SUCCESS) {
|
|
PrintAndLogEx(FAILED, "Page %u ( " _RED_("fail") " ) - stopping here", page);
|
|
PrintAndLogEx(WARNING, "The tag is part written; pages before this one were changed");
|
|
free(dump);
|
|
return res;
|
|
}
|
|
PrintAndLogEx(SUCCESS, "Page %u %s ( " _GREEN_("ok") " )", page, sprint_hex_inrow(pd, HITAG_BLOCK_SIZE));
|
|
}
|
|
|
|
free(dump);
|
|
|
|
// report back which key/pwd was just set
|
|
PrintAndLogEx(NORMAL, "");
|
|
if ((new_cfg & 0x08) != 0) {
|
|
PrintAndLogEx(SUCCESS, "Tag is in " _GREEN_("Crypto") " mode");
|
|
PrintAndLogEx(SUCCESS, "New key... " _GREEN_("%s"), sprint_hex_inrow(new_key, HITAG_CRYPTOKEY_SIZE));
|
|
} else {
|
|
PrintAndLogEx(SUCCESS, "Tag is in " _GREEN_("Password") " mode");
|
|
PrintAndLogEx(SUCCESS, "New password... " _GREEN_("%s"), sprint_hex_inrow(new_pwd, HITAG_PASSWORD_SIZE));
|
|
}
|
|
|
|
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("lf hitag info") "` to verify");
|
|
PrintAndLogEx(NORMAL, "");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitag2Dump(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag dump",
|
|
"Read all Hitag 2 card memory and save to file\n"
|
|
"Crypto mode key format: ISK high + ISK low, 4F4E4D494B52 (ONMIKR)\n"
|
|
"Password mode, default key 4D494B52 (MIKR)\n",
|
|
"lf hitag dump --pwd -> use def pwd\n"
|
|
"lf hitag dump -k 4D494B52 -> pwd mode\n"
|
|
"lf hitag dump --crypto -> use def crypto\n"
|
|
"lf hitag dump -k 4F4E4D494B52 -> crypto mode\n"
|
|
"lf hitag dump --nrar 0102030411223344\n"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0(NULL, "pwd", "password mode"),
|
|
arg_str0(NULL, "nrar", "<hex>", "nonce / answer reader, 8 hex bytes"),
|
|
arg_lit0(NULL, "crypto", "crypto mode"),
|
|
arg_str0("k", "key", "<hex>", "key, 4 or 6 hex bytes"),
|
|
arg_str0("f", "file", "<fn>", "specify file name"),
|
|
arg_lit0(NULL, "ns", "no save to file"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
|
|
bool use_ht1 = false; // not yet implemented
|
|
bool use_hts = false; // not yet implemented
|
|
bool use_ht2 = true;
|
|
bool use_htm = false; // not yet implemented
|
|
|
|
bool use_plain = false;
|
|
bool use_pwd = arg_get_lit(ctx, 1);
|
|
uint8_t nrar[8];
|
|
int nalen = 0;
|
|
int res = CLIParamHexToBuf(arg_get_str(ctx, 2), nrar, sizeof(nrar), &nalen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
bool use_nrar = nalen > 0;
|
|
bool use_crypto = arg_get_lit(ctx, 3);
|
|
|
|
uint8_t key[HITAG_NRAR_SIZE];
|
|
int keylen = 0;
|
|
res = CLIParamHexToBuf(arg_get_str(ctx, 4), key, sizeof(key), &keylen);
|
|
if (res != 0) {
|
|
CLIParserFree(ctx);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE] = {0};
|
|
CLIParamStrToBuf(arg_get_str(ctx, 5), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
|
|
bool nosave = arg_get_lit(ctx, 6);
|
|
CLIParserFree(ctx);
|
|
|
|
// sanity checks
|
|
if ((use_ht1 + use_ht2 + use_hts + use_htm) > 1) {
|
|
PrintAndLogEx(ERR, "error, specify only one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
if ((use_ht1 + use_ht2 + use_hts + use_htm) == 0) {
|
|
PrintAndLogEx(ERR, "error, specify one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (keylen != 0 &&
|
|
keylen != HITAG_PASSWORD_SIZE &&
|
|
keylen != HITAG_CRYPTOKEY_SIZE &&
|
|
keylen != HITAG_NRAR_SIZE) {
|
|
PrintAndLogEx(WARNING, "Wrong KEY len expected (0,4,6,8) got %d", keylen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// complete options
|
|
if (keylen == HITAG_PASSWORD_SIZE) {
|
|
use_pwd = true;
|
|
}
|
|
if (keylen == HITAG_CRYPTOKEY_SIZE) {
|
|
use_crypto = true;
|
|
}
|
|
if (keylen == HITAG_NRAR_SIZE) {
|
|
use_nrar = true;
|
|
memcpy(nrar, key, sizeof(nrar));
|
|
}
|
|
|
|
// Set default key / pwd
|
|
if ((keylen == 0) && use_pwd) {
|
|
memcpy(key, "MIKR", HITAG_PASSWORD_SIZE);
|
|
keylen = HITAG_PASSWORD_SIZE;
|
|
}
|
|
if ((keylen == 0) && use_crypto) {
|
|
memcpy(key, "ONMIKR", HITAG_CRYPTOKEY_SIZE);
|
|
keylen = HITAG_CRYPTOKEY_SIZE;
|
|
}
|
|
|
|
// check coherence
|
|
uint8_t foo = (use_plain + use_pwd + use_nrar + use_crypto);
|
|
if (foo > 1) {
|
|
PrintAndLogEx(WARNING, "Specify only one authentication mode");
|
|
return PM3_EINVARG;
|
|
} else if (foo == 0) {
|
|
if (use_hts) {
|
|
use_plain = true;
|
|
} else {
|
|
PrintAndLogEx(WARNING, "Specify one authentication mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
}
|
|
|
|
if (use_hts && use_pwd) { // not sure for the other types...
|
|
PrintAndLogEx(WARNING, "Chosen Hitag type does not have Password mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (use_ht2 && use_plain) { // not sure for the other types...
|
|
PrintAndLogEx(WARNING, "Chosen Hitag type does not have Plain mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
uint32_t uid = 0;
|
|
|
|
PacketResponseNG resp;
|
|
uint8_t *data = NULL;
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
|
|
if (use_ht2 && use_pwd) {
|
|
packet.cmd = HT2F_PASSWORD;
|
|
memcpy(packet.pwd, key, sizeof(packet.pwd));
|
|
PrintAndLogEx(INFO, "Authenticating to " _YELLOW_("Hitag 2") " in Password mode");
|
|
|
|
} else if (use_ht2 && use_crypto) {
|
|
packet.cmd = HT2F_CRYPTO;
|
|
memcpy(packet.key, key, sizeof(packet.key));
|
|
PrintAndLogEx(INFO, "Authenticating to " _YELLOW_("Hitag 2") " in Crypto mode");
|
|
|
|
} else if (use_ht2 && use_nrar) {
|
|
|
|
|
|
memcpy(packet.NrAr, nrar, sizeof(packet.NrAr));
|
|
|
|
PrintAndLogEx(INFO, _YELLOW_("Hitag 2") " - Challenge mode (NrAr)");
|
|
|
|
uint64_t t1 = msclock();
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG2_CRACK, (uint8_t *) &packet, sizeof(packet));
|
|
|
|
// loop
|
|
uint8_t attempt = 30;
|
|
do {
|
|
|
|
PrintAndLogEx(INPLACE, "Attack 1 running...");
|
|
fflush(stdout);
|
|
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG2_CRACK, &resp, 1000) == false) {
|
|
attempt--;
|
|
continue;
|
|
}
|
|
|
|
lf_hitag_crack_response_t *payload = (lf_hitag_crack_response_t *)resp.data.asBytes;
|
|
|
|
if (resp.status == PM3_SUCCESS) {
|
|
PrintAndLogEx(NORMAL, " ( %s )", _GREEN_("ok"));
|
|
data = payload->data;
|
|
|
|
t1 = msclock() - t1;
|
|
PrintAndLogEx(SUCCESS, "\ntime " _YELLOW_("%.0f") " seconds\n", (float)t1 / 1000.0);
|
|
goto out;
|
|
}
|
|
|
|
// error codes
|
|
switch (payload->status) {
|
|
case -1: {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(FAILED, "Couldn't select tag!");
|
|
return PM3_ESOFT;
|
|
}
|
|
case -2: {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(FAILED, "Cannot find a valid encrypted command!");
|
|
return PM3_ESOFT;
|
|
}
|
|
case -3: {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(FAILED, "Cannot find encrypted 'read page0' command!");
|
|
return PM3_ESOFT;
|
|
}
|
|
case -4: {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(FAILED, "Partial data extraction!");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
} while (attempt);
|
|
|
|
if (attempt == 0) {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
t1 = msclock() - t1;
|
|
PrintAndLogEx(SUCCESS, "\ntime " _YELLOW_("%.0f") " seconds\n", (float)t1 / 1000.0);
|
|
|
|
goto out;
|
|
|
|
} else {
|
|
PrintAndLogEx(WARNING, "Sorry, not yet implemented");
|
|
return PM3_ENOTIMPL;
|
|
}
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_READER, (uint8_t *) &packet, sizeof(packet));
|
|
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_READER, &resp, 5000) == false) {
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
if (resp.status != PM3_SUCCESS) {
|
|
PrintAndLogEx(DEBUG, "DEBUG: Error - hitag failed");
|
|
return resp.status;
|
|
}
|
|
|
|
data = resp.data.asBytes;
|
|
|
|
out:
|
|
|
|
|
|
// block3, 1 byte
|
|
uid = bytes_to_num(data, HITAG_UID_SIZE);
|
|
|
|
if (use_ht2) {
|
|
print_hitag2_configuration(uid, data[HITAG_BLOCK_SIZE * 3]);
|
|
print_hitag2_blocks(data, HITAG2_MAX_BYTE_SIZE);
|
|
print_hitag2_paxton(true, data);
|
|
} else {
|
|
PrintAndLogEx(INFO, "No memory printing available");
|
|
}
|
|
|
|
if (nosave) {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(INFO, "Called with no save option");
|
|
PrintAndLogEx(NORMAL, "");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
if (fnlen < 1) {
|
|
char *fptr = filename;
|
|
fptr += snprintf(filename, sizeof(filename), "lf-hitag-");
|
|
FillFileNameByUID(fptr, data, "-dump", HITAG_UID_SIZE);
|
|
}
|
|
|
|
pm3_save_dump(filename, data, HITAG2_MAX_BYTE_SIZE, jsfHitag2);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagView(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag view",
|
|
"Print a HITAG dump file (bin/eml/json)",
|
|
"lf hitag view -f lf-hitag-01020304-dump.bin"
|
|
);
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str1("f", "file", "<fn>", "Specify a filename for dump file"),
|
|
arg_lit0("v", "verbose", "Verbose output"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE];
|
|
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
bool verbose = arg_get_lit(ctx, 2);
|
|
CLIParserFree(ctx);
|
|
|
|
// read dump file
|
|
uint8_t *dump = NULL;
|
|
size_t bytes_read = 0;
|
|
int res = pm3_load_dump(filename, (void **)&dump, &bytes_read, HITAG2_MAX_BYTE_SIZE);
|
|
if (res != PM3_SUCCESS) {
|
|
return res;
|
|
}
|
|
|
|
if (bytes_read < HITAG2_MAX_BYTE_SIZE) {
|
|
PrintAndLogEx(ERR, "Error, dump file is too small");
|
|
free(dump);
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
if (verbose) {
|
|
// block3, 1 byte
|
|
uint8_t config = dump[HITAG2_CONFIG_OFFSET];
|
|
uint32_t uid = bytes_to_num(dump, HITAG_UID_SIZE);
|
|
print_hitag2_configuration(uid, config);
|
|
print_hitag2_paxton(true, dump);
|
|
}
|
|
print_hitag2_blocks(dump, HITAG2_MAX_BYTE_SIZE);
|
|
free(dump);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagEload(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag eload",
|
|
"Loads hitag tag dump into emulator memory on device",
|
|
"lf hitag eload -2 -f lf-hitag-11223344-dump.bin\n"
|
|
);
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str1("f", "file", "<fn>", "Specify dump filename"),
|
|
arg_lit0("1", "ht1", "Card type Hitag 1"),
|
|
arg_lit0("2", "ht2", "Card type Hitag 2"),
|
|
arg_lit0("s", "hts", "Card type Hitag S"),
|
|
arg_lit0("m", "htm", "Card type Hitag \xce\xbc"), // μ
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE] = {0};
|
|
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
|
|
bool use_ht1 = arg_get_lit(ctx, 2);
|
|
bool use_ht2 = arg_get_lit(ctx, 3);
|
|
bool use_hts = arg_get_lit(ctx, 4);
|
|
bool use_htm = arg_get_lit(ctx, 5);
|
|
CLIParserFree(ctx);
|
|
|
|
if ((use_ht1 + use_ht2 + use_hts + use_htm) > 1) {
|
|
PrintAndLogEx(ERR, "error, specify only one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
if ((use_ht1 + use_ht2 + use_hts + use_htm) == 0) {
|
|
PrintAndLogEx(ERR, "error, specify one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// A Hitag u image is the 6 byte UID followed by its pages, and is the largest
|
|
// of the four. Everything still fits one NG frame.
|
|
#define HITAGU_EIMAGE_SIZE (HITAGU_UID_SIZE + (HITAGU_MAX_PAGE_ADVANCED_PLUS * HITAGU_BLOCK_SIZE))
|
|
|
|
// read dump file
|
|
uint8_t *dump = NULL;
|
|
size_t bytes_read = HITAGU_EIMAGE_SIZE;
|
|
int res = pm3_load_dump(filename, (void **)&dump, &bytes_read, HITAGU_EIMAGE_SIZE);
|
|
if (res != PM3_SUCCESS) {
|
|
return res;
|
|
}
|
|
|
|
// Validate against the card type the user selected rather than a fixed pair of
|
|
// sizes. The old check accepted only 32 or 256 bytes, so a Hitag 1 dump (64)
|
|
// and every Hitag u dump were rejected even though -1 and -m were accepted.
|
|
size_t expected = HITAG2_MAX_BYTE_SIZE;
|
|
const char *tname = "Hitag 2";
|
|
if (use_ht1) {
|
|
expected = HITAG1_MAX_BYTE_SIZE;
|
|
tname = "Hitag 1";
|
|
} else if (use_hts) {
|
|
expected = HITAGS_MAX_BYTE_SIZE;
|
|
tname = "Hitag S";
|
|
} else if (use_htm) {
|
|
// a u dump is sized by the tag's ICR, so accept anything that fits
|
|
expected = 0;
|
|
tname = "Hitag \xce\xbc";
|
|
}
|
|
|
|
if (use_htm) {
|
|
if ((bytes_read < HITAGU_UID_SIZE) || (bytes_read > HITAGU_EIMAGE_SIZE)) {
|
|
PrintAndLogEx(ERR, "error, wrong dump file size for %s. got %zu, expected %u..%u",
|
|
tname, bytes_read, (unsigned)HITAGU_UID_SIZE, (unsigned)HITAGU_EIMAGE_SIZE);
|
|
free(dump);
|
|
return PM3_EINVARG;
|
|
}
|
|
} else if (bytes_read != expected) {
|
|
PrintAndLogEx(ERR, "error, wrong dump file size for %s. got %zu, expected %zu",
|
|
tname, bytes_read, expected);
|
|
free(dump);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
{
|
|
|
|
lf_hitag_t *payload = calloc(1, sizeof(lf_hitag_t) + bytes_read);
|
|
if (payload == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
free(dump);
|
|
return PM3_EMALLOC;
|
|
}
|
|
|
|
if (use_ht1)
|
|
payload->type = 1;
|
|
|
|
if (use_ht2)
|
|
payload->type = 2;
|
|
|
|
if (use_hts)
|
|
payload->type = 3;
|
|
|
|
if (use_htm)
|
|
payload->type = 4;
|
|
|
|
payload->len = bytes_read;
|
|
memcpy(payload->data, dump, bytes_read);
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_ELOAD, (uint8_t *)payload, 3 + bytes_read);
|
|
free(payload);
|
|
}
|
|
|
|
free(dump);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagEview(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag eview",
|
|
"It displays emulator memory",
|
|
"lf hitag eview -2\n"
|
|
"lf hitag eview -s\n"
|
|
);
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("v", "verbose", "Verbose output"),
|
|
arg_lit0("1", "ht1", "Card type Hitag 1"),
|
|
arg_lit0("2", "ht2", "Card type Hitag 2 (default)"),
|
|
arg_lit0("s", "hts", "Card type Hitag S"),
|
|
arg_lit0("m", "htm", "Card type Hitag \xce\xbc"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
bool verbose = arg_get_lit(ctx, 1);
|
|
bool use_ht1 = arg_get_lit(ctx, 2);
|
|
bool use_ht2 = arg_get_lit(ctx, 3);
|
|
bool use_hts = arg_get_lit(ctx, 4);
|
|
bool use_htm = arg_get_lit(ctx, 5);
|
|
CLIParserFree(ctx);
|
|
|
|
if ((use_ht1 + use_ht2 + use_hts + use_htm) > 1) {
|
|
PrintAndLogEx(ERR, "error, specify only one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// Hitag 2 stays the default so `lf hitag eview` keeps working as before
|
|
int bytes = HITAG2_MAX_BYTE_SIZE;
|
|
if (use_ht1) {
|
|
bytes = HITAG1_MAX_BYTE_SIZE;
|
|
} else if (use_hts) {
|
|
bytes = HITAGS_MAX_BYTE_SIZE;
|
|
} else if (use_htm) {
|
|
// a Hitag u image is the 6 byte UID followed by its pages
|
|
bytes = HITAGU_UID_SIZE + (HITAGU_MAX_PAGE_ADVANCED_PLUS * HITAGU_BLOCK_SIZE);
|
|
}
|
|
|
|
// reserve memory
|
|
uint8_t *dump = calloc(bytes, sizeof(uint8_t));
|
|
if (dump == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
return PM3_EMALLOC;
|
|
}
|
|
|
|
PrintAndLogEx(INFO, "Downloading " _YELLOW_("%u") " bytes from emulator memory...", bytes);
|
|
if (GetFromDevice(BIG_BUF_EML, dump, bytes, 0, NULL, 0, NULL, 2500, false) == false) {
|
|
PrintAndLogEx(WARNING, "Fail, transfer from device time-out");
|
|
free(dump);
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
|
|
// the configuration and Paxton decoding are Hitag 2 specific
|
|
if (verbose && ((use_ht1 + use_hts + use_htm) == 0)) {
|
|
// block3, 1 byte
|
|
uint8_t config = dump[HITAG2_CONFIG_OFFSET];
|
|
uint32_t uid = bytes_to_num(dump, HITAG_UID_SIZE);
|
|
print_hitag2_configuration(uid, config);
|
|
print_hitag2_paxton(true, dump);
|
|
}
|
|
print_hitag2_blocks(dump, bytes);
|
|
free(dump);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagSim(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag sim",
|
|
"Simulate Hitag transponder\n"
|
|
"You need to `lf hitag eload` first",
|
|
"lf hitag sim -2\n"
|
|
"lf hitag sim -2 -t 20 -> set edge detect threshold to 20"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("1", "ht1", "simulate Hitag 1"),
|
|
arg_lit0("2", "ht2", "simulate Hitag 2"),
|
|
arg_int0("t", "threshold", "<dec>", "edge detect threshold, 0 = auto (def: 0)"),
|
|
arg_int0(NULL, "twait", "<dec>", "tag response delay in T0, 0 = default 227"),
|
|
arg_lit0(NULL, "invert", "invert load modulation polarity"),
|
|
arg_lit0(NULL, "noalt", "answer every START_AUTH, not every second"),
|
|
arg_lit0(NULL, "hold", "diagnostic: hold coil load on"),
|
|
arg_int0(NULL, "diag", "<dec>", "diagnostic flag bits, ORed into flags (32 = slope, now default)"),
|
|
arg_int0(NULL, "sof", "<dec>", "SOF bits in the tag answer (def: 6)"),
|
|
arg_int0(NULL, "duty", "<dec>", "carrier periods loaded per half bit, 1..16 (def: 16)"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
|
|
bool use_ht1 = arg_get_lit(ctx, 1);
|
|
bool use_ht2 = arg_get_lit(ctx, 2);
|
|
bool use_htm = false; // not implemented yet
|
|
int threshold = arg_get_int_def(ctx, 3, 0);
|
|
int twait = arg_get_int_def(ctx, 4, 0);
|
|
bool invert = arg_get_lit(ctx, 5);
|
|
bool noalt = arg_get_lit(ctx, 6);
|
|
bool hold = arg_get_lit(ctx, 7);
|
|
int diag = arg_get_int_def(ctx, 8, 0);
|
|
int sof = arg_get_int_def(ctx, 9, 0);
|
|
int duty = arg_get_int_def(ctx, 10, 0);
|
|
CLIParserFree(ctx);
|
|
|
|
if (duty < 0 || duty > 16) {
|
|
PrintAndLogEx(ERR, "error, duty must be 0..16");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (sof < 0 || sof > 200) {
|
|
PrintAndLogEx(ERR, "error, sof must be 0..200");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (twait < 0 || twait > 4000) {
|
|
PrintAndLogEx(ERR, "error, twait must be 0..4000");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (threshold < 0 || threshold > 255) {
|
|
PrintAndLogEx(ERR, "error, threshold must be 0..255");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if ((use_ht1 + use_ht2 + use_htm) > 1) {
|
|
PrintAndLogEx(ERR, "error, specify only one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
if ((use_ht1 + use_ht2 + use_htm) == 0) {
|
|
PrintAndLogEx(ERR, "error, specify one Hitag type");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
uint16_t cmd = CMD_LF_HITAG_SIMULATE;
|
|
// if (use_ht1)
|
|
// cmd = CMD_LF_HITAG1_SIMULATE;
|
|
|
|
// the tag content comes from emulator memory, this only carries the threshold
|
|
hitag_sim_t payload = {
|
|
.tag_mem_supplied = false,
|
|
// --diag is documented as "ORed into flags", so OR all of it. Masking it
|
|
// with 0xF8 silently dropped bits 0..2, which made --diag 1, 2 and 4 do
|
|
// nothing at all while still looking like they had been applied - two
|
|
// no-alternation measurements were taken that way before it was noticed.
|
|
// The named options set the same bits, so they simply agree.
|
|
.flags = (uint8_t)((invert ? 1 : 0) | (noalt ? 2 : 0) | (hold ? 4 : 0) | (diag & 0xFF)),
|
|
.threshold = (uint16_t)threshold,
|
|
.twait = (uint16_t)twait,
|
|
.sof = (uint8_t)sof,
|
|
.duty = (uint8_t)duty,
|
|
};
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(cmd, (uint8_t *)&payload, sizeof(payload));
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitagSniff(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag sniff",
|
|
"Sniff the communication between reader and tag\n"
|
|
"Use `lf hitag list` to view collected data.",
|
|
" lf hitag sniff\n"
|
|
" lf hitag sniff -t 20 -> lower edge detect threshold"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_int0("t", "threshold", "<dec>", "edge detect threshold, 0 = default 32"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
int threshold = arg_get_int_def(ctx, 1, 0);
|
|
CLIParserFree(ctx);
|
|
|
|
if (threshold < 0 || threshold > 255) {
|
|
PrintAndLogEx(ERR, "error, threshold must be 0..255");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
PrintAndLogEx(INFO, "Press " _GREEN_("pm3 button") " or " _GREEN_("<Enter>") " to abort sniffing");
|
|
|
|
PacketResponseNG resp;
|
|
clearCommandBuffer();
|
|
uint8_t payload = (uint8_t)threshold;
|
|
SendCommandNG(CMD_LF_HITAG_SNIFF, &payload, sizeof(payload));
|
|
|
|
// Wait the way the other long running LF commands do, rather than blocking
|
|
// in WaitForResponse(). Blocking there means the client never reads another
|
|
// command, so the device's own data_available() abort can never be reached -
|
|
// `hw break` sits unread in the input and the session looks hung even though
|
|
// the firmware is willing to stop.
|
|
for (;;) {
|
|
if (kbd_enter_pressed()) {
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
PrintAndLogEx(DEBUG, "\naborted via keyboard!");
|
|
break;
|
|
}
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_SNIFF, &resp, 1000)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
PrintAndLogEx(INFO, "Done!");
|
|
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("lf hitag list")"` to view captured tracelog");
|
|
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("trace save -h") "` to save tracelog for later analysing");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
static int CmdLFHitag2PWMDemod(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag pwmdemod",
|
|
"Demodulate the data in the GraphBuffer and output binary\n",
|
|
"lf hitag pwmdemod"
|
|
"lf hitag pwmdemod -t 65 --> specify first wave index\n"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_int0("t", "start", "<dec>", "first wave index"),
|
|
arg_int0(NULL, "zero", "<dec>", "Zero pulse length"),
|
|
arg_int0(NULL, "one", "<dec>", "One pulse length"),
|
|
arg_param_end
|
|
};
|
|
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
uint32_t start_idx = (uint32_t)arg_get_int_def(ctx, 1, 0);
|
|
uint8_t fclow = (uint8_t)arg_get_int_def(ctx, 2, 20);
|
|
uint8_t fchigh = (uint8_t)arg_get_int_def(ctx, 3, 29);
|
|
CLIParserFree(ctx);
|
|
|
|
uint8_t *bits = calloc(MAX_GRAPH_TRACE_LEN, sizeof(uint8_t));
|
|
if (bits == NULL) {
|
|
PrintAndLogEx(WARNING, "Failed to allocate memory");
|
|
return PM3_EMALLOC;
|
|
}
|
|
|
|
size_t size = getFromGraphBuffer(bits);
|
|
|
|
PrintAndLogEx(DEBUG, "DEBUG: (Hitag2PWM) #samples from graphbuff... %zu", size);
|
|
|
|
if (size < 255) {
|
|
PrintAndLogEx(INFO, "too few samples in buffer");
|
|
free(bits);
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
// TODO autodetect
|
|
size = HitagPWMDemod(bits, size, &fchigh, &fclow, &start_idx, g_DemodBitRangeBuffer);
|
|
if (size == 0) {
|
|
PrintAndLogEx(FAILED, "No wave detected");
|
|
free(bits);
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
PrintAndLogEx(DEBUG, "DEBUG: start_idx... %u size... %zu", start_idx, size);
|
|
|
|
setDemodBuffBitRange(bits, size, 0, g_DemodBitRangeBuffer);
|
|
setClockGrid(32, start_idx);
|
|
|
|
uint32_t total = 0;
|
|
for (size_t i = 0; i < size; i++) {
|
|
total += g_DemodBitRangeBuffer[i];
|
|
PrintAndLogEx(DEBUG, "%d", g_DemodBitRangeBuffer[i]);
|
|
}
|
|
PrintAndLogEx(DEBUG, "Total... %d", total);
|
|
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(INFO, "--- " _CYAN_("HITAG/PWM") " ---------------------------");
|
|
printDemodBuff(0, false, false, false);
|
|
printDemodBuff(0, false, false, true);
|
|
free(bits);
|
|
return PM3_SUCCESS;
|
|
}
|
|
*/
|
|
|
|
static int CmdLFHitag2Chk(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag chk",
|
|
"Run dictionary key or password recovery against Hitag card.",
|
|
"lf hitag chk -> checks for both pwd / crypto keys\n"
|
|
"lf hitag chk --crypto -> use def dictionary\n"
|
|
"lf hitag chk --pwd -f my.dic -> pwd mode, custom dictionary"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str0("f", "file", "<fn>", "specify dictionary filename"),
|
|
arg_lit0(NULL, "pwd", "password mode"),
|
|
arg_lit0(NULL, "crypto", "crypto mode"),
|
|
arg_param_end
|
|
};
|
|
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE] = {0};
|
|
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
|
|
bool use_pwd = arg_get_lit(ctx, 2);
|
|
bool use_crypto = arg_get_lit(ctx, 3);
|
|
CLIParserFree(ctx);
|
|
|
|
if (use_pwd + use_crypto > 1) {
|
|
PrintAndLogEx(WARNING, "Only specify one mode");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// no filename -> use default = ht2_default.dic
|
|
if (fnlen == 0) {
|
|
snprintf(filename, sizeof(filename), HITAG_DICTIONARY);
|
|
}
|
|
|
|
uint8_t keylen = 4;
|
|
if (use_crypto) {
|
|
keylen = 6;
|
|
}
|
|
|
|
uint64_t t1 = msclock();
|
|
|
|
// just loop twice at max. Starting with 4 or 6.
|
|
for (; keylen < 7; keylen += 2) {
|
|
// load keys
|
|
uint8_t *keys = NULL;
|
|
uint32_t key_count = 0;
|
|
int res = loadFileDICTIONARY_safe(filename, (void **)&keys, keylen, &key_count);
|
|
if (res != PM3_SUCCESS || key_count == 0 || keys == NULL) {
|
|
PrintAndLogEx(WARNING, "no keys found in file");
|
|
if (keys != NULL) {
|
|
free(keys);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// Main loop
|
|
uint32_t found_idx = 0;
|
|
int status = ht2_check_dictionary(key_count, keys, keylen, &found_idx);
|
|
|
|
if (status == PM3_SUCCESS) {
|
|
|
|
PrintAndLogEx(NORMAL, "");
|
|
if (keylen == 6) {
|
|
PrintAndLogEx(SUCCESS, "found valid key [ " _GREEN_("%s") " ]", sprint_hex_inrow(keys + (found_idx * keylen), keylen));
|
|
} else {
|
|
PrintAndLogEx(SUCCESS, "found valid password [ " _GREEN_("%s") " ]", sprint_hex_inrow(keys + (found_idx * keylen), keylen));
|
|
}
|
|
free(keys);
|
|
break;
|
|
}
|
|
free(keys);
|
|
|
|
PrintAndLogEx(NORMAL, "");
|
|
|
|
if (use_pwd) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
t1 = msclock() - t1;
|
|
PrintAndLogEx(SUCCESS, "\ntime in check " _YELLOW_("%.0f") " seconds\n", (float)t1 / 1000.0);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitag2Lookup(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag lookup",
|
|
"This command take sniffed trace data and try to recovery a Hitag 2 crypto key.\n"
|
|
" You can either\n"
|
|
" - verify that NR/AR matches a known crypto key\n"
|
|
" - verify if NR/AR matches a known 6 byte crypto key in a dictionary",
|
|
"lf hitag lookup --uid 11223344 --nr 73AA5A62 --ar EAB8529C -k 010203040506 -> check key\n"
|
|
"lf hitag lookup --uid 11223344 --nr 73AA5A62 --ar EAB8529C -> use def dictionary\n"
|
|
"lf hitag lookup --uid 11223344 --nr 73AA5A62 --ar EAB8529C -f my.dic -> use custom dictionary\n"
|
|
"lf hitag lookup --uid 11223344 --nrar 73AA5A62EAB8529C"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str0("f", "file", "<fn>", "specify dictionary filename"),
|
|
arg_str0("k", "key", "<hex>", "specify known cryptokey as 6 bytes"),
|
|
arg_str1("u", "uid", "<hex>", "specify UID as 4 hex bytes"),
|
|
arg_str0(NULL, "nr", "<hex>", "specify nonce as 4 hex bytes"),
|
|
arg_str0(NULL, "ar", "<hex>", "specify answer as 4 hex bytes"),
|
|
arg_str0(NULL, "nrar", "<hex>", "specify nonce / answer as 8 hex bytes"),
|
|
arg_param_end
|
|
};
|
|
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
int fnlen = 0;
|
|
char filename[FILE_PATH_SIZE] = {0};
|
|
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
|
|
|
|
int inkeylen = 0;
|
|
uint8_t inkey[6] = {0};
|
|
CLIGetHexWithReturn(ctx, 2, inkey, &inkeylen);
|
|
|
|
int ulen = 0;
|
|
uint8_t uidarr[4] = {0};
|
|
CLIGetHexWithReturn(ctx, 3, uidarr, &ulen);
|
|
|
|
int nlen = 0;
|
|
uint8_t narr[4] = {0};
|
|
CLIGetHexWithReturn(ctx, 4, narr, &nlen);
|
|
|
|
int alen = 0;
|
|
uint8_t aarr[4] = {0};
|
|
CLIGetHexWithReturn(ctx, 5, aarr, &alen);
|
|
|
|
int nalen = 0;
|
|
uint8_t nrar[8] = {0};
|
|
CLIGetHexWithReturn(ctx, 6, nrar, &nalen);
|
|
|
|
CLIParserFree(ctx);
|
|
|
|
// sanity checks
|
|
if (inkeylen && inkeylen != 6) {
|
|
PrintAndLogEx(INFO, "Key wrong length. expected 6, got %i", inkeylen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (ulen && ulen != 4) {
|
|
PrintAndLogEx(INFO, "UID wrong length. expected 4, got %i", ulen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (nlen && nlen != 4) {
|
|
PrintAndLogEx(INFO, "Nr wrong length. expected 4, got %i", nlen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (alen && alen != 4) {
|
|
PrintAndLogEx(INFO, "Ar wrong length. expected 4, got %i", alen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
if (nalen && nalen != 8) {
|
|
PrintAndLogEx(INFO, "NrAr wrong length. expected 8, got %i", nalen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
// Iceman note:
|
|
// - key, uid and Nr1 is alway dentoed as LSB/LE order
|
|
// - Ar1 is NOT. It is in BE/MSB everywhere.
|
|
// - At1 is NOT. It is in BE/MSB everywhere.
|
|
// - crypto stream generated is in BE/MSB order in Pm3 code.
|
|
// - crypto state is in ?
|
|
// - lfsr state is in ?
|
|
//
|
|
// Different implementations handles internally the state either in MSB or LSB.
|
|
// Something to keep an eye for when looking at code.
|
|
//
|
|
// Termology:
|
|
// cs / hstate.shiftregister / crypto state = same
|
|
// lsfr = some implementations mixes cs and lsfr into one and only use the state. Some differentiate between them.
|
|
// usually the key recovery functions under /tools/hitag2crack
|
|
// IV / Nonce Reader 1 / Nr1 = same (clear text), always 00 00 00 00 in PM3 code when acting as reader.
|
|
// Answer Reader 1 / Ar1 = encrypted and BE/MSB, +32, the clear text is always FF FF FF FF.
|
|
// Answer Tag 1 / At1 = encrypted and BE/MSB, +32,
|
|
|
|
/*
|
|
When initializer the crypto engine
|
|
|
|
1. UID: 11223344
|
|
2. KEY: FFFF143624FF
|
|
3. NONCE / IV: 00 00 00 00
|
|
3. NONCE / IV: 3B 6F 08 4D
|
|
|
|
now you have a CS / Shiftregister / state = crypto stream?
|
|
|
|
Ar1 - first encrypted crypto stream ^ 0xFFFFFFFF
|
|
4. Ar1: 96 7A 6F 2A ^ FF FF FF FF == 69 85 90 D5
|
|
|
|
*/
|
|
rev_msb_array(inkey, sizeof(inkey));
|
|
rev_msb_array(uidarr, sizeof(uidarr));
|
|
rev_msb_array(narr, sizeof(narr));
|
|
rev_msb_array(nrar, 4);
|
|
|
|
|
|
// Little Endian
|
|
uint64_t knownkey = MemLeToUint6byte(inkey);
|
|
uint32_t uid = MemLeToUint4byte(uidarr);
|
|
|
|
uint32_t nr;
|
|
// Big Endian
|
|
uint32_t ar;
|
|
|
|
if (nlen && alen) {
|
|
nr = MemLeToUint4byte(narr);
|
|
ar = MemBeToUint4byte(aarr);
|
|
} else if (nalen) {
|
|
nr = MemLeToUint4byte(nrar);
|
|
ar = MemBeToUint4byte(nrar + 4);
|
|
} else {
|
|
PrintAndLogEx(INFO, "No nr or ar was supplied");
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
uint32_t iv = nr;
|
|
|
|
|
|
if (inkeylen) {
|
|
|
|
PrintAndLogEx(DEBUG, "UID... %08" PRIx32, uid);
|
|
PrintAndLogEx(DEBUG, "IV.... %08" PRIx32, iv);
|
|
PrintAndLogEx(DEBUG, "Key... %012" PRIx64, knownkey);
|
|
|
|
// initialize state
|
|
hitag_state_t hstate;
|
|
ht2_hitag2_init_ex(&hstate, knownkey, uid, iv);
|
|
|
|
// get 32 bits of crypto stream.
|
|
uint32_t cbits = ht2_hitag2_nstep(&hstate, 32);
|
|
bool isok = (ar == (cbits ^ 0xFFFFFFFF));
|
|
|
|
PrintAndLogEx(DEBUG, "state.shiftreg...... %012" PRIx64, hstate.shiftreg);
|
|
PrintAndLogEx(DEBUG, "state.lfsr.......... %012" PRIx64, hstate.lfsr);
|
|
PrintAndLogEx(DEBUG, "c bits.............. %08x", cbits);
|
|
PrintAndLogEx(DEBUG, "c-bits ^ FFFFFFFF... %08x", cbits ^ 0xFFFFFFFF);
|
|
PrintAndLogEx(DEBUG, "Ar.................. %08" PRIx32 " ( %s )", ar, (isok) ? _GREEN_("ok") : _RED_("fail"));
|
|
|
|
PrintAndLogEx(INFO, "Nr/Ar match key ( %s )", (isok) ? _GREEN_("ok") : _RED_("fail"));
|
|
PrintAndLogEx(NORMAL, "");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
if (fnlen == 0) {
|
|
snprintf(filename, sizeof(filename), HITAG_DICTIONARY);
|
|
}
|
|
|
|
// load keys
|
|
uint8_t *keys = NULL;
|
|
uint32_t key_count = 0;
|
|
int res = loadFileDICTIONARY_safe(filename, (void **)&keys, HITAG_CRYPTOKEY_SIZE, &key_count);
|
|
if (res != PM3_SUCCESS || key_count == 0 || keys == NULL) {
|
|
PrintAndLogEx(WARNING, "no keys found in file");
|
|
if (keys != NULL) {
|
|
free(keys);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
bool found = false;
|
|
for (uint32_t i = 0; i < key_count; i++) {
|
|
|
|
uint8_t *pkey = keys + (i * HITAG_CRYPTOKEY_SIZE);
|
|
uint64_t mykey = MemLeToUint6byte(pkey);
|
|
mykey = REV64(mykey);
|
|
|
|
hitag_state_t hs2;
|
|
ht2_hitag2_init_ex(&hs2, mykey, uid, iv);
|
|
|
|
uint32_t tbits = ht2_hitag2_nstep(&hs2, 32);
|
|
if ((ar ^ tbits) == 0xFFFFFFFF) {
|
|
PrintAndLogEx(SUCCESS, "Found valid key [ " _GREEN_("%s")" ]", sprint_hex_inrow(pkey, HITAG_CRYPTOKEY_SIZE));
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
if (g_debugMode) {
|
|
PrintAndLogEx(DEBUG, " tbits... %08" PRIx32 " Known ar... %08" PRIx32, tbits, ar);
|
|
PrintAndLogEx(DEBUG, " 0xFFFFFFFF ^ tbits... %08" PRIx32, tbits ^ 0xFFFFFFFF);
|
|
PrintAndLogEx(DEBUG, " 0xFFFFFFFF ^ ar...... %08" PRIx32, ar ^ 0xFFFFFFFF);
|
|
PrintAndLogEx(DEBUG, " tbits ^ ar........... %08" PRIx32 " ( 0xFFFFFFFF )", ar ^ tbits);
|
|
}
|
|
}
|
|
|
|
free(keys);
|
|
|
|
if (found == false) {
|
|
PrintAndLogEx(WARNING, "check failed");
|
|
}
|
|
|
|
PrintAndLogEx(NORMAL, "");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdLFHitag2Crack2(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag crack2",
|
|
"This command tries to recover 2048 bits of Hitag 2 crypto stream data from card.\n"
|
|
"Put card on pm3 before running this command\n",
|
|
"lf hitag crack2 --nrar 73AA5A62EAB8529C"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_str0(NULL, "nrar", "<hex>", "specify nonce / answer as 8 hex bytes"),
|
|
arg_param_end
|
|
};
|
|
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
int nalen = 0;
|
|
uint8_t nrar[8] = {0};
|
|
CLIGetHexWithReturn(ctx, 1, nrar, &nalen);
|
|
CLIParserFree(ctx);
|
|
|
|
// sanity checks
|
|
if (nalen && nalen != 8) {
|
|
PrintAndLogEx(INFO, "NrAr wrong length. expected 8, got %i", nalen);
|
|
return PM3_EINVARG;
|
|
}
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
memcpy(packet.NrAr, nrar, sizeof(packet.NrAr));
|
|
|
|
PrintAndLogEx(INFO, _YELLOW_("Hitag 2") " - Nonce replay and length extension attack ( Crack2 )");
|
|
|
|
uint64_t t1 = msclock();
|
|
|
|
PacketResponseNG resp;
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG2_CRACK_2, (uint8_t *) &packet, sizeof(packet));
|
|
|
|
// loop
|
|
uint8_t attempt = 50;
|
|
do {
|
|
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG2_CRACK_2, &resp, 1000) == false) {
|
|
attempt--;
|
|
continue;
|
|
}
|
|
|
|
if (resp.status == PM3_SUCCESS) {
|
|
|
|
PrintAndLogEx(SUCCESS, "--------------------- " _CYAN_("Recovered Keystream") " ----------------------");
|
|
lf_hitag_crack_response_t *payload = (lf_hitag_crack_response_t *)resp.data.asBytes;
|
|
|
|
for (int i = 0; i < 256; i += 32) {
|
|
PrintAndLogEx(SUCCESS, "%s", sprint_hex_inrow(payload->data + i, 32));
|
|
}
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(SUCCESS, "Nonce replay and length extension attack ( %s )", _GREEN_("ok"));
|
|
PrintAndLogEx(HINT, "Hint: Try `" _YELLOW_("tools/hitag2crack/crack2/ht2crack2search <FILE_with_above_bytes>") "`");
|
|
break;
|
|
} else {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(FAILED, "Nonce replay and length extension attack ( %s )", _RED_("fail"));
|
|
break;
|
|
}
|
|
|
|
} while (attempt);
|
|
|
|
if (attempt == 0) {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(WARNING, "timeout while waiting for reply");
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
t1 = msclock() - t1;
|
|
PrintAndLogEx(SUCCESS, "\ntime " _YELLOW_("%.0f") " seconds\n", (float)t1 / 1000.0);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
/* Test code
|
|
|
|
Test data and below information about it comes from
|
|
http://www.mikrocontroller.net/attachment/102194/hitag2.c
|
|
Written by "I.C. Wiener 2006-2007"
|
|
|
|
"MIKRON" = O N M I K R
|
|
Key = 4F 4E 4D 49 4B 52 - Secret 48-bit key
|
|
Serial = 49 43 57 69 - Serial number of the tag, transmitted in clear
|
|
Random = 65 6E 45 72 - Random IV, transmitted in clear
|
|
~28~DC~80~31 = D7 23 7F CE - Authenticator value = inverted first 4 bytes of the keystream
|
|
|
|
The code below must print out "D7 23 7F CE 8C D0 37 A9 57 49 C1 E6 48 00 8A B6".
|
|
The inverse of the first 4 bytes is sent to the tag to authenticate.
|
|
The rest is encrypted by XORing it with the subsequent keystream.
|
|
*/
|
|
static uint64_t hitag2_benchtest_gen32(void) {
|
|
const uint64_t key = 0x4ad292b272f2;
|
|
const uint32_t serial = 0x96eac292;
|
|
const uint32_t initvec = 0x4ea276a6;
|
|
hitag_state_t state;
|
|
|
|
// init crypto
|
|
ht2_hitag2_init_ex(&state, key, serial, initvec);
|
|
|
|
// benchmark: generation of 32 bit stream (excludes initialisation)
|
|
uint64_t t1 = usclock();
|
|
|
|
(void) ht2_hitag2_nstep(&state, 32);
|
|
|
|
t1 = usclock() - t1;
|
|
return t1;
|
|
}
|
|
|
|
static uint64_t hitag2_benchtest(uint32_t count) {
|
|
|
|
const uint64_t key = 0x4ad292b272f2;
|
|
const uint32_t serial = 0x96eac292;
|
|
const uint32_t initvec = 0x4ea276a6;
|
|
|
|
hitag_state_t state;
|
|
|
|
// start timer
|
|
uint64_t t1 = usclock();
|
|
|
|
// benchmark: initialise crypto & generate 32 bit authentication
|
|
// adding i stops gcc optimizer moving init function call out of loop
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
ht2_hitag2_init_ex(&state, key, serial, initvec + i);
|
|
(void) ht2_hitag2_nstep(&state, 32);
|
|
}
|
|
|
|
t1 = usclock() - t1;
|
|
return t1;
|
|
}
|
|
|
|
static uint64_t hitag2_verify_crypto_test(void) {
|
|
|
|
uint8_t expected[16] = { 0xD7, 0x23, 0x7F, 0xCE, 0x8C, 0xD0, 0x37, 0xA9, 0x57, 0x49, 0xC1, 0xE6, 0x48, 0x00, 0x8A, 0xB6 };
|
|
// key = 0x4ad292b272f2 after each byte has its bit order reversed
|
|
// uid = 0x96eac292 ditto
|
|
// initvec = 0x4ea276a6 ditto
|
|
const uint64_t key = REV64(UINT64_C(0x524B494D4E4F));
|
|
const uint32_t uid = REV32(UINT32_C(0x69574349));
|
|
const uint32_t iv = REV32(UINT32_C(0x72456E65));
|
|
|
|
PrintAndLogEx(DEBUG, "UID... %08" PRIx32, uid);
|
|
PrintAndLogEx(DEBUG, "IV.... %08" PRIx32, iv);
|
|
PrintAndLogEx(DEBUG, "Key... %012" PRIx64, key);
|
|
|
|
// initialise
|
|
hitag_state_t state;
|
|
ht2_hitag2_init_ex(&state, key, uid, iv);
|
|
PrintAndLogEx(DEBUG, "hs shiftreg... %012" PRIx64, state.shiftreg);
|
|
|
|
for (uint32_t i = 0; i < 16; i++) {
|
|
// get 8 bits of keystream
|
|
uint8_t x = (uint8_t) ht2_hitag2_nstep(&state, 8);
|
|
uint8_t y = expected[i];
|
|
|
|
PrintAndLogEx(DEBUG, "%02X (%02X)", x, y);
|
|
if (x != y) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static uint64_t hitag2_verify_crypto_test_round(void) {
|
|
|
|
uint8_t expected[16] = { 0xD7, 0x23, 0x7F, 0xCE, 0x8C, 0xD0, 0x37, 0xA9, 0x57, 0x49, 0xC1, 0xE6, 0x48, 0x00, 0x8A, 0xB6 };
|
|
const uint64_t key = REV64(UINT64_C(0x524B494D4E4F));
|
|
const uint32_t uid = REV32(UINT32_C(0x69574349));
|
|
const uint32_t iv = REV32(UINT32_C(0x72456E65));
|
|
|
|
PrintAndLogEx(DEBUG, "UID... %08" PRIx32, uid);
|
|
PrintAndLogEx(DEBUG, "IV.... %08" PRIx32, iv);
|
|
PrintAndLogEx(DEBUG, "Key... %012" PRIx64, key);
|
|
|
|
// initialise
|
|
uint64_t cs = ht2_hitag2_init(key, uid, iv);
|
|
PrintAndLogEx(DEBUG, "hs shiftreg... %012" PRIx64, cs);
|
|
|
|
for (uint32_t i = 0; i < 16; i++) {
|
|
// get 8 bits of keystream
|
|
uint8_t x = (uint8_t) ht2_hitag2_byte(&cs);
|
|
uint8_t y = expected[i];
|
|
|
|
PrintAndLogEx(DEBUG, "%02X (%02X)", x, y);
|
|
if (x != y) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int CmdLFHitag2Selftest(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf hitag test",
|
|
"Perform self tests of Hitag crypto engine",
|
|
"lf hitag test\n"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
CLIParserFree(ctx);
|
|
|
|
PrintAndLogEx(INFO, "======== " _CYAN_("Hitag 2 crypto test") " ============================");
|
|
uint64_t test = hitag2_verify_crypto_test();
|
|
PrintAndLogEx(INFO, "Crypto self test ( %s )", test ? _GREEN_("ok") : _RED_("fail"));
|
|
|
|
test |= hitag2_verify_crypto_test_round();
|
|
PrintAndLogEx(INFO, "Crypto self test ROUND ( %s )", test ? _GREEN_("ok") : _RED_("fail"));
|
|
|
|
test |= hitag2_benchtest(1);
|
|
PrintAndLogEx(INFO, "Hitag 2 crypto, init + gen 32 bits ( us %" PRIu64 " )", test);
|
|
|
|
test |= hitag2_benchtest_gen32();
|
|
PrintAndLogEx(INFO, "Hitag 2 crypto, gen new 32 bits only ( us: %" PRIu64 " )", test);
|
|
|
|
test |= hitag2_benchtest(1000);
|
|
PrintAndLogEx(INFO, "Hitag 2 crypto, init + gen 32 bits, x1000 ( us: %" PRIu64 " )", test);
|
|
|
|
PrintAndLogEx(INFO, "--------------------------------------------------------");
|
|
PrintAndLogEx(SUCCESS, "Tests ( %s )", (test) ? _GREEN_("ok") : _RED_("fail"));
|
|
PrintAndLogEx(NORMAL, "");
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
int ht2_read_uid(void) {
|
|
uint32_t uid = 0;
|
|
if (ht2_get_uid(&uid, true) == false) {
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
PrintAndLogEx(SUCCESS, "UID....... " _GREEN_("%08X"), uid);
|
|
PrintAndLogEx(SUCCESS, "TYPE...... " _GREEN_("%s"), getHitagTypeStr(uid));
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
int ht2_read_paxton(void) {
|
|
|
|
// read block 4,5,6,7
|
|
|
|
lf_hitag_data_t packet;
|
|
memset(&packet, 0, sizeof(packet));
|
|
|
|
packet.cmd = HT2F_PASSWORD;
|
|
memcpy(packet.pwd, ht2_default_keys, sizeof(packet.pwd));
|
|
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_HITAG_READER, (uint8_t *)&packet, sizeof(packet));
|
|
|
|
PacketResponseNG resp;
|
|
if (WaitForResponseTimeout(CMD_LF_HITAG_READER, &resp, 2000) == false) {
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
return PM3_ETIMEOUT;
|
|
}
|
|
|
|
if (resp.status != PM3_SUCCESS) {
|
|
PrintAndLogEx(DEBUG, "DEBUG: Error - hitag failed");
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
uint8_t *data = resp.data.asBytes;
|
|
print_hitag2_paxton(false, data);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static command_t CommandTable[] = {
|
|
{"help", CmdHelp, AlwaysAvailable, "This help"},
|
|
{"list", CmdLFHitagList, AlwaysAvailable, "List Hitag trace history"},
|
|
{"hts", CmdLFHitagS, AlwaysAvailable, "{ Hitag S/8211 operations }"},
|
|
{"htu", CmdLFHitagU, AlwaysAvailable, "{ Hitag µ/8265 operations }"},
|
|
{"-----------", CmdHelp, IfPm3Hitag, "------------------------ " _CYAN_("General") " ------------------------"},
|
|
{"info", CmdLFHitagInfo, IfPm3Hitag, "Tag information"},
|
|
{"reader", CmdLFHitagReader, IfPm3Hitag, "Act like a Hitag 2 reader"},
|
|
{"test", CmdLFHitag2Selftest, AlwaysAvailable, "Perform self tests"},
|
|
{"-----------", CmdHelp, IfPm3Hitag, "----------------------- " _CYAN_("Operations") " -----------------------"},
|
|
// {"demod", CmdLFHitag2PWMDemod, IfPm3Hitag, "PWM Hitag 2 reader message demodulation"},
|
|
{"dump", CmdLFHitag2Dump, IfPm3Hitag, "Dump Hitag 2 tag"},
|
|
{"read", CmdLFHitagRd, IfPm3Hitag, "Read Hitag memory"},
|
|
{"sniff", CmdLFHitagSniff, IfPm3Hitag, "Eavesdrop Hitag communication"},
|
|
{"view", CmdLFHitagView, AlwaysAvailable, "Display content from tag dump file"},
|
|
{"wrbl", CmdLFHitagWriter, IfPm3Hitag, "Write a block (page) in Hitag memory"},
|
|
{"restore", CmdLFHitag2Restore, IfPm3Hitag, "Restore a dump file to a Hitag 2 tag"},
|
|
{"-----------", CmdHelp, IfPm3Hitag, "----------------------- " _CYAN_("Simulation") " -----------------------"},
|
|
{"eload", CmdLFHitagEload, IfPm3Hitag, "Upload file into emulator memory"},
|
|
// {"esave", CmdLFHitagESave, IfPm3Hitag, "Save emulator memory to file"},
|
|
{"eview", CmdLFHitagEview, IfPm3Hitag, "View emulator memory"},
|
|
{"sim", CmdLFHitagSim, IfPm3Hitag, "Simulate Hitag transponder"},
|
|
{"-----------", CmdHelp, IfPm3Hitag, "----------------------- " _CYAN_("Recovery") " -----------------------"},
|
|
{"cc", CmdLFHitagSCheckChallenges, IfPm3Hitag, "Hitag S: test all provided challenges"},
|
|
{"crack2", CmdLFHitag2Crack2, IfPm3Hitag, "Recover 2048bits of crypto stream"},
|
|
{"chk", CmdLFHitag2Chk, IfPm3Hitag, "Check keys"},
|
|
{"lookup", CmdLFHitag2Lookup, AlwaysAvailable, "Uses authentication trace to check for key in dictionary file"},
|
|
{"ta", CmdLFHitag2CheckChallenges, IfPm3Hitag, "Hitag 2: test all recorded authentications"},
|
|
{ NULL, NULL, 0, NULL }
|
|
};
|
|
|
|
static int CmdHelp(const char *Cmd) {
|
|
(void)Cmd; // Cmd is not used so far
|
|
CmdsHelp(CommandTable);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
int CmdLFHitag(const char *Cmd) {
|
|
clearCommandBuffer();
|
|
return CmdsParse(CommandTable, Cmd);
|
|
}
|
|
|
|
|