github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-20 13:23:51 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Replace WITH_ISO14443a by dynamic detection in client

Browse source
This commit is contained in:
Philippe Teuwen 2019-05-01 23:38:57 +02:00
commit e6135a8f78
11 changed files with 99 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

20
client/cmdhf14a.c
View file

@ -1116,16 +1116,16 @@ static int CmdHF14AChaining(const char *Cmd) {
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdHF14AList, IfPm3Present, "List ISO 14443-a history"}, {"list", CmdHF14AList, IfPm3Iso14443a, "List ISO 14443-a history"},
{"info", CmdHF14AInfo, IfPm3Present, "Tag information"}, {"info", CmdHF14AInfo, IfPm3Iso14443a, "Tag information"},
{"reader", CmdHF14AReader, IfPm3Present, "Act like an ISO14443-a reader"}, {"reader", CmdHF14AReader, IfPm3Iso14443a, "Act like an ISO14443-a reader"},
{"cuids", CmdHF14ACUIDs, IfPm3Present, "<n> Collect n>0 ISO14443-a UIDs in one go"}, {"cuids", CmdHF14ACUIDs, IfPm3Iso14443a, "<n> Collect n>0 ISO14443-a UIDs in one go"},
{"sim", CmdHF14ASim, IfPm3Present, "<UID> -- Simulate ISO 14443-a tag"}, {"sim", CmdHF14ASim, IfPm3Iso14443a, "<UID> -- Simulate ISO 14443-a tag"},
{"sniff", CmdHF14ASniff, IfPm3Present, "sniff ISO 14443-a traffic"}, {"sniff", CmdHF14ASniff, IfPm3Iso14443a, "sniff ISO 14443-a traffic"},
{"apdu", CmdHF14AAPDU, IfPm3Present, "Send ISO 14443-4 APDU to tag"}, {"apdu", CmdHF14AAPDU, IfPm3Iso14443a, "Send ISO 14443-4 APDU to tag"},
{"chaining", CmdHF14AChaining, IfPm3Present, "Control ISO 14443-4 input chaining"}, {"chaining", CmdHF14AChaining, IfPm3Iso14443a, "Control ISO 14443-4 input chaining"},
{"raw", CmdHF14ACmdRaw, IfPm3Present, "Send raw hex data to tag"}, {"raw", CmdHF14ACmdRaw, IfPm3Iso14443a, "Send raw hex data to tag"},
{"antifuzz", CmdHF14AAntiFuzz, IfPm3Present, "Fuzzing the anticollision phase. Warning! Readers may react strange"}, {"antifuzz", CmdHF14AAntiFuzz, IfPm3Iso14443a, "Fuzzing the anticollision phase. Warning! Readers may react strange"},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}
}; };

4
client/cmdhfepa.c
View file

@ -158,8 +158,8 @@ static int CmdHFEPAPACEReplay(const char *Cmd) {
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"cnonces", CmdHFEPACollectPACENonces, IfPm3Present, "<m> <n> <d> Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"}, {"cnonces", CmdHFEPACollectPACENonces, IfPm3Iso14443, "<m> <n> <d> Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"},
{"preplay", CmdHFEPAPACEReplay, IfPm3Present, "<mse> <get> <map> <pka> <ma> Perform PACE protocol by replaying given APDUs"}, {"preplay", CmdHFEPAPACEReplay, IfPm3Iso14443, "<mse> <get> <map> <pka> <ma> Perform PACE protocol by replaying given APDUs"},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}
}; };

10
client/cmdhffido.c
View file

@ -896,11 +896,11 @@ static int CmdHFFido2GetAssertion(const char *cmd) {
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help."}, {"help", CmdHelp, AlwaysAvailable, "This help."},
{"info", CmdHFFidoInfo, IfPm3Present, "Info about FIDO tag."}, {"info", CmdHFFidoInfo, IfPm3Iso14443a, "Info about FIDO tag."},
{"reg", CmdHFFidoRegister, IfPm3Present, "FIDO U2F Registration Message."}, {"reg", CmdHFFidoRegister, IfPm3Iso14443a, "FIDO U2F Registration Message."},
{"auth", CmdHFFidoAuthenticate, IfPm3Present, "FIDO U2F Authentication Message."}, {"auth", CmdHFFidoAuthenticate, IfPm3Iso14443a, "FIDO U2F Authentication Message."},
{"make", CmdHFFido2MakeCredential, IfPm3Present, "FIDO2 MakeCredential command."}, {"make", CmdHFFido2MakeCredential, IfPm3Iso14443a, "FIDO2 MakeCredential command."},
{"assert", CmdHFFido2GetAssertion, IfPm3Present, "FIDO2 GetAssertion command."}, {"assert", CmdHFFido2GetAssertion, IfPm3Iso14443a, "FIDO2 GetAssertion command."},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };

74
client/cmdhfmf.c
View file

@ -3551,46 +3551,46 @@ static int CmdHF14AMfList(const char *Cmd) {
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdHF14AMfList, IfPm3Present, "List Mifare history"}, {"list", CmdHF14AMfList, IfPm3Iso14443a, "List Mifare history"},
{"darkside", CmdHF14AMfDarkside, IfPm3Present, "Darkside attack. read parity error messages."}, {"darkside", CmdHF14AMfDarkside, IfPm3Iso14443a, "Darkside attack. read parity error messages."},
{"nested", CmdHF14AMfNested, IfPm3Present, "Nested attack. Test nested authentication"}, {"nested", CmdHF14AMfNested, IfPm3Iso14443a, "Nested attack. Test nested authentication"},
{"hardnested", CmdHF14AMfNestedHard, IfPm3Present, "Nested attack for hardened Mifare cards"}, {"hardnested", CmdHF14AMfNestedHard, IfPm3Iso14443a, "Nested attack for hardened Mifare cards"},
{"keybrute", CmdHF14AMfKeyBrute, IfPm3Present, "J_Run's 2nd phase of multiple sector nested authentication key recovery"}, {"keybrute", CmdHF14AMfKeyBrute, IfPm3Iso14443a, "J_Run's 2nd phase of multiple sector nested authentication key recovery"},
{"nack", CmdHf14AMfNack, IfPm3Present, "Test for Mifare NACK bug"}, {"nack", CmdHf14AMfNack, IfPm3Iso14443a, "Test for Mifare NACK bug"},
{"chk", CmdHF14AMfChk, IfPm3Present, "Check keys"}, {"chk", CmdHF14AMfChk, IfPm3Iso14443a, "Check keys"},
{"fchk", CmdHF14AMfChk_fast, IfPm3Present, "Check keys fast, targets all keys on card"}, {"fchk", CmdHF14AMfChk_fast, IfPm3Iso14443a, "Check keys fast, targets all keys on card"},
{"decrypt", CmdHf14AMfDecryptBytes, AlwaysAvailable, "[nt] [ar_enc] [at_enc] [data] - to decrypt sniff or trace"}, {"decrypt", CmdHf14AMfDecryptBytes, AlwaysAvailable, "[nt] [ar_enc] [at_enc] [data] - to decrypt sniff or trace"},
{"-----------", CmdHelp, IfPm3Present, ""}, {"-----------", CmdHelp, IfPm3Iso14443a, ""},
{"dbg", CmdHF14AMfDbg, IfPm3Present, "Set default debug mode"}, {"dbg", CmdHF14AMfDbg, IfPm3Iso14443a, "Set default debug mode"},
{"rdbl", CmdHF14AMfRdBl, IfPm3Present, "Read MIFARE classic block"}, {"rdbl", CmdHF14AMfRdBl, IfPm3Iso14443a, "Read MIFARE classic block"},
{"rdsc", CmdHF14AMfRdSc, IfPm3Present, "Read MIFARE classic sector"}, {"rdsc", CmdHF14AMfRdSc, IfPm3Iso14443a, "Read MIFARE classic sector"},
{"dump", CmdHF14AMfDump, IfPm3Present, "Dump MIFARE classic tag to binary file"}, {"dump", CmdHF14AMfDump, IfPm3Iso14443a, "Dump MIFARE classic tag to binary file"},
{"restore", CmdHF14AMfRestore, IfPm3Present, "Restore MIFARE classic binary file to BLANK tag"}, {"restore", CmdHF14AMfRestore, IfPm3Iso14443a, "Restore MIFARE classic binary file to BLANK tag"},
{"wrbl", CmdHF14AMfWrBl, IfPm3Present, "Write MIFARE classic block"}, {"wrbl", CmdHF14AMfWrBl, IfPm3Iso14443a, "Write MIFARE classic block"},
{"setmod", CmdHf14AMfSetMod, IfPm3Present, "Set MIFARE Classic EV1 load modulation strength"}, {"setmod", CmdHf14AMfSetMod, IfPm3Iso14443a, "Set MIFARE Classic EV1 load modulation strength"},
{"auth4", CmdHF14AMfAuth4, IfPm3Present, "ISO14443-4 AES authentication"}, {"auth4", CmdHF14AMfAuth4, IfPm3Iso14443a, "ISO14443-4 AES authentication"},
// {"sniff", CmdHF14AMfSniff, 0, "Sniff card-reader communication"}, // {"sniff", CmdHF14AMfSniff, 0, "Sniff card-reader communication"},
{"-----------", CmdHelp, IfPm3Present, ""}, {"-----------", CmdHelp, IfPm3Iso14443a, ""},
{"sim", CmdHF14AMfSim, IfPm3Present, "Simulate MIFARE card"}, {"sim", CmdHF14AMfSim, IfPm3Iso14443a, "Simulate MIFARE card"},
{"eclr", CmdHF14AMfEClear, IfPm3Present, "Clear simulator memory"}, {"eclr", CmdHF14AMfEClear, IfPm3Iso14443a, "Clear simulator memory"},
{"eget", CmdHF14AMfEGet, IfPm3Present, "Get simulator memory block"}, {"eget", CmdHF14AMfEGet, IfPm3Iso14443a, "Get simulator memory block"},
{"eset", CmdHF14AMfESet, IfPm3Present, "Set simulator memory block"}, {"eset", CmdHF14AMfESet, IfPm3Iso14443a, "Set simulator memory block"},
{"eload", CmdHF14AMfELoad, IfPm3Present, "Load from file emul dump"}, {"eload", CmdHF14AMfELoad, IfPm3Iso14443a, "Load from file emul dump"},
{"esave", CmdHF14AMfESave, IfPm3Present, "Save to file emul dump"}, {"esave", CmdHF14AMfESave, IfPm3Iso14443a, "Save to file emul dump"},
{"ecfill", CmdHF14AMfECFill, IfPm3Present, "Fill simulator memory with help of keys from simulator"}, {"ecfill", CmdHF14AMfECFill, IfPm3Iso14443a, "Fill simulator memory with help of keys from simulator"},
{"ekeyprn", CmdHF14AMfEKeyPrn, IfPm3Present, "Print keys from simulator memory"}, {"ekeyprn", CmdHF14AMfEKeyPrn, IfPm3Iso14443a, "Print keys from simulator memory"},
{"-----------", CmdHelp, IfPm3Present, ""}, {"-----------", CmdHelp, IfPm3Iso14443a, ""},
{"csetuid", CmdHF14AMfCSetUID, IfPm3Present, "Set UID for magic Chinese card"}, {"csetuid", CmdHF14AMfCSetUID, IfPm3Iso14443a, "Set UID for magic Chinese card"},
{"csetblk", CmdHF14AMfCSetBlk, IfPm3Present, "Write block - Magic Chinese card"}, {"csetblk", CmdHF14AMfCSetBlk, IfPm3Iso14443a, "Write block - Magic Chinese card"},
{"cgetblk", CmdHF14AMfCGetBlk, IfPm3Present, "Read block - Magic Chinese card"}, {"cgetblk", CmdHF14AMfCGetBlk, IfPm3Iso14443a, "Read block - Magic Chinese card"},
{"cgetsc", CmdHF14AMfCGetSc, IfPm3Present, "Read sector - Magic Chinese card"}, {"cgetsc", CmdHF14AMfCGetSc, IfPm3Iso14443a, "Read sector - Magic Chinese card"},
{"cload", CmdHF14AMfCLoad, IfPm3Present, "Load dump into magic Chinese card"}, {"cload", CmdHF14AMfCLoad, IfPm3Iso14443a, "Load dump into magic Chinese card"},
{"csave", CmdHF14AMfCSave, IfPm3Present, "Save dump from magic Chinese card into file or emulator"}, {"csave", CmdHF14AMfCSave, IfPm3Iso14443a, "Save dump from magic Chinese card into file or emulator"},
{"-----------", CmdHelp, IfPm3Present, ""}, {"-----------", CmdHelp, IfPm3Iso14443a, ""},
{"mad", CmdHF14AMfMAD, IfPm3Present, "Checks and prints MAD"}, {"mad", CmdHF14AMfMAD, IfPm3Iso14443a, "Checks and prints MAD"},
{"ndef", CmdHFMFNDEF, IfPm3Present, "Prints NDEF records from card"}, {"ndef", CmdHFMFNDEF, IfPm3Iso14443a, "Prints NDEF records from card"},
{"ice", CmdHF14AMfice, IfPm3Present, "collect Mifare Classic nonces to file"}, {"ice", CmdHF14AMfice, IfPm3Iso14443a, "collect Mifare Classic nonces to file"},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}
}; };

10
client/cmdhfmfdes.c
View file

@ -625,11 +625,11 @@ static int CmdHF14ADesAuth(const char *Cmd) {
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"info", CmdHF14ADesInfo, IfPm3Present, "Tag information"}, {"info", CmdHF14ADesInfo, IfPm3Iso14443a, "Tag information"},
{"enum", CmdHF14ADesEnumApplications, IfPm3Present, "Tries enumerate all applications"}, {"enum", CmdHF14ADesEnumApplications, IfPm3Iso14443a, "Tries enumerate all applications"},
{"auth", CmdHF14ADesAuth, IfPm3Present, "Tries a MIFARE DesFire Authentication"}, {"auth", CmdHF14ADesAuth, IfPm3Iso14443a, "Tries a MIFARE DesFire Authentication"},
// {"rdbl", CmdHF14ADesRb, 0, "Read MIFARE DesFire block"}, // {"rdbl", CmdHF14ADesRb, IfPm3Iso14443a, "Read MIFARE DesFire block"},
// {"wrbl", CmdHF14ADesWb, 0, "write MIFARE DesFire block"}, // {"wrbl", CmdHF14ADesWb, IfPm3Iso14443a, "write MIFARE DesFire block"},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}
}; };

6
client/cmdhfmfdesfire.c
View file

@ -221,9 +221,9 @@ static int CmdHF14AMfAESAuth(const char *Cmd) {
//------------------------------------ //------------------------------------
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"dbg", CmdHF14AMfDbg, IfPm3Present, "Set default debug mode"}, {"dbg", CmdHF14AMfDbg, IfPm3Iso14443a, "Set default debug mode"},
{"des-auth", CmdHF14AMfDESAuth, IfPm3Present, "Desfire Authentication"}, {"des-auth", CmdHF14AMfDESAuth, IfPm3Iso14443a, "Desfire Authentication"},
{"ev1-auth", CmdHF14AMfAESAuth, IfPm3Present, "EV1 Authentication"}, {"ev1-auth", CmdHF14AMfAESAuth, IfPm3Iso14443a, "EV1 Authentication"},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}
}; };

20
client/cmdhfmfp.c
View file

@ -840,16 +840,16 @@ static int CmdHFMFPNDEF(const char *cmd) {
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"info", CmdHFMFPInfo, IfPm3Present, "Info about Mifare Plus tag"}, {"info", CmdHFMFPInfo, IfPm3Iso14443a, "Info about Mifare Plus tag"},
{"wrp", CmdHFMFPWritePerso, IfPm3Present, "Write Perso command"}, {"wrp", CmdHFMFPWritePerso, IfPm3Iso14443a, "Write Perso command"},
{"initp", CmdHFMFPInitPerso, IfPm3Present, "Fills all the card's keys"}, {"initp", CmdHFMFPInitPerso, IfPm3Iso14443a, "Fills all the card's keys"},
{"commitp", CmdHFMFPCommitPerso, IfPm3Present, "Move card to SL1 or SL3 mode"}, {"commitp", CmdHFMFPCommitPerso, IfPm3Iso14443a, "Move card to SL1 or SL3 mode"},
{"auth", CmdHFMFPAuth, IfPm3Present, "Authentication"}, {"auth", CmdHFMFPAuth, IfPm3Iso14443a, "Authentication"},
{"rdbl", CmdHFMFPRdbl, IfPm3Present, "Read blocks"}, {"rdbl", CmdHFMFPRdbl, IfPm3Iso14443a, "Read blocks"},
{"rdsc", CmdHFMFPRdsc, IfPm3Present, "Read sectors"}, {"rdsc", CmdHFMFPRdsc, IfPm3Iso14443a, "Read sectors"},
{"wrbl", CmdHFMFPWrbl, IfPm3Present, "Write blocks"}, {"wrbl", CmdHFMFPWrbl, IfPm3Iso14443a, "Write blocks"},
{"mad", CmdHFMFPMAD, IfPm3Present, "Checks and prints MAD"}, {"mad", CmdHFMFPMAD, IfPm3Iso14443a, "Checks and prints MAD"},
{"ndef", CmdHFMFPNDEF, IfPm3Present, "Prints NDEF records from card"}, {"ndef", CmdHFMFPNDEF, IfPm3Iso14443a, "Prints NDEF records from card"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };

22
client/cmdhfmfu.c
View file

@ -2700,17 +2700,17 @@ static int CmdHF14AMfUPwdGen(const char *Cmd) {
//------------------------------------ //------------------------------------
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"dbg", CmdHF14AMfDbg, IfPm3Present, "Set default debug mode"}, {"dbg", CmdHF14AMfDbg, IfPm3Iso14443a, "Set default debug mode"},
{"info", CmdHF14AMfUInfo, IfPm3Present, "Tag information"}, {"info", CmdHF14AMfUInfo, IfPm3Iso14443a, "Tag information"},
{"dump", CmdHF14AMfUDump, IfPm3Present, "Dump Ultralight / Ultralight-C / NTAG tag to binary file"}, {"dump", CmdHF14AMfUDump, IfPm3Iso14443a, "Dump Ultralight / Ultralight-C / NTAG tag to binary file"},
{"restore", CmdHF14AMfURestore, IfPm3Present, "Restore a dump onto a MFU MAGIC tag"}, {"restore", CmdHF14AMfURestore, IfPm3Iso14443a, "Restore a dump onto a MFU MAGIC tag"},
{"eload", CmdHF14AMfUeLoad, IfPm3Present, "load Ultralight .eml dump file into emulator memory"}, {"eload", CmdHF14AMfUeLoad, IfPm3Iso14443a, "load Ultralight .eml dump file into emulator memory"},
{"rdbl", CmdHF14AMfURdBl, IfPm3Present, "Read block"}, {"rdbl", CmdHF14AMfURdBl, IfPm3Iso14443a, "Read block"},
{"wrbl", CmdHF14AMfUWrBl, IfPm3Present, "Write block"}, {"wrbl", CmdHF14AMfUWrBl, IfPm3Iso14443a, "Write block"},
{"cauth", CmdHF14AMfUCAuth, IfPm3Present, "Authentication - Ultralight C"}, {"cauth", CmdHF14AMfUCAuth, IfPm3Iso14443a, "Authentication - Ultralight C"},
{"setpwd", CmdHF14AMfUCSetPwd, IfPm3Present, "Set 3des password - Ultralight-C"}, {"setpwd", CmdHF14AMfUCSetPwd, IfPm3Iso14443a, "Set 3des password - Ultralight-C"},
{"setuid", CmdHF14AMfUCSetUid, IfPm3Present, "Set UID - MAGIC tags only"}, {"setuid", CmdHF14AMfUCSetUid, IfPm3Iso14443a, "Set UID - MAGIC tags only"},
{"sim", CmdHF14AMfUSim, IfPm3Present, "Simulate Ultralight from emulator memory"}, {"sim", CmdHF14AMfUSim, IfPm3Iso14443a, "Simulate Ultralight from emulator memory"},
{"gen", CmdHF14AMfUGenDiverseKeys, AlwaysAvailable, "Generate 3des mifare diversified keys"}, {"gen", CmdHF14AMfUGenDiverseKeys, AlwaysAvailable, "Generate 3des mifare diversified keys"},
{"pwdgen", CmdHF14AMfUPwdGen, AlwaysAvailable, "Generate pwd from known algos"}, {"pwdgen", CmdHF14AMfUPwdGen, AlwaysAvailable, "Generate pwd from known algos"},
{NULL, NULL, NULL, NULL} {NULL, NULL, NULL, NULL}

10
client/cmdhftopaz.c
View file

@ -505,11 +505,11 @@ static int CmdHelp(const char *Cmd);
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, AlwaysAvailable, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"reader", CmdHFTopazReader, IfPm3Present, "Act like a Topaz reader"}, {"reader", CmdHFTopazReader, IfPm3Iso14443a, "Act like a Topaz reader"},
{"sim", CmdHFTopazSim, IfPm3Present, "<UID> -- Simulate Topaz tag"}, {"sim", CmdHFTopazSim, IfPm3Iso14443a, "<UID> -- Simulate Topaz tag"},
{"sniff", CmdHF14ASniff, IfPm3Present, "Sniff Topaz reader-tag communication"}, {"sniff", CmdHF14ASniff, IfPm3Iso14443a, "Sniff Topaz reader-tag communication"},
{"raw", CmdHFTopazCmdRaw, IfPm3Present, "Send raw hex data to tag"}, {"raw", CmdHFTopazCmdRaw, IfPm3Iso14443a, "Send raw hex data to tag"},
{"list", CmdHFTopazList, IfPm3Present, "List Topaz history"}, {"list", CmdHFTopazList, IfPm3Iso14443a, "List Topaz history"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };

6
client/cmdparser.c
View file

@ -87,6 +87,12 @@ bool IfPm3Iso14443b(void) {
return pm3_capabilities.compiled_with_iso14443b; return pm3_capabilities.compiled_with_iso14443b;
} }
bool IfPm3Iso14443(void) {
if (!IfPm3Present())
return false;
return pm3_capabilities.compiled_with_iso14443a || pm3_capabilities.compiled_with_iso14443b;
}
bool IfPm3Iso15693(void) { bool IfPm3Iso15693(void) {
if (!IfPm3Present()) if (!IfPm3Present())
return false; return false;

1
client/cmdparser.h
View file

@ -31,6 +31,7 @@ bool IfPm3Hitag(void);
bool IfPm3Hfsniff(void); bool IfPm3Hfsniff(void);
bool IfPm3Iso14443a(void); bool IfPm3Iso14443a(void);
bool IfPm3Iso14443b(void); bool IfPm3Iso14443b(void);
bool IfPm3Iso14443(void);
bool IfPm3Iso15693(void); bool IfPm3Iso15693(void);
bool IfPm3Felica(void); bool IfPm3Felica(void);
bool IfPm3Legicrf(void); bool IfPm3Legicrf(void);