RfidResearchGroup/proxmark3
1
1
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-03-20 12:07:05 +08:00
Code Issues Projects Releases Packages Wiki Activity

Rename few USB -> PM3 to avoid misleading interpretations

Browse source
This commit is contained in:
Philippe Teuwen 2019-04-30 21:10:11 +02:00
parent cddc25994c
commit 27f7057961
42 changed files with 165 additions and 165 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
armsrc/Standalone/hf_mattyrun.h
View file

@ -14,7 +14,7 @@
#include "standalone.h" // standalone definitions
#include "apps.h" // debugstatements, lfops?
#include "usb_cmd.h" // mifare1ksim flags
#include "pm3_cmd.h" // mifare1ksim flags
#include "mifaresim.h" // mifare1ksim
#include "mifareutil.h"

30
armsrc/appmain.c
View file

@ -118,7 +118,7 @@ void DbpStringEx(uint32_t flags, char *str) {
#if DEBUG
struct {
uint16_t flag;
uint8_t buf[USB_CMD_DATA_SIZE - sizeof(uint16_t)];
uint8_t buf[PM3_CMD_DATA_SIZE - sizeof(uint16_t)];
} PACKED data;
data.flag = flags;
uint16_t len = MIN(strlen(str), sizeof(data.buf));
@ -333,8 +333,8 @@ extern struct version_information version_information;
/* bootrom version information is pointed to from _bootphase1_version_pointer */
extern char *_bootphase1_version_pointer, _flash_start, _flash_end, _bootrom_start, _bootrom_end, __data_src_start__;
void SendVersion(void) {
char temp[USB_CMD_DATA_SIZE]; /* Limited data payload in USB packets */
char VersionString[USB_CMD_DATA_SIZE] = { '\0' };
char temp[PM3_CMD_DATA_SIZE]; /* Limited data payload in USB packets */
char VersionString[PM3_CMD_DATA_SIZE] = { '\0' };
/* Try to find the bootrom version information. Expect to find a pointer at
* symbol _bootphase1_version_pointer, perform slight sanity checks on the
@ -384,9 +384,9 @@ void printUSBSpeed(void) {
LED_B_ON();
while (end_time < start_time + USB_SPEED_TEST_MIN_TIME) {
reply_ng(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, PM3_SUCCESS, test_data, USB_CMD_DATA_SIZE);
reply_ng(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, PM3_SUCCESS, test_data, PM3_CMD_DATA_SIZE);
end_time = GetTickCount();
bytes_transferred += USB_CMD_DATA_SIZE;
bytes_transferred += PM3_CMD_DATA_SIZE;
}
LED_B_OFF();
@ -1089,7 +1089,7 @@ static void PacketReceived(PacketCommandNG *packet) {
case CMD_SMART_UPLOAD: {
// upload file from client
uint8_t *mem = BigBuf_get_addr();
memcpy(mem + packet->oldarg[0], packet->data.asBytes, USB_CMD_DATA_SIZE);
memcpy(mem + packet->oldarg[0], packet->data.asBytes, PM3_CMD_DATA_SIZE);
reply_old(CMD_ACK, 1, 0, 0, 0, 0);
break;
}
@ -1205,8 +1205,8 @@ static void PacketReceived(PacketCommandNG *packet) {
// arg2 = BigBuf tracelen
//Dbprintf("transfer to client parameters: %" PRIu32 " | %" PRIu32 " | %" PRIu32, startidx, numofbytes, packet->oldarg[2]);
for (size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
for (size_t i = 0; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
int result = reply_old(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K, i, len, BigBuf_get_traceLen(), mem + startidx + i, len);
if (result != PM3_SUCCESS)
Dbprintf("transfer to client failed :: | bytes between %d - %d (%d) | result: %d", i, i + len, len, result);
@ -1234,7 +1234,7 @@ static void PacketReceived(PacketCommandNG *packet) {
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
uint8_t *mem = BigBuf_get_addr();
memcpy(mem + packet->oldarg[0], packet->data.asBytes, USB_CMD_DATA_SIZE);
memcpy(mem + packet->oldarg[0], packet->data.asBytes, PM3_CMD_DATA_SIZE);
reply_old(CMD_ACK, 1, 0, 0, 0, 0);
break;
}
@ -1249,8 +1249,8 @@ static void PacketReceived(PacketCommandNG *packet) {
// arg1 = length bytes to transfer
// arg2 = RFU
for (size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
for (size_t i = 0; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
int result = reply_old(CMD_DOWNLOADED_EML_BIGBUF, i, len, 0, mem + startidx + i, len);
if (result != PM3_SUCCESS)
Dbprintf("transfer to client failed :: | bytes between %d - %d (%d) | result: %d", i, i + len, len, result);
@ -1274,7 +1274,7 @@ static void PacketReceived(PacketCommandNG *packet) {
Dbprintf("FlashMem read | %d - %d | ", startidx, len);
size_t size = MIN(USB_CMD_DATA_SIZE, len);
size_t size = MIN(PM3_CMD_DATA_SIZE, len);
if (!FlashInit()) {
break;
@ -1383,7 +1383,7 @@ static void PacketReceived(PacketCommandNG *packet) {
case CMD_FLASHMEM_DOWNLOAD: {
LED_B_ON();
uint8_t *mem = BigBuf_malloc(USB_CMD_DATA_SIZE);
uint8_t *mem = BigBuf_malloc(PM3_CMD_DATA_SIZE);
uint32_t startidx = packet->oldarg[0];
uint32_t numofbytes = packet->oldarg[1];
// arg0 = startindex
@ -1394,8 +1394,8 @@ static void PacketReceived(PacketCommandNG *packet) {
break;
}
for (size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
for (size_t i = 0; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
bool isok = Flash_ReadDataCont(startidx + i, mem, len);
if (!isok)

12
armsrc/iclass.c
View file

@ -1168,7 +1168,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
//Use the emulator memory for SIM
uint8_t *emulator = BigBuf_get_EM_addr();
uint8_t mac_responses[USB_CMD_DATA_SIZE] = { 0 };
uint8_t mac_responses[PM3_CMD_DATA_SIZE] = { 0 };
if (simType == 0) {
// Use the CSN from commandline
@ -1188,7 +1188,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
// in order to obtain the keys, as in the "dismantling iclass"-paper.
#define EPURSE_MAC_SIZE 16
int i = 0;
for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < USB_CMD_DATA_SIZE; i++) {
for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < PM3_CMD_DATA_SIZE; i++) {
// The usb data is 512 bytes, fitting 65 8-byte CSNs in there.
memcpy(emulator, datain + (i * 8), 8);
@ -1220,7 +1220,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
// attack below is same as SIM 2, but we run the CSN twice to collected the mac for both keys.
int i = 0;
// The usb data is 512 bytes, fitting 65 8-byte CSNs in there. iceman fork uses 9 CSNS
for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < USB_CMD_DATA_SIZE; i++) {
for (; i < numberOfCSNS && i * EPURSE_MAC_SIZE + 8 < PM3_CMD_DATA_SIZE; i++) {
memcpy(emulator, datain + (i * 8), 8);
@ -2110,7 +2110,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
uint8_t mem = 0;
uint8_t check[] = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
uint8_t read[] = { 0x0c, 0x00, 0x00, 0x00 };
uint8_t card_data[USB_CMD_DATA_SIZE] = {0};
uint8_t card_data[PM3_CMD_DATA_SIZE] = {0};
uint8_t resp[ICLASS_BUFFER_SIZE] = {0};
static struct memory_t {
@ -2158,7 +2158,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
WDT_HIT();
//Set card_data to all zeroes, we'll fill it with data
memset(card_data, 0x0, USB_CMD_DATA_SIZE);
memset(card_data, 0x0, PM3_CMD_DATA_SIZE);
uint8_t failedRead = 0;
uint32_t stored_data_length = 0;
@ -2178,7 +2178,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
//Fill up the buffer
memcpy(card_data + stored_data_length, resp, 8);
stored_data_length += 8;
if (stored_data_length + 8 > USB_CMD_DATA_SIZE) {
if (stored_data_length + 8 > PM3_CMD_DATA_SIZE) {
//Time to send this off and start afresh
reply_old(CMD_ACK,
stored_data_length,//data length

2
armsrc/iso14443a.c
View file

@ -2406,7 +2406,7 @@ void ReaderIso14443a(PacketCommandNG *c) {
uint32_t timeout = c->oldarg[2];
uint8_t *cmd = c->data.asBytes;
uint32_t arg0;
uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
uint8_t par[MAX_PARITY_SIZE] = {0x00};
if ((param & ISO14A_CONNECT))

2
armsrc/iso14443a.h
View file

@ -17,7 +17,7 @@
extern "C" {
#endif
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "cmd.h"
#include "apps.h"
#include "util.h"

4
armsrc/iso14443b.c
View file

@ -1573,7 +1573,7 @@ void SendRawCommand14443B_Ex(PacketCommandNG *c) {
uint8_t *cmd = c->data.asBytes;
uint8_t status;
uint32_t sendlen = sizeof(iso14b_card_select_t);
uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
if (MF_DBGLEVEL > 3) Dbprintf("14b raw: param, %04x", param);
@ -1621,7 +1621,7 @@ void SendRawCommand14443B_Ex(PacketCommandNG *c) {
CodeAndTransmit14443bAsReader(cmd, len); // raw
GetTagSamplesFor14443bDemod(); // raw
sendlen = MIN(Demod.len, USB_CMD_DATA_SIZE);
sendlen = MIN(Demod.len, PM3_CMD_DATA_SIZE);
status = (Demod.len > 0) ? 0 : 1;
reply_old(CMD_ACK, status, sendlen, 0, Demod.output, sendlen);
}

14
armsrc/mifarecmd.c
View file

@ -621,7 +621,7 @@ void MifareAcquireNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *
uint8_t uid[10] = {0x00};
uint8_t answer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t par[1] = {0x00};
uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
uint32_t cuid = 0;
int16_t isOK = 0;
uint16_t num_nonces = 0;
@ -645,7 +645,7 @@ void MifareAcquireNonces(uint32_t arg0, uint32_t arg1, uint32_t flags, uint8_t *
LED_C_ON();
for (uint16_t i = 0; i <= USB_CMD_DATA_SIZE - 4; i += 4) {
for (uint16_t i = 0; i <= PM3_CMD_DATA_SIZE - 4; i += 4) {
// Test if the action was cancelled
if (BUTTON_PRESS()) {
@ -733,7 +733,7 @@ void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags,
uint8_t uid[10] = {0x00};
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t par_enc[1] = {0x00};
uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
uint64_t ui64Key = bytes_to_num(datain, 6);
uint32_t cuid = 0;
@ -763,7 +763,7 @@ void MifareAcquireEncryptedNonces(uint32_t arg0, uint32_t arg1, uint32_t flags,
LED_C_ON();
for (uint16_t i = 0; i <= USB_CMD_DATA_SIZE - 9;) {
for (uint16_t i = 0; i <= PM3_CMD_DATA_SIZE - 9;) {
// Test if the action was cancelled
if (BUTTON_PRESS()) {
@ -1645,11 +1645,11 @@ void MifareEMemSet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
void MifareEMemGet(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain) {
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint8_t buf[PM3_CMD_DATA_SIZE] = {0x00};
emlGetMem(buf, arg0, arg1); // data, block num, blocks count (max 4)
LED_B_ON();
reply_old(CMD_ACK, arg0, arg1, 0, buf, USB_CMD_DATA_SIZE);
reply_old(CMD_ACK, arg0, arg1, 0, buf, PM3_CMD_DATA_SIZE);
LED_B_OFF();
}
@ -1949,7 +1949,7 @@ void MifareCIdent() {
uint8_t recpar[1] = {0x00};
uint8_t rats[4] = { ISO14443A_CMD_RATS, 0x80, 0x31, 0x73 };
uint8_t *par = BigBuf_malloc(MAX_PARITY_SIZE);
uint8_t *buf = BigBuf_malloc(USB_CMD_DATA_SIZE);
uint8_t *buf = BigBuf_malloc(PM3_CMD_DATA_SIZE);
uint8_t *uid = BigBuf_malloc(10);
uint32_t cuid = 0;

8
armsrc/mifaredesfire.c
View file

@ -88,8 +88,8 @@ void MifareDesfireGetInformation() {
int len = 0;
iso14a_card_select_t card;
uint8_t resp[USB_CMD_DATA_SIZE] = {0x00};
uint8_t dataout[USB_CMD_DATA_SIZE] = {0x00};
uint8_t resp[PM3_CMD_DATA_SIZE] = {0x00};
uint8_t dataout[PM3_CMD_DATA_SIZE] = {0x00};
/*
1 = PCB 1
@ -505,7 +505,7 @@ int DesfireAPDU(uint8_t *cmd, size_t cmd_len, uint8_t *dataout) {
size_t len = 0;
size_t wrappedLen = 0;
uint8_t wCmd[USB_CMD_DATA_SIZE] = {0x00};
uint8_t wCmd[PM3_CMD_DATA_SIZE] = {0x00};
uint8_t resp[MAX_FRAME_SIZE];
uint8_t par[MAX_PARITY_SIZE];
@ -537,7 +537,7 @@ int DesfireAPDU(uint8_t *cmd, size_t cmd_len, uint8_t *dataout) {
// CreateAPDU
size_t CreateAPDU(uint8_t *datain, size_t len, uint8_t *dataout) {
size_t cmdlen = MIN(len + 4, USB_CMD_DATA_SIZE - 1);
size_t cmdlen = MIN(len + 4, PM3_CMD_DATA_SIZE - 1);
uint8_t cmd[cmdlen];
memset(cmd, 0, cmdlen);

2
armsrc/mifaresniff.c
View file

@ -315,7 +315,7 @@ void RAMFUNC MfSniffSend() {
while (packlen > 0) {
LED_B_ON();
chunksize = MIN(USB_CMD_DATA_SIZE, packlen); // chunk size 512
chunksize = MIN(PM3_CMD_DATA_SIZE, packlen); // chunk size 512
reply_old(CMD_ACK, 1, tracelen, chunksize, data + tracelen - packlen, chunksize);
packlen -= chunksize;
LED_B_OFF();

4
bootrom/bootrom.c
View file

@ -26,9 +26,9 @@ static int reply_old(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2,
txcmd.arg[1] = arg1;
txcmd.arg[2] = arg2;
// Add the (optional) content to the frame, with a maximum size of USB_CMD_DATA_SIZE
// Add the (optional) content to the frame, with a maximum size of PM3_CMD_DATA_SIZE
if (data && len) {
len = MIN(len, USB_CMD_DATA_SIZE);
len = MIN(len, PM3_CMD_DATA_SIZE);
for (size_t i = 0; i < len; i++) {
txcmd.d.asBytes[i] = ((uint8_t *)data)[i];
}

8
client/Makefile
View file

@ -283,7 +283,7 @@ ifeq "$(SUPPORTS_AVX512)" "True"
endif
BINS = proxmark3 flasher fpga_compress
CLEAN = $(BINS) $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(ZLIBOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(OBJDIR)/*.o *.moc.cpp ui/ui_overlays.h lualibs/usb_cmd.lua lualibs/mf_default_keys.lua
CLEAN = $(BINS) $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(ZLIBOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(OBJDIR)/*.o *.moc.cpp ui/ui_overlays.h lualibs/pm3_cmd.lua lualibs/mf_default_keys.lua
# need to assign dependancies to build these first...
all: lua_build jansson_build mbedtls_build cbor_build $(BINS)
@ -292,7 +292,7 @@ all-static: LDLIBS:=-static $(LDLIBS)
all-static: proxmark3 flasher fpga_compress
proxmark3: LDLIBS+=$(LUALIB) $(JANSSONLIB) $(MBEDTLSLIB) $(CBORLIB) $(QTLDLIBS)
proxmark3: $(OBJDIR)/proxmark3.o $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(ZLIBOBJS) lualibs/usb_cmd.lua lualibs/mf_default_keys.lua
proxmark3: $(OBJDIR)/proxmark3.o $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(ZLIBOBJS) lualibs/pm3_cmd.lua lualibs/mf_default_keys.lua
$(LD) $(LDFLAGS) $(OBJDIR)/proxmark3.o $(COREOBJS) $(CMDOBJS) $(OBJCOBJS) $(QTGUIOBJS) $(MULTIARCHOBJS) $(ZLIBOBJS) $(LDLIBS) -o $@
flasher: $(OBJDIR)/flash.o $(OBJDIR)/flasher.o $(COREOBJS) $(OBJCOBJS)
@ -309,8 +309,8 @@ proxguiqt.moc.cpp: proxguiqt.h
ui/ui_overlays.h: ui/overlays.ui
$(UIC) $^ > $@
lualibs/usb_cmd.lua: ../include/usb_cmd.h
awk -f usb_cmd_h2lua.awk $^ > $@
lualibs/pm3_cmd.lua: ../include/pm3_cmd.h
awk -f pm3_cmd_h2lua.awk $^ > $@
lualibs/mf_default_keys.lua : default_keys.dic
awk -f default_keys_dic2lua.awk $^ > $@

4
client/cmdanalyse.c
View file

@ -488,7 +488,7 @@ static int CmdAnalyseA(const char *Cmd) {
int hexlen = 0;
uint8_t cmdp = 0;
bool errors = false;
uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
switch (tolower(param_getchar(Cmd, cmdp))) {
@ -513,7 +513,7 @@ static int CmdAnalyseA(const char *Cmd) {
clearCommandBuffer();
SendCommandOLD(CMD_FPC_SEND, 0, 0, 0, data, USB_CMD_DATA_SIZE);
SendCommandOLD(CMD_FPC_SEND, 0, 0, 0, data, PM3_CMD_DATA_SIZE);
PacketResponseNG resp;
if (!WaitForResponseTimeout(CMD_ACK, &resp, 2500)) {

16
client/cmdhf14a.c
View file

@ -558,7 +558,7 @@ int ExchangeRAW14a(uint8_t *datain, int datainlen, bool activateField, bool leav
if (leaveSignalON)
cmdc |= ISO14A_NO_DISCONNECT;
uint8_t data[USB_CMD_DATA_SIZE] = { 0x0a | responseNum, 0x00};
uint8_t data[PM3_CMD_DATA_SIZE] = { 0x0a | responseNum, 0x00};
responseNum ^= 1;
memcpy(&data[2], datain, datainlen & 0xFFFF);
SendCommandOLD(CMD_READER_ISO_14443a, ISO14A_RAW | ISO14A_APPEND_CRC | cmdc, (datainlen & 0xFFFF) + 2, 0, data, (datainlen & 0xFFFF) + 2);
@ -688,7 +688,7 @@ static int CmdExchangeAPDU(bool chainingin, uint8_t *datain, int datainlen, bool
// "Command APDU" length should be 5+255+1, but javacard's APDU buffer might be smaller - 133 bytes
// https://stackoverflow.com/questions/32994936/safe-max-java-card-apdu-data-command-and-respond-size
// here length USB_CMD_DATA_SIZE=512
// here length PM3_CMD_DATA_SIZE=512
// timeout must be authomatically set by "get ATS"
if (datain)
SendCommandOLD(CMD_READER_ISO_14443a, ISO14A_APDU | ISO14A_NO_DISCONNECT | cmdc, (datainlen & 0xFFFF), 0, datain, datainlen & 0xFFFF);
@ -764,7 +764,7 @@ int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool lea
// 3 byte here - 1b framing header, 2b crc16
if (APDUInFramingEnable &&
((frameLength && (datainlen > frameLength - 3)) || (datainlen > USB_CMD_DATA_SIZE - 3))) {
((frameLength && (datainlen > frameLength - 3)) || (datainlen > PM3_CMD_DATA_SIZE - 3))) {
int clen = 0;
bool vActivateField = activateField;
@ -828,7 +828,7 @@ int ExchangeAPDU14a(uint8_t *datain, int datainlen, bool activateField, bool lea
// ISO14443-4. 7. Half-duplex block transmission protocol
static int CmdHF14AAPDU(const char *Cmd) {
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
int datalen = 0;
bool activateField = false;
bool leaveSignalON = false;
@ -857,7 +857,7 @@ static int CmdHF14AAPDU(const char *Cmd) {
CLIParserFree();
PrintAndLogEx(NORMAL, ">>>>[%s%s%s] %s", activateField ? "sel " : "", leaveSignalON ? "keep " : "", decodeTLV ? "TLV" : "", sprint_hex(data, datalen));
int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, USB_CMD_DATA_SIZE, &datalen);
int res = ExchangeAPDU14a(data, datalen, activateField, leaveSignalON, data, PM3_CMD_DATA_SIZE, &datalen);
if (res)
return res;
@ -887,7 +887,7 @@ static int CmdHF14ACmdRaw(const char *Cmd) {
bool topazmode = false;
char buf[5] = "";
int i = 0;
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
uint16_t datalen = 0;
uint32_t temp;
@ -1012,8 +1012,8 @@ static int CmdHF14ACmdRaw(const char *Cmd) {
flags |= ISO14A_NO_RATS;
}
// Max buffer is USB_CMD_DATA_SIZE
datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;
// Max buffer is PM3_CMD_DATA_SIZE
datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
clearCommandBuffer();
SendCommandOLD(CMD_READER_ISO_14443a, flags, (datalen & 0xFFFF) | ((uint32_t)(numbits << 16)), argtimeout, data, datalen & 0xFFFF);

8
client/cmdhf14b.c
View file

@ -121,7 +121,7 @@ static int switch_off_field_14b(void) {
static bool waitCmd14b(bool verbose) {
uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_ACK, &resp, TIMEOUT)) {
@ -188,7 +188,7 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
bool reply = true, power = false, select = false, hasTimeout = false;
char buf[5] = "";
int i = 0;
uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
uint16_t datalen = 0;
uint32_t flags = ISO14B_CONNECT;
uint32_t temp = 0, user_timeout = 0, time_wait = 0;
@ -270,8 +270,8 @@ static int CmdHF14BCmdRaw(const char *Cmd) {
if (datalen > 0)
flags |= ISO14B_RAW;
// Max buffer is USB_CMD_DATA_SIZE
datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;
// Max buffer is PM3_CMD_DATA_SIZE
datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
clearCommandBuffer();
SendCommandOLD(CMD_ISO_14443B_COMMAND, flags, datalen, time_wait, data, datalen);

8
client/cmdhf15.c
View file

@ -592,7 +592,7 @@ static int CmdHF15Info(const char *Cmd) {
PacketResponseNG resp;
uint8_t *recv;
uint8_t req[USB_CMD_DATA_SIZE] = {0};
uint8_t req[PM3_CMD_DATA_SIZE] = {0};
uint16_t reqlen;
uint8_t arg1 = 1;
char cmdbuf[100] = {0};
@ -932,7 +932,7 @@ static int CmdHF15Readmulti(const char *Cmd) {
PacketResponseNG resp;
uint8_t *recv;
uint8_t req[USB_CMD_DATA_SIZE] = {0};
uint8_t req[PM3_CMD_DATA_SIZE] = {0};
uint16_t reqlen = 0;
uint8_t arg1 = 1;
uint8_t pagenum, pagecount;
@ -1018,7 +1018,7 @@ static int CmdHF15Read(const char *Cmd) {
// arg0 (datalen, cmd len? .arg0 == crc?)
// arg1 (speed == 0 == 1 of 256, == 1 == 1 of 4 )
// arg2 (recv == 1 == expect a response)
uint8_t req[USB_CMD_DATA_SIZE] = {0};
uint8_t req[PM3_CMD_DATA_SIZE] = {0};
uint16_t reqlen = 0;
uint8_t arg1 = 1;
int blocknum;
@ -1085,7 +1085,7 @@ static int CmdHF15Write(const char *Cmd) {
PacketResponseNG resp;
uint8_t *recv;
uint8_t req[USB_CMD_DATA_SIZE] = {0};
uint8_t req[PM3_CMD_DATA_SIZE] = {0};
uint16_t reqlen = 0;
uint8_t arg1 = 1;
int pagenum, temp;

2
client/cmdhfepa.c
View file

@ -108,7 +108,7 @@ static int CmdHFEPAPACEReplay(const char *Cmd) {
}
// transfer the APDUs to the Proxmark
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
for (int i = 0; i < sizeof(apdu_lengths); i++) {
// transfer the APDU in several parts if necessary
for (int j = 0; j * sizeof(data) < apdu_lengths[i]; j++) {

6
client/cmdhffelica.c
View file

@ -429,7 +429,7 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) {
uint16_t numbits = 0;
char buf[5] = "";
int i = 0;
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
uint16_t datalen = 0;
uint32_t temp;
@ -518,8 +518,8 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) {
flags |= FELICA_RAW;
}
// Max buffer is USB_CMD_DATA_SIZE
datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;
// Max buffer is PM3_CMD_DATA_SIZE
datalen = (datalen > PM3_CMD_DATA_SIZE) ? PM3_CMD_DATA_SIZE : datalen;
clearCommandBuffer();
SendCommandOLD(CMD_FELICA_COMMAND, flags, (datalen & 0xFFFF) | (uint32_t)(numbits << 16), 0, data, datalen);

10
client/cmdhficlass.c
View file

@ -595,7 +595,7 @@ static int CmdHFiClassELoad(const char *Cmd) {
uint32_t bytes_remaining = bytes_read;
while (bytes_remaining > 0) {
uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
uint32_t bytes_in_packet = MIN(PM3_CMD_DATA_SIZE, bytes_remaining);
clearCommandBuffer();
SendCommandOLD(CMD_ICLASS_EML_MEMSET, bytes_sent, bytes_in_packet, 0, dump + bytes_sent, bytes_in_packet);
bytes_remaining -= bytes_in_packet;
@ -1272,10 +1272,10 @@ static int CmdHFiClassCloneTag(const char *Cmd) {
FILE *f;
iclass_block_t tag_data[USB_CMD_DATA_SIZE / 12];
iclass_block_t tag_data[PM3_CMD_DATA_SIZE / 12];
if ((endblock - startblock + 1) * 12 > USB_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "Trying to write too many blocks at once. Max: %d", USB_CMD_DATA_SIZE / 8);
if ((endblock - startblock + 1) * 12 > PM3_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "Trying to write too many blocks at once. Max: %d", PM3_CMD_DATA_SIZE / 8);
}
// file handling and reading
f = fopen(filename, "rb");
@ -1944,7 +1944,7 @@ static int CmdHFiClassCheckKeys(const char *Cmd) {
//PrintPreCalcMac(keyBlock, keycnt, pre);
// max 42 keys inside USB_COMMAND. 512/4 = 103 mac
uint32_t chunksize = keycnt > (USB_CMD_DATA_SIZE / 4) ? (USB_CMD_DATA_SIZE / 4) : keycnt;
uint32_t chunksize = keycnt > (PM3_CMD_DATA_SIZE / 4) ? (PM3_CMD_DATA_SIZE / 4) : keycnt;
bool lastChunk = false;
// fast push mode

2
client/cmdhficlass.h
View file

@ -29,7 +29,7 @@
#include "loclass/elite_crack.h"
#include "loclass/fileutils.h"
#include "protocols.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "cmdhfmfu.h"
#include "cmdhf.h"
#include "protocols.h" // picopass structs,

12
client/cmdhflegic.c
View file

@ -833,9 +833,9 @@ void legic_chk_iv(uint32_t *iv) {
}
void legic_seteml(uint8_t *src, uint32_t offset, uint32_t numofbytes) {
for (size_t i = offset; i < numofbytes; i += USB_CMD_DATA_SIZE) {
for (size_t i = offset; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
clearCommandBuffer();
SendCommandOLD(CMD_LEGIC_ESET, i, len, 0, src + i, len);
}
@ -1041,9 +1041,9 @@ static int CmdLegicRestore(const char *Cmd) {
// transfer to device
PacketResponseNG resp;
for (size_t i = 7; i < numofbytes; i += USB_CMD_DATA_SIZE) {
for (size_t i = 7; i < numofbytes; i += PM3_CMD_DATA_SIZE) {
size_t len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
size_t len = MIN((numofbytes - i), PM3_CMD_DATA_SIZE);
clearCommandBuffer();
SendCommandOLD(CMD_WRITER_LEGIC_RF, i, len, 0x55, data + i, len);
@ -1230,11 +1230,11 @@ static int CmdLegicWipe(const char *Cmd) {
// transfer to device
PacketResponseNG resp;
for (size_t i = 7; i < card.cardsize; i += USB_CMD_DATA_SIZE) {
for (size_t i = 7; i < card.cardsize; i += PM3_CMD_DATA_SIZE) {
printf(".");
fflush(stdout);
size_t len = MIN((card.cardsize - i), USB_CMD_DATA_SIZE);
size_t len = MIN((card.cardsize - i), PM3_CMD_DATA_SIZE);
clearCommandBuffer();
SendCommandOLD(CMD_WRITER_LEGIC_RF, i, len, 0x55, data + i, len);

4
client/cmdhfmf.c
View file

@ -1661,7 +1661,7 @@ static int CmdHF14AMfChk_fast(const char *Cmd) {
return 1;
}
uint32_t chunksize = keycnt > (USB_CMD_DATA_SIZE / 6) ? (USB_CMD_DATA_SIZE / 6) : keycnt;
uint32_t chunksize = keycnt > (PM3_CMD_DATA_SIZE / 6) ? (PM3_CMD_DATA_SIZE / 6) : keycnt;
bool firstChunk = true, lastChunk = false;
// time
@ -1933,7 +1933,7 @@ static int CmdHF14AMfChk(const char *Cmd) {
uint8_t trgKeyType = 0;
uint32_t max_keys = keycnt > ((USB_CMD_DATA_SIZE - 4) / 6) ? ((USB_CMD_DATA_SIZE - 4) / 6) : keycnt;
uint32_t max_keys = keycnt > ((PM3_CMD_DATA_SIZE - 4) / 6) ? ((PM3_CMD_DATA_SIZE - 4) / 6) : keycnt;
// time
uint64_t t1 = msclock();

6
client/cmdhw.c
View file

@ -442,12 +442,12 @@ static int CmdPing(const char *Cmd) {
static int CmdPingNG(const char *Cmd) {
uint32_t len = strtol(Cmd, NULL, 0);
if (len > USB_CMD_DATA_SIZE)
len = USB_CMD_DATA_SIZE;
if (len > PM3_CMD_DATA_SIZE)
len = PM3_CMD_DATA_SIZE;
PrintAndLogEx(NORMAL, "PingNG sent with payload len=%d", len);
clearCommandBuffer();
PacketResponseNG resp;
uint8_t data[USB_CMD_DATA_SIZE] = {0};
uint8_t data[PM3_CMD_DATA_SIZE] = {0};
for (uint16_t i = 0; i < len; i++)
data[i] = i & 0xFF;
SendCommandNG(CMD_PING, data, len);

24
client/cmdlf.c
View file

@ -149,7 +149,7 @@ int CmdLFCommandRead(const char *Cmd) {
uint32_t arg0 = 0;
uint32_t arg1 = 0;
uint32_t arg2 = 0;
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
uint16_t datalen = 0;
uint8_t cmdp = 0;
@ -423,9 +423,9 @@ int CmdLFSim(const char *Cmd) {
conn.block_after_ACK = true;
//can send only 512 bits at a time (1 byte sent per bit...)
for (uint16_t i = 0; i < GraphTraceLen; i += USB_CMD_DATA_SIZE) {
for (uint16_t i = 0; i < GraphTraceLen; i += PM3_CMD_DATA_SIZE) {
clearCommandBuffer();
SendCommandOLD(CMD_UPLOAD_SIM_SAMPLES_125K, i, FPGA_LF, 0, &GraphBuffer[i], USB_CMD_DATA_SIZE);
SendCommandOLD(CMD_UPLOAD_SIM_SAMPLES_125K, i, FPGA_LF, 0, &GraphBuffer[i], PM3_CMD_DATA_SIZE);
WaitForResponse(CMD_ACK, NULL);
printf(".");
fflush(stdout);
@ -518,9 +518,9 @@ int CmdLFfskSim(const char *Cmd) {
if (fcLow == 0) fcLow = 8;
size_t size = DemodBufferLen;
if (size > USB_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
size = USB_CMD_DATA_SIZE;
if (size > PM3_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, PM3_CMD_DATA_SIZE);
size = PM3_CMD_DATA_SIZE;
}
clearCommandBuffer();
SendCommandOLD(CMD_FSK_SIM_TAG, fcHigh << 8 | fcLow, (separator << 8) | clk, size, DemodBuffer, size);
@ -603,9 +603,9 @@ int CmdLFaskSim(const char *Cmd) {
if (encoding == 0) clk /= 2; //askraw needs to double the clock speed
size_t size = DemodBufferLen;
if (size > USB_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
size = USB_CMD_DATA_SIZE;
if (size > PM3_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, PM3_CMD_DATA_SIZE);
size = PM3_CMD_DATA_SIZE;
}
PrintAndLogEx(NORMAL, "preparing to sim ask data: %d bits", size);
@ -707,9 +707,9 @@ int CmdLFpskSim(const char *Cmd) {
}
}
size_t size = DemodBufferLen;
if (size > USB_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
size = USB_CMD_DATA_SIZE;
if (size > PM3_CMD_DATA_SIZE) {
PrintAndLogEx(NORMAL, "DemodBuffer too long for current implementation - length: %d - max: %d", size, PM3_CMD_DATA_SIZE);
size = PM3_CMD_DATA_SIZE;
}
PrintAndLogEx(DEBUG, "DEBUG: Sending DemodBuffer Length: %d", size);
clearCommandBuffer();

6
client/cmdlfhitag.c
View file

@ -128,7 +128,7 @@ static int CmdLFHitagList(const char *Cmd) {
return 0;
/*
uint8_t *got = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
uint8_t *got = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (!got) {
PrintAndLogEx(WARNING, "Cannot allocate memory for trace");
return 2;
@ -136,14 +136,14 @@ static int CmdLFHitagList(const char *Cmd) {
// Query for the actual size of the trace
PacketResponseNG response;
if (!GetFromDevice(BIG_BUF, got, USB_CMD_DATA_SIZE, 0, &response, 2500, false)) {
if (!GetFromDevice(BIG_BUF, got, PM3_CMD_DATA_SIZE, 0, &response, 2500, false)) {
PrintAndLogEx(WARNING, "command execution time out");
free(got);
return 2;
}
uint16_t traceLen = response.arg[2];
if (traceLen > USB_CMD_DATA_SIZE) {
if (traceLen > PM3_CMD_DATA_SIZE) {
uint8_t *p = realloc(got, traceLen);
if (p == NULL) {
PrintAndLogEx(WARNING, "Cannot allocate memory for trace");

2
client/cmdmain.h
View file

@ -19,7 +19,7 @@
#include <string.h>
#include "util_posix.h"
#include "proxmark3.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "util.h"
#include "ui.h"
#include "cmdparser.h"

18
client/cmdsmartcard.c
View file

@ -395,7 +395,7 @@ static int CmdSmartRaw(const char *Cmd) {
bool useT0 = false;
uint8_t cmdp = 0;
bool errors = false, reply = true, decodeTLV = false, breakloop = false;
uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
uint8_t data[PM3_CMD_DATA_SIZE] = {0x00};
while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
switch (tolower(param_getchar(Cmd, cmdp))) {
@ -470,7 +470,7 @@ static int CmdSmartRaw(const char *Cmd) {
// reading response from smart card
if (reply) {
uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (!buf)
return 1;
@ -644,7 +644,7 @@ static int CmdSmartUpgrade(const char *Cmd) {
uint32_t bytes_remaining = firmware_size;
while (bytes_remaining > 0) {
uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
uint32_t bytes_in_packet = MIN(PM3_CMD_DATA_SIZE, bytes_remaining);
clearCommandBuffer();
SendCommandOLD(CMD_SMART_UPLOAD, index + bytes_sent, bytes_in_packet, 0, dump + bytes_sent, bytes_in_packet);
if (!WaitForResponseTimeout(CMD_ACK, NULL, 2000)) {
@ -858,7 +858,7 @@ static int CmdSmartList(const char *Cmd) {
static void smart_brute_prim() {
uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (!buf)
return;
@ -891,7 +891,7 @@ static void smart_brute_prim() {
static int smart_brute_sfi(bool decodeTLV) {
uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (!buf)
return 1;
@ -945,7 +945,7 @@ static int smart_brute_sfi(bool decodeTLV) {
}
}
}
memset(buf, 0x00, USB_CMD_DATA_SIZE);
memset(buf, 0x00, PM3_CMD_DATA_SIZE);
}
}
free(buf);
@ -954,7 +954,7 @@ static int smart_brute_sfi(bool decodeTLV) {
static void smart_brute_options(bool decodeTLV) {
uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (!buf)
return;
@ -1019,7 +1019,7 @@ static int CmdSmartBruteforceSFI(const char *Cmd) {
json_t *root = NULL;
smart_loadjson("aidlist", "json", &root);
uint8_t *buf = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
uint8_t *buf = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (!buf)
return 1;
@ -1064,7 +1064,7 @@ static int CmdSmartBruteforceSFI(const char *Cmd) {
snprintf(caid, 8 + 2 + aidlen + 1, SELECT, aidlen >> 1, aid);
int hexlen = 0;
uint8_t cmddata[USB_CMD_DATA_SIZE];
uint8_t cmddata[PM3_CMD_DATA_SIZE];
int res = param_gethex_to_eol(caid, 0, cmddata, sizeof(cmddata), &hexlen);
if (res)
continue;

8
client/cmdtrace.c
View file

@ -664,18 +664,18 @@ int CmdTraceList(const char *Cmd) {
// reserv some space.
if (!trace)
trace = calloc(USB_CMD_DATA_SIZE, sizeof(uint8_t));
trace = calloc(PM3_CMD_DATA_SIZE, sizeof(uint8_t));
if (isOnline) {
// Query for the size of the trace, downloading USB_CMD_DATA_SIZE
// Query for the size of the trace, downloading PM3_CMD_DATA_SIZE
PacketResponseNG response;
if (!GetFromDevice(BIG_BUF, trace, USB_CMD_DATA_SIZE, 0, &response, 4000, true)) {
if (!GetFromDevice(BIG_BUF, trace, PM3_CMD_DATA_SIZE, 0, &response, 4000, true)) {
PrintAndLogEx(WARNING, "timeout while waiting for reply.");
return 1;
}
traceLen = response.oldarg[2];
if (traceLen > USB_CMD_DATA_SIZE) {
if (traceLen > PM3_CMD_DATA_SIZE) {
uint8_t *p = realloc(trace, traceLen);
if (p == NULL) {
PrintAndLogEx(FAILED, "Cannot allocate memory for trace");

20
client/comms.c
View file

@ -123,7 +123,7 @@ static void SendCommandNG_internal(uint16_t cmd, uint8_t *data, size_t len, bool
PrintAndLogEx(NORMAL, "Sending bytes to proxmark failed - offline");
return;
}
if (len > USB_CMD_DATA_SIZE) {
if (len > PM3_CMD_DATA_SIZE) {
PrintAndLogEx(WARNING, "Sending %d bytes of payload is too much, abort", len);
return;
}
@ -182,11 +182,11 @@ 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) {
uint64_t arg[3] = {arg0, arg1, arg2};
if (len > USB_CMD_DATA_SIZE_MIX) {
if (len > PM3_CMD_DATA_SIZE_MIX) {
PrintAndLogEx(WARNING, "Sending %d bytes of payload is too much for MIX frames, abort", len);
return;
}
uint8_t cmddata[USB_CMD_DATA_SIZE];
uint8_t cmddata[PM3_CMD_DATA_SIZE];
memcpy(cmddata, arg, sizeof(arg));
if (len && data)
memcpy(cmddata + sizeof(arg), data, len);
@ -307,7 +307,7 @@ static void PacketResponseReceived(PacketResponseNG *packet) {
// First check if we are handling a debug message
case CMD_DEBUG_PRINT_STRING: {
char s[USB_CMD_DATA_SIZE + 1];
char s[PM3_CMD_DATA_SIZE + 1];
memset(s, 0x00, sizeof(s));
size_t len;
@ -315,14 +315,14 @@ static void PacketResponseReceived(PacketResponseNG *packet) {
if (packet->ng) {
struct d {
uint16_t flag;
uint8_t buf[USB_CMD_DATA_SIZE - sizeof(uint16_t)];
uint8_t buf[PM3_CMD_DATA_SIZE - sizeof(uint16_t)];
} PACKED;
struct d *data = (struct d *)&packet->data.asBytes;
len = packet->length - sizeof(data->flag);
flag = data->flag;
memcpy_filtered(s, data->buf, len, flag & FLAG_ANSI);
} else {
len = MIN(packet->oldarg[0], USB_CMD_DATA_SIZE);
len = MIN(packet->oldarg[0], PM3_CMD_DATA_SIZE);
flag = packet->oldarg[1];
memcpy_filtered(s, packet->data.asBytes, len, flag & FLAG_ANSI);
}
@ -410,7 +410,7 @@ __attribute__((force_align_arg_pointer))
rx.status = rx_raw.pre.status;
rx.cmd = rx_raw.pre.cmd;
if (rx.magic == RESPONSENG_PREAMBLE_MAGIC) { // New style NG reply
if (length > USB_CMD_DATA_SIZE) {
if (length > PM3_CMD_DATA_SIZE) {
PrintAndLogEx(WARNING, "Received packet frame with incompatible length: 0x%04x", length);
error = true;
}
@ -496,7 +496,7 @@ __attribute__((force_align_arg_pointer))
rx.oldarg[0] = rx_old.arg[0];
rx.oldarg[1] = rx_old.arg[1];
rx.oldarg[2] = rx_old.arg[2];
rx.length = USB_CMD_DATA_SIZE;
rx.length = PM3_CMD_DATA_SIZE;
memcpy(&rx.data, &rx_old.d, rx.length);
PacketResponseReceived(&rx);
if (rx.cmd == CMD_ACK) {
@ -829,9 +829,9 @@ static bool dl_it(uint8_t *dest, uint32_t bytes, uint32_t start_index, PacketRes
uint32_t copy_bytes = MIN(bytes - bytes_completed, response->oldarg[1]);
//uint32_t tracelen = response->oldarg[2];
// extended bounds check1. upper limit is USB_CMD_DATA_SIZE
// extended bounds check1. upper limit is PM3_CMD_DATA_SIZE
// shouldn't happen
copy_bytes = MIN(copy_bytes, USB_CMD_DATA_SIZE);
copy_bytes = MIN(copy_bytes, PM3_CMD_DATA_SIZE);
// extended bounds check2.
if (offset + copy_bytes > bytes) {

2
client/comms.h
View file

@ -15,7 +15,7 @@
#include <stdbool.h>
#include <pthread.h>
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "uart.h"
#include "ui.h"
#include "common.h"

2
client/flash.h
View file

@ -18,7 +18,7 @@
#include "proxmark3.h"
#include "elf.h"
#include "proxendian.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "at91sam7s512.h"
#include "util_posix.h"
#include "util.h"

2
client/flasher.c
View file

@ -16,7 +16,7 @@
#include "util.h"
#include "flash.h"
#include "comms.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#define MAX_FILES 4

12
client/mifare/mifarehost.c
View file

@ -89,8 +89,8 @@ int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) {
PrintAndLogEx(SUCCESS, "found %u candidate key%s\n", keycount, (keycount > 1) ? "s." : ".");
*key = UINT64_C(-1);
uint8_t keyBlock[USB_CMD_DATA_SIZE];
uint32_t max_keys = (USB_CMD_DATA_SIZE - 4) / 6;
uint8_t keyBlock[PM3_CMD_DATA_SIZE];
uint32_t max_keys = (PM3_CMD_DATA_SIZE - 4) / 6;
for (uint32_t i = 0; i < keycount; i += max_keys) {
uint32_t size = keycount - i > max_keys ? max_keys : keycount - i;
@ -123,7 +123,7 @@ int mfDarkside(uint8_t blockno, uint8_t key_type, uint64_t *key) {
int mfCheckKeys(uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t *keyBlock, uint64_t *key) {
*key = -1;
clearCommandBuffer();
uint8_t data[USB_CMD_DATA_SIZE] = {0};
uint8_t data[PM3_CMD_DATA_SIZE] = {0};
data[0] = keyType;
data[1] = blockNo;
data[2] = clear_trace;
@ -220,7 +220,7 @@ int mfCheckKeys_fast(uint8_t sectorsCnt, uint8_t firstChunk, uint8_t lastChunk,
// ref: https://github.com/J-Run/mf_key_brute
int mfKeyBrute(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint64_t *resultkey) {
#define KEYS_IN_BLOCK ((USB_CMD_DATA_SIZE - 4) / 6)
#define KEYS_IN_BLOCK ((PM3_CMD_DATA_SIZE - 4) / 6)
#define KEYBLOCK_SIZE (KEYS_IN_BLOCK * 6)
#define CANDIDATE_SIZE (0xFFFF * 6)
@ -379,8 +379,8 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo,
uint64_t key64 = -1;
// The list may still contain several key candidates. Test each of them with mfCheckKeys
uint32_t max_keys = keycnt > ((USB_CMD_DATA_SIZE - 4) / 6) ? ((USB_CMD_DATA_SIZE - 4) / 6) : keycnt;
uint8_t keyBlock[USB_CMD_DATA_SIZE] = {0x00};
uint32_t max_keys = keycnt > ((PM3_CMD_DATA_SIZE - 4) / 6) ? ((PM3_CMD_DATA_SIZE - 4) / 6) : keycnt;
uint8_t keyBlock[PM3_CMD_DATA_SIZE] = {0x00};
for (i = 0; i < keycnt; i += max_keys) {

2
client/usb_cmd_h2lua.awk → client/pm3_cmd_h2lua.awk
View file

@ -1,7 +1,7 @@
BEGIN {
print "--[["
print "These are Proxmark command definitions."
print "This file is automatically generated from usb_cmd.h - DON'T EDIT MANUALLY."
print "This file is automatically generated from pm3_cmd.h - DON'T EDIT MANUALLY."
print "--]]"
print "local __commands = {"
}

2
client/proxmark3.h
View file

@ -12,7 +12,7 @@
#ifndef PROXMARK3_H__
#define PROXMARK3_H__
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "cmdscript.h" // CmdScriptRun
#define PROXPROMPT "pm3 --> "

10
client/scripting.c
View file

@ -90,7 +90,7 @@ static int l_SendCommandOLD(lua_State *L) {
// (uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len)
uint64_t cmd, arg0, arg1, arg2;
uint8_t data[USB_CMD_DATA_SIZE] = {0};
uint8_t data[PM3_CMD_DATA_SIZE] = {0};
size_t len = 0, size;
//Check number of arguments
@ -138,7 +138,7 @@ static int l_SendCommandOLD(lua_State *L) {
static int l_SendCommandMIX(lua_State *L) {
uint64_t cmd, arg0, arg1, arg2;
uint8_t data[USB_CMD_DATA_SIZE] = {0};
uint8_t data[PM3_CMD_DATA_SIZE] = {0};
size_t len = 0, size;
// check number of arguments
@ -180,7 +180,7 @@ static int l_SendCommandMIX(lua_State *L) {
*/
static int l_SendCommandNG(lua_State *L) {
uint8_t data[USB_CMD_DATA_SIZE] = {0};
uint8_t data[PM3_CMD_DATA_SIZE] = {0};
size_t len = 0, size;
// check number of arguments
@ -414,7 +414,7 @@ static int l_CmdConsole(lua_State *L) {
static int l_iso15693_crc(lua_State *L) {
uint32_t tmp;
unsigned char buf[USB_CMD_DATA_SIZE] = {0x00};
unsigned char buf[PM3_CMD_DATA_SIZE] = {0x00};
size_t size = 0;
const char *data = luaL_checklstring(L, 1, &size);
@ -431,7 +431,7 @@ static int l_iso15693_crc(lua_State *L) {
static int l_iso14443b_crc(lua_State *L) {
uint32_t tmp;
unsigned char buf[USB_CMD_DATA_SIZE] = {0x00};
unsigned char buf[PM3_CMD_DATA_SIZE] = {0x00};
size_t size = 0;
const char *data = luaL_checklstring(L, 1, &size);

2
client/scripting.h
View file

@ -15,7 +15,7 @@
#include <lualib.h>
#include <lauxlib.h>
#include "proxmark3.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "cmdmain.h"
#include "comms.h"
#include "util.h"

2
common/Makefile.common
View file

@ -62,7 +62,7 @@ endif
# Also search prerequisites in the common directory (for usb.c), the fpga directory (for fpga.bit), and the zlib directory
VPATH = . ../common ../common/crapto1 ../common/polarssl ../fpga ../zlib ../armsrc/Standalone ../uart
INCLUDES = ../include/proxmark3.h ../include/at91sam7s512.h ../include/config_gpio.h ../include/usb_cmd.h $(APP_INCLUDES)
INCLUDES = ../include/proxmark3.h ../include/at91sam7s512.h ../include/config_gpio.h ../include/pm3_cmd.h $(APP_INCLUDES)
CFLAGS = -c $(INCLUDE) -Wall -Werror -pedantic -Wunused -std=c99 $(APP_CFLAGS) -Os
LDFLAGS = -nostartfiles -nodefaultlibs -Wl,-gc-sections -n

20
common/cmd.c
View file

@ -59,9 +59,9 @@ int reply_old(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *d
txcmd.arg[1] = arg1;
txcmd.arg[2] = arg2;
// Add the (optional) content to the frame, with a maximum size of USB_CMD_DATA_SIZE
// Add the (optional) content to the frame, with a maximum size of PM3_CMD_DATA_SIZE
if (data && len) {
len = MIN(len, USB_CMD_DATA_SIZE);
len = MIN(len, PM3_CMD_DATA_SIZE);
for (size_t i = 0; i < len; i++) {
txcmd.d.asBytes[i] = ((uint8_t *)data)[i];
}
@ -95,14 +95,14 @@ static int reply_ng_internal(uint16_t cmd, int16_t status, uint8_t *data, size_t
txBufferNG.pre.cmd = cmd;
txBufferNG.pre.status = status;
txBufferNG.pre.ng = ng;
if (len > USB_CMD_DATA_SIZE) {
len = USB_CMD_DATA_SIZE;
if (len > PM3_CMD_DATA_SIZE) {
len = PM3_CMD_DATA_SIZE;
// overwrite status
txBufferNG.pre.status = PM3_EOVFLOW;
}
txBufferNG.pre.length = len;
// Add the (optional) content to the frame, with a maximum size of USB_CMD_DATA_SIZE
// Add the (optional) content to the frame, with a maximum size of PM3_CMD_DATA_SIZE
if (data && len) {
for (size_t i = 0; i < len; i++) {
txBufferNG.data[i] = data[i];
@ -143,11 +143,11 @@ int reply_ng(uint16_t cmd, int16_t status, uint8_t *data, size_t len) {
int reply_mix(uint64_t cmd, uint64_t arg0, uint64_t arg1, uint64_t arg2, void *data, size_t len) {
uint16_t status = PM3_SUCCESS;
uint64_t arg[3] = {arg0, arg1, arg2};
if (len > USB_CMD_DATA_SIZE - sizeof(arg)) {
len = USB_CMD_DATA_SIZE - sizeof(arg);
if (len > PM3_CMD_DATA_SIZE - sizeof(arg)) {
len = PM3_CMD_DATA_SIZE - sizeof(arg);
status = PM3_EOVFLOW;
}
uint8_t cmddata[USB_CMD_DATA_SIZE];
uint8_t cmddata[PM3_CMD_DATA_SIZE];
memcpy(cmddata, arg, sizeof(arg));
if (len && data)
memcpy(cmddata + sizeof(arg), data, len);
@ -166,7 +166,7 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da
uint16_t length = rx_raw.pre.length;
rx->cmd = rx_raw.pre.cmd;
if (rx->magic == COMMANDNG_PREAMBLE_MAGIC) { // New style NG command
if (length > USB_CMD_DATA_SIZE)
if (length > PM3_CMD_DATA_SIZE)
return PM3_EOVFLOW;
// Get the core and variable length payload
bytes = read_ng((uint8_t *)&rx_raw.data, length);
@ -213,7 +213,7 @@ static int receive_ng_internal(PacketCommandNG *rx, uint32_t read_ng(uint8_t *da
rx->oldarg[0] = rx_old.arg[0];
rx->oldarg[1] = rx_old.arg[1];
rx->oldarg[2] = rx_old.arg[2];
rx->length = USB_CMD_DATA_SIZE;
rx->length = PM3_CMD_DATA_SIZE;
memcpy(&rx->data, &rx_old.d.asBytes, rx->length);
}
return PM3_SUCCESS;

2
common/cmd.h
View file

@ -34,7 +34,7 @@
#define _PROXMARK_CMD_H_
#include "common.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#include "usb_cdc.h"
#include "usart.h"
#include "proxmark3.h"

24
include/usb_cmd.h → include/pm3_cmd.h
View file

@ -27,15 +27,15 @@ typedef BYTE uint8_t;
#define PACKED __attribute__((packed))
#endif
#define USB_CMD_DATA_SIZE 512
#define USB_CMD_DATA_SIZE_MIX ( USB_CMD_DATA_SIZE - 3 * sizeof(uint64_t) )
#define PM3_CMD_DATA_SIZE 512
#define PM3_CMD_DATA_SIZE_MIX ( PM3_CMD_DATA_SIZE - 3 * sizeof(uint64_t) )
typedef struct {
uint64_t cmd;
uint64_t arg[3];
union {
uint8_t asBytes[USB_CMD_DATA_SIZE];
uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
uint8_t asBytes[PM3_CMD_DATA_SIZE];
uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
} d;
} PACKED PacketCommandOLD;
@ -61,8 +61,8 @@ typedef struct {
uint16_t crc; // NG
uint64_t oldarg[3]; // OLD
union {
uint8_t asBytes[USB_CMD_DATA_SIZE];
uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
uint8_t asBytes[PM3_CMD_DATA_SIZE];
uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
} data;
bool ng; // does it store NG data or OLD data?
} PACKED PacketCommandNG;
@ -70,7 +70,7 @@ typedef struct {
// For reception and CRC check
typedef struct {
PacketCommandNGPreamble pre;
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
PacketCommandNGPostamble foopost; // Probably not at that offset!
} PACKED PacketCommandNGRaw;
@ -78,8 +78,8 @@ typedef struct {
uint64_t cmd;
uint64_t arg[3];
union {
uint8_t asBytes[USB_CMD_DATA_SIZE];
uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
uint8_t asBytes[PM3_CMD_DATA_SIZE];
uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
} d;
} PACKED PacketResponseOLD;
@ -107,8 +107,8 @@ typedef struct {
uint16_t crc; // NG
uint64_t oldarg[3]; // OLD
union {
uint8_t asBytes[USB_CMD_DATA_SIZE];
uint32_t asDwords[USB_CMD_DATA_SIZE / 4];
uint8_t asBytes[PM3_CMD_DATA_SIZE];
uint32_t asDwords[PM3_CMD_DATA_SIZE / 4];
} data;
bool ng; // does it store NG data or OLD data?
} PACKED PacketResponseNG;
@ -116,7 +116,7 @@ typedef struct {
// For reception and CRC check
typedef struct {
PacketResponseNGPreamble pre;
uint8_t data[USB_CMD_DATA_SIZE];
uint8_t data[PM3_CMD_DATA_SIZE];
PacketResponseNGPostamble foopost; // Probably not at that offset!
} PACKED PacketResponseNGRaw;

2
include/proxmark3.h
View file

@ -14,7 +14,7 @@
// Might as well have the hardware-specific defines everywhere.
#include "at91sam7s512.h"
#include "config_gpio.h"
#include "usb_cmd.h"
#include "pm3_cmd.h"
#define WDT_HIT() AT91C_BASE_WDTC->WDTC_WDCR = 0xa5000001

2
uart/uart_posix.c
View file

@ -67,7 +67,7 @@ typedef struct {
term_info tiNew; // Terminal info during the transaction
} serial_port_unix;
// see usb_cmd.h
// see pm3_cmd.h
struct timeval timeout = {
.tv_sec = 0, // 0 second
.tv_usec = UART_FPC_CLIENT_RX_TIMEOUT_MS * 1000