rfidrig/proxmark3
0
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2026-05-12 11:18:11 -07:00
Code Issues Packages Projects Releases Wiki Activity

begin of dynamic capabilities handling in client

Browse Source
This commit is contained in:
Philippe Teuwen
2019-05-01 20:48:15 +02:00
parent 5a6929c533
commit ca43afa19b
55 changed files with 554 additions and 536 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/cmdanalyse.c
+10 -10
View File
@@ -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) {
client/cmddata.c
+37 -37
View File
@@ -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, "<digits> -- 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, "[<a|f|n|p>] Detect ASK, FSK, NRZ, PSK clock rate of wave in GraphBuffer"},
{"fsktonrz", CmdFSKToNRZ, 1, "Convert fsk2 to nrz wave for alternate fsk demodulating (for weak fsk)"},
{"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, "<digits> -- 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, "[<a|f|n|p>] 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, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
{"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
{"hex2bin", Cmdhex2bin, 1, "<hexadecimal> -- Converts hexadecimal to binary"},
{"hide", CmdHide, 1, "Hide graph window"},
{"hpf", CmdHpf, 1, "Remove DC offset from trace"},
{"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},
{"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},
{"rtrim", CmdRtrim, 1, "<location to end trace> -- Trim samples from right of trace"},
{"mtrim", CmdMtrim, 1, "<start> <stop> -- Trim out samples from the specified start to the specified stop"},
{"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] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"},
{"rawdemod", CmdRawDemod, 1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},
{"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
{"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
{"setgraphmarkers", CmdSetGraphMarkers, 1, "[orange_marker] [blue_marker] (in graph window)"},
{"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
{"setdebugmode", CmdSetDebugMode, 1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
{"shiftgraphzero", CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"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, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
{"hexsamples", CmdHexsamples, IfPm3Present, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
{"hex2bin", Cmdhex2bin, AlwaysAvailable, "<hexadecimal> -- Converts hexadecimal to binary"},
{"hide", CmdHide, AlwaysAvailable, "Hide graph window"},
{"hpf", CmdHpf, AlwaysAvailable, "Remove DC offset from trace"},
{"load", CmdLoad, AlwaysAvailable, "<filename> -- Load trace (to graph window"},
{"ltrim", CmdLtrim, AlwaysAvailable, "<samples> -- Trim samples from left of trace"},
{"rtrim", CmdRtrim, AlwaysAvailable, "<location to end trace> -- Trim samples from right of trace"},
{"mtrim", CmdMtrim, AlwaysAvailable, "<start> <stop> -- 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] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"},
{"rawdemod", CmdRawDemod, AlwaysAvailable, "[modulation] ... <options> -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, "<filename> -- Save trace (from graph window)"},
{"setgraphmarkers", CmdSetGraphMarkers, AlwaysAvailable, "[orange_marker] [blue_marker] (in graph window)"},
{"scale", CmdScale, AlwaysAvailable, "<int> -- Set cursor display scale"},
{"setdebugmode", CmdSetDebugMode, AlwaysAvailable, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
{"shiftgraphzero", CmdGraphShiftZero, AlwaysAvailable, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
{"dirthreshold", CmdDirectionalThreshold, AlwaysAvailable, "<thres up> <thres down> -- 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) {
client/cmdflashmem.c
+8 -8
View File
@@ -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) {
client/cmdhf.c
+19 -19
View File
@@ -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, "<samples to skip (10000)> <triggers to skip (1)> 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, "<samples to skip (10000)> <triggers to skip (1)> Generic HF Sniff"},
{NULL, NULL, NULL, NULL}
};
int CmdHF(const char *Cmd) {
client/cmdhf14a.c
+12 -12
View File
@@ -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, "<n> Collect n>0 ISO14443-a UIDs in one go"},
{"sim", CmdHF14ASim, 0, "<UID> -- 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, "<n> Collect n>0 ISO14443-a UIDs in one go"},
{"sim", CmdHF14ASim, IfPm3Present, "<UID> -- 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) {
client/cmdhf14b.c
+11 -11
View File
@@ -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) {
client/cmdhf15.c
+16 -16
View File
@@ -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) {
client/cmdhfepa.c
+4 -4
View File
@@ -157,10 +157,10 @@ static int CmdHFEPAPACEReplay(const char *Cmd) {
}
static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"},
{"cnonces", CmdHFEPACollectPACENonces, 0, "<m> <n> <d> Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"},
{"preplay", CmdHFEPAPACEReplay, 0, "<mse> <get> <map> <pka> <ma> Perform PACE protocol by replaying given APDUs"},
{NULL, NULL, 0, NULL}
{"help", CmdHelp, AlwaysAvailable, "This help"},
{"cnonces", CmdHFEPACollectPACENonces, IfPm3Present, "<m> <n> <d> Acquire n>0 encrypted PACE nonces of size m>0 with d sec pauses"},
{"preplay", CmdHFEPAPACEReplay, IfPm3Present, "<mse> <get> <map> <pka> <ma> Perform PACE protocol by replaying given APDUs"},
{NULL, NULL, NULL, NULL}
};
static int CmdHelp(const char *Cmd) {
client/cmdhffelica.c
+9 -9
View File
@@ -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, "<UID> -- 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, "<UID> -- 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, "<NDEF2> - only reply to poll request"},
{"litedump", CmdHFFelicaDumpLite, 0, "Wait for and try dumping FelicaLite"},
{NULL, NULL, 0, NULL}
{"litesim", CmdHFFelicaSimLite, IfPm3Present, "<NDEF2> - only reply to poll request"},
{"litedump", CmdHFFelicaDumpLite, IfPm3Present, "Wait for and try dumping FelicaLite"},
{NULL, NULL, NULL, NULL}
};
static int CmdHelp(const char *Cmd) {
client/cmdhffido.c
+6 -6
View File
@@ -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}
};
client/cmdhficlass.c
+21 -21
View File
@@ -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 <fname>] Decrypt tagdump" },
{"dump", CmdHFiClassReader_Dump, 0, "[options..] Authenticate and Dump iClass tag's AA1"},
{"eload", CmdHFiClassELoad, 0, "[f <fname>] (experimental) Load data into iClass emulator memory"},
{"encryptblk", CmdHFiClassEncryptBlk, 1, "<BlockData> 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, "<mac> 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 <fname>] Decrypt tagdump" },
{"dump", CmdHFiClassReader_Dump, IfPm3Present, "[options..] Authenticate and Dump iClass tag's AA1"},
{"eload", CmdHFiClassELoad, IfPm3Present, "[f <fname>] (experimental) Load data into iClass emulator memory"},
{"encryptblk", CmdHFiClassEncryptBlk, AlwaysAvailable, "<BlockData> 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, "<mac> 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) {
client/cmdhflegic.c
+14 -14
View File
@@ -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) {
client/cmdhfmf.c
+40 -40
View File
@@ -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) {
client/cmdhfmfdes.c
+5 -5
View File
@@ -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) {
client/cmdhfmfdesfire.c
+5 -5
View File
@@ -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) {
client/cmdhfmfp.c
+11 -11
View File
@@ -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}
};
client/cmdhfmfu.c
+15 -15
View File
@@ -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) {
client/cmdhftopaz.c
+6 -6
View File
@@ -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, "<UID> -- 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, "<UID> -- 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}
};
client/cmdhw.c
+15 -15
View File
@@ -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, "<HEX command> <count> -- Send command/data to LCD"},
{"lcdreset", CmdLCDReset, 0, "Hardware reset LCD"},
{"lcd", CmdLCD, IfPm3Present, "<HEX command> <count> -- 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, "<loraw|hiraw|lopkd|hipkd> -- 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, "<loraw|hiraw|lopkd|hipkd> -- 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) {
client/cmdlf.c
+38 -38
View File
@@ -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, "<off period> <'0' period> <'1' period> <command> ['h' 134] \n\t\t-- Modulate LF reader field to send command before read (all periods in microseconds)"},
{"flexdemod", CmdFlexdemod, 1, "Demodulate samples for FlexPass"},
{"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 <hexdata>] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"},
{"simfsk", CmdLFfskSim, 0, "[c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"},
{"simpsk", CmdLFpskSim, 0, "[1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>] \n\t\t-- Simulate LF PSK tag from demodbuffer or input"},
{"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, "<off period> <'0' period> <'1' period> <command> ['h' 134] \n\t\t-- Modulate LF reader field to send command before read (all periods in microseconds)"},
{"flexdemod", CmdFlexdemod, 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 <hexdata>] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"},
{"simfsk", CmdLFfskSim, IfPm3Present, "[c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"},
{"simpsk", CmdLFpskSim, IfPm3Present, "[1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>] \n\t\t-- Simulate LF PSK tag from demodbuffer or input"},
{"simbidir", CmdLFSimBidir, 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) {

Some files were not shown because too many files have changed in this diff Show More