diff --git a/client/cmdanalyse.c b/client/cmdanalyse.c index 1b12b33fd..3e80371ea 100644 --- a/client/cmdanalyse.c +++ b/client/cmdanalyse.c @@ -903,16 +903,16 @@ static int CmdAnalyseNuid(const char *Cmd) { return 0; } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"lcr", CmdAnalyseLCR, 1, "Generate final byte for XOR LRC"}, - {"crc", CmdAnalyseCRC, 1, "Stub method for CRC evaluations"}, - {"chksum", CmdAnalyseCHKSUM, 1, "Checksum with adding, masking and one's complement"}, - {"dates", CmdAnalyseDates, 1, "Look for datestamps in a given array of bytes"}, - {"tea", CmdAnalyseTEASelfTest, 1, "Crypto TEA test"}, - {"lfsr", CmdAnalyseLfsr, 1, "LFSR tests"}, - {"a", CmdAnalyseA, 1, "num bits test"}, - {"nuid", CmdAnalyseNuid, 1, "create NUID from 7byte UID"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"lcr", CmdAnalyseLCR, AlwaysAvailable, "Generate final byte for XOR LRC"}, + {"crc", CmdAnalyseCRC, AlwaysAvailable, "Stub method for CRC evaluations"}, + {"chksum", CmdAnalyseCHKSUM, AlwaysAvailable, "Checksum with adding, masking and one's complement"}, + {"dates", CmdAnalyseDates, AlwaysAvailable, "Look for datestamps in a given array of bytes"}, + {"tea", CmdAnalyseTEASelfTest, AlwaysAvailable, "Crypto TEA test"}, + {"lfsr", CmdAnalyseLfsr, AlwaysAvailable, "LFSR tests"}, + {"a", CmdAnalyseA, AlwaysAvailable, "num bits test"}, + {"nuid", CmdAnalyseNuid, AlwaysAvailable, "create NUID from 7byte UID"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmddata.c b/client/cmddata.c index 6ac03202d..a83c4811d 100644 --- a/client/cmddata.c +++ b/client/cmddata.c @@ -2097,44 +2097,44 @@ static int CmdDataIIR(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "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)"}, - {"autocorr", CmdAutoCorr, 1, "[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)"}, - {"bin2hex", Cmdbin2hex, 1, " -- Converts binary to hexadecimal"}, - {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, - {"buffclear", CmdBuffClear, 1, "Clears bigbuff on deviceside and graph window"}, - {"dec", CmdDec, 1, "Decimate samples"}, - {"detectclock", CmdDetectClockRate, 1, "[] 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)"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"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, AlwaysAvailable, "[window length] [g] -- Autocorrelation over window - g to save back to GraphBuffer (overwrite)"}, + {"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, AlwaysAvailable, " -- Converts binary to hexadecimal"}, + {"bitsamples", CmdBitsamples, IfPm3Present, "Get raw samples as bitstring"}, + {"buffclear", CmdBuffClear, AlwaysAvailable, "Clears bigbuff on deviceside and graph window"}, + {"dec", CmdDec, AlwaysAvailable, "Decimate samples"}, + {"detectclock", CmdDetectClockRate, AlwaysAvailable, "[] Detect ASK, FSK, NRZ, PSK clock rate of wave in GraphBuffer"}, + {"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"}, - {"grid", CmdGrid, 1, " -- overlay grid on graph window, use zero value to turn off either"}, - {"hexsamples", CmdHexsamples, 0, " [] -- Dump big buffer as hex bytes"}, - {"hex2bin", Cmdhex2bin, 1, " -- Converts hexadecimal to binary"}, - {"hide", CmdHide, 1, "Hide graph window"}, - {"hpf", CmdHpf, 1, "Remove DC offset from trace"}, - {"load", CmdLoad, 1, " -- Load trace (to graph window"}, - {"ltrim", CmdLtrim, 1, " -- Trim samples from left of trace"}, - {"rtrim", CmdRtrim, 1, " -- Trim samples from right of trace"}, - {"mtrim", CmdMtrim, 1, " -- Trim out samples from the specified start to the specified stop"}, - {"manrawdecode", Cmdmandecoderaw, 1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"}, - {"norm", CmdNorm, 1, "Normalize max/min to +/-128"}, - {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, - {"printdemodbuffer", CmdPrintDemodBuff, 1, "[x] [o] [l] -- print the data in the DemodBuffer - 'x' for hex output"}, - {"rawdemod", CmdRawDemod, 1, "[modulation] ... -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)"}, - {"save", CmdSave, 1, " -- Save trace (from graph window)"}, - {"setgraphmarkers", CmdSetGraphMarkers, 1, "[orange_marker] [blue_marker] (in graph window)"}, - {"scale", CmdScale, 1, " -- Set cursor display scale"}, - {"setdebugmode", CmdSetDebugMode, 1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"}, - {"shiftgraphzero", CmdGraphShiftZero, 1, " -- Shift 0 for Graphed wave + or - shift value"}, - {"dirthreshold", CmdDirectionalThreshold, 1, " -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, - {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"}, - {"undec", CmdUndec, 1, "Un-decimate samples by 2"}, - {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"}, - {"iir", CmdDataIIR, 0, "apply IIR buttersworth filter on plotdata"}, - {NULL, NULL, 0, NULL} + {"getbitstream", CmdGetBitStream, AlwaysAvailable, "Convert GraphBuffer's >=1 values to 1 and <1 to 0"}, + {"grid", CmdGrid, AlwaysAvailable, " -- overlay grid on graph window, use zero value to turn off either"}, + {"hexsamples", CmdHexsamples, IfPm3Present, " [] -- Dump big buffer as hex bytes"}, + {"hex2bin", Cmdhex2bin, AlwaysAvailable, " -- Converts hexadecimal to binary"}, + {"hide", CmdHide, AlwaysAvailable, "Hide graph window"}, + {"hpf", CmdHpf, AlwaysAvailable, "Remove DC offset from trace"}, + {"load", CmdLoad, AlwaysAvailable, " -- Load trace (to graph window"}, + {"ltrim", CmdLtrim, AlwaysAvailable, " -- Trim samples from left of trace"}, + {"rtrim", CmdRtrim, AlwaysAvailable, " -- Trim samples from right of trace"}, + {"mtrim", CmdMtrim, AlwaysAvailable, " -- Trim out samples from the specified start to the specified stop"}, + {"manrawdecode", Cmdmandecoderaw, AlwaysAvailable, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"}, + {"norm", CmdNorm, AlwaysAvailable, "Normalize max/min to +/-128"}, + {"plot", CmdPlot, AlwaysAvailable, "Show graph window (hit 'h' in window for keystroke help)"}, + {"printdemodbuffer", CmdPrintDemodBuff, AlwaysAvailable, "[x] [o] [l] -- print the data in the DemodBuffer - 'x' for hex output"}, + {"rawdemod", CmdRawDemod, AlwaysAvailable, "[modulation] ... -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"}, + {"samples", CmdSamples, IfPm3Present, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"}, + {"save", CmdSave, AlwaysAvailable, " -- Save trace (from graph window)"}, + {"setgraphmarkers", CmdSetGraphMarkers, AlwaysAvailable, "[orange_marker] [blue_marker] (in graph window)"}, + {"scale", CmdScale, AlwaysAvailable, " -- Set cursor display scale"}, + {"setdebugmode", CmdSetDebugMode, AlwaysAvailable, "<0|1|2> -- Turn on or off Debugging Level for lf demods"}, + {"shiftgraphzero", CmdGraphShiftZero, AlwaysAvailable, " -- Shift 0 for Graphed wave + or - shift value"}, + {"dirthreshold", CmdDirectionalThreshold, AlwaysAvailable, " -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, + {"tune", CmdTuneSamples, IfPm3Present, "Get hw tune samples for graph window"}, + {"undec", CmdUndec, AlwaysAvailable, "Un-decimate samples by 2"}, + {"zerocrossings", CmdZerocrossings, AlwaysAvailable, "Count time between zero-crossings"}, + {"iir", CmdDataIIR, IfPm3Present, "apply IIR buttersworth filter on plotdata"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdflashmem.c b/client/cmdflashmem.c index 3a202c875..127bd3419 100644 --- a/client/cmdflashmem.c +++ b/client/cmdflashmem.c @@ -617,14 +617,14 @@ static int CmdFlashMemInfo(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"spibaud", CmdFlashmemSpiBaudrate, 1, "Set Flash memory Spi baudrate [rdv40]"}, - {"read", CmdFlashMemRead, 1, "Read Flash memory [rdv40]"}, - {"info", CmdFlashMemInfo, 1, "Flash memory information [rdv40]"}, - {"load", CmdFlashMemLoad, 1, "Load data into flash memory [rdv40]"}, - {"save", CmdFlashMemSave, 1, "Save data from flash memory [rdv40]"}, - {"wipe", CmdFlashMemWipe, 1, "Wipe data from flash memory [rdv40]"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"spibaud", CmdFlashmemSpiBaudrate, AlwaysAvailable, "Set Flash memory Spi baudrate [rdv40]"}, + {"read", CmdFlashMemRead, AlwaysAvailable, "Read Flash memory [rdv40]"}, + {"info", CmdFlashMemInfo, AlwaysAvailable, "Flash memory information [rdv40]"}, + {"load", CmdFlashMemLoad, AlwaysAvailable, "Load data into flash memory [rdv40]"}, + {"save", CmdFlashMemSave, AlwaysAvailable, "Save data from flash memory [rdv40]"}, + {"wipe", CmdFlashMemWipe, AlwaysAvailable, "Wipe data from flash memory [rdv40]"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhf.c b/client/cmdhf.c index 405ad4c67..06624cd1b 100644 --- a/client/cmdhf.c +++ b/client/cmdhf.c @@ -102,25 +102,25 @@ int CmdHFSniff(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"14a", CmdHF14A, 1, "{ ISO14443A RFIDs... }"}, - {"14b", CmdHF14B, 1, "{ ISO14443B RFIDs... }"}, - {"15", CmdHF15, 1, "{ ISO15693 RFIDs... }"}, - {"epa", CmdHFEPA, 1, "{ German Identification Card... }"}, - {"felica", CmdHFFelica, 1, "{ ISO18092 / Felica RFIDs... }"}, - {"legic", CmdHFLegic, 1, "{ LEGIC RFIDs... }"}, - {"iclass", CmdHFiClass, 1, "{ ICLASS RFIDs... }"}, - {"mf", CmdHFMF, 1, "{ MIFARE RFIDs... }"}, - {"mfp", CmdHFMFP, 1, "{ MIFARE Plus RFIDs... }"}, - {"mfu", CmdHFMFUltra, 1, "{ MIFARE Ultralight RFIDs... }"}, - {"mfdes", CmdHFMFDes, 1, "{ MIFARE Desfire RFIDs... }"}, - {"topaz", CmdHFTopaz, 1, "{ TOPAZ (NFC Type 1) RFIDs... }"}, - {"fido", CmdHFFido, 1, "{ FIDO and FIDO2 authenticators... }"}, - {"list", CmdTraceList, 0, "List protocol data in trace buffer"}, - {"tune", CmdHFTune, 0, "Continuously measure HF antenna tuning"}, - {"search", CmdHFSearch, 1, "Search for known HF tags [preliminary]"}, - {"sniff", CmdHFSniff, 0, " Generic HF Sniff"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"14a", CmdHF14A, AlwaysAvailable, "{ ISO14443A RFIDs... }"}, + {"14b", CmdHF14B, AlwaysAvailable, "{ ISO14443B RFIDs... }"}, + {"15", CmdHF15, AlwaysAvailable, "{ ISO15693 RFIDs... }"}, + {"epa", CmdHFEPA, AlwaysAvailable, "{ German Identification Card... }"}, + {"felica", CmdHFFelica, AlwaysAvailable, "{ ISO18092 / Felica RFIDs... }"}, + {"legic", CmdHFLegic, AlwaysAvailable, "{ LEGIC RFIDs... }"}, + {"iclass", CmdHFiClass, AlwaysAvailable, "{ ICLASS RFIDs... }"}, + {"mf", CmdHFMF, AlwaysAvailable, "{ MIFARE RFIDs... }"}, + {"mfp", CmdHFMFP, AlwaysAvailable, "{ MIFARE Plus RFIDs... }"}, + {"mfu", CmdHFMFUltra, AlwaysAvailable, "{ MIFARE Ultralight RFIDs... }"}, + {"mfdes", CmdHFMFDes, AlwaysAvailable, "{ MIFARE Desfire RFIDs... }"}, + {"topaz", CmdHFTopaz, AlwaysAvailable, "{ TOPAZ (NFC Type 1) RFIDs... }"}, + {"fido", CmdHFFido, AlwaysAvailable, "{ FIDO and FIDO2 authenticators... }"}, + {"list", CmdTraceList, IfPm3Present, "List protocol data in trace buffer"}, + {"tune", CmdHFTune, IfPm3Present, "Continuously measure HF antenna tuning"}, + {"search", CmdHFSearch, AlwaysAvailable, "Search for known HF tags [preliminary]"}, + {"sniff", CmdHFSniff, IfPm3Hfsniff, " Generic HF Sniff"}, + {NULL, NULL, NULL, NULL} }; int CmdHF(const char *Cmd) { diff --git a/client/cmdhf14a.c b/client/cmdhf14a.c index 42e5e5c29..c54c51741 100644 --- a/client/cmdhf14a.c +++ b/client/cmdhf14a.c @@ -1115,18 +1115,18 @@ static int CmdHF14AChaining(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdHF14AList, 0, "List ISO 14443-a history"}, - {"info", CmdHF14AInfo, 0, "Tag information"}, - {"reader", CmdHF14AReader, 0, "Act like an ISO14443-a reader"}, - {"cuids", CmdHF14ACUIDs, 0, " Collect n>0 ISO14443-a UIDs in one go"}, - {"sim", CmdHF14ASim, 0, " -- Simulate ISO 14443-a tag"}, - {"sniff", CmdHF14ASniff, 0, "sniff ISO 14443-a traffic"}, - {"apdu", CmdHF14AAPDU, 0, "Send ISO 14443-4 APDU to tag"}, - {"chaining", CmdHF14AChaining, 0, "Control ISO 14443-4 input chaining"}, - {"raw", CmdHF14ACmdRaw, 0, "Send raw hex data to tag"}, - {"antifuzz", CmdHF14AAntiFuzz, 0, "Fuzzing the anticollision phase. Warning! Readers may react strange"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"list", CmdHF14AList, IfPm3Present, "List ISO 14443-a history"}, + {"info", CmdHF14AInfo, IfPm3Present, "Tag information"}, + {"reader", CmdHF14AReader, IfPm3Present, "Act like an ISO14443-a reader"}, + {"cuids", CmdHF14ACUIDs, IfPm3Present, " Collect n>0 ISO14443-a UIDs in one go"}, + {"sim", CmdHF14ASim, IfPm3Present, " -- Simulate ISO 14443-a tag"}, + {"sniff", CmdHF14ASniff, IfPm3Present, "sniff ISO 14443-a traffic"}, + {"apdu", CmdHF14AAPDU, IfPm3Present, "Send ISO 14443-4 APDU to tag"}, + {"chaining", CmdHF14AChaining, IfPm3Present, "Control ISO 14443-4 input chaining"}, + {"raw", CmdHF14ACmdRaw, IfPm3Present, "Send raw hex data to tag"}, + {"antifuzz", CmdHF14AAntiFuzz, IfPm3Present, "Fuzzing the anticollision phase. Warning! Readers may react strange"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhf14b.c b/client/cmdhf14b.c index 0696a3203..c11074850 100644 --- a/client/cmdhf14b.c +++ b/client/cmdhf14b.c @@ -1074,18 +1074,18 @@ static int srix4kValid(const char *Cmd) { } */ static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"dump", CmdHF14BDump, 0, "Read all memory pages of an ISO14443-B tag, save to file"}, - {"info", CmdHF14Binfo, 0, "Tag information"}, - {"list", CmdHF14BList, 0, "List ISO 14443B history"}, - {"raw", CmdHF14BCmdRaw, 0, "Send raw hex data to tag"}, - {"reader", CmdHF14BReader, 0, "Act as a 14443B reader to identify a tag"}, - {"sim", CmdHF14BSim, 0, "Fake ISO 14443B tag"}, - {"sniff", CmdHF14BSniff, 0, "Eavesdrop ISO 14443B"}, - {"sriread", CmdHF14BReadSri, 0, "Read contents of a SRI512 | SRIX4K tag"}, - {"sriwrite", CmdHF14BWriteSri, 0, "Write data to a SRI512 | SRIX4K tag"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"dump", CmdHF14BDump, IfPm3Present, "Read all memory pages of an ISO14443-B tag, save to file"}, + {"info", CmdHF14Binfo, IfPm3Present, "Tag information"}, + {"list", CmdHF14BList, IfPm3Present, "List ISO 14443B history"}, + {"raw", CmdHF14BCmdRaw, IfPm3Present, "Send raw hex data to tag"}, + {"reader", CmdHF14BReader, IfPm3Present, "Act as a 14443B reader to identify a tag"}, + {"sim", CmdHF14BSim, IfPm3Present, "Fake ISO 14443B tag"}, + {"sniff", CmdHF14BSniff, IfPm3Present, "Eavesdrop ISO 14443B"}, + {"sriread", CmdHF14BReadSri, IfPm3Present, "Read contents of a SRI512 | SRIX4K tag"}, + {"sriwrite", CmdHF14BWriteSri, IfPm3Present, "Write data to a SRI512 | SRIX4K tag"}, //{"valid", srix4kValid, 1, "srix4k checksum test"}, - {NULL, NULL, 0, NULL} + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhf15.c b/client/cmdhf15.c index 5cce0079a..eba66143f 100644 --- a/client/cmdhf15.c +++ b/client/cmdhf15.c @@ -1274,22 +1274,22 @@ static int CmdHF15Restore(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHF15Help, 1, "This help"}, - {"demod", CmdHF15Demod, 1, "Demodulate ISO15693 from tag"}, - {"dump", CmdHF15Dump, 0, "Read all memory pages of an ISO15693 tag, save to file"}, - {"findafi", CmdHF15Afi, 0, "Brute force AFI of an ISO15693 tag"}, - {"info", CmdHF15Info, 0, "Tag information"}, - {"list", CmdHF15List, 0, "List ISO15693 history"}, - {"raw", CmdHF15Raw, 0, "Send raw hex data to tag"}, - {"reader", CmdHF15Reader, 0, "Act like an ISO15693 reader"}, - {"record", CmdHF15Record, 0, "Record Samples (ISO15693)"}, - {"restore", CmdHF15Restore, 0, "Restore from file to all memory pages of an ISO15693 tag"}, - {"sim", CmdHF15Sim, 0, "Fake an ISO15693 tag"}, - {"samples", CmdHF15Samples, 0, "Acquire Samples as Reader (enables carrier, sends inquiry)"}, - {"read", CmdHF15Read, 0, "Read a block"}, - {"write", CmdHF15Write, 0, "Write a block"}, - {"readmulti", CmdHF15Readmulti, 0, "Reads multiple Blocks"}, - {NULL, NULL, 0, NULL} + {"help", CmdHF15Help, AlwaysAvailable, "This help"}, + {"demod", CmdHF15Demod, AlwaysAvailable, "Demodulate ISO15693 from tag"}, + {"dump", CmdHF15Dump, IfPm3Present, "Read all memory pages of an ISO15693 tag, save to file"}, + {"findafi", CmdHF15Afi, IfPm3Present, "Brute force AFI of an ISO15693 tag"}, + {"info", CmdHF15Info, IfPm3Present, "Tag information"}, + {"list", CmdHF15List, IfPm3Present, "List ISO15693 history"}, + {"raw", CmdHF15Raw, IfPm3Present, "Send raw hex data to tag"}, + {"reader", CmdHF15Reader, IfPm3Present, "Act like an ISO15693 reader"}, + {"record", CmdHF15Record, IfPm3Present, "Record Samples (ISO15693)"}, + {"restore", CmdHF15Restore, IfPm3Present, "Restore from file to all memory pages of an ISO15693 tag"}, + {"sim", CmdHF15Sim, IfPm3Present, "Fake an ISO15693 tag"}, + {"samples", CmdHF15Samples, IfPm3Present, "Acquire Samples as Reader (enables carrier, sends inquiry)"}, + {"read", CmdHF15Read, IfPm3Present, "Read a block"}, + {"write", CmdHF15Write, IfPm3Present, "Write a block"}, + {"readmulti", CmdHF15Readmulti, IfPm3Present, "Reads multiple Blocks"}, + {NULL, NULL, NULL, NULL} }; static int CmdHF15Help(const char *Cmd) { diff --git a/client/cmdhfepa.c b/client/cmdhfepa.c index 3b6549cce..18812d15a 100644 --- a/client/cmdhfepa.c +++ b/client/cmdhfepa.c @@ -157,10 +157,10 @@ static int CmdHFEPAPACEReplay(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"cnonces", CmdHFEPACollectPACENonces, 0, " Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"}, - {"preplay", CmdHFEPAPACEReplay, 0, " Perform PACE protocol by replaying given APDUs"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"cnonces", CmdHFEPACollectPACENonces, IfPm3Present, " Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"}, + {"preplay", CmdHFEPAPACEReplay, IfPm3Present, " Perform PACE protocol by replaying given APDUs"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhffelica.c b/client/cmdhffelica.c index c61e386c8..6565dc2b2 100644 --- a/client/cmdhffelica.c +++ b/client/cmdhffelica.c @@ -534,16 +534,16 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdHFFelicaList, 0, "List ISO 18092/FeliCa history"}, - {"reader", CmdHFFelicaReader, 0, "Act like an ISO18092/FeliCa reader"}, - {"sim", CmdHFFelicaSim, 0, " -- Simulate ISO 18092/FeliCa tag"}, - {"sniff", CmdHFFelicaSniff, 0, "sniff ISO 18092/Felica traffic"}, - {"raw", CmdHFFelicaCmdRaw, 0, "Send raw hex data to tag"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"list", CmdHFFelicaList, IfPm3Present, "List ISO 18092/FeliCa history"}, + {"reader", CmdHFFelicaReader, IfPm3Present, "Act like an ISO18092/FeliCa reader"}, + {"sim", CmdHFFelicaSim, IfPm3Present, " -- Simulate ISO 18092/FeliCa tag"}, + {"sniff", CmdHFFelicaSniff, IfPm3Present, "sniff ISO 18092/Felica traffic"}, + {"raw", CmdHFFelicaCmdRaw, IfPm3Present, "Send raw hex data to tag"}, - {"litesim", CmdHFFelicaSimLite, 0, " - only reply to poll request"}, - {"litedump", CmdHFFelicaDumpLite, 0, "Wait for and try dumping FelicaLite"}, - {NULL, NULL, 0, NULL} + {"litesim", CmdHFFelicaSimLite, IfPm3Present, " - only reply to poll request"}, + {"litedump", CmdHFFelicaDumpLite, IfPm3Present, "Wait for and try dumping FelicaLite"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhffido.c b/client/cmdhffido.c index 2bdb9421b..522d525ec 100644 --- a/client/cmdhffido.c +++ b/client/cmdhffido.c @@ -895,12 +895,12 @@ static int CmdHFFido2GetAssertion(const char *cmd) { }; static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help."}, - {"info", CmdHFFidoInfo, 0, "Info about FIDO tag."}, - {"reg", CmdHFFidoRegister, 0, "FIDO U2F Registration Message."}, - {"auth", CmdHFFidoAuthenticate, 0, "FIDO U2F Authentication Message."}, - {"make", CmdHFFido2MakeCredential, 0, "FIDO2 MakeCredential command."}, - {"assert", CmdHFFido2GetAssertion, 0, "FIDO2 GetAssertion command."}, + {"help", CmdHelp, AlwaysAvailable, "This help."}, + {"info", CmdHFFidoInfo, IfPm3Present, "Info about FIDO tag."}, + {"reg", CmdHFFidoRegister, IfPm3Present, "FIDO U2F Registration Message."}, + {"auth", CmdHFFidoAuthenticate, IfPm3Present, "FIDO U2F Authentication Message."}, + {"make", CmdHFFido2MakeCredential, IfPm3Present, "FIDO2 MakeCredential command."}, + {"assert", CmdHFFido2GetAssertion, IfPm3Present, "FIDO2 GetAssertion command."}, {NULL, NULL, 0, NULL} }; diff --git a/client/cmdhficlass.c b/client/cmdhficlass.c index 5f04f03f5..cd3c204cb 100644 --- a/client/cmdhficlass.c +++ b/client/cmdhficlass.c @@ -2418,27 +2418,27 @@ static int CmdHFiClassPermuteKey(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"calcnewkey", CmdHFiClassCalcNewKey, 1, "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"}, - {"chk", CmdHFiClassCheckKeys, 1, " Check keys"}, - {"clone", CmdHFiClassCloneTag, 0, "[options..] Authenticate and Clone from iClass bin file"}, - {"decrypt", CmdHFiClassDecrypt, 1, "[f ] Decrypt tagdump" }, - {"dump", CmdHFiClassReader_Dump, 0, "[options..] Authenticate and Dump iClass tag's AA1"}, - {"eload", CmdHFiClassELoad, 0, "[f ] (experimental) Load data into iClass emulator memory"}, - {"encryptblk", CmdHFiClassEncryptBlk, 1, " Encrypt given block data"}, - {"list", CmdHFiClassList, 0, " List iClass history"}, - {"loclass", CmdHFiClass_loclass, 1, "[options..] Use loclass to perform bruteforce of reader attack dump"}, - {"lookup", CmdHFiClassLookUp, 1, "[options..] Uses authentication trace to check for key in dictionary file"}, - {"managekeys", CmdHFiClassManageKeys, 1, "[options..] Manage the keys to use with iClass"}, - {"permutekey", CmdHFiClassPermuteKey, 0, " Permute function from 'heart of darkness' paper"}, - {"readblk", CmdHFiClass_ReadBlock, 0, "[options..] Authenticate and Read iClass block"}, - {"reader", CmdHFiClassReader, 0, " Act like an iClass reader"}, - {"readtagfile", CmdHFiClassReadTagFile, 1, "[options..] Display Content from tagfile"}, - {"replay", CmdHFiClassReader_Replay, 0, " Read an iClass tag via Replay Attack"}, - {"sim", CmdHFiClassSim, 0, "[options..] Simulate iClass tag"}, - {"sniff", CmdHFiClassSniff, 0, " Eavesdrop iClass communication"}, - {"writeblk", CmdHFiClass_WriteBlock, 0, "[options..] Authenticate and Write iClass block"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"calcnewkey", CmdHFiClassCalcNewKey, AlwaysAvailable, "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"}, + {"chk", CmdHFiClassCheckKeys, AlwaysAvailable, " Check keys"}, + {"clone", CmdHFiClassCloneTag, IfPm3Present, "[options..] Authenticate and Clone from iClass bin file"}, + {"decrypt", CmdHFiClassDecrypt, AlwaysAvailable, "[f ] Decrypt tagdump" }, + {"dump", CmdHFiClassReader_Dump, IfPm3Present, "[options..] Authenticate and Dump iClass tag's AA1"}, + {"eload", CmdHFiClassELoad, IfPm3Present, "[f ] (experimental) Load data into iClass emulator memory"}, + {"encryptblk", CmdHFiClassEncryptBlk, AlwaysAvailable, " Encrypt given block data"}, + {"list", CmdHFiClassList, IfPm3Present, " List iClass history"}, + {"loclass", CmdHFiClass_loclass, AlwaysAvailable, "[options..] Use loclass to perform bruteforce of reader attack dump"}, + {"lookup", CmdHFiClassLookUp, AlwaysAvailable, "[options..] Uses authentication trace to check for key in dictionary file"}, + {"managekeys", CmdHFiClassManageKeys, AlwaysAvailable, "[options..] Manage the keys to use with iClass"}, + {"permutekey", CmdHFiClassPermuteKey, IfPm3Present, " Permute function from 'heart of darkness' paper"}, + {"readblk", CmdHFiClass_ReadBlock, IfPm3Present, "[options..] Authenticate and Read iClass block"}, + {"reader", CmdHFiClassReader, IfPm3Present, " Act like an iClass reader"}, + {"readtagfile", CmdHFiClassReadTagFile, AlwaysAvailable, "[options..] Display Content from tagfile"}, + {"replay", CmdHFiClassReader_Replay, IfPm3Present, " Read an iClass tag via Replay Attack"}, + {"sim", CmdHFiClassSim, IfPm3Present, "[options..] Simulate iClass tag"}, + {"sniff", CmdHFiClassSniff, IfPm3Present, " Eavesdrop iClass communication"}, + {"writeblk", CmdHFiClass_WriteBlock, IfPm3Present, "[options..] Authenticate and Write iClass block"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhflegic.c b/client/cmdhflegic.c index 85a3a18bc..6ebcd7db2 100644 --- a/client/cmdhflegic.c +++ b/client/cmdhflegic.c @@ -1270,20 +1270,20 @@ static int CmdLegicList(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"reader", CmdLegicReader, 1, "LEGIC Prime Reader UID and tag info"}, - {"info", CmdLegicInfo, 0, "Display deobfuscated and decoded LEGIC Prime tag data"}, - {"dump", CmdLegicDump, 0, "Dump LEGIC Prime tag to binary file"}, - {"restore", CmdLegicRestore, 0, "Restore a dump file onto a LEGIC Prime tag"}, - {"rdmem", CmdLegicRdmem, 0, "Read bytes from a LEGIC Prime tag"}, - {"sim", CmdLegicRfSim, 0, "Start tag simulator"}, - {"write", CmdLegicRfWrite, 0, "Write data to a LEGIC Prime tag"}, - {"crc", CmdLegicCalcCrc, 1, "Calculate Legic CRC over given bytes"}, - {"eload", CmdLegicELoad, 1, "Load binary dump to emulator memory"}, - {"esave", CmdLegicESave, 1, "Save emulator memory to binary file"}, - {"list", CmdLegicList, 1, "List LEGIC history"}, - {"wipe", CmdLegicWipe, 1, "Wipe a LEGIC Prime tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"reader", CmdLegicReader, AlwaysAvailable, "LEGIC Prime Reader UID and tag info"}, + {"info", CmdLegicInfo, IfPm3Present, "Display deobfuscated and decoded LEGIC Prime tag data"}, + {"dump", CmdLegicDump, IfPm3Present, "Dump LEGIC Prime tag to binary file"}, + {"restore", CmdLegicRestore, IfPm3Present, "Restore a dump file onto a LEGIC Prime tag"}, + {"rdmem", CmdLegicRdmem, IfPm3Present, "Read bytes from a LEGIC Prime tag"}, + {"sim", CmdLegicRfSim, IfPm3Present, "Start tag simulator"}, + {"write", CmdLegicRfWrite, IfPm3Present, "Write data to a LEGIC Prime tag"}, + {"crc", CmdLegicCalcCrc, AlwaysAvailable, "Calculate Legic CRC over given bytes"}, + {"eload", CmdLegicELoad, AlwaysAvailable, "Load binary dump to emulator memory"}, + {"esave", CmdLegicESave, AlwaysAvailable, "Save emulator memory to binary file"}, + {"list", CmdLegicList, AlwaysAvailable, "List LEGIC history"}, + {"wipe", CmdLegicWipe, AlwaysAvailable, "Wipe a LEGIC Prime tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c index 6c82d36a5..dac5c3b11 100644 --- a/client/cmdhfmf.c +++ b/client/cmdhfmf.c @@ -3553,48 +3553,48 @@ static int CmdHF14AMfList(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdHF14AMfList, 0, "List Mifare history"}, - {"darkside", CmdHF14AMfDarkside, 0, "Darkside attack. read parity error messages."}, - {"nested", CmdHF14AMfNested, 0, "Nested attack. Test nested authentication"}, - {"hardnested", CmdHF14AMfNestedHard, 0, "Nested attack for hardened Mifare cards"}, - {"keybrute", CmdHF14AMfKeyBrute, 0, "J_Run's 2nd phase of multiple sector nested authentication key recovery"}, - {"nack", CmdHf14AMfNack, 0, "Test for Mifare NACK bug"}, - {"chk", CmdHF14AMfChk, 0, "Check keys"}, - {"fchk", CmdHF14AMfChk_fast, 0, "Check keys fast, targets all keys on card"}, - {"decrypt", CmdHf14AMfDecryptBytes, 1, "[nt] [ar_enc] [at_enc] [data] - to decrypt sniff or trace"}, - {"-----------", CmdHelp, 0, ""}, - {"dbg", CmdHF14AMfDbg, 0, "Set default debug mode"}, - {"rdbl", CmdHF14AMfRdBl, 0, "Read MIFARE classic block"}, - {"rdsc", CmdHF14AMfRdSc, 0, "Read MIFARE classic sector"}, - {"dump", CmdHF14AMfDump, 0, "Dump MIFARE classic tag to binary file"}, - {"restore", CmdHF14AMfRestore, 0, "Restore MIFARE classic binary file to BLANK tag"}, - {"wrbl", CmdHF14AMfWrBl, 0, "Write MIFARE classic block"}, - {"setmod", CmdHf14AMfSetMod, 0, "Set MIFARE Classic EV1 load modulation strength"}, - {"auth4", CmdHF14AMfAuth4, 0, "ISO14443-4 AES authentication"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"list", CmdHF14AMfList, IfPm3Present, "List Mifare history"}, + {"darkside", CmdHF14AMfDarkside, IfPm3Present, "Darkside attack. read parity error messages."}, + {"nested", CmdHF14AMfNested, IfPm3Present, "Nested attack. Test nested authentication"}, + {"hardnested", CmdHF14AMfNestedHard, IfPm3Present, "Nested attack for hardened Mifare cards"}, + {"keybrute", CmdHF14AMfKeyBrute, IfPm3Present, "J_Run's 2nd phase of multiple sector nested authentication key recovery"}, + {"nack", CmdHf14AMfNack, IfPm3Present, "Test for Mifare NACK bug"}, + {"chk", CmdHF14AMfChk, IfPm3Present, "Check keys"}, + {"fchk", CmdHF14AMfChk_fast, IfPm3Present, "Check keys fast, targets all keys on card"}, + {"decrypt", CmdHf14AMfDecryptBytes, AlwaysAvailable, "[nt] [ar_enc] [at_enc] [data] - to decrypt sniff or trace"}, + {"-----------", CmdHelp, IfPm3Present, ""}, + {"dbg", CmdHF14AMfDbg, IfPm3Present, "Set default debug mode"}, + {"rdbl", CmdHF14AMfRdBl, IfPm3Present, "Read MIFARE classic block"}, + {"rdsc", CmdHF14AMfRdSc, IfPm3Present, "Read MIFARE classic sector"}, + {"dump", CmdHF14AMfDump, IfPm3Present, "Dump MIFARE classic tag to binary file"}, + {"restore", CmdHF14AMfRestore, IfPm3Present, "Restore MIFARE classic binary file to BLANK tag"}, + {"wrbl", CmdHF14AMfWrBl, IfPm3Present, "Write MIFARE classic block"}, + {"setmod", CmdHf14AMfSetMod, IfPm3Present, "Set MIFARE Classic EV1 load modulation strength"}, + {"auth4", CmdHF14AMfAuth4, IfPm3Present, "ISO14443-4 AES authentication"}, // {"sniff", CmdHF14AMfSniff, 0, "Sniff card-reader communication"}, - {"-----------", CmdHelp, 0, ""}, - {"sim", CmdHF14AMfSim, 0, "Simulate MIFARE card"}, - {"eclr", CmdHF14AMfEClear, 0, "Clear simulator memory"}, - {"eget", CmdHF14AMfEGet, 0, "Get simulator memory block"}, - {"eset", CmdHF14AMfESet, 0, "Set simulator memory block"}, - {"eload", CmdHF14AMfELoad, 0, "Load from file emul dump"}, - {"esave", CmdHF14AMfESave, 0, "Save to file emul dump"}, - {"ecfill", CmdHF14AMfECFill, 0, "Fill simulator memory with help of keys from simulator"}, - {"ekeyprn", CmdHF14AMfEKeyPrn, 0, "Print keys from simulator memory"}, - {"-----------", CmdHelp, 0, ""}, - {"csetuid", CmdHF14AMfCSetUID, 0, "Set UID for magic Chinese card"}, - {"csetblk", CmdHF14AMfCSetBlk, 0, "Write block - Magic Chinese card"}, - {"cgetblk", CmdHF14AMfCGetBlk, 0, "Read block - Magic Chinese card"}, - {"cgetsc", CmdHF14AMfCGetSc, 0, "Read sector - Magic Chinese card"}, - {"cload", CmdHF14AMfCLoad, 0, "Load dump into magic Chinese card"}, - {"csave", CmdHF14AMfCSave, 0, "Save dump from magic Chinese card into file or emulator"}, - {"-----------", CmdHelp, 0, ""}, - {"mad", CmdHF14AMfMAD, 0, "Checks and prints MAD"}, - {"ndef", CmdHFMFNDEF, 0, "Prints NDEF records from card"}, + {"-----------", CmdHelp, IfPm3Present, ""}, + {"sim", CmdHF14AMfSim, IfPm3Present, "Simulate MIFARE card"}, + {"eclr", CmdHF14AMfEClear, IfPm3Present, "Clear simulator memory"}, + {"eget", CmdHF14AMfEGet, IfPm3Present, "Get simulator memory block"}, + {"eset", CmdHF14AMfESet, IfPm3Present, "Set simulator memory block"}, + {"eload", CmdHF14AMfELoad, IfPm3Present, "Load from file emul dump"}, + {"esave", CmdHF14AMfESave, IfPm3Present, "Save to file emul dump"}, + {"ecfill", CmdHF14AMfECFill, IfPm3Present, "Fill simulator memory with help of keys from simulator"}, + {"ekeyprn", CmdHF14AMfEKeyPrn, IfPm3Present, "Print keys from simulator memory"}, + {"-----------", CmdHelp, IfPm3Present, ""}, + {"csetuid", CmdHF14AMfCSetUID, IfPm3Present, "Set UID for magic Chinese card"}, + {"csetblk", CmdHF14AMfCSetBlk, IfPm3Present, "Write block - Magic Chinese card"}, + {"cgetblk", CmdHF14AMfCGetBlk, IfPm3Present, "Read block - Magic Chinese card"}, + {"cgetsc", CmdHF14AMfCGetSc, IfPm3Present, "Read sector - Magic Chinese card"}, + {"cload", CmdHF14AMfCLoad, IfPm3Present, "Load dump into magic Chinese card"}, + {"csave", CmdHF14AMfCSave, IfPm3Present, "Save dump from magic Chinese card into file or emulator"}, + {"-----------", CmdHelp, IfPm3Present, ""}, + {"mad", CmdHF14AMfMAD, IfPm3Present, "Checks and prints MAD"}, + {"ndef", CmdHFMFNDEF, IfPm3Present, "Prints NDEF records from card"}, - {"ice", CmdHF14AMfice, 0, "collect Mifare Classic nonces to file"}, - {NULL, NULL, 0, NULL} + {"ice", CmdHF14AMfice, IfPm3Present, "collect Mifare Classic nonces to file"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhfmfdes.c b/client/cmdhfmfdes.c index 62f328acc..fa776fdd6 100644 --- a/client/cmdhfmfdes.c +++ b/client/cmdhfmfdes.c @@ -624,13 +624,13 @@ static int CmdHF14ADesAuth(const char *Cmd) { static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"info", CmdHF14ADesInfo, 0, "Tag information"}, - {"enum", CmdHF14ADesEnumApplications, 0, "Tries enumerate all applications"}, - {"auth", CmdHF14ADesAuth, 0, "Tries a MIFARE DesFire Authentication"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"info", CmdHF14ADesInfo, IfPm3Present, "Tag information"}, + {"enum", CmdHF14ADesEnumApplications, IfPm3Present, "Tries enumerate all applications"}, + {"auth", CmdHF14ADesAuth, IfPm3Present, "Tries a MIFARE DesFire Authentication"}, // {"rdbl", CmdHF14ADesRb, 0, "Read MIFARE DesFire block"}, // {"wrbl", CmdHF14ADesWb, 0, "write MIFARE DesFire block"}, - {NULL, NULL, 0, NULL} + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhfmfdesfire.c b/client/cmdhfmfdesfire.c index 90779722a..7f9ae0758 100644 --- a/client/cmdhfmfdesfire.c +++ b/client/cmdhfmfdesfire.c @@ -220,11 +220,11 @@ static int CmdHF14AMfAESAuth(const char *Cmd) { // Menu Stuff //------------------------------------ static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"dbg", CmdHF14AMfDbg, 0, "Set default debug mode"}, - {"des-auth", CmdHF14AMfDESAuth, 0, "Desfire Authentication"}, - {"ev1-auth", CmdHF14AMfAESAuth, 0, "EV1 Authentication"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"dbg", CmdHF14AMfDbg, IfPm3Present, "Set default debug mode"}, + {"des-auth", CmdHF14AMfDESAuth, IfPm3Present, "Desfire Authentication"}, + {"ev1-auth", CmdHF14AMfAESAuth, IfPm3Present, "EV1 Authentication"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhfmfp.c b/client/cmdhfmfp.c index 6552f8713..3474a12ae 100644 --- a/client/cmdhfmfp.c +++ b/client/cmdhfmfp.c @@ -839,17 +839,17 @@ static int CmdHFMFPNDEF(const char *cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"info", CmdHFMFPInfo, 0, "Info about Mifare Plus tag"}, - {"wrp", CmdHFMFPWritePerso, 0, "Write Perso command"}, - {"initp", CmdHFMFPInitPerso, 0, "Fills all the card's keys"}, - {"commitp", CmdHFMFPCommitPerso, 0, "Move card to SL1 or SL3 mode"}, - {"auth", CmdHFMFPAuth, 0, "Authentication"}, - {"rdbl", CmdHFMFPRdbl, 0, "Read blocks"}, - {"rdsc", CmdHFMFPRdsc, 0, "Read sectors"}, - {"wrbl", CmdHFMFPWrbl, 0, "Write blocks"}, - {"mad", CmdHFMFPMAD, 0, "Checks and prints MAD"}, - {"ndef", CmdHFMFPNDEF, 0, "Prints NDEF records from card"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"info", CmdHFMFPInfo, IfPm3Present, "Info about Mifare Plus tag"}, + {"wrp", CmdHFMFPWritePerso, IfPm3Present, "Write Perso command"}, + {"initp", CmdHFMFPInitPerso, IfPm3Present, "Fills all the card's keys"}, + {"commitp", CmdHFMFPCommitPerso, IfPm3Present, "Move card to SL1 or SL3 mode"}, + {"auth", CmdHFMFPAuth, IfPm3Present, "Authentication"}, + {"rdbl", CmdHFMFPRdbl, IfPm3Present, "Read blocks"}, + {"rdsc", CmdHFMFPRdsc, IfPm3Present, "Read sectors"}, + {"wrbl", CmdHFMFPWrbl, IfPm3Present, "Write blocks"}, + {"mad", CmdHFMFPMAD, IfPm3Present, "Checks and prints MAD"}, + {"ndef", CmdHFMFPNDEF, IfPm3Present, "Prints NDEF records from card"}, {NULL, NULL, 0, NULL} }; diff --git a/client/cmdhfmfu.c b/client/cmdhfmfu.c index 3246960d6..5b30e2259 100644 --- a/client/cmdhfmfu.c +++ b/client/cmdhfmfu.c @@ -2699,21 +2699,21 @@ static int CmdHF14AMfUPwdGen(const char *Cmd) { // Menu Stuff //------------------------------------ static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"dbg", CmdHF14AMfDbg, 0, "Set default debug mode"}, - {"info", CmdHF14AMfUInfo, 0, "Tag information"}, - {"dump", CmdHF14AMfUDump, 0, "Dump Ultralight / Ultralight-C / NTAG tag to binary file"}, - {"restore", CmdHF14AMfURestore, 0, "Restore a dump onto a MFU MAGIC tag"}, - {"eload", CmdHF14AMfUeLoad, 0, "load Ultralight .eml dump file into emulator memory"}, - {"rdbl", CmdHF14AMfURdBl, 0, "Read block"}, - {"wrbl", CmdHF14AMfUWrBl, 0, "Write block"}, - {"cauth", CmdHF14AMfUCAuth, 0, "Authentication - Ultralight C"}, - {"setpwd", CmdHF14AMfUCSetPwd, 0, "Set 3des password - Ultralight-C"}, - {"setuid", CmdHF14AMfUCSetUid, 0, "Set UID - MAGIC tags only"}, - {"sim", CmdHF14AMfUSim, 0, "Simulate Ultralight from emulator memory"}, - {"gen", CmdHF14AMfUGenDiverseKeys, 1, "Generate 3des mifare diversified keys"}, - {"pwdgen", CmdHF14AMfUPwdGen, 1, "Generate pwd from known algos"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"dbg", CmdHF14AMfDbg, IfPm3Present, "Set default debug mode"}, + {"info", CmdHF14AMfUInfo, IfPm3Present, "Tag information"}, + {"dump", CmdHF14AMfUDump, IfPm3Present, "Dump Ultralight / Ultralight-C / NTAG tag to binary file"}, + {"restore", CmdHF14AMfURestore, IfPm3Present, "Restore a dump onto a MFU MAGIC tag"}, + {"eload", CmdHF14AMfUeLoad, IfPm3Present, "load Ultralight .eml dump file into emulator memory"}, + {"rdbl", CmdHF14AMfURdBl, IfPm3Present, "Read block"}, + {"wrbl", CmdHF14AMfUWrBl, IfPm3Present, "Write block"}, + {"cauth", CmdHF14AMfUCAuth, IfPm3Present, "Authentication - Ultralight C"}, + {"setpwd", CmdHF14AMfUCSetPwd, IfPm3Present, "Set 3des password - Ultralight-C"}, + {"setuid", CmdHF14AMfUCSetUid, IfPm3Present, "Set UID - MAGIC tags only"}, + {"sim", CmdHF14AMfUSim, IfPm3Present, "Simulate Ultralight from emulator memory"}, + {"gen", CmdHF14AMfUGenDiverseKeys, AlwaysAvailable, "Generate 3des mifare diversified keys"}, + {"pwdgen", CmdHF14AMfUPwdGen, AlwaysAvailable, "Generate pwd from known algos"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdhftopaz.c b/client/cmdhftopaz.c index a87566d23..74705441f 100644 --- a/client/cmdhftopaz.c +++ b/client/cmdhftopaz.c @@ -504,12 +504,12 @@ static int CmdHFTopazList(const char *Cmd) { static int CmdHelp(const char *Cmd); static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"reader", CmdHFTopazReader, 0, "Act like a Topaz reader"}, - {"sim", CmdHFTopazSim, 0, " -- Simulate Topaz tag"}, - {"sniff", CmdHF14ASniff, 0, "Sniff Topaz reader-tag communication"}, - {"raw", CmdHFTopazCmdRaw, 0, "Send raw hex data to tag"}, - {"list", CmdHFTopazList, 0, "List Topaz history"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"reader", CmdHFTopazReader, IfPm3Present, "Act like a Topaz reader"}, + {"sim", CmdHFTopazSim, IfPm3Present, " -- Simulate Topaz tag"}, + {"sniff", CmdHF14ASniff, IfPm3Present, "Sniff Topaz reader-tag communication"}, + {"raw", CmdHFTopazCmdRaw, IfPm3Present, "Send raw hex data to tag"}, + {"list", CmdHFTopazList, IfPm3Present, "List Topaz history"}, {NULL, NULL, 0, NULL} }; diff --git a/client/cmdhw.c b/client/cmdhw.c index 2a62d3e67..0dece387b 100644 --- a/client/cmdhw.c +++ b/client/cmdhw.c @@ -462,23 +462,23 @@ static int CmdPingNG(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"detectreader", CmdDetectReader, 0, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"}, - {"fpgaoff", CmdFPGAOff, 0, "Set FPGA off"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"detectreader", CmdDetectReader, IfPm3Present, "['l'|'h'] -- Detect external reader field (option 'l' or 'h' to limit to LF or HF)"}, + {"fpgaoff", CmdFPGAOff, IfPm3Present, "Set FPGA off"}, #ifdef WITH_LCD - {"lcd", CmdLCD, 0, " -- Send command/data to LCD"}, - {"lcdreset", CmdLCDReset, 0, "Hardware reset LCD"}, + {"lcd", CmdLCD, IfPm3Present, " -- Send command/data to LCD"}, + {"lcdreset", CmdLCDReset, IfPm3Present, "Hardware reset LCD"}, #endif - {"readmem", CmdReadmem, 0, "[address] -- Read memory at decimal address from flash"}, - {"reset", CmdReset, 0, "Reset the Proxmark3"}, - {"setlfdivisor", CmdSetDivisor, 0, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"}, - {"setmux", CmdSetMux, 0, " -- Set the ADC mux to a specific value"}, - {"tune", CmdTune, 0, "Measure antenna tuning"}, - {"version", CmdVersion, 0, "Show version information about the connected Proxmark3"}, - {"status", CmdStatus, 0, "Show runtime status information about the connected Proxmark3"}, - {"ping", CmdPing, 0, "Test if the Proxmark3 is responding"}, - {"pingng", CmdPingNG, 0, "Test if the Proxmark3 is responsive, using new frame format (experimental)"}, - {NULL, NULL, 0, NULL} + {"readmem", CmdReadmem, IfPm3Present, "[address] -- Read memory at decimal address from flash"}, + {"reset", CmdReset, IfPm3Present, "Reset the Proxmark3"}, + {"setlfdivisor", CmdSetDivisor, IfPm3Present, "<19 - 255> -- Drive LF antenna at 12Mhz/(divisor+1)"}, + {"setmux", CmdSetMux, IfPm3Present, " -- Set the ADC mux to a specific value"}, + {"tune", CmdTune, IfPm3Present, "Measure antenna tuning"}, + {"version", CmdVersion, IfPm3Present, "Show version information about the connected Proxmark3"}, + {"status", CmdStatus, IfPm3Present, "Show runtime status information about the connected Proxmark3"}, + {"ping", CmdPing, IfPm3Present, "Test if the Proxmark3 is responding"}, + {"pingng", CmdPingNG, IfPm3Present, "Test if the Proxmark3 is responsive, using new frame format (experimental)"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlf.c b/client/cmdlf.c index 7725dc327..cf607f2e4 100644 --- a/client/cmdlf.c +++ b/client/cmdlf.c @@ -949,46 +949,46 @@ out: } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"awid", CmdLFAWID, 1, "{ AWID RFIDs... }"}, - {"cotag", CmdLFCOTAG, 1, "{ COTAG CHIPs... }"}, - {"em", CmdLFEM4X, 1, "{ EM4X CHIPs & RFIDs... }"}, - {"fdx", CmdLFFdx, 1, "{ FDX-B RFIDs... }"}, - {"gproxii", CmdLFGuard, 1, "{ Guardall Prox II RFIDs... }"}, - {"hid", CmdLFHID, 1, "{ HID RFIDs... }"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"awid", CmdLFAWID, AlwaysAvailable, "{ AWID RFIDs... }"}, + {"cotag", CmdLFCOTAG, AlwaysAvailable, "{ COTAG CHIPs... }"}, + {"em", CmdLFEM4X, AlwaysAvailable, "{ EM4X CHIPs & RFIDs... }"}, + {"fdx", CmdLFFdx, AlwaysAvailable, "{ FDX-B RFIDs... }"}, + {"gproxii", CmdLFGuard, AlwaysAvailable, "{ Guardall Prox II RFIDs... }"}, + {"hid", CmdLFHID, AlwaysAvailable, "{ HID RFIDs... }"}, #ifdef WITH_HITAG - {"hitag", CmdLFHitag, 1, "{ Hitag CHIPs... }"}, + {"hitag", CmdLFHitag, AlwaysAvailable, "{ Hitag CHIPs... }"}, #endif - {"indala", CmdLFINDALA, 1, "{ Indala RFIDs... }"}, - {"io", CmdLFIO, 1, "{ ioProx RFIDs... }"}, - {"jablotron", CmdLFJablotron, 1, "{ Jablotron RFIDs... }"}, - {"keri", CmdLFKeri, 1, "{ KERI RFIDs... }"}, - {"nedap", CmdLFNedap, 1, "{ Nedap RFIDs... }"}, - {"nexwatch", CmdLFNEXWATCH, 1, "{ NexWatch RFIDs... }"}, - {"noralsy", CmdLFNoralsy, 1, "{ Noralsy RFIDs... }"}, - {"pac", CmdLFPac, 1, "{ PAC/Stanley RFIDs... }"}, - {"paradox", CmdLFParadox, 1, "{ Paradox RFIDs... }"}, - {"pcf7931", CmdLFPCF7931, 1, "{ PCF7931 CHIPs... }"}, - {"presco", CmdLFPresco, 1, "{ Presco RFIDs... }"}, - {"pyramid", CmdLFPyramid, 1, "{ Farpointe/Pyramid RFIDs... }"}, - {"securakey", CmdLFSecurakey, 1, "{ Securakey RFIDs... }"}, - {"ti", CmdLFTI, 1, "{ TI CHIPs... }"}, - {"t55xx", CmdLFT55XX, 1, "{ T55xx CHIPs... }"}, - {"viking", CmdLFViking, 1, "{ Viking RFIDs... }"}, - {"visa2000", CmdLFVisa2k, 1, "{ Visa2000 RFIDs... }"}, - {"config", CmdLFSetConfig, 0, "Set config for LF sampling, bit/sample, decimation, frequency"}, - {"cmdread", CmdLFCommandRead, 0, " <'0' period> <'1' period> ['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"}, - {"read", CmdLFRead, 0, "['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"}, - {"sim", CmdLFSim, 0, "[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 ] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"}, - {"simfsk", CmdLFfskSim, 0, "[c ] [i] [H ] [L ] [d ] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"}, - {"simpsk", CmdLFpskSim, 0, "[1|2|3] [c ] [i] [r ] [d ] \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)"}, - {"sniff", CmdLFSniff, 0, "Sniff LF traffic between reader and tag"}, - {"vchdemod", CmdVchDemod, 1, "['clone'] -- Demodulate samples for VeriChip"}, - {NULL, NULL, 0, NULL} + {"indala", CmdLFINDALA, AlwaysAvailable, "{ Indala RFIDs... }"}, + {"io", CmdLFIO, AlwaysAvailable, "{ ioProx RFIDs... }"}, + {"jablotron", CmdLFJablotron, AlwaysAvailable, "{ Jablotron RFIDs... }"}, + {"keri", CmdLFKeri, AlwaysAvailable, "{ KERI RFIDs... }"}, + {"nedap", CmdLFNedap, AlwaysAvailable, "{ Nedap RFIDs... }"}, + {"nexwatch", CmdLFNEXWATCH, AlwaysAvailable, "{ NexWatch RFIDs... }"}, + {"noralsy", CmdLFNoralsy, AlwaysAvailable, "{ Noralsy RFIDs... }"}, + {"pac", CmdLFPac, AlwaysAvailable, "{ PAC/Stanley RFIDs... }"}, + {"paradox", CmdLFParadox, AlwaysAvailable, "{ Paradox RFIDs... }"}, + {"pcf7931", CmdLFPCF7931, AlwaysAvailable, "{ PCF7931 CHIPs... }"}, + {"presco", CmdLFPresco, AlwaysAvailable, "{ Presco RFIDs... }"}, + {"pyramid", CmdLFPyramid, AlwaysAvailable, "{ Farpointe/Pyramid RFIDs... }"}, + {"securakey", CmdLFSecurakey, AlwaysAvailable, "{ Securakey RFIDs... }"}, + {"ti", CmdLFTI, AlwaysAvailable, "{ TI CHIPs... }"}, + {"t55xx", CmdLFT55XX, AlwaysAvailable, "{ T55xx CHIPs... }"}, + {"viking", CmdLFViking, AlwaysAvailable, "{ Viking RFIDs... }"}, + {"visa2000", CmdLFVisa2k, AlwaysAvailable, "{ Visa2000 RFIDs... }"}, + {"config", CmdLFSetConfig, IfPm3Present, "Set config for LF sampling, bit/sample, decimation, frequency"}, + {"cmdread", CmdLFCommandRead, IfPm3Present, " <'0' period> <'1' period> ['h' 134] \n\t\t-- Modulate LF reader field to send command before read (all periods in microseconds)"}, + {"flexdemod", CmdFlexdemod, AlwaysAvailable, "Demodulate samples for FlexPass"}, + {"read", CmdLFRead, IfPm3Present, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"}, + {"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, IfPm3Present, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"}, + {"simask", CmdLFaskSim, IfPm3Present, "[clock] [invert <1|0>] [biphase/manchester/raw <'b'|'m'|'r'>] [msg separator 's'] [d ] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"}, + {"simfsk", CmdLFfskSim, IfPm3Present, "[c ] [i] [H ] [L ] [d ] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"}, + {"simpsk", CmdLFpskSim, IfPm3Present, "[1|2|3] [c ] [i] [r ] [d ] \n\t\t-- Simulate LF PSK tag from demodbuffer or input"}, + {"simbidir", CmdLFSimBidir, IfPm3Present, "Simulate LF tag (with bidirectional data transmission between reader and tag)"}, + {"sniff", CmdLFSniff, IfPm3Present, "Sniff LF traffic between reader and tag"}, + {"vchdemod", CmdVchDemod, AlwaysAvailable, "['clone'] -- Demodulate samples for VeriChip"}, + {NULL, NULL, NULL, NULL} }; int CmdLF(const char *Cmd) { diff --git a/client/cmdlfawid.c b/client/cmdlfawid.c index fc57e9597..abecb6791 100644 --- a/client/cmdlfawid.c +++ b/client/cmdlfawid.c @@ -491,13 +491,13 @@ static int CmdAWIDBrute(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdAWIDDemod, 0, "demodulate an AWID FSK tag from the GraphBuffer"}, - {"read", CmdAWIDRead, 0, "attempt to read and extract tag data"}, - {"clone", CmdAWIDClone, 0, "clone AWID to T55x7"}, - {"sim", CmdAWIDSim, 0, "simulate AWID tag"}, - {"brute", CmdAWIDBrute, 0, "Bruteforce card number against reader"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdAWIDDemod, IfPm3Present, "demodulate an AWID FSK tag from the GraphBuffer"}, + {"read", CmdAWIDRead, IfPm3Present, "attempt to read and extract tag data"}, + {"clone", CmdAWIDClone, IfPm3Present, "clone AWID to T55x7"}, + {"sim", CmdAWIDSim, IfPm3Present, "simulate AWID tag"}, + {"brute", CmdAWIDBrute, IfPm3Present, "Bruteforce card number against reader"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfcotag.c b/client/cmdlfcotag.c index 79a259b79..2bb92f32a 100644 --- a/client/cmdlfcotag.c +++ b/client/cmdlfcotag.c @@ -103,10 +103,10 @@ static int CmdCOTAGRead(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdCOTAGDemod, 1, "Tries to decode a COTAG signal"}, - {"read", CmdCOTAGRead, 0, "Attempt to read and extract tag data"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdCOTAGDemod, AlwaysAvailable, "Tries to decode a COTAG signal"}, + {"read", CmdCOTAGRead, IfPm3Present, "Attempt to read and extract tag data"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfem4x.c b/client/cmdlfem4x.c index 12c7447a4..be00d01ba 100644 --- a/client/cmdlfem4x.c +++ b/client/cmdlfem4x.c @@ -1464,23 +1464,23 @@ static int CmdEM4x05Info(const char *Cmd) { } 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", CmdEM410xDemod, 1, "demodulate a EM410x tag from the GraphBuffer"}, - {"410x_read", CmdEM410xRead, 0, "attempt to read and extract tag data"}, - {"410x_sim", CmdEM410xSim, 0, "simulate EM410x tag"}, - {"410x_brute", CmdEM410xBrute, 0, "reader bruteforce attack by simulating EM410x tags"}, - {"410x_watch", CmdEM410xWatch, 0, "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_write", CmdEM410xWrite, 0, "write EM410x UID to T5555(Q5) or T55x7 tag"}, - {"4x05_dump", CmdEM4x05Dump, 0, "dump EM4x05/EM4x69 tag"}, - {"4x05_info", CmdEM4x05Info, 0, "tag information EM4x05/EM4x69"}, - {"4x05_read", CmdEM4x05Read, 0, "read word data from EM4x05/EM4x69"}, - {"4x05_write", CmdEM4x05Write, 0, "write word data to EM4x05/EM4x69"}, - {"4x50_dump", CmdEM4x50Dump, 0, "dump EM4x50 tag"}, - {"4x50_read", CmdEM4x50Read, 0, "read word data from EM4x50"}, - {"4x50_write", CmdEM4x50Write, 0, "write word data to EM4x50"}, - {NULL, NULL, 0, NULL} + {"410x_demod", CmdEM410xDemod, AlwaysAvailable, "demodulate a EM410x tag from the GraphBuffer"}, + {"410x_read", CmdEM410xRead, IfPm3Present, "attempt to read and extract tag data"}, + {"410x_sim", CmdEM410xSim, IfPm3Present, "simulate EM410x tag"}, + {"410x_brute", CmdEM410xBrute, IfPm3Present, "reader bruteforce attack by simulating EM410x tags"}, + {"410x_watch", CmdEM410xWatch, IfPm3Present, "watches for EM410x 125/134 kHz tags (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, IfPm3Present, "write EM410x UID to T5555(Q5) or T55x7 tag"}, + {"4x05_dump", CmdEM4x05Dump, IfPm3Present, "dump EM4x05/EM4x69 tag"}, + {"4x05_info", CmdEM4x05Info, IfPm3Present, "tag information EM4x05/EM4x69"}, + {"4x05_read", CmdEM4x05Read, IfPm3Present, "read word data from EM4x05/EM4x69"}, + {"4x05_write", CmdEM4x05Write, IfPm3Present, "write word data to EM4x05/EM4x69"}, + {"4x50_dump", CmdEM4x50Dump, IfPm3Present, "dump EM4x50 tag"}, + {"4x50_read", CmdEM4x50Read, IfPm3Present, "read word data from EM4x50"}, + {"4x50_write", CmdEM4x50Write, IfPm3Present, "write word data to EM4x50"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlffdx.c b/client/cmdlffdx.c index e2a627aae..48155e867 100644 --- a/client/cmdlffdx.c +++ b/client/cmdlffdx.c @@ -320,12 +320,12 @@ static int CmdFdxSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdFdxDemod, 1, "demodulate a FDX-B ISO11784/85 tag from the GraphBuffer"}, - {"read", CmdFdxRead, 0, "attempt to read and extract tag data"}, - {"clone", CmdFdxClone, 0, "clone animal ID tag to T55x7 (or to q5/T5555)"}, - {"sim", CmdFdxSim, 0, "simulate Animal ID tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdFdxDemod, AlwaysAvailable, "demodulate a FDX-B ISO11784/85 tag from the GraphBuffer"}, + {"read", CmdFdxRead, IfPm3Present, "attempt to read and extract tag data"}, + {"clone", CmdFdxClone, IfPm3Present, "clone animal ID tag to T55x7 (or to q5/T5555)"}, + {"sim", CmdFdxSim, IfPm3Present, "simulate Animal ID tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfguard.c b/client/cmdlfguard.c index 8dfa9dddb..663311bbb 100644 --- a/client/cmdlfguard.c +++ b/client/cmdlfguard.c @@ -215,12 +215,12 @@ static int CmdGuardSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdGuardDemod, 1, "demodulate a G Prox II tag from the GraphBuffer"}, - {"read", CmdGuardRead, 0, "attempt to read and extract tag data from the antenna"}, - {"clone", CmdGuardClone, 0, "clone Guardall tag"}, - {"sim", CmdGuardSim, 0, "simulate Guardall tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdGuardDemod, AlwaysAvailable, "demodulate a G Prox II tag from the GraphBuffer"}, + {"read", CmdGuardRead, IfPm3Present, "attempt to read and extract tag data from the antenna"}, + {"clone", CmdGuardClone, IfPm3Present, "clone Guardall tag"}, + {"sim", CmdGuardSim, IfPm3Present, "simulate Guardall tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfhid.c b/client/cmdlfhid.c index 857d79adb..a92f1fc00 100644 --- a/client/cmdlfhid.c +++ b/client/cmdlfhid.c @@ -594,14 +594,14 @@ static int CmdHIDBrute(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdHIDDemod, 0, "demodulate HID Prox tag from the GraphBuffer"}, - {"read", CmdHIDRead, 0, "attempt to read and extract tag data"}, - {"clone", CmdHIDClone, 0, "clone HID to T55x7"}, - {"sim", CmdHIDSim, 0, "simulate HID tag"}, - {"wiegand", CmdHIDWiegand, 1, "convert facility code/card number to Wiegand code"}, - {"brute", CmdHIDBrute, 0, "bruteforce card number against reader"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdHIDDemod, IfPm3Present, "demodulate HID Prox tag from the GraphBuffer"}, + {"read", CmdHIDRead, IfPm3Present, "attempt to read and extract tag data"}, + {"clone", CmdHIDClone, IfPm3Present, "clone HID to T55x7"}, + {"sim", CmdHIDSim, IfPm3Present, "simulate HID tag"}, + {"wiegand", CmdHIDWiegand, AlwaysAvailable, "convert facility code/card number to Wiegand code"}, + {"brute", CmdHIDBrute, IfPm3Present, "bruteforce card number against reader"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfhitag.c b/client/cmdlfhitag.c index a7e2aee26..87b3cad1d 100644 --- a/client/cmdlfhitag.c +++ b/client/cmdlfhitag.c @@ -694,14 +694,14 @@ static int CmdLFHitagDump(const char *Cmd) { */ static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help" }, - {"list", CmdLFHitagList, 0, "List Hitag trace history" }, - {"info", CmdLFHitagInfo, 1, "Tag information" }, - {"reader", CmdLFHitagReader, 1, "Act like a Hitag Reader" }, - {"sim", CmdLFHitagSim, 1, "Simulate Hitag transponder" }, - {"sniff", CmdLFHitagSniff, 1, "Eavesdrop Hitag communication" }, - {"writer", CmdLFHitagWriter, 1, "Act like a Hitag Writer" }, - {"cc", CmdLFHitagCheckChallenges, 1, "Test all challenges" }, + {"help", CmdHelp, AlwaysAvailable, "This help" }, + {"list", CmdLFHitagList, IfPm3Present, "List Hitag trace history" }, + {"info", CmdLFHitagInfo, AlwaysAvailable, "Tag information" }, + {"reader", CmdLFHitagReader, AlwaysAvailable, "Act like a Hitag Reader" }, + {"sim", CmdLFHitagSim, AlwaysAvailable, "Simulate Hitag transponder" }, + {"sniff", CmdLFHitagSniff, AlwaysAvailable, "Eavesdrop Hitag communication" }, + {"writer", CmdLFHitagWriter, AlwaysAvailable, "Act like a Hitag Writer" }, + {"cc", CmdLFHitagCheckChallenges, AlwaysAvailable, "Test all challenges" }, { NULL, NULL, 0, NULL } }; diff --git a/client/cmdlfindala.c b/client/cmdlfindala.c index 10cf0c916..bedf18cb6 100644 --- a/client/cmdlfindala.c +++ b/client/cmdlfindala.c @@ -457,13 +457,13 @@ static int CmdIndalaClone(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdIndalaDemod, 1, "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)"}, - {"read", CmdIndalaRead, 0, "read an Indala Prox tag from the antenna"}, - {"clone", CmdIndalaClone, 0, "clone Indala to T55x7"}, - {"sim", CmdIndalaSim, 0, "simulate Indala tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdIndalaDemod, AlwaysAvailable, "demodulate an indala tag (PSK1) from GraphBuffer"}, + {"altdemod", CmdIndalaDemodAlt, AlwaysAvailable, "alternative method to Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"}, + {"read", CmdIndalaRead, IfPm3Present, "read an Indala Prox tag from the antenna"}, + {"clone", CmdIndalaClone, IfPm3Present, "clone Indala to T55x7"}, + {"sim", CmdIndalaSim, IfPm3Present, "simulate Indala tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfio.c b/client/cmdlfio.c index 6e60f8728..17b6c70b8 100644 --- a/client/cmdlfio.c +++ b/client/cmdlfio.c @@ -257,12 +257,12 @@ static int CmdIOProxClone(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdIOProxDemod, 1, "demodulate an IOProx tag from the GraphBuffer"}, - {"read", CmdIOProxRead, 1, "attempt to read and extract tag data"}, - {"clone", CmdIOProxClone, 0, "clone IOProx to T55x7"}, - {"sim", CmdIOProxSim, 0, "simulate IOProx tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdIOProxDemod, AlwaysAvailable, "demodulate an IOProx tag from the GraphBuffer"}, + {"read", CmdIOProxRead, AlwaysAvailable, "attempt to read and extract tag data"}, + {"clone", CmdIOProxClone, IfPm3Present, "clone IOProx to T55x7"}, + {"sim", CmdIOProxSim, IfPm3Present, "simulate IOProx tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfjablotron.c b/client/cmdlfjablotron.c index cf5230f19..2d69dfff4 100644 --- a/client/cmdlfjablotron.c +++ b/client/cmdlfjablotron.c @@ -193,12 +193,12 @@ static int CmdJablotronSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdJablotronDemod, 1, "Demodulate an Jablotron tag from the GraphBuffer"}, - {"read", CmdJablotronRead, 0, "Attempt to read and extract tag data from the antenna"}, - {"clone", CmdJablotronClone, 0, "clone jablotron tag"}, - {"sim", CmdJablotronSim, 0, "simulate jablotron tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdJablotronDemod, AlwaysAvailable, "Demodulate an Jablotron tag from the GraphBuffer"}, + {"read", CmdJablotronRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"}, + {"clone", CmdJablotronClone, IfPm3Present, "clone jablotron tag"}, + {"sim", CmdJablotronSim, IfPm3Present, "simulate jablotron tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfkeri.c b/client/cmdlfkeri.c index 055eb1a4b..5e03aaa75 100644 --- a/client/cmdlfkeri.c +++ b/client/cmdlfkeri.c @@ -188,12 +188,12 @@ static int CmdKeriSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdKeriDemod, 1, "Demodulate an KERI tag from the GraphBuffer"}, - {"read", CmdKeriRead, 0, "Attempt to read and extract tag data from the antenna"}, - {"clone", CmdKeriClone, 0, "clone KERI to T55x7"}, - {"sim", CmdKeriSim, 0, "simulate KERI tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdKeriDemod, AlwaysAvailable, "Demodulate an KERI tag from the GraphBuffer"}, + {"read", CmdKeriRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"}, + {"clone", CmdKeriClone, IfPm3Present, "clone KERI to T55x7"}, + {"sim", CmdKeriSim, IfPm3Present, "simulate KERI tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfnedap.c b/client/cmdlfnedap.c index 2d95fa008..035c40919 100644 --- a/client/cmdlfnedap.c +++ b/client/cmdlfnedap.c @@ -294,13 +294,13 @@ static int CmdLFNedapChk(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdLFNedapDemod, 0, "demodulate an Nedap tag from the GraphBuffer"}, - {"read", CmdLFNedapRead, 0, "attempt to read and extract tag data"}, + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdLFNedapDemod, IfPm3Present, "demodulate an Nedap tag from the GraphBuffer"}, + {"read", CmdLFNedapRead, IfPm3Present, "attempt to read and extract tag data"}, // {"clone", CmdLFNedapClone,0, " clone nedap tag"}, - {"sim", CmdLFNedapSim, 0, "simulate nedap tag"}, - {"chk", CmdLFNedapChk, 1, "calculate Nedap Checksum "}, - {NULL, NULL, 0, NULL} + {"sim", CmdLFNedapSim, IfPm3Present, "simulate nedap tag"}, + {"chk", CmdLFNedapChk, AlwaysAvailable, "calculate Nedap Checksum "}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfnexwatch.c b/client/cmdlfnexwatch.c index 6adc3bc1a..aeb85974d 100644 --- a/client/cmdlfnexwatch.c +++ b/client/cmdlfnexwatch.c @@ -75,10 +75,10 @@ static int CmdNexWatchRead(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdNexWatchDemod, 1, "Demodulate a NexWatch tag (nexkey, quadrakey) from the GraphBuffer"}, - {"read", CmdNexWatchRead, 0, "Attempt to Read and Extract tag data from the antenna"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdNexWatchDemod, AlwaysAvailable, "Demodulate a NexWatch tag (nexkey, quadrakey) from the GraphBuffer"}, + {"read", CmdNexWatchRead, IfPm3Present, "Attempt to Read and Extract tag data from the antenna"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfnoralsy.c b/client/cmdlfnoralsy.c index 227237936..4ebe7adc6 100644 --- a/client/cmdlfnoralsy.c +++ b/client/cmdlfnoralsy.c @@ -196,12 +196,12 @@ static int CmdNoralsySim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdNoralsyDemod, 1, "Demodulate an Noralsy tag from the GraphBuffer"}, - {"read", CmdNoralsyRead, 0, "Attempt to read and extract tag data from the antenna"}, - {"clone", CmdNoralsyClone, 0, "clone Noralsy to T55x7"}, - {"sim", CmdNoralsySim, 0, "simulate Noralsy tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdNoralsyDemod, AlwaysAvailable, "Demodulate an Noralsy tag from the GraphBuffer"}, + {"read", CmdNoralsyRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"}, + {"clone", CmdNoralsyClone, IfPm3Present, "clone Noralsy to T55x7"}, + {"sim", CmdNoralsySim, IfPm3Present, "simulate Noralsy tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfpac.c b/client/cmdlfpac.c index 333269494..7dc637e89 100644 --- a/client/cmdlfpac.c +++ b/client/cmdlfpac.c @@ -57,10 +57,10 @@ static int CmdPacRead(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdPacDemod, 1, "Demodulate an PAC tag from the GraphBuffer"}, - {"read", CmdPacRead, 0, "Attempt to read and extract tag data from the antenna"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdPacDemod, AlwaysAvailable, "Demodulate an PAC tag from the GraphBuffer"}, + {"read", CmdPacRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfparadox.c b/client/cmdlfparadox.c index 11f295b0c..32bc25c98 100644 --- a/client/cmdlfparadox.c +++ b/client/cmdlfparadox.c @@ -142,12 +142,12 @@ static int CmdParadoxSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdParadoxDemod, 1, "Demodulate a Paradox FSK tag from the GraphBuffer"}, - {"read", CmdParadoxRead, 0, "Attempt to read and Extract tag data from the antenna"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdParadoxDemod, AlwaysAvailable, "Demodulate a Paradox FSK tag from the GraphBuffer"}, + {"read", CmdParadoxRead, IfPm3Present, "Attempt to read and Extract tag data from the antenna"}, // {"clone", CmdParadoxClone, 0, "clone paradox tag"}, - {"sim", CmdParadoxSim, 0, "simulate paradox tag"}, - {NULL, NULL, 0, NULL} + {"sim", CmdParadoxSim, IfPm3Present, "simulate paradox tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfpcf7931.c b/client/cmdlfpcf7931.c index ae93cecef..189bc495e 100644 --- a/client/cmdlfpcf7931.c +++ b/client/cmdlfpcf7931.c @@ -157,11 +157,11 @@ static int CmdLFPCF7931Write(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"read", CmdLFPCF7931Read, 0, "Read content of a PCF7931 transponder"}, - {"write", CmdLFPCF7931Write, 0, "Write data on a PCF7931 transponder."}, - {"config", CmdLFPCF7931Config, 1, "Configure the password, the tags initialization delay and time offsets (optional)"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"read", CmdLFPCF7931Read, IfPm3Present, "Read content of a PCF7931 transponder"}, + {"write", CmdLFPCF7931Write, IfPm3Present, "Write data on a PCF7931 transponder."}, + {"config", CmdLFPCF7931Config, AlwaysAvailable, "Configure the password, the tags initialization delay and time offsets (optional)"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfpresco.c b/client/cmdlfpresco.c index 672d8643a..3a6b23722 100644 --- a/client/cmdlfpresco.c +++ b/client/cmdlfpresco.c @@ -152,11 +152,11 @@ static int CmdPrescoSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"read", CmdPrescoRead, 0, "Attempt to read and Extract tag data"}, - {"clone", CmdPrescoClone, 0, "clone presco tag"}, - {"sim", CmdPrescoSim, 0, "simulate presco tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"read", CmdPrescoRead, IfPm3Present, "Attempt to read and Extract tag data"}, + {"clone", CmdPrescoClone, IfPm3Present, "clone presco tag"}, + {"sim", CmdPrescoSim, IfPm3Present, "simulate presco tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfpyramid.c b/client/cmdlfpyramid.c index 72f129583..b2bc8e33b 100644 --- a/client/cmdlfpyramid.c +++ b/client/cmdlfpyramid.c @@ -276,12 +276,12 @@ static int CmdPyramidSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "this help"}, - {"demod", CmdPyramidDemod, 0, "demodulate a Pyramid FSK tag from the GraphBuffer"}, - {"read", CmdPyramidRead, 0, "attempt to read and extract tag data"}, - {"clone", CmdPyramidClone, 0, "clone pyramid tag"}, - {"sim", CmdPyramidSim, 0, "simulate pyramid tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "this help"}, + {"demod", CmdPyramidDemod, IfPm3Present, "demodulate a Pyramid FSK tag from the GraphBuffer"}, + {"read", CmdPyramidRead, IfPm3Present, "attempt to read and extract tag data"}, + {"clone", CmdPyramidClone, IfPm3Present, "clone pyramid tag"}, + {"sim", CmdPyramidSim, IfPm3Present, "simulate pyramid tag"}, + {NULL, NULL, NULL, NULL} }; int CmdLFPyramid(const char *Cmd) { diff --git a/client/cmdlfsecurakey.c b/client/cmdlfsecurakey.c index 23acad670..3629cd9b0 100644 --- a/client/cmdlfsecurakey.c +++ b/client/cmdlfsecurakey.c @@ -100,12 +100,12 @@ static int CmdSecurakeyRead(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdSecurakeyDemod, 1, "Demodulate an Securakey tag from the GraphBuffer"}, - {"read", CmdSecurakeyRead, 0, "Attempt to read and extract tag data from the antenna"}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdSecurakeyDemod, AlwaysAvailable, "Demodulate an Securakey tag from the GraphBuffer"}, + {"read", CmdSecurakeyRead, IfPm3Present, "Attempt to read and extract tag data from the antenna"}, //{"clone", CmdSecurakeyClone,0, "clone Securakey tag"}, //{"sim", CmdSecurakeydSim, 0, "simulate Securakey tag"}, - {NULL, NULL, 0, NULL} + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlft55xx.c b/client/cmdlft55xx.c index 661d4bdbb..8ec3de2d4 100644 --- a/client/cmdlft55xx.c +++ b/client/cmdlft55xx.c @@ -2302,24 +2302,24 @@ static int CmdT55xxSetDeviceConfig(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"bruteforce", CmdT55xxBruteForce, 0, " [i <*.dic>] Simple bruteforce attack to find password"}, - {"config", CmdT55xxSetConfig, 1, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"}, - {"chk", CmdT55xxChkPwds, 1, "Check passwords"}, - {"detect", CmdT55xxDetect, 1, "[1] Try detecting the tag modulation from reading the configuration block."}, - {"deviceconfig", CmdT55xxSetDeviceConfig, 1, "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"}, - {"dump", CmdT55xxDump, 0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"}, - {"info", CmdT55xxInfo, 1, "[1] Show T55x7 configuration data (page 0/ blk 0)"}, - {"read", CmdT55xxReadBlock, 0, "b 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)"}, - {"recoverpw", CmdT55xxRecoverPW, 0, "[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"}, - {"trace", CmdT55xxReadTrace, 1, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"}, - {"wakeup", CmdT55xxWakeUp, 0, "Send AOR wakeup command"}, - {"wipe", CmdT55xxWipe, 0, "[q] Wipe a T55xx tag and set defaults (will destroy any data on tag)"}, - {"write", CmdT55xxWriteBlock, 0, "b d p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"bruteforce", CmdT55xxBruteForce, IfPm3Present, " [i <*.dic>] Simple bruteforce attack to find password"}, + {"config", CmdT55xxSetConfig, AlwaysAvailable, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"}, + {"chk", CmdT55xxChkPwds, AlwaysAvailable, "Check passwords"}, + {"detect", CmdT55xxDetect, AlwaysAvailable, "[1] Try detecting the tag modulation from reading the configuration block."}, + {"deviceconfig", CmdT55xxSetDeviceConfig, AlwaysAvailable, "Set/Get T55XX device configuration (startgap, writegap, write0, write1, readgap"}, + {"p1detect", CmdT55xxDetectPage1, AlwaysAvailable, "[1] Try detecting if this is a t55xx tag by reading page 1"}, + {"dump", CmdT55xxDump, IfPm3Present, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"}, + {"info", CmdT55xxInfo, AlwaysAvailable, "[1] Show T55x7 configuration data (page 0/ blk 0)"}, + {"read", CmdT55xxReadBlock, IfPm3Present, "b p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"}, + {"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, IfPm3Present, "[password] Try to recover from bad password write from a cloner. Only use on PW protected chips!"}, + {"special", special, IfPm3Present, "Show block changes with 64 different offsets"}, + {"trace", CmdT55xxReadTrace, AlwaysAvailable, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"}, + {"wakeup", CmdT55xxWakeUp, IfPm3Present, "Send AOR wakeup command"}, + {"wipe", CmdT55xxWipe, IfPm3Present, "[q] Wipe a T55xx tag and set defaults (will destroy any data on tag)"}, + {"write", CmdT55xxWriteBlock, IfPm3Present, "b d p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfti.c b/client/cmdlfti.c index 3b12116b6..0889be200 100644 --- a/client/cmdlfti.c +++ b/client/cmdlfti.c @@ -299,11 +299,11 @@ static int CmdTIWrite(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdTIDemod, 1, "Demodulate raw bits for TI-type LF tag from the GraphBuffer"}, - {"read", CmdTIRead, 0, "Read and decode a TI 134 kHz tag"}, - {"write", CmdTIWrite, 0, "Write new data to a r/w TI 134 kHz tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdTIDemod, AlwaysAvailable, "Demodulate raw bits for TI-type LF tag from the GraphBuffer"}, + {"read", CmdTIRead, IfPm3Present, "Read and decode a TI 134 kHz tag"}, + {"write", CmdTIWrite, IfPm3Present, "Write new data to a r/w TI 134 kHz tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfviking.c b/client/cmdlfviking.c index 66eda8219..3f6e91eae 100644 --- a/client/cmdlfviking.c +++ b/client/cmdlfviking.c @@ -121,12 +121,12 @@ static int CmdVikingSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdVikingDemod, 1, "Demodulate a Viking tag from the GraphBuffer"}, - {"read", CmdVikingRead, 0, "Attempt to read and Extract tag data from the antenna"}, - {"clone", CmdVikingClone, 0, "<8 digit ID number> clone viking tag"}, - {"sim", CmdVikingSim, 0, "<8 digit ID number> simulate viking tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdVikingDemod, AlwaysAvailable, "Demodulate a Viking tag from the GraphBuffer"}, + {"read", CmdVikingRead, IfPm3Present, "Attempt to read and Extract tag data from the antenna"}, + {"clone", CmdVikingClone, IfPm3Present, "<8 digit ID number> clone viking tag"}, + {"sim", CmdVikingSim, IfPm3Present, "<8 digit ID number> simulate viking tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdlfvisa2000.c b/client/cmdlfvisa2000.c index 424a28106..348a9adeb 100644 --- a/client/cmdlfvisa2000.c +++ b/client/cmdlfvisa2000.c @@ -203,12 +203,12 @@ static int CmdVisa2kSim(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"demod", CmdVisa2kDemod, 1, "demodulate an VISA2000 tag from the GraphBuffer"}, - {"read", CmdVisa2kRead, 0, "attempt to read and extract tag data from the antenna"}, - {"clone", CmdVisa2kClone, 0, "clone Visa2000 to t55x7"}, - {"sim", CmdVisa2kSim, 0, "simulate Visa2000 tag"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"demod", CmdVisa2kDemod, AlwaysAvailable, "demodulate an VISA2000 tag from the GraphBuffer"}, + {"read", CmdVisa2kRead, IfPm3Present, "attempt to read and extract tag data from the antenna"}, + {"clone", CmdVisa2kClone, IfPm3Present, "clone Visa2000 to t55x7"}, + {"sim", CmdVisa2kSim, IfPm3Present, "simulate Visa2000 tag"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdmain.c b/client/cmdmain.c index 45a5139b2..2349dac9b 100644 --- a/client/cmdmain.c +++ b/client/cmdmain.c @@ -42,26 +42,26 @@ static int CmdRev(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help. Use ' help' for details of a particular command."}, - {"analyse", CmdAnalyse, 1, "{ Analyse utils... }"}, - {"data", CmdData, 1, "{ Plot window / data buffer manipulation... }"}, - {"hf", CmdHF, 1, "{ High Frequency commands... }"}, - {"hw", CmdHW, 1, "{ Hardware commands... }"}, - {"lf", CmdLF, 1, "{ Low Frequency commands... }"}, - {"emv", CmdEMV, 1, "{ EMV iso14443 and iso7816... }"}, - {"rem", CmdRem, 1, "{ Add text to row in log file }"}, - {"reveng", CmdRev, 1, "{ Crc calculations from the RevEng software... }"}, - {"script", CmdScript, 1, "{ Scripting commands }"}, - {"trace", CmdTrace, 1, "{ Trace manipulation... }"}, + {"help", CmdHelp, AlwaysAvailable, "This help. Use ' help' for details of a particular command."}, + {"analyse", CmdAnalyse, AlwaysAvailable, "{ Analyse utils... }"}, + {"data", CmdData, AlwaysAvailable, "{ Plot window / data buffer manipulation... }"}, + {"hf", CmdHF, AlwaysAvailable, "{ High Frequency commands... }"}, + {"hw", CmdHW, AlwaysAvailable, "{ Hardware commands... }"}, + {"lf", CmdLF, AlwaysAvailable, "{ Low Frequency commands... }"}, + {"emv", CmdEMV, AlwaysAvailable, "{ EMV iso14443 and iso7816... }"}, + {"rem", CmdRem, AlwaysAvailable, "{ Add text to row in log file }"}, + {"reveng", CmdRev, AlwaysAvailable, "{ Crc calculations from the RevEng software... }"}, + {"script", CmdScript, AlwaysAvailable, "{ Scripting commands }"}, + {"trace", CmdTrace, AlwaysAvailable, "{ Trace manipulation... }"}, #ifdef WITH_FLASH - {"mem", CmdFlashMem, 1, "{ Flash Memory manipulation... }"}, + {"mem", CmdFlashMem, AlwaysAvailable, "{ Flash Memory manipulation... }"}, #endif #ifdef WITH_SMARTCARD - {"sc", CmdSmartcard, 1, "{ Smart card ISO7816 commands... }"}, + {"sc", CmdSmartcard, AlwaysAvailable, "{ Smart card ISO7816 commands... }"}, #endif - {"quit", CmdQuit, 1, ""}, - {"exit", CmdQuit, 1, "Exit program"}, - {NULL, NULL, 0, NULL} + {"quit", CmdQuit, AlwaysAvailable, ""}, + {"exit", CmdQuit, AlwaysAvailable, "Exit program"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdmain.h b/client/cmdmain.h index 0bf5ff1e7..f5e9bab68 100644 --- a/client/cmdmain.h +++ b/client/cmdmain.h @@ -32,14 +32,8 @@ #include "cmdcrc.h" #include "cmdanalyse.h" #include "emv/cmdemv.h" // EMV - -#ifdef WITH_FLASH #include "cmdflashmem.h" // rdv40 flashmem commands -#endif - -#ifdef WITH_SMARTCARD #include "cmdsmartcard.h" // rdv40 smart card ISO7816 commands -#endif int CommandReceived(char *Cmd); command_t *getTopLevelCommandTable(void); diff --git a/client/cmdparser.c b/client/cmdparser.c index bb24e532b..b205a0d1f 100644 --- a/client/cmdparser.c +++ b/client/cmdparser.c @@ -17,11 +17,27 @@ #include "proxmark3.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[]) { if (Commands[0].Name == NULL) return; int i = 0; 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); ++i; } @@ -46,7 +62,7 @@ int CmdsParse(const command_t Commands[], const char *Cmd) { int i = 0; while (Commands[i].Name) { if (0 == strcmp(Commands[i].Name, cmd_name)) { - if (session.pm3_present || Commands[i].Offline) { + if (Commands[i].IsAvailable()) { break; } else { 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; 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; matches++; } @@ -94,33 +110,33 @@ void dumpCommandsRecursive(const command_t cmds[], int markdown) { // First, dump all single commands, which are not a container for // other commands if (markdown) { - PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s\n", w_cmd, "command", w_off, "offline", "description"); - PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s\n", w_cmd, "-------", w_off, "-------", "-----------"); + PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s", w_cmd, "command", w_off, "offline", "description"); + PrintAndLogEx(NORMAL, "|%-*s|%-*s|%s", w_cmd, "-------", w_off, "-------", "-----------"); } else { - PrintAndLogEx(NORMAL, "%-*s|%-*s|%s\n", w_cmd, "command", w_off, "offline", "description"); - PrintAndLogEx(NORMAL, "%-*s|%-*s|%s\n", w_cmd, "-------", w_off, "-------", "-----------"); + PrintAndLogEx(NORMAL, "%-*s|%-*s|%s", w_cmd, "command", w_off, "offline", "description"); + PrintAndLogEx(NORMAL, "%-*s|%-*s|%s", w_cmd, "-------", w_off, "-------", "-----------"); } while (cmds[i].Name) { const char *cmd_offline = "N"; if (cmds[i].Help[0] == '{' && ++i) continue; - if (cmds[i].Offline) + if (cmds[i].IsAvailable()) cmd_offline = "Y"; 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 - 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; } - PrintAndLogEx(NORMAL, "\n\n"); + PrintAndLogEx(NORMAL, "\n"); i = 0; // Then, print the categories. These will go into subsections with their own tables while (cmds[i].Name) { 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}; snprintf(currentparent, sizeof currentparent, "%s%s ", parent, cmds[i].Name); diff --git a/client/cmdparser.h b/client/cmdparser.h index 722fd0d21..9b7e9e734 100644 --- a/client/cmdparser.h +++ b/client/cmdparser.h @@ -14,12 +14,15 @@ typedef struct command_s { const char *Name; int (*Parse)(const char *Cmd); - int Offline; + bool (*IsAvailable)(void); const char *Help; } command_t; - // 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 void CmdsHelp(const command_t Commands[]); // Print each command in the command array without help diff --git a/client/cmdscript.c b/client/cmdscript.c index ba581290f..8880e18fd 100644 --- a/client/cmdscript.c +++ b/client/cmdscript.c @@ -167,10 +167,10 @@ static int CmdScriptRun(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdScriptList, 1, "List available scripts"}, - {"run", CmdScriptRun, 1, " -- Execute a script"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"list", CmdScriptList, AlwaysAvailable, "List available scripts"}, + {"run", CmdScriptRun, AlwaysAvailable, " -- Execute a script"}, + {NULL, NULL, NULL, NULL} }; /** diff --git a/client/cmdsmartcard.c b/client/cmdsmartcard.c index b5b303534..4b41f7201 100644 --- a/client/cmdsmartcard.c +++ b/client/cmdsmartcard.c @@ -1118,15 +1118,15 @@ static int CmdSmartBruteforceSFI(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdSmartList, 0, "List ISO 7816 history"}, - {"info", CmdSmartInfo, 1, "Tag information"}, - {"reader", CmdSmartReader, 1, "Act like an IS07816 reader"}, - {"raw", CmdSmartRaw, 1, "Send raw hex data to tag"}, - {"upgrade", CmdSmartUpgrade, 1, "Upgrade sim module firmware"}, - {"setclock", CmdSmartSetClock, 1, "Set clock speed"}, - {"brute", CmdSmartBruteforceSFI, 1, "Bruteforce SFI"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"list", CmdSmartList, IfPm3Present, "List ISO 7816 history"}, + {"info", CmdSmartInfo, AlwaysAvailable, "Tag information"}, + {"reader", CmdSmartReader, AlwaysAvailable, "Act like an IS07816 reader"}, + {"raw", CmdSmartRaw, AlwaysAvailable, "Send raw hex data to tag"}, + {"upgrade", CmdSmartUpgrade, AlwaysAvailable, "Upgrade sim module firmware"}, + {"setclock", CmdSmartSetClock, AlwaysAvailable, "Set clock speed"}, + {"brute", CmdSmartBruteforceSFI, AlwaysAvailable, "Bruteforce SFI"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/cmdtrace.c b/client/cmdtrace.c index a329f8931..e50a2b2c4 100644 --- a/client/cmdtrace.c +++ b/client/cmdtrace.c @@ -568,11 +568,11 @@ static int CmdTraceSave(const char *Cmd) { } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdTraceList, 1, "List protocol data in trace buffer"}, - {"load", CmdTraceLoad, 1, "Load trace from file"}, - {"save", CmdTraceSave, 1, "Save trace buffer to file"}, - {NULL, NULL, 0, NULL} + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"list", CmdTraceList, AlwaysAvailable, "List protocol data in trace buffer"}, + {"load", CmdTraceLoad, AlwaysAvailable, "Load trace from file"}, + {"save", CmdTraceSave, AlwaysAvailable, "Save trace buffer to file"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/emv/cmdemv.c b/client/emv/cmdemv.c index abd6467c3..fa7f35e3a 100644 --- a/client/emv/cmdemv.c +++ b/client/emv/cmdemv.c @@ -1940,28 +1940,28 @@ out: } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"exec", CmdEMVExec, 0, "Executes EMV contactless transaction."}, - {"pse", CmdEMVPPSE, 0, "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."}, - {"select", CmdEMVSelect, 0, "Select applet."}, - {"gpo", CmdEMVGPO, 0, "Execute GetProcessingOptions."}, - {"readrec", CmdEMVReadRecord, 0, "Read files from card."}, - {"genac", CmdEMVAC, 0, "Generate ApplicationCryptogram."}, - {"challenge", CmdEMVGenerateChallenge, 0, "Generate challenge."}, - {"intauth", CmdEMVInternalAuthenticate, 0, "Internal authentication."}, - {"scan", CmdEMVScan, 0, "Scan EMV card and save it contents to json file for emulator."}, - {"test", CmdEMVTest, 0, "Crypto logic test."}, + {"help", CmdHelp, AlwaysAvailable, "This help"}, + {"exec", CmdEMVExec, IfPm3Present, "Executes EMV contactless transaction."}, + {"pse", CmdEMVPPSE, IfPm3Present, "Execute PPSE. It selects 2PAY.SYS.DDF01 or 1PAY.SYS.DDF01 directory."}, + {"search", CmdEMVSearch, IfPm3Present, "Try to select all applets from applets list and print installed applets."}, + {"select", CmdEMVSelect, IfPm3Present, "Select applet."}, + {"gpo", CmdEMVGPO, IfPm3Present, "Execute GetProcessingOptions."}, + {"readrec", CmdEMVReadRecord, IfPm3Present, "Read files from card."}, + {"genac", CmdEMVAC, IfPm3Present, "Generate ApplicationCryptogram."}, + {"challenge", CmdEMVGenerateChallenge, IfPm3Present, "Generate challenge."}, + {"intauth", CmdEMVInternalAuthenticate, IfPm3Present, "Internal authentication."}, + {"scan", CmdEMVScan, IfPm3Present, "Scan EMV card and save it contents to json file for emulator."}, + {"test", CmdEMVTest, IfPm3Present, "Crypto logic test."}, /* - {"getrng", CmdEMVGetrng, 0, "get random number from terminal"}, - {"eload", CmdEmvELoad, 0, "load EMV tag into device"}, - {"dump", CmdEmvDump, 0, "dump EMV tag values"}, - {"sim", CmdEmvSim, 0, "simulate EMV tag"}, - {"clone", CmdEmvClone, 0, "clone an EMV tag"}, + {"getrng", CmdEMVGetrng, IfPm3Present, "get random number from terminal"}, + {"eload", CmdEmvELoad, IfPm3Present, "load EMV tag into device"}, + {"dump", CmdEmvDump, IfPm3Present, "dump EMV tag values"}, + {"sim", CmdEmvSim, IfPm3Present, "simulate EMV tag"}, + {"clone", CmdEmvClone, IfPm3Present, "clone an EMV tag"}, */ - {"list", CmdEMVList, 0, "List ISO7816 history"}, - {"roca", CmdEMVRoca, 0, "Extract public keys and run ROCA test"}, - {NULL, NULL, 0, NULL} + {"list", CmdEMVList, IfPm3Present, "List ISO7816 history"}, + {"roca", CmdEMVRoca, IfPm3Present, "Extract public keys and run ROCA test"}, + {NULL, NULL, NULL, NULL} }; static int CmdHelp(const char *Cmd) { diff --git a/client/flasher.c b/client/flasher.c index 782888102..430a411af 100644 --- a/client/flasher.c +++ b/client/flasher.c @@ -50,6 +50,7 @@ int main(int argc, char **argv) { if (session.stdinOnTTY && session.stdoutOnTTY) session.supports_colors = true; #endif + session.help_dump_mode = false; if (argc < 3) { usage(argv[0]); diff --git a/client/proxmark3.c b/client/proxmark3.c index 2a6ff7aa4..1dde3d61e 100644 --- a/client/proxmark3.c +++ b/client/proxmark3.c @@ -220,12 +220,14 @@ main_loop(char *script_cmds_file, char *script_cmd) { } static void dumpAllHelp(int markdown) { + session.help_dump_mode = true; 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, "Check column \"offline\" for their availability.\n"); PrintAndLogEx(NORMAL, "\n"); command_t *cmds = getTopLevelCommandTable(); dumpCommandsRecursive(cmds, markdown); + session.help_dump_mode = false; } static char *my_executable_path = NULL; @@ -291,6 +293,7 @@ int main(int argc, char *argv[]) { srand(time(0)); session.pm3_present = false; + session.help_dump_mode = false; bool waitCOMPort = false; bool addLuaExec = false; char *script_cmds_file = NULL; diff --git a/client/ui.h b/client/ui.h index 5ab30b3e1..4f70b54cd 100644 --- a/client/ui.h +++ b/client/ui.h @@ -29,6 +29,7 @@ typedef struct { bool stdoutOnTTY; bool supports_colors; bool pm3_present; + bool help_dump_mode; } session_arg_t; extern session_arg_t session;