github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-07-16 10:03:04 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

style

Browse source
This commit is contained in:
iceman1001 2021-05-05 21:04:48 +02:00
parent e5320650c9
commit e4f55556ba
26 changed files with 289 additions and 289 deletions
Download patch file Download diff file Expand all files Collapse all files

4
armsrc/appmain.c
View file

@ -1318,7 +1318,7 @@ static void PacketReceived(PacketCommandNG *packet) {
break; break;
} }
case CMD_HF_ISO14443B_COMMAND: { case CMD_HF_ISO14443B_COMMAND: {
iso14b_raw_cmd_t *payload = (iso14b_raw_cmd_t*)packet->data.asBytes; iso14b_raw_cmd_t *payload = (iso14b_raw_cmd_t *)packet->data.asBytes;
SendRawCommand14443B_Ex(payload); SendRawCommand14443B_Ex(payload);
break; break;
} }
@ -1704,7 +1704,7 @@ static void PacketReceived(PacketCommandNG *packet) {
break; break;
} }
case CMD_HF_ICLASS_CHKKEYS: { case CMD_HF_ICLASS_CHKKEYS: {
iClass_Authentication_fast((iclass_chk_t*)packet->data.asBytes); iClass_Authentication_fast((iclass_chk_t *)packet->data.asBytes);
break; break;
} }
case CMD_HF_ICLASS_DUMP: { case CMD_HF_ICLASS_DUMP: {

8
armsrc/iso14443b.c
View file

@ -445,7 +445,7 @@ static void iso14b_set_timeout(uint32_t timeout_etu) {
// keep track of FWT, also updates the timeout // keep track of FWT, also updates the timeout
static void iso14b_set_fwt(uint8_t fwt) { static void iso14b_set_fwt(uint8_t fwt) {
iso14b_fwt = fwt; iso14b_fwt = fwt;
iso14b_set_timeout( 32 << fwt ); iso14b_set_timeout(32 << fwt);
} }
static void iso14b_set_maxframesize(uint16_t size) { static void iso14b_set_maxframesize(uint16_t size) {
@ -1370,7 +1370,7 @@ static int Get14443bAnswerFromTag(uint8_t *response, uint16_t max_len, uint32_t
break; break;
} }
if (((GetCountSspClkDelta(dma_start_time) ) > timeout) && Demod.state < DEMOD_PHASE_REF_TRAINING) { if (((GetCountSspClkDelta(dma_start_time)) > timeout) && Demod.state < DEMOD_PHASE_REF_TRAINING) {
ret = -1; ret = -1;
break; break;
} }
@ -1570,7 +1570,7 @@ int iso14443b_apdu(uint8_t const *msg, size_t msg_len, bool send_chaining, void
uint32_t fwt_temp = iso14b_fwt * wtxm; uint32_t fwt_temp = iso14b_fwt * wtxm;
// temporarily increase timeout // temporarily increase timeout
iso14b_set_timeout( (32 << fwt_temp)); iso14b_set_timeout((32 << fwt_temp));
// Transmit WTX back // Transmit WTX back
data_bytes[1] = wtxm; data_bytes[1] = wtxm;
@ -2176,7 +2176,7 @@ void SendRawCommand14443B_Ex(iso14b_raw_cmd_t *o) {
// receive buffer // receive buffer
uint8_t buf[PM3_CMD_DATA_SIZE]; uint8_t buf[PM3_CMD_DATA_SIZE];
memset(buf, 0 , sizeof(buf)); memset(buf, 0, sizeof(buf));
if (DBGLEVEL > DBG_DEBUG) { if (DBGLEVEL > DBG_DEBUG) {
Dbprintf("14b raw: param, %04x", o->flags); Dbprintf("14b raw: param, %04x", o->flags);
} }

4
armsrc/iso15693.c
View file

@ -2108,7 +2108,7 @@ void SetTag15693Uid(uint8_t *uid) {
static void init_password_15693_slixl(uint8_t *buffer, uint8_t *pwd, uint8_t *rnd) { static void init_password_15693_slixl(uint8_t *buffer, uint8_t *pwd, uint8_t *rnd) {
memcpy(buffer, pwd, 4); memcpy(buffer, pwd, 4);
if(rnd) { if (rnd) {
buffer[0] ^= rnd[0]; buffer[0] ^= rnd[0];
buffer[1] ^= rnd[1]; buffer[1] ^= rnd[1];
buffer[2] ^= rnd[0]; buffer[2] ^= rnd[0];
@ -2127,7 +2127,7 @@ static bool get_rnd_15693_slixl(uint32_t start_time, uint32_t *eof_time, uint8_t
return false; return false;
} }
if(rnd) { if (rnd) {
memcpy(rnd, &recvbuf[1], 2); memcpy(rnd, &recvbuf[1], 2);
} }
return true; return true;

2
client/src/cmdanalyse.c
View file

@ -1079,7 +1079,7 @@ static int CmdAnalyseFoo(const char *Cmd) {
return PM3_SUCCESS; return PM3_SUCCESS;
} }
static int CmdAnalyseUnits(const char* Cmd) { static int CmdAnalyseUnits(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "analyse units", CLIParserInit(&ctx, "analyse units",

2
client/src/cmddata.c
View file

@ -2883,7 +2883,7 @@ static int CmdDataModulationSearch(const char *Cmd) {
return try_detect_modulation(); return try_detect_modulation();
} }
static int CmdAsn1Decoder(const char* Cmd) { static int CmdAsn1Decoder(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data asn1", CLIParserInit(&ctx, "data asn1",

4
client/src/cmdflashmem.c
View file

@ -98,7 +98,7 @@ static int rdv4_sign_write(uint8_t *signature, uint8_t slen) {
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_FLASHMEM_WRITE, (uint8_t*)&payload, sizeof(payload)); SendCommandNG(CMD_FLASHMEM_WRITE, (uint8_t *)&payload, sizeof(payload));
if (WaitForResponseTimeout(CMD_FLASHMEM_WRITE, &resp, 2000) == false) { if (WaitForResponseTimeout(CMD_FLASHMEM_WRITE, &resp, 2000) == false) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -285,7 +285,7 @@ static int CmdFlashMemLoad(const char *Cmd) {
.len = bytes_in_packet, .len = bytes_in_packet,
}; };
memcpy(payload.data, data + bytes_sent, bytes_in_packet); memcpy(payload.data, data + bytes_sent, bytes_in_packet);
SendCommandNG(CMD_FLASHMEM_WRITE, (uint8_t*)&payload, sizeof(payload)); SendCommandNG(CMD_FLASHMEM_WRITE, (uint8_t *)&payload, sizeof(payload));
bytes_remaining -= bytes_in_packet; bytes_remaining -= bytes_in_packet;
bytes_sent += bytes_in_packet; bytes_sent += bytes_in_packet;

48
client/src/cmdhf14b.c
View file

@ -48,7 +48,7 @@ static int switch_off_field_14b(void) {
.rawlen = 0, .rawlen = 0,
}; };
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
return PM3_SUCCESS; return PM3_SUCCESS;
} }
@ -354,7 +354,7 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen; datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t*)calloc(1, sizeof(iso14b_raw_cmd_t) + datalen); iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t *)calloc(1, sizeof(iso14b_raw_cmd_t) + datalen);
if (packet == NULL) { if (packet == NULL) {
PrintAndLogEx(FAILED, "failed to allocate memory"); PrintAndLogEx(FAILED, "failed to allocate memory");
return PM3_EMALLOC; return PM3_EMALLOC;
@ -365,7 +365,7 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
memcpy(packet->raw, data, datalen); memcpy(packet->raw, data, datalen);
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen);
free(packet); free(packet);
if (read_reply == false) { if (read_reply == false) {
@ -415,7 +415,7 @@ static bool get_14b_UID(iso14b_card_select_t *card) {
PacketResponseNG resp; PacketResponseNG resp;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT)) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT)) {
@ -428,7 +428,7 @@ static bool get_14b_UID(iso14b_card_select_t *card) {
// test 14b standard // test 14b standard
packet.flags = (ISO14B_CONNECT | ISO14B_SELECT_STD | ISO14B_DISCONNECT); packet.flags = (ISO14B_CONNECT | ISO14B_SELECT_STD | ISO14B_DISCONNECT);
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT)) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT)) {
if (resp.oldarg[0] == 0) { if (resp.oldarg[0] == 0) {
@ -762,7 +762,7 @@ static bool HF14B_Std_Info(bool verbose, bool do_aid_search) {
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -815,7 +815,7 @@ static bool HF14B_ST_Info(bool verbose, bool do_aid_search) {
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -870,7 +870,7 @@ static bool HF14B_st_reader(bool verbose) {
// SRx get and print general info about SRx chip from UID // SRx get and print general info about SRx chip from UID
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -912,7 +912,7 @@ static bool HF14B_std_reader(bool verbose) {
// 14b get and print UID only (general info) // 14b get and print UID only (general info)
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -959,7 +959,7 @@ static bool HF14B_ask_ct_reader(bool verbose) {
// 14b get and print UID only (general info) // 14b get and print UID only (general info)
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) PrintAndLogEx(WARNING, "timeout while waiting for reply"); if (verbose) PrintAndLogEx(WARNING, "timeout while waiting for reply");
return false; return false;
@ -991,7 +991,7 @@ static bool HF14B_ask_ct_reader(bool verbose) {
// test for other 14b type tags (mimic another reader - don't have tags to identify) // test for other 14b type tags (mimic another reader - don't have tags to identify)
static bool HF14B_other_reader(bool verbose) { static bool HF14B_other_reader(bool verbose) {
iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t*)calloc(1, sizeof(iso14b_raw_cmd_t) + 4); iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t *)calloc(1, sizeof(iso14b_raw_cmd_t) + 4);
if (packet == NULL) { if (packet == NULL) {
PrintAndLogEx(FAILED, "failed to allocate memory"); PrintAndLogEx(FAILED, "failed to allocate memory");
return PM3_EMALLOC; return PM3_EMALLOC;
@ -1005,7 +1005,7 @@ static bool HF14B_other_reader(bool verbose) {
clearCommandBuffer(); clearCommandBuffer();
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen);
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -1035,7 +1035,7 @@ static bool HF14B_other_reader(bool verbose) {
packet->rawlen = 1; packet->rawlen = 1;
packet->raw[0] = ISO14443B_AUTHENTICATE; packet->raw[0] = ISO14443B_AUTHENTICATE;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen);
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
PrintAndLogEx(WARNING, "timeout while waiting for reply"); PrintAndLogEx(WARNING, "timeout while waiting for reply");
@ -1064,7 +1064,7 @@ static bool HF14B_other_reader(bool verbose) {
packet->raw[0] = ISO14443B_RESET; packet->raw[0] = ISO14443B_RESET;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen);
free(packet); free(packet);
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
@ -1320,7 +1320,7 @@ static int CmdHF14BDump(const char *Cmd) {
// detect blocksize from card :) // detect blocksize from card :)
PrintAndLogEx(INFO, "reading tag memory from UID " _GREEN_("%s"), sprint_hex_inrow(SwapEndian64(card.uid, card.uidlen, 8), card.uidlen)); PrintAndLogEx(INFO, "reading tag memory from UID " _GREEN_("%s"), sprint_hex_inrow(SwapEndian64(card.uid, card.uidlen, 8), card.uidlen));
iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t*)calloc(1, sizeof(iso14b_raw_cmd_t) + 2); iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t *)calloc(1, sizeof(iso14b_raw_cmd_t) + 2);
if (packet == NULL) { if (packet == NULL) {
PrintAndLogEx(FAILED, "failed to allocate memory"); PrintAndLogEx(FAILED, "failed to allocate memory");
return PM3_EMALLOC; return PM3_EMALLOC;
@ -1330,7 +1330,7 @@ static int CmdHF14BDump(const char *Cmd) {
packet->rawlen = 0; packet->rawlen = 0;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t));
PacketResponseNG resp; PacketResponseNG resp;
// select // select
@ -1338,7 +1338,7 @@ static int CmdHF14BDump(const char *Cmd) {
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000)) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000)) {
status = resp.oldarg[0]; status = resp.oldarg[0];
if (status < 0) { if (status < 0) {
PrintAndLogEx(FAILED, "failed to select arg0[%" PRId64 "]" , resp.oldarg[0]); PrintAndLogEx(FAILED, "failed to select arg0[%" PRId64 "]", resp.oldarg[0]);
free(packet); free(packet);
return switch_off_field_14b(); return switch_off_field_14b();
} }
@ -1359,7 +1359,7 @@ static int CmdHF14BDump(const char *Cmd) {
packet->raw[1] = blocknum & 0xFF; packet->raw[1] = blocknum & 0xFF;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t) + 2); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t) + 2);
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000)) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000)) {
status = resp.oldarg[0]; status = resp.oldarg[0];
@ -1567,19 +1567,19 @@ static int select_card_14443b_4(bool disconnect, iso14b_card_select_t *card) {
}; };
// Anticollision + SELECT STD card // Anticollision + SELECT STD card
PacketResponseNG resp; PacketResponseNG resp;
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
PrintAndLogEx(INFO, "Trying 14B Select SRx"); PrintAndLogEx(INFO, "Trying 14B Select SRx");
// Anticollision + SELECT SR card // Anticollision + SELECT SR card
packet.flags = (ISO14B_CONNECT | ISO14B_SELECT_SR); packet.flags = (ISO14B_CONNECT | ISO14B_SELECT_SR);
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
PrintAndLogEx(INFO, "Trying 14B Select CTS"); PrintAndLogEx(INFO, "Trying 14B Select CTS");
// Anticollision + SELECT ASK C-Ticket card // Anticollision + SELECT ASK C-Ticket card
packet.flags = (ISO14B_CONNECT | ISO14B_SELECT_CTS); packet.flags = (ISO14B_CONNECT | ISO14B_SELECT_CTS);
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
PrintAndLogEx(ERR, "connection timeout"); PrintAndLogEx(ERR, "connection timeout");
switch_off_field_14b(); switch_off_field_14b();
@ -1627,7 +1627,7 @@ static int handle_14b_apdu(bool chainingin, uint8_t *datain, int datainlen,
return selres; return selres;
} }
iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t*)calloc(1, sizeof(iso14b_raw_cmd_t) + datainlen); iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t *)calloc(1, sizeof(iso14b_raw_cmd_t) + datainlen);
if (packet == NULL) { if (packet == NULL) {
PrintAndLogEx(FAILED, "APDU: failed to allocate memory"); PrintAndLogEx(FAILED, "APDU: failed to allocate memory");
return PM3_EMALLOC; return PM3_EMALLOC;
@ -1656,9 +1656,9 @@ static int handle_14b_apdu(bool chainingin, uint8_t *datain, int datainlen,
if (datain) { if (datain) {
packet->rawlen = datainlen; packet->rawlen = datainlen;
memcpy(packet->raw, datain, datainlen); memcpy(packet->raw, datain, datainlen);
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t) + packet->rawlen);
} else { } else {
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t));
} }
free(packet); free(packet);
PacketResponseNG resp; PacketResponseNG resp;

2
client/src/cmdhf15.c
View file

@ -2174,7 +2174,7 @@ static int CmdHF15SlixDisable(const char *Cmd) {
return PM3_ESOFT; return PM3_ESOFT;
} }
switch(resp.status) { switch (resp.status) {
case PM3_ETIMEOUT: { case PM3_ETIMEOUT: {
PrintAndLogEx(WARNING, "no tag found"); PrintAndLogEx(WARNING, "no tag found");
break; break;

14
client/src/cmdhfcryptorf.c
View file

@ -42,7 +42,7 @@ static int switch_off_field_cryptorf(void) {
.rawlen = 0, .rawlen = 0,
}; };
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
return PM3_SUCCESS; return PM3_SUCCESS;
} }
@ -105,7 +105,7 @@ static bool get_14b_UID(iso14b_card_select_t *card) {
.rawlen = 0, .rawlen = 0,
}; };
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
PacketResponseNG resp; PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT)) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT)) {
if (resp.oldarg[0] == 0) { if (resp.oldarg[0] == 0) {
@ -130,7 +130,7 @@ static int infoHFCryptoRF(bool verbose) {
}; };
// 14b get and print UID only (general info) // 14b get and print UID only (general info)
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
PacketResponseNG resp; PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, TIMEOUT) == false) {
if (verbose) { if (verbose) {
@ -197,7 +197,7 @@ int readHFCryptoRF(bool loop, bool verbose) {
.rawlen = 0, .rawlen = 0,
}; };
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
PacketResponseNG resp; PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) { if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) {
@ -300,7 +300,7 @@ static int CmdHFCryptoRFDump(const char *Cmd) {
PrintAndLogEx(INFO, "Reading memory from tag UID " _GREEN_("%s"), sprint_hex(card.uid, card.uidlen)); PrintAndLogEx(INFO, "Reading memory from tag UID " _GREEN_("%s"), sprint_hex(card.uid, card.uidlen));
// select tag // select tag
iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t*)calloc(1, sizeof(iso14b_raw_cmd_t) + 2); iso14b_raw_cmd_t *packet = (iso14b_raw_cmd_t *)calloc(1, sizeof(iso14b_raw_cmd_t) + 2);
if (packet == NULL) { if (packet == NULL) {
PrintAndLogEx(FAILED, "failed to allocate memory"); PrintAndLogEx(FAILED, "failed to allocate memory");
return PM3_EMALLOC; return PM3_EMALLOC;
@ -310,7 +310,7 @@ static int CmdHFCryptoRFDump(const char *Cmd) {
packet->rawlen = 0; packet->rawlen = 0;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)packet, sizeof(iso14b_raw_cmd_t));
PacketResponseNG resp; PacketResponseNG resp;
// select // select
@ -339,7 +339,7 @@ static int CmdHFCryptoRFDump(const char *Cmd) {
packet->raw[1] = blocknum & 0xFF; packet->raw[1] = blocknum & 0xFF;
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t) + 2); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t) + 2);
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000)) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000)) {
status = resp.oldarg[0]; status = resp.oldarg[0];

2
client/src/cmdhfemrtd.c
View file

@ -1035,7 +1035,7 @@ static bool emrtd_connect(bool *use_14b) {
.rawlen = 0, .rawlen = 0,
}; };
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t*)&packet, sizeof(iso14b_raw_cmd_t)); SendCommandNG(CMD_HF_ISO14443B_COMMAND, (uint8_t *)&packet, sizeof(iso14b_raw_cmd_t));
if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000) == false) { if (WaitForResponseTimeout(CMD_HF_ISO14443B_COMMAND, &resp, 2000) == false) {
PrintAndLogEx(INFO, "timeout, no eMRTD spotted with 14b, exiting"); PrintAndLogEx(INFO, "timeout, no eMRTD spotted with 14b, exiting");
return false; return false;

6
client/src/cmdhficlass.c
View file

@ -141,7 +141,7 @@ static void iclass_upload_emul(uint8_t *d, uint16_t n, uint16_t *bytes_sent) {
payload->len = bytes_in_packet; payload->len = bytes_in_packet;
memcpy(payload->data, d + *bytes_sent, bytes_in_packet); memcpy(payload->data, d + *bytes_sent, bytes_in_packet);
SendCommandNG(CMD_HF_ICLASS_EML_MEMSET, (uint8_t*)payload, 4 + bytes_in_packet); SendCommandNG(CMD_HF_ICLASS_EML_MEMSET, (uint8_t *)payload, 4 + bytes_in_packet);
free(payload); free(payload);
bytes_remaining -= bytes_in_packet; bytes_remaining -= bytes_in_packet;
@ -3068,7 +3068,7 @@ static int CmdHFiClassCheckKeys(const char *Cmd) {
} }
uint32_t tmp_plen = sizeof(iclass_chk_t) + (4 * curr_chunk_cnt); uint32_t tmp_plen = sizeof(iclass_chk_t) + (4 * curr_chunk_cnt);
iclass_chk_t *packet = calloc(tmp_plen, sizeof(uint8_t) ); iclass_chk_t *packet = calloc(tmp_plen, sizeof(uint8_t));
if (packet == NULL) { if (packet == NULL) {
PrintAndLogEx(WARNING, "failed to allocate memory"); PrintAndLogEx(WARNING, "failed to allocate memory");
break; break;
@ -3079,7 +3079,7 @@ static int CmdHFiClassCheckKeys(const char *Cmd) {
memcpy(packet->items, (pre + chunk_offset), (4 * curr_chunk_cnt)); memcpy(packet->items, (pre + chunk_offset), (4 * curr_chunk_cnt));
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_ICLASS_CHKKEYS, (uint8_t*)packet, tmp_plen); SendCommandNG(CMD_HF_ICLASS_CHKKEYS, (uint8_t *)packet, tmp_plen);
free(packet); free(packet);
bool looped = false; bool looped = false;

2
client/src/cmdhflegic.c
View file

@ -902,7 +902,7 @@ static int CmdLegicRestore(const char *Cmd) {
} }
if (shall_obsfuscate) { if (shall_obsfuscate) {
if (legic_xor(data, card.cardsize) == false){ if (legic_xor(data, card.cardsize) == false) {
PrintAndLogEx(FAILED, "Obsfuscate failed, exiting..."); PrintAndLogEx(FAILED, "Obsfuscate failed, exiting...");
PrintAndLogEx(HINT, "Try running command without `--ob` parameter"); PrintAndLogEx(HINT, "Try running command without `--ob` parameter");
free(data); free(data);

2
client/src/cmdhfmf.c
View file

@ -5794,7 +5794,7 @@ static int CmdHF14AMfWipe(const char *Cmd) {
"hf mf wipe --> reads card uid to generate file name\n" "hf mf wipe --> reads card uid to generate file name\n"
"hf mf wipe --gen2 --> force write to S0, B0 manufacture block\n" "hf mf wipe --gen2 --> force write to S0, B0 manufacture block\n"
"hf mf wipe -f mykey.bin --> use mykey.bin\n" "hf mf wipe -f mykey.bin --> use mykey.bin\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_str0("f", "file", "<fn>", "key filename"), arg_str0("f", "file", "<fn>", "key filename"),

18
client/src/cmdhfmfdes.c
View file

@ -1160,12 +1160,12 @@ static int mifare_desfire_change_key(uint8_t key_no, uint8_t *new_key, uint8_t n
As such, we should be able to convert the Des to TDes then run the code as TDes As such, we should be able to convert the Des to TDes then run the code as TDes
*/ */
if (new_algo == MFDES_ALGO_DES) { if (new_algo == MFDES_ALGO_DES) {
memcpy(&new_key[8],new_key,8); memcpy(&new_key[8], new_key, 8);
new_algo = MFDES_ALGO_3DES; new_algo = MFDES_ALGO_3DES;
} }
if (old_algo == MFDES_ALGO_DES) { if (old_algo == MFDES_ALGO_DES) {
memcpy(&old_key[8],old_key,8); memcpy(&old_key[8], old_key, 8);
old_algo = MFDES_ALGO_3DES; old_algo = MFDES_ALGO_3DES;
} }
@ -1208,13 +1208,13 @@ static int mifare_desfire_change_key(uint8_t key_no, uint8_t *new_key, uint8_t n
uint8_t new_key_length = 16; uint8_t new_key_length = 16;
switch (new_algo) { switch (new_algo) {
/* /*
// We have converted the DES to 3DES above,so this will never hit // We have converted the DES to 3DES above,so this will never hit
case MFDES_ALGO_DES: case MFDES_ALGO_DES:
memcpy(data + cmdcnt + 1, new_key, new_key_length); memcpy(data + cmdcnt + 1, new_key, new_key_length);
memcpy(data + cmdcnt + 1 + new_key_length, new_key, new_key_length); memcpy(data + cmdcnt + 1 + new_key_length, new_key, new_key_length);
break; break;
*/ */
case MFDES_ALGO_3DES: case MFDES_ALGO_3DES:
case MFDES_ALGO_AES: case MFDES_ALGO_AES:
new_key_length = 16; new_key_length = 16;
@ -1259,7 +1259,7 @@ static int mifare_desfire_change_key(uint8_t key_no, uint8_t *new_key, uint8_t n
// 19 bytes // 19 bytes
//uint8_t csPkt[30] = {0x00}; //uint8_t csPkt[30] = {0x00};
csPkt[0] = 0xC4; csPkt[0] = 0xC4;
memcpy (&csPkt[1],data,18); memcpy(&csPkt[1], data, 18);
desfire_crc32(csPkt, 19, data + 1 + cmdcnt); desfire_crc32(csPkt, 19, data + 1 + cmdcnt);
} else { } else {
@ -1288,7 +1288,7 @@ static int mifare_desfire_change_key(uint8_t key_no, uint8_t *new_key, uint8_t n
apdu.Lc = (uint8_t)cmdcnt + 1; apdu.Lc = (uint8_t)cmdcnt + 1;
// apdu.data = p; // apdu.data = p;
// the above data pointed to from p did not have the key no. at the start, so copy preprocessed data after the key no. // the above data pointed to from p did not have the key no. at the start, so copy preprocessed data after the key no.
memcpy (&data[1], p, cmdcnt); memcpy(&data[1], p, cmdcnt);
apdu.data = data; apdu.data = data;
@ -1319,7 +1319,7 @@ static int mifare_desfire_change_key(uint8_t key_no, uint8_t *new_key, uint8_t n
As such !p is true and the code reports "Error on changing key"; so comment back to user until its fixed. As such !p is true and the code reports "Error on changing key"; so comment back to user until its fixed.
*/ */
if (new_algo == MFDES_ALGO_AES) { if (new_algo == MFDES_ALGO_AES) {
PrintAndLogEx(WARNING,"AES password may have been changed, please check new password with the auth command."); PrintAndLogEx(WARNING, "AES password may have been changed, please check new password with the auth command.");
} }
return PM3_ESOFT; return PM3_ESOFT;
@ -3612,10 +3612,10 @@ static int CmdHF14ADesInfo(const char *Cmd) {
static const char STANDALONE_DESFIRE[] = { 0x75, 0x77, 0x81, 0x02}; static const char STANDALONE_DESFIRE[] = { 0x75, 0x77, 0x81, 0x02};
static const char JCOP_DESFIRE[] = { 0x75, 0xf7, 0xb1, 0x02 }; static const char JCOP_DESFIRE[] = { 0x75, 0xf7, 0xb1, 0x02 };
if (str_startswith((const char*)card.ats + 1, STANDALONE_DESFIRE)) { if (str_startswith((const char *)card.ats + 1, STANDALONE_DESFIRE)) {
PrintAndLogEx(INFO, "Standalone DESFire"); PrintAndLogEx(INFO, "Standalone DESFire");
} }
if (str_startswith((const char*)card.ats + 1, JCOP_DESFIRE)) { if (str_startswith((const char *)card.ats + 1, JCOP_DESFIRE)) {
PrintAndLogEx(INFO, "JCOP DESFire"); PrintAndLogEx(INFO, "JCOP DESFire");
} }
} }

2
client/src/cmdparser.c
View file

@ -329,7 +329,7 @@ void dumpCommandsRecursive(const command_t cmds[], int markdown, bool full_help)
PrintAndLogEx(NORMAL, "|`%s%-*s`|%-*s|`%s`", parent, w_cmd - (int)strlen(parent) - 2, cmds[i].Name, w_off, cmd_offline, cmds[i].Help); PrintAndLogEx(NORMAL, "|`%s%-*s`|%-*s|`%s`", parent, w_cmd - (int)strlen(parent) - 2, cmds[i].Name, w_off, cmd_offline, cmds[i].Help);
else if (full_help) { else if (full_help) {
PrintAndLogEx(NORMAL, "---------------------------------------------------------------------------------------"); PrintAndLogEx(NORMAL, "---------------------------------------------------------------------------------------");
PrintAndLogEx(NORMAL, _RED_("%s%-*s\n") "available offline: %s", parent, w_cmd - (int)strlen(parent), cmds[i].Name, cmds[i].IsAvailable()?_GREEN_("yes"):_RED_("no")); PrintAndLogEx(NORMAL, _RED_("%s%-*s\n") "available offline: %s", parent, w_cmd - (int)strlen(parent), cmds[i].Name, cmds[i].IsAvailable() ? _GREEN_("yes") : _RED_("no"));
cmds[i].Parse("--help"); cmds[i].Parse("--help");
} else { } else {
PrintAndLogEx(NORMAL, "%s%-*s|%-*s|%s", parent, w_cmd - (int)strlen(parent), cmds[i].Name, w_off, cmd_offline, cmds[i].Help); PrintAndLogEx(NORMAL, "%s%-*s|%-*s|%s", parent, w_cmd - (int)strlen(parent), cmds[i].Name, w_off, cmd_offline, cmds[i].Help);

4
client/src/crypto/asn1dump.c
View file

@ -318,12 +318,12 @@ bool asn1_tag_dump(const struct tlv *tlv, int level, bool *candump) {
const struct asn1_tag *tag = asn1_get_tag(tlv); const struct asn1_tag *tag = asn1_get_tag(tlv);
/* /*
if ((tlv->tag & 0x20) == 0x20 ) { if ((tlv->tag & 0x20) == 0x20 ) {
} else if ((tlv->tag & 0x80) == 0x80 ) { } else if ((tlv->tag & 0x80) == 0x80 ) {
} else { } else {
} }
*/ */
PrintAndLogEx(INFO, PrintAndLogEx(INFO,
"%*s-- %2x [%02zx] '"_YELLOW_("%s") "'" NOLF "%*s-- %2x [%02zx] '"_YELLOW_("%s") "'" NOLF

8
client/src/wiegand_formats.c
View file

@ -146,8 +146,8 @@ static bool Pack_indasc27(wiegand_card_t *card, wiegand_message_t *packed, bool
if (card->OEM > 0) return false; // Not used in this format if (card->OEM > 0) return false; // Not used in this format
packed->Length = 27; packed->Length = 27;
set_nonlinear_field(packed, card->FacilityCode, 11, (uint8_t[]) {9,4,6,5,0,7,19,8,10,16,24,12,22}); set_nonlinear_field(packed, card->FacilityCode, 11, (uint8_t[]) {9, 4, 6, 5, 0, 7, 19, 8, 10, 16, 24, 12, 22});
set_nonlinear_field(packed, card->CardNumber, 14, (uint8_t[]) {26,1,3,15,14,17,20,13,25,2,18,21,11,23}); set_nonlinear_field(packed, card->CardNumber, 14, (uint8_t[]) {26, 1, 3, 15, 14, 17, 20, 13, 25, 2, 18, 21, 11, 23});
if (preamble) if (preamble)
return add_HID_header(packed); return add_HID_header(packed);
return true; return true;
@ -158,8 +158,8 @@ static bool Unpack_indasc27(wiegand_message_t *packed, wiegand_card_t *card) {
if (packed->Length != 27) return false; // Wrong length? Stop here. if (packed->Length != 27) return false; // Wrong length? Stop here.
card->FacilityCode = get_nonlinear_field(packed, 11, (uint8_t[]) {9,4,6,5,0,7,19,8,10,16,24,12,22}); card->FacilityCode = get_nonlinear_field(packed, 11, (uint8_t[]) {9, 4, 6, 5, 0, 7, 19, 8, 10, 16, 24, 12, 22});
card->CardNumber = get_nonlinear_field(packed, 14, (uint8_t[]) {26,1,3,15,14,17,20,13,25,2,18,21,11,23}); card->CardNumber = get_nonlinear_field(packed, 14, (uint8_t[]) {26, 1, 3, 15, 14, 17, 20, 13, 25, 2, 18, 21, 11, 23});
return true; return true;
} }