dash/proxmark3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename few CMD_* to get some less diversity

Browse Source
This commit is contained in:
Philippe Teuwen
2019-08-03 19:17:00 +02:00
parent cbf5c717f7
commit a0a232a985
71 changed files with 687 additions and 687 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
armsrc/Standalone/hf_young.c
View File

@@ -138,18 +138,18 @@ void RunMod() {
SpinDelay(500);
// Begin clone function here:
/* Example from client/mifarehost.c for commanding a block write for "magic Chinese" cards:
SendCommandOLD(CMD_MIFARE_CSETBLOCK, params & (0xFE | (uid == NULL ? 0:1)), blockNo, 0, data, 16);
SendCommandOLD(CMD_HF_MIFARE_CSETBL, params & (0xFE | (uid == NULL ? 0:1)), blockNo, 0, data, 16);
Block read is similar:
SendCommandOLD(CMD_MIFARE_CGETBLOCK, params, blockNo, 0,...};
SendCommandOLD(CMD_HF_MIFARE_CGETBL, params, blockNo, 0,...};
We need to imitate that call with blockNo 0 to set a uid.
The get and set commands are handled in this file:
// Work with "magic Chinese" card
case CMD_MIFARE_CSETBLOCK:
case CMD_HF_MIFARE_CSETBL:
MifareCSetBlock(c->arg[0], c->arg[1], c->d.asBytes);
break;
case CMD_MIFARE_CGETBLOCK:
case CMD_HF_MIFARE_CGETBL:
MifareCGetBlock(c->arg[0], c->arg[1], c->d.asBytes);
break;

238
armsrc/appmain.c
View File

@@ -756,25 +756,25 @@ static void PacketReceived(PacketCommandNG *packet) {
reply_via_usb = false;
break;
#ifdef WITH_LF
case CMD_SET_LF_T55XX_CONFIG: {
case CMD_LF_T55XX_SET_CONFIG: {
setT55xxConfig(packet->oldarg[0], (t55xx_configurations_t *) packet->data.asBytes);
break;
}
case CMD_SET_LF_SAMPLING_CONFIG: {
case CMD_LF_SAMPLING_SET_CONFIG: {
setSamplingConfig((sample_config *) packet->data.asBytes);
break;
}
case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K: {
case CMD_LF_ACQ_RAW_ADC: {
struct p {
uint8_t silent;
uint32_t samples;
} PACKED;
struct p *payload = (struct p *)packet->data.asBytes;
uint32_t bits = SampleLF(payload->silent, payload->samples);
reply_ng(CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, PM3_SUCCESS, (uint8_t *)&bits, sizeof(bits));
reply_ng(CMD_LF_ACQ_RAW_ADC, PM3_SUCCESS, (uint8_t *)&bits, sizeof(bits));
break;
}
case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K: {
case CMD_LF_MOD_THEN_ACQ_RAW_ADC: {
struct p {
uint32_t delay;
uint16_t ones;
@@ -784,67 +784,67 @@ static void PacketReceived(PacketCommandNG *packet) {
ModThenAcquireRawAdcSamples125k(payload->delay, payload->zeros, payload->ones, packet->data.asBytes + 8);
break;
}
case CMD_LF_SNIFF_RAW_ADC_SAMPLES: {
case CMD_LF_SNIFF_RAW_ADC: {
uint32_t bits = SniffLF();
reply_mix(CMD_ACK, bits, 0, 0, 0, 0);
break;
}
case CMD_HID_DEMOD_FSK: {
case CMD_LF_HID_DEMOD: {
uint32_t high, low;
CmdHIDdemodFSK(packet->oldarg[0], &high, &low, 1);
break;
}
case CMD_HID_SIM_TAG: {
case CMD_LF_HID_SIMULATE: {
CmdHIDsimTAG(packet->oldarg[0], packet->oldarg[1], 1);
break;
}
case CMD_FSK_SIM_TAG: {
case CMD_LF_FSK_SIMULATE: {
lf_fsksim_t *payload = (lf_fsksim_t *)packet->data.asBytes;
CmdFSKsimTAG(payload->fchigh, payload->fclow, payload->separator, payload->clock, packet->length - sizeof(lf_fsksim_t), payload->data, true);
break;
}
case CMD_ASK_SIM_TAG: {
case CMD_LF_ASK_SIMULATE: {
lf_asksim_t *payload = (lf_asksim_t *)packet->data.asBytes;
CmdASKsimTAG(payload->encoding, payload->invert, payload->separator, payload->clock, packet->length - sizeof(lf_asksim_t), payload->data, true);
break;
}
case CMD_PSK_SIM_TAG: {
case CMD_LF_PSK_SIMULATE: {
lf_psksim_t *payload = (lf_psksim_t *)packet->data.asBytes;
CmdPSKsimTag(payload->carrier, payload->invert, payload->clock, packet->length - sizeof(lf_psksim_t), payload->data, true);
break;
}
case CMD_HID_CLONE_TAG: {
case CMD_LF_HID_CLONE: {
CopyHIDtoT55x7(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes[0]);
break;
}
case CMD_IO_DEMOD_FSK: {
case CMD_LF_IO_DEMOD: {
uint32_t high, low;
CmdIOdemodFSK(packet->oldarg[0], &high, &low, 1);
break;
}
case CMD_IO_CLONE_TAG: {
case CMD_LF_IO_CLONE: {
CopyIOtoT55x7(packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_EM410X_DEMOD: {
case CMD_LF_EM410X_DEMOD: {
uint32_t high;
uint64_t low;
CmdEM410xdemod(packet->oldarg[0], &high, &low, 1);
break;
}
case CMD_EM410X_WRITE_TAG: {
case CMD_LF_EM410X_WRITE: {
WriteEM410x(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]);
break;
}
case CMD_READ_TI_TYPE: {
case CMD_LF_TI_READ: {
ReadTItag();
break;
}
case CMD_WRITE_TI_TYPE: {
case CMD_LF_TI_WRITE: {
WriteTItag(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]);
break;
}
case CMD_SIMULATE_TAG_125K: {
case CMD_LF_SIMULATE: {
LED_A_ON();
struct p {
uint16_t len;
@@ -853,7 +853,7 @@ static void PacketReceived(PacketCommandNG *packet) {
struct p *payload = (struct p *)packet->data.asBytes;
// length, start gap, led control
SimulateTagLowFrequency(payload->len, payload->gap, 1);
reply_ng(CMD_SIMULATE_TAG_125K, PM3_EOPABORTED, NULL, 0);
reply_ng(CMD_LF_SIMULATE, PM3_EOPABORTED, NULL, 0);
LED_A_OFF();
break;
}
@@ -861,18 +861,18 @@ static void PacketReceived(PacketCommandNG *packet) {
SimulateTagLowFrequencyBidir(packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_INDALA_CLONE_TAG: {
case CMD_LF_INDALA_CLONE: {
CopyIndala64toT55x7(packet->data.asDwords[0], packet->data.asDwords[1]);
break;
}
case CMD_INDALA_CLONE_TAG_L: {
case CMD_LF_INDALA224_CLONE: {
CopyIndala224toT55x7(
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: {
case CMD_LF_T55XX_READBL: {
struct p {
uint32_t password;
uint8_t blockno;
@@ -884,28 +884,28 @@ static void PacketReceived(PacketCommandNG *packet) {
T55xxReadBlock(payload->page, payload->pwdmode, false, payload->blockno, payload->password, payload->downlink_mode);
break;
}
case CMD_T55XX_WRITE_BLOCK: {
case CMD_LF_T55XX_WRITEBL: {
// uses NG format
T55xxWriteBlock(packet->data.asBytes);
break;
}
case CMD_T55XX_WAKEUP: {
case CMD_LF_T55XX_WAKEUP: {
T55xxWakeUp(packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_T55XX_RESET_READ: {
case CMD_LF_T55XX_RESET_READ: {
T55xxResetRead(packet->data.asBytes[0] & 0xff);
break;
}
case CMD_T55XX_CHKPWDS: {
case CMD_LF_T55XX_CHK_PWDS: {
T55xx_ChkPwds(packet->data.asBytes[0] & 0xff);
break;
}
case CMD_PCF7931_READ: {
case CMD_LF_PCF7931_READ: {
ReadPCF7931();
break;
}
case CMD_PCF7931_WRITE: {
case CMD_LF_PCF7931_WRITE: {
WritePCF7931(
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],
@@ -916,7 +916,7 @@ static void PacketReceived(PacketCommandNG *packet) {
);
break;
}
case CMD_EM4X_READ_WORD: {
case CMD_LF_EM4X_READWORD: {
struct p {
uint32_t password;
uint8_t address;
@@ -926,7 +926,7 @@ static void PacketReceived(PacketCommandNG *packet) {
EM4xReadWord(payload->address, payload->password, payload->usepwd);
break;
}
case CMD_EM4X_WRITE_WORD: {
case CMD_LF_EM4X_WRITEWORD: {
struct p {
uint32_t password;
uint32_t data;
@@ -937,48 +937,48 @@ static void PacketReceived(PacketCommandNG *packet) {
EM4xWriteWord(payload->address, payload->data, payload->password, payload->usepwd);
break;
}
case CMD_AWID_DEMOD_FSK: {
case CMD_LF_AWID_DEMOD: {
uint32_t high, low;
// Set realtime AWID demodulation
CmdAWIDdemodFSK(packet->oldarg[0], &high, &low, 1);
break;
}
case CMD_VIKING_CLONE_TAG: {
case CMD_LF_VIKING_CLONE: {
CopyVikingtoT55xx(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]);
break;
}
case CMD_COTAG: {
case CMD_LF_COTAG_READ: {
Cotag(packet->oldarg[0]);
break;
}
#endif
#ifdef WITH_HITAG
case CMD_SNIFF_HITAG: { // Eavesdrop Hitag tag, args = type
case CMD_LF_HITAG_SNIFF: { // Eavesdrop Hitag tag, args = type
SniffHitag();
break;
}
case CMD_SIMULATE_HITAG: { // Simulate Hitag tag, args = memory content
case CMD_LF_HITAG_SIMULATE: { // Simulate Hitag tag, args = memory content
SimulateHitagTag((bool)packet->oldarg[0], packet->data.asBytes);
break;
}
case CMD_READER_HITAG: { // Reader for Hitag tags, args = type and function
case CMD_LF_HITAG_READER: { // Reader for Hitag tags, args = type and function
ReaderHitag((hitag_function)packet->oldarg[0], (hitag_data *)packet->data.asBytes);
break;
}
case CMD_SIMULATE_HITAG_S: { // Simulate Hitag s tag, args = memory content
case CMD_LF_HITAGS_SIMULATE: { // Simulate Hitag s tag, args = memory content
SimulateHitagSTag((bool)packet->oldarg[0], packet->data.asBytes);
break;
}
case CMD_TEST_HITAGS_TRACES: { // Tests every challenge within the given file
case CMD_LF_HITAGS_TEST_TRACES: { // Tests every challenge within the given file
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
case CMD_LF_HITAGS_READ: { //Reader for only Hitag S tags, args = key or challenge
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
case CMD_LF_HITAGS_WRITE: { //writer for Hitag tags args=data to write,page and key or challenge
if ((hitag_function)packet->oldarg[0] < 10) {
WritePageHitagS((hitag_function)packet->oldarg[0], (hitag_data *)packet->data.asBytes, packet->oldarg[2]);
} else {
@@ -989,50 +989,50 @@ static void PacketReceived(PacketCommandNG *packet) {
#endif
#ifdef WITH_ISO15693
case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693: {
case CMD_HF_ISO15693_ACQ_RAW_ADC: {
AcquireRawAdcSamplesIso15693();
break;
}
case CMD_RECORD_RAW_ADC_SAMPLES_ISO_15693: {
case CMD_HF_ISO15693_RAWADC: {
RecordRawAdcSamplesIso15693();
break;
}
case CMD_ISO_15693_COMMAND: {
case CMD_HF_ISO15693_COMMAND: {
DirectTag15693Command(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_ISO_15693_FIND_AFI: {
case CMD_HF_ISO15693_FINDAFI: {
BruteforceIso15693Afi(packet->oldarg[0]);
break;
}
case CMD_READER_ISO_15693: {
case CMD_HF_ISO15693_READER: {
ReaderIso15693(packet->oldarg[0]);
break;
}
case CMD_SIMTAG_ISO_15693: {
case CMD_HF_ISO15693_SIMULATE: {
SimTagIso15693(packet->oldarg[0], packet->data.asBytes);
break;
}
#endif
#ifdef WITH_LEGICRF
case CMD_SIMULATE_TAG_LEGIC_RF: {
case CMD_HF_LEGIC_SIMULATE: {
LegicRfSimulate(packet->oldarg[0]);
break;
}
case CMD_WRITER_LEGIC_RF: {
case CMD_HF_LEGIC_WRITER: {
LegicRfWriter(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_READER_LEGIC_RF: {
case CMD_HF_LEGIC_READER: {
LegicRfReader(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]);
break;
}
case CMD_LEGIC_INFO: {
case CMD_HF_LEGIC_INFO: {
LegicRfInfo();
break;
}
case CMD_LEGIC_ESET: {
case CMD_HF_LEGIC_ESET: {
//-----------------------------------------------------------------------------
// Note: we call FpgaDownloadAndGo(FPGA_BITSTREAM_HF) here although FPGA is not
// involved in dealing with emulator memory. But if it is called later, it might
@@ -1047,19 +1047,19 @@ static void PacketReceived(PacketCommandNG *packet) {
#endif
#ifdef WITH_ISO14443b
case CMD_READ_SRI_TAG: {
case CMD_HF_SRI_READ: {
ReadSTMemoryIso14443b(packet->oldarg[0]);
break;
}
case CMD_SNIFF_ISO_14443B: {
case CMD_HF_ISO14443B_SNIFF: {
SniffIso14443b();
break;
}
case CMD_SIMULATE_TAG_ISO_14443B: {
case CMD_HF_ISO14443B_SIMULATE: {
SimulateIso14443bTag(packet->oldarg[0]);
break;
}
case CMD_ISO_14443B_COMMAND: {
case CMD_HF_ISO14443B_COMMAND: {
//SendRawCommand14443B(packet->oldarg[0],packet->oldarg[1],packet->oldarg[2],packet->data.asBytes);
SendRawCommand14443B_Ex(packet);
break;
@@ -1067,34 +1067,34 @@ static void PacketReceived(PacketCommandNG *packet) {
#endif
#ifdef WITH_FELICA
case CMD_FELICA_COMMAND: {
case CMD_HF_FELICA_COMMAND: {
felica_sendraw(packet);
break;
}
case CMD_FELICA_LITE_SIM: {
case CMD_HF_FELICALITE_SIMULATE: {
felica_sim_lite(packet->oldarg[0]);
break;
}
case CMD_FELICA_SNIFF: {
case CMD_HF_FELICA_SNIFF: {
felica_sniff(packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_FELICA_LITE_DUMP: {
case CMD_HF_FELICALITE_DUMP: {
felica_dump_lite_s();
break;
}
#endif
#ifdef WITH_ISO14443a
case CMD_SNIFF_ISO_14443a: {
case CMD_HF_ISO14443A_SNIFF: {
SniffIso14443a(packet->data.asBytes[0]);
break;
}
case CMD_READER_ISO_14443a: {
case CMD_HF_ISO14443A_READER: {
ReaderIso14443a(packet);
break;
}
case CMD_SIMULATE_TAG_ISO_14443a: {
case CMD_HF_ISO14443A_SIMULATE: {
struct p {
uint8_t tagtype;
uint8_t flags;
@@ -1104,80 +1104,80 @@ static void PacketReceived(PacketCommandNG *packet) {
SimulateIso14443aTag(payload->tagtype, payload->flags, payload->uid); // ## Simulate iso14443a tag - pass tag type & UID
break;
}
case CMD_ANTIFUZZ_ISO_14443a: {
case CMD_HF_ISO14443A_ANTIFUZZ: {
iso14443a_antifuzz(packet->oldarg[0]);
break;
}
case CMD_EPA_PACE_COLLECT_NONCE: {
case CMD_HF_EPA_COLLECT_NONCE: {
EPA_PACE_Collect_Nonce(packet);
break;
}
case CMD_EPA_PACE_REPLAY: {
case CMD_HF_EPA_REPLAY: {
EPA_PACE_Replay(packet);
break;
}
case CMD_READER_MIFARE: {
case CMD_HF_MIFARE_READER: {
ReaderMifare(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2]);
break;
}
case CMD_MIFARE_READBL: {
case CMD_HF_MIFARE_READBL: {
mf_readblock_t *payload = (mf_readblock_t *)packet->data.asBytes;
MifareReadBlock(payload->blockno, payload->keytype, payload->key);
break;
}
case CMD_MIFAREU_READBL: {
case CMD_HF_MIFAREU_READBL: {
MifareUReadBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFAREUC_AUTH: {
case CMD_HF_MIFAREUC_AUTH: {
MifareUC_Auth(packet->oldarg[0], packet->data.asBytes);
break;
}
case CMD_MIFAREU_READCARD: {
case CMD_HF_MIFAREU_READCARD: {
MifareUReadCard(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_MIFAREUC_SETPWD: {
case CMD_HF_MIFAREUC_SETPWD: {
MifareUSetPwd(packet->oldarg[0], packet->data.asBytes);
break;
}
case CMD_MIFARE_READSC: {
case CMD_HF_MIFARE_READSC: {
MifareReadSector(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFARE_WRITEBL: {
case CMD_HF_MIFARE_WRITEBL: {
MifareWriteBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
//case CMD_MIFAREU_WRITEBL_COMPAT: {
//case CMD_HF_MIFAREU_WRITEBL_COMPAT: {
//MifareUWriteBlockCompat(packet->oldarg[0], packet->data.asBytes);
//break;
//}
case CMD_MIFAREU_WRITEBL: {
case CMD_HF_MIFAREU_WRITEBL: {
MifareUWriteBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFARE_ACQUIRE_ENCRYPTED_NONCES: {
case CMD_HF_MIFARE_ACQ_ENCRYPTED_NONCES: {
MifareAcquireEncryptedNonces(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_MIFARE_ACQUIRE_NONCES: {
case CMD_HF_MIFARE_ACQ_NONCES: {
MifareAcquireNonces(packet->oldarg[0], packet->oldarg[2]);
break;
}
case CMD_MIFARE_NESTED: {
case CMD_HF_MIFARE_NESTED: {
MifareNested(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_MIFARE_CHKKEYS: {
case CMD_HF_MIFARE_CHKKEYS: {
MifareChkKeys(packet->data.asBytes);
break;
}
case CMD_MIFARE_CHKKEYS_FAST: {
case CMD_HF_MIFARE_CHKKEYS_FAST: {
MifareChkKeys_fast(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_SIMULATE_MIFARE_CARD: {
case CMD_HF_MIFARE_SIMULATE: {
struct p {
uint16_t flags;
uint8_t exitAfter;
@@ -1194,12 +1194,12 @@ static void PacketReceived(PacketCommandNG *packet) {
reply_ng(CMD_SET_DBGMODE, PM3_SUCCESS, NULL, 0);
break;
}
case CMD_MIFARE_EML_MEMCLR: {
case CMD_HF_MIFARE_EML_MEMCLR: {
MifareEMemClr();
reply_ng(CMD_MIFARE_EML_MEMCLR, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_HF_MIFARE_EML_MEMCLR, PM3_SUCCESS, NULL, 0);
break;
}
case CMD_MIFARE_EML_MEMSET: {
case CMD_HF_MIFARE_EML_MEMSET: {
struct p {
uint8_t blockno;
uint8_t blockcnt;
@@ -1210,7 +1210,7 @@ static void PacketReceived(PacketCommandNG *packet) {
MifareEMemSet(payload->blockno, payload->blockcnt, payload->blockwidth, payload->data);
break;
}
case CMD_MIFARE_EML_MEMGET: {
case CMD_HF_MIFARE_EML_MEMGET: {
struct p {
uint8_t blockno;
uint8_t blockcnt;
@@ -1219,71 +1219,71 @@ static void PacketReceived(PacketCommandNG *packet) {
MifareEMemGet(payload->blockno, payload->blockcnt);
break;
}
case CMD_MIFARE_EML_CARDLOAD: {
case CMD_HF_MIFARE_EML_LOAD: {
MifareECardLoad(packet->oldarg[0], packet->oldarg[1]);
break;
}
// Work with "magic Chinese" card
case CMD_MIFARE_CSETBLOCK: {
case CMD_HF_MIFARE_CSETBL: {
MifareCSetBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFARE_CGETBLOCK: {
case CMD_HF_MIFARE_CGETBL: {
MifareCGetBlock(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFARE_CIDENT: {
case CMD_HF_MIFARE_CIDENT: {
MifareCIdent();
break;
}
// mifare sniffer
// case CMD_MIFARE_SNIFFER: {
// case CMD_HF_MIFARE_SNIFF: {
// SniffMifare(packet->oldarg[0]);
// break;
// }
case CMD_MIFARE_SETMOD: {
case CMD_HF_MIFARE_SETMOD: {
MifareSetMod(packet->data.asBytes);
break;
}
//mifare desfire
case CMD_MIFARE_DESFIRE_READBL: {
case CMD_HF_DESFIRE_READBL: {
break;
}
case CMD_MIFARE_DESFIRE_WRITEBL: {
case CMD_HF_DESFIRE_WRITEBL: {
break;
}
case CMD_MIFARE_DESFIRE_AUTH1: {
case CMD_HF_DESFIRE_AUTH1: {
MifareDES_Auth1(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_MIFARE_DESFIRE_AUTH2: {
case CMD_HF_DESFIRE_AUTH2: {
//MifareDES_Auth2(packet->oldarg[0],packet->data.asBytes);
break;
}
case CMD_MIFARE_DES_READER: {
case CMD_HF_DESFIRE_READER: {
//readermifaredes(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFARE_DESFIRE_INFO: {
case CMD_HF_DESFIRE_INFO: {
MifareDesfireGetInformation();
break;
}
case CMD_MIFARE_DESFIRE: {
case CMD_HF_DESFIRE_COMMAND: {
MifareSendCommand(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_MIFARE_COLLECT_NONCES: {
case CMD_HF_MIFARE_COLLECT_NONCES: {
break;
}
case CMD_MIFARE_NACK_DETECT: {
case CMD_HF_MIFARE_NACK_DETECT: {
DetectNACKbug();
break;
}
case CMD_THINFILM_READ: {
case CMD_HF_THINFILM_READ: {
ReadThinFilm();
break;
}
case CMD_SIMULATE_TAG_THINFILM: {
case CMD_HF_THINFILM_SIMULATE: {
SimulateThinFilm(packet->data.asBytes, packet->length);
break;
}
@@ -1291,60 +1291,60 @@ static void PacketReceived(PacketCommandNG *packet) {
#ifdef WITH_ICLASS
// Makes use of ISO14443a FPGA Firmware
case CMD_SNIFF_ICLASS: {
case CMD_HF_ICLASS_SNIFF: {
SniffIClass();
break;
}
case CMD_SIMULATE_TAG_ICLASS: {
case CMD_HF_ICLASS_SIMULATE: {
SimulateIClass(packet->oldarg[0], packet->oldarg[1], packet->oldarg[2], packet->data.asBytes);
break;
}
case CMD_READER_ICLASS: {
case CMD_HF_ICLASS_READER: {
ReaderIClass(packet->oldarg[0]);
break;
}
case CMD_READER_ICLASS_REPLAY: {
case CMD_HF_ICLASS_REPLAY: {
ReaderIClass_Replay(packet->oldarg[0], packet->data.asBytes);
break;
}
case CMD_ICLASS_EML_MEMSET: {
case CMD_HF_ICLASS_EML_MEMSET: {
//iceman, should call FPGADOWNLOAD before, since it corrupts BigBuf
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
emlSet(packet->data.asBytes, packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_ICLASS_WRITEBLOCK: {
case CMD_HF_ICLASS_WRITEBL: {
iClass_WriteBlock(packet->oldarg[0], packet->data.asBytes);
break;
}
case CMD_ICLASS_READCHECK: { // auth step 1
case CMD_HF_ICLASS_READCHECK: { // auth step 1
iClass_ReadCheck(packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_ICLASS_READBLOCK: {
case CMD_HF_ICLASS_READBL: {
iClass_ReadBlk(packet->oldarg[0]);
break;
}
case CMD_ICLASS_AUTHENTICATION: { //check
case CMD_HF_ICLASS_AUTH: { //check
iClass_Authentication(packet->data.asBytes);
break;
}
case CMD_ICLASS_CHECK_KEYS: {
case CMD_HF_ICLASS_CHKKEYS: {
iClass_Authentication_fast(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
case CMD_ICLASS_DUMP: {
case CMD_HF_ICLASS_DUMP: {
iClass_Dump(packet->oldarg[0], packet->oldarg[1]);
break;
}
case CMD_ICLASS_CLONE: {
case CMD_HF_ICLASS_CLONE: {
iClass_Clone(packet->oldarg[0], packet->oldarg[1], packet->data.asBytes);
break;
}
#endif
#ifdef WITH_HFSNIFF
case CMD_HF_SNIFFER: {
case CMD_HF_SNIFF: {
HfSniff(packet->oldarg[0], packet->oldarg[1]);
break;
}
@@ -1546,7 +1546,7 @@ static void PacketReceived(PacketCommandNG *packet) {
break;
}
#ifdef WITH_LF
case CMD_UPLOAD_SIM_SAMPLES_125K: {
case CMD_LF_UPLOAD_SIM_SAMPLES: {
// iceman; since changing fpga_bitstreams clears bigbuff, Its better to call it before.
// to be able to use this one for uploading data to device
// flag =
@@ -1568,7 +1568,7 @@ static void PacketReceived(PacketCommandNG *packet) {
uint8_t *mem = BigBuf_get_addr();
memcpy(mem + payload->offset, &payload->data, PM3_CMD_DATA_SIZE - 3);
reply_ng(CMD_UPLOAD_SIM_SAMPLES_125K, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_UPLOAD_SIM_SAMPLES, PM3_SUCCESS, NULL, 0);
break;
}
#endif
@@ -1836,7 +1836,7 @@ static void PacketReceived(PacketCommandNG *packet) {
break;
}
#endif
case CMD_SET_LF_DIVISOR: {
case CMD_LF_SET_DIVISOR: {
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, packet->data.asBytes[0]);
break;

12
armsrc/iclass.c
View File

@@ -1195,11 +1195,11 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
if (doIClassSimulation(MODE_EXIT_AFTER_MAC, mac_responses + i * EPURSE_MAC_SIZE)) {
// Button pressed
reply_old(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i, 0, mac_responses, i * EPURSE_MAC_SIZE);
reply_old(CMD_ACK, CMD_HF_ICLASS_SIMULATE, i, 0, mac_responses, i * EPURSE_MAC_SIZE);
goto out;
}
}
reply_old(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i, 0, mac_responses, i * EPURSE_MAC_SIZE);
reply_old(CMD_ACK, CMD_HF_ICLASS_SIMULATE, i, 0, mac_responses, i * EPURSE_MAC_SIZE);
} else if (simType == 3) {
//This is 'full sim' mode, where we use the emulator storage for data.
@@ -1226,20 +1226,20 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
// keyroll 1
if (doIClassSimulation(MODE_EXIT_AFTER_MAC, mac_responses + i * EPURSE_MAC_SIZE)) {
reply_old(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i * 2, 0, mac_responses, i * EPURSE_MAC_SIZE * 2);
reply_old(CMD_ACK, CMD_HF_ICLASS_SIMULATE, i * 2, 0, mac_responses, i * EPURSE_MAC_SIZE * 2);
// Button pressed
goto out;
}
// keyroll 2
if (doIClassSimulation(MODE_EXIT_AFTER_MAC, mac_responses + (i + numberOfCSNS) * EPURSE_MAC_SIZE)) {
reply_old(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i * 2, 0, mac_responses, i * EPURSE_MAC_SIZE * 2);
reply_old(CMD_ACK, CMD_HF_ICLASS_SIMULATE, i * 2, 0, mac_responses, i * EPURSE_MAC_SIZE * 2);
// Button pressed
goto out;
}
}
// double the amount of collected data.
reply_old(CMD_ACK, CMD_SIMULATE_TAG_ICLASS, i * 2, 0, mac_responses, i * EPURSE_MAC_SIZE * 2);
reply_old(CMD_ACK, CMD_HF_ICLASS_SIMULATE, i * 2, 0, mac_responses, i * EPURSE_MAC_SIZE * 2);
} else {
// We may want a mode here where we hardcode the csns to use (from proxclone).
@@ -2222,7 +2222,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *mac) {
switch_off();
}
// not used. ?!? ( CMD_ICLASS_READCHECK)
// not used. ?!? ( CMD_HF_ICLASS_READCHECK)
// turn off afterwards
void iClass_ReadCheck(uint8_t blockno, uint8_t keytype) {
uint8_t readcheck[] = { keytype, blockno };

8
armsrc/iso14443a.c
View File

@@ -1149,7 +1149,7 @@ void SimulateIso14443aTag(uint8_t tagType, uint8_t flags, uint8_t *data) {
if (SimulateIso14443aInit(tagType, flags, data, &responses, &cuid, counters, tearings, &pages) == false) {
BigBuf_free_keep_EM();
reply_ng(CMD_SIMULATE_MIFARE_CARD, PM3_EINIT, NULL, 0);
reply_ng(CMD_HF_MIFARE_SIMULATE, PM3_EINIT, NULL, 0);
return;
}
@@ -1269,7 +1269,7 @@ void SimulateIso14443aTag(uint8_t tagType, uint8_t flags, uint8_t *data) {
ar_nr_nonces[index].state = SECOND;
// send to client (one struct nonces_t)
reply_ng(CMD_SIMULATE_MIFARE_CARD, PM3_SUCCESS, (uint8_t *)&ar_nr_nonces[index], sizeof(nonces_t));
reply_ng(CMD_HF_MIFARE_SIMULATE, PM3_SUCCESS, (uint8_t *)&ar_nr_nonces[index], sizeof(nonces_t));
ar_nr_nonces[index].state = EMPTY;
ar_nr_nonces[index].sector = 0;
@@ -1593,7 +1593,7 @@ void SimulateIso14443aTag(uint8_t tagType, uint8_t flags, uint8_t *data) {
Dbprintf("-[ Num of moebius tries [%d]", moebius_count);
}
reply_ng(CMD_SIMULATE_MIFARE_CARD, retval, NULL, 0);
reply_ng(CMD_HF_MIFARE_SIMULATE, retval, NULL, 0);
}
// prepare a delayed transfer. This simply shifts ToSend[] by a number
@@ -3246,7 +3246,7 @@ void DetectNACKbug(void) {
data[0] = isOK;
data[1] = num_nacks;
num_to_bytes(i, 2, data + 2);
reply_ng(CMD_MIFARE_NACK_DETECT, status, data, 4);
reply_ng(CMD_HF_MIFARE_NACK_DETECT, status, data, 4);
//reply_mix(CMD_ACK, isOK, num_nacks, i, 0, 0);
BigBuf_free();

22
armsrc/lfops.c
View File

@@ -432,7 +432,7 @@ void ModThenAcquireRawAdcSamples125k(uint32_t delay_off, uint32_t period_0, uint
// Turn off antenna
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
// tell client we are done
reply_ng(CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_MOD_THEN_ACQ_RAW_ADC, PM3_SUCCESS, NULL, 0);
}
/* blank r/w tag data stream
@@ -1012,7 +1012,7 @@ void CmdHIDsimTAGEx(uint32_t hi, uint32_t lo, bool ledcontrol, int numcycles) {
void CmdHIDsimTAG(uint32_t hi, uint32_t lo, bool ledcontrol) {
CmdHIDsimTAGEx(hi, lo, ledcontrol, -1);
reply_ng(CMD_HID_SIM_TAG, PM3_EOPABORTED, NULL, 0);
reply_ng(CMD_LF_HID_SIMULATE, PM3_EOPABORTED, NULL, 0);
}
// prepare a waveform pattern in the buffer based on the ID given then
@@ -1050,7 +1050,7 @@ void CmdFSKsimTAG(uint8_t fchigh, uint8_t fclow, uint8_t separator, uint8_t clk,
if (ledcontrol) LED_A_ON();
SimulateTagLowFrequency(n, 0, ledcontrol);
if (ledcontrol) LED_A_OFF();
reply_ng(CMD_FSK_SIM_TAG, PM3_EOPABORTED, NULL, 0);
reply_ng(CMD_LF_FSK_SIMULATE, PM3_EOPABORTED, NULL, 0);
}
// compose ask waveform for one bit(ASK)
@@ -1139,7 +1139,7 @@ void CmdASKsimTAG(uint8_t encoding, uint8_t invert, uint8_t separator, uint8_t c
if (ledcontrol) LED_A_ON();
SimulateTagLowFrequency(n, 0, ledcontrol);
if (ledcontrol) LED_A_OFF();
reply_ng(CMD_ASK_SIM_TAG, PM3_EOPABORTED, NULL, 0);
reply_ng(CMD_LF_ASK_SIMULATE, PM3_EOPABORTED, NULL, 0);
}
//carrier can be 2,4 or 8
@@ -1186,7 +1186,7 @@ void CmdPSKsimTag(uint8_t carrier, uint8_t invert, uint8_t clk, uint16_t size, u
if (ledcontrol) LED_A_ON();
SimulateTagLowFrequency(n, 0, ledcontrol);
if (ledcontrol) LED_A_OFF();
reply_ng(CMD_PSK_SIM_TAG, PM3_EOPABORTED, NULL, 0);
reply_ng(CMD_LF_PSK_SIMULATE, PM3_EOPABORTED, NULL, 0);
}
// loop to get raw HID waveform then FSK demodulate the TAG ID from it
@@ -1803,7 +1803,7 @@ void T55xxWriteBlock(uint8_t *data) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
// cmd_send(CMD_ACK,0,0,0,0,0);
reply_ng(CMD_T55XX_WRITE_BLOCK, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_T55XX_WRITEBL, PM3_SUCCESS, NULL, 0);
LED_A_OFF();
}
@@ -1812,7 +1812,7 @@ void T55xxWriteBlock(uint8_t *data) {
void T55xxWriteBlock(uint8_t *data) {
t55xx_write_block_t *c = (t55xx_write_block_t *)data;
T55xxWriteBlockExt(c->data, c->blockno, c->pwd, c->flags);
// reply_ng(CMD_T55XX_WRITE_BLOCK, PM3_SUCCESS, NULL, 0);
// reply_ng(CMD_LF_T55XX_WRITEBL, PM3_SUCCESS, NULL, 0);
}
*/
/*
@@ -1864,7 +1864,7 @@ bool brute_mem = (flags & 0x0100) >> 8;
// Turn the field off
if (!brute_mem) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
reply_ng(CMD_T55XX_READ_BLOCK, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_T55XX_READBL, PM3_SUCCESS, NULL, 0);
LED_A_OFF();
}
}
@@ -1924,7 +1924,7 @@ void T55xxReadBlock(uint8_t page, bool pwd_mode, bool brute_mem, uint8_t block,
// Turn the field off
if (!brute_mem) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
reply_ng(CMD_T55XX_READ_BLOCK, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_T55XX_READBL, PM3_SUCCESS, NULL, 0);
LED_A_OFF();
}
@@ -2412,7 +2412,7 @@ void EM4xReadWord(uint8_t addr, uint32_t pwd, uint8_t usepwd) {
DoPartialAcquisition(20, true, 6000, 1000);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
reply_ng(CMD_EM4X_READ_WORD, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_EM4X_READWORD, PM3_SUCCESS, NULL, 0);
LED_A_OFF();
}
@@ -2445,7 +2445,7 @@ void EM4xWriteWord(uint8_t addr, uint32_t data, uint32_t pwd, uint8_t usepwd) {
DoPartialAcquisition(20, true, 6000, 1000);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
reply_ng(CMD_EM4X_WRITE_WORD, PM3_SUCCESS, NULL, 0);
reply_ng(CMD_LF_EM4X_WRITEWORD, PM3_SUCCESS, NULL, 0);
LED_A_OFF();
}

12
armsrc/mifarecmd.c
View File

@@ -94,7 +94,7 @@ void MifareReadBlock(uint8_t blockNo, uint8_t keyType, uint8_t *datain) {
if (DBGLEVEL >= 2) DbpString("READ BLOCK FINISHED");
LED_B_ON();
reply_ng(CMD_MIFARE_READBL, status, dataoutbuf, 16);
reply_ng(CMD_HF_MIFARE_READBL, status, dataoutbuf, 16);
LED_B_OFF();
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
@@ -1601,7 +1601,7 @@ void MifareChkKeys(uint8_t *datain) {
LED_B_ON();
reply_ng(CMD_MIFARE_CHKKEYS, PM3_SUCCESS, (uint8_t *)&keyresult, sizeof(keyresult));
reply_ng(CMD_HF_MIFARE_CHKKEYS, PM3_SUCCESS, (uint8_t *)&keyresult, sizeof(keyresult));
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff();
@@ -1637,7 +1637,7 @@ void MifareEMemGet(uint8_t blockno, uint8_t blockcnt) {
//
size_t size = blockcnt * 16;
if (size > PM3_CMD_DATA_SIZE) {
reply_ng(CMD_MIFARE_EML_MEMGET, PM3_EMALLOC, NULL, 0);
reply_ng(CMD_HF_MIFARE_EML_MEMGET, PM3_EMALLOC, NULL, 0);
return;
}
@@ -1646,7 +1646,7 @@ void MifareEMemGet(uint8_t blockno, uint8_t blockcnt) {
emlGetMem(buf, blockno, blockcnt); // data, block num, blocks count (max 4)
LED_B_ON();
reply_ng(CMD_MIFARE_EML_MEMGET, PM3_SUCCESS, buf, size);
reply_ng(CMD_HF_MIFARE_EML_MEMGET, PM3_SUCCESS, buf, size);
LED_B_OFF();
BigBuf_free_keep_EM();
}
@@ -1990,7 +1990,7 @@ TEST2:
OUT:
data[0] = isGen;
reply_ng(CMD_MIFARE_CIDENT, PM3_SUCCESS, data, sizeof(data));
reply_ng(CMD_HF_MIFARE_CIDENT, PM3_SUCCESS, data, sizeof(data));
// turns off
OnSuccessMagic();
BigBuf_free();
@@ -2059,7 +2059,7 @@ void MifareSetMod(uint8_t *datain) {
crypto1_destroy(pcs);
LED_B_ON();
reply_ng(CMD_MIFARE_SETMOD, isOK, NULL, 0);
reply_ng(CMD_HF_MIFARE_SETMOD, isOK, NULL, 0);
LED_B_OFF();

2
armsrc/mifaresim.c
View File

@@ -1221,7 +1221,7 @@ void Mifare1ksim(uint16_t flags, uint8_t exitAfterNReads, uint8_t *datain) {
if ((flags & FLAG_INTERACTIVE) == FLAG_INTERACTIVE) { // Interactive mode flag, means we need to send ACK
//Send the collected ar_nr in the response
reply_old(CMD_ACK, CMD_SIMULATE_MIFARE_CARD, button_pushed, 0, &ar_nr_resp, sizeof(ar_nr_resp));
reply_old(CMD_ACK, CMD_HF_MIFARE_SIMULATE, button_pushed, 0, &ar_nr_resp, sizeof(ar_nr_resp));
}
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);

4
armsrc/thinfilm.c
View File

@@ -30,7 +30,7 @@ void ReadThinFilm(void) {
// power on and listen for answer.
bool status = GetIso14443aAnswerFromTag_Thinfilm(buf, &len);
reply_ng(CMD_THINFILM_READ, status ? PM3_SUCCESS : PM3_ENODATA, buf, len);
reply_ng(CMD_HF_THINFILM_READ, status ? PM3_SUCCESS : PM3_ENODATA, buf, len);
iso14443a_off();
set_tracing(false);
@@ -148,5 +148,5 @@ void SimulateThinFilm(uint8_t *data, size_t len) {
}
}
LED_A_OFF();
reply_ng(CMD_SIMULATE_TAG_THINFILM, status, NULL, 0);
reply_ng(CMD_HF_THINFILM_SIMULATE, status, NULL, 0);
}