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

begin of dynamic capabilities handling in client

Browse source
This commit is contained in:
Philippe Teuwen 2019-05-01 20:48:15 +02:00
commit ca43afa19b
55 changed files with 554 additions and 536 deletions
Download patch file Download diff file Expand all files Collapse all files

20
client/cmdanalyse.c
View file

@ -903,16 +903,16 @@ static int CmdAnalyseNuid(const char *Cmd) {
return 0; return 0;
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"lcr", CmdAnalyseLCR, 1, "Generate final byte for XOR LRC"}, {"lcr", CmdAnalyseLCR, AlwaysAvailable, "Generate final byte for XOR LRC"},
{"crc", CmdAnalyseCRC, 1, "Stub method for CRC evaluations"}, {"crc", CmdAnalyseCRC, AlwaysAvailable, "Stub method for CRC evaluations"},
{"chksum", CmdAnalyseCHKSUM, 1, "Checksum with adding, masking and one's complement"}, {"chksum", CmdAnalyseCHKSUM, AlwaysAvailable, "Checksum with adding, masking and one's complement"},
{"dates", CmdAnalyseDates, 1, "Look for datestamps in a given array of bytes"}, {"dates", CmdAnalyseDates, AlwaysAvailable, "Look for datestamps in a given array of bytes"},
{"tea", CmdAnalyseTEASelfTest, 1, "Crypto TEA test"}, {"tea", CmdAnalyseTEASelfTest, AlwaysAvailable, "Crypto TEA test"},
{"lfsr", CmdAnalyseLfsr, 1, "LFSR tests"}, {"lfsr", CmdAnalyseLfsr, AlwaysAvailable, "LFSR tests"},
{"a", CmdAnalyseA, 1, "num bits test"}, {"a", CmdAnalyseA, AlwaysAvailable, "num bits test"},
{"nuid", CmdAnalyseNuid, 1, "create NUID from 7byte UID"}, {"nuid", CmdAnalyseNuid, AlwaysAvailable, "create NUID from 7byte UID"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

74
client/cmddata.c
View file

@ -2097,44 +2097,44 @@ static int CmdDataIIR(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"askedgedetect", CmdAskEdgeDetect, 1, "[threshold] Adjust Graph for manual ASK demod using the length of sample differences to detect the edge of a wave (use 20-45, def:25)"}, {"askedgedetect", CmdAskEdgeDetect, AlwaysAvailable, "[threshold] Adjust Graph for manual ASK demod using the length of sample differences to detect the edge of a wave (use 20-45, def:25)"},
{"autocorr", CmdAutoCorr, 1, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"}, {"autocorr", CmdAutoCorr, AlwaysAvailable, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"},
{"biphaserawdecode", CmdBiphaseDecodeRaw, 1, "[offset] [invert<0|1>] [maxErr] -- Biphase decode bin stream in DemodBuffer (offset = 0|1 bits to shift the decode start)"}, {"biphaserawdecode", CmdBiphaseDecodeRaw, AlwaysAvailable, "[offset] [invert<0|1>] [maxErr] -- Biphase decode bin stream in DemodBuffer (offset = 0|1 bits to shift the decode start)"},
{"bin2hex", Cmdbin2hex, 1, "<digits> -- Converts binary to hexadecimal"}, {"bin2hex", Cmdbin2hex, AlwaysAvailable, "<digits> -- Converts binary to hexadecimal"},
{"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, {"bitsamples", CmdBitsamples, IfPm3Present, "Get raw samples as bitstring"},
{"buffclear", CmdBuffClear, 1, "Clears bigbuff on deviceside and graph window"}, {"buffclear", CmdBuffClear, AlwaysAvailable, "Clears bigbuff on deviceside and graph window"},
{"dec", CmdDec, 1, "Decimate samples"}, {"dec", CmdDec, AlwaysAvailable, "Decimate samples"},
{"detectclock", CmdDetectClockRate, 1, "[<a|f|n|p>] Detect ASK, FSK, NRZ, PSK clock rate of wave in GraphBuffer"}, {"detectclock", CmdDetectClockRate, AlwaysAvailable, "[<a|f|n|p>] Detect ASK, FSK, NRZ, PSK clock rate of wave in GraphBuffer"},
{"fsktonrz", CmdFSKToNRZ, 1, "Convert fsk2 to nrz wave for alternate fsk demodulating (for weak fsk)"}, {"fsktonrz", CmdFSKToNRZ, AlwaysAvailable, "Convert fsk2 to nrz wave for alternate fsk demodulating (for weak fsk)"},
{"getbitstream", CmdGetBitStream, 1, "Convert GraphBuffer's >=1 values to 1 and <1 to 0"}, {"getbitstream", CmdGetBitStream, AlwaysAvailable, "Convert GraphBuffer's >=1 values to 1 and <1 to 0"},
{"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"}, {"grid", CmdGrid, AlwaysAvailable, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
{"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"}, {"hexsamples", CmdHexsamples, IfPm3Present, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
{"hex2bin", Cmdhex2bin, 1, "<hexadecimal> -- Converts hexadecimal to binary"}, {"hex2bin", Cmdhex2bin, AlwaysAvailable, "<hexadecimal> -- Converts hexadecimal to binary"},
{"hide", CmdHide, 1, "Hide graph window"}, {"hide", CmdHide, AlwaysAvailable, "Hide graph window"},
{"hpf", CmdHpf, 1, "Remove DC offset from trace"}, {"hpf", CmdHpf, AlwaysAvailable, "Remove DC offset from trace"},
{"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"}, {"load", CmdLoad, AlwaysAvailable, "<filename> -- Load trace (to graph window"},
{"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"}, {"ltrim", CmdLtrim, AlwaysAvailable, "<samples> -- Trim samples from left of trace"},
{"rtrim", CmdRtrim, 1, "<location to end trace> -- Trim samples from right of trace"}, {"rtrim", CmdRtrim, AlwaysAvailable, "<location to end trace> -- Trim samples from right of trace"},
{"mtrim", CmdMtrim, 1, "<start> <stop> -- Trim out samples from the specified start to the specified stop"}, {"mtrim", CmdMtrim, AlwaysAvailable, "<start> <stop> -- Trim out samples from the specified start to the specified stop"},
{"manrawdecode", Cmdmandecoderaw, 1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"}, {"manrawdecode", Cmdmandecoderaw, AlwaysAvailable, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"},
{"norm", CmdNorm, 1, "Normalize max/min to +/-128"}, {"norm", CmdNorm, AlwaysAvailable, "Normalize max/min to +/-128"},
{"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, {"plot", CmdPlot, AlwaysAvailable, "Show graph window (hit 'h' in window for keystroke help)"},
{"printdemodbuffer", CmdPrintDemodBuff, 1, "[x] [o] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"}, {"printdemodbuffer", CmdPrintDemodBuff, AlwaysAvailable, "[x] [o] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"},
{"rawdemod", CmdRawDemod, 1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"}, {"rawdemod", CmdRawDemod, AlwaysAvailable, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},
{"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"}, {"samples", CmdSamples, IfPm3Present, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
{"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"}, {"save", CmdSave, AlwaysAvailable, "<filename> -- Save trace (from graph window)"},
{"setgraphmarkers", CmdSetGraphMarkers, 1, "[orange_marker] [blue_marker] (in graph window)"}, {"setgraphmarkers", CmdSetGraphMarkers, AlwaysAvailable, "[orange_marker] [blue_marker] (in graph window)"},
{"scale", CmdScale, 1, "<int> -- Set cursor display scale"}, {"scale", CmdScale, AlwaysAvailable, "<int> -- Set cursor display scale"},
{"setdebugmode", CmdSetDebugMode, 1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"}, {"setdebugmode", CmdSetDebugMode, AlwaysAvailable, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
{"shiftgraphzero", CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"}, {"shiftgraphzero", CmdGraphShiftZero, AlwaysAvailable, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, {"dirthreshold", CmdDirectionalThreshold, AlwaysAvailable, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"}, {"tune", CmdTuneSamples, IfPm3Present, "Get hw tune samples for graph window"},
{"undec", CmdUndec, 1, "Un-decimate samples by 2"}, {"undec", CmdUndec, AlwaysAvailable, "Un-decimate samples by 2"},
{"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"}, {"zerocrossings", CmdZerocrossings, AlwaysAvailable, "Count time between zero-crossings"},
{"iir", CmdDataIIR, 0, "apply IIR buttersworth filter on plotdata"}, {"iir", CmdDataIIR, IfPm3Present, "apply IIR buttersworth filter on plotdata"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

16
client/cmdflashmem.c
View file

@ -617,14 +617,14 @@ static int CmdFlashMemInfo(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"spibaud", CmdFlashmemSpiBaudrate, 1, "Set Flash memory Spi baudrate [rdv40]"}, {"spibaud", CmdFlashmemSpiBaudrate, AlwaysAvailable, "Set Flash memory Spi baudrate [rdv40]"},
{"read", CmdFlashMemRead, 1, "Read Flash memory [rdv40]"}, {"read", CmdFlashMemRead, AlwaysAvailable, "Read Flash memory [rdv40]"},
{"info", CmdFlashMemInfo, 1, "Flash memory information [rdv40]"}, {"info", CmdFlashMemInfo, AlwaysAvailable, "Flash memory information [rdv40]"},
{"load", CmdFlashMemLoad, 1, "Load data into flash memory [rdv40]"}, {"load", CmdFlashMemLoad, AlwaysAvailable, "Load data into flash memory [rdv40]"},
{"save", CmdFlashMemSave, 1, "Save data from flash memory [rdv40]"}, {"save", CmdFlashMemSave, AlwaysAvailable, "Save data from flash memory [rdv40]"},
{"wipe", CmdFlashMemWipe, 1, "Wipe data from flash memory [rdv40]"}, {"wipe", CmdFlashMemWipe, AlwaysAvailable, "Wipe data from flash memory [rdv40]"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

38
client/cmdhf.c
View file

@ -102,25 +102,25 @@ int CmdHFSniff(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"14a", CmdHF14A, 1, "{ ISO14443A RFIDs... }"}, {"14a", CmdHF14A, AlwaysAvailable, "{ ISO14443A RFIDs... }"},
{"14b", CmdHF14B, 1, "{ ISO14443B RFIDs... }"}, {"14b", CmdHF14B, AlwaysAvailable, "{ ISO14443B RFIDs... }"},
{"15", CmdHF15, 1, "{ ISO15693 RFIDs... }"}, {"15", CmdHF15, AlwaysAvailable, "{ ISO15693 RFIDs... }"},
{"epa", CmdHFEPA, 1, "{ German Identification Card... }"}, {"epa", CmdHFEPA, AlwaysAvailable, "{ German Identification Card... }"},
{"felica", CmdHFFelica, 1, "{ ISO18092 / Felica RFIDs... }"}, {"felica", CmdHFFelica, AlwaysAvailable, "{ ISO18092 / Felica RFIDs... }"},
{"legic", CmdHFLegic, 1, "{ LEGIC RFIDs... }"}, {"legic", CmdHFLegic, AlwaysAvailable, "{ LEGIC RFIDs... }"},
{"iclass", CmdHFiClass, 1, "{ ICLASS RFIDs... }"}, {"iclass", CmdHFiClass, AlwaysAvailable, "{ ICLASS RFIDs... }"},
{"mf", CmdHFMF, 1, "{ MIFARE RFIDs... }"}, {"mf", CmdHFMF, AlwaysAvailable, "{ MIFARE RFIDs... }"},
{"mfp", CmdHFMFP, 1, "{ MIFARE Plus RFIDs... }"}, {"mfp", CmdHFMFP, AlwaysAvailable, "{ MIFARE Plus RFIDs... }"},
{"mfu", CmdHFMFUltra, 1, "{ MIFARE Ultralight RFIDs... }"}, {"mfu", CmdHFMFUltra, AlwaysAvailable, "{ MIFARE Ultralight RFIDs... }"},
{"mfdes", CmdHFMFDes, 1, "{ MIFARE Desfire RFIDs... }"}, {"mfdes", CmdHFMFDes, AlwaysAvailable, "{ MIFARE Desfire RFIDs... }"},
{"topaz", CmdHFTopaz, 1, "{ TOPAZ (NFC Type 1) RFIDs... }"}, {"topaz", CmdHFTopaz, AlwaysAvailable, "{ TOPAZ (NFC Type 1) RFIDs... }"},
{"fido", CmdHFFido, 1, "{ FIDO and FIDO2 authenticators... }"}, {"fido", CmdHFFido, AlwaysAvailable, "{ FIDO and FIDO2 authenticators... }"},
{"list", CmdTraceList, 0, "List protocol data in trace buffer"}, {"list", CmdTraceList, IfPm3Present, "List protocol data in trace buffer"},
{"tune", CmdHFTune, 0, "Continuously measure HF antenna tuning"}, {"tune", CmdHFTune, IfPm3Present, "Continuously measure HF antenna tuning"},
{"search", CmdHFSearch, 1, "Search for known HF tags [preliminary]"}, {"search", CmdHFSearch, AlwaysAvailable, "Search for known HF tags [preliminary]"},
{"sniff", CmdHFSniff, 0, "<samples to skip (10000)> <triggers to skip (1)> Generic HF Sniff"}, {"sniff", CmdHFSniff, IfPm3Hfsniff, "<samples to skip (10000)> <triggers to skip (1)> Generic HF Sniff"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
int CmdHF(const char *Cmd) { int CmdHF(const char *Cmd) {

24
client/cmdhf14a.c
View file

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

22
client/cmdhf14b.c
View file

@ -1074,18 +1074,18 @@ static int srix4kValid(const char *Cmd) {
} }
*/ */
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"dump", CmdHF14BDump, 0, "Read all memory pages of an ISO14443-B tag, save to file"}, {"dump", CmdHF14BDump, IfPm3Present, "Read all memory pages of an ISO14443-B tag, save to file"},
{"info", CmdHF14Binfo, 0, "Tag information"}, {"info", CmdHF14Binfo, IfPm3Present, "Tag information"},
{"list", CmdHF14BList, 0, "List ISO 14443B history"}, {"list", CmdHF14BList, IfPm3Present, "List ISO 14443B history"},
{"raw", CmdHF14BCmdRaw, 0, "Send raw hex data to tag"}, {"raw", CmdHF14BCmdRaw, IfPm3Present, "Send raw hex data to tag"},
{"reader", CmdHF14BReader, 0, "Act as a 14443B reader to identify a tag"}, {"reader", CmdHF14BReader, IfPm3Present, "Act as a 14443B reader to identify a tag"},
{"sim", CmdHF14BSim, 0, "Fake ISO 14443B tag"}, {"sim", CmdHF14BSim, IfPm3Present, "Fake ISO 14443B tag"},
{"sniff", CmdHF14BSniff, 0, "Eavesdrop ISO 14443B"}, {"sniff", CmdHF14BSniff, IfPm3Present, "Eavesdrop ISO 14443B"},
{"sriread", CmdHF14BReadSri, 0, "Read contents of a SRI512 | SRIX4K tag"}, {"sriread", CmdHF14BReadSri, IfPm3Present, "Read contents of a SRI512 | SRIX4K tag"},
{"sriwrite", CmdHF14BWriteSri, 0, "Write data to a SRI512 | SRIX4K tag"}, {"sriwrite", CmdHF14BWriteSri, IfPm3Present, "Write data to a SRI512 | SRIX4K tag"},
//{"valid", srix4kValid, 1, "srix4k checksum test"}, //{"valid", srix4kValid, 1, "srix4k checksum test"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

32
client/cmdhf15.c
View file

@ -1274,22 +1274,22 @@ static int CmdHF15Restore(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHF15Help, 1, "This help"}, {"help", CmdHF15Help, AlwaysAvailable, "This help"},
{"demod", CmdHF15Demod, 1, "Demodulate ISO15693 from tag"}, {"demod", CmdHF15Demod, AlwaysAvailable, "Demodulate ISO15693 from tag"},
{"dump", CmdHF15Dump, 0, "Read all memory pages of an ISO15693 tag, save to file"}, {"dump", CmdHF15Dump, IfPm3Present, "Read all memory pages of an ISO15693 tag, save to file"},
{"findafi", CmdHF15Afi, 0, "Brute force AFI of an ISO15693 tag"}, {"findafi", CmdHF15Afi, IfPm3Present, "Brute force AFI of an ISO15693 tag"},
{"info", CmdHF15Info, 0, "Tag information"}, {"info", CmdHF15Info, IfPm3Present, "Tag information"},
{"list", CmdHF15List, 0, "List ISO15693 history"}, {"list", CmdHF15List, IfPm3Present, "List ISO15693 history"},
{"raw", CmdHF15Raw, 0, "Send raw hex data to tag"}, {"raw", CmdHF15Raw, IfPm3Present, "Send raw hex data to tag"},
{"reader", CmdHF15Reader, 0, "Act like an ISO15693 reader"}, {"reader", CmdHF15Reader, IfPm3Present, "Act like an ISO15693 reader"},
{"record", CmdHF15Record, 0, "Record Samples (ISO15693)"}, {"record", CmdHF15Record, IfPm3Present, "Record Samples (ISO15693)"},
{"restore", CmdHF15Restore, 0, "Restore from file to all memory pages of an ISO15693 tag"}, {"restore", CmdHF15Restore, IfPm3Present, "Restore from file to all memory pages of an ISO15693 tag"},
{"sim", CmdHF15Sim, 0, "Fake an ISO15693 tag"}, {"sim", CmdHF15Sim, IfPm3Present, "Fake an ISO15693 tag"},
{"samples", CmdHF15Samples, 0, "Acquire Samples as Reader (enables carrier, sends inquiry)"}, {"samples", CmdHF15Samples, IfPm3Present, "Acquire Samples as Reader (enables carrier, sends inquiry)"},
{"read", CmdHF15Read, 0, "Read a block"}, {"read", CmdHF15Read, IfPm3Present, "Read a block"},
{"write", CmdHF15Write, 0, "Write a block"}, {"write", CmdHF15Write, IfPm3Present, "Write a block"},
{"readmulti", CmdHF15Readmulti, 0, "Reads multiple Blocks"}, {"readmulti", CmdHF15Readmulti, IfPm3Present, "Reads multiple Blocks"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHF15Help(const char *Cmd) { static int CmdHF15Help(const char *Cmd) {

8
client/cmdhfepa.c
View file

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

18
client/cmdhffelica.c
View file

@ -534,16 +534,16 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdHFFelicaList, 0, "List ISO 18092/FeliCa history"}, {"list", CmdHFFelicaList, IfPm3Present, "List ISO 18092/FeliCa history"},
{"reader", CmdHFFelicaReader, 0, "Act like an ISO18092/FeliCa reader"}, {"reader", CmdHFFelicaReader, IfPm3Present, "Act like an ISO18092/FeliCa reader"},
{"sim", CmdHFFelicaSim, 0, "<UID> -- Simulate ISO 18092/FeliCa tag"}, {"sim", CmdHFFelicaSim, IfPm3Present, "<UID> -- Simulate ISO 18092/FeliCa tag"},
{"sniff", CmdHFFelicaSniff, 0, "sniff ISO 18092/Felica traffic"}, {"sniff", CmdHFFelicaSniff, IfPm3Present, "sniff ISO 18092/Felica traffic"},
{"raw", CmdHFFelicaCmdRaw, 0, "Send raw hex data to tag"}, {"raw", CmdHFFelicaCmdRaw, IfPm3Present, "Send raw hex data to tag"},
{"litesim", CmdHFFelicaSimLite, 0, "<NDEF2> - only reply to poll request"}, {"litesim", CmdHFFelicaSimLite, IfPm3Present, "<NDEF2> - only reply to poll request"},
{"litedump", CmdHFFelicaDumpLite, 0, "Wait for and try dumping FelicaLite"}, {"litedump", CmdHFFelicaDumpLite, IfPm3Present, "Wait for and try dumping FelicaLite"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdhffido.c
View file

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

42
client/cmdhficlass.c
View file

@ -2418,27 +2418,27 @@ static int CmdHFiClassPermuteKey(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"calcnewkey", CmdHFiClassCalcNewKey, 1, "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"}, {"calcnewkey", CmdHFiClassCalcNewKey, AlwaysAvailable, "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"},
{"chk", CmdHFiClassCheckKeys, 1, " Check keys"}, {"chk", CmdHFiClassCheckKeys, AlwaysAvailable, " Check keys"},
{"clone", CmdHFiClassCloneTag, 0, "[options..] Authenticate and Clone from iClass bin file"}, {"clone", CmdHFiClassCloneTag, IfPm3Present, "[options..] Authenticate and Clone from iClass bin file"},
{"decrypt", CmdHFiClassDecrypt, 1, "[f <fname>] Decrypt tagdump" }, {"decrypt", CmdHFiClassDecrypt, AlwaysAvailable, "[f <fname>] Decrypt tagdump" },
{"dump", CmdHFiClassReader_Dump, 0, "[options..] Authenticate and Dump iClass tag's AA1"}, {"dump", CmdHFiClassReader_Dump, IfPm3Present, "[options..] Authenticate and Dump iClass tag's AA1"},
{"eload", CmdHFiClassELoad, 0, "[f <fname>] (experimental) Load data into iClass emulator memory"}, {"eload", CmdHFiClassELoad, IfPm3Present, "[f <fname>] (experimental) Load data into iClass emulator memory"},
{"encryptblk", CmdHFiClassEncryptBlk, 1, "<BlockData> Encrypt given block data"}, {"encryptblk", CmdHFiClassEncryptBlk, AlwaysAvailable, "<BlockData> Encrypt given block data"},
{"list", CmdHFiClassList, 0, " List iClass history"}, {"list", CmdHFiClassList, IfPm3Present, " List iClass history"},
{"loclass", CmdHFiClass_loclass, 1, "[options..] Use loclass to perform bruteforce of reader attack dump"}, {"loclass", CmdHFiClass_loclass, AlwaysAvailable, "[options..] Use loclass to perform bruteforce of reader attack dump"},
{"lookup", CmdHFiClassLookUp, 1, "[options..] Uses authentication trace to check for key in dictionary file"}, {"lookup", CmdHFiClassLookUp, AlwaysAvailable, "[options..] Uses authentication trace to check for key in dictionary file"},
{"managekeys", CmdHFiClassManageKeys, 1, "[options..] Manage the keys to use with iClass"}, {"managekeys", CmdHFiClassManageKeys, AlwaysAvailable, "[options..] Manage the keys to use with iClass"},
{"permutekey", CmdHFiClassPermuteKey, 0, " Permute function from 'heart of darkness' paper"}, {"permutekey", CmdHFiClassPermuteKey, IfPm3Present, " Permute function from 'heart of darkness' paper"},
{"readblk", CmdHFiClass_ReadBlock, 0, "[options..] Authenticate and Read iClass block"}, {"readblk", CmdHFiClass_ReadBlock, IfPm3Present, "[options..] Authenticate and Read iClass block"},
{"reader", CmdHFiClassReader, 0, " Act like an iClass reader"}, {"reader", CmdHFiClassReader, IfPm3Present, " Act like an iClass reader"},
{"readtagfile", CmdHFiClassReadTagFile, 1, "[options..] Display Content from tagfile"}, {"readtagfile", CmdHFiClassReadTagFile, AlwaysAvailable, "[options..] Display Content from tagfile"},
{"replay", CmdHFiClassReader_Replay, 0, "<mac> Read an iClass tag via Replay Attack"}, {"replay", CmdHFiClassReader_Replay, IfPm3Present, "<mac> Read an iClass tag via Replay Attack"},
{"sim", CmdHFiClassSim, 0, "[options..] Simulate iClass tag"}, {"sim", CmdHFiClassSim, IfPm3Present, "[options..] Simulate iClass tag"},
{"sniff", CmdHFiClassSniff, 0, " Eavesdrop iClass communication"}, {"sniff", CmdHFiClassSniff, IfPm3Present, " Eavesdrop iClass communication"},
{"writeblk", CmdHFiClass_WriteBlock, 0, "[options..] Authenticate and Write iClass block"}, {"writeblk", CmdHFiClass_WriteBlock, IfPm3Present, "[options..] Authenticate and Write iClass block"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

28
client/cmdhflegic.c
View file

@ -1270,20 +1270,20 @@ static int CmdLegicList(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"reader", CmdLegicReader, 1, "LEGIC Prime Reader UID and tag info"}, {"reader", CmdLegicReader, AlwaysAvailable, "LEGIC Prime Reader UID and tag info"},
{"info", CmdLegicInfo, 0, "Display deobfuscated and decoded LEGIC Prime tag data"}, {"info", CmdLegicInfo, IfPm3Present, "Display deobfuscated and decoded LEGIC Prime tag data"},
{"dump", CmdLegicDump, 0, "Dump LEGIC Prime tag to binary file"}, {"dump", CmdLegicDump, IfPm3Present, "Dump LEGIC Prime tag to binary file"},
{"restore", CmdLegicRestore, 0, "Restore a dump file onto a LEGIC Prime tag"}, {"restore", CmdLegicRestore, IfPm3Present, "Restore a dump file onto a LEGIC Prime tag"},
{"rdmem", CmdLegicRdmem, 0, "Read bytes from a LEGIC Prime tag"}, {"rdmem", CmdLegicRdmem, IfPm3Present, "Read bytes from a LEGIC Prime tag"},
{"sim", CmdLegicRfSim, 0, "Start tag simulator"}, {"sim", CmdLegicRfSim, IfPm3Present, "Start tag simulator"},
{"write", CmdLegicRfWrite, 0, "Write data to a LEGIC Prime tag"}, {"write", CmdLegicRfWrite, IfPm3Present, "Write data to a LEGIC Prime tag"},
{"crc", CmdLegicCalcCrc, 1, "Calculate Legic CRC over given bytes"}, {"crc", CmdLegicCalcCrc, AlwaysAvailable, "Calculate Legic CRC over given bytes"},
{"eload", CmdLegicELoad, 1, "Load binary dump to emulator memory"}, {"eload", CmdLegicELoad, AlwaysAvailable, "Load binary dump to emulator memory"},
{"esave", CmdLegicESave, 1, "Save emulator memory to binary file"}, {"esave", CmdLegicESave, AlwaysAvailable, "Save emulator memory to binary file"},
{"list", CmdLegicList, 1, "List LEGIC history"}, {"list", CmdLegicList, AlwaysAvailable, "List LEGIC history"},
{"wipe", CmdLegicWipe, 1, "Wipe a LEGIC Prime tag"}, {"wipe", CmdLegicWipe, AlwaysAvailable, "Wipe a LEGIC Prime tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

80
client/cmdhfmf.c
View file

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

10
client/cmdhfmfdes.c
View file

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

10
client/cmdhfmfdesfire.c
View file

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

22
client/cmdhfmfp.c
View file

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

30
client/cmdhfmfu.c
View file

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

12
client/cmdhftopaz.c
View file

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

30
client/cmdhw.c
View file

@ -462,23 +462,23 @@ static int CmdPingNG(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"detectreader", CmdDetectReader, 0, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"}, {"detectreader", CmdDetectReader, IfPm3Present, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"},
{"fpgaoff", CmdFPGAOff, 0, "Set FPGA off"}, {"fpgaoff", CmdFPGAOff, IfPm3Present, "Set FPGA off"},
#ifdef WITH_LCD #ifdef WITH_LCD
{"lcd", CmdLCD, 0, "<HEX command> <count> -- Send command/data to LCD"}, {"lcd", CmdLCD, IfPm3Present, "<HEX command> <count> -- Send command/data to LCD"},
{"lcdreset", CmdLCDReset, 0, "Hardware reset LCD"}, {"lcdreset", CmdLCDReset, IfPm3Present, "Hardware reset LCD"},
#endif #endif
{"readmem", CmdReadmem, 0, "[address] -- Read memory at decimal address from flash"}, {"readmem", CmdReadmem, IfPm3Present, "[address] -- Read memory at decimal address from flash"},
{"reset", CmdReset, 0, "Reset the Proxmark3"}, {"reset", CmdReset, IfPm3Present, "Reset the Proxmark3"},
{"setlfdivisor", CmdSetDivisor, 0, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"}, {"setlfdivisor", CmdSetDivisor, IfPm3Present, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"},
{"setmux", CmdSetMux, 0, "<loraw|hiraw|lopkd|hipkd> -- Set the ADC mux to a specific value"}, {"setmux", CmdSetMux, IfPm3Present, "<loraw|hiraw|lopkd|hipkd> -- Set the ADC mux to a specific value"},
{"tune", CmdTune, 0, "Measure antenna tuning"}, {"tune", CmdTune, IfPm3Present, "Measure antenna tuning"},
{"version", CmdVersion, 0, "Show version information about the connected Proxmark3"}, {"version", CmdVersion, IfPm3Present, "Show version information about the connected Proxmark3"},
{"status", CmdStatus, 0, "Show runtime status information about the connected Proxmark3"}, {"status", CmdStatus, IfPm3Present, "Show runtime status information about the connected Proxmark3"},
{"ping", CmdPing, 0, "Test if the Proxmark3 is responding"}, {"ping", CmdPing, IfPm3Present, "Test if the Proxmark3 is responding"},
{"pingng", CmdPingNG, 0, "Test if the Proxmark3 is responsive, using new frame format (experimental)"}, {"pingng", CmdPingNG, IfPm3Present, "Test if the Proxmark3 is responsive, using new frame format (experimental)"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

76
client/cmdlf.c
View file

@ -949,46 +949,46 @@ out:
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"awid", CmdLFAWID, 1, "{ AWID RFIDs... }"}, {"awid", CmdLFAWID, AlwaysAvailable, "{ AWID RFIDs... }"},
{"cotag", CmdLFCOTAG, 1, "{ COTAG CHIPs... }"}, {"cotag", CmdLFCOTAG, AlwaysAvailable, "{ COTAG CHIPs... }"},
{"em", CmdLFEM4X, 1, "{ EM4X CHIPs & RFIDs... }"}, {"em", CmdLFEM4X, AlwaysAvailable, "{ EM4X CHIPs & RFIDs... }"},
{"fdx", CmdLFFdx, 1, "{ FDX-B RFIDs... }"}, {"fdx", CmdLFFdx, AlwaysAvailable, "{ FDX-B RFIDs... }"},
{"gproxii", CmdLFGuard, 1, "{ Guardall Prox II RFIDs... }"}, {"gproxii", CmdLFGuard, AlwaysAvailable, "{ Guardall Prox II RFIDs... }"},
{"hid", CmdLFHID, 1, "{ HID RFIDs... }"}, {"hid", CmdLFHID, AlwaysAvailable, "{ HID RFIDs... }"},
#ifdef WITH_HITAG #ifdef WITH_HITAG
{"hitag", CmdLFHitag, 1, "{ Hitag CHIPs... }"}, {"hitag", CmdLFHitag, AlwaysAvailable, "{ Hitag CHIPs... }"},
#endif #endif
{"indala", CmdLFINDALA, 1, "{ Indala RFIDs... }"}, {"indala", CmdLFINDALA, AlwaysAvailable, "{ Indala RFIDs... }"},
{"io", CmdLFIO, 1, "{ ioProx RFIDs... }"}, {"io", CmdLFIO, AlwaysAvailable, "{ ioProx RFIDs... }"},
{"jablotron", CmdLFJablotron, 1, "{ Jablotron RFIDs... }"}, {"jablotron", CmdLFJablotron, AlwaysAvailable, "{ Jablotron RFIDs... }"},
{"keri", CmdLFKeri, 1, "{ KERI RFIDs... }"}, {"keri", CmdLFKeri, AlwaysAvailable, "{ KERI RFIDs... }"},
{"nedap", CmdLFNedap, 1, "{ Nedap RFIDs... }"}, {"nedap", CmdLFNedap, AlwaysAvailable, "{ Nedap RFIDs... }"},
{"nexwatch", CmdLFNEXWATCH, 1, "{ NexWatch RFIDs... }"}, {"nexwatch", CmdLFNEXWATCH, AlwaysAvailable, "{ NexWatch RFIDs... }"},
{"noralsy", CmdLFNoralsy, 1, "{ Noralsy RFIDs... }"}, {"noralsy", CmdLFNoralsy, AlwaysAvailable, "{ Noralsy RFIDs... }"},
{"pac", CmdLFPac, 1, "{ PAC/Stanley RFIDs... }"}, {"pac", CmdLFPac, AlwaysAvailable, "{ PAC/Stanley RFIDs... }"},
{"paradox", CmdLFParadox, 1, "{ Paradox RFIDs... }"}, {"paradox", CmdLFParadox, AlwaysAvailable, "{ Paradox RFIDs... }"},
{"pcf7931", CmdLFPCF7931, 1, "{ PCF7931 CHIPs... }"}, {"pcf7931", CmdLFPCF7931, AlwaysAvailable, "{ PCF7931 CHIPs... }"},
{"presco", CmdLFPresco, 1, "{ Presco RFIDs... }"}, {"presco", CmdLFPresco, AlwaysAvailable, "{ Presco RFIDs... }"},
{"pyramid", CmdLFPyramid, 1, "{ Farpointe/Pyramid RFIDs... }"}, {"pyramid", CmdLFPyramid, AlwaysAvailable, "{ Farpointe/Pyramid RFIDs... }"},
{"securakey", CmdLFSecurakey, 1, "{ Securakey RFIDs... }"}, {"securakey", CmdLFSecurakey, AlwaysAvailable, "{ Securakey RFIDs... }"},
{"ti", CmdLFTI, 1, "{ TI CHIPs... }"}, {"ti", CmdLFTI, AlwaysAvailable, "{ TI CHIPs... }"},
{"t55xx", CmdLFT55XX, 1, "{ T55xx CHIPs... }"}, {"t55xx", CmdLFT55XX, AlwaysAvailable, "{ T55xx CHIPs... }"},
{"viking", CmdLFViking, 1, "{ Viking RFIDs... }"}, {"viking", CmdLFViking, AlwaysAvailable, "{ Viking RFIDs... }"},
{"visa2000", CmdLFVisa2k, 1, "{ Visa2000 RFIDs... }"}, {"visa2000", CmdLFVisa2k, AlwaysAvailable, "{ Visa2000 RFIDs... }"},
{"config", CmdLFSetConfig, 0, "Set config for LF sampling, bit/sample, decimation, frequency"}, {"config", CmdLFSetConfig, IfPm3Present, "Set config for LF sampling, bit/sample, decimation, frequency"},
{"cmdread", CmdLFCommandRead, 0, "<off period> <'0' period> <'1' period> <command> ['h' 134] \n\t\t-- Modulate LF reader field to send command before read (all periods in microseconds)"}, {"cmdread", CmdLFCommandRead, IfPm3Present, "<off period> <'0' period> <'1' period> <command> ['h' 134] \n\t\t-- Modulate LF reader field to send command before read (all periods in microseconds)"},
{"flexdemod", CmdFlexdemod, 1, "Demodulate samples for FlexPass"}, {"flexdemod", CmdFlexdemod, AlwaysAvailable, "Demodulate samples for FlexPass"},
{"read", CmdLFRead, 0, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"}, {"read", CmdLFRead, IfPm3Present, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"},
{"search", CmdLFfind, 1, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) \n\t\t-- 'u' to search for unknown tags"}, {"search", CmdLFfind, AlwaysAvailable, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) \n\t\t-- 'u' to search for unknown tags"},
{"sim", CmdLFSim, 0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"}, {"sim", CmdLFSim, IfPm3Present, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"},
{"simask", CmdLFaskSim, 0, "[clock] [invert <1|0>] [biphase/manchester/raw <'b'|'m'|'r'>] [msg separator 's'] [d <hexdata>] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"}, {"simask", CmdLFaskSim, IfPm3Present, "[clock] [invert <1|0>] [biphase/manchester/raw <'b'|'m'|'r'>] [msg separator 's'] [d <hexdata>] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"},
{"simfsk", CmdLFfskSim, 0, "[c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"}, {"simfsk", CmdLFfskSim, IfPm3Present, "[c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"},
{"simpsk", CmdLFpskSim, 0, "[1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>] \n\t\t-- Simulate LF PSK tag from demodbuffer or input"}, {"simpsk", CmdLFpskSim, IfPm3Present, "[1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>] \n\t\t-- Simulate LF PSK tag from demodbuffer or input"},
{"simbidir", CmdLFSimBidir, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"}, {"simbidir", CmdLFSimBidir, IfPm3Present, "Simulate LF tag (with bidirectional data transmission between reader and tag)"},
{"sniff", CmdLFSniff, 0, "Sniff LF traffic between reader and tag"}, {"sniff", CmdLFSniff, IfPm3Present, "Sniff LF traffic between reader and tag"},
{"vchdemod", CmdVchDemod, 1, "['clone'] -- Demodulate samples for VeriChip"}, {"vchdemod", CmdVchDemod, AlwaysAvailable, "['clone'] -- Demodulate samples for VeriChip"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
int CmdLF(const char *Cmd) { int CmdLF(const char *Cmd) {

14
client/cmdlfawid.c
View file

@ -491,13 +491,13 @@ static int CmdAWIDBrute(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdAWIDDemod, 0, "demodulate an AWID FSK tag from the GraphBuffer"}, {"demod", CmdAWIDDemod, IfPm3Present, "demodulate an AWID FSK tag from the GraphBuffer"},
{"read", CmdAWIDRead, 0, "attempt to read and extract tag data"}, {"read", CmdAWIDRead, IfPm3Present, "attempt to read and extract tag data"},
{"clone", CmdAWIDClone, 0, "clone AWID to T55x7"}, {"clone", CmdAWIDClone, IfPm3Present, "clone AWID to T55x7"},
{"sim", CmdAWIDSim, 0, "simulate AWID tag"}, {"sim", CmdAWIDSim, IfPm3Present, "simulate AWID tag"},
{"brute", CmdAWIDBrute, 0, "Bruteforce card number against reader"}, {"brute", CmdAWIDBrute, IfPm3Present, "Bruteforce card number against reader"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

8
client/cmdlfcotag.c
View file

@ -103,10 +103,10 @@ static int CmdCOTAGRead(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdCOTAGDemod, 1, "Tries to decode a COTAG signal"}, {"demod", CmdCOTAGDemod, AlwaysAvailable, "Tries to decode a COTAG signal"},
{"read", CmdCOTAGRead, 0, "Attempt to read and extract tag data"}, {"read", CmdCOTAGRead, IfPm3Present, "Attempt to read and extract tag data"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

32
client/cmdlfem4x.c
View file

@ -1464,23 +1464,23 @@ static int CmdEM4x05Info(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
//{"410x_demod", CmdEMdemodASK, 0, "Extract ID from EM410x tag on antenna)"}, //{"410x_demod", CmdEMdemodASK, 0, "Extract ID from EM410x tag on antenna)"},
{"410x_demod", CmdEM410xDemod, 1, "demodulate a EM410x tag from the GraphBuffer"}, {"410x_demod", CmdEM410xDemod, AlwaysAvailable, "demodulate a EM410x tag from the GraphBuffer"},
{"410x_read", CmdEM410xRead, 0, "attempt to read and extract tag data"}, {"410x_read", CmdEM410xRead, IfPm3Present, "attempt to read and extract tag data"},
{"410x_sim", CmdEM410xSim, 0, "simulate EM410x tag"}, {"410x_sim", CmdEM410xSim, IfPm3Present, "simulate EM410x tag"},
{"410x_brute", CmdEM410xBrute, 0, "reader bruteforce attack by simulating EM410x tags"}, {"410x_brute", CmdEM410xBrute, IfPm3Present, "reader bruteforce attack by simulating EM410x tags"},
{"410x_watch", CmdEM410xWatch, 0, "watches for EM410x 125/134 kHz tags (option 'h' for 134)"}, {"410x_watch", CmdEM410xWatch, IfPm3Present, "watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
{"410x_spoof", CmdEM410xWatchnSpoof, 0, "watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" }, {"410x_spoof", CmdEM410xWatchnSpoof, IfPm3Present, "watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
{"410x_write", CmdEM410xWrite, 0, "write EM410x UID to T5555(Q5) or T55x7 tag"}, {"410x_write", CmdEM410xWrite, IfPm3Present, "write EM410x UID to T5555(Q5) or T55x7 tag"},
{"4x05_dump", CmdEM4x05Dump, 0, "dump EM4x05/EM4x69 tag"}, {"4x05_dump", CmdEM4x05Dump, IfPm3Present, "dump EM4x05/EM4x69 tag"},
{"4x05_info", CmdEM4x05Info, 0, "tag information EM4x05/EM4x69"}, {"4x05_info", CmdEM4x05Info, IfPm3Present, "tag information EM4x05/EM4x69"},
{"4x05_read", CmdEM4x05Read, 0, "read word data from EM4x05/EM4x69"}, {"4x05_read", CmdEM4x05Read, IfPm3Present, "read word data from EM4x05/EM4x69"},
{"4x05_write", CmdEM4x05Write, 0, "write word data to EM4x05/EM4x69"}, {"4x05_write", CmdEM4x05Write, IfPm3Present, "write word data to EM4x05/EM4x69"},
{"4x50_dump", CmdEM4x50Dump, 0, "dump EM4x50 tag"}, {"4x50_dump", CmdEM4x50Dump, IfPm3Present, "dump EM4x50 tag"},
{"4x50_read", CmdEM4x50Read, 0, "read word data from EM4x50"}, {"4x50_read", CmdEM4x50Read, IfPm3Present, "read word data from EM4x50"},
{"4x50_write", CmdEM4x50Write, 0, "write word data to EM4x50"}, {"4x50_write", CmdEM4x50Write, IfPm3Present, "write word data to EM4x50"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlffdx.c
View file

@ -320,12 +320,12 @@ static int CmdFdxSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdFdxDemod, 1, "demodulate a FDX-B ISO11784/85 tag from the GraphBuffer"}, {"demod", CmdFdxDemod, AlwaysAvailable, "demodulate a FDX-B ISO11784/85 tag from the GraphBuffer"},
{"read", CmdFdxRead, 0, "attempt to read and extract tag data"}, {"read", CmdFdxRead, IfPm3Present, "attempt to read and extract tag data"},
{"clone", CmdFdxClone, 0, "clone animal ID tag to T55x7 (or to q5/T5555)"}, {"clone", CmdFdxClone, IfPm3Present, "clone animal ID tag to T55x7 (or to q5/T5555)"},
{"sim", CmdFdxSim, 0, "simulate Animal ID tag"}, {"sim", CmdFdxSim, IfPm3Present, "simulate Animal ID tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfguard.c
View file

@ -215,12 +215,12 @@ static int CmdGuardSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdGuardDemod, 1, "demodulate a G Prox II tag from the GraphBuffer"}, {"demod", CmdGuardDemod, AlwaysAvailable, "demodulate a G Prox II tag from the GraphBuffer"},
{"read", CmdGuardRead, 0, "attempt to read and extract tag data from the antenna"}, {"read", CmdGuardRead, IfPm3Present, "attempt to read and extract tag data from the antenna"},
{"clone", CmdGuardClone, 0, "clone Guardall tag"}, {"clone", CmdGuardClone, IfPm3Present, "clone Guardall tag"},
{"sim", CmdGuardSim, 0, "simulate Guardall tag"}, {"sim", CmdGuardSim, IfPm3Present, "simulate Guardall tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

16
client/cmdlfhid.c
View file

@ -594,14 +594,14 @@ static int CmdHIDBrute(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdHIDDemod, 0, "demodulate HID Prox tag from the GraphBuffer"}, {"demod", CmdHIDDemod, IfPm3Present, "demodulate HID Prox tag from the GraphBuffer"},
{"read", CmdHIDRead, 0, "attempt to read and extract tag data"}, {"read", CmdHIDRead, IfPm3Present, "attempt to read and extract tag data"},
{"clone", CmdHIDClone, 0, "clone HID to T55x7"}, {"clone", CmdHIDClone, IfPm3Present, "clone HID to T55x7"},
{"sim", CmdHIDSim, 0, "simulate HID tag"}, {"sim", CmdHIDSim, IfPm3Present, "simulate HID tag"},
{"wiegand", CmdHIDWiegand, 1, "convert facility code/card number to Wiegand code"}, {"wiegand", CmdHIDWiegand, AlwaysAvailable, "convert facility code/card number to Wiegand code"},
{"brute", CmdHIDBrute, 0, "bruteforce card number against reader"}, {"brute", CmdHIDBrute, IfPm3Present, "bruteforce card number against reader"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

16
client/cmdlfhitag.c
View file

@ -694,14 +694,14 @@ static int CmdLFHitagDump(const char *Cmd) {
*/ */
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help" }, {"help", CmdHelp, AlwaysAvailable, "This help" },
{"list", CmdLFHitagList, 0, "List Hitag trace history" }, {"list", CmdLFHitagList, IfPm3Present, "List Hitag trace history" },
{"info", CmdLFHitagInfo, 1, "Tag information" }, {"info", CmdLFHitagInfo, AlwaysAvailable, "Tag information" },
{"reader", CmdLFHitagReader, 1, "Act like a Hitag Reader" }, {"reader", CmdLFHitagReader, AlwaysAvailable, "Act like a Hitag Reader" },
{"sim", CmdLFHitagSim, 1, "Simulate Hitag transponder" }, {"sim", CmdLFHitagSim, AlwaysAvailable, "Simulate Hitag transponder" },
{"sniff", CmdLFHitagSniff, 1, "Eavesdrop Hitag communication" }, {"sniff", CmdLFHitagSniff, AlwaysAvailable, "Eavesdrop Hitag communication" },
{"writer", CmdLFHitagWriter, 1, "Act like a Hitag Writer" }, {"writer", CmdLFHitagWriter, AlwaysAvailable, "Act like a Hitag Writer" },
{"cc", CmdLFHitagCheckChallenges, 1, "Test all challenges" }, {"cc", CmdLFHitagCheckChallenges, AlwaysAvailable, "Test all challenges" },
{ NULL, NULL, 0, NULL } { NULL, NULL, 0, NULL }
}; };

14
client/cmdlfindala.c
View file

@ -457,13 +457,13 @@ static int CmdIndalaClone(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdIndalaDemod, 1, "demodulate an indala tag (PSK1) from GraphBuffer"}, {"demod", CmdIndalaDemod, AlwaysAvailable, "demodulate an indala tag (PSK1) from GraphBuffer"},
{"altdemod", CmdIndalaDemodAlt, 1, "alternative method to Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"}, {"altdemod", CmdIndalaDemodAlt, AlwaysAvailable, "alternative method to Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},
{"read", CmdIndalaRead, 0, "read an Indala Prox tag from the antenna"}, {"read", CmdIndalaRead, IfPm3Present, "read an Indala Prox tag from the antenna"},
{"clone", CmdIndalaClone, 0, "clone Indala to T55x7"}, {"clone", CmdIndalaClone, IfPm3Present, "clone Indala to T55x7"},
{"sim", CmdIndalaSim, 0, "simulate Indala tag"}, {"sim", CmdIndalaSim, IfPm3Present, "simulate Indala tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfio.c
View file

@ -257,12 +257,12 @@ static int CmdIOProxClone(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdIOProxDemod, 1, "demodulate an IOProx tag from the GraphBuffer"}, {"demod", CmdIOProxDemod, AlwaysAvailable, "demodulate an IOProx tag from the GraphBuffer"},
{"read", CmdIOProxRead, 1, "attempt to read and extract tag data"}, {"read", CmdIOProxRead, AlwaysAvailable, "attempt to read and extract tag data"},
{"clone", CmdIOProxClone, 0, "clone IOProx to T55x7"}, {"clone", CmdIOProxClone, IfPm3Present, "clone IOProx to T55x7"},
{"sim", CmdIOProxSim, 0, "simulate IOProx tag"}, {"sim", CmdIOProxSim, IfPm3Present, "simulate IOProx tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfjablotron.c
View file

@ -193,12 +193,12 @@ static int CmdJablotronSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdJablotronDemod, 1, "Demodulate an Jablotron tag from the GraphBuffer"}, {"demod", CmdJablotronDemod, AlwaysAvailable, "Demodulate an Jablotron tag from the GraphBuffer"},
{"read", CmdJablotronRead, 0, "Attempt to read and extract tag data from the antenna"}, {"read", CmdJablotronRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"},
{"clone", CmdJablotronClone, 0, "clone jablotron tag"}, {"clone", CmdJablotronClone, IfPm3Present, "clone jablotron tag"},
{"sim", CmdJablotronSim, 0, "simulate jablotron tag"}, {"sim", CmdJablotronSim, IfPm3Present, "simulate jablotron tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfkeri.c
View file

@ -188,12 +188,12 @@ static int CmdKeriSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdKeriDemod, 1, "Demodulate an KERI tag from the GraphBuffer"}, {"demod", CmdKeriDemod, AlwaysAvailable, "Demodulate an KERI tag from the GraphBuffer"},
{"read", CmdKeriRead, 0, "Attempt to read and extract tag data from the antenna"}, {"read", CmdKeriRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"},
{"clone", CmdKeriClone, 0, "clone KERI to T55x7"}, {"clone", CmdKeriClone, IfPm3Present, "clone KERI to T55x7"},
{"sim", CmdKeriSim, 0, "simulate KERI tag"}, {"sim", CmdKeriSim, IfPm3Present, "simulate KERI tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfnedap.c
View file

@ -294,13 +294,13 @@ static int CmdLFNedapChk(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdLFNedapDemod, 0, "demodulate an Nedap tag from the GraphBuffer"}, {"demod", CmdLFNedapDemod, IfPm3Present, "demodulate an Nedap tag from the GraphBuffer"},
{"read", CmdLFNedapRead, 0, "attempt to read and extract tag data"}, {"read", CmdLFNedapRead, IfPm3Present, "attempt to read and extract tag data"},
// {"clone", CmdLFNedapClone,0, "<Card Number> clone nedap tag"}, // {"clone", CmdLFNedapClone,0, "<Card Number> clone nedap tag"},
{"sim", CmdLFNedapSim, 0, "simulate nedap tag"}, {"sim", CmdLFNedapSim, IfPm3Present, "simulate nedap tag"},
{"chk", CmdLFNedapChk, 1, "calculate Nedap Checksum <uid bytes>"}, {"chk", CmdLFNedapChk, AlwaysAvailable, "calculate Nedap Checksum <uid bytes>"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

8
client/cmdlfnexwatch.c
View file

@ -75,10 +75,10 @@ static int CmdNexWatchRead(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdNexWatchDemod, 1, "Demodulate a NexWatch tag (nexkey, quadrakey) from the GraphBuffer"}, {"demod", CmdNexWatchDemod, AlwaysAvailable, "Demodulate a NexWatch tag (nexkey, quadrakey) from the GraphBuffer"},
{"read", CmdNexWatchRead, 0, "Attempt to Read and Extract tag data from the antenna"}, {"read", CmdNexWatchRead, IfPm3Present, "Attempt to Read and Extract tag data from the antenna"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfnoralsy.c
View file

@ -196,12 +196,12 @@ static int CmdNoralsySim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdNoralsyDemod, 1, "Demodulate an Noralsy tag from the GraphBuffer"}, {"demod", CmdNoralsyDemod, AlwaysAvailable, "Demodulate an Noralsy tag from the GraphBuffer"},
{"read", CmdNoralsyRead, 0, "Attempt to read and extract tag data from the antenna"}, {"read", CmdNoralsyRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"},
{"clone", CmdNoralsyClone, 0, "clone Noralsy to T55x7"}, {"clone", CmdNoralsyClone, IfPm3Present, "clone Noralsy to T55x7"},
{"sim", CmdNoralsySim, 0, "simulate Noralsy tag"}, {"sim", CmdNoralsySim, IfPm3Present, "simulate Noralsy tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

8
client/cmdlfpac.c
View file

@ -57,10 +57,10 @@ static int CmdPacRead(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdPacDemod, 1, "Demodulate an PAC tag from the GraphBuffer"}, {"demod", CmdPacDemod, AlwaysAvailable, "Demodulate an PAC tag from the GraphBuffer"},
{"read", CmdPacRead, 0, "Attempt to read and extract tag data from the antenna"}, {"read", CmdPacRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

10
client/cmdlfparadox.c
View file

@ -142,12 +142,12 @@ static int CmdParadoxSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdParadoxDemod, 1, "Demodulate a Paradox FSK tag from the GraphBuffer"}, {"demod", CmdParadoxDemod, AlwaysAvailable, "Demodulate a Paradox FSK tag from the GraphBuffer"},
{"read", CmdParadoxRead, 0, "Attempt to read and Extract tag data from the antenna"}, {"read", CmdParadoxRead, IfPm3Present, "Attempt to read and Extract tag data from the antenna"},
// {"clone", CmdParadoxClone, 0, "clone paradox tag"}, // {"clone", CmdParadoxClone, 0, "clone paradox tag"},
{"sim", CmdParadoxSim, 0, "simulate paradox tag"}, {"sim", CmdParadoxSim, IfPm3Present, "simulate paradox tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

10
client/cmdlfpcf7931.c
View file

@ -157,11 +157,11 @@ static int CmdLFPCF7931Write(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"read", CmdLFPCF7931Read, 0, "Read content of a PCF7931 transponder"}, {"read", CmdLFPCF7931Read, IfPm3Present, "Read content of a PCF7931 transponder"},
{"write", CmdLFPCF7931Write, 0, "Write data on a PCF7931 transponder."}, {"write", CmdLFPCF7931Write, IfPm3Present, "Write data on a PCF7931 transponder."},
{"config", CmdLFPCF7931Config, 1, "Configure the password, the tags initialization delay and time offsets (optional)"}, {"config", CmdLFPCF7931Config, AlwaysAvailable, "Configure the password, the tags initialization delay and time offsets (optional)"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

10
client/cmdlfpresco.c
View file

@ -152,11 +152,11 @@ static int CmdPrescoSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"read", CmdPrescoRead, 0, "Attempt to read and Extract tag data"}, {"read", CmdPrescoRead, IfPm3Present, "Attempt to read and Extract tag data"},
{"clone", CmdPrescoClone, 0, "clone presco tag"}, {"clone", CmdPrescoClone, IfPm3Present, "clone presco tag"},
{"sim", CmdPrescoSim, 0, "simulate presco tag"}, {"sim", CmdPrescoSim, IfPm3Present, "simulate presco tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfpyramid.c
View file

@ -276,12 +276,12 @@ static int CmdPyramidSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "this help"}, {"help", CmdHelp, AlwaysAvailable, "this help"},
{"demod", CmdPyramidDemod, 0, "demodulate a Pyramid FSK tag from the GraphBuffer"}, {"demod", CmdPyramidDemod, IfPm3Present, "demodulate a Pyramid FSK tag from the GraphBuffer"},
{"read", CmdPyramidRead, 0, "attempt to read and extract tag data"}, {"read", CmdPyramidRead, IfPm3Present, "attempt to read and extract tag data"},
{"clone", CmdPyramidClone, 0, "clone pyramid tag"}, {"clone", CmdPyramidClone, IfPm3Present, "clone pyramid tag"},
{"sim", CmdPyramidSim, 0, "simulate pyramid tag"}, {"sim", CmdPyramidSim, IfPm3Present, "simulate pyramid tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
int CmdLFPyramid(const char *Cmd) { int CmdLFPyramid(const char *Cmd) {

8
client/cmdlfsecurakey.c
View file

@ -100,12 +100,12 @@ static int CmdSecurakeyRead(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdSecurakeyDemod, 1, "Demodulate an Securakey tag from the GraphBuffer"}, {"demod", CmdSecurakeyDemod, AlwaysAvailable, "Demodulate an Securakey tag from the GraphBuffer"},
{"read", CmdSecurakeyRead, 0, "Attempt to read and extract tag data from the antenna"}, {"read", CmdSecurakeyRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"},
//{"clone", CmdSecurakeyClone,0, "clone Securakey tag"}, //{"clone", CmdSecurakeyClone,0, "clone Securakey tag"},
//{"sim", CmdSecurakeydSim, 0, "simulate Securakey tag"}, //{"sim", CmdSecurakeydSim, 0, "simulate Securakey tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

36
client/cmdlft55xx.c
View file

@ -2302,24 +2302,24 @@ static int CmdT55xxSetDeviceConfig(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"bruteforce", CmdT55xxBruteForce, 0, "<start password> <end password> [i <*.dic>] Simple bruteforce attack to find password"}, {"bruteforce", CmdT55xxBruteForce, IfPm3Present, "<start password> <end password> [i <*.dic>] Simple bruteforce attack to find password"},
{"config", CmdT55xxSetConfig, 1, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"}, {"config", CmdT55xxSetConfig, AlwaysAvailable, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"},
{"chk", CmdT55xxChkPwds, 1, "Check passwords"}, {"chk", CmdT55xxChkPwds, AlwaysAvailable, "Check passwords"},
{"detect", CmdT55xxDetect, 1, "[1] Try detecting the tag modulation from reading the configuration block."}, {"detect", CmdT55xxDetect, AlwaysAvailable, "[1] Try detecting the tag modulation from reading the configuration block."},
{"deviceconfig", CmdT55xxSetDeviceConfig, 1, "Set/Get T55XX device configuration (startgap, writegap, write0, write1, readgap"}, {"deviceconfig", CmdT55xxSetDeviceConfig, AlwaysAvailable, "Set/Get T55XX device configuration (startgap, writegap, write0, write1, readgap"},
{"p1detect", CmdT55xxDetectPage1, 1, "[1] Try detecting if this is a t55xx tag by reading page 1"}, {"p1detect", CmdT55xxDetectPage1, AlwaysAvailable, "[1] Try detecting if this is a t55xx tag by reading page 1"},
{"dump", CmdT55xxDump, 0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"}, {"dump", CmdT55xxDump, IfPm3Present, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"},
{"info", CmdT55xxInfo, 1, "[1] Show T55x7 configuration data (page 0/ blk 0)"}, {"info", CmdT55xxInfo, AlwaysAvailable, "[1] Show T55x7 configuration data (page 0/ blk 0)"},
{"read", CmdT55xxReadBlock, 0, "b <block> p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"}, {"read", CmdT55xxReadBlock, IfPm3Present, "b <block> p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"},
{"resetread", CmdResetRead, 0, "Send Reset Cmd then lf read the stream to attempt to identify the start of it (needs a demod and/or plot after)"}, {"resetread", CmdResetRead, IfPm3Present, "Send Reset Cmd then lf read the stream to attempt to identify the start of it (needs a demod and/or plot after)"},
{"recoverpw", CmdT55xxRecoverPW, 0, "[password] Try to recover from bad password write from a cloner. Only use on PW protected chips!"}, {"recoverpw", CmdT55xxRecoverPW, IfPm3Present, "[password] Try to recover from bad password write from a cloner. Only use on PW protected chips!"},
{"special", special, 0, "Show block changes with 64 different offsets"}, {"special", special, IfPm3Present, "Show block changes with 64 different offsets"},
{"trace", CmdT55xxReadTrace, 1, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"}, {"trace", CmdT55xxReadTrace, AlwaysAvailable, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"},
{"wakeup", CmdT55xxWakeUp, 0, "Send AOR wakeup command"}, {"wakeup", CmdT55xxWakeUp, IfPm3Present, "Send AOR wakeup command"},
{"wipe", CmdT55xxWipe, 0, "[q] Wipe a T55xx tag and set defaults (will destroy any data on tag)"}, {"wipe", CmdT55xxWipe, IfPm3Present, "[q] Wipe a T55xx tag and set defaults (will destroy any data on tag)"},
{"write", CmdT55xxWriteBlock, 0, "b <block> d <data> p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"}, {"write", CmdT55xxWriteBlock, IfPm3Present, "b <block> d <data> p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

10
client/cmdlfti.c
View file

@ -299,11 +299,11 @@ static int CmdTIWrite(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdTIDemod, 1, "Demodulate raw bits for TI-type LF tag from the GraphBuffer"}, {"demod", CmdTIDemod, AlwaysAvailable, "Demodulate raw bits for TI-type LF tag from the GraphBuffer"},
{"read", CmdTIRead, 0, "Read and decode a TI 134 kHz tag"}, {"read", CmdTIRead, IfPm3Present, "Read and decode a TI 134 kHz tag"},
{"write", CmdTIWrite, 0, "Write new data to a r/w TI 134 kHz tag"}, {"write", CmdTIWrite, IfPm3Present, "Write new data to a r/w TI 134 kHz tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfviking.c
View file

@ -121,12 +121,12 @@ static int CmdVikingSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdVikingDemod, 1, "Demodulate a Viking tag from the GraphBuffer"}, {"demod", CmdVikingDemod, AlwaysAvailable, "Demodulate a Viking tag from the GraphBuffer"},
{"read", CmdVikingRead, 0, "Attempt to read and Extract tag data from the antenna"}, {"read", CmdVikingRead, IfPm3Present, "Attempt to read and Extract tag data from the antenna"},
{"clone", CmdVikingClone, 0, "<8 digit ID number> clone viking tag"}, {"clone", CmdVikingClone, IfPm3Present, "<8 digit ID number> clone viking tag"},
{"sim", CmdVikingSim, 0, "<8 digit ID number> simulate viking tag"}, {"sim", CmdVikingSim, IfPm3Present, "<8 digit ID number> simulate viking tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

12
client/cmdlfvisa2000.c
View file

@ -203,12 +203,12 @@ static int CmdVisa2kSim(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"demod", CmdVisa2kDemod, 1, "demodulate an VISA2000 tag from the GraphBuffer"}, {"demod", CmdVisa2kDemod, AlwaysAvailable, "demodulate an VISA2000 tag from the GraphBuffer"},
{"read", CmdVisa2kRead, 0, "attempt to read and extract tag data from the antenna"}, {"read", CmdVisa2kRead, IfPm3Present, "attempt to read and extract tag data from the antenna"},
{"clone", CmdVisa2kClone, 0, "clone Visa2000 to t55x7"}, {"clone", CmdVisa2kClone, IfPm3Present, "clone Visa2000 to t55x7"},
{"sim", CmdVisa2kSim, 0, "simulate Visa2000 tag"}, {"sim", CmdVisa2kSim, IfPm3Present, "simulate Visa2000 tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

32
client/cmdmain.c
View file

@ -42,26 +42,26 @@ static int CmdRev(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help. Use '<command> help' for details of a particular command."}, {"help", CmdHelp, AlwaysAvailable, "This help. Use '<command> help' for details of a particular command."},
{"analyse", CmdAnalyse, 1, "{ Analyse utils... }"}, {"analyse", CmdAnalyse, AlwaysAvailable, "{ Analyse utils... }"},
{"data", CmdData, 1, "{ Plot window / data buffer manipulation... }"}, {"data", CmdData, AlwaysAvailable, "{ Plot window / data buffer manipulation... }"},
{"hf", CmdHF, 1, "{ High Frequency commands... }"}, {"hf", CmdHF, AlwaysAvailable, "{ High Frequency commands... }"},
{"hw", CmdHW, 1, "{ Hardware commands... }"}, {"hw", CmdHW, AlwaysAvailable, "{ Hardware commands... }"},
{"lf", CmdLF, 1, "{ Low Frequency commands... }"}, {"lf", CmdLF, AlwaysAvailable, "{ Low Frequency commands... }"},
{"emv", CmdEMV, 1, "{ EMV iso14443 and iso7816... }"}, {"emv", CmdEMV, AlwaysAvailable, "{ EMV iso14443 and iso7816... }"},
{"rem", CmdRem, 1, "{ Add text to row in log file }"}, {"rem", CmdRem, AlwaysAvailable, "{ Add text to row in log file }"},
{"reveng", CmdRev, 1, "{ Crc calculations from the RevEng software... }"}, {"reveng", CmdRev, AlwaysAvailable, "{ Crc calculations from the RevEng software... }"},
{"script", CmdScript, 1, "{ Scripting commands }"}, {"script", CmdScript, AlwaysAvailable, "{ Scripting commands }"},
{"trace", CmdTrace, 1, "{ Trace manipulation... }"}, {"trace", CmdTrace, AlwaysAvailable, "{ Trace manipulation... }"},
#ifdef WITH_FLASH #ifdef WITH_FLASH
{"mem", CmdFlashMem, 1, "{ Flash Memory manipulation... }"}, {"mem", CmdFlashMem, AlwaysAvailable, "{ Flash Memory manipulation... }"},
#endif #endif
#ifdef WITH_SMARTCARD #ifdef WITH_SMARTCARD
{"sc", CmdSmartcard, 1, "{ Smart card ISO7816 commands... }"}, {"sc", CmdSmartcard, AlwaysAvailable, "{ Smart card ISO7816 commands... }"},
#endif #endif
{"quit", CmdQuit, 1, ""}, {"quit", CmdQuit, AlwaysAvailable, ""},
{"exit", CmdQuit, 1, "Exit program"}, {"exit", CmdQuit, AlwaysAvailable, "Exit program"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

6
client/cmdmain.h
View file

@ -32,14 +32,8 @@
#include "cmdcrc.h" #include "cmdcrc.h"
#include "cmdanalyse.h" #include "cmdanalyse.h"
#include "emv/cmdemv.h" // EMV #include "emv/cmdemv.h" // EMV
#ifdef WITH_FLASH
#include "cmdflashmem.h" // rdv40 flashmem commands #include "cmdflashmem.h" // rdv40 flashmem commands
#endif
#ifdef WITH_SMARTCARD
#include "cmdsmartcard.h" // rdv40 smart card ISO7816 commands #include "cmdsmartcard.h" // rdv40 smart card ISO7816 commands
#endif
int CommandReceived(char *Cmd); int CommandReceived(char *Cmd);
command_t *getTopLevelCommandTable(void); command_t *getTopLevelCommandTable(void);

40
client/cmdparser.c
View file

@ -17,11 +17,27 @@
#include "proxmark3.h" #include "proxmark3.h"
#include "comms.h" #include "comms.h"
bool AlwaysAvailable(void) {
return true;
}
bool IfPm3Present(void) {
if (session.help_dump_mode)
return false;
return session.pm3_present;
}
bool IfPm3Hfsniff(void) {
if (!IfPm3Present())
return false;
return pm3_capabilities.compiled_with_hfsniff;
}
void CmdsHelp(const command_t Commands[]) { void CmdsHelp(const command_t Commands[]) {
if (Commands[0].Name == NULL) return; if (Commands[0].Name == NULL) return;
int i = 0; int i = 0;
while (Commands[i].Name) { while (Commands[i].Name) {
if (session.pm3_present || Commands[i].Offline) if (Commands[i].IsAvailable())
PrintAndLogEx(NORMAL, "%-16s %s", Commands[i].Name, Commands[i].Help); PrintAndLogEx(NORMAL, "%-16s %s", Commands[i].Name, Commands[i].Help);
++i; ++i;
} }
@ -46,7 +62,7 @@ int CmdsParse(const command_t Commands[], const char *Cmd) {
int i = 0; int i = 0;
while (Commands[i].Name) { while (Commands[i].Name) {
if (0 == strcmp(Commands[i].Name, cmd_name)) { if (0 == strcmp(Commands[i].Name, cmd_name)) {
if (session.pm3_present || Commands[i].Offline) { if (Commands[i].IsAvailable()) {
break; break;
} else { } else {
PrintAndLogEx(WARNING, "This command is only available in " _YELLOW_("online") "mode"); PrintAndLogEx(WARNING, "This command is only available in " _YELLOW_("online") "mode");
@ -62,7 +78,7 @@ int CmdsParse(const command_t Commands[], const char *Cmd) {
int matches = 0; int matches = 0;
for (i = 0; Commands[i].Name; i++) { for (i = 0; Commands[i].Name; i++) {
if (!strncmp(Commands[i].Name, cmd_name, strlen(cmd_name)) && (session.pm3_present || Commands[i].Offline)) { if (!strncmp(Commands[i].Name, cmd_name, strlen(cmd_name)) && Commands[i].IsAvailable()) {
last_match = i; last_match = i;
matches++; matches++;
} }
@ -94,33 +110,33 @@ void dumpCommandsRecursive(const command_t cmds[], int markdown) {
// First, dump all single commands, which are not a container for // First, dump all single commands, which are not a container for
// other commands // other commands
if (markdown) { if (markdown) {
PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s\n", w_cmd, "command", w_off, "offline", "description"); PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s", w_cmd, "command", w_off, "offline", "description");
PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s\n", w_cmd, "-------", w_off, "-------", "-----------"); PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s", w_cmd, "-------", w_off, "-------", "-----------");
} else { } else {
PrintAndLogEx(NORMAL, "%-*s|%-*s|%s\n", w_cmd, "command", w_off, "offline", "description"); PrintAndLogEx(NORMAL, "%-*s|%-*s|%s", w_cmd, "command", w_off, "offline", "description");
PrintAndLogEx(NORMAL, "%-*s|%-*s|%s\n", w_cmd, "-------", w_off, "-------", "-----------"); PrintAndLogEx(NORMAL, "%-*s|%-*s|%s", w_cmd, "-------", w_off, "-------", "-----------");
} }
while (cmds[i].Name) { while (cmds[i].Name) {
const char *cmd_offline = "N"; const char *cmd_offline = "N";
if (cmds[i].Help[0] == '{' && ++i) continue; if (cmds[i].Help[0] == '{' && ++i) continue;
if (cmds[i].Offline) if (cmds[i].IsAvailable())
cmd_offline = "Y"; cmd_offline = "Y";
if (markdown) if (markdown)
PrintAndLogEx(NORMAL, "|`%s%-*s`|%-*s|`%s`\n", parent, w_cmd - (int)strlen(parent) - 2, cmds[i].Name, w_off, cmd_offline, cmds[i].Help); PrintAndLogEx(NORMAL, "|`%s%-*s`|%-*s|`%s`", parent, w_cmd - (int)strlen(parent) - 2, cmds[i].Name, w_off, cmd_offline, cmds[i].Help);
else else
PrintAndLogEx(NORMAL, "%s%-*s|%-*s|%s\n", parent, w_cmd - (int)strlen(parent), cmds[i].Name, w_off, cmd_offline, cmds[i].Help); PrintAndLogEx(NORMAL, "%s%-*s|%-*s|%s", parent, w_cmd - (int)strlen(parent), cmds[i].Name, w_off, cmd_offline, cmds[i].Help);
++i; ++i;
} }
PrintAndLogEx(NORMAL, "\n\n"); PrintAndLogEx(NORMAL, "\n");
i = 0; i = 0;
// Then, print the categories. These will go into subsections with their own tables // Then, print the categories. These will go into subsections with their own tables
while (cmds[i].Name) { while (cmds[i].Name) {
if (cmds[i].Help[0] != '{' && ++i) continue; if (cmds[i].Help[0] != '{' && ++i) continue;
PrintAndLogEx(NORMAL, "### %s%s\n\n %s\n\n", parent, cmds[i].Name, cmds[i].Help); PrintAndLogEx(NORMAL, "### %s%s\n\n %s\n", parent, cmds[i].Name, cmds[i].Help);
char currentparent[512] = {0}; char currentparent[512] = {0};
snprintf(currentparent, sizeof currentparent, "%s%s ", parent, cmds[i].Name); snprintf(currentparent, sizeof currentparent, "%s%s ", parent, cmds[i].Name);

7
client/cmdparser.h
View file

@ -14,12 +14,15 @@
typedef struct command_s { typedef struct command_s {
const char *Name; const char *Name;
int (*Parse)(const char *Cmd); int (*Parse)(const char *Cmd);
int Offline; bool (*IsAvailable)(void);
const char *Help; const char *Help;
} command_t; } command_t;
// command_t array are expected to be NULL terminated // command_t array are expected to be NULL terminated
bool AlwaysAvailable(void);
bool IfPm3Present(void);
bool IfPm3Hfsniff(void);
// Print help for each command in the command array // Print help for each command in the command array
void CmdsHelp(const command_t Commands[]); void CmdsHelp(const command_t Commands[]);
// Print each command in the command array without help // Print each command in the command array without help

8
client/cmdscript.c
View file

@ -167,10 +167,10 @@ static int CmdScriptRun(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdScriptList, 1, "List available scripts"}, {"list", CmdScriptList, AlwaysAvailable, "List available scripts"},
{"run", CmdScriptRun, 1, "<name> -- Execute a script"}, {"run", CmdScriptRun, AlwaysAvailable, "<name> -- Execute a script"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
/** /**

18
client/cmdsmartcard.c
View file

@ -1118,15 +1118,15 @@ static int CmdSmartBruteforceSFI(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdSmartList, 0, "List ISO 7816 history"}, {"list", CmdSmartList, IfPm3Present, "List ISO 7816 history"},
{"info", CmdSmartInfo, 1, "Tag information"}, {"info", CmdSmartInfo, AlwaysAvailable, "Tag information"},
{"reader", CmdSmartReader, 1, "Act like an IS07816 reader"}, {"reader", CmdSmartReader, AlwaysAvailable, "Act like an IS07816 reader"},
{"raw", CmdSmartRaw, 1, "Send raw hex data to tag"}, {"raw", CmdSmartRaw, AlwaysAvailable, "Send raw hex data to tag"},
{"upgrade", CmdSmartUpgrade, 1, "Upgrade sim module firmware"}, {"upgrade", CmdSmartUpgrade, AlwaysAvailable, "Upgrade sim module firmware"},
{"setclock", CmdSmartSetClock, 1, "Set clock speed"}, {"setclock", CmdSmartSetClock, AlwaysAvailable, "Set clock speed"},
{"brute", CmdSmartBruteforceSFI, 1, "Bruteforce SFI"}, {"brute", CmdSmartBruteforceSFI, AlwaysAvailable, "Bruteforce SFI"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

10
client/cmdtrace.c
View file

@ -568,11 +568,11 @@ static int CmdTraceSave(const char *Cmd) {
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"list", CmdTraceList, 1, "List protocol data in trace buffer"}, {"list", CmdTraceList, AlwaysAvailable, "List protocol data in trace buffer"},
{"load", CmdTraceLoad, 1, "Load trace from file"}, {"load", CmdTraceLoad, AlwaysAvailable, "Load trace from file"},
{"save", CmdTraceSave, 1, "Save trace buffer to file"}, {"save", CmdTraceSave, AlwaysAvailable, "Save trace buffer to file"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

40
client/emv/cmdemv.c
View file

@ -1940,28 +1940,28 @@ out:
} }
static command_t CommandTable[] = { static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, AlwaysAvailable, "This help"},
{"exec", CmdEMVExec, 0, "Executes EMV contactless transaction."}, {"exec", CmdEMVExec, IfPm3Present, "Executes EMV contactless transaction."},
{"pse", CmdEMVPPSE, 0, "Execute PPSE. It selects 2PAY.SYS.DDF01 or 1PAY.SYS.DDF01 directory."}, {"pse", CmdEMVPPSE, IfPm3Present, "Execute PPSE. It selects 2PAY.SYS.DDF01 or 1PAY.SYS.DDF01 directory."},
{"search", CmdEMVSearch, 0, "Try to select all applets from applets list and print installed applets."}, {"search", CmdEMVSearch, IfPm3Present, "Try to select all applets from applets list and print installed applets."},
{"select", CmdEMVSelect, 0, "Select applet."}, {"select", CmdEMVSelect, IfPm3Present, "Select applet."},
{"gpo", CmdEMVGPO, 0, "Execute GetProcessingOptions."}, {"gpo", CmdEMVGPO, IfPm3Present, "Execute GetProcessingOptions."},
{"readrec", CmdEMVReadRecord, 0, "Read files from card."}, {"readrec", CmdEMVReadRecord, IfPm3Present, "Read files from card."},
{"genac", CmdEMVAC, 0, "Generate ApplicationCryptogram."}, {"genac", CmdEMVAC, IfPm3Present, "Generate ApplicationCryptogram."},
{"challenge", CmdEMVGenerateChallenge, 0, "Generate challenge."}, {"challenge", CmdEMVGenerateChallenge, IfPm3Present, "Generate challenge."},
{"intauth", CmdEMVInternalAuthenticate, 0, "Internal authentication."}, {"intauth", CmdEMVInternalAuthenticate, IfPm3Present, "Internal authentication."},
{"scan", CmdEMVScan, 0, "Scan EMV card and save it contents to json file for emulator."}, {"scan", CmdEMVScan, IfPm3Present, "Scan EMV card and save it contents to json file for emulator."},
{"test", CmdEMVTest, 0, "Crypto logic test."}, {"test", CmdEMVTest, IfPm3Present, "Crypto logic test."},
/* /*
{"getrng", CmdEMVGetrng, 0, "get random number from terminal"}, {"getrng", CmdEMVGetrng, IfPm3Present, "get random number from terminal"},
{"eload", CmdEmvELoad, 0, "load EMV tag into device"}, {"eload", CmdEmvELoad, IfPm3Present, "load EMV tag into device"},
{"dump", CmdEmvDump, 0, "dump EMV tag values"}, {"dump", CmdEmvDump, IfPm3Present, "dump EMV tag values"},
{"sim", CmdEmvSim, 0, "simulate EMV tag"}, {"sim", CmdEmvSim, IfPm3Present, "simulate EMV tag"},
{"clone", CmdEmvClone, 0, "clone an EMV tag"}, {"clone", CmdEmvClone, IfPm3Present, "clone an EMV tag"},
*/ */
{"list", CmdEMVList, 0, "List ISO7816 history"}, {"list", CmdEMVList, IfPm3Present, "List ISO7816 history"},
{"roca", CmdEMVRoca, 0, "Extract public keys and run ROCA test"}, {"roca", CmdEMVRoca, IfPm3Present, "Extract public keys and run ROCA test"},
{NULL, NULL, 0, NULL} {NULL, NULL, NULL, NULL}
}; };
static int CmdHelp(const char *Cmd) { static int CmdHelp(const char *Cmd) {

1
client/flasher.c
View file

@ -50,6 +50,7 @@ int main(int argc, char **argv) {
if (session.stdinOnTTY && session.stdoutOnTTY) if (session.stdinOnTTY && session.stdoutOnTTY)
session.supports_colors = true; session.supports_colors = true;
#endif #endif
session.help_dump_mode = false;
if (argc < 3) { if (argc < 3) {
usage(argv[0]); usage(argv[0]);

3
client/proxmark3.c
View file

@ -220,12 +220,14 @@ main_loop(char *script_cmds_file, char *script_cmd) {
} }
static void dumpAllHelp(int markdown) { static void dumpAllHelp(int markdown) {
session.help_dump_mode = true;
PrintAndLogEx(NORMAL, "\n%sProxmark3 command dump%s\n\n", markdown ? "# " : "", markdown ? "" : "\n======================"); PrintAndLogEx(NORMAL, "\n%sProxmark3 command dump%s\n\n", markdown ? "# " : "", markdown ? "" : "\n======================");
PrintAndLogEx(NORMAL, "Some commands are available only if a Proxmark3 is actually connected.%s\n", markdown ? " " : ""); PrintAndLogEx(NORMAL, "Some commands are available only if a Proxmark3 is actually connected.%s\n", markdown ? " " : "");
PrintAndLogEx(NORMAL, "Check column \"offline\" for their availability.\n"); PrintAndLogEx(NORMAL, "Check column \"offline\" for their availability.\n");
PrintAndLogEx(NORMAL, "\n"); PrintAndLogEx(NORMAL, "\n");
command_t *cmds = getTopLevelCommandTable(); command_t *cmds = getTopLevelCommandTable();
dumpCommandsRecursive(cmds, markdown); dumpCommandsRecursive(cmds, markdown);
session.help_dump_mode = false;
} }
static char *my_executable_path = NULL; static char *my_executable_path = NULL;
@ -291,6 +293,7 @@ int main(int argc, char *argv[]) {
srand(time(0)); srand(time(0));
session.pm3_present = false; session.pm3_present = false;
session.help_dump_mode = false;
bool waitCOMPort = false; bool waitCOMPort = false;
bool addLuaExec = false; bool addLuaExec = false;
char *script_cmds_file = NULL; char *script_cmds_file = NULL;

1
client/ui.h
View file

@ -29,6 +29,7 @@ typedef struct {
bool stdoutOnTTY; bool stdoutOnTTY;
bool supports_colors; bool supports_colors;
bool pm3_present; bool pm3_present;
bool help_dump_mode;
} session_arg_t; } session_arg_t;
extern session_arg_t session; extern session_arg_t session;