github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-20 21:33:47 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Merge remote-tracking branch 'upstream/master' into felica_support_sniffing

Browse source
This commit is contained in:
Thomas Sutter 2019-11-01 15:12:24 +01:00
commit b422b79679
7 changed files with 96 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

39
client/cmdhf14b.c
View file

@ -147,15 +147,15 @@ static bool waitCmd14b(bool verbose) {
if (len >= 3) { if (len >= 3) {
bool crc = check_crc(CRC_14443_B, data, len); bool crc = check_crc(CRC_14443_B, data, len);
PrintAndLogEx(NORMAL, "[LEN %u] %s[%02X %02X] %s", PrintAndLogEx(SUCCESS, "[LEN %u] %s[%02X %02X] %s",
len, len,
sprint_hex(data, len - 2), sprint_hex(data, len - 2),
data[len - 2], data[len - 2],
data[len - 1], data[len - 1],
(crc) ? "OK" : "FAIL" (crc) ? _GREEN_("OK") : _RED_("FAIL")
); );
} else { } else {
PrintAndLogEx(NORMAL, "[LEN %u] %s", len, sprint_hex(data, len)); PrintAndLogEx(SUCCESS, "[LEN %u] %s", len, sprint_hex(data, len));
} }
} }
return true; return true;
@ -182,7 +182,7 @@ static int CmdHF14BSim(const char *Cmd) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_ISO14443B_SIMULATE, pupi, 0, 0, NULL, 0); SendCommandMIX(CMD_HF_ISO14443B_SIMULATE, pupi, 0, 0, NULL, 0);
return 0; return PM3_SUCCESS;
} }
static int CmdHF14BSniff(const char *Cmd) { static int CmdHF14BSniff(const char *Cmd) {
@ -192,7 +192,7 @@ static int CmdHF14BSniff(const char *Cmd) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_SNIFF, NULL, 0); SendCommandNG(CMD_HF_ISO14443B_SNIFF, NULL, 0);
return 0; return PM3_SUCCESS;
} }
static int CmdHF14BCmdRaw(const char *Cmd) { static int CmdHF14BCmdRaw(const char *Cmd) {
@ -262,15 +262,16 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
continue; continue;
} }
PrintAndLogEx(WARNING, "unknown parameter '%c'\n", param_getchar(Cmd, i)); PrintAndLogEx(WARNING, "unknown parameter '%c'\n", param_getchar(Cmd, i));
return 0; return PM3_EINVARG;
} }
if (hasTimeout) { if (hasTimeout) {
#define MAX_TIMEOUT 40542464 // = (2^32-1) * (8*16) / 13560000Hz * 1000ms/s
#define MAX_14B_TIMEOUT 40542464 // = (2^32-1) * (8*16) / 13560000Hz * 1000ms/s
flags |= ISO14B_SET_TIMEOUT; flags |= ISO14B_SET_TIMEOUT;
if (user_timeout > MAX_TIMEOUT) { if (user_timeout > MAX_14B_TIMEOUT) {
user_timeout = MAX_TIMEOUT; user_timeout = MAX_14B_TIMEOUT;
PrintAndLogEx(NORMAL, "Set timeout to 40542 seconds (11.26 hours). The max we can wait for response"); PrintAndLogEx(INFO, "Set timeout to 40542 seconds (11.26 hours). The max we can wait for response");
} }
time_wait = 13560000 / 1000 / (8 * 16) * user_timeout; // timeout in ETUs (time to transfer 1 bit, approx. 9.4 us) time_wait = 13560000 / 1000 / (8 * 16) * user_timeout; // timeout in ETUs (time to transfer 1 bit, approx. 9.4 us)
} }
@ -287,7 +288,7 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
clearCommandBuffer(); clearCommandBuffer();
SendCommandOLD(CMD_HF_ISO14443B_COMMAND, flags, datalen, time_wait, data, datalen); SendCommandOLD(CMD_HF_ISO14443B_COMMAND, flags, datalen, time_wait, data, datalen);
if (!reply) return 1; if (!reply) return PM3_SUCCESS;
bool success = true; bool success = true;
// get back iso14b_card_select_t, don't print it. // get back iso14b_card_select_t, don't print it.
@ -297,7 +298,7 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
// get back response from the raw bytes you sent. // get back response from the raw bytes you sent.
if (success && datalen > 0) waitCmd14b(true); if (success && datalen > 0) waitCmd14b(true);
return 1; return PM3_SUCCESS;
} }
static bool get_14b_UID(iso14b_card_select_t *card) { static bool get_14b_UID(iso14b_card_select_t *card) {
@ -484,7 +485,6 @@ static void print_st_general_info(uint8_t *data, uint8_t len) {
PrintAndLogEx(NORMAL, " UID: %s", sprint_hex(SwapEndian64(data, 8, 8), len)); PrintAndLogEx(NORMAL, " UID: %s", sprint_hex(SwapEndian64(data, 8, 8), len));
PrintAndLogEx(NORMAL, " MFG: %02X, %s", data[6], getTagInfo(data[6])); PrintAndLogEx(NORMAL, " MFG: %02X, %s", data[6], getTagInfo(data[6]));
PrintAndLogEx(NORMAL, "Chip: %02X, %s", data[5] >> 2, get_ST_Chip_Model(data[5] >> 2)); PrintAndLogEx(NORMAL, "Chip: %02X, %s", data[5] >> 2, get_ST_Chip_Model(data[5] >> 2));
return;
} }
//05 00 00 = find one tag in field //05 00 00 = find one tag in field
@ -793,18 +793,18 @@ static int CmdHF14BWriteSri(const char *Cmd) {
if (isSrix4k) { if (isSrix4k) {
if (blockno > 0x7f && blockno != 0xff) { if (blockno > 0x7f && blockno != 0xff) {
PrintAndLogEx(FAILED, "block number out of range"); PrintAndLogEx(FAILED, "block number out of range");
return 0; return PM3_ESOFT;
} }
} else { } else {
if (blockno > 0x0f && blockno != 0xff) { if (blockno > 0x0f && blockno != 0xff) {
PrintAndLogEx(FAILED, "block number out of range"); PrintAndLogEx(FAILED, "block number out of range");
return 0; return PM3_ESOFT;
} }
} }
if (param_gethex(Cmd, 2, data, 8)) { if (param_gethex(Cmd, 2, data, 8)) {
PrintAndLogEx(WARNING, "data must include 8 HEX symbols"); PrintAndLogEx(WARNING, "data must include 8 HEX symbols");
return 0; return PM3_ESOFT;
} }
if (blockno == 0xff) { if (blockno == 0xff) {
@ -822,8 +822,7 @@ static int CmdHF14BWriteSri(const char *Cmd) {
} }
sprintf(str, "-ss -c %02x %02x %02x %02x %02x %02x", ISO14443B_WRITE_BLK, blockno, data[0], data[1], data[2], data[3]); sprintf(str, "-ss -c %02x %02x %02x %02x %02x %02x", ISO14443B_WRITE_BLK, blockno, data[0], data[1], data[2], data[3]);
CmdHF14BCmdRaw(str); return CmdHF14BCmdRaw(str);
return 0;
} }
// need to write to file // need to write to file
@ -875,7 +874,7 @@ static int CmdHF14BDump(const char *Cmd) {
if (!get_14b_UID(&card)) { if (!get_14b_UID(&card)) {
PrintAndLogEx(WARNING, "No tag found."); PrintAndLogEx(WARNING, "No tag found.");
return 1; return PM3_SUCCESS;
} }
if (fileNameLen < 1) { if (fileNameLen < 1) {
@ -1102,7 +1101,7 @@ static command_t CommandTable[] = {
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {
(void)Cmd; // Cmd is not used so far (void)Cmd; // Cmd is not used so far
CmdsHelp(CommandTable); CmdsHelp(CommandTable);
return 0; return PM3_SUCCESS;
} }
int CmdHF14B(const char *Cmd) { int CmdHF14B(const char *Cmd) {

2
client/cmdhw.c
View file

@ -542,7 +542,7 @@ static int CmdPing(const char *Cmd) {
bool error = false; bool error = false;
if (len) { if (len) {
error = memcmp(data, resp.data.asBytes, len) != 0; error = memcmp(data, resp.data.asBytes, len) != 0;
PrintAndLogEx((error) ? ERR : SUCCESS, "Ping response " _GREEN_("received") "and content is %s", error ? _RED_("NOT ok") : _GREEN_("ok")); PrintAndLogEx((error) ? ERR : SUCCESS, "Ping response " _GREEN_("received") "and content is %s", error ? _RED_("NOT ok") : _GREEN_("OK"));
} else { } else {
PrintAndLogEx(SUCCESS, "Ping response " _GREEN_("received")); PrintAndLogEx(SUCCESS, "Ping response " _GREEN_("received"));
} }

83
client/cmdlffdx.c
View file

@ -13,6 +13,7 @@
#include <inttypes.h> #include <inttypes.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <ctype.h> // tolower
#include "cmdparser.h" // command_t #include "cmdparser.h" // command_t
#include "comms.h" #include "comms.h"
@ -49,15 +50,14 @@ static int CmdHelp(const char *Cmd);
static int usage_lf_fdx_clone(void) { static int usage_lf_fdx_clone(void) {
PrintAndLogEx(NORMAL, "Clone a FDX-B animal tag to a T55x7 tag."); PrintAndLogEx(NORMAL, "Clone a FDX-B animal tag to a T55x7 tag.");
PrintAndLogEx(NORMAL, "Usage: lf fdx clone [h] <country id> <animal id> <Q5>"); PrintAndLogEx(NORMAL, "Usage: lf fdx clone [h] <country id> <animal id> <extended> <Q5>");
PrintAndLogEx(NORMAL, "Options:"); PrintAndLogEx(NORMAL, "Options:");
PrintAndLogEx(NORMAL, " h : This help"); PrintAndLogEx(NORMAL, " h : This help");
PrintAndLogEx(NORMAL, " <country id> : Country id"); PrintAndLogEx(NORMAL, " <country id> : Country id");
PrintAndLogEx(NORMAL, " <animal id> : Animal id"); PrintAndLogEx(NORMAL, " <animal id> : Animal id");
// has extended data? PrintAndLogEx(NORMAL, " <extended> : Extended data");
//reserved/rfu //reserved/rfu
//is animal tag //is animal tag
// extended data
PrintAndLogEx(NORMAL, " <Q5> : Specify write to Q5 (t5555 instead of t55x7)"); PrintAndLogEx(NORMAL, " <Q5> : Specify write to Q5 (t5555 instead of t55x7)");
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
PrintAndLogEx(NORMAL, "Examples:"); PrintAndLogEx(NORMAL, "Examples:");
@ -69,11 +69,12 @@ static int usage_lf_fdx_sim(void) {
PrintAndLogEx(NORMAL, "Enables simulation of FDX-B animal tag"); PrintAndLogEx(NORMAL, "Enables simulation of FDX-B animal tag");
PrintAndLogEx(NORMAL, "Simulation runs until the button is pressed or another USB command is issued."); PrintAndLogEx(NORMAL, "Simulation runs until the button is pressed or another USB command is issued.");
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
PrintAndLogEx(NORMAL, "Usage: lf fdx sim [h] <country id> <animal id>"); PrintAndLogEx(NORMAL, "Usage: lf fdx sim [h] <country id> <animal id> <extended>");
PrintAndLogEx(NORMAL, "Options:"); PrintAndLogEx(NORMAL, "Options:");
PrintAndLogEx(NORMAL, " h : This help"); PrintAndLogEx(NORMAL, " h : This help");
PrintAndLogEx(NORMAL, " <country id> : Country ID"); PrintAndLogEx(NORMAL, " <country id> : Country ID");
PrintAndLogEx(NORMAL, " <animal id> : Animal ID"); PrintAndLogEx(NORMAL, " <animal id> : Animal ID");
PrintAndLogEx(NORMAL, " <extended> : Extended data");
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
PrintAndLogEx(NORMAL, "Examples:"); PrintAndLogEx(NORMAL, "Examples:");
PrintAndLogEx(NORMAL, " lf fdx sim 999 112233"); PrintAndLogEx(NORMAL, " lf fdx sim 999 112233");
@ -81,14 +82,14 @@ static int usage_lf_fdx_sim(void) {
} }
// clearing the topbit needed for the preambl detection. // clearing the topbit needed for the preambl detection.
static void verify_values(uint32_t countryid, uint64_t animalid) { static void verify_values(uint64_t *animalid, uint32_t *countryid) {
if ((animalid & 0x3FFFFFFFFF) != animalid) { if ((*animalid & 0x3FFFFFFFFF) != *animalid) {
animalid &= 0x3FFFFFFFFF; *animalid &= 0x3FFFFFFFFF;
PrintAndLogEx(INFO, "Animal ID Truncated to 38bits: %"PRIx64, animalid); PrintAndLogEx(INFO, "Animal ID Truncated to 38bits: %"PRIx64, *animalid);
} }
if ((countryid & 0x3ff) != countryid) { if ((*countryid & 0x3ff) != *countryid) {
countryid &= 0x3ff; *countryid &= 0x3ff;
PrintAndLogEx(INFO, "Country ID Truncated to 10bits: %03d", countryid); PrintAndLogEx(INFO, "Country ID Truncated to 10bits: %03d", *countryid);
} }
} }
@ -226,15 +227,12 @@ static int CmdFdxDemod(const char *Cmd) {
uint8_t dataBlockBit = DemodBuffer[48]; uint8_t dataBlockBit = DemodBuffer[48];
uint32_t reservedCode = bytebits_to_byteLSBF(DemodBuffer + 49, 14); uint32_t reservedCode = bytebits_to_byteLSBF(DemodBuffer + 49, 14);
uint8_t animalBit = DemodBuffer[63]; uint8_t animalBit = DemodBuffer[63];
uint32_t crc_16 = bytebits_to_byteLSBF(DemodBuffer + 64, 16); uint16_t crc = bytebits_to_byteLSBF(DemodBuffer + 64, 16);
uint32_t extended = bytebits_to_byteLSBF(DemodBuffer + 80, 24); uint32_t extended = bytebits_to_byteLSBF(DemodBuffer + 80, 24);
uint64_t rawid = (uint64_t)(bytebits_to_byte(DemodBuffer, 32)) << 32 | bytebits_to_byte(DemodBuffer + 32, 32); uint64_t rawid = (uint64_t)(bytebits_to_byte(DemodBuffer, 32)) << 32 | bytebits_to_byte(DemodBuffer + 32, 32);
uint8_t raw[8]; uint8_t raw[8];
num_to_bytes(rawid, 8, raw); num_to_bytes(rawid, 8, raw);
uint16_t calcCrc = crc16_kermit(raw, 8);
PrintAndLogEx(SUCCESS, "\nFDX-B / ISO 11784/5 Animal Tag ID Found: Raw : %s", sprint_hex(raw, 8)); PrintAndLogEx(SUCCESS, "\nFDX-B / ISO 11784/5 Animal Tag ID Found: Raw : %s", sprint_hex(raw, 8));
PrintAndLogEx(SUCCESS, "Animal ID %04u-%012" PRIu64, countryCode, NationalCode); PrintAndLogEx(SUCCESS, "Animal ID %04u-%012" PRIu64, countryCode, NationalCode);
PrintAndLogEx(SUCCESS, "National Code %012" PRIu64 " (0x%" PRIx64 ")", NationalCode, NationalCode); PrintAndLogEx(SUCCESS, "National Code %012" PRIu64 " (0x%" PRIx64 ")", NationalCode, NationalCode);
@ -242,7 +240,10 @@ static int CmdFdxDemod(const char *Cmd) {
PrintAndLogEx(SUCCESS, "Reserved/RFU %u (0x04%X)", reservedCode, reservedCode); PrintAndLogEx(SUCCESS, "Reserved/RFU %u (0x04%X)", reservedCode, reservedCode);
PrintAndLogEx(SUCCESS, "Animal Tag %s", animalBit ? _YELLOW_("True") : "False"); PrintAndLogEx(SUCCESS, "Animal Tag %s", animalBit ? _YELLOW_("True") : "False");
PrintAndLogEx(SUCCESS, "Has extended data %s [0x%X]", dataBlockBit ? _YELLOW_("True") : "False", extended); PrintAndLogEx(SUCCESS, "Has extended data %s [0x%X]", dataBlockBit ? _YELLOW_("True") : "False", extended);
PrintAndLogEx(SUCCESS, "CRC-16 0x%04X - 0x%04X [%s]", crc_16, calcCrc, (calcCrc == crc_16) ? _GREEN_("Ok") : _RED_("Fail"));
uint8_t c[] = {0, 0};
compute_crc(CRC_11784, raw, sizeof(raw), &c[0], &c[1]);
PrintAndLogEx(SUCCESS, "CRC-16 0x%04X [ %s] ", crc, (crc == (c[1] << 8 | c[0]) ) ? _GREEN_("OK") : _RED_("Fail"));
if (g_debugMode) { if (g_debugMode) {
PrintAndLogEx(DEBUG, "Start marker %d; Size %zu", preambleIndex, size); PrintAndLogEx(DEBUG, "Start marker %d; Size %zu", preambleIndex, size);
@ -263,19 +264,21 @@ static int CmdFdxRead(const char *Cmd) {
static int CmdFdxClone(const char *Cmd) { static int CmdFdxClone(const char *Cmd) {
uint32_t countryid = 0; uint32_t countryid = 0, extended = 0;
uint64_t animalid = 0; uint64_t animalid = 0;
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_fdx_clone(); char cmdp = tolower(param_getchar(Cmd, 0));
if (strlen(Cmd) == 0 || cmdp == 'h') return usage_lf_fdx_clone();
countryid = param_get32ex(Cmd, 0, 0, 10); countryid = param_get32ex(Cmd, 0, 0, 10);
animalid = param_get64ex(Cmd, 1, 0, 10); animalid = param_get64ex(Cmd, 1, 0, 10);
extended = param_get32ex(Cmd, 2, 0, 10);
verify_values(countryid, animalid); verify_values(&animalid, &countryid);
uint8_t *bits = calloc(128, sizeof(uint8_t)); uint8_t *bits = calloc(128, sizeof(uint8_t));
if (getFDXBits(animalid, countryid, 1, 0, 0, bits) != PM3_SUCCESS) { if (getFDXBits(animalid, countryid, 1, (extended > 0), extended, bits) != PM3_SUCCESS) {
PrintAndLogEx(ERR, "Error with tag bitstream generation."); PrintAndLogEx(ERR, "Error with tag bitstream generation.");
free(bits); free(bits);
return PM3_ESOFT; return PM3_ESOFT;
@ -284,7 +287,7 @@ static int CmdFdxClone(const char *Cmd) {
uint32_t blocks[5] = {T55x7_MODULATION_DIPHASE | T55x7_BITRATE_RF_32 | 4 << T55x7_MAXBLOCK_SHIFT, 0, 0, 0, 0}; uint32_t blocks[5] = {T55x7_MODULATION_DIPHASE | T55x7_BITRATE_RF_32 | 4 << T55x7_MAXBLOCK_SHIFT, 0, 0, 0, 0};
//Q5 //Q5
if (param_getchar(Cmd, 2) == 'Q' || param_getchar(Cmd, 2) == 'q') if (tolower(param_getchar(Cmd, 2)) == 'q')
blocks[0] = T5555_MODULATION_BIPHASE | T5555_INVERT_OUTPUT | T5555_SET_BITRATE(32) | 4 << T5555_MAXBLOCK_SHIFT; blocks[0] = T5555_MODULATION_BIPHASE | T5555_INVERT_OUTPUT | T5555_SET_BITRATE(32) | 4 << T5555_MAXBLOCK_SHIFT;
// convert from bit stream to block data // convert from bit stream to block data
@ -302,33 +305,41 @@ static int CmdFdxClone(const char *Cmd) {
} }
static int CmdFdxSim(const char *Cmd) { static int CmdFdxSim(const char *Cmd) {
uint32_t countryid = 0; uint32_t countryid = 0, extended = 0;
uint64_t animalid = 0; uint64_t animalid = 0;
char cmdp = param_getchar(Cmd, 0); char cmdp = tolower(param_getchar(Cmd, 0));
if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_fdx_sim(); if (strlen(Cmd) == 0 || cmdp == 'h') return usage_lf_fdx_sim();
countryid = param_get32ex(Cmd, 0, 0, 10); countryid = param_get32ex(Cmd, 0, 0, 10);
animalid = param_get64ex(Cmd, 1, 0, 10); animalid = param_get64ex(Cmd, 1, 0, 10);
extended = param_get32ex(Cmd, 2, 0 , 10);
verify_values(countryid, animalid); verify_values(&animalid, &countryid);
PrintAndLogEx(SUCCESS, "Simulating FDX-B animal ID: %04u-%"PRIu64, countryid, animalid); PrintAndLogEx(SUCCESS, "Simulating FDX-B animal ID: %04u-%"PRIu64, countryid, animalid);
uint8_t bs[128];
//getFDXBits(uint64_t national_id, uint16_t country, uint8_t isanimal, uint8_t isextended, uint32_t extended, uint8_t *bits) //getFDXBits(uint64_t national_id, uint16_t country, uint8_t isanimal, uint8_t isextended, uint32_t extended, uint8_t *bits)
getFDXBits(animalid, countryid, 1, 0, 0, bs); uint8_t *bits = calloc(128, sizeof(uint8_t));
if (getFDXBits(animalid, countryid, 1, (extended > 0), extended, bits) != PM3_SUCCESS) {
PrintAndLogEx(ERR, "Error with tag bitstream generation.");
free(bits);
return PM3_ESOFT;
}
// 32, no STT, BIPHASE INVERTED == diphase // 32, no STT, BIPHASE INVERTED == diphase
lf_asksim_t *payload = calloc(1, sizeof(lf_asksim_t) + sizeof(bs)); lf_asksim_t *payload = calloc(1, sizeof(lf_asksim_t) + 128);
payload->encoding = 2; payload->encoding = 2;
payload->invert = 1; payload->invert = 1;
payload->separator = 0; payload->separator = 0;
payload->clock = 32; payload->clock = 32;
memcpy(payload->data, bs, sizeof(bs)); memcpy(payload->data, bits, 128);
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_LF_ASK_SIMULATE, (uint8_t *)payload, sizeof(lf_asksim_t) + sizeof(bs)); SendCommandNG(CMD_LF_ASK_SIMULATE, (uint8_t *)payload, sizeof(lf_asksim_t) + 128);
free(bits);
free(payload); free(payload);
PacketResponseNG resp; PacketResponseNG resp;
@ -337,6 +348,7 @@ static int CmdFdxSim(const char *Cmd) {
PrintAndLogEx(INFO, "Done"); PrintAndLogEx(INFO, "Done");
if (resp.status != PM3_EOPABORTED) if (resp.status != PM3_EOPABORTED)
return resp.status; return resp.status;
return PM3_SUCCESS; return PM3_SUCCESS;
} }
@ -378,7 +390,7 @@ int demodFDX(void) {
return CmdFdxDemod(""); return CmdFdxDemod("");
} }
int getFDXBits(uint64_t national_id, uint16_t country, uint8_t isanimal, uint8_t isextended, uint32_t extended, uint8_t *bits) { int getFDXBits(uint64_t national_id, uint16_t country, uint8_t is_animal, uint8_t is_extended, uint32_t extended, uint8_t *bits) {
// add preamble ten 0x00 and one 0x01 // add preamble ten 0x00 and one 0x01
memset(bits, 0x00, 10); memset(bits, 0x00, 10);
@ -396,10 +408,10 @@ int getFDXBits(uint64_t national_id, uint16_t country, uint8_t isanimal, uint8_t
num_to_bytebitsLSBF(0x00 >> 7, 7, bits + 74); num_to_bytebitsLSBF(0x00 >> 7, 7, bits + 74);
// add animal flag - OK // add animal flag - OK
bits[65] = isanimal; bits[65] = is_animal;
// add extended flag - OK // add extended flag - OK
bits[81] = isextended; bits[81] = is_extended;
// add national code 40bits - OK // add national code 40bits - OK
num_to_bytebitsLSBF(national_id >> 0, 8, bits + 11); num_to_bytebitsLSBF(national_id >> 0, 8, bits + 11);
@ -417,7 +429,8 @@ int getFDXBits(uint64_t national_id, uint16_t country, uint8_t isanimal, uint8_t
for (uint8_t i = 0; i < 8; ++i) for (uint8_t i = 0; i < 8; ++i)
raw[i] = bytebits_to_byte(bits + 11 + i * 9, 8); raw[i] = bytebits_to_byte(bits + 11 + i * 9, 8);
uint16_t crc = crc16_kermit(raw, 8); init_table(CRC_11784);
uint16_t crc = crc16_fdx(raw, 8);
num_to_bytebitsLSBF(crc >> 0, 8, bits + 83); num_to_bytebitsLSBF(crc >> 0, 8, bits + 83);
num_to_bytebitsLSBF(crc >> 8, 8, bits + 92); num_to_bytebitsLSBF(crc >> 8, 8, bits + 92);

2
client/dictionaries/mfc_default_keys.dic
View file

@ -21,6 +21,8 @@ a0478cc39091
8fd0a4f256e9 8fd0a4f256e9
# #
d2ece8b9395e # lib d2ece8b9395e # lib
# NSCP default key
☻1494E81663D7
# #
# more Keys from mfc_default_keys.lua # more Keys from mfc_default_keys.lua
000000000001 000000000001

17
common/crc16.c
View file

@ -46,6 +46,9 @@ void init_table(CrcType_t crctype) {
case CRC_KERMIT: case CRC_KERMIT:
generate_table(CRC16_POLY_CCITT, true); generate_table(CRC16_POLY_CCITT, true);
break; break;
case CRC_11784:
generate_table(CRC16_POLY_CCITT, false);
break;
case CRC_NONE: case CRC_NONE:
crc_table_init = false; crc_table_init = false;
current_crc_type = CRC_NONE; current_crc_type = CRC_NONE;
@ -185,6 +188,9 @@ void compute_crc(CrcType_t ct, const uint8_t *d, size_t n, uint8_t *first, uint8
case CRC_KERMIT: case CRC_KERMIT:
crc = crc16_kermit(d, n); crc = crc16_kermit(d, n);
break; break;
case CRC_11784:
crc = crc16_fdx(d, n);
break;
case CRC_LEGIC: case CRC_LEGIC:
// TODO // TODO
return; return;
@ -215,6 +221,8 @@ uint16_t Crc16ex(CrcType_t ct, const uint8_t *d, size_t n) {
return crc16_ccitt(d, n); return crc16_ccitt(d, n);
case CRC_KERMIT: case CRC_KERMIT:
return crc16_kermit(d, n); return crc16_kermit(d, n);
case CRC_11784:
return crc16_fdx(d, n);
case CRC_LEGIC: case CRC_LEGIC:
// TODO // TODO
return 0; return 0;
@ -257,6 +265,8 @@ bool check_crc(CrcType_t ct, const uint8_t *d, size_t n) {
return (crc16_ccitt(d, n) == 0); return (crc16_ccitt(d, n) == 0);
case CRC_KERMIT: case CRC_KERMIT:
return (crc16_kermit(d, n) == 0); return (crc16_kermit(d, n) == 0);
case CRC_11784:
return (crc16_fdx(d, n) == 0);
case CRC_LEGIC: case CRC_LEGIC:
// TODO // TODO
return false; return false;
@ -272,7 +282,12 @@ uint16_t crc16_ccitt(uint8_t const *d, size_t n) {
return crc16_fast(d, n, 0xffff, false, false); return crc16_fast(d, n, 0xffff, false, false);
} }
// FDX-B ISO11784/85) uses KERMIT // FDX-B ISO11784/85) uses KERMIT/CCITT
// poly 0x xx init=0x000 refin=false refout=true xorout=0x0000 ...
uint16_t crc16_fdx(uint8_t const *d, size_t n) {
return crc16_fast(d, n, 0x0000, false, true);
}
// poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 name="KERMIT" // poly=0x1021 init=0x0000 refin=true refout=true xorout=0x0000 name="KERMIT"
uint16_t crc16_kermit(uint8_t const *d, size_t n) { uint16_t crc16_kermit(uint8_t const *d, size_t n) {
return crc16_fast(d, n, 0x0000, true, true); return crc16_fast(d, n, 0x0000, true, true);

11
common/crc16.h
View file

@ -10,14 +10,16 @@
#include "common.h" #include "common.h"
#define CRC16_POLY_CCITT 0x1021 #define CRC16_POLY_CCITT 0x1021
#define CRC16_POLY_LEGIC 0xc6c6 //0x6363 #define CRC16_POLY_KERMIT 0x8408
#define CRC16_POLY_DNP 0x3d65 #define CRC16_POLY_LEGIC 0xc6c6 //0x6363
#define CRC16_POLY_DNP 0x3d65
#define X25_CRC_CHECK ((uint16_t)(~0xF0B8 & 0xFFFF)) // use this for checking of a correct crc #define X25_CRC_CHECK ((uint16_t)(~0xF0B8 & 0xFFFF)) // use this for checking of a correct crc
typedef enum { typedef enum {
CRC_NONE, CRC_NONE,
CRC_11784,
CRC_14443_A, CRC_14443_A,
CRC_14443_B, CRC_14443_B,
CRC_15693, CRC_15693,
@ -41,6 +43,9 @@ bool check_crc(CrcType_t ct, const uint8_t *d, size_t n);
uint16_t crc16_ccitt(uint8_t const *d, size_t n); uint16_t crc16_ccitt(uint8_t const *d, size_t n);
// Calculate CRC-16/KERMIT (FDX-B ISO11784/85) LF // Calculate CRC-16/KERMIT (FDX-B ISO11784/85) LF
uint16_t crc16_fdx(uint8_t const *d, size_t n);
// Calculate CRC-16/KERMIT
uint16_t crc16_kermit(uint8_t const *d, size_t n); uint16_t crc16_kermit(uint8_t const *d, size_t n);
// Calculate CRC-16/XMODEM (FeliCa) // Calculate CRC-16/XMODEM (FeliCa)

3
doc/md/Installation_Instructions/Linux-Installation-Instructions.md
View file

@ -58,7 +58,8 @@ git clone https://github.com/RfidResearchGroup/proxmark3.git
# Check ModemManager # Check ModemManager
**Very important**: make sure ModemManager will not interfer, otherwise it could brick your Proxmark3! ### ⚠️ Very important ⚠️
make sure ModemManager will not interfer, otherwise it could brick your Proxmark3!
Read carefully [this page about ModemManager](ModemManager-Must-Be-Discarded.md) and follow its instructions. Read carefully [this page about ModemManager](ModemManager-Must-Be-Discarded.md) and follow its instructions.
# Check connection # Check connection