From 4e31c6110bc153d16fe1363cadce8622906d0c5b Mon Sep 17 00:00:00 2001 From: Philippe Teuwen Date: Thu, 18 Apr 2019 00:12:52 +0200 Subject: [PATCH] Better Command structs --- armsrc/appmain.c | 315 +++++++++++++++++++++++---------------------- armsrc/epa.c | 18 +-- armsrc/felica.c | 6 +- armsrc/iso14443a.c | 10 +- armsrc/iso14443b.c | 8 +- bootrom/bootrom.c | 14 +- client/comms.c | 20 +-- include/usb_cmd.h | 34 +++-- 8 files changed, 219 insertions(+), 206 deletions(-) diff --git a/armsrc/appmain.c b/armsrc/appmain.c index bab5ada6e..dd029b3e2 100644 --- a/armsrc/appmain.c +++ b/armsrc/appmain.c @@ -634,32 +634,29 @@ void ListenReaderField(int limit) { } static void UsbPacketReceived(UsbCommandNG *packet) { - uint64_t cmd; // To accommodate old cmd, can be reduced to uint16_t once all old cmds are gone. - - // For cmd handlers still using old cmd format: +/* if (packet->ng) { - cmd = packet->core.ng.cmd; -// Dbprintf("received NG frame with %d bytes payload, with command: 0x%04x", packet->length, cmd); + Dbprintf("received NG frame with %d bytes payload, with command: 0x%04x", packet->length, cmd); } else { - cmd = packet->core.old.cmd; -// Dbprintf("received OLD frame of %d bytes, with command: 0x%04x and args: %d %d %d", packet->length, packet->core.old.cmd, packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + Dbprintf("received OLD frame of %d bytes, with command: 0x%04x and args: %d %d %d", packet->length, packet->cmd, packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); } +*/ - switch (cmd) { + switch (packet->cmd) { #ifdef WITH_LF case CMD_SET_LF_T55XX_CONFIG: - setT55xxConfig(packet->core.old.arg[0], (t55xx_config *) packet->core.old.d.asBytes); + setT55xxConfig(packet->oldarg[0], (t55xx_config *) packet->data.asBytes); break; case CMD_SET_LF_SAMPLING_CONFIG: - setSamplingConfig((sample_config *) packet->core.old.d.asBytes); + setSamplingConfig((sample_config *) packet->data.asBytes); break; case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K: { - uint32_t bits = SampleLF(packet->core.old.arg[0], packet->core.old.arg[1]); + uint32_t bits = SampleLF(packet->oldarg[0], packet->oldarg[1]); cmd_send(CMD_ACK, bits, 0, 0, 0, 0); break; } case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K: - ModThenAcquireRawAdcSamples125k(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + ModThenAcquireRawAdcSamples125k(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_LF_SNIFF_RAW_ADC_SAMPLES: { uint32_t bits = SniffLF(); @@ -668,73 +665,73 @@ static void UsbPacketReceived(UsbCommandNG *packet) { } case CMD_HID_DEMOD_FSK: { uint32_t high, low; - CmdHIDdemodFSK(packet->core.old.arg[0], &high, &low, 1); + CmdHIDdemodFSK(packet->oldarg[0], &high, &low, 1); break; } case CMD_HID_SIM_TAG: - CmdHIDsimTAG(packet->core.old.arg[0], packet->core.old.arg[1], 1); + CmdHIDsimTAG(packet->oldarg[0], packet->oldarg[1], 1); break; case CMD_FSK_SIM_TAG: - CmdFSKsimTAG(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes, 1); + CmdFSKsimTAG(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes, 1); break; case CMD_ASK_SIM_TAG: - CmdASKsimTag(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes, 1); + CmdASKsimTag(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes, 1); break; case CMD_PSK_SIM_TAG: - CmdPSKsimTag(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes, 1); + CmdPSKsimTag(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes, 1); break; case CMD_HID_CLONE_TAG: - CopyHIDtoT55x7(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes[0]); + CopyHIDtoT55x7(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes[0]); break; case CMD_IO_DEMOD_FSK: { uint32_t high, low; - CmdIOdemodFSK(packet->core.old.arg[0], &high, &low, 1); + CmdIOdemodFSK(packet->oldarg[0], &high, &low, 1); break; } case CMD_IO_CLONE_TAG: - CopyIOtoT55x7(packet->core.old.arg[0], packet->core.old.arg[1]); + CopyIOtoT55x7(packet->oldarg[0], packet->oldarg[1]); break; case CMD_EM410X_DEMOD: { uint32_t high; uint64_t low; - CmdEM410xdemod(packet->core.old.arg[0], &high, &low, 1); + CmdEM410xdemod(packet->oldarg[0], &high, &low, 1); break; } case CMD_EM410X_WRITE_TAG: - WriteEM410x(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + WriteEM410x(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_READ_TI_TYPE: ReadTItag(); break; case CMD_WRITE_TI_TYPE: - WriteTItag(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + WriteTItag(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_SIMULATE_TAG_125K: LED_A_ON(); - SimulateTagLowFrequency(packet->core.old.arg[0], packet->core.old.arg[1], 1); + SimulateTagLowFrequency(packet->oldarg[0], packet->oldarg[1], 1); LED_A_OFF(); break; case CMD_LF_SIMULATE_BIDIR: - SimulateTagLowFrequencyBidir(packet->core.old.arg[0], packet->core.old.arg[1]); + SimulateTagLowFrequencyBidir(packet->oldarg[0], packet->oldarg[1]); break; case CMD_INDALA_CLONE_TAG: - CopyIndala64toT55x7(packet->core.old.d.asDwords[0], packet->core.old.d.asDwords[1]); + CopyIndala64toT55x7(packet->data.asDwords[0], packet->data.asDwords[1]); break; case CMD_INDALA_CLONE_TAG_L: CopyIndala224toT55x7( - packet->core.old.d.asDwords[0], packet->core.old.d.asDwords[1], packet->core.old.d.asDwords[2], packet->core.old.d.asDwords[3], - packet->core.old.d.asDwords[4], packet->core.old.d.asDwords[5], packet->core.old.d.asDwords[6] + packet->data.asDwords[0], packet->data.asDwords[1], packet->data.asDwords[2], packet->data.asDwords[3], + packet->data.asDwords[4], packet->data.asDwords[5], packet->data.asDwords[6] ); break; case CMD_T55XX_READ_BLOCK: { - T55xxReadBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + T55xxReadBlock(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; } case CMD_T55XX_WRITE_BLOCK: - T55xxWriteBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes[0]); + T55xxWriteBlock(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes[0]); break; case CMD_T55XX_WAKEUP: - T55xxWakeUp(packet->core.old.arg[0]); + T55xxWakeUp(packet->oldarg[0]); break; case CMD_T55XX_RESET_READ: T55xxResetRead(); @@ -747,58 +744,58 @@ static void UsbPacketReceived(UsbCommandNG *packet) { break; case CMD_PCF7931_WRITE: WritePCF7931( - packet->core.old.d.asBytes[0], packet->core.old.d.asBytes[1], packet->core.old.d.asBytes[2], packet->core.old.d.asBytes[3], - packet->core.old.d.asBytes[4], packet->core.old.d.asBytes[5], packet->core.old.d.asBytes[6], packet->core.old.d.asBytes[9], - packet->core.old.d.asBytes[7] - 128, packet->core.old.d.asBytes[8] - 128, - packet->core.old.arg[0], - packet->core.old.arg[1], - packet->core.old.arg[2] + packet->data.asBytes[0], packet->data.asBytes[1], packet->data.asBytes[2], packet->data.asBytes[3], + packet->data.asBytes[4], packet->data.asBytes[5], packet->data.asBytes[6], packet->data.asBytes[9], + packet->data.asBytes[7] - 128, packet->data.asBytes[8] - 128, + packet->oldarg[0], + packet->oldarg[1], + packet->oldarg[2] ); break; case CMD_EM4X_READ_WORD: - EM4xReadWord(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + EM4xReadWord(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_EM4X_WRITE_WORD: - EM4xWriteWord(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + EM4xWriteWord(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_AWID_DEMOD_FSK: { uint32_t high, low; // Set realtime AWID demodulation - CmdAWIDdemodFSK(packet->core.old.arg[0], &high, &low, 1); + CmdAWIDdemodFSK(packet->oldarg[0], &high, &low, 1); break; } case CMD_VIKING_CLONE_TAG: - CopyVikingtoT55xx(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + CopyVikingtoT55xx(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_COTAG: - Cotag(packet->core.old.arg[0]); + Cotag(packet->oldarg[0]); break; #endif #ifdef WITH_HITAG case CMD_SNIFF_HITAG: // Eavesdrop Hitag tag, args = type - SniffHitag(packet->core.old.arg[0]); + SniffHitag(packet->oldarg[0]); break; case CMD_SIMULATE_HITAG: // Simulate Hitag tag, args = memory content - SimulateHitagTag((bool)packet->core.old.arg[0], packet->core.old.d.asBytes); + SimulateHitagTag((bool)packet->oldarg[0], packet->data.asBytes); break; case CMD_READER_HITAG: // Reader for Hitag tags, args = type and function - ReaderHitag((hitag_function)packet->core.old.arg[0], (hitag_data *)packet->core.old.d.asBytes); + ReaderHitag((hitag_function)packet->oldarg[0], (hitag_data *)packet->data.asBytes); break; case CMD_SIMULATE_HITAG_S:// Simulate Hitag s tag, args = memory content - SimulateHitagSTag((bool)packet->core.old.arg[0], packet->core.old.d.asBytes); + SimulateHitagSTag((bool)packet->oldarg[0], packet->data.asBytes); break; case CMD_TEST_HITAGS_TRACES:// Tests every challenge within the given file - check_challenges((bool)packet->core.old.arg[0], packet->core.old.d.asBytes); + check_challenges((bool)packet->oldarg[0], packet->data.asBytes); break; case CMD_READ_HITAG_S: //Reader for only Hitag S tags, args = key or challenge - ReadHitagS((hitag_function)packet->core.old.arg[0], (hitag_data *)packet->core.old.d.asBytes); + ReadHitagS((hitag_function)packet->oldarg[0], (hitag_data *)packet->data.asBytes); break; case CMD_WR_HITAG_S: //writer for Hitag tags args=data to write,page and key or challenge - if ((hitag_function)packet->core.old.arg[0] < 10) { - WritePageHitagS((hitag_function)packet->core.old.arg[0], (hitag_data *)packet->core.old.d.asBytes, packet->core.old.arg[2]); + if ((hitag_function)packet->oldarg[0] < 10) { + WritePageHitagS((hitag_function)packet->oldarg[0], (hitag_data *)packet->data.asBytes, packet->oldarg[2]); } else { - WriterHitag((hitag_function)packet->core.old.arg[0], (hitag_data *)packet->core.old.d.asBytes, packet->core.old.arg[2]); + WriterHitag((hitag_function)packet->oldarg[0], (hitag_data *)packet->data.asBytes, packet->oldarg[2]); } break; #endif @@ -811,28 +808,28 @@ static void UsbPacketReceived(UsbCommandNG *packet) { RecordRawAdcSamplesIso15693(); break; case CMD_ISO_15693_COMMAND: - DirectTag15693Command(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + DirectTag15693Command(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_ISO_15693_FIND_AFI: - BruteforceIso15693Afi(packet->core.old.arg[0]); + BruteforceIso15693Afi(packet->oldarg[0]); break; case CMD_READER_ISO_15693: - ReaderIso15693(packet->core.old.arg[0]); + ReaderIso15693(packet->oldarg[0]); break; case CMD_SIMTAG_ISO_15693: - SimTagIso15693(packet->core.old.arg[0], packet->core.old.d.asBytes); + SimTagIso15693(packet->oldarg[0], packet->data.asBytes); break; #endif #ifdef WITH_LEGICRF case CMD_SIMULATE_TAG_LEGIC_RF: - LegicRfSimulate(packet->core.old.arg[0]); + LegicRfSimulate(packet->oldarg[0]); break; case CMD_WRITER_LEGIC_RF: - LegicRfWriter(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + LegicRfWriter(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_READER_LEGIC_RF: - LegicRfReader(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + LegicRfReader(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_LEGIC_INFO: LegicRfInfo(); @@ -846,22 +843,22 @@ static void UsbPacketReceived(UsbCommandNG *packet) { // arg0 = offset // arg1 = num of bytes FpgaDownloadAndGo(FPGA_BITSTREAM_HF); - emlSet(packet->core.old.d.asBytes, packet->core.old.arg[0], packet->core.old.arg[1]); + emlSet(packet->data.asBytes, packet->oldarg[0], packet->oldarg[1]); break; #endif #ifdef WITH_ISO14443b case CMD_READ_SRI_TAG: - ReadSTMemoryIso14443b(packet->core.old.arg[0]); + ReadSTMemoryIso14443b(packet->oldarg[0]); break; case CMD_SNIFF_ISO_14443B: SniffIso14443b(); break; case CMD_SIMULATE_TAG_ISO_14443B: - SimulateIso14443bTag(packet->core.old.arg[0]); + SimulateIso14443bTag(packet->oldarg[0]); break; case CMD_ISO_14443B_COMMAND: - //SendRawCommand14443B(packet->core.old.arg[0],packet->core.old.arg[1],packet->core.old.arg[2],packet->core.old.d.asBytes); + //SendRawCommand14443B(packet->oldarg[0],packet->oldarg[1],packet->oldarg[2],packet->data.asBytes); SendRawCommand14443B_Ex(packet); break; #endif @@ -871,10 +868,10 @@ static void UsbPacketReceived(UsbCommandNG *packet) { felica_sendraw(packet); break; case CMD_FELICA_LITE_SIM: - felica_sim_lite(packet->core.old.arg[0]); + felica_sim_lite(packet->oldarg[0]); break; case CMD_FELICA_SNIFF: - felica_sniff(packet->core.old.arg[0], packet->core.old.arg[1]); + felica_sniff(packet->oldarg[0], packet->oldarg[1]); break; case CMD_FELICA_LITE_DUMP: felica_dump_lite_s(); @@ -883,16 +880,16 @@ static void UsbPacketReceived(UsbCommandNG *packet) { #ifdef WITH_ISO14443a case CMD_SNIFF_ISO_14443a: - SniffIso14443a(packet->core.old.arg[0]); + SniffIso14443a(packet->oldarg[0]); break; case CMD_READER_ISO_14443a: ReaderIso14443a(packet); break; case CMD_SIMULATE_TAG_ISO_14443a: - SimulateIso14443aTag(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); // ## Simulate iso14443a tag - pass tag type & UID + SimulateIso14443aTag(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); // ## Simulate iso14443a tag - pass tag type & UID break; case CMD_ANTIFUZZ_ISO_14443a: - iso14443a_antifuzz(packet->core.old.arg[0]); + iso14443a_antifuzz(packet->oldarg[0]); break; case CMD_EPA_PACE_COLLECT_NONCE: EPA_PACE_Collect_Nonce(packet); @@ -901,89 +898,89 @@ static void UsbPacketReceived(UsbCommandNG *packet) { EPA_PACE_Replay(packet); break; case CMD_READER_MIFARE: - ReaderMifare(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2]); + ReaderMifare(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]); break; case CMD_MIFARE_READBL: - MifareReadBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareReadBlock(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFAREU_READBL: - MifareUReadBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + MifareUReadBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_MIFAREUC_AUTH: - MifareUC_Auth(packet->core.old.arg[0], packet->core.old.d.asBytes); + MifareUC_Auth(packet->oldarg[0], packet->data.asBytes); break; case CMD_MIFAREU_READCARD: - MifareUReadCard(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareUReadCard(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFAREUC_SETPWD: - MifareUSetPwd(packet->core.old.arg[0], packet->core.old.d.asBytes); + MifareUSetPwd(packet->oldarg[0], packet->data.asBytes); break; case CMD_MIFARE_READSC: - MifareReadSector(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareReadSector(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_WRITEBL: - MifareWriteBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareWriteBlock(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; //case CMD_MIFAREU_WRITEBL_COMPAT: - //MifareUWriteBlockCompat(packet->core.old.arg[0], packet->core.old.d.asBytes); + //MifareUWriteBlockCompat(packet->oldarg[0], packet->data.asBytes); //break; case CMD_MIFAREU_WRITEBL: - MifareUWriteBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + MifareUWriteBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_MIFARE_ACQUIRE_ENCRYPTED_NONCES: - MifareAcquireEncryptedNonces(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareAcquireEncryptedNonces(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_ACQUIRE_NONCES: - MifareAcquireNonces(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareAcquireNonces(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_NESTED: - MifareNested(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareNested(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_CHKKEYS: { - MifareChkKeys(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareChkKeys(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; } case CMD_MIFARE_CHKKEYS_FAST: { - MifareChkKeys_fast(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareChkKeys_fast(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; } case CMD_SIMULATE_MIFARE_CARD: - Mifare1ksim(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + Mifare1ksim(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; // emulator case CMD_MIFARE_SET_DBGMODE: - MifareSetDbgLvl(packet->core.old.arg[0]); + MifareSetDbgLvl(packet->oldarg[0]); break; case CMD_MIFARE_EML_MEMCLR: - MifareEMemClr(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareEMemClr(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_EML_MEMSET: - MifareEMemSet(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareEMemSet(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_EML_MEMGET: - MifareEMemGet(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareEMemGet(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_EML_CARDLOAD: - MifareECardLoad(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareECardLoad(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; // Work with "magic Chinese" card case CMD_MIFARE_CSETBLOCK: - MifareCSetBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + MifareCSetBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_MIFARE_CGETBLOCK: - MifareCGetBlock(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + MifareCGetBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_MIFARE_CIDENT: MifareCIdent(); break; // mifare sniffer // case CMD_MIFARE_SNIFFER: -// SniffMifare(packet->core.old.arg[0]); +// SniffMifare(packet->oldarg[0]); // break; case CMD_MIFARE_SETMOD: - MifareSetMod(packet->core.old.arg[0], packet->core.old.d.asBytes); + MifareSetMod(packet->oldarg[0], packet->data.asBytes); break; //mifare desfire case CMD_MIFARE_DESFIRE_READBL: @@ -991,19 +988,19 @@ static void UsbPacketReceived(UsbCommandNG *packet) { case CMD_MIFARE_DESFIRE_WRITEBL: break; case CMD_MIFARE_DESFIRE_AUTH1: - MifareDES_Auth1(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + MifareDES_Auth1(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_MIFARE_DESFIRE_AUTH2: - //MifareDES_Auth2(packet->core.old.arg[0],packet->core.old.d.asBytes); + //MifareDES_Auth2(packet->oldarg[0],packet->data.asBytes); break; case CMD_MIFARE_DES_READER: - //readermifaredes(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + //readermifaredes(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_MIFARE_DESFIRE_INFO: MifareDesfireGetInformation(); break; case CMD_MIFARE_DESFIRE: - MifareSendCommand(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + MifareSendCommand(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_MIFARE_COLLECT_NONCES: break; @@ -1018,45 +1015,45 @@ static void UsbPacketReceived(UsbCommandNG *packet) { SniffIClass(); break; case CMD_SIMULATE_TAG_ICLASS: - SimulateIClass(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.arg[2], packet->core.old.d.asBytes); + SimulateIClass(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes); break; case CMD_READER_ICLASS: - ReaderIClass(packet->core.old.arg[0]); + ReaderIClass(packet->oldarg[0]); break; case CMD_READER_ICLASS_REPLAY: - ReaderIClass_Replay(packet->core.old.arg[0], packet->core.old.d.asBytes); + ReaderIClass_Replay(packet->oldarg[0], packet->data.asBytes); break; case CMD_ICLASS_EML_MEMSET: //iceman, should call FPGADOWNLOAD before, since it corrupts BigBuf FpgaDownloadAndGo(FPGA_BITSTREAM_HF); - emlSet(packet->core.old.d.asBytes, packet->core.old.arg[0], packet->core.old.arg[1]); + emlSet(packet->data.asBytes, packet->oldarg[0], packet->oldarg[1]); break; case CMD_ICLASS_WRITEBLOCK: - iClass_WriteBlock(packet->core.old.arg[0], packet->core.old.d.asBytes); + iClass_WriteBlock(packet->oldarg[0], packet->data.asBytes); break; case CMD_ICLASS_READCHECK: // auth step 1 - iClass_ReadCheck(packet->core.old.arg[0], packet->core.old.arg[1]); + iClass_ReadCheck(packet->oldarg[0], packet->oldarg[1]); break; case CMD_ICLASS_READBLOCK: - iClass_ReadBlk(packet->core.old.arg[0]); + iClass_ReadBlk(packet->oldarg[0]); break; case CMD_ICLASS_AUTHENTICATION: //check - iClass_Authentication(packet->core.old.d.asBytes); + iClass_Authentication(packet->data.asBytes); break; case CMD_ICLASS_CHECK_KEYS: - iClass_Authentication_fast(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + iClass_Authentication_fast(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; case CMD_ICLASS_DUMP: - iClass_Dump(packet->core.old.arg[0], packet->core.old.arg[1]); + iClass_Dump(packet->oldarg[0], packet->oldarg[1]); break; case CMD_ICLASS_CLONE: - iClass_Clone(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + iClass_Clone(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; #endif #ifdef WITH_HFSNIFF case CMD_HF_SNIFFER: - HfSniff(packet->core.old.arg[0], packet->core.old.arg[1]); + HfSniff(packet->oldarg[0], packet->oldarg[1]); break; #endif @@ -1066,26 +1063,26 @@ static void UsbPacketReceived(UsbCommandNG *packet) { break; } case CMD_SMART_SETBAUD: { - SmartCardSetBaud(packet->core.old.arg[0]); + SmartCardSetBaud(packet->oldarg[0]); break; } case CMD_SMART_SETCLOCK: { - SmartCardSetClock(packet->core.old.arg[0]); + SmartCardSetClock(packet->oldarg[0]); break; } case CMD_SMART_RAW: { - SmartCardRaw(packet->core.old.arg[0], packet->core.old.arg[1], packet->core.old.d.asBytes); + SmartCardRaw(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes); break; } case CMD_SMART_UPLOAD: { // upload file from client uint8_t *mem = BigBuf_get_addr(); - memcpy(mem + packet->core.old.arg[0], packet->core.old.d.asBytes, USB_CMD_DATA_SIZE); + memcpy(mem + packet->oldarg[0], packet->data.asBytes, USB_CMD_DATA_SIZE); cmd_send(CMD_ACK, 1, 0, 0, 0, 0); break; } case CMD_SMART_UPGRADE: { - SmartCardUpgrade(packet->core.old.arg[0]); + SmartCardUpgrade(packet->oldarg[0]); break; } #endif @@ -1127,10 +1124,10 @@ static void UsbPacketReceived(UsbCommandNG *packet) { usart_writebuffer((uint8_t *)welcome, strlen(welcome)); sprintf(dest, "| bytes 0x%02x 0x%02x 0x%02x 0x%02x\r\n" - , packet->core.old.d.asBytes[0] - , packet->core.old.d.asBytes[1] - , packet->core.old.d.asBytes[2] - , packet->core.old.d.asBytes[3] + , packet->data.asBytes[0] + , packet->data.asBytes[1] + , packet->data.asBytes[2] + , packet->data.asBytes[3] ); usart_writebuffer((uint8_t *)dest, strlen(dest)); @@ -1176,7 +1173,7 @@ static void UsbPacketReceived(UsbCommandNG *packet) { break; case CMD_LISTEN_READER_FIELD: - ListenReaderField(packet->core.old.arg[0]); + ListenReaderField(packet->oldarg[0]); break; case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control @@ -1188,12 +1185,12 @@ static void UsbPacketReceived(UsbCommandNG *packet) { case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K: { LED_B_ON(); uint8_t *mem = BigBuf_get_addr(); - uint32_t startidx = packet->core.old.arg[0]; - uint32_t numofbytes = packet->core.old.arg[1]; + uint32_t startidx = packet->oldarg[0]; + uint32_t numofbytes = packet->oldarg[1]; // arg0 = startindex // arg1 = length bytes to transfer // arg2 = BigBuf tracelen - //Dbprintf("transfer to client parameters: %" PRIu32 " | %" PRIu32 " | %" PRIu32, startidx, numofbytes, packet->core.old.arg[2]); + //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); @@ -1218,13 +1215,13 @@ static void UsbPacketReceived(UsbCommandNG *packet) { // arg1 = 0 upload for LF usage // 1 upload for HF usage #define FPGA_LF 1 - if (packet->core.old.arg[1] == FPGA_LF) + if (packet->oldarg[1] == FPGA_LF) FpgaDownloadAndGo(FPGA_BITSTREAM_LF); else FpgaDownloadAndGo(FPGA_BITSTREAM_HF); uint8_t *mem = BigBuf_get_addr(); - memcpy(mem + packet->core.old.arg[0], packet->core.old.d.asBytes, USB_CMD_DATA_SIZE); + memcpy(mem + packet->oldarg[0], packet->data.asBytes, USB_CMD_DATA_SIZE); cmd_send(CMD_ACK, 1, 0, 0, 0, 0); break; } @@ -1233,8 +1230,8 @@ static void UsbPacketReceived(UsbCommandNG *packet) { uint8_t *mem = BigBuf_get_EM_addr(); bool isok = false; size_t len = 0; - uint32_t startidx = packet->core.old.arg[0]; - uint32_t numofbytes = packet->core.old.arg[1]; + uint32_t startidx = packet->oldarg[0]; + uint32_t numofbytes = packet->oldarg[1]; // arg0 = startindex // arg1 = length bytes to transfer @@ -1252,16 +1249,16 @@ static void UsbPacketReceived(UsbCommandNG *packet) { break; } case CMD_READ_MEM: - ReadMem(packet->core.old.arg[0]); + ReadMem(packet->oldarg[0]); break; #ifdef WITH_FLASH case CMD_FLASHMEM_SET_SPIBAUDRATE: - FlashmemSetSpiBaudrate(packet->core.old.arg[0]); + FlashmemSetSpiBaudrate(packet->oldarg[0]); break; case CMD_FLASHMEM_READ: { LED_B_ON(); - uint32_t startidx = packet->core.old.arg[0]; - uint16_t len = packet->core.old.arg[1]; + uint32_t startidx = packet->oldarg[0]; + uint16_t len = packet->oldarg[1]; Dbprintf("FlashMem read | %d - %d | ", startidx, len); @@ -1294,9 +1291,9 @@ static void UsbPacketReceived(UsbCommandNG *packet) { LED_B_ON(); uint8_t isok = 0; uint16_t res = 0; - uint32_t startidx = packet->core.old.arg[0]; - uint16_t len = packet->core.old.arg[1]; - uint8_t *data = packet->core.old.d.asBytes; + uint32_t startidx = packet->oldarg[0]; + uint16_t len = packet->oldarg[1]; + uint8_t *data = packet->data.asBytes; uint32_t tmp = startidx + len; @@ -1355,8 +1352,8 @@ static void UsbPacketReceived(UsbCommandNG *packet) { } case CMD_FLASHMEM_WIPE: { LED_B_ON(); - uint8_t page = packet->core.old.arg[0]; - uint8_t initalwipe = packet->core.old.arg[1]; + uint8_t page = packet->oldarg[0]; + uint8_t initalwipe = packet->oldarg[1]; bool isok = false; if (initalwipe) { isok = Flash_WipeMemory(); @@ -1375,8 +1372,8 @@ static void UsbPacketReceived(UsbCommandNG *packet) { LED_B_ON(); uint8_t *mem = BigBuf_malloc(USB_CMD_DATA_SIZE); - uint32_t startidx = packet->core.old.arg[0]; - uint32_t numofbytes = packet->core.old.arg[1]; + uint32_t startidx = packet->oldarg[0]; + uint32_t numofbytes = packet->oldarg[1]; // arg0 = startindex // arg1 = length bytes to transfer // arg2 = RFU @@ -1423,11 +1420,11 @@ static void UsbPacketReceived(UsbCommandNG *packet) { #endif case CMD_SET_LF_DIVISOR: FpgaDownloadAndGo(FPGA_BITSTREAM_LF); - FpgaSendCommand(FPGA_CMD_SET_DIVISOR, packet->core.old.arg[0]); + FpgaSendCommand(FPGA_CMD_SET_DIVISOR, packet->oldarg[0]); break; case CMD_SET_ADC_MUX: - switch (packet->core.old.arg[0]) { + switch (packet->oldarg[0]) { case 0: SetAdcMuxFor(GPIO_MUXSEL_LOPKD); break; @@ -1453,7 +1450,7 @@ static void UsbPacketReceived(UsbCommandNG *packet) { break; case CMD_PING: if (packet->ng) { - reply_ng(CMD_PING, PM3_SUCCESS, packet->core.ng.data, packet->length); + reply_ng(CMD_PING, PM3_SUCCESS, packet->data.asBytes, packet->length); } else { #ifdef WITH_FPC_HOST cmd_send(CMD_ACK, reply_via_fpc, 0, 0, 0, 0); @@ -1467,7 +1464,7 @@ static void UsbPacketReceived(UsbCommandNG *packet) { LCDReset(); break; case CMD_LCD: - LCDSend(packet->core.old.arg[0]); + LCDSend(packet->oldarg[0]); break; #endif case CMD_SETUP_WRITE: @@ -1501,7 +1498,7 @@ static void UsbPacketReceived(UsbCommandNG *packet) { break; } default: - Dbprintf("%s: 0x%04x", "unknown command:", cmd); + Dbprintf("%s: 0x%04x", "unknown command:", packet->cmd); break; } } @@ -1567,6 +1564,7 @@ void __attribute__((noreturn)) AppMain(void) { usb_enable(); UsbCommandNG rx; + UsbCommandNGRaw rx_raw; for (;;) { WDT_HIT(); @@ -1574,28 +1572,36 @@ void __attribute__((noreturn)) AppMain(void) { // Check if there is a usb packet available if (usb_poll_validate_length()) { bool error = false; - size_t bytes = usb_read_ng((uint8_t *)&rx, sizeof(UsbCommandNGPreamble)); + size_t bytes = usb_read_ng((uint8_t *)&rx_raw.pre, sizeof(UsbCommandNGPreamble)); if (bytes == sizeof(UsbCommandNGPreamble)) { + rx.magic = rx_raw.pre.magic; + rx.length = rx_raw.pre.length; + rx.cmd = rx_raw.pre.cmd; if (rx.magic == USB_COMMANDNG_PREAMBLE_MAGIC) { // New style NG command if (rx.length > USB_CMD_DATA_SIZE) { Dbprintf("Packet frame with incompatible length: 0x%04x", rx.length); error = true; } if (!error) { // Get the core and variable length payload - bytes = usb_read_ng(((uint8_t *)&rx.core), sizeof(UsbPacketNGCore) - USB_CMD_DATA_SIZE + rx.length); - if (bytes != sizeof(UsbPacketNGCore) - USB_CMD_DATA_SIZE + rx.length) { + bytes = usb_read_ng(((uint8_t *)&rx_raw.data), rx.length); + if (bytes != rx.length) { Dbprintf("Packet frame error variable part too short? %d/%d", bytes, rx.length); error = true; + } else { + memcpy(&rx.data, &rx_raw.data, rx.length); } } if (!error) { // Get the postamble - bytes = usb_read_ng(((uint8_t *)&rx.crc), sizeof(UsbCommandNGPostamble)); + bytes = usb_read_ng(((uint8_t *)&rx_raw.foopost), sizeof(UsbCommandNGPostamble)); if (bytes != sizeof(UsbCommandNGPostamble)) { Dbprintf("Packet frame error fetching postamble"); error = true; } + } + if (!error) { // Check CRC + rx.crc = rx_raw.foopost.crc; uint8_t first, second; - compute_crc(CRC_14443_A, (uint8_t *)&rx, sizeof(UsbCommandNGPreamble) + sizeof(UsbPacketNGCore) - USB_CMD_DATA_SIZE + rx.length, &first, &second); + compute_crc(CRC_14443_A, (uint8_t *)&rx_raw, sizeof(UsbCommandNGPreamble) + rx.length, &first, &second); if ((first << 8) + second != rx.crc) { Dbprintf("Packet frame CRC error %02X%02X <> %04X", first, second, rx.crc); error = true; @@ -1609,13 +1615,9 @@ void __attribute__((noreturn)) AppMain(void) { UsbPacketReceived(&rx); } } else { // Old style command - uint8_t tmp[sizeof(UsbCommandNGPreamble)]; - memcpy(tmp, &rx, sizeof(UsbCommandNGPreamble)); - memcpy(&rx.core.old, tmp, sizeof(UsbCommandNGPreamble)); - - - - bytes = usb_read_ng(((uint8_t *)&rx.core.old) + sizeof(UsbCommandNGPreamble), sizeof(UsbCommandOLD) - sizeof(UsbCommandNGPreamble)); + UsbCommandOLD rx_old; + memcpy(&rx_old, &rx_raw.pre, sizeof(UsbCommandNGPreamble)); + bytes = usb_read_ng(((uint8_t *)&rx_old) + sizeof(UsbCommandNGPreamble), sizeof(UsbCommandOLD) - sizeof(UsbCommandNGPreamble)); if (bytes != sizeof(UsbCommandOLD) - sizeof(UsbCommandNGPreamble)) { Dbprintf("Packet frame error var part too short? %d/%d", bytes, sizeof(UsbCommandOLD) - sizeof(UsbCommandNGPreamble)); error = true; @@ -1626,8 +1628,13 @@ void __attribute__((noreturn)) AppMain(void) { #endif rx.ng = false; rx.magic = 0; - rx.length = USB_CMD_DATA_SIZE; rx.crc = 0; + rx.cmd = rx_old.cmd; + 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; + memcpy(&rx.data, &rx_old.d, rx.length); UsbPacketReceived(&rx); } } diff --git a/armsrc/epa.c b/armsrc/epa.c index 8c1db359c..be3145452 100644 --- a/armsrc/epa.c +++ b/armsrc/epa.c @@ -313,7 +313,7 @@ void EPA_PACE_Collect_Nonce(UsbCommandNG *c) { // now get the nonce uint8_t nonce[256] = {0}; - uint8_t requested_size = (uint8_t)c->core.old.arg[0]; + uint8_t requested_size = (uint8_t)c->oldarg[0]; func_return = EPA_PACE_Get_Nonce(requested_size, nonce); // check if the command succeeded if (func_return < 0) { @@ -434,19 +434,19 @@ void EPA_PACE_Replay(UsbCommandNG *c) { uint32_t timings[sizeof(apdu_lengths_replay) / sizeof(apdu_lengths_replay[0])] = {0}; // if an APDU has been passed, save it - if (c->core.old.arg[0] != 0) { + if (c->oldarg[0] != 0) { // make sure it's not too big - if (c->core.old.arg[2] > apdus_replay[c->core.old.arg[0] - 1].len) { + if (c->oldarg[2] > apdus_replay[c->oldarg[0] - 1].len) { cmd_send(CMD_ACK, 1, 0, 0, NULL, 0); } - memcpy(apdus_replay[c->core.old.arg[0] - 1].data + c->core.old.arg[1], - c->core.old.d.asBytes, - c->core.old.arg[2]); + memcpy(apdus_replay[c->oldarg[0] - 1].data + c->oldarg[1], + c->data.asBytes, + c->oldarg[2]); // save/update APDU length - if (c->core.old.arg[1] == 0) { - apdu_lengths_replay[c->core.old.arg[0] - 1] = c->core.old.arg[2]; + if (c->oldarg[1] == 0) { + apdu_lengths_replay[c->oldarg[0] - 1] = c->oldarg[2]; } else { - apdu_lengths_replay[c->core.old.arg[0] - 1] += c->core.old.arg[2]; + apdu_lengths_replay[c->oldarg[0] - 1] += c->oldarg[2]; } cmd_send(CMD_ACK, 0, 0, 0, NULL, 0); return; diff --git a/armsrc/felica.c b/armsrc/felica.c index 5172e98ef..6ab60fc5f 100644 --- a/armsrc/felica.c +++ b/armsrc/felica.c @@ -479,9 +479,9 @@ void felica_sendraw(UsbCommandNG *c) { if (MF_DBGLEVEL > 3) Dbprintf("FeliCa_sendraw Enter"); - felica_command_t param = c->core.old.arg[0]; - size_t len = c->core.old.arg[1] & 0xffff; - uint8_t *cmd = c->core.old.d.asBytes; + felica_command_t param = c->oldarg[0]; + size_t len = c->oldarg[1] & 0xffff; + uint8_t *cmd = c->data.asBytes; uint32_t arg0; felica_card_select_t card; diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c index 05176d903..07711ad80 100644 --- a/armsrc/iso14443a.c +++ b/armsrc/iso14443a.c @@ -2351,11 +2351,11 @@ int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, bool send_chaining, void *data, u // arg2 timeout // d.asBytes command bytes to send void ReaderIso14443a(UsbCommandNG *c) { - iso14a_command_t param = c->core.old.arg[0]; - size_t len = c->core.old.arg[1] & 0xffff; - size_t lenbits = c->core.old.arg[1] >> 16; - uint32_t timeout = c->core.old.arg[2]; - uint8_t *cmd = c->core.old.d.asBytes; + iso14a_command_t param = c->oldarg[0]; + size_t len = c->oldarg[1] & 0xffff; + size_t lenbits = c->oldarg[1] >> 16; + 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 par[MAX_PARITY_SIZE] = {0x00}; diff --git a/armsrc/iso14443b.c b/armsrc/iso14443b.c index 5044d0bc2..aa3abcfb1 100644 --- a/armsrc/iso14443b.c +++ b/armsrc/iso14443b.c @@ -1567,10 +1567,10 @@ void iso14b_set_trigger(bool enable) { * */ void SendRawCommand14443B_Ex(UsbCommandNG *c) { - iso14b_command_t param = c->core.old.arg[0]; - size_t len = c->core.old.arg[1] & 0xffff; - uint32_t timeout = c->core.old.arg[2]; - uint8_t *cmd = c->core.old.d.asBytes; + iso14b_command_t param = c->oldarg[0]; + size_t len = c->oldarg[1] & 0xffff; + uint32_t timeout = c->oldarg[2]; + 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}; diff --git a/bootrom/bootrom.c b/bootrom/bootrom.c index 7fa20ec0a..78bda337c 100644 --- a/bootrom/bootrom.c +++ b/bootrom/bootrom.c @@ -90,9 +90,9 @@ void UsbPacketReceived(UsbCommandNG *packet) { //if ( len != sizeof(UsbCommand)) Fatal(); - uint32_t arg0 = (uint32_t)packet->core.old.arg[0]; + uint32_t arg0 = (uint32_t)packet->oldarg[0]; - switch (packet->core.old.cmd) { + switch (packet->cmd) { case CMD_DEVICE_INFO: { dont_ack = 1; arg0 = DEVICE_INFO_FLAG_BOOTROM_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_BOOTROM | @@ -110,7 +110,7 @@ void UsbPacketReceived(UsbCommandNG *packet) { */ p = (volatile uint32_t *)&_flash_start; for (i = 0; i < 12; i++) - p[i + arg0] = packet->core.old.d.asDwords[i]; + p[i + arg0] = packet->data.asDwords[i]; } break; @@ -118,7 +118,7 @@ void UsbPacketReceived(UsbCommandNG *packet) { uint32_t *flash_mem = (uint32_t *)(&_flash_start); for (int j = 0; j < 2; j++) { for (i = 0 + (64 * j); i < 64 + (64 * j); i++) { - flash_mem[i] = packet->core.old.d.asDwords[i]; + flash_mem[i] = packet->data.asDwords[i]; } uint32_t flash_address = arg0 + (0x100 * j); @@ -154,7 +154,7 @@ void UsbPacketReceived(UsbCommandNG *packet) { break; case CMD_START_FLASH: { - if (packet->core.old.arg[2] == START_FLASH_MAGIC) + if (packet->oldarg[2] == START_FLASH_MAGIC) bootrom_unlocked = 1; else bootrom_unlocked = 0; @@ -163,8 +163,8 @@ void UsbPacketReceived(UsbCommandNG *packet) { int prot_end = (int)&_bootrom_end; int allow_start = (int)&_flash_start; int allow_end = (int)&_flash_end; - int cmd_start = packet->core.old.arg[0]; - int cmd_end = packet->core.old.arg[1]; + int cmd_start = packet->oldarg[0]; + int cmd_end = packet->oldarg[1]; /* Only allow command if the bootrom is unlocked, or the parameters are outside of the protected * bootrom area. In any case they must be within the flash area. diff --git a/client/comms.c b/client/comms.c index 571a1d8fc..a3643898f 100644 --- a/client/comms.c +++ b/client/comms.c @@ -26,7 +26,7 @@ static pthread_t USB_communication_thread; // Transmit buffer. static UsbCommandOLD txBuffer; -static UsbCommandNG txBufferNG; +static UsbCommandNGRaw txBufferNG; size_t txBufferNGLen; static bool txBuffer_pending = false; static pthread_mutex_t txBufferMutex = PTHREAD_MUTEX_INITIALIZER; @@ -104,7 +104,7 @@ void SendCommandNG(uint16_t cmd, uint8_t *data, size_t len) { return; } - UsbCommandNGPostamble *tx_post = (UsbCommandNGPostamble *)((uint8_t *)&txBufferNG + sizeof(UsbCommandNGPreamble) + sizeof(UsbPacketNGCore) - USB_CMD_DATA_SIZE + len); + UsbCommandNGPostamble *tx_post = (UsbCommandNGPostamble *)((uint8_t *)&txBufferNG + sizeof(UsbCommandNGPreamble) + len); pthread_mutex_lock(&txBufferMutex); /** @@ -116,14 +116,14 @@ void SendCommandNG(uint16_t cmd, uint8_t *data, size_t len) { pthread_cond_wait(&txBufferSig, &txBufferMutex); } - txBufferNG.magic = USB_COMMANDNG_PREAMBLE_MAGIC; - txBufferNG.length = len; - txBufferNG.core.ng.cmd = cmd; - memcpy(&txBufferNG.core.ng.data, data, len); + txBufferNG.pre.magic = USB_COMMANDNG_PREAMBLE_MAGIC; + txBufferNG.pre.length = len; + txBufferNG.pre.cmd = cmd; + memcpy(&txBufferNG.data, data, len); uint8_t first, second; - compute_crc(CRC_14443_A, (uint8_t *)&txBufferNG, sizeof(UsbCommandNGPreamble) + sizeof(UsbPacketNGCore) - USB_CMD_DATA_SIZE + len, &first, &second); + compute_crc(CRC_14443_A, (uint8_t *)&txBufferNG, sizeof(UsbCommandNGPreamble) + len, &first, &second); tx_post->crc = (first << 8) + second; - txBufferNGLen = sizeof(UsbCommandNGPreamble) + sizeof(UsbPacketNGCore) - USB_CMD_DATA_SIZE + len + sizeof(UsbCommandNGPostamble); + txBufferNGLen = sizeof(UsbCommandNGPreamble) + len + sizeof(UsbCommandNGPostamble); txBuffer_pending = true; // tell communication thread that a new command can be send @@ -311,13 +311,13 @@ __attribute__((force_align_arg_pointer)) } } if (!error) { // Get the postamble - if ((!uart_receive(sp, (uint8_t *)&rx_raw.post, sizeof(UsbReplyNGPostamble), &rxlen)) || (rxlen != sizeof(UsbReplyNGPostamble))) { + if ((!uart_receive(sp, (uint8_t *)&rx_raw.foopost, sizeof(UsbReplyNGPostamble), &rxlen)) || (rxlen != sizeof(UsbReplyNGPostamble))) { PrintAndLogEx(WARNING, "Received packet frame error fetching postamble"); error = true; } } if (!error) { // Check CRC - rx.crc = rx_raw.post.crc; + rx.crc = rx_raw.foopost.crc; uint8_t first, second; compute_crc(CRC_14443_A, (uint8_t *)&rx_raw, sizeof(UsbReplyNGPreamble) + rx.length, &first, &second); if ((first << 8) + second != rx.crc) { diff --git a/include/usb_cmd.h b/include/usb_cmd.h index ed6ba08e8..a460dd980 100644 --- a/include/usb_cmd.h +++ b/include/usb_cmd.h @@ -35,14 +35,10 @@ typedef struct { } d; } PACKED UsbCommandOLD; -typedef struct { - uint16_t cmd; - uint8_t data[USB_CMD_DATA_SIZE]; -} PACKED UsbPacketNGCore; - typedef struct { uint32_t magic; uint16_t length; // length of the variable part, 0 if none. + uint16_t cmd; } PACKED UsbCommandNGPreamble; #define USB_COMMANDNG_PREAMBLE_MAGIC 0x61334d50 // PM3a @@ -51,17 +47,27 @@ typedef struct { uint16_t crc; } PACKED UsbCommandNGPostamble; +// For internal usage typedef struct { - uint32_t magic; - uint16_t length; // length of the variable part, 0 if none. - union { // we can simplify it once we get rid of old format compatibility - UsbPacketNGCore ng; - UsbCommandOLD old; - } core; - uint16_t crc; - bool ng; + uint16_t cmd; + uint16_t length; + uint32_t magic; // NG + 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]; + } data; + bool ng; // does it store NG data or OLD data? } PACKED UsbCommandNG; +// For reception and CRC check +typedef struct { + UsbCommandNGPreamble pre; + uint8_t data[USB_CMD_DATA_SIZE]; + UsbCommandNGPostamble foopost; // Probably not at that offset! +} PACKED UsbCommandNGRaw; + typedef struct { uint32_t magic; uint16_t length; // length of the variable part, 0 if none. @@ -94,7 +100,7 @@ typedef struct { typedef struct { UsbReplyNGPreamble pre; uint8_t data[USB_CMD_DATA_SIZE]; - UsbReplyNGPostamble post; + UsbReplyNGPostamble foopost; // Probably not at that offset! } PACKED UsbReplyNGRaw; #ifdef WITH_FPC_HOST