Merge branch 'master' into loud-nightingale
Signed-off-by: Iceman <iceman@iuse.se>
This commit is contained in:
77 files changed
+1688
-825
No files matched your search
+23
-23
@@ -3670,8 +3670,8 @@ static int CmdXor(const char *Cmd) {
|
||||
static int CmdTestSaveState8(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "data test_ss8",
|
||||
"Tests the implementation of Buffer Save States (8-bit buffer)",
|
||||
"data test_ss8");
|
||||
"Tests the implementation of Buffer Save States (8-bit buffer)",
|
||||
"data test_ss8");
|
||||
void *argtable[] = {
|
||||
arg_param_begin,
|
||||
arg_param_end
|
||||
@@ -3686,7 +3686,7 @@ static int CmdTestSaveState8(const char *Cmd) {
|
||||
uint8_t *srcBuffer = (uint8_t*)calloc(length + 1, sizeof(uint8_t));
|
||||
|
||||
//Set up the source buffer with random data
|
||||
for(int i = 0; i < length; i++) {
|
||||
for (int i = 0; i < length; i++) {
|
||||
srcBuffer[i] = (rand() % 256);
|
||||
}
|
||||
|
||||
@@ -3697,18 +3697,18 @@ static int CmdTestSaveState8(const char *Cmd) {
|
||||
test8.offset = rand();
|
||||
PrintAndLogEx(DEBUG, "Save State clock = %u, offset = %u", test8.clock, test8.offset);
|
||||
|
||||
uint8_t *destBuffer = (uint8_t*)calloc(length, sizeof(uint8_t));
|
||||
uint8_t *destBuffer = (uint8_t *)calloc(length, sizeof(uint8_t));
|
||||
size_t returnedLength = restore_buffer8(test8, destBuffer);
|
||||
|
||||
if(returnedLength != length) {
|
||||
if (returnedLength != length) {
|
||||
PrintAndLogEx(DEBUG, _YELLOW_("Returned length != expected length!"));
|
||||
PrintAndLogEx(WARNING, "Returned Length = %llu Buffer Length = %llu Expected = %llu", returnedLength, test8.bufferSize, length);
|
||||
} else {
|
||||
PrintAndLogEx(DEBUG, _GREEN_("Lengths match!") "\n");
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < returnedLength; i++) {
|
||||
if(srcBuffer[i] != destBuffer[i]) {
|
||||
for (size_t i = 0; i < returnedLength; i++) {
|
||||
if (srcBuffer[i] != destBuffer[i]) {
|
||||
PrintAndLogEx(FAILED, "Buffers don't match at index %lu!, Expected %i, got %i", i, srcBuffer[i], destBuffer[i]);
|
||||
free(srcBuffer);
|
||||
free(destBuffer);
|
||||
@@ -3726,8 +3726,8 @@ static int CmdTestSaveState8(const char *Cmd) {
|
||||
static int CmdTestSaveState32(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "data test_ss32",
|
||||
"Tests the implementation of Buffer Save States (32-bit buffer)",
|
||||
"data test_ss32");
|
||||
"Tests the implementation of Buffer Save States (32-bit buffer)",
|
||||
"data test_ss32");
|
||||
void *argtable[] = {
|
||||
arg_param_begin,
|
||||
arg_param_end
|
||||
@@ -3738,10 +3738,10 @@ static int CmdTestSaveState32(const char *Cmd) {
|
||||
srand(time(NULL));
|
||||
|
||||
size_t length = 64;
|
||||
uint32_t *srcBuffer = (uint32_t*)calloc(length, sizeof(uint32_t));
|
||||
uint32_t *srcBuffer = (uint32_t *)calloc(length, sizeof(uint32_t));
|
||||
|
||||
//Set up the source buffer with random data
|
||||
for(size_t i = 0; i < length; i++) {
|
||||
for (size_t i = 0; i < length; i++) {
|
||||
srcBuffer[i] = (rand());
|
||||
}
|
||||
|
||||
@@ -3752,10 +3752,10 @@ static int CmdTestSaveState32(const char *Cmd) {
|
||||
test32.offset = rand();
|
||||
PrintAndLogEx(DEBUG, "Save State clock=%u, offset=%u", test32.clock, test32.offset);
|
||||
|
||||
uint32_t *destBuffer = (uint32_t*)calloc(length, sizeof(uint32_t));
|
||||
uint32_t *destBuffer = (uint32_t *)calloc(length, sizeof(uint32_t));
|
||||
size_t returnedLength = restore_buffer32(test32, destBuffer);
|
||||
|
||||
if(returnedLength != length) {
|
||||
if (returnedLength != length) {
|
||||
PrintAndLogEx(FAILED, "Return Length != Buffer Length! Expected '%llu', got '%llu", g_DemodBufferLen, returnedLength);
|
||||
free(srcBuffer);
|
||||
free(destBuffer);
|
||||
@@ -3763,8 +3763,8 @@ static int CmdTestSaveState32(const char *Cmd) {
|
||||
}
|
||||
PrintAndLogEx(DEBUG, _GREEN_("Lengths match!") "\n");
|
||||
|
||||
for(size_t i = 0; i < length; i++) {
|
||||
if(srcBuffer[i] != destBuffer[i]) {
|
||||
for (size_t i = 0; i < length; i++) {
|
||||
if (srcBuffer[i] != destBuffer[i]) {
|
||||
PrintAndLogEx(FAILED, "Buffers don't match at index %lu!, Expected %i, got %i", i, srcBuffer[i], destBuffer[i]);
|
||||
free(srcBuffer);
|
||||
free(destBuffer);
|
||||
@@ -3782,8 +3782,8 @@ static int CmdTestSaveState32(const char *Cmd) {
|
||||
static int CmdTestSaveState32S(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "data test_ss32s",
|
||||
"Tests the implementation of Buffer Save States (32-bit signed buffer)",
|
||||
"data test_ss32s");
|
||||
"Tests the implementation of Buffer Save States (32-bit signed buffer)",
|
||||
"data test_ss32s");
|
||||
void *argtable[] = {
|
||||
arg_param_begin,
|
||||
arg_param_end
|
||||
@@ -3794,10 +3794,10 @@ static int CmdTestSaveState32S(const char *Cmd) {
|
||||
srand(time(NULL));
|
||||
|
||||
size_t length = 64;
|
||||
int32_t *srcBuffer = (int32_t*)calloc(length, sizeof(int32_t));
|
||||
int32_t *srcBuffer = (int32_t *)calloc(length, sizeof(int32_t));
|
||||
|
||||
//Set up the source buffer with random data
|
||||
for(int i = 0; i < length; i++) {
|
||||
for (int i = 0; i < length; i++) {
|
||||
srcBuffer[i] = (rand() - 4294967296);
|
||||
}
|
||||
|
||||
@@ -3808,10 +3808,10 @@ static int CmdTestSaveState32S(const char *Cmd) {
|
||||
test32.offset = rand();
|
||||
PrintAndLogEx(DEBUG, "Save State clock=%u, offset=%u", test32.clock, test32.offset);
|
||||
|
||||
int32_t *destBuffer = (int32_t*)calloc(length, sizeof(int32_t));
|
||||
int32_t *destBuffer = (int32_t *)calloc(length, sizeof(int32_t));
|
||||
size_t returnedLength = restore_bufferS32(test32, destBuffer);
|
||||
|
||||
if(returnedLength != length) {
|
||||
if (returnedLength != length) {
|
||||
PrintAndLogEx(FAILED, "Return Length != Buffer Length! Expected '%llu', got '%llu", g_DemodBufferLen, returnedLength);
|
||||
free(srcBuffer);
|
||||
free(destBuffer);
|
||||
@@ -3819,8 +3819,8 @@ static int CmdTestSaveState32S(const char *Cmd) {
|
||||
}
|
||||
PrintAndLogEx(DEBUG, _GREEN_("Lengths match!") "\n");
|
||||
|
||||
for(int i = 0; i < length; i++) {
|
||||
if(srcBuffer[i] != destBuffer[i]) {
|
||||
for (int i = 0; i < length; i++) {
|
||||
if (srcBuffer[i] != destBuffer[i]) {
|
||||
PrintAndLogEx(FAILED, "Buffers don't match at index %i!, Expected %i, got %i", i, srcBuffer[i], destBuffer[i]);
|
||||
free(srcBuffer);
|
||||
free(destBuffer);
|
||||
|
||||
@@ -26,7 +26,7 @@
|
||||
|
||||
static int CmdHelp(const char *Cmd);
|
||||
|
||||
int flashmem_spiffs_load(char *destfn, uint8_t *data, size_t datalen) {
|
||||
int flashmem_spiffs_load(const char *destfn, const uint8_t *data, size_t datalen) {
|
||||
|
||||
int ret_val = PM3_SUCCESS;
|
||||
|
||||
@@ -429,9 +429,14 @@ static int CmdFlashMemSpiFFSDump(const char *Cmd) {
|
||||
PrintAndLogEx(HINT, "Use 'trace list -1 -t ...' to view, 'trace save -f ...' to save");
|
||||
}
|
||||
|
||||
if (dlen) {
|
||||
|
||||
if (dlen || slen) {
|
||||
|
||||
// save to file
|
||||
char fn[FILE_PATH_SIZE] = {0};
|
||||
|
||||
// prefer dest name
|
||||
// else source name
|
||||
if (dlen) {
|
||||
strncpy(fn, dest, dlen);
|
||||
} else {
|
||||
@@ -439,7 +444,7 @@ static int CmdFlashMemSpiFFSDump(const char *Cmd) {
|
||||
}
|
||||
|
||||
// set file extension
|
||||
char *suffix = strchr(fn, '.');
|
||||
const char *suffix = strchr(fn, '.');
|
||||
if (suffix) {
|
||||
saveFile(fn, suffix, dump, len);
|
||||
} else {
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
#include "common.h"
|
||||
|
||||
int CmdFlashMemSpiFFS(const char *Cmd);
|
||||
int flashmem_spiffs_load(char *destfn, uint8_t *data, size_t datalen);
|
||||
int flashmem_spiffs_load(const char *destfn, const uint8_t *data, size_t datalen);
|
||||
int flashmem_spiffs_download(char *fn, uint8_t fnlen, void **pdest, size_t *destlen);
|
||||
|
||||
#endif
|
||||
+13
-11
@@ -95,6 +95,16 @@ int CmdHFSearch(const char *Cmd) {
|
||||
}
|
||||
}
|
||||
|
||||
PROMPT_CLEARLINE;
|
||||
PrintAndLogEx(INPLACE, " Searching for Topaz tag...");
|
||||
if (IfPm3Iso14443a()) {
|
||||
if (readTopazUid(false, false) == PM3_SUCCESS) {
|
||||
PrintAndLogEx(SUCCESS, "\nValid " _GREEN_("Topaz tag") " found\n");
|
||||
success[TOPAZ] = true;
|
||||
res = PM3_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
PROMPT_CLEARLINE;
|
||||
PrintAndLogEx(INPLACE, " Searching for LTO-CM tag...");
|
||||
if (IfPm3Iso14443a()) {
|
||||
@@ -119,7 +129,8 @@ int CmdHFSearch(const char *Cmd) {
|
||||
}
|
||||
}
|
||||
|
||||
// ICT
|
||||
/*
|
||||
// ICT
|
||||
if (IfPm3Iso14443a()) {
|
||||
int sel_state = infoHF14A(false, false, false);
|
||||
if (sel_state > 0) {
|
||||
@@ -131,6 +142,7 @@ int CmdHFSearch(const char *Cmd) {
|
||||
infoHF14A4Applications(verbose);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
PROMPT_CLEARLINE;
|
||||
PrintAndLogEx(INPLACE, " Searching for LEGIC tag...");
|
||||
@@ -142,16 +154,6 @@ int CmdHFSearch(const char *Cmd) {
|
||||
}
|
||||
}
|
||||
|
||||
PROMPT_CLEARLINE;
|
||||
PrintAndLogEx(INPLACE, " Searching for Topaz tag...");
|
||||
if (IfPm3Iso14443a()) {
|
||||
if (readTopazUid(false, false) == PM3_SUCCESS) {
|
||||
PrintAndLogEx(SUCCESS, "\nValid " _GREEN_("Topaz tag") " found\n");
|
||||
success[TOPAZ] = true;
|
||||
res = PM3_SUCCESS;
|
||||
}
|
||||
}
|
||||
|
||||
// texkom
|
||||
PROMPT_CLEARLINE;
|
||||
PrintAndLogEx(INPLACE, " Searching for TEXKOM tag...");
|
||||
|
||||
@@ -863,7 +863,7 @@ int CmdHF14ASim(const char *Cmd) {
|
||||
if ((flags & FLAG_NR_AR_ATTACK) != FLAG_NR_AR_ATTACK)
|
||||
break;
|
||||
|
||||
nonces_t *data = (nonces_t *)resp.data.asBytes;
|
||||
const nonces_t *data = (nonces_t *)resp.data.asBytes;
|
||||
readerAttack(k_sector, k_sectors_cnt, data[0], setEmulatorMem, verbose);
|
||||
|
||||
keypress = kbd_enter_pressed();
|
||||
@@ -1099,7 +1099,7 @@ int SelectCard14443A_4(bool disconnect, bool verbose, iso14a_card_select_t *card
|
||||
return SelectCard14443A_4_WithParameters(disconnect, verbose, card, NULL);
|
||||
}
|
||||
|
||||
static int CmdExchangeAPDU(bool chainingin, uint8_t *datain, int datainlen, bool activateField, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, bool *chainingout) {
|
||||
static int CmdExchangeAPDU(bool chainingin, const uint8_t *datain, int datainlen, bool activateField, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, bool *chainingout) {
|
||||
*chainingout = false;
|
||||
|
||||
size_t timeout = 1500;
|
||||
@@ -1158,7 +1158,7 @@ static int CmdExchangeAPDU(bool chainingin, uint8_t *datain, int datainlen, bool
|
||||
PacketResponseNG resp;
|
||||
|
||||
if (WaitForResponseTimeout(CMD_ACK, &resp, timeout)) {
|
||||
uint8_t *recv = resp.data.asBytes;
|
||||
const uint8_t *recv = resp.data.asBytes;
|
||||
int iLen = resp.oldarg[0];
|
||||
uint8_t res = resp.oldarg[1];
|
||||
|
||||
@@ -1216,7 +1216,7 @@ static int CmdExchangeAPDU(bool chainingin, uint8_t *datain, int datainlen, bool
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
int ExchangeAPDU14a(const uint8_t *datain, int datainlen, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
*dataoutlen = 0;
|
||||
bool chaining = false;
|
||||
int res;
|
||||
@@ -1519,7 +1519,7 @@ static int CmdHF14ACmdRaw(const char *Cmd) {
|
||||
}
|
||||
|
||||
// TODO: allow to use reader command with both data and polling configuration
|
||||
if (use_ecp | use_magsafe) {
|
||||
if (use_ecp || use_magsafe) {
|
||||
PrintAndLogEx(WARNING, "ECP and Magsafe not supported with this command at this moment. Instead use 'hf 14a reader -sk --ecp/--mag'");
|
||||
// flags |= ISO14A_USE_MAGSAFE;
|
||||
// flags |= ISO14A_USE_ECP;
|
||||
@@ -2452,9 +2452,9 @@ int infoHF14A(bool verbose, bool do_nack_test, bool do_aid_search) {
|
||||
get_compact_tlv(card.ats + pos, calen);
|
||||
} else {
|
||||
PrintAndLogEx(SUCCESS, "%s - %s"
|
||||
, sprint_hex_inrow(card.ats + pos, calen)
|
||||
, sprint_ascii(card.ats + pos, calen)
|
||||
);
|
||||
, sprint_hex_inrow(card.ats + pos, calen)
|
||||
, sprint_ascii(card.ats + pos, calen)
|
||||
);
|
||||
}
|
||||
|
||||
PrintAndLogEx(NORMAL, "");
|
||||
|
||||
@@ -66,7 +66,7 @@ int infoHF14A(bool verbose, bool do_nack_test, bool do_aid_search);
|
||||
int infoHF14A4Applications(bool verbose);
|
||||
const char *getTagInfo(uint8_t uid);
|
||||
int Hf14443_4aGetCardData(iso14a_card_select_t *card);
|
||||
int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
int ExchangeAPDU14a(const uint8_t *datain, int datainlen, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
int ExchangeRAW14a(uint8_t *datain, int datainlen, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, bool silentMode);
|
||||
|
||||
iso14a_polling_parameters_t iso14a_get_polling_parameters(bool use_ecp, bool use_magsafe);
|
||||
|
||||
+48
-48
@@ -403,7 +403,7 @@ uint8_t *get_uid_from_filename(const char *filename) {
|
||||
}
|
||||
|
||||
// extract uid part from filename
|
||||
char uidinhex[17] = {0};
|
||||
char uidinhex[17] = {0};
|
||||
strncpy(uidinhex, found + 7, 16);
|
||||
|
||||
uidinhex[16] = '\0';
|
||||
@@ -2486,16 +2486,16 @@ static int CmdHF14BAPDU(const char *Cmd) {
|
||||
uint16_t sw = get_sw(data, datalen);
|
||||
if (sw != ISO7816_OK) {
|
||||
PrintAndLogEx(SUCCESS, "APDU response: " _YELLOW_("%02x %02x") " - %s"
|
||||
, data[datalen - 2]
|
||||
, data[datalen - 1]
|
||||
, GetAPDUCodeDescription(data[datalen - 2], data[datalen - 1])
|
||||
);
|
||||
, data[datalen - 2]
|
||||
, data[datalen - 1]
|
||||
, GetAPDUCodeDescription(data[datalen - 2], data[datalen - 1])
|
||||
);
|
||||
} else {
|
||||
PrintAndLogEx(SUCCESS, "APDU response: " _GREEN_("%02x %02x") " - %s"
|
||||
, data[datalen - 2]
|
||||
, data[datalen - 1]
|
||||
, GetAPDUCodeDescription(data[datalen - 2], data[datalen - 1])
|
||||
);
|
||||
, data[datalen - 2]
|
||||
, data[datalen - 1]
|
||||
, GetAPDUCodeDescription(data[datalen - 2], data[datalen - 1])
|
||||
);
|
||||
}
|
||||
|
||||
// TLV decoder
|
||||
@@ -2708,30 +2708,30 @@ static int CmdHF14BCalypsoRead(const char *Cmd) {
|
||||
{"19.SpecEv1", "\x94\xb2\x01\x04\x1d", 5},
|
||||
};
|
||||
|
||||
/*
|
||||
local CLA = '94'
|
||||
local _calypso_cmds = {
|
||||
/*
|
||||
local CLA = '94'
|
||||
local _calypso_cmds = {
|
||||
|
||||
-- Break down of command bytes:
|
||||
-- A4 = select
|
||||
-- Master File 3F00
|
||||
-- 0x3F = master file
|
||||
-- 0x00 = master file id, is constant to 0x00.
|
||||
-- Break down of command bytes:
|
||||
-- A4 = select
|
||||
-- Master File 3F00
|
||||
-- 0x3F = master file
|
||||
-- 0x00 = master file id, is constant to 0x00.
|
||||
|
||||
-- DF Dedicated File 38nn
|
||||
-- can be seen as directories
|
||||
-- 0x38
|
||||
-- 0xNN id
|
||||
-- ["01.Select ICC file"] = '0294 a4 080004 3f00 0002',
|
||||
-- DF Dedicated File 38nn
|
||||
-- can be seen as directories
|
||||
-- 0x38
|
||||
-- 0xNN id
|
||||
-- ["01.Select ICC file"] = '0294 a4 080004 3f00 0002',
|
||||
|
||||
-- EF Elementary File
|
||||
-- EF1 Pin file
|
||||
-- EF2 Key file
|
||||
-- Grey Lock file
|
||||
-- Electronic deposit file
|
||||
-- Electronic Purse file
|
||||
-- Electronic Transaction log file
|
||||
*/
|
||||
-- EF Elementary File
|
||||
-- EF1 Pin file
|
||||
-- EF2 Key file
|
||||
-- Grey Lock file
|
||||
-- Electronic deposit file
|
||||
-- Electronic Purse file
|
||||
-- Electronic Transaction log file
|
||||
*/
|
||||
bool activate_field = true;
|
||||
bool leave_signal_on = true;
|
||||
uint8_t response[PM3_CMD_DATA_SIZE] = { 0x00 };
|
||||
@@ -2741,15 +2741,15 @@ local _calypso_cmds = {
|
||||
int user_timeout = -1;
|
||||
int resplen = 0;
|
||||
int res = exchange_14b_apdu(
|
||||
(uint8_t*)cmds[i].apdu,
|
||||
cmds[i].apdulen,
|
||||
activate_field,
|
||||
leave_signal_on,
|
||||
response,
|
||||
PM3_CMD_DATA_SIZE,
|
||||
&resplen,
|
||||
user_timeout
|
||||
);
|
||||
(uint8_t *)cmds[i].apdu,
|
||||
cmds[i].apdulen,
|
||||
activate_field,
|
||||
leave_signal_on,
|
||||
response,
|
||||
PM3_CMD_DATA_SIZE,
|
||||
&resplen,
|
||||
user_timeout
|
||||
);
|
||||
|
||||
if (res != PM3_SUCCESS) {
|
||||
PrintAndLogEx(FAILED, "sending command failed, aborting!");
|
||||
@@ -2846,15 +2846,15 @@ static int CmdHF14BMobibRead(const char *Cmd) {
|
||||
int user_timeout = -1;
|
||||
int resplen = 0;
|
||||
int res = exchange_14b_apdu(
|
||||
(uint8_t*)cmds[i].apdu,
|
||||
cmds[i].apdulen,
|
||||
activate_field,
|
||||
leave_signal_on,
|
||||
response,
|
||||
PM3_CMD_DATA_SIZE,
|
||||
&resplen,
|
||||
user_timeout
|
||||
);
|
||||
(uint8_t *)cmds[i].apdu,
|
||||
cmds[i].apdulen,
|
||||
activate_field,
|
||||
leave_signal_on,
|
||||
response,
|
||||
PM3_CMD_DATA_SIZE,
|
||||
&resplen,
|
||||
user_timeout
|
||||
);
|
||||
|
||||
if (res != PM3_SUCCESS) {
|
||||
PrintAndLogEx(FAILED, "sending command failed, aborting!");
|
||||
|
||||
+64
-28
@@ -130,15 +130,15 @@ static const productName_t uidmapping[] = {
|
||||
{ 0xe002480000000000LL, 24, "ST Microelectronics; ST25TV16K"},
|
||||
{ 0xe002480000000000LL, 24, "ST Microelectronics; ST25TV64K"},
|
||||
|
||||
/*
|
||||
ST25TV02K 0xe0 02 23
|
||||
ST25TV512 0xe0 02 23
|
||||
ST25TV02KC 0xe00208
|
||||
ST25TV512C 0xe00208
|
||||
ST25TV04K-P 0xe00235
|
||||
ST25TV16K 0xe00248
|
||||
ST25TV64K 0xe00248
|
||||
*/
|
||||
/*
|
||||
ST25TV02K 0xe0 02 23
|
||||
ST25TV512 0xe0 02 23
|
||||
ST25TV02KC 0xe00208
|
||||
ST25TV512C 0xe00208
|
||||
ST25TV04K-P 0xe00235
|
||||
ST25TV16K 0xe00248
|
||||
ST25TV64K 0xe00248
|
||||
*/
|
||||
|
||||
{ 0xE003000000000000LL, 16, "Hitachi, Ltd Japan" },
|
||||
|
||||
@@ -416,7 +416,7 @@ static int nxp_15693_print_signature(uint8_t *uid, uint8_t *signature) {
|
||||
// get a product description based on the UID
|
||||
// uid[8] tag uid
|
||||
// returns description of the best match
|
||||
static const char *getTagInfo_15(uint8_t *uid) {
|
||||
static const char *getTagInfo_15(const uint8_t *uid) {
|
||||
if (uid == NULL) {
|
||||
return "";
|
||||
}
|
||||
@@ -473,6 +473,26 @@ static const char *TagErrorStr(uint8_t error) {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int iso15_error_handling_card_response(uint8_t *d, uint16_t n) {
|
||||
if (check_crc(CRC_15693, d, n) == false) {
|
||||
PrintAndLogEx(FAILED, "crc ( " _RED_("fail") " )");
|
||||
return PM3_ECRC;
|
||||
}
|
||||
|
||||
if ((d[0] & ISO15_RES_ERROR) == ISO15_RES_ERROR) {
|
||||
if (d[1] == 0x0F || d[1] == 0x10) {
|
||||
return PM3_EOUTOFBOUND;
|
||||
}
|
||||
|
||||
PrintAndLogEx(ERR, "iso15693 card returned error %i: %s", d[0], TagErrorStr(d[0]));
|
||||
return PM3_EWRONGANSWER;
|
||||
}
|
||||
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
// fast method to just read the UID of a tag (collision detection not supported)
|
||||
// *buf should be large enough to fit the 64bit uid
|
||||
// returns 1 if succeeded
|
||||
@@ -714,7 +734,7 @@ static int CmdHF15Samples(const char *Cmd) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int NxpTestEAS(uint8_t *uid) {
|
||||
static int NxpTestEAS(const uint8_t *uid) {
|
||||
|
||||
if (uid == NULL) {
|
||||
return PM3_EINVARG;
|
||||
@@ -1162,7 +1182,7 @@ static void hf15EmlClear(void) {
|
||||
WaitForResponse(CMD_HF_ISO15693_EML_CLEAR, &resp);
|
||||
}
|
||||
|
||||
static int hf15EmlSetMem(uint8_t *data, uint16_t count, size_t offset) {
|
||||
static int hf15EmlSetMem(const uint8_t *data, uint16_t count, size_t offset) {
|
||||
struct p {
|
||||
uint32_t offset;
|
||||
uint16_t count;
|
||||
@@ -1212,13 +1232,14 @@ static int CmdHF15ELoad(const char *Cmd) {
|
||||
return res;
|
||||
}
|
||||
|
||||
if (bytes_read != sizeof(iso15_tag_t)) {
|
||||
PrintAndLogEx(FAILED, "Memory image is not matching tag structure.");
|
||||
if (bytes_read == 0) {
|
||||
PrintAndLogEx(FAILED, "Memory image empty.");
|
||||
free(tag);
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
if (bytes_read == 0) {
|
||||
PrintAndLogEx(FAILED, "Memory image empty.");
|
||||
|
||||
if (bytes_read != sizeof(iso15_tag_t)) {
|
||||
PrintAndLogEx(FAILED, "Memory image is not matching tag structure.");
|
||||
free(tag);
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
@@ -1335,7 +1356,7 @@ static void print_blocks_15693(iso15_tag_t *tag, bool dense_output) {
|
||||
|
||||
for (int i = 0; i < tag->pagesCount; i++) {
|
||||
|
||||
uint8_t *blk = d + (i * blocksize);
|
||||
const uint8_t *blk = d + (i * blocksize);
|
||||
|
||||
// suppress repeating blocks, truncate as such that the first and last block with the same data is shown
|
||||
// but the blocks in between are replaced with a single line of "......" if dense_output is enabled
|
||||
@@ -1830,6 +1851,7 @@ static int CmdHF15Dump(const char *Cmd) {
|
||||
iso15_tag_t *tag = (iso15_tag_t *)calloc(1, sizeof(iso15_tag_t));
|
||||
if (tag == NULL) {
|
||||
PrintAndLogEx(FAILED, "failed to allocate memory");
|
||||
free(packet);
|
||||
return PM3_EMALLOC;
|
||||
};
|
||||
|
||||
@@ -1844,6 +1866,7 @@ static int CmdHF15Dump(const char *Cmd) {
|
||||
PrintAndLogEx(INFO, "Using scan mode");
|
||||
if (getUID(verbose, false, uid) != PM3_SUCCESS) {
|
||||
free(packet);
|
||||
free(tag);
|
||||
PrintAndLogEx(WARNING, "no tag found");
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
@@ -1873,18 +1896,27 @@ static int CmdHF15Dump(const char *Cmd) {
|
||||
PacketResponseNG resp;
|
||||
if (WaitForResponseTimeout(CMD_HF_ISO15693_COMMAND, &resp, 2000) == false) {
|
||||
PrintAndLogEx(DEBUG, "iso15693 timeout");
|
||||
free(packet);
|
||||
free(tag);
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
if (resp.length < 2) {
|
||||
PrintAndLogEx(WARNING, "iso15693 card doesn't answer to systeminfo command (%d)", resp.length);
|
||||
free(packet);
|
||||
free(tag);
|
||||
return PM3_EWRONGANSWER;
|
||||
}
|
||||
|
||||
uint8_t *d = resp.data.asBytes;
|
||||
uint8_t dCpt = 10;
|
||||
|
||||
ISO15_ERROR_HANDLING_CARD_RESPONSE(d, resp.length);
|
||||
int res = iso15_error_handling_card_response(d, resp.length);
|
||||
if (res != PM3_SUCCESS) {
|
||||
free(tag);
|
||||
free(packet);
|
||||
return res;
|
||||
}
|
||||
|
||||
memcpy(tag->uid, &d[2], 8);
|
||||
|
||||
@@ -1991,6 +2023,7 @@ static int CmdHF15Dump(const char *Cmd) {
|
||||
if (no_save) {
|
||||
PrintAndLogEx(INFO, "Called with no save option");
|
||||
PrintAndLogEx(NORMAL, "");
|
||||
free(tag);
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -2004,6 +2037,7 @@ static int CmdHF15Dump(const char *Cmd) {
|
||||
|
||||
pm3_save_dump(filename, (uint8_t *)tag, sizeof(iso15_tag_t), jsf15_v4);
|
||||
|
||||
free(tag);
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -2436,7 +2470,7 @@ static int CmdHF15Readblock(const char *Cmd) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int hf_15_write_blk(uint8_t *pm3flags, uint16_t flags, uint8_t *uid, bool fast, uint8_t blockno, uint8_t *data, uint8_t dlen) {
|
||||
static int hf_15_write_blk(const uint8_t *pm3flags, uint16_t flags, const uint8_t *uid, bool fast, uint8_t blockno, const uint8_t *data, uint8_t dlen) {
|
||||
|
||||
// request to be sent to device/card
|
||||
// 2 + 8 + 1 + (4|8) + 2
|
||||
@@ -2660,13 +2694,14 @@ static int CmdHF15Restore(const char *Cmd) {
|
||||
return res;
|
||||
}
|
||||
|
||||
if (bytes_read != sizeof(iso15_tag_t)) {
|
||||
PrintAndLogEx(FAILED, "Memory image is not matching tag structure.");
|
||||
if (bytes_read == 0) {
|
||||
PrintAndLogEx(FAILED, "Memory image empty.");
|
||||
free(tag);
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
if (bytes_read == 0) {
|
||||
PrintAndLogEx(FAILED, "Memory image empty.");
|
||||
|
||||
if (bytes_read != sizeof(iso15_tag_t)) {
|
||||
PrintAndLogEx(FAILED, "Memory image is not matching tag structure.");
|
||||
free(tag);
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
@@ -2694,7 +2729,7 @@ static int CmdHF15Restore(const char *Cmd) {
|
||||
size_t bytes = 0;
|
||||
uint16_t i = 0;
|
||||
uint8_t *data = calloc(tag->bytesPerPage, sizeof(uint8_t));
|
||||
uint32_t tried = 0;
|
||||
uint32_t tried;
|
||||
while (bytes < (tag->pagesCount * tag->bytesPerPage)) {
|
||||
|
||||
// copy over the data to the request
|
||||
@@ -3324,13 +3359,14 @@ static int CmdHF15View(const char *Cmd) {
|
||||
return res;
|
||||
}
|
||||
|
||||
if (bytes_read != sizeof(iso15_tag_t)) {
|
||||
PrintAndLogEx(FAILED, "Memory image is not matching tag structure.");
|
||||
if (bytes_read == 0) {
|
||||
PrintAndLogEx(FAILED, "Memory image empty.");
|
||||
free(tag);
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
if (bytes_read == 0) {
|
||||
PrintAndLogEx(FAILED, "Memory image empty.");
|
||||
|
||||
if (bytes_read != sizeof(iso15_tag_t)) {
|
||||
PrintAndLogEx(FAILED, "Memory image is not matching tag structure.");
|
||||
free(tag);
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
|
||||
@@ -312,13 +312,13 @@ static int CmdHFFelicaList(const char *Cmd) {
|
||||
|
||||
int read_felica_uid(bool loop, bool verbose) {
|
||||
|
||||
int res = PM3_SUCCESS;
|
||||
int res = PM3_ETIMEOUT;
|
||||
|
||||
do {
|
||||
clearCommandBuffer();
|
||||
SendCommandMIX(CMD_HF_FELICA_COMMAND, FELICA_CONNECT, 0, 0, NULL, 0);
|
||||
PacketResponseNG resp;
|
||||
if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) {
|
||||
if (WaitForResponseTimeout(CMD_ACK, &resp, 2500)) {
|
||||
|
||||
uint8_t status = resp.oldarg[0] & 0xFF;
|
||||
|
||||
@@ -342,7 +342,10 @@ int read_felica_uid(bool loop, bool verbose) {
|
||||
}
|
||||
PrintAndLogEx(SUCCESS, "IDm: " _GREEN_("%s"), sprint_hex_inrow(card.IDm, sizeof(card.IDm)));
|
||||
set_last_known_card(card);
|
||||
|
||||
res = PM3_SUCCESS;
|
||||
}
|
||||
|
||||
} while (loop && kbd_enter_pressed() == false);
|
||||
|
||||
DropField();
|
||||
|
||||
@@ -120,7 +120,7 @@ static int derive_app_key(uint8_t *uid, uint8_t *app_key) {
|
||||
}
|
||||
|
||||
// Might miss payload..
|
||||
static int diversify_mifare_key(uint8_t *uid, uint8_t *app_key) {
|
||||
static int diversify_mifare_key(const uint8_t *uid, uint8_t *app_key) {
|
||||
if (uid == NULL || app_key == NULL) {
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
@@ -152,7 +152,7 @@ static int diversify_mifare_key(uint8_t *uid, uint8_t *app_key) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int decrypt_card_sector(uint8_t *uid, uint8_t *sector_data, uint8_t len, uint8_t *plain) {
|
||||
static int decrypt_card_sector(uint8_t *uid, const uint8_t *sector_data, uint8_t len, uint8_t *plain) {
|
||||
if (uid == NULL || sector_data == NULL || plain == NULL) {
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
@@ -203,7 +203,7 @@ static int derive_mifare_key_b(uint8_t *uid, uint8_t *app_key) {
|
||||
return derive_mifare_key(uid, ICT_MIFARE_B_KEY, app_key);
|
||||
}
|
||||
|
||||
static int decrypt_card_file(uint8_t *card_file, uint8_t len, uint8_t *plain) {
|
||||
static int decrypt_card_file(const uint8_t *card_file, uint8_t len, uint8_t *plain) {
|
||||
if (card_file == NULL || plain == NULL) {
|
||||
return PM3_EINVARG;
|
||||
}
|
||||
@@ -211,7 +211,7 @@ static int decrypt_card_file(uint8_t *card_file, uint8_t len, uint8_t *plain) {
|
||||
uint8_t input[ICT_FILE_SIZE];
|
||||
memcpy(input, card_file, len);
|
||||
|
||||
uint8_t key[AES_KEY_LEN];
|
||||
uint8_t key[AES_KEY_LEN] = {0};
|
||||
// memcpy(key, ICT_DESFIRE_FILEKEY, AES_KEY_LEN);
|
||||
|
||||
uint8_t iv[16] = {0};
|
||||
@@ -230,7 +230,7 @@ static int decrypt_card_file(uint8_t *card_file, uint8_t len, uint8_t *plain) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int encrypt_card_file(uint8_t *card_file, uint8_t len, bool padding, uint8_t *enc) {
|
||||
static int encrypt_card_file(const uint8_t *card_file, uint8_t len, bool padding, uint8_t *enc) {
|
||||
|
||||
if (len > ICT_FILE_SIZE) {
|
||||
return PM3_EINVARG;
|
||||
@@ -243,7 +243,7 @@ static int encrypt_card_file(uint8_t *card_file, uint8_t len, bool padding, uint
|
||||
memset(input + len, 0x4C, 128 - len);
|
||||
}
|
||||
|
||||
uint8_t key[AES_KEY_LEN];
|
||||
uint8_t key[AES_KEY_LEN] = {0};
|
||||
// memcpy(key, ICT_DESFIRE_FILEKEY, AES_KEY_LEN);
|
||||
|
||||
uint8_t iv[16] = {0};
|
||||
@@ -262,7 +262,7 @@ static int encrypt_card_file(uint8_t *card_file, uint8_t len, bool padding, uint
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static void itc_decode_card_blob(uint8_t *data, uint8_t card_type) {
|
||||
static void itc_decode_card_blob(const uint8_t *data, uint8_t card_type) {
|
||||
if (data == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -4858,10 +4858,10 @@ static int DesfileReadFileAndPrint(DesfireContext_t *dctx,
|
||||
|
||||
if (verbose) {
|
||||
PrintAndLogEx(INFO, _CYAN_("File type:") " %s Option: %s comm mode: %s",
|
||||
GetDesfireFileType(fsettings.fileType),
|
||||
CLIGetOptionListStr(DesfireReadFileTypeOpts, filetype),
|
||||
CLIGetOptionListStr(DesfireCommunicationModeOpts, fsettings.commMode)
|
||||
);
|
||||
GetDesfireFileType(fsettings.fileType),
|
||||
CLIGetOptionListStr(DesfireReadFileTypeOpts, filetype),
|
||||
CLIGetOptionListStr(DesfireCommunicationModeOpts, fsettings.commMode)
|
||||
);
|
||||
}
|
||||
} else {
|
||||
PrintAndLogEx(WARNING, "GetFileSettings error. Can't get file type.");
|
||||
|
||||
@@ -3253,7 +3253,7 @@ int CmdHF14MfUTamper(const char *Cmd) {
|
||||
}
|
||||
}
|
||||
|
||||
if (enable | disable | lock_msg) {
|
||||
if (enable || disable || lock_msg) {
|
||||
|
||||
if (ul_select(&card) == false) {
|
||||
PrintAndLogEx(ERR, "Unable to select tag");
|
||||
|
||||
@@ -38,6 +38,7 @@
|
||||
|
||||
|
||||
// NTAG424 commands currently implemented
|
||||
// icenam: should be able to use 14a / msdes to annotate NTAG424 communications
|
||||
#define NTAG424_CMD_GET_FILE_SETTINGS 0xF5
|
||||
#define NTAG424_CMD_CHANGE_FILE_SETTINGS 0x5F
|
||||
#define NTAG424_CMD_CHANGE_KEY 0xC4
|
||||
@@ -280,7 +281,7 @@ static void ntag424_calc_receive_iv(ntag424_session_keys_t *session_keys, uint8_
|
||||
aes_encode(zero_iv, session_keys->encryption, iv_clear, out_ivc, 16);
|
||||
}
|
||||
|
||||
static void ntag424_calc_mac(ntag424_session_keys_t *session_keys, uint8_t command, uint8_t *data, uint8_t datalen, uint8_t *out_mac) {
|
||||
static void ntag424_calc_mac(const ntag424_session_keys_t *session_keys, uint8_t command, const uint8_t *data, uint8_t datalen, uint8_t *out_mac) {
|
||||
uint8_t mac_input_header[] = { command,
|
||||
(uint8_t)session_keys->command_counter, (uint8_t)(session_keys->command_counter >> 8),
|
||||
session_keys->ti[0], session_keys->ti[1], session_keys->ti[2], session_keys->ti[3]
|
||||
@@ -445,7 +446,7 @@ static int ntag424_get_file_settings(uint8_t fileno, ntag424_file_settings_t *se
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int ntag424_write_file_settings(uint8_t fileno, ntag424_file_settings_t *settings, ntag424_session_keys_t *session_keys) {
|
||||
static int ntag424_write_file_settings(uint8_t fileno, const ntag424_file_settings_t *settings, ntag424_session_keys_t *session_keys) {
|
||||
|
||||
// ------- Convert file settings to the format for writing
|
||||
file_settings_write_t write_settings = {
|
||||
@@ -807,7 +808,7 @@ static int ntag424_get_signature(uint8_t *signature_out) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int ntag424_change_key(uint8_t keyno, uint8_t *new_key, uint8_t *old_key, uint8_t version, ntag424_session_keys_t *session_keys) {
|
||||
static int ntag424_change_key(uint8_t keyno, const uint8_t *new_key, const uint8_t *old_key, uint8_t version, ntag424_session_keys_t *session_keys) {
|
||||
// -------- Calculate xor and crc
|
||||
uint8_t key[16] = {0};
|
||||
uint8_t crc[4] = {0};
|
||||
@@ -965,7 +966,7 @@ static int CmdHF_ntag424_auth(const char *Cmd) {
|
||||
};
|
||||
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
||||
|
||||
int keyno;
|
||||
int keyno = 0;
|
||||
uint8_t key[16] = {0};
|
||||
if (ntag424_cli_get_auth_information(ctx, 1, 2, &keyno, key) != PM3_SUCCESS) {
|
||||
CLIParserFree(ctx);
|
||||
@@ -1019,7 +1020,7 @@ static int CmdHF_ntag424_read(const char *Cmd) {
|
||||
|
||||
int fileno = arg_get_int(ctx, 1);
|
||||
|
||||
int keyno;
|
||||
int keyno = 0;
|
||||
uint8_t key[16] = {0};
|
||||
bool auth = (ntag424_cli_get_auth_information(ctx, 2, 3, &keyno, key) == PM3_SUCCESS);
|
||||
|
||||
@@ -1248,7 +1249,7 @@ static int CmdHF_ntag424_changefilesettings(const char *Cmd) {
|
||||
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
||||
int fileno = arg_get_int(ctx, 1);
|
||||
|
||||
int keyno;
|
||||
int keyno = 0;
|
||||
uint8_t key[16] = {0};
|
||||
|
||||
uint8_t has_options = 0;
|
||||
|
||||
@@ -42,7 +42,7 @@ const char *get_st_chip_model(uint8_t pc) {
|
||||
return "SRT512";
|
||||
case 0xC4:
|
||||
return "ST25TA64K";
|
||||
case 0xC5:
|
||||
case 0xC5:
|
||||
return "ST25TA16K";
|
||||
case 0xE2:
|
||||
return "ST25??? IKEA Rothult";
|
||||
|
||||
@@ -190,13 +190,13 @@ static int print_st25ta_signature(uint8_t *uid, uint8_t *signature) {
|
||||
}
|
||||
|
||||
static int st25ta_get_signature(uint8_t *signature) {
|
||||
/*
|
||||
/*
|
||||
hf 14a raw -sck 0200A4040007D276000085010100
|
||||
hf 14a raw -ck 0300A4000C020001
|
||||
hf 14a raw -c 02a2b000e020
|
||||
*/
|
||||
*/
|
||||
typedef struct {
|
||||
const char* apdu;
|
||||
const char *apdu;
|
||||
uint8_t apdulen;
|
||||
} transport_st25a_apdu_t;
|
||||
|
||||
@@ -211,7 +211,7 @@ static int st25ta_get_signature(uint8_t *signature) {
|
||||
bool activate_field = true;
|
||||
|
||||
for (uint8_t i = 0; i < ARRAYLEN(cmds); i++) {
|
||||
int res = ExchangeAPDU14a( (uint8_t*)cmds[i].apdu, cmds[i].apdulen, activate_field, true, resp, sizeof(resp), &resplen);
|
||||
int res = ExchangeAPDU14a((uint8_t *)cmds[i].apdu, cmds[i].apdulen, activate_field, true, resp, sizeof(resp), &resplen);
|
||||
if (res != PM3_SUCCESS) {
|
||||
DropField();
|
||||
return res;
|
||||
|
||||
+1
-1
@@ -1587,7 +1587,7 @@ out:
|
||||
|
||||
restore_bufferS32(saveState_gb, g_GraphBuffer);
|
||||
g_GridOffset = saveState_gb.offset;
|
||||
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
+151
-72
@@ -164,10 +164,18 @@ typedef struct _em4x70_cmd_input_verify_auth_t {
|
||||
ID48LIB_GRN grn;
|
||||
} em4x70_cmd_input_verify_auth_t;
|
||||
|
||||
static int CmdHelp(const char *Cmd);
|
||||
typedef struct _em4x70_cmd_input_calculate_t {
|
||||
ID48LIB_KEY key;
|
||||
ID48LIB_NONCE rn;
|
||||
} em4x70_cmd_input_calculate_t;
|
||||
typedef struct _em4x70_cmd_output_calculate_t {
|
||||
ID48LIB_FRN frn;
|
||||
ID48LIB_GRN grn;
|
||||
} em4x70_cmd_output_calculate_t;
|
||||
|
||||
|
||||
static void fill_buffer_prng_bytes(void *buffer, size_t byte_count) {
|
||||
if (byte_count <= 0) {
|
||||
if (byte_count == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -225,14 +233,10 @@ static int get_em4x70_info(const em4x70_cmd_input_info_t *opts, em4x70_tag_info_
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_INFO, &resp, TIMEOUT) == false) {
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
if (resp.status == PM3_SUCCESS) {
|
||||
memcpy(data_out, resp.data.asBytes, sizeof(em4x70_tag_info_t));
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
static int writeblock_em4x70(const em4x70_cmd_input_writeblock_t *opts, em4x70_tag_info_t *data_out) {
|
||||
@@ -251,14 +255,10 @@ static int writeblock_em4x70(const em4x70_cmd_input_writeblock_t *opts, em4x70_t
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_WRITE, &resp, TIMEOUT) == false) {
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
if (resp.status == PM3_SUCCESS) {
|
||||
memcpy(data_out, resp.data.asBytes, sizeof(em4x70_tag_info_t));
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
static int auth_em4x70(const em4x70_cmd_input_auth_t *opts, em4x70_cmd_output_auth_t *data_out) {
|
||||
@@ -276,20 +276,15 @@ static int auth_em4x70(const em4x70_cmd_input_auth_t *opts, em4x70_cmd_output_au
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_AUTH, &resp, TIMEOUT) == false) {
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
if (resp.status == PM3_SUCCESS) {
|
||||
// Response is 20-bit from tag
|
||||
|
||||
// HACKHACK -- It appears the byte order differs from what is expected?
|
||||
data_out->grn.grn[0] = resp.data.asBytes[2];
|
||||
data_out->grn.grn[1] = resp.data.asBytes[1];
|
||||
data_out->grn.grn[2] = resp.data.asBytes[0];
|
||||
//memcpy(data_out, &resp.data.asBytes[0], sizeof(ID48LIB_GRN));
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
static int setkey_em4x70(const em4x70_cmd_input_setkey_t *opts) {
|
||||
@@ -305,13 +300,7 @@ static int setkey_em4x70(const em4x70_cmd_input_setkey_t *opts) {
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_SETKEY, &resp, TIMEOUT) == false) {
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
static int brute_em4x70(const em4x70_cmd_input_brute_t *opts, em4x70_cmd_output_brute_t *data_out) {
|
||||
@@ -346,14 +335,10 @@ static int brute_em4x70(const em4x70_cmd_input_brute_t *opts, em4x70_cmd_output_
|
||||
}
|
||||
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_BRUTE, &resp, TIMEOUT)) {
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
if (resp.status == PM3_SUCCESS) {
|
||||
memcpy(data_out, resp.data.asBytes, sizeof(em4x70_cmd_output_brute_t));
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
// NOTE: It takes about 11 seconds per 0x0100 authentication attempts.
|
||||
@@ -383,15 +368,10 @@ static int unlock_em4x70(const em4x70_cmd_input_unlock_t *opts, em4x70_tag_info_
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_UNLOCK, &resp, TIMEOUT) == false) {
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
if (resp.status == PM3_SUCCESS) {
|
||||
memcpy(data_out, resp.data.asBytes, sizeof(em4x70_tag_info_t));
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
static int setpin_em4x70(const em4x70_cmd_input_setpin_t *opts, em4x70_tag_info_t *data_out) {
|
||||
@@ -408,14 +388,10 @@ static int setpin_em4x70(const em4x70_cmd_input_setpin_t *opts, em4x70_tag_info_
|
||||
if (WaitForResponseTimeout(CMD_LF_EM4X70_SETPIN, &resp, TIMEOUT) == false) {
|
||||
return PM3_ETIMEOUT;
|
||||
}
|
||||
|
||||
//iceman: prefer to have specific return code check.
|
||||
// like resp.status != PM3_SUCCESS if looking for failure
|
||||
if (resp.status) {
|
||||
if (resp.status == PM3_SUCCESS) {
|
||||
memcpy(data_out, resp.data.asBytes, sizeof(em4x70_tag_info_t));
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
return PM3_ESOFT;
|
||||
return resp.status;
|
||||
}
|
||||
|
||||
static int recover_em4x70(const em4x70_cmd_input_recover_t *opts, em4x70_cmd_output_recover_t *data_out) {
|
||||
@@ -463,23 +439,8 @@ static int verify_auth_em4x70(const em4x70_cmd_input_verify_auth_t *opts) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// used by `lf search` and `search`, this is a quick test for EM4x70 tag
|
||||
// In alignment with other tags implementations, this also dumps basic information
|
||||
// about the tag, if one is found.
|
||||
// Use helper function `get_em4x70_info()` if wanting to limit / avoid output.
|
||||
bool detect_4x70_block(void) {
|
||||
em4x70_tag_info_t info;
|
||||
em4x70_cmd_input_info_t opts = { 0 };
|
||||
|
||||
int result = get_em4x70_info(&opts, &info);
|
||||
|
||||
if (result == PM3_ETIMEOUT) { // consider removing this output?
|
||||
PrintAndLogEx(WARNING, "Timeout while waiting for reply.");
|
||||
}
|
||||
return result == PM3_SUCCESS;
|
||||
}
|
||||
|
||||
int CmdEM4x70Info(const char *Cmd) {
|
||||
static int CmdEM4x70Info(const char *Cmd) {
|
||||
|
||||
// invoke reading of a EM4x70 tag which has to be on the antenna because
|
||||
// decoding is done by the device (not on client side)
|
||||
@@ -519,7 +480,7 @@ int CmdEM4x70Info(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70Write(const char *Cmd) {
|
||||
static int CmdEM4x70Write(const char *Cmd) {
|
||||
|
||||
// write one block/word (16 bits) to the tag at given block address (0-15)
|
||||
CLIParserContext *ctx;
|
||||
@@ -571,7 +532,7 @@ int CmdEM4x70Write(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70Brute(const char *Cmd) {
|
||||
static int CmdEM4x70Brute(const char *Cmd) {
|
||||
|
||||
// From paper "Dismantling Megamos Crypto", Roel Verdult, Flavio D. Garcia and Barıs¸ Ege.
|
||||
// Partial Key-Update Attack (optimized version)
|
||||
@@ -581,8 +542,10 @@ int CmdEM4x70Brute(const char *Cmd) {
|
||||
"This attack does NOT write anything to the tag.\n"
|
||||
"Before starting this attack, 0000 must be written to the 16-bit key block: 'lf em 4x70 write -b 9 -d 0000'.\n"
|
||||
"After success, the 16-bit key block have to be restored with the key found: 'lf em 4x70 write -b 9 -d c0de'\n",
|
||||
"lf em 4x70 brute -b 9 --rnd 45F54ADA252AAC --frn 4866BB70 --> bruteforcing key bits k95...k80\n"
|
||||
);
|
||||
"lf em 4x70 brute -b 9 --rnd 45F54ADA252AAC --frn 4866BB70 --> bruteforcing key bits k95...k80 (pm3 test key)\n"
|
||||
"lf em 4x70 brute -b 8 --rnd 3FFE1FB6CC513F --frn F355F1A0 --> bruteforcing key bits k79...k64 (research paper key)\n"
|
||||
"lf em 4x70 brute -b 7 --rnd 7D5167003571F8 --frn 982DBCC0 --> bruteforcing key bits k63...k48 (autorecovery test key)\n"
|
||||
);
|
||||
void *argtable[] = {
|
||||
arg_param_begin,
|
||||
arg_lit0(NULL, "par", "Add parity bit when sending commands"),
|
||||
@@ -655,7 +618,7 @@ int CmdEM4x70Brute(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70Unlock(const char *Cmd) {
|
||||
static int CmdEM4x70Unlock(const char *Cmd) {
|
||||
|
||||
// send pin code to device, unlocking it for writing
|
||||
CLIParserContext *ctx;
|
||||
@@ -703,7 +666,7 @@ int CmdEM4x70Unlock(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70Auth(const char *Cmd) {
|
||||
static int CmdEM4x70Auth(const char *Cmd) {
|
||||
|
||||
// Authenticate transponder
|
||||
// Send 56-bit random number + pre-computed f(rnd, k) to transponder.
|
||||
@@ -716,6 +679,7 @@ int CmdEM4x70Auth(const char *Cmd) {
|
||||
" If F(RN) is correct based on the tag key, the tag will give a 20-bit response\n",
|
||||
"lf em 4x70 auth --rnd 45F54ADA252AAC --frn 4866BB70 --> (using pm3 test key)\n"
|
||||
"lf em 4x70 auth --rnd 3FFE1FB6CC513F --frn F355F1A0 --> (using research paper key)\n"
|
||||
"lf em 4x70 auth --rnd 7D5167003571F8 --frn 982DBCC0 --> (autorecovery test key)\n"
|
||||
);
|
||||
|
||||
void *argtable[] = {
|
||||
@@ -762,7 +726,7 @@ int CmdEM4x70Auth(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70SetPIN(const char *Cmd) {
|
||||
static int CmdEM4x70SetPIN(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "lf em 4x70 setpin",
|
||||
"Write new PIN\n",
|
||||
@@ -807,12 +771,13 @@ int CmdEM4x70SetPIN(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70SetKey(const char *Cmd) {
|
||||
static int CmdEM4x70SetKey(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "lf em 4x70 setkey",
|
||||
"Write new 96-bit key to tag\n",
|
||||
"lf em 4x70 setkey -k F32AA98CF5BE4ADFA6D3480B (pm3 test key)\n"
|
||||
"lf em 4x70 setkey -k A090A0A02080000000000000 (research paper key)\n"
|
||||
"lf em 4x70 setkey -k 022A028C02BE000102030405 (autorecovery test key)\n"
|
||||
);
|
||||
|
||||
void *argtable[] = {
|
||||
@@ -932,6 +897,7 @@ static int CmdEM4x70Recover_ParseArgs(const char *Cmd, em4x70_cmd_input_recover_
|
||||
,
|
||||
"lf em 4x70 recover --key F32AA98CF5BE --rnd 45F54ADA252AAC --frn 4866BB70 --grn 9BD180 (pm3 test key)\n"
|
||||
"lf em 4x70 recover --key A090A0A02080 --rnd 3FFE1FB6CC513F --frn F355F1A0 --grn 609D60 (research paper key)\n"
|
||||
"lf em 4x70 recover --key 022A028C02BE --rnd 7D5167003571F8 --frn 982DBCC0 --grn 36C0E0 (autorecovery test key)\n"
|
||||
);
|
||||
|
||||
void *argtable[] = {
|
||||
@@ -1003,7 +969,7 @@ static int CmdEM4x70Recover_ParseArgs(const char *Cmd, em4x70_cmd_input_recover_
|
||||
return result;
|
||||
}
|
||||
|
||||
int CmdEM4x70Recover(const char *Cmd) {
|
||||
static int CmdEM4x70Recover(const char *Cmd) {
|
||||
// From paper "Dismantling Megamos Crypto", Roel Verdult, Flavio D. Garcia and Barıs¸ Ege.
|
||||
// Partial Key-Update Attack -- final 48 bits (after optimized version gets k95..k48)
|
||||
em4x70_recovery_data_t recover_ctx = {0};
|
||||
@@ -1137,6 +1103,7 @@ static int CmdEM4x70AutoRecover_ParseArgs(const char *Cmd, em4x70_cmd_input_reco
|
||||
,
|
||||
"lf em 4x70 autorecover --rnd 45F54ADA252AAC --frn 4866BB70 --grn 9BD180 (pm3 test key)\n"
|
||||
"lf em 4x70 autorecover --rnd 3FFE1FB6CC513F --frn F355F1A0 --grn 609D60 (research paper key)\n"
|
||||
"lf em 4x70 autorecover --rnd 7D5167003571F8 --frn 982DBCC0 --grn 36C0E0 (autorecovery test key)\n"
|
||||
);
|
||||
|
||||
void *argtable[] = {
|
||||
@@ -1471,6 +1438,97 @@ static int CmdEM4x70AutoRecover(const char *Cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
static int CmdEM4x70Calc_ParseArgs(const char *Cmd, em4x70_cmd_input_calculate_t *out_results) {
|
||||
|
||||
memset(out_results, 0, sizeof(em4x70_cmd_input_calculate_t));
|
||||
|
||||
int result = PM3_SUCCESS;
|
||||
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(
|
||||
&ctx,
|
||||
"lf em 4x70 calc",
|
||||
"Calculates both the reader and tag challenge for a user-provided key and rnd.\n"
|
||||
,
|
||||
"lf em 4x70 calc --key F32AA98CF5BE4ADFA6D3480B --rnd 45F54ADA252AAC (pm3 test key)\n" // --frn 4866BB70 --grn 9BD180
|
||||
"lf em 4x70 calc --key A090A0A02080000000000000 --rnd 3FFE1FB6CC513F (research paper key)\n" // --frn F355F1A0 --grn 609D60
|
||||
"lf em 4x70 calc --key 022A028C02BE000102030405 --rnd 7D5167003571F8 (autorecovery test key)\n" // --frn 982DBCC0 --grn 36C0E0
|
||||
);
|
||||
void *argtable[] = {
|
||||
arg_param_begin,
|
||||
arg_str1(NULL, "key", "<hex>", "Key 96-bit as 12 hex bytes"),
|
||||
arg_str1(NULL, "rnd", "<hex>", "56-bit random value sent to tag for authentication"),
|
||||
arg_param_end
|
||||
};
|
||||
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
||||
int key_len = 0; // must be 12 bytes hex data
|
||||
int rnd_len = 0; // must be 7 bytes hex data
|
||||
|
||||
// These macros hide early function return on error ... including free'ing ctx.
|
||||
CLIGetHexWithReturn(ctx, 1, out_results->key.k, &key_len);
|
||||
CLIGetHexWithReturn(ctx, 2, out_results->rn.rn, &rnd_len);
|
||||
CLIParserFree(ctx);
|
||||
|
||||
if (key_len != 12) {
|
||||
PrintAndLogEx(FAILED, "Key length must be 12 bytes, got %d", key_len);
|
||||
result = PM3_EINVARG;
|
||||
}
|
||||
|
||||
if (rnd_len != 7) {
|
||||
PrintAndLogEx(FAILED, "Random number length must be 7 bytes, got %d", rnd_len);
|
||||
result = PM3_EINVARG;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static int CmdEM4x70Calc(const char *Cmd) {
|
||||
em4x70_cmd_input_calculate_t opts = {0};
|
||||
em4x70_cmd_output_calculate_t data = {0};
|
||||
|
||||
// 0. Parse the command line
|
||||
int result = CmdEM4x70Calc_ParseArgs(Cmd, &opts);
|
||||
if (PM3_SUCCESS != result) {
|
||||
return result;
|
||||
}
|
||||
|
||||
// There are no failure paths. All inputs are valid, and ID48LIB doesn't add any failure paths.
|
||||
id48lib_generator(&opts.key, &opts.rn, &data.frn, &data.grn);
|
||||
|
||||
char key_string[24 + 1] = {0};
|
||||
char rnd_string[14 + 1] = {0};
|
||||
char frn_string[ 8 + 1] = {0};
|
||||
char grn_string[ 6 + 1] = {0};
|
||||
if (true) {
|
||||
snprintf(
|
||||
key_string, 25,
|
||||
"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
|
||||
opts.key.k[ 0], opts.key.k[ 1], opts.key.k[ 2], opts.key.k[ 3],
|
||||
opts.key.k[ 4], opts.key.k[ 5], opts.key.k[ 6], opts.key.k[ 7],
|
||||
opts.key.k[ 8], opts.key.k[ 9], opts.key.k[10], opts.key.k[11]
|
||||
);
|
||||
snprintf(
|
||||
rnd_string, 15,
|
||||
"%02X%02X%02X%02X%02X%02X%02X",
|
||||
opts.rn.rn[0], opts.rn.rn[1], opts.rn.rn[2], opts.rn.rn[3], opts.rn.rn[4], opts.rn.rn[5], opts.rn.rn[6]
|
||||
);
|
||||
snprintf(
|
||||
frn_string, 9,
|
||||
"%02X%02X%02X%02X",
|
||||
data.frn.frn[0], data.frn.frn[1], data.frn.frn[2], data.frn.frn[3]
|
||||
);
|
||||
snprintf(
|
||||
grn_string, 7,
|
||||
"%02X%02X%02X",
|
||||
data.grn.grn[0], data.grn.grn[1], data.grn.grn[2]
|
||||
);
|
||||
}
|
||||
PrintAndLogEx(SUCCESS, "KEY: %s RND: %s FRN: " _GREEN_("%s") " GRN: " _GREEN_("%s"), key_string, rnd_string, frn_string, grn_string);
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
// Must be declared to be used in the table,
|
||||
// but cannot be defined yet because it uses the table.
|
||||
static int CmdHelp(const char *Cmd);
|
||||
|
||||
static command_t CommandTable[] = {
|
||||
{"help", CmdHelp, AlwaysAvailable, "This help"},
|
||||
@@ -1481,6 +1539,7 @@ static command_t CommandTable[] = {
|
||||
{"auth", CmdEM4x70Auth, IfPm3EM4x70, "Authenticate EM4x70"},
|
||||
{"setpin", CmdEM4x70SetPIN, IfPm3EM4x70, "Write PIN"},
|
||||
{"setkey", CmdEM4x70SetKey, IfPm3EM4x70, "Write key"},
|
||||
{"calc", CmdEM4x70Calc, AlwaysAvailable, "Calculate EM4x70 challenge and response"},
|
||||
{"recover", CmdEM4x70Recover, AlwaysAvailable, "Recover remaining key from partial key"},
|
||||
{"autorecover", CmdEM4x70AutoRecover, IfPm3EM4x70, "Recover entire key from writable tag"},
|
||||
{NULL, NULL, NULL, NULL}
|
||||
@@ -1492,7 +1551,27 @@ static int CmdHelp(const char *Cmd) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Only two functions need to be non-static:
|
||||
// * CmdLFEM4X70()
|
||||
// * detect_4x70_block()
|
||||
int CmdLFEM4X70(const char *Cmd) {
|
||||
clearCommandBuffer();
|
||||
return CmdsParse(CommandTable, Cmd);
|
||||
}
|
||||
|
||||
// used by `lf search` and `search`, this is a quick test for EM4x70 tag
|
||||
// In alignment with other tags implementations, this also dumps basic information
|
||||
// about the tag, if one is found.
|
||||
// Use helper function `get_em4x70_info()` if wanting to limit / avoid output.
|
||||
bool detect_4x70_block(void) {
|
||||
em4x70_tag_info_t info;
|
||||
em4x70_cmd_input_info_t opts = { 0 };
|
||||
|
||||
int result = get_em4x70_info(&opts, &info);
|
||||
|
||||
if (result == PM3_ETIMEOUT) { // consider removing this output?
|
||||
PrintAndLogEx(WARNING, "Timeout while waiting for reply.");
|
||||
}
|
||||
return result == PM3_SUCCESS;
|
||||
}
|
||||
@@ -24,14 +24,6 @@
|
||||
#define TIMEOUT 2000
|
||||
|
||||
int CmdLFEM4X70(const char *Cmd);
|
||||
int CmdEM4x70Info(const char *Cmd);
|
||||
int CmdEM4x70Write(const char *Cmd);
|
||||
int CmdEM4x70Brute(const char *Cmd);
|
||||
int CmdEM4x70Unlock(const char *Cmd);
|
||||
int CmdEM4x70Auth(const char *Cmd);
|
||||
int CmdEM4x70SetPIN(const char *Cmd);
|
||||
int CmdEM4x70SetKey(const char *Cmd);
|
||||
int CmdEM4x70Recover(const char *Cmd);
|
||||
|
||||
// for `lf search`:
|
||||
bool detect_4x70_block(void);
|
||||
|
||||
+76
-4
@@ -2167,6 +2167,77 @@ static int CmdLFHitag2Lookup(const char *Cmd) {
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
static int CmdLFHitag2Crack2(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "lf hitag lookup",
|
||||
"This command tries to recover 2048 bits of Hitag2 crypto stream data.\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") " - Crack2 (NrAR)");
|
||||
|
||||
uint64_t t1 = msclock();
|
||||
|
||||
PacketResponseNG resp;
|
||||
clearCommandBuffer();
|
||||
SendCommandNG(CMD_LF_HITAG2_CRACK_2, (uint8_t *) &packet, sizeof(packet));
|
||||
|
||||
// loop
|
||||
uint8_t attempt = 30;
|
||||
do {
|
||||
|
||||
PrintAndLogEx(INPLACE, "Attack 2 running...");
|
||||
fflush(stdout);
|
||||
|
||||
if (WaitForResponseTimeout(CMD_LF_HITAG2_CRACK_2, &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"));
|
||||
break;
|
||||
} else {
|
||||
PrintAndLogEx(NORMAL, " ( %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
|
||||
@@ -2285,9 +2356,9 @@ static uint64_t hitag2_verify_crypto_test_round(void) {
|
||||
|
||||
static int CmdLFHitag2Selftest(const char *Cmd) {
|
||||
CLIParserContext *ctx;
|
||||
CLIParserInit(&ctx, "lf hitag selftest",
|
||||
"Perform selftest of Hitag crypto engine",
|
||||
"lf hitag selftest\n"
|
||||
CLIParserInit(&ctx, "lf hitag test",
|
||||
"Perform self tests of Hitag crypto engine",
|
||||
"lf hitag test\n"
|
||||
);
|
||||
|
||||
void *argtable[] = {
|
||||
@@ -2324,7 +2395,7 @@ static command_t CommandTable[] = {
|
||||
{"list", CmdLFHitagList, AlwaysAvailable, "List Hitag trace history"},
|
||||
{"-----------", CmdHelp, IfPm3Hitag, "------------------------ " _CYAN_("General") " ------------------------"},
|
||||
{"info", CmdLFHitagInfo, IfPm3Hitag, "Hitag 2 tag information"},
|
||||
{"selftest", CmdLFHitag2Selftest, AlwaysAvailable, "Perform self test"},
|
||||
{"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"},
|
||||
@@ -2339,6 +2410,7 @@ static command_t CommandTable[] = {
|
||||
{"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"},
|
||||
|
||||
@@ -530,7 +530,7 @@ static int CmdLFNedapSim(const char *Cmd) {
|
||||
uint8_t data[16];
|
||||
NedapGen(sub_type, customer_code, id, is_long, data);
|
||||
|
||||
uint8_t bs[16 * 8];
|
||||
uint8_t bs[16 * 8] = {0};
|
||||
for (uint8_t i = 0; i < max; i++) {
|
||||
num_to_bytebits(data[i], 8, bs + i * 8);
|
||||
}
|
||||
|
||||
+18
-28
@@ -42,12 +42,12 @@ static bool is_last_record(uint16_t tracepos, uint16_t traceLen) {
|
||||
}
|
||||
|
||||
static bool next_record_is_response(uint16_t tracepos, uint8_t *trace) {
|
||||
tracelog_hdr_t *hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
const tracelog_hdr_t *hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
return (hdr->isResponse);
|
||||
}
|
||||
|
||||
static bool merge_topaz_reader_frames(uint32_t timestamp, uint32_t *duration, uint16_t *tracepos, uint16_t traceLen,
|
||||
uint8_t *trace, uint8_t *frame, uint8_t *topaz_reader_command, uint16_t *data_len) {
|
||||
uint8_t *trace, const uint8_t *frame, uint8_t *topaz_reader_command, uint16_t *data_len) {
|
||||
|
||||
#define MAX_TOPAZ_READER_CMD_LEN 16
|
||||
|
||||
@@ -59,7 +59,7 @@ static bool merge_topaz_reader_frames(uint32_t timestamp, uint32_t *duration, ui
|
||||
|
||||
while (!is_last_record(*tracepos, traceLen) && !next_record_is_response(*tracepos, trace)) {
|
||||
|
||||
tracelog_hdr_t *hdr = (tracelog_hdr_t *)(trace + *tracepos);
|
||||
const tracelog_hdr_t *hdr = (tracelog_hdr_t *)(trace + *tracepos);
|
||||
|
||||
*tracepos += TRACELOG_HDR_LEN + hdr->data_len;
|
||||
|
||||
@@ -93,7 +93,7 @@ static uint8_t calc_pos(const uint8_t *d) {
|
||||
|
||||
// Copy an existing buffer into client trace buffer
|
||||
// I think this is cleaner than further globalizing gs_trace, and may lend itself to more modularity later?
|
||||
bool ImportTraceBuffer(uint8_t *trace_src, uint16_t trace_len) {
|
||||
bool ImportTraceBuffer(const uint8_t *trace_src, uint16_t trace_len) {
|
||||
if (trace_len == 0 || trace_src == NULL) return (false);
|
||||
if (gs_trace) {
|
||||
free(gs_trace);
|
||||
@@ -218,7 +218,7 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
|
||||
switch (c) {
|
||||
case ICLASS_CMD_SELECT: {
|
||||
|
||||
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
const tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
tracepos += SKIP_TO_NEXT(next_hdr);
|
||||
if (next_hdr->data_len != 10) {
|
||||
break;
|
||||
@@ -231,7 +231,7 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
|
||||
|
||||
// get epurse
|
||||
if (frame[1] == 2 && data_len == 2) {
|
||||
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
const tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
tracepos += SKIP_TO_NEXT(next_hdr);
|
||||
if (next_hdr->data_len < 8) {
|
||||
break;
|
||||
@@ -641,25 +641,22 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
|
||||
|
||||
} else if (((protocol == PROTO_HITAG1) || (protocol == PROTO_HITAG2) || (protocol == PROTO_HITAGS))) {
|
||||
|
||||
// handle partial bytes. The parity array[0] is used to store number of left over bits from NBYTES
|
||||
// This part prints the number of bits in the trace entry for hitag.
|
||||
uint8_t nbits = parityBytes[0];
|
||||
if (j == 0) {
|
||||
|
||||
// handle partial bytes. The parity array[0] is used to store number of left over bits from NBYTES
|
||||
// This part prints the number of bits in the trace entry for hitag.
|
||||
uint8_t nbits = parityBytes[0];
|
||||
|
||||
// only apply this to lesser than one byte
|
||||
if (data_len == 1) {
|
||||
|
||||
if (nbits == 5) {
|
||||
snprintf(line[0], 120, "%2u: %02X ", nbits, frame[0] >> (8 - nbits));
|
||||
} else {
|
||||
snprintf(line[0], 120, "%2u: %02X ", nbits, frame[0] >> (8 - nbits));
|
||||
}
|
||||
snprintf(line[0], 120, "%2u: %02X ", nbits, frame[0] >> (8 - nbits));
|
||||
|
||||
} else {
|
||||
if (nbits == 0) {
|
||||
snprintf(line[0], 120, "%2u: %02X ", (data_len * 8), frame[0]);
|
||||
snprintf(line[0], 120, "%2u: %02X ", (uint16_t)(data_len * 8), frame[0]);
|
||||
} else {
|
||||
snprintf(line[0], 120, "%2u: %02X ", ((data_len - 1) * 8) + nbits, frame[0]);
|
||||
snprintf(line[0], 120, "%2u: %02X ", (uint16_t)(((data_len - 1) * 8) + nbits), frame[0]);
|
||||
}
|
||||
}
|
||||
offset = 4;
|
||||
@@ -676,7 +673,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
|
||||
|
||||
if (markCRCBytes && data_len > 2) {
|
||||
// CRC-command
|
||||
if (((protocol == PROTO_HITAG1) || (protocol == PROTO_HITAGS)) && (data_len > 1)) {
|
||||
if (((protocol == PROTO_HITAG1) || (protocol == PROTO_HITAGS))) {
|
||||
// Note that UID REQUEST response has no CRC, but we don't know
|
||||
// if the response we see is a UID
|
||||
char *pos1 = line[(data_len - 1) / 18] + (((data_len - 1) % 18) * 4) + offset - 1;
|
||||
@@ -989,7 +986,6 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
|
||||
// handle partial bytes. The parity array[0] is used to store number of left over bits from NBYTES
|
||||
// This part prints the number of bits in the trace entry for hitag.
|
||||
uint8_t nbits = parityBytes[0];
|
||||
|
||||
annotateHitag2(explanation, sizeof(explanation), ht2plain, n, nbits, hdr->isResponse, NULL, 0, true);
|
||||
|
||||
// iceman: colorise crc bytes here will need a refactor of code from above.
|
||||
@@ -1000,19 +996,13 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
|
||||
|
||||
// only apply this to lesser than one byte
|
||||
if (n == 1) {
|
||||
|
||||
if (nbits == 5) {
|
||||
snprintf(line[0], 120, "%2u: %02X ", nbits, ht2plain[0] >> (8 - nbits));
|
||||
} else {
|
||||
snprintf(line[0], 120, "%2u: %02X ", nbits, ht2plain[0] >> (8 - nbits));
|
||||
}
|
||||
|
||||
snprintf(line[0], 120, "%2u: %02X ", nbits, ht2plain[0] >> (8 - nbits));
|
||||
} else {
|
||||
|
||||
if (nbits == 0) {
|
||||
snprintf(line[0], 120, "%2u: %02X ", (n * 8), ht2plain[0]);
|
||||
snprintf(line[0], 120, "%2u: %02X ", (uint16_t)(n * 8), ht2plain[0]);
|
||||
} else {
|
||||
snprintf(line[0], 120, "%2u: %02X ", ((n - 1) * 8) + nbits, ht2plain[0]);
|
||||
snprintf(line[0], 120, "%2u: %02X ", (uint16_t)(((n - 1) * 8) + nbits), ht2plain[0]);
|
||||
}
|
||||
}
|
||||
offset = 4;
|
||||
@@ -1049,7 +1039,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
|
||||
|
||||
if (showWaitCycles && hdr->isResponse == false && next_record_is_response(tracepos, trace)) {
|
||||
|
||||
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
const tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
|
||||
|
||||
uint32_t time1 = end_of_transmission_timestamp - first_hdr->timestamp;
|
||||
uint32_t time2 = next_hdr->timestamp - first_hdr->timestamp;
|
||||
|
||||
@@ -24,6 +24,6 @@
|
||||
int CmdTrace(const char *Cmd);
|
||||
int CmdTraceList(const char *Cmd);
|
||||
int CmdTraceListAlias(const char *Cmd, const char *alias, const char *protocol);
|
||||
bool ImportTraceBuffer(uint8_t *trace_src, uint16_t trace_len);
|
||||
bool ImportTraceBuffer(const uint8_t *trace_src, uint16_t trace_len);
|
||||
|
||||
#endif
|
||||
+8
-8
@@ -87,7 +87,7 @@ void SendCommandBL(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, vo
|
||||
SendCommandOLD(cmd, arg0, arg1, arg2, data, len);
|
||||
}
|
||||
|
||||
void SendCommandOLD(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len) {
|
||||
void SendCommandOLD(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, const void *data, size_t len) {
|
||||
PacketCommandOLD c = {CMD_UNKNOWN, {0, 0, 0}, {{0}}};
|
||||
c.cmd = cmd;
|
||||
c.arg[0] = arg0;
|
||||
@@ -198,7 +198,7 @@ void SendCommandNG(uint16_t cmd, uint8_t *data, size_t len) {
|
||||
SendCommandNG_internal(cmd, data, len, true);
|
||||
}
|
||||
|
||||
void SendCommandMIX(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len) {
|
||||
void SendCommandMIX(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, const void *data, size_t len) {
|
||||
uint64_t arg[3] = {arg0, arg1, arg2};
|
||||
if (len > PM3_CMD_DATA_SIZE_MIX) {
|
||||
PrintAndLogEx(WARNING, "Sending %zu bytes of payload is too much for MIX frames, abort", len);
|
||||
@@ -228,7 +228,7 @@ void clearCommandBuffer(void) {
|
||||
* @brief storeCommand stores a USB command in a circular buffer
|
||||
* @param UC
|
||||
*/
|
||||
static void storeReply(PacketResponseNG *packet) {
|
||||
static void storeReply(const PacketResponseNG *packet) {
|
||||
pthread_mutex_lock(&rxBufferMutex);
|
||||
if ((cmd_head + 1) % CMD_BUFFER_SIZE == cmd_tail) {
|
||||
//If these two are equal, we're about to overwrite in the
|
||||
@@ -296,7 +296,7 @@ static void PacketResponseReceived(PacketResponseNG *packet) {
|
||||
uint16_t flag;
|
||||
uint8_t buf[PM3_CMD_DATA_SIZE - sizeof(uint16_t)];
|
||||
} PACKED;
|
||||
struct d *data = (struct d *)&packet->data.asBytes;
|
||||
const struct d *data = (struct d *)&packet->data.asBytes;
|
||||
len = packet->length - sizeof(data->flag);
|
||||
flag = data->flag;
|
||||
memcpy(s, data->buf, len);
|
||||
@@ -350,7 +350,7 @@ static void PacketResponseReceived(PacketResponseNG *packet) {
|
||||
// When communication thread is dead, start up and try to start it again
|
||||
void *uart_reconnect(void *targ) {
|
||||
|
||||
communication_arg_t *connection = (communication_arg_t *)targ;
|
||||
const communication_arg_t *connection = (communication_arg_t *)targ;
|
||||
|
||||
#if defined(__MACH__) && defined(__APPLE__)
|
||||
disableAppNap("Proxmark3 polling UART");
|
||||
@@ -405,7 +405,7 @@ __attribute__((force_align_arg_pointer))
|
||||
#endif
|
||||
#endif
|
||||
*uart_communication(void *targ) {
|
||||
communication_arg_t *connection = (communication_arg_t *)targ;
|
||||
const communication_arg_t *connection = (communication_arg_t *)targ;
|
||||
uint32_t rxlen;
|
||||
bool commfailed = false;
|
||||
PacketResponseNG rx;
|
||||
@@ -686,7 +686,7 @@ bool IsCommunicationThreadDead(void) {
|
||||
|
||||
bool SetCommunicationReceiveMode(bool isRawMode) {
|
||||
if (isRawMode) {
|
||||
uint8_t *buffer = __atomic_load_n(&comm_raw_data, __ATOMIC_SEQ_CST);
|
||||
const uint8_t *buffer = __atomic_load_n(&comm_raw_data, __ATOMIC_SEQ_CST);
|
||||
if (buffer == NULL) {
|
||||
PrintAndLogEx(ERR, "Buffer for raw data is not set");
|
||||
return false;
|
||||
@@ -850,7 +850,7 @@ int TestProxmark(pm3_device_t *dev) {
|
||||
return PM3_EDEVNOTSUPP;
|
||||
}
|
||||
|
||||
memcpy(&g_pm3_capabilities, resp.data.asBytes, MIN(sizeof(capabilities_t), resp.length));
|
||||
memcpy(&g_pm3_capabilities, resp.data.asBytes, sizeof(capabilities_t));
|
||||
g_conn.send_via_fpc_usart = g_pm3_capabilities.via_fpc;
|
||||
g_conn.uart_speed = g_pm3_capabilities.baudrate;
|
||||
|
||||
|
||||
+2
-2
@@ -96,9 +96,9 @@ void *uart_reconnect(void *targ);
|
||||
|
||||
void *uart_receiver(void *targ);
|
||||
void SendCommandBL(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len);
|
||||
void SendCommandOLD(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len);
|
||||
void SendCommandOLD(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, const void *data, size_t len);
|
||||
void SendCommandNG(uint16_t cmd, uint8_t *data, size_t len);
|
||||
void SendCommandMIX(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len);
|
||||
void SendCommandMIX(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, const void *data, size_t len);
|
||||
void clearCommandBuffer(void);
|
||||
|
||||
#define FLASHMODE_SPEED 460800
|
||||
|
||||
@@ -292,7 +292,7 @@ static int emv_parse_track1(const uint8_t *d, size_t n, bool verbose) {
|
||||
// decoder
|
||||
char *tmp = str_ndup((const char *)d, n);
|
||||
uint8_t i = 0;
|
||||
char delim[2] = "^";
|
||||
const char delim[2] = "^";
|
||||
char *token = strtok(tmp, delim);
|
||||
while (token != NULL) {
|
||||
|
||||
|
||||
@@ -747,7 +747,7 @@ out:
|
||||
int saveFileJSONroot(const char *preferredName, void *root, size_t flags, bool verbose) {
|
||||
return saveFileJSONrootEx(preferredName, root, flags, verbose, false);
|
||||
}
|
||||
int saveFileJSONrootEx(const char *preferredName, void *root, size_t flags, bool verbose, bool overwrite) {
|
||||
int saveFileJSONrootEx(const char *preferredName, const void *root, size_t flags, bool verbose, bool overwrite) {
|
||||
if (root == NULL)
|
||||
return PM3_EINVARG;
|
||||
|
||||
@@ -863,7 +863,7 @@ out:
|
||||
}
|
||||
|
||||
// key file dump
|
||||
int createMfcKeyDump(const char *preferredName, uint8_t sectorsCnt, sector_t *e_sector) {
|
||||
int createMfcKeyDump(const char *preferredName, uint8_t sectorsCnt, const sector_t *e_sector) {
|
||||
|
||||
if (e_sector == NULL) return PM3_EINVARG;
|
||||
|
||||
@@ -1743,7 +1743,7 @@ int loadFileJSONex(const char *preferredName, void *data, size_t maxdatalen, siz
|
||||
goto out;
|
||||
}
|
||||
|
||||
snprintf(blocks, sizeof(blocks), "$.blocks.%d", i);
|
||||
snprintf(blocks, sizeof(blocks), "$.blocks.%u", i);
|
||||
JsonLoadBufAsHex(root, blocks, &tag->data[sptr], 4, &len);
|
||||
if (load_file_sanity(ctype, tag->bytesPerPage, i, len) == false) {
|
||||
break;
|
||||
@@ -1790,7 +1790,7 @@ int loadFileJSONex(const char *preferredName, void *data, size_t maxdatalen, siz
|
||||
goto out;
|
||||
}
|
||||
|
||||
snprintf(blocks, sizeof(blocks), "$.blocks.%d", i);
|
||||
snprintf(blocks, sizeof(blocks), "$.blocks.%u", i);
|
||||
JsonLoadBufAsHex(root, blocks, &tag->data[sptr], 8, &len);
|
||||
if (load_file_sanity(ctype, tag->bytesPerPage, i, len) == false) {
|
||||
break;
|
||||
@@ -2426,7 +2426,7 @@ mfu_df_e detect_mfu_dump_format(uint8_t **dump, bool verbose) {
|
||||
|
||||
// detect plain
|
||||
if (retval == MFU_DF_UNKNOWN) {
|
||||
uint8_t *plain = *dump;
|
||||
const uint8_t *plain = *dump;
|
||||
bcc0 = ct ^ plain[0] ^ plain[1] ^ plain[2];
|
||||
bcc1 = plain[4] ^ plain[5] ^ plain[6] ^ plain[7];
|
||||
if ((bcc0 == plain[3]) && (bcc1 == plain[8])) {
|
||||
|
||||
@@ -107,8 +107,8 @@ int fileExists(const char *filename);
|
||||
bool setDefaultPath(savePaths_t pathIndex, const char *path);
|
||||
|
||||
char *newfilenamemcopy(const char *preferredName, const char *suffix);
|
||||
char *newfilenamemcopyEx(const char *preferredName, const char *suffix, savePaths_t save_path);
|
||||
void truncate_filename(char *fn, uint16_t len);
|
||||
char *newfilenamemcopyEx(const char *preferredName, const char *suffix, savePaths_t e_save_path);
|
||||
void truncate_filename(char *fn, uint16_t maxlen);
|
||||
|
||||
|
||||
/**
|
||||
@@ -138,7 +138,7 @@ int saveFile(const char *preferredName, const char *suffix, const void *data, si
|
||||
int saveFileJSON(const char *preferredName, JSONFileType ftype, uint8_t *data, size_t datalen, void (*callback)(json_t *));
|
||||
int saveFileJSONex(const char *preferredName, JSONFileType ftype, uint8_t *data, size_t datalen, bool verbose, void (*callback)(json_t *), savePaths_t e_save_path);
|
||||
int saveFileJSONroot(const char *preferredName, void *root, size_t flags, bool verbose);
|
||||
int saveFileJSONrootEx(const char *preferredName, void *root, size_t flags, bool verbose, bool overwrite);
|
||||
int saveFileJSONrootEx(const char *preferredName, const void *root, size_t flags, bool verbose, bool overwrite);
|
||||
/** STUB
|
||||
* @brief Utility function to save WAVE data to a file. This method takes a preferred name, but if that
|
||||
* file already exists, it tries with another name until it finds something suitable.
|
||||
@@ -171,7 +171,7 @@ int saveFilePM3(const char *preferredName, int *data, size_t datalen);
|
||||
* @param e_sector the keys in question
|
||||
* @return 0 for ok, 1 for failz
|
||||
*/
|
||||
int createMfcKeyDump(const char *preferredName, uint8_t sectorsCnt, sector_t *e_sector);
|
||||
int createMfcKeyDump(const char *preferredName, uint8_t sectorsCnt, const sector_t *e_sector);
|
||||
|
||||
/**
|
||||
* @brief Utility function to load data from a binary file. This method takes a preferred name.
|
||||
|
||||
+54
-10
@@ -32,6 +32,9 @@ int32_t g_OverlayBuffer[MAX_GRAPH_TRACE_LEN];
|
||||
bool g_useOverlays = false;
|
||||
size_t g_GraphTraceLen;
|
||||
buffer_savestate_t g_saveState_gb;
|
||||
marker_t g_MarkerA, g_MarkerB, g_MarkerC, g_MarkerD;
|
||||
marker_t *g_TempMarkers;
|
||||
uint8_t g_TempMarkerSize = 0;
|
||||
|
||||
/* write a manchester bit to the graph
|
||||
*/
|
||||
@@ -124,7 +127,7 @@ size_t getFromGraphBuffer(uint8_t *dest) {
|
||||
}
|
||||
|
||||
size_t getFromGraphBufferEx(uint8_t *dest, size_t maxLen) {
|
||||
if (dest == NULL){
|
||||
if (dest == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -465,9 +468,50 @@ bool fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, int *firstClockEdge) {
|
||||
return true;
|
||||
}
|
||||
|
||||
void add_temporary_marker(uint32_t position, const char *label) {
|
||||
if (g_TempMarkerSize == 0) { //Initialize the marker array
|
||||
g_TempMarkers = (marker_t *)calloc(1, sizeof(marker_t));
|
||||
} else { //add more space to the marker array using realloc()
|
||||
marker_t *temp = (marker_t *)realloc(g_TempMarkers, ((g_TempMarkerSize + 1) * sizeof(marker_t)));
|
||||
|
||||
if (temp == NULL) { //Unable to reallocate memory for a new marker
|
||||
PrintAndLogEx(FAILED, "Unable to allocate memory for a new temporary marker!");
|
||||
free(temp);
|
||||
return;
|
||||
} else {
|
||||
//Set g_TempMarkers to the new pointer
|
||||
g_TempMarkers = temp;
|
||||
}
|
||||
}
|
||||
|
||||
g_TempMarkers[g_TempMarkerSize].pos = position;
|
||||
|
||||
char *markerLabel = (char *)calloc(1, strlen(label) + 1);
|
||||
strcpy(markerLabel, label);
|
||||
|
||||
if (strlen(markerLabel) > 30) {
|
||||
PrintAndLogEx(WARNING, "Label for temporary marker too long! Trunicating...");
|
||||
markerLabel[30] = '\0';
|
||||
}
|
||||
|
||||
strncpy(g_TempMarkers[g_TempMarkerSize].label, markerLabel, 30);
|
||||
g_TempMarkerSize++;
|
||||
|
||||
memset(markerLabel, 0x00, strlen(label));
|
||||
free(markerLabel);
|
||||
}
|
||||
|
||||
void remove_temporary_markers(void) {
|
||||
if (g_TempMarkerSize == 0) return;
|
||||
|
||||
memset(g_TempMarkers, 0x00, (g_TempMarkerSize * sizeof(marker_t)));
|
||||
free(g_TempMarkers);
|
||||
g_TempMarkerSize = 0;
|
||||
}
|
||||
|
||||
buffer_savestate_t save_buffer32(uint32_t *src, size_t length) {
|
||||
//calloc the memory needed
|
||||
uint32_t* savedBuffer = (uint32_t*)calloc(length, sizeof(uint32_t));
|
||||
uint32_t *savedBuffer = (uint32_t *)calloc(length, sizeof(uint32_t));
|
||||
|
||||
//Make a copy of the source buffer
|
||||
memcpy(savedBuffer, src, (length * sizeof(uint32_t)));
|
||||
@@ -484,7 +528,7 @@ buffer_savestate_t save_buffer32(uint32_t *src, size_t length) {
|
||||
|
||||
buffer_savestate_t save_bufferS32(int32_t *src, size_t length) {
|
||||
//calloc the memory needed
|
||||
uint32_t* savedBuffer = (uint32_t*)calloc(length, (sizeof(uint32_t)));
|
||||
uint32_t *savedBuffer = (uint32_t *)calloc(length, (sizeof(uint32_t)));
|
||||
|
||||
//Make a copy of the source buffer
|
||||
memcpy(savedBuffer, src, (length * sizeof(uint32_t)));
|
||||
@@ -513,15 +557,15 @@ buffer_savestate_t save_buffer8(uint8_t *src, size_t length) {
|
||||
}
|
||||
|
||||
// calloc the memory needed
|
||||
uint32_t* savedBuffer = (uint32_t*)calloc(buffSize, sizeof(uint32_t));
|
||||
uint32_t *savedBuffer = (uint32_t *)calloc(buffSize, sizeof(uint32_t));
|
||||
size_t index = 0;
|
||||
|
||||
// Pack the source array into the backing array
|
||||
for(size_t i = 0; i < length; i += 4) {
|
||||
for (size_t i = 0; i < length; i += 4) {
|
||||
savedBuffer[index] = MemLeToUint4byte(src + i);
|
||||
index++;
|
||||
}
|
||||
|
||||
|
||||
buffer_savestate_t bst = {
|
||||
.type = sizeof(uint8_t),
|
||||
.bufferSize = buffSize,
|
||||
@@ -533,7 +577,7 @@ buffer_savestate_t save_buffer8(uint8_t *src, size_t length) {
|
||||
}
|
||||
|
||||
size_t restore_buffer32(buffer_savestate_t saveState, uint32_t *dest) {
|
||||
if(saveState.type != sizeof(uint32_t)) {
|
||||
if (saveState.type != sizeof(uint32_t)) {
|
||||
PrintAndLogEx(WARNING, "Invalid Save State type! Expected uint32_t!");
|
||||
PrintAndLogEx(WARNING, "Buffer not modified!\n");
|
||||
return 0;
|
||||
@@ -545,7 +589,7 @@ size_t restore_buffer32(buffer_savestate_t saveState, uint32_t *dest) {
|
||||
}
|
||||
|
||||
size_t restore_bufferS32(buffer_savestate_t saveState, int32_t *dest) {
|
||||
if(saveState.type != (sizeof(int32_t) >> 8)) {
|
||||
if (saveState.type != (sizeof(int32_t) >> 8)) {
|
||||
PrintAndLogEx(WARNING, "Invalid Save State type! Expected int32_t");
|
||||
PrintAndLogEx(WARNING, "Buffer not modified!\n");
|
||||
return 0;
|
||||
@@ -557,7 +601,7 @@ size_t restore_bufferS32(buffer_savestate_t saveState, int32_t *dest) {
|
||||
}
|
||||
|
||||
size_t restore_buffer8(buffer_savestate_t saveState, uint8_t *dest) {
|
||||
if(saveState.type != sizeof(uint8_t)) {
|
||||
if (saveState.type != sizeof(uint8_t)) {
|
||||
PrintAndLogEx(WARNING, "Invalid Save State type! Expected uint8_t!");
|
||||
PrintAndLogEx(WARNING, "Buffer not modified!\n");
|
||||
return 0;
|
||||
@@ -567,7 +611,7 @@ size_t restore_buffer8(buffer_savestate_t saveState, uint8_t *dest) {
|
||||
size_t length = ((saveState.bufferSize * 4) - saveState.padding);
|
||||
|
||||
// Unpack the array
|
||||
for(size_t i = 0; i < saveState.bufferSize; i++) {
|
||||
for (size_t i = 0; i < saveState.bufferSize; i++) {
|
||||
dest[index++] = saveState.buffer[i];
|
||||
if(index == length) break;
|
||||
dest[index++] = (saveState.buffer[i] >> 8) & 0xFF;
|
||||
|
||||
@@ -34,6 +34,11 @@ typedef struct {
|
||||
uint32_t clock; // (optional) Clock data for the buffer
|
||||
} buffer_savestate_t;
|
||||
|
||||
typedef struct {
|
||||
uint32_t pos;
|
||||
char label[30];
|
||||
} marker_t;
|
||||
|
||||
void AppendGraph(bool redraw, uint16_t clock, int bit);
|
||||
size_t ClearGraph(bool redraw);
|
||||
bool HasGraphData(void);
|
||||
@@ -52,6 +57,9 @@ int GetNrzClock(const char *str, bool verbose);
|
||||
int GetFskClock(const char *str, bool verbose);
|
||||
bool fskClocks(uint8_t *fc1, uint8_t *fc2, uint8_t *rf1, int *firstClockEdge);
|
||||
|
||||
extern void add_temporary_marker(uint32_t position, const char *label);
|
||||
extern void remove_temporary_markers(void);
|
||||
|
||||
buffer_savestate_t save_buffer32(uint32_t *src, size_t length);
|
||||
buffer_savestate_t save_bufferS32(int32_t *src, size_t length);
|
||||
buffer_savestate_t save_buffer8(uint8_t *src, size_t length);
|
||||
@@ -69,6 +77,10 @@ extern int32_t g_OverlayBuffer[MAX_GRAPH_TRACE_LEN];
|
||||
extern bool g_useOverlays;
|
||||
extern size_t g_GraphTraceLen;
|
||||
|
||||
extern marker_t g_MarkerA, g_MarkerB, g_MarkerC, g_MarkerD;
|
||||
extern marker_t *g_TempMarkers;
|
||||
extern uint8_t g_TempMarkerSize;
|
||||
|
||||
extern double g_GridOffset;
|
||||
|
||||
extern buffer_savestate_t g_saveState_gb;
|
||||
|
||||
@@ -158,7 +158,7 @@ Definition 14. Define the rotate key function rk : (F 82 ) 8 × N → (F 82 ) 8
|
||||
rk(x [0] . . . x [7] , 0) = x [0] . . . x [7]
|
||||
rk(x [0] . . . x [7] , n + 1) = rk(rl(x [0] ) . . . rl(x [7] ), n)
|
||||
**/
|
||||
static void rk(uint8_t *key, uint8_t n, uint8_t *outp_key) {
|
||||
static void rk(const uint8_t *key, uint8_t n, uint8_t *outp_key) {
|
||||
memcpy(outp_key, key, 8);
|
||||
while (n-- > 0) {
|
||||
outp_key[0] = rl(outp_key[0]);
|
||||
|
||||
@@ -203,7 +203,7 @@ int CalculateMAC(mf4Session_t *mf4session, MACType_t mtype, uint8_t blockNum, ui
|
||||
return aes_cmac8(NULL, mf4session->Kmac, macdata, mac, macdatalen);
|
||||
}
|
||||
|
||||
int MifareAuth4(mf4Session_t *mf4session, uint8_t *keyn, uint8_t *key, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode) {
|
||||
int MifareAuth4(mf4Session_t *mf4session, const uint8_t *keyn, uint8_t *key, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode) {
|
||||
uint8_t data[257] = {0};
|
||||
int datalen = 0;
|
||||
|
||||
@@ -375,7 +375,7 @@ static int intExchangeRAW14aPlus(uint8_t *datain, int datainlen, bool activateFi
|
||||
return res;
|
||||
}
|
||||
|
||||
int MFPWritePerso(uint8_t *keyNum, uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
int MFPWritePerso(const uint8_t *keyNum, const uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen) {
|
||||
uint8_t rcmd[3 + 16] = {0xa8, keyNum[1], keyNum[0], 0x00};
|
||||
memmove(&rcmd[3], key, 16);
|
||||
|
||||
@@ -432,7 +432,7 @@ int MFPReadBlock(mf4Session_t *mf4session, bool plain, bool nomaccmd, bool nomac
|
||||
return PM3_SUCCESS;
|
||||
}
|
||||
|
||||
int MFPWriteBlock(mf4Session_t *mf4session, bool plain, bool nomacres, uint8_t blockNum, uint8_t blockHdr, uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac) {
|
||||
int MFPWriteBlock(mf4Session_t *mf4session, bool plain, bool nomacres, uint8_t blockNum, uint8_t blockHdr, const uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac) {
|
||||
int cmdb = 0xA1;
|
||||
if (nomacres) {
|
||||
cmdb = cmdb ^ 0x01; // If we do not want MAC in reply, remove 0x01
|
||||
|
||||
@@ -20,6 +20,7 @@
|
||||
#define MIFARE4_H
|
||||
|
||||
#include "common.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct {
|
||||
bool Authenticated;
|
||||
@@ -59,12 +60,12 @@ void mfpSetVerboseMode(bool verbose);
|
||||
const char *mfpGetErrorDescription(uint8_t errorCode);
|
||||
|
||||
int CalculateMAC(mf4Session_t *mf4session, MACType_t mtype, uint8_t blockNum, uint8_t blockCount, uint8_t *data, int datalen, uint8_t *mac, bool verbose);
|
||||
int MifareAuth4(mf4Session_t *mf4session, uint8_t *keyn, uint8_t *key, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode);
|
||||
int MifareAuth4(mf4Session_t *mf4session, const uint8_t *keyn, uint8_t *key, bool activateField, bool leaveSignalON, bool dropFieldIfError, bool verbose, bool silentMode);
|
||||
|
||||
int MFPWritePerso(uint8_t *keyNum, uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
int MFPWritePerso(const uint8_t *keyNum, const uint8_t *key, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
int MFPCommitPerso(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
int MFPReadBlock(mf4Session_t *mf4session, bool plain, bool maccmd, bool macres, uint8_t blockNum, uint8_t blockCount, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
|
||||
int MFPWriteBlock(mf4Session_t *mf4session, bool plain, bool nomacres, uint8_t blockNum, uint8_t blockHdr, uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
|
||||
int MFPReadBlock(mf4Session_t *mf4session, bool plain, bool nomaccmd, bool nomacres, uint8_t blockNum, uint8_t blockCount, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
|
||||
int MFPWriteBlock(mf4Session_t *mf4session, bool plain, bool nomacres, uint8_t blockNum, uint8_t blockHdr, const uint8_t *data, bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen, uint8_t *mac);
|
||||
int mfpReadSector(uint8_t sectorNo, uint8_t keyType, uint8_t *key, uint8_t *dataout, bool verbose);
|
||||
|
||||
int MFPGetSignature(bool activateField, bool leaveSignalON, uint8_t *dataout, int maxdataoutlen, int *dataoutlen);
|
||||
|
||||
@@ -118,6 +118,9 @@ const static vocabulary_t vocabulary[] = {
|
||||
{ 1, "data diff" },
|
||||
{ 0, "data hexsamples" },
|
||||
{ 0, "data samples" },
|
||||
{ 0, "data test_ss8" },
|
||||
{ 0, "data test_ss32" },
|
||||
{ 0, "data test_ss32s" },
|
||||
{ 1, "emv help" },
|
||||
{ 1, "emv list" },
|
||||
{ 1, "emv test" },
|
||||
@@ -170,6 +173,8 @@ const static vocabulary_t vocabulary[] = {
|
||||
{ 0, "hf 14b wrbl" },
|
||||
{ 1, "hf 14b view" },
|
||||
{ 1, "hf 14b valid" },
|
||||
{ 0, "hf 14b calypso" },
|
||||
{ 0, "hf 14b mobib" },
|
||||
{ 1, "hf 15 help" },
|
||||
{ 1, "hf 15 list" },
|
||||
{ 1, "hf 15 demod" },
|
||||
@@ -645,7 +650,7 @@ const static vocabulary_t vocabulary[] = {
|
||||
{ 1, "lf hitag help" },
|
||||
{ 1, "lf hitag list" },
|
||||
{ 0, "lf hitag info" },
|
||||
{ 1, "lf hitag selftest" },
|
||||
{ 1, "lf hitag test" },
|
||||
{ 0, "lf hitag dump" },
|
||||
{ 0, "lf hitag read" },
|
||||
{ 0, "lf hitag sniff" },
|
||||
@@ -655,6 +660,7 @@ const static vocabulary_t vocabulary[] = {
|
||||
{ 0, "lf hitag eview" },
|
||||
{ 0, "lf hitag sim" },
|
||||
{ 0, "lf hitag cc" },
|
||||
{ 0, "lf hitag crack2" },
|
||||
{ 0, "lf hitag chk" },
|
||||
{ 1, "lf hitag lookup" },
|
||||
{ 0, "lf hitag ta" },
|
||||
|
||||
@@ -24,9 +24,6 @@
|
||||
#include "ui.h" // for prints
|
||||
|
||||
static ProxGuiQT *gui = NULL;
|
||||
marker_t g_MarkerA, g_MarkerB, g_MarkerC, g_MarkerD;
|
||||
marker_t *g_TempMarkers;
|
||||
uint8_t g_TempMarkerSize = 0;
|
||||
static WorkerThread *main_loop_thread = NULL;
|
||||
|
||||
WorkerThread::WorkerThread(char *script_cmds_file, char *script_cmd, bool stayInCommandLoop) : script_cmds_file(script_cmds_file), script_cmd(script_cmd), stayInCommandLoop(stayInCommandLoop) {
|
||||
@@ -137,47 +134,6 @@ extern "C" void InitGraphics(int argc, char **argv, char *script_cmds_file, char
|
||||
gui = new ProxGuiQT(argc, argv, main_loop_thread);
|
||||
}
|
||||
|
||||
void add_temporary_marker(uint32_t position, const char *label) {
|
||||
if (g_TempMarkerSize == 0) { //Initialize the marker array
|
||||
g_TempMarkers = (marker_t *)calloc(1, sizeof(marker_t));
|
||||
} else { //add more space to the marker array using realloc()
|
||||
marker_t *temp = (marker_t *)realloc(g_TempMarkers, ((g_TempMarkerSize + 1) * sizeof(marker_t)));
|
||||
|
||||
if (temp == NULL) { //Unable to reallocate memory for a new marker
|
||||
PrintAndLogEx(FAILED, "Unable to allocate memory for a new temporary marker!");
|
||||
free(temp);
|
||||
return;
|
||||
} else {
|
||||
//Set g_TempMarkers to the new pointer
|
||||
g_TempMarkers = temp;
|
||||
}
|
||||
}
|
||||
|
||||
g_TempMarkers[g_TempMarkerSize].pos = position;
|
||||
|
||||
char *markerLabel = (char *)calloc(1, strlen(label) + 1);
|
||||
strcpy(markerLabel, label);
|
||||
|
||||
if (strlen(markerLabel) > 30) {
|
||||
PrintAndLogEx(WARNING, "Label for temporary marker too long! Trunicating...");
|
||||
markerLabel[30] = '\0';
|
||||
}
|
||||
|
||||
strncpy(g_TempMarkers[g_TempMarkerSize].label, markerLabel, 30);
|
||||
g_TempMarkerSize++;
|
||||
|
||||
memset(markerLabel, 0x00, strlen(label));
|
||||
free(markerLabel);
|
||||
}
|
||||
|
||||
void remove_temporary_markers(void) {
|
||||
if (g_TempMarkerSize == 0) return;
|
||||
|
||||
memset(g_TempMarkers, 0x00, (g_TempMarkerSize * sizeof(marker_t)));
|
||||
free(g_TempMarkers);
|
||||
g_TempMarkerSize = 0;
|
||||
}
|
||||
|
||||
extern "C" void ExitGraphics(void) {
|
||||
if (!gui)
|
||||
return;
|
||||
|
||||
@@ -27,11 +27,6 @@ extern "C" {
|
||||
#include <stddef.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct {
|
||||
uint32_t pos;
|
||||
char label[30];
|
||||
} marker_t;
|
||||
|
||||
void ShowGraphWindow(void);
|
||||
void HideGraphWindow(void);
|
||||
void RepaintGraphWindow(void);
|
||||
@@ -46,16 +41,9 @@ void MainGraphics(void);
|
||||
void InitGraphics(int argc, char **argv, char *script_cmds_file, char *script_cmd, bool stayInCommandLoop);
|
||||
void ExitGraphics(void);
|
||||
|
||||
//Temporary Marker Functions
|
||||
extern void add_temporary_marker(uint32_t position, const char *label);
|
||||
extern void remove_temporary_markers(void);
|
||||
|
||||
extern double g_CursorScaleFactor;
|
||||
extern char g_CursorScaleFactorUnit[11];
|
||||
extern double g_PlotGridX, g_PlotGridY, g_DefaultGridX, g_DefaultGridY;
|
||||
extern marker_t g_MarkerA, g_MarkerB, g_MarkerC, g_MarkerD;
|
||||
extern marker_t *g_TempMarkers;
|
||||
extern uint8_t g_TempMarkerSize;
|
||||
extern uint32_t g_GraphStart, g_GraphStart_old, g_GraphStop;
|
||||
extern int CommandFinished;
|
||||
extern int offline;
|
||||
|
||||
@@ -1268,14 +1268,22 @@ void Plot::wheelEvent(QWheelEvent *event) {
|
||||
|
||||
void Plot::mouseMoveEvent(QMouseEvent *event) {
|
||||
int x = event->x();
|
||||
x -= WIDTH_AXES;
|
||||
x = (int)(x / g_GraphPixelsPerPoint);
|
||||
x += g_GraphStart;
|
||||
|
||||
if ((event->buttons() & Qt::LeftButton)) {
|
||||
g_MarkerA.pos = x;
|
||||
} else if (event->buttons() & Qt::RightButton) {
|
||||
g_MarkerB.pos = x;
|
||||
//Only run the marker place code if a mouse button is pressed
|
||||
if ((event->buttons() & Qt::LeftButton) || (event->buttons() & Qt::RightButton)) {
|
||||
x -= WIDTH_AXES;
|
||||
x = (int)(x / g_GraphPixelsPerPoint);
|
||||
x += g_GraphStart;
|
||||
|
||||
if (x > (int)g_GraphTraceLen) x = 0; // Set to 0 if the number is stupidly big
|
||||
else if (x < (int)g_GraphStart) x = (int)g_GraphStart; // Bounds checking for the start of the Graph Window
|
||||
else if (x > (int)g_GraphStop) x = (int)g_GraphStop; // Bounds checking for the end of the Graph Window
|
||||
|
||||
if ((event->buttons() & Qt::LeftButton)) { // True for left click, false otherwise
|
||||
g_MarkerA.pos = x;
|
||||
} else {
|
||||
g_MarkerB.pos = x;
|
||||
}
|
||||
}
|
||||
|
||||
this->update();
|
||||
|
||||
@@ -30,6 +30,7 @@
|
||||
#include <QtGui>
|
||||
|
||||
#include "proxgui.h"
|
||||
#include "graph.h"
|
||||
#include "ui/ui_overlays.h"
|
||||
#include "ui/ui_image.h"
|
||||
|
||||
|
||||
+9
-11
@@ -385,7 +385,7 @@ void
|
||||
__attribute__((force_align_arg_pointer))
|
||||
#endif
|
||||
#endif
|
||||
main_loop(char *script_cmds_file, char *script_cmd, bool stayInCommandLoop) {
|
||||
main_loop(const char *script_cmds_file, char *script_cmd, bool stayInCommandLoop) {
|
||||
|
||||
char *cmd = NULL;
|
||||
bool execCommand = (script_cmd != NULL);
|
||||
@@ -777,31 +777,29 @@ static void show_help(bool showFullHelp, char *exec_name) {
|
||||
}
|
||||
|
||||
static int dumpmem_to_file(const char *filename, uint32_t addr, uint32_t len, bool raw, bool in_bootloader) {
|
||||
int res = PM3_EUNDEF;
|
||||
|
||||
uint8_t *buffer = calloc(len, sizeof(uint8_t));
|
||||
if (!buffer) {
|
||||
if (buffer == NULL) {
|
||||
PrintAndLogEx(ERR, "error, cannot allocate memory ");
|
||||
res = PM3_EMALLOC;
|
||||
goto fail;
|
||||
return PM3_EMALLOC;
|
||||
}
|
||||
|
||||
size_t read = 0;
|
||||
int res = PM3_EUNDEF;
|
||||
size_t readlen = 0;
|
||||
DeviceMemType_t type = raw ? MCU_MEM : MCU_FLASH;
|
||||
if (GetFromDevice(type, buffer, len, addr, NULL, 0, NULL, 1000, true)) {
|
||||
res = PM3_SUCCESS;
|
||||
read = len; // GetFromDevice does not report the actual number of bytes received.
|
||||
readlen = len; // GetFromDevice does not report the actual number of bytes received.
|
||||
}
|
||||
|
||||
if (res == PM3_SUCCESS) {
|
||||
if (saveFile(filename, ".bin", buffer, read) != 0) {
|
||||
res = saveFile(filename, ".bin", buffer, readlen);
|
||||
if (res != PM3_SUCCESS) {
|
||||
PrintAndLogEx(ERR, "error writing to file "_YELLOW_("%s"), filename);
|
||||
res = PM3_EFILE;
|
||||
}
|
||||
}
|
||||
|
||||
free(buffer);
|
||||
fail:
|
||||
return res;
|
||||
}
|
||||
|
||||
@@ -1441,7 +1439,7 @@ int main(int argc, char *argv[]) {
|
||||
MainGraphics();
|
||||
# else
|
||||
// for *nix distro's, check environment variable to verify a display
|
||||
char *display = getenv("DISPLAY");
|
||||
const char *display = getenv("DISPLAY");
|
||||
if (display && strlen(display) > 1) {
|
||||
InitGraphics(argc, argv, script_cmds_file, script_cmd, stayInCommandLoop);
|
||||
MainGraphics();
|
||||
|
||||
@@ -64,7 +64,7 @@ const char *get_my_executable_path(void);
|
||||
const char *get_my_executable_directory(void);
|
||||
const char *get_my_user_directory(void);
|
||||
void pm3_init(void);
|
||||
void main_loop(char *script_cmds_file, char *script_cmd, bool stayInCommandLoop);
|
||||
void main_loop(const char *script_cmds_file, char *script_cmd, bool stayInCommandLoop);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user