RfidResearchGroup/proxmark3
1
1
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-02-28 10:05:13 +08:00
Code Issues Projects Releases Packages Wiki Activity

CHG: replace 'samples:' with 'Examples:', unify some usage text

Browse source
This commit is contained in:
Brian Pow 2018-02-09 21:18:54 +08:00
parent a02ec72f50
commit b1d414c680
32 changed files with 306 additions and 258 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
client/cmdanalyse.c
View file

@ -20,7 +20,7 @@ int usage_analyse_lcr(void) {
PrintAndLog(" h This help");
PrintAndLog(" <bytes> bytes to calc missing XOR in a LCR");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" analyse lcr 04008064BA");
PrintAndLog("expected output: Target (BA) requires final LRC XOR byte value: 5A");
return 0;
@ -36,7 +36,7 @@ int usage_analyse_checksum(void) {
PrintAndLog(" b <bytes> bytes to calc missing XOR in a LCR");
PrintAndLog(" m <mask> bit mask to limit the outpuyt");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" analyse chksum b 137AF00A0A0D m FF");
PrintAndLog("expected output: 0x61");
return 0;
@ -49,7 +49,7 @@ int usage_analyse_crc(void){
PrintAndLog(" h This help");
PrintAndLog(" <bytes> bytes to calc crc");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" analyse crc 137AF00A0A0D");
return 0;
}
@ -62,7 +62,7 @@ int usage_analyse_nuid(void){
PrintAndLog(" h This help");
PrintAndLog(" <bytes> input bytes (14 hexsymbols)");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" analyse nuid 11223344556677");
return 0;
}

28
client/cmddata.c
View file

@ -33,7 +33,7 @@ int usage_data_manrawdecode(void){
PrintAndLog(" [invert] invert output");
PrintAndLog(" [maxErr] set number of errors allowed (default = 20)");
PrintAndLog("");
PrintAndLog(" sample: data manrawdecode = decode manchester bitstream from the demodbuffer");
PrintAndLog(" Example: data manrawdecode = decode manchester bitstream from the demodbuffer");
return 0;
}
int usage_data_biphaserawdecode(void){
@ -46,8 +46,8 @@ int usage_data_biphaserawdecode(void){
PrintAndLog(" [invert <0|1>], set to 1 to invert output");
PrintAndLog(" [maxErr int], set max errors tolerated - default=20");
PrintAndLog("");
PrintAndLog(" sample: data biphaserawdecode = decode biphase bitstream from the demodbuffer");
PrintAndLog(" sample: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output");
PrintAndLog(" Example: data biphaserawdecode = decode biphase bitstream from the demodbuffer");
PrintAndLog(" Example: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output");
return 0;
}
int usage_data_rawdemod(void){
@ -57,7 +57,7 @@ int usage_data_rawdemod(void){
PrintAndLog(" <help> as 'h', prints the help for the specific modulation");
PrintAndLog(" <options> see specific modulation help for optional parameters");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod fs h = print help specific to fsk demod");
PrintAndLog(" Example: data rawdemod fs h = print help specific to fsk demod");
PrintAndLog(" : data rawdemod fs = demod GraphBuffer using: fsk - autodetect");
PrintAndLog(" : data rawdemod ab = demod GraphBuffer using: ask/biphase - autodetect");
PrintAndLog(" : data rawdemod am = demod GraphBuffer using: ask/manchester - autodetect");
@ -76,7 +76,7 @@ int usage_data_rawdemod_am(void){
PrintAndLog(" [set maximum Samples to read], default = 32768 (512 bits at rf/64)");
PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod am = demod an ask/manchester tag from GraphBuffer");
PrintAndLog(" Example: data rawdemod am = demod an ask/manchester tag from GraphBuffer");
PrintAndLog(" : data rawdemod am 32 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32");
PrintAndLog(" : data rawdemod am 32 1 = demod an ask/manchester tag from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data rawdemod am 1 = demod an ask/manchester tag from GraphBuffer while inverting data");
@ -97,7 +97,7 @@ int usage_data_rawdemod_ab(void){
PrintAndLog("");
PrintAndLog(" NOTE: --invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod ab = demod an ask/biph tag from GraphBuffer");
PrintAndLog(" Example: data rawdemod ab = demod an ask/biph tag from GraphBuffer");
PrintAndLog(" : data rawdemod ab 0 a = demod an ask/biph tag from GraphBuffer, amplified");
PrintAndLog(" : data rawdemod ab 1 32 = demod an ask/biph tag from GraphBuffer using an offset of 1 and a clock of RF/32");
PrintAndLog(" : data rawdemod ab 0 32 1 = demod an ask/biph tag from GraphBuffer using a clock of RF/32 and inverting data");
@ -114,7 +114,7 @@ int usage_data_rawdemod_ar(void){
PrintAndLog(" [set maximum Samples to read], default = 32768 (1024 bits at rf/64)");
PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod ar = demod an ask tag from GraphBuffer");
PrintAndLog(" Example: data rawdemod ar = demod an ask tag from GraphBuffer");
PrintAndLog(" : data rawdemod ar a = demod an ask tag from GraphBuffer, amplified");
PrintAndLog(" : data rawdemod ar 32 = demod an ask tag from GraphBuffer using a clock of RF/32");
PrintAndLog(" : data rawdemod ar 32 1 = demod an ask tag from GraphBuffer using a clock of RF/32 and inverting data");
@ -130,7 +130,7 @@ int usage_data_rawdemod_fs(void){
PrintAndLog(" [fchigh], larger field clock length, omit for autodetect");
PrintAndLog(" [fclow], small field clock length, omit for autodetect");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod fs = demod an fsk tag from GraphBuffer using autodetect");
PrintAndLog(" Example: data rawdemod fs = demod an fsk tag from GraphBuffer using autodetect");
PrintAndLog(" : data rawdemod fs 32 = demod an fsk tag from GraphBuffer using a clock of RF/32, autodetect fc");
PrintAndLog(" : data rawdemod fs 1 = demod an fsk tag from GraphBuffer using autodetect, invert output");
PrintAndLog(" : data rawdemod fs 32 1 = demod an fsk tag from GraphBuffer using a clock of RF/32, invert output, autodetect fc");
@ -145,7 +145,7 @@ int usage_data_rawdemod_nr(void){
PrintAndLog(" <invert>, 1 for invert output");
PrintAndLog(" [set maximum allowed errors], default = 100.");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod nr = demod a nrz/direct tag from GraphBuffer");
PrintAndLog(" Example: data rawdemod nr = demod a nrz/direct tag from GraphBuffer");
PrintAndLog(" : data rawdemod nr 32 = demod a nrz/direct tag from GraphBuffer using a clock of RF/32");
PrintAndLog(" : data rawdemod nr 32 1 = demod a nrz/direct tag from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data rawdemod nr 1 = demod a nrz/direct tag from GraphBuffer while inverting data");
@ -158,7 +158,7 @@ int usage_data_rawdemod_p1(void){
PrintAndLog(" <invert>, 1 for invert output");
PrintAndLog(" [set maximum allowed errors], default = 100.");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod p1 = demod a psk1 tag from GraphBuffer");
PrintAndLog(" Example: data rawdemod p1 = demod a psk1 tag from GraphBuffer");
PrintAndLog(" : data rawdemod p1 32 = demod a psk1 tag from GraphBuffer using a clock of RF/32");
PrintAndLog(" : data rawdemod p1 32 1 = demod a psk1 tag from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data rawdemod p1 1 = demod a psk1 tag from GraphBuffer while inverting data");
@ -171,7 +171,7 @@ int usage_data_rawdemod_p2(void){
PrintAndLog(" <invert>, 1 for invert output");
PrintAndLog(" [set maximum allowed errors], default = 100.");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod p2 = demod a psk2 tag from GraphBuffer, autodetect clock");
PrintAndLog(" Example: data rawdemod p2 = demod a psk2 tag from GraphBuffer, autodetect clock");
PrintAndLog(" : data rawdemod p2 32 = demod a psk2 tag from GraphBuffer using a clock of RF/32");
PrintAndLog(" : data rawdemod p2 32 1 = demod a psk2 tag from GraphBuffer using a clock of RF/32 and inverting output");
PrintAndLog(" : data rawdemod p2 1 = demod a psk2 tag from GraphBuffer, autodetect clock and invert output");
@ -189,7 +189,7 @@ int usage_data_autocorr(void) {
int usage_data_undecimate(void){
PrintAndLog("Usage: data undec [factor]");
PrintAndLog("This function performs un-decimation, by repeating each sample N times");
PrintAndLog("Options: ");
PrintAndLog("Options:");
PrintAndLog(" h This help");
PrintAndLog(" factor The number of times to repeat each sample.[default:2]");
PrintAndLog("Example: 'data undec 3'");
@ -201,7 +201,7 @@ int usage_data_detectclock(void){
PrintAndLog(" <clock> , specify the clock (optional - to get best start position only)");
PrintAndLog(" 'a' = ask, 'f' = fsk, 'n' = nrz/direct, 'p' = psk");
PrintAndLog("");
PrintAndLog(" sample: data detectclock a = detect the clock of an ask modulated wave in the GraphBuffer");
PrintAndLog(" Example: data detectclock a = detect the clock of an ask modulated wave in the GraphBuffer");
PrintAndLog(" data detectclock f = detect the clock of an fsk modulated wave in the GraphBuffer");
PrintAndLog(" data detectclock p = detect the clock of an psk modulated wave in the GraphBuffer");
PrintAndLog(" data detectclock n = detect the clock of an nrz/direct modulated wave in the GraphBuffer");
@ -226,7 +226,7 @@ int usage_data_buffclear(void){
}
int usage_data_fsktonrz() {
PrintAndLog("Usage: data fsktonrz c <clock> l <fc_low> f <fc_high>");
PrintAndLog("Options: ");
PrintAndLog("Options:");
PrintAndLog(" h This help");
PrintAndLog(" c <clock> enter the a clock (omit to autodetect)");
PrintAndLog(" l <fc_low> enter a field clock (omit to autodetect)");

8
client/cmdhf.c
View file

@ -844,8 +844,9 @@ int usage_hf_list(){
PrintAndLog(" legic - interpret data as LEGIC communications");
PrintAndLog(" felica - interpret data as ISO18092 / FeliCa communications");
PrintAndLog("");
PrintAndLog("example: hf list 14a f");
PrintAndLog(" hf list iclass");
PrintAndLog("Examples:");
PrintAndLog(" hf list 14a f");
PrintAndLog(" hf list iclass");
return 0;
}
int usage_hf_search(){
@ -866,7 +867,8 @@ int usage_hf_snoop(){
PrintAndLog(" <skip pairs> - skip sample pairs");
PrintAndLog(" <skip triggers> - skip number of triggers");
PrintAndLog("");
PrintAndLog("example: hf snoop");
PrintAndLog("Examples:");
PrintAndLog(" hf snoop");
PrintAndLog(" hf snoop 1000 0");
return 0;
}

9
client/cmdhf14a.c
View file

@ -108,8 +108,8 @@ char* getTagInfo(uint8_t uid) {
int usage_hf_14a_sim(void) {
// PrintAndLog("\n Emulating ISO/IEC 14443 type A tag with 4,7 or 10 byte UID\n");
PrintAndLog("\n Emulating ISO/IEC 14443 type A tag with 4,7 byte UID\n");
PrintAndLog("usage: hf 14a sim [h] t <type> u <uid> [x] [e] [v]");
PrintAndLog("options: ");
PrintAndLog("Usage: hf 14a sim [h] t <type> u <uid> [x] [e] [v]");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" t : 1 = MIFARE Classic 1k");
PrintAndLog(" 2 = MIFARE Ultralight");
@ -124,7 +124,7 @@ int usage_hf_14a_sim(void) {
PrintAndLog(" x : (Optional) Performs the 'reader attack', nr/ar attack against a reader");
PrintAndLog(" e : (Optional) Fill simulator keys from found keys");
PrintAndLog(" v : (Optional) Verbose");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf 14a sim t 1 u 11223344 x");
PrintAndLog(" hf 14a sim t 1 u 11223344");
PrintAndLog(" hf 14a sim t 1 u 11223344556677");
@ -137,7 +137,8 @@ int usage_hf_14a_sniff(void) {
PrintAndLog("Usage: hf 14a sniff [c][r]");
PrintAndLog("c - triggered by first data from card");
PrintAndLog("r - triggered by first 7-bit request from reader (REQ,WUP,...)");
PrintAndLog("sample: hf 14a sniff c r");
PrintAndLog("Examples:");
PrintAndLog(" hf 14a sniff c r");
return 0;
}
int usage_hf_14a_raw(void) {

14
client/cmdhf14b.c
View file

@ -18,7 +18,7 @@ int usage_hf_14b_info(void){
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" s silently");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b info");
return 0;
}
@ -27,7 +27,7 @@ int usage_hf_14b_reader(void){
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" s silently");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b reader");
return 0;
}
@ -40,7 +40,7 @@ int usage_hf_14b_raw(void){
PrintAndLog(" -p leave the field on after receive");
PrintAndLog(" -s active signal field ON with select");
PrintAndLog(" -ss active signal field ON with select for SRx ST Microelectronics tags");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b raw -s -c -p 0200a40400");
return 0;
}
@ -50,7 +50,7 @@ int usage_hf_14b_sniff(void){
PrintAndLog("Usage: hf 14b sniff [h]");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b sniff");
return 0;
}
@ -60,7 +60,7 @@ int usage_hf_14b_sim(void){
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" u 4byte UID/PUPI");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b sim");
PrintAndLog(" hf 14b sim u 11223344");
return 0;
@ -70,7 +70,7 @@ int usage_hf_14b_read_srx(void){
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <1|2> 1 = SRIX4K , 2 = SRI512");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b sriread 1");
PrintAndLog(" hf 14b sriread 2");
return 0;
@ -82,7 +82,7 @@ int usage_hf_14b_write_srx(void){
PrintAndLog(" <1|2> 1 = SRIX4K , 2 = SRI512");
PrintAndLog(" <block> BLOCK number depends on tag, special block == FF");
PrintAndLog(" <data> hex bytes of data to be written");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 14b sriwrite 1 7F 11223344");
PrintAndLog(" hf 14b sriwrite 1 FF 11223344");
PrintAndLog(" hf 14b sriwrite 2 15 11223344");

30
client/cmdhf15.c
View file

@ -283,14 +283,14 @@ int usage_15_info(void){
PrintAndLog("defaults to '1 out of 4' mode");
PrintAndLog("");
PrintAndLog("Usage: hf 15 info [options] <uid|s|u|*>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" -2 use slower '1 out of 256' mode");
PrintAndLog(" uid (either): ");
PrintAndLog(" <8B hex> full UID eg E011223344556677");
PrintAndLog(" s selected tag");
PrintAndLog(" u unaddressed mode");
PrintAndLog(" * scan for tag");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf 15 info u");
return 0;
}
@ -301,18 +301,18 @@ int usage_15_record(void){
int usage_15_reader(void){
PrintAndLog("This command identifies a ISO 15693 tag");
PrintAndLog("");
PrintAndLog("usage: hf 15 reader [h]");
PrintAndLog("options:");
PrintAndLog("Usage: hf 15 reader [h]");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog("");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 15 reader");
return 0;
}
int usage_15_sim(void){
PrintAndLog("usage: hf 15 sim <UID>");
PrintAndLog("Usage: hf 15 sim <UID>");
PrintAndLog("");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 15 sim E016240000000000");
return 0;
}
@ -323,12 +323,12 @@ int usage_15_findafi(void){
int usage_15_dump(void){
PrintAndLog("This command dumps the contents of a ISO-15693 tag and save it to file");
PrintAndLog("");
PrintAndLog("usage: hf 15 dump [h] <f filname> ");
PrintAndLog("options:");
PrintAndLog("Usage: hf 15 dump [h] <f filname> ");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" f <name> filename, if no <name> UID will be used as filename");
PrintAndLog("");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf 15 dump f");
PrintAndLog(" hf 15 dump f mydump");
return 0;
@ -346,8 +346,8 @@ int usage_15_raw(void){
return 0;
}
int usage_15_read(void){
PrintAndLog("usage: hf 15 read [options] <uid|s|u|*> <page#>");
PrintAndLog("options:");
PrintAndLog("Usage: hf 15 read [options] <uid|s|u|*> <page#>");
PrintAndLog("Options:");
PrintAndLog(" -2 use slower '1 out of 256' mode");
PrintAndLog(" uid (either): ");
PrintAndLog(" <8B hex> full UID eg E011223344556677");
@ -358,8 +358,8 @@ int usage_15_read(void){
return 0;
}
int usage_15_write(void){
PrintAndLog("usage: hf 15 write [options] <uid|s|u|*> <page#> <hexdata>");
PrintAndLog("options:");
PrintAndLog("Usage: hf 15 write [options] <uid|s|u|*> <page#> <hexdata>");
PrintAndLog("Options:");
PrintAndLog(" -2 use slower '1 out of 256' mode");
PrintAndLog(" -o set OPTION Flag (needed for TI)");
PrintAndLog(" uid (either): ");
@ -373,7 +373,7 @@ int usage_15_write(void){
}
int usage_15_readmulti(void){
PrintAndLog("Usage: hf 15 readmulti [options] <uid|s|u|*> <start#> <count#>");
PrintAndLog(" options:");
PrintAndLog("Options:");
PrintAndLog(" -2 use slower '1 out of 256' mode");
PrintAndLog(" uid (either): ");
PrintAndLog(" <8B hex> full UID eg E011223344556677");

16
client/cmdhfemv.c
View file

@ -18,7 +18,7 @@ int usage_hf_emv_test(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv test");
return 0;
}
@ -30,7 +30,7 @@ int usage_hf_emv_readrecord(void){
PrintAndLog(" <records> : number of records");
PrintAndLog(" <sfi> : number of SFI records");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv readrecord 1 1");
return 0;
}
@ -41,7 +41,7 @@ int usage_hf_emv_clone(void){
PrintAndLog(" <records> : number of records");
PrintAndLog(" <sfi> : number of SFI records");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv clone 10 10");
return 0;
}
@ -51,7 +51,7 @@ int usage_hf_emv_transaction(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv trans");
return 0;
}
@ -61,7 +61,7 @@ int usage_hf_emv_getrnd(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv getrnd");
return 0;
}
@ -72,7 +72,7 @@ int usage_hf_emv_eload(void){
PrintAndLog(" h : this help");
PrintAndLog(" o <filename> : filename w/o '.bin'");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv eload o myfile");
return 0;
}
@ -84,7 +84,7 @@ int usage_hf_emv_dump(void){
PrintAndLog(" h : this help");
PrintAndLog(" o <filename> : filename w/o '.bin' to dump bytes");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv dump");
PrintAndLog(" hf emv dump o myfile");
return 0;
@ -95,7 +95,7 @@ int usage_hf_emv_sim(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv sim");
return 0;
}

20
client/cmdhffelica.c
View file

@ -13,13 +13,13 @@ static int CmdHelp(const char *Cmd);
int usage_hf_felica_sim(void) {
PrintAndLog("\n Emulating ISO/18092 FeliCa tag \n");
PrintAndLog("usage: hf felica sim [h] t <type> [v]");
PrintAndLog("options: ");
PrintAndLog("Usage: hf felica sim [h] t <type> [v]");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" t : 1 = FeliCa");
PrintAndLog(" : 2 = FeliCaLiteS");
PrintAndLog(" v : (Optional) Verbose");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf felica sim t 1 ");
return 0;
}
@ -29,27 +29,27 @@ int usage_hf_felica_sniff(void){
PrintAndLog("Usage: hf felica sniff <s > <t>");
PrintAndLog(" s samples to skip (decimal)");
PrintAndLog(" t triggers to skip (decimal)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf felica sniff s 1000");
return 0;
}
int usage_hf_felica_simlite(void) {
PrintAndLog("\n Emulating ISO/18092 FeliCa Lite tag \n");
PrintAndLog("usage: hf felica litesim [h] u <uid>");
PrintAndLog("options: ");
PrintAndLog("Usage: hf felica litesim [h] u <uid>");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" uid : UID in hexsymbol");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf felica litesim 11223344556677");
return 0;
}
int usage_hf_felica_dumplite(void) {
PrintAndLog("\n Dump ISO/18092 FeliCa Lite tag \n");
PrintAndLog("press button to abort run, otherwise it will loop for 200sec.");
PrintAndLog("usage: hf felica litedump [h]");
PrintAndLog("options: ");
PrintAndLog("Usage: hf felica litedump [h]");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf felica litedump");
return 0;
}

36
client/cmdhficlass.c
View file

@ -36,7 +36,7 @@ int usage_hf_iclass_sim(void) {
PrintAndLog(" 2 Reader-attack, gather reader responses to extract elite key");
PrintAndLog(" 3 Full simulation using emulator memory (see 'hf iclass eload')");
PrintAndLog(" 4 Reader-attack, adapted for KeyRoll mode, gather reader responses to extract elite key");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass sim 0 031FEC8AF7FF12E0");
PrintAndLog(" hf iclass sim 2");
PrintAndLog(" hf iclass eload 'tagdump.bin'");
@ -47,7 +47,7 @@ int usage_hf_iclass_sim(void) {
int usage_hf_iclass_eload(void) {
PrintAndLog("Loads iclass tag-dump into emulator memory on device");
PrintAndLog("Usage: hf iclass eload f <filename>");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass eload f iclass_tagdump-aa162d30f8ff12f1.bin");
return 0;
}
@ -60,7 +60,7 @@ int usage_hf_iclass_decrypt(void) {
PrintAndLog("");
PrintAndLog("Usage: hf iclass decrypt f <tagdump>");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog("S hf iclass decrypt f tagdump_12312342343.bin");
return 0;
}
@ -70,7 +70,7 @@ int usage_hf_iclass_encrypt(void) {
PrintAndLog("");
PrintAndLog("Usage: hf iclass encrypt <BlockData>");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass encrypt 0102030405060708");
PrintAndLog("");
return 0;
@ -85,7 +85,7 @@ int usage_hf_iclass_dump(void) {
PrintAndLog(" r : raw, the key is interpreted as raw block 3/4");
PrintAndLog(" v : verbose output");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass dump k 001122334455667B");
PrintAndLog(" hf iclass dump k AAAAAAAAAAAAAAAA c 001122334455667B");
PrintAndLog(" hf iclass dump k AAAAAAAAAAAAAAAA e");
@ -101,7 +101,7 @@ int usage_hf_iclass_clone(void) {
PrintAndLog(" c : If 'c' is specified, the key set is assumed to be the credit key\n");
PrintAndLog(" e : If 'e' is specified, elite computations applied to key");
PrintAndLog(" r : If 'r' is specified, no computations applied to key");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass clone f iclass_tagdump-121345.bin b 06 l 1A k 1122334455667788 e");
PrintAndLog(" hf iclass clone f iclass_tagdump-121345.bin b 05 l 19 k 0");
PrintAndLog(" hf iclass clone f iclass_tagdump-121345.bin b 06 l 19 k 0 e");
@ -117,7 +117,7 @@ int usage_hf_iclass_writeblock(void) {
PrintAndLog(" e : elite computations applied to key");
PrintAndLog(" r : raw, no computations applied to key");
PrintAndLog(" v : verbose output");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA k 001122334455667B");
PrintAndLog(" hf iclass writeblk b 1B d AAAAAAAAAAAAAAAA k 001122334455667B c");
return 0;
@ -131,7 +131,7 @@ int usage_hf_iclass_readblock(void) {
PrintAndLog(" e : elite computations applied to key");
PrintAndLog(" r : raw, no computations applied to key");
PrintAndLog(" v : verbose output");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass readblk b 06 k 0011223344556677");
PrintAndLog(" hf iclass readblk b 1B k 0011223344556677 c");
PrintAndLog(" hf iclass readblk b 0A k 0");
@ -144,13 +144,13 @@ int usage_hf_iclass_readtagfile() {
int usage_hf_iclass_calc_newkey(void) {
PrintAndLog("Calculate new key for updating\n");
PrintAndLog("Usage: hf iclass calc_newkey o <Old key> n <New key> s [csn] e");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" o <oldkey> : *specify a key as 16 hex symbols or a key number as 1 symbol");
PrintAndLog(" n <newkey> : *specify a key as 16 hex symbols or a key number as 1 symbol");
PrintAndLog(" s <csn> : specify a card Serial number to diversify the key (if omitted will attempt to read a csn)");
PrintAndLog(" e : specify new key as elite calc");
PrintAndLog(" ee : specify old and new key as elite calc");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" e key to e key given csn : hf iclass calcnewkey o 1122334455667788 n 2233445566778899 s deadbeafdeadbeaf ee");
PrintAndLog(" std key to e key read csn : hf iclass calcnewkey o 1122334455667788 n 2233445566778899 e");
PrintAndLog(" std to std read csn : hf iclass calcnewkey o 1122334455667788 n 2233445566778899");
@ -160,14 +160,14 @@ int usage_hf_iclass_calc_newkey(void) {
int usage_hf_iclass_managekeys(void) {
PrintAndLog("HELP : Manage iClass Keys in client memory:\n");
PrintAndLog("Usage: hf iclass managekeys n [keynbr] k [key] f [filename] s l p\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" n <keynbr> : specify the keyNbr to set in memory");
PrintAndLog(" k <key> : set a key in memory");
PrintAndLog(" f <filename>: specify a filename to use with load or save operations");
PrintAndLog(" s : save keys in memory to file specified by filename");
PrintAndLog(" l : load keys to memory from file specified by filename");
PrintAndLog(" p : print keys loaded into memory\n");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" set key : hf iclass managekeys n 0 k 1122334455667788");
PrintAndLog(" save key file: hf iclass managekeys f mykeys.bin s");
PrintAndLog(" load key file: hf iclass managekeys f mykeys.bin l");
@ -180,7 +180,7 @@ int usage_hf_iclass_reader(void) {
PrintAndLog("Options:");
PrintAndLog(" h This help text");
PrintAndLog(" 1 read only 1 tag");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass reader 1");
return 0;
}
@ -190,14 +190,14 @@ int usage_hf_iclass_replay(void) {
PrintAndLog("Options:");
PrintAndLog(" h This help text");
PrintAndLog(" <mac> Mac bytes to replay (8 hexsymbols)");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass replay 00112233");
return 0;
}
int usage_hf_iclass_sniff(void) {
PrintAndLog("Sniff the communication between reader and tag");
PrintAndLog("Usage: hf iclass sniff [h]");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass sniff");
return 0;
}
@ -224,7 +224,7 @@ int usage_hf_iclass_chk(void) {
PrintAndLog(" f <filename> Dictionary file with default iclass keys");
PrintAndLog(" r raw");
PrintAndLog(" e elite");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass chk f default_iclass_keys.dic");
PrintAndLog(" hf iclass chk f default_iclass_keys.dic e");
return 0;
@ -240,7 +240,7 @@ int usage_hf_iclass_lookup(void) {
PrintAndLog(" m macs");
PrintAndLog(" r raw");
PrintAndLog(" e elite");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass lookup u 9655a400f8ff12e0 p f0ffffffffffffff m 0000000089cb984b f default_iclass_keys.dic");
PrintAndLog(" hf iclass lookup u 9655a400f8ff12e0 p f0ffffffffffffff m 0000000089cb984b f default_iclass_keys.dic e");
return 0;
@ -255,7 +255,7 @@ int usage_hf_iclass_permutekey(void){
PrintAndLog(" f permute key");
PrintAndLog(" <bytes> input bytes");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf iclass permute r 0123456789abcdef");
return 0;
}

22
client/cmdhflegic.c
View file

@ -23,7 +23,7 @@ int usage_legic_calccrc(void){
PrintAndLog(" u <uidcrc> : MCC hexbyte");
PrintAndLog(" c <8|16> : Crc type");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic crc d deadbeef1122");
PrintAndLog(" hf legic crc d deadbeef1122 u 9A c 16");
return 0;
@ -37,7 +37,7 @@ int usage_legic_rdmem(void){
PrintAndLog(" <length> : (hex) number of bytes to read");
PrintAndLog(" <IV> : (hex) (optional) Initialization vector to use. Must be odd and 7bits max");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic rdmem 0 16 - reads from byte[0] 0x16 bytes(system header)");
PrintAndLog(" hf legic rdmem 0 4 55 - reads from byte[0] 0x4 bytes with IV 0x55");
PrintAndLog(" hf legic rdmem 0 100 55 - reads 0x100 bytes with IV 0x55");
@ -56,7 +56,7 @@ int usage_legic_sim(void){
PrintAndLog(" <frame> : frame drift");
PrintAndLog(" <reqresp> : reqresp drift");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic sim");
PrintAndLog(" hf legic sim ");
return 0;
@ -70,7 +70,7 @@ int usage_legic_write(void){
//PrintAndLog(" <IV> : (optional) Initialization vector to use (ODD and 7bits)");
PrintAndLog(" d <data> : (hex symbols) bytes to write ");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic write o 10 d 11223344 - Write 0x11223344 starting from offset 0x10");
return 0;
}
@ -80,7 +80,7 @@ int usage_legic_reader(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic reader");
return 0;
}
@ -91,7 +91,7 @@ int usage_legic_info(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic info");
return 0;
}
@ -104,7 +104,7 @@ int usage_legic_dump(void){
PrintAndLog(" h : this help");
PrintAndLog(" o <filename> : filename w/o '.bin' to dump bytes");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic dump");
PrintAndLog(" hf legic dump o myfile");
return 0;
@ -117,7 +117,7 @@ int usage_legic_restore(void){
PrintAndLog(" h : this help");
PrintAndLog(" i <filename> : filename w/o '.bin' to restore bytes on to card from");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic restore i myfile");
return 0;
}
@ -131,7 +131,7 @@ int usage_legic_eload(void){
PrintAndLog(" : 2 = MIM1024");
PrintAndLog(" <filename> : filename w/o .bin to load");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic eload 2 myfile");
return 0;
}
@ -145,7 +145,7 @@ int usage_legic_esave(void){
PrintAndLog(" : 2 = MIM1024");
PrintAndLog(" <filename> : filename w/o .bin to load");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic esave 2 myfile");
return 0;
}
@ -155,7 +155,7 @@ int usage_legic_wipe(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf legic wipe");
return 0;
}

116
client/cmdhfmf.c
View file

@ -23,7 +23,8 @@ int usage_hf14_ice(void){
PrintAndLog(" l <limit> nonces to be collected");
PrintAndLog(" f <name> save nonces to <name> instead of hf-mf-<UID>-nonces.bin");
PrintAndLog("");
PrintAndLog("Samples: hf mf ice");
PrintAndLog("Examples:");
PrintAndLog(" hf mf ice");
PrintAndLog(" hf mf ice f nonces.bin");
return 0;
}
@ -34,18 +35,19 @@ int usage_hf14_dump(void){
PrintAndLog(" k <name> : key filename, if no <name> given, UID will be used as filename");
PrintAndLog(" f <name> : data filename, if no <name> given, UID will be used as filename");
PrintAndLog("");
PrintAndLog("Samples: hf mf dump");
PrintAndLog("Examples:");
PrintAndLog(" hf mf dump");
PrintAndLog(" hf mf dump 4");
return 0;
}
int usage_hf14_mifare(void){
PrintAndLog("Usage: hf mf darkside [h] <block number> <A|B>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <block number> (Optional) target other block");
PrintAndLog(" <A|B> (optional) target key type");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf darkside");
PrintAndLog(" hf mf darkside 16");
PrintAndLog(" hf mf darkside 16 B");
@ -53,7 +55,7 @@ int usage_hf14_mifare(void){
}
int usage_hf14_mf1ksim(void){
PrintAndLog("Usage: hf mf sim [h] u <uid> n <numreads> [i] [x] [e] [v]");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" u (Optional) UID 4,7 or 10bytes. If not specified, the UID 4b from emulator memory will be used");
PrintAndLog(" n (Optional) Automatically exit simulation after <numreads> blocks have been read by reader. 0 = infinite");
@ -61,7 +63,7 @@ int usage_hf14_mf1ksim(void){
PrintAndLog(" x (Optional) Crack, performs the 'reader attack', nr/ar attack against a reader");
PrintAndLog(" e (Optional) Fill simulator keys from found keys");
PrintAndLog(" v (Optional) Verbose");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf sim u 0a0a0a0a");
PrintAndLog(" hf mf sim u 11223344556677");
PrintAndLog(" hf mf sim u 112233445566778899AA");
@ -70,7 +72,7 @@ int usage_hf14_mf1ksim(void){
}
int usage_hf14_dbg(void){
PrintAndLog("Usage: hf mf dbg [h] <debug level>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <debug level> (Optional) see list for valid levels");
PrintAndLog(" 0 - no debug messages");
@ -79,20 +81,20 @@ int usage_hf14_dbg(void){
PrintAndLog(" 3 - plus debug messages");
PrintAndLog(" 4 - print even debug messages in timing critical functions");
PrintAndLog(" Note: this option therefore may cause malfunction itself");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf dbg 3");
return 0;
}
int usage_hf14_sniff(void){
PrintAndLog("It continuously gets data from the field and saves it to: log, emulator, emulator file.");
PrintAndLog("Usage: hf mf sniff [h] [l] [d] [f]");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" l save encrypted sequence to logfile `uid.log`");
PrintAndLog(" d decrypt sequence and put it to log file `uid.log`");
// PrintAndLog(" n/a e decrypt sequence, collect read and write commands and save the result of the sequence to emulator memory");
PrintAndLog(" f decrypt sequence, collect read and write commands and save the result of the sequence to emulator dump file `uid.eml`");
PrintAndLog("sample:");
PrintAndLog("Example:");
PrintAndLog(" hf mf sniff l d f");
return 0;
}
@ -101,13 +103,13 @@ int usage_hf14_nested(void){
PrintAndLog(" all sectors: hf mf nested <card memory> <block number> <key A/B> <key (12 hex symbols)> [t,d]");
PrintAndLog(" one sector: hf mf nested o <block number> <key A/B> <key (12 hex symbols)>");
PrintAndLog(" <target block number> <target key A/B> [t]");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");
PrintAndLog(" t transfer keys into emulator memory");
PrintAndLog(" d write keys to binary file `hf-mf-<UID>-key.bin`");
PrintAndLog(" ");
PrintAndLog("samples:");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" hf mf nested 1 0 A FFFFFFFFFFFF ");
PrintAndLog(" hf mf nested 1 0 A FFFFFFFFFFFF t ");
PrintAndLog(" hf mf nested 1 0 A FFFFFFFFFFFF d ");
@ -119,8 +121,8 @@ int usage_hf14_hardnested(void){
PrintAndLog(" hf mf hardnested <block number> <key A|B> <key (12 hex symbols)>");
PrintAndLog(" <target block number> <target key A|B> [known target key (12 hex symbols)] [w] [s]");
PrintAndLog(" or hf mf hardnested r [known target key]");
PrintAndLog(" ");
PrintAndLog("options:");
PrintAndLog("");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" w acquire nonces and UID, and write them to binary file with default name hf-mf-<UID>-nonces.bin");
PrintAndLog(" s slower acquisition (required by some non standard cards)");
@ -128,21 +130,21 @@ int usage_hf14_hardnested(void){
PrintAndLog(" u <UID> read/write hf-mf-<UID>-nonces.bin instead of default name");
PrintAndLog(" f <name> read/write <name> instead of default name");
PrintAndLog(" t tests?");
PrintAndLog(" ");
PrintAndLog("samples:");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" hf mf hardnested 0 A FFFFFFFFFFFF 4 A");
PrintAndLog(" hf mf hardnested 0 A FFFFFFFFFFFF 4 A w");
PrintAndLog(" hf mf hardnested 0 A FFFFFFFFFFFF 4 A f nonces.bin w s");
PrintAndLog(" hf mf hardnested r");
PrintAndLog(" hf mf hardnested r a0a1a2a3a4a5");
PrintAndLog(" ");
PrintAndLog("");
PrintAndLog("Add the known target key to check if it is present in the remaining key space:");
PrintAndLog(" sample5: hf mf hardnested 0 A A0A1A2A3A4A5 4 A FFFFFFFFFFFF");
PrintAndLog(" hf mf hardnested 0 A A0A1A2A3A4A5 4 A FFFFFFFFFFFF");
return 0;
}
int usage_hf14_chk(void){
PrintAndLog("Usage: hf mf chk [h] <block number>|<*card memory> <key type (A/B/?)> [t|d] [<key (12 hex symbols)>] [<dic (*.dic)>]");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" * all sectors based on card memory, other values then below defaults to 1k");
PrintAndLog(" 0 - MINI(320 bytes)");
@ -151,8 +153,8 @@ int usage_hf14_chk(void){
PrintAndLog(" 4 - 4K");
PrintAndLog(" d write keys to binary file");
PrintAndLog(" t write keys to emulator memory\n");
PrintAndLog(" ");
PrintAndLog("samples:");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" hf mf chk 0 A 1234567890ab keys.dic -- target block 0, Key A");
PrintAndLog(" hf mf chk *1 ? t -- target all blocks, all keys, 1K, write to emul");
PrintAndLog(" hf mf chk *1 ? d -- target all blocks, all keys, 1K, write to file");
@ -161,7 +163,7 @@ int usage_hf14_chk(void){
int usage_hf14_chk_fast(void){
PrintAndLog("This is a improved checkkeys method speedwise. It checks Mifare Classic tags sector keys against a dictionary file with keys");
PrintAndLog("Usage: hf mf fchk [h] <card memory> [t|d] [<key (12 hex symbols)>] [<dic (*.dic)>]");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <cardmem> all sectors based on card memory, other values than below defaults to 1k");
PrintAndLog(" 0 - MINI(320 bytes)");
@ -170,8 +172,8 @@ int usage_hf14_chk_fast(void){
PrintAndLog(" 4 - 4K");
PrintAndLog(" d write keys to binary file");
PrintAndLog(" t write keys to emulator memory\n");
PrintAndLog(" ");
PrintAndLog("samples:");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" hf mf fchk 1 1234567890ab keys.dic -- target 1K using key 1234567890ab, using dictionary file");
PrintAndLog(" hf mf fchk 1 t -- target 1K, write to emulator memory");
PrintAndLog(" hf mf fchk 1 d -- target 1K, write to file");
@ -185,24 +187,25 @@ int usage_hf14_keybrute(void){
PrintAndLog(" ---[ This attack is obsolete, try hardnested instead ]---");
PrintAndLog("");
PrintAndLog("Usage: hf mf keybrute [h] <block number> <A|B> <key>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <block number> target block number");
PrintAndLog(" <A|B> target key type");
PrintAndLog(" <key> candidate key from mf_nonce_brute tool");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf keybrute 1 A 000011223344");
return 0;
}
int usage_hf14_restore(void){
PrintAndLog("Usage: hf mf restore [card memory] u <UID> k <name> f <name>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");
PrintAndLog(" u <UID> : uid, try to restore from hf-mf-<UID>-key.bin and hf-mf-<UID>-data.bin");
PrintAndLog(" k <name> : key filename, specific the full filename of key file");
PrintAndLog(" f <name> : data filename, specific the full filename of data file");
PrintAndLog("");
PrintAndLog("Samples: hf mf restore -- read the UID from tag first, then restore from hf-mf-<UID>-key.bin and and hf-mf-<UID>-data.bin");
PrintAndLog("Examples:");
PrintAndLog(" hf mf restore -- read the UID from tag first, then restore from hf-mf-<UID>-key.bin and and hf-mf-<UID>-data.bin");
PrintAndLog(" hf mf restore 1 u 12345678 -- restore from hf-mf-12345678-key.bin and hf-mf-12345678-data.bin");
PrintAndLog(" hf mf restore 1 u 12345678 k dumpkey.bin -- restore from dumpkey.bin and hf-mf-12345678-data.bin");
PrintAndLog(" hf mf restore 4 -- read the UID from tag with 4K memory first, then restore from hf-mf-<UID>-key.bin and and hf-mf-<UID>-data.bin");
@ -210,14 +213,14 @@ int usage_hf14_restore(void){
}
int usage_hf14_decryptbytes(void){
PrintAndLog("Decrypt Crypto-1 encrypted bytes given some known state of crypto. See tracelog to gather needed values\n");
PrintAndLog("usage: hf mf decrypt [h] <nt> <ar_enc> <at_enc> <data>");
PrintAndLog("options:");
PrintAndLog("Usage: hf mf decrypt [h] <nt> <ar_enc> <at_enc> <data>");
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <nt> reader nonce");
PrintAndLog(" <ar_enc> encrypted reader response");
PrintAndLog(" <at_enc> encrypted tag response");
PrintAndLog(" <data> encrypted data, taken directly after at_enc and forward");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf decrypt b830049b 9248314a 9280e203 41e586f9\n");
PrintAndLog(" this sample decrypts 41e586f9 -> 3003999a Annotated: 30 03 [99 9a] auth block 3 [crc]");
return 0;
@ -225,7 +228,8 @@ int usage_hf14_decryptbytes(void){
int usage_hf14_eget(void){
PrintAndLog("Usage: hf mf eget <block number>");
PrintAndLog(" sample: hf mf eget 0 ");
PrintAndLog("Examples:");
PrintAndLog(" hf mf eget 0 ");
return 0;
}
int usage_hf14_eclr(void){
@ -235,7 +239,8 @@ int usage_hf14_eclr(void){
}
int usage_hf14_eset(void){
PrintAndLog("Usage: hf mf eset <block number> <block data (32 hex symbols)>");
PrintAndLog("sample: hf mf eset 1 000102030405060708090a0b0c0d0e0f ");
PrintAndLog("Examples:");
PrintAndLog(" hf mf eset 1 000102030405060708090a0b0c0d0e0f ");
return 0;
}
int usage_hf14_eload(void){
@ -243,8 +248,9 @@ int usage_hf14_eload(void){
PrintAndLog("Usage: hf mf eload [card memory] <file name w/o `.eml`> [numblocks]");
PrintAndLog(" [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K, u = UL");
PrintAndLog("");
PrintAndLog(" sample: hf mf eload filename");
PrintAndLog(" hf mf eload 4 filename");
PrintAndLog("Examples:");
PrintAndLog(" hf mf eload filename");
PrintAndLog(" hf mf eload 4 filename");
return 0;
}
int usage_hf14_esave(void){
@ -252,9 +258,10 @@ int usage_hf14_esave(void){
PrintAndLog(" Usage: hf mf esave [card memory] [file name w/o `.eml`]");
PrintAndLog(" [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");
PrintAndLog("");
PrintAndLog(" sample: hf mf esave ");
PrintAndLog(" hf mf esave 4");
PrintAndLog(" hf mf esave 4 filename");
PrintAndLog("Examples:");
PrintAndLog(" hf mf esave ");
PrintAndLog(" hf mf esave 4");
PrintAndLog(" hf mf esave 4 filename");
return 0;
}
int usage_hf14_ecfill(void){
@ -263,8 +270,9 @@ int usage_hf14_ecfill(void){
PrintAndLog("Usage: hf mf ecfill <key A/B> [card memory]");
PrintAndLog(" [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");
PrintAndLog("");
PrintAndLog("samples: hf mf ecfill A");
PrintAndLog(" hf mf ecfill A 4");
PrintAndLog("Examples:");
PrintAndLog(" hf mf ecfill A");
PrintAndLog(" hf mf ecfill A 4");
return 0;
}
int usage_hf14_ekeyprn(void){
@ -272,7 +280,8 @@ int usage_hf14_ekeyprn(void){
PrintAndLog("Usage: hf mf ekeyprn [card memory]");
PrintAndLog(" [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");
PrintAndLog("");
PrintAndLog(" sample: hf mf ekeyprn 1");
PrintAndLog("Examples:");
PrintAndLog(" hf mf ekeyprn 1");
return 0;
}
@ -286,7 +295,7 @@ int usage_hf14_csetuid(void){
PrintAndLog(" <uid> UID 8 hex symbols");
PrintAndLog(" <atqa> ATQA 4 hex symbols");
PrintAndLog(" <sak> SAK 2 hex symbols");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf csetuid 01020304");
PrintAndLog(" hf mf csetuid 01020304 0004 08 w");
return 0;
@ -300,7 +309,7 @@ int usage_hf14_csetblk(void){
PrintAndLog(" w wipe card before writing");
PrintAndLog(" <block> block number");
PrintAndLog(" <data> block data to write (32 hex symbols)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf csetblk 1 01020304050607080910111213141516");
PrintAndLog(" hf mf csetblk 1 01020304050607080910111213141516 w");
return 0;
@ -314,7 +323,7 @@ int usage_hf14_cload(void){
PrintAndLog(" h this help");
PrintAndLog(" e load card with data from emulator memory");
PrintAndLog(" <filename> load card with data from file");
PrintAndLog(" samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf cload mydump");
PrintAndLog(" hf mf cload e");
return 0;
@ -326,7 +335,7 @@ int usage_hf14_cgetblk(void){
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <block> block number");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf cgetblk 1");
return 0;
}
@ -337,7 +346,7 @@ int usage_hf14_cgetsc(void){
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" <sector> sector number");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf cgetsc 0");
return 0;
}
@ -353,7 +362,7 @@ int usage_hf14_csave(void){
PrintAndLog(" card memory 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");
PrintAndLog(" o <filename> save data to file");
PrintAndLog("");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf csave u 1");
PrintAndLog(" hf mf csave e 1");
PrintAndLog(" hf mf csave 4 o filename");
@ -366,7 +375,7 @@ int usage_hf14_nack(void) {
PrintAndLog("Options:");
PrintAndLog(" h this help");
PrintAndLog(" v verbose");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mf nack");
return 0;
}
@ -445,7 +454,8 @@ int CmdHF14AMfWrBl(const char *Cmd) {
if (strlen(Cmd)<3) {
PrintAndLog("Usage: hf mf wrbl <block number> <key A/B> <key (12 hex symbols)> <block data (32 hex symbols)>");
PrintAndLog(" sample: hf mf wrbl 0 A FFFFFFFFFFFF 000102030405060708090A0B0C0D0E0F");
PrintAndLog("Examples:");
PrintAndLog(" hf mf wrbl 0 A FFFFFFFFFFFF 000102030405060708090A0B0C0D0E0F");
return 0;
}
@ -492,7 +502,8 @@ int CmdHF14AMfRdBl(const char *Cmd) {
if (strlen(Cmd)<3) {
PrintAndLog("Usage: hf mf rdbl <block number> <key A/B> <key (12 hex symbols)>");
PrintAndLog(" sample: hf mf rdbl 0 A FFFFFFFFFFFF ");
PrintAndLog("Examples:");
PrintAndLog(" hf mf rdbl 0 A FFFFFFFFFFFF ");
return 0;
}
@ -541,7 +552,8 @@ int CmdHF14AMfRdSc(const char *Cmd) {
if (strlen(Cmd)<3) {
PrintAndLog("Usage: hf mf rdsc <sector number> <key A/B> <key (12 hex symbols)>");
PrintAndLog(" sample: hf mf rdsc 0 A FFFFFFFFFFFF ");
PrintAndLog("Examples:");
PrintAndLog(" hf mf rdsc 0 A FFFFFFFFFFFF ");
return 0;
}

5
client/cmdhfmfdes.c
View file

@ -568,8 +568,9 @@ int CmdHF14ADesAuth(const char *Cmd){
PrintAndLog(" Crypto");
PrintAndLog(" 1 = DES 2 = 3DES 3 = 3K3DES 4 = AES");
PrintAndLog("");
PrintAndLog(" sample: hf mfdes auth 1 1 0 11223344");
PrintAndLog(" sample: hf mfdes auth 3 4 0 404142434445464748494a4b4c4d4e4f");
PrintAndLog("Examples:");
PrintAndLog(" hf mfdes auth 1 1 0 11223344");
PrintAndLog(" hf mfdes auth 3 4 0 404142434445464748494a4b4c4d4e4f");
return 0;
}
uint8_t cmdAuthMode = param_get8(Cmd,0);

6
client/cmdhfmfdesfire.c
View file

@ -48,7 +48,8 @@ int CmdHF14AMfDESAuth(const char *Cmd){
if (strlen(Cmd)<1) {
PrintAndLog("Usage: hf desfire des-auth k <key number>");
PrintAndLog(" sample: hf desfire des-auth k 0");
PrintAndLog("Examples:");
PrintAndLog(" hf desfire des-auth k 0");
return 0;
}
@ -144,7 +145,8 @@ int CmdHF14AMfAESAuth(const char *Cmd){
if (strlen(Cmd)<1) {
PrintAndLog("Usage: hf desfire aes-auth k <key number>");
PrintAndLog(" sample: hf desfire aes-auth k 0");
PrintAndLog("Examples:");
PrintAndLog(" hf desfire aes-auth k 0");
return 0;
}

67
client/cmdhfmfu.c
View file

@ -1396,9 +1396,10 @@ int usage_hf_mfu_info(void) {
PrintAndLog(" k <key> : (optional) key for authentication [UL-C 16bytes, EV1/NTAG 4bytes]");
PrintAndLog(" l : (optional) swap entered key's endianness");
PrintAndLog("");
PrintAndLog(" sample : hf mfu info");
PrintAndLog(" : hf mfu info k 00112233445566778899AABBCCDDEEFF");
PrintAndLog(" : hf mfu info k AABBCCDDD");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu info");
PrintAndLog(" hf mfu info k 00112233445566778899AABBCCDDEEFF");
PrintAndLog(" hf mfu info k AABBCCDDD");
return 0;
}
@ -1415,10 +1416,11 @@ int usage_hf_mfu_dump(void) {
PrintAndLog(" p <Pg > : starting Page number to manually set a page to start the dump at");
PrintAndLog(" q <qty> : number of Pages to manually set how many pages to dump");
PrintAndLog("");
PrintAndLog(" sample : hf mfu dump");
PrintAndLog(" : hf mfu dump n myfile");
PrintAndLog(" : hf mfu dump k 00112233445566778899AABBCCDDEEFF");
PrintAndLog(" : hf mfu dump k AABBCCDDD\n");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu dump");
PrintAndLog(" hf mfu dump n myfile");
PrintAndLog(" hf mfu dump k 00112233445566778899AABBCCDDEEFF");
PrintAndLog(" hf mfu dump k AABBCCDDD\n");
return 0;
}
@ -1433,38 +1435,40 @@ int usage_hf_mfu_restore(void){
PrintAndLog(" r : (optional) use the password found in dumpfile to configure tag. requires 'e' parameter to work");
PrintAndLog(" f <FN> : filename w/o .bin to restore");
PrintAndLog("");
PrintAndLog(" samples:");
PrintAndLog(" : hf mfu restore s f myfile");
PrintAndLog(" : hf mfu restore k AABBCCDDD s f myfile\n");
PrintAndLog(" : hf mfu restore k AABBCCDDD s e r f myfile\n");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu restore s f myfile");
PrintAndLog(" hf mfu restore k AABBCCDDD s f myfile\n");
PrintAndLog(" hf mfu restore k AABBCCDDD s e r f myfile\n");
return 0;
}
int usage_hf_mfu_rdbl(void) {
PrintAndLog("Read a block and print. It autodetects card type.\n");
PrintAndLog("Usage: hf mfu rdbl b <block number> k <key> l\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" b <no> : block to read");
PrintAndLog(" k <key> : (optional) key for authentication [UL-C 16bytes, EV1/NTAG 4bytes]");
PrintAndLog(" l : (optional) swap entered key's endianness");
PrintAndLog("");
PrintAndLog(" sample : hf mfu rdbl b 0");
PrintAndLog(" : hf mfu rdbl b 0 k 00112233445566778899AABBCCDDEEFF");
PrintAndLog(" : hf mfu rdbl b 0 k AABBCCDDD\n");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu rdbl b 0");
PrintAndLog(" hf mfu rdbl b 0 k 00112233445566778899AABBCCDDEEFF");
PrintAndLog(" hf mfu rdbl b 0 k AABBCCDDD\n");
return 0;
}
int usage_hf_mfu_wrbl(void) {
PrintAndLog("Write a block. It autodetects card type.\n");
PrintAndLog("Usage: hf mfu wrbl b <block number> d <data> k <key> l\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" b <no> : block to write");
PrintAndLog(" d <data> : block data - (8 hex symbols)");
PrintAndLog(" k <key> : (optional) key for authentication [UL-C 16bytes, EV1/NTAG 4bytes]");
PrintAndLog(" l : (optional) swap entered key's endianness");
PrintAndLog("");
PrintAndLog(" sample : hf mfu wrbl b 0 d 01234567");
PrintAndLog(" : hf mfu wrbl b 0 d 01234567 k AABBCCDDD\n");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu wrbl b 0 d 01234567");
PrintAndLog(" hf mfu wrbl b 0 d 01234567 k AABBCCDDD\n");
return 0;
}
@ -1487,12 +1491,14 @@ int usage_hf_mfu_sim(void) {
PrintAndLog("\nEmulating Ultralight tag from emulator memory\n");
PrintAndLog("\nBe sure to load the emulator memory first!\n");
PrintAndLog("Usage: hf mfu sim t 7 u <uid>");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" t 7 : 7 = NTAG or Ultralight sim (required)");
PrintAndLog(" u <uid> : 4 or 7 byte UID (optional)");
PrintAndLog("\n sample : hf mfu sim t 7");
PrintAndLog(" : hf mfu sim t 7 u 1122344556677\n");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu sim t 7");
PrintAndLog(" hf mfu sim t 7 u 1122344556677\n");
return 0;
}
@ -1506,8 +1512,9 @@ int usage_hf_mfu_ucauth(void) {
PrintAndLog(" 4 : all 0x01 key");
PrintAndLog(" 5 : all 0xff key");
PrintAndLog(" 6 : 0x00-0xFF key");
PrintAndLog("\n sample : hf mfu cauth k");
PrintAndLog(" : hf mfu cauth k 3");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu cauth k");
PrintAndLog(" hf mfu cauth k 3");
return 0;
}
@ -1515,7 +1522,8 @@ int usage_hf_mfu_ucsetpwd(void) {
PrintAndLog("Usage: hf mfu setpwd <password (32 hex symbols)>");
PrintAndLog(" [password] - (32 hex symbols)");
PrintAndLog("");
PrintAndLog("sample: hf mfu setpwd 000102030405060708090a0b0c0d0e0f");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu setpwd 000102030405060708090a0b0c0d0e0f");
PrintAndLog("");
return 0;
}
@ -1525,18 +1533,19 @@ int usage_hf_mfu_ucsetuid(void) {
PrintAndLog(" [uid] - (14 hex symbols)");
PrintAndLog("\nThis only works for Magic Ultralight tags.");
PrintAndLog("");
PrintAndLog("sample: hf mfu setuid 11223344556677");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu setuid 11223344556677");
PrintAndLog("");
return 0;
}
int usage_hf_mfu_gendiverse(void){
PrintAndLog("Usage: hf mfu gen [h] [r] <uid (8 hex symbols)>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" r : read uid from tag");
PrintAndLog(" <uid> : 4 byte UID (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu gen r");
PrintAndLog(" hf mfu gen 11223344");
PrintAndLog("");
@ -1545,12 +1554,12 @@ int usage_hf_mfu_gendiverse(void){
int usage_hf_mfu_pwdgen(void){
PrintAndLog("Usage: hf mfu pwdgen [h|t] [r] <uid (14 hex symbols)>");
PrintAndLog("options:");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" t : selftest");
PrintAndLog(" r : read uid from tag");
PrintAndLog(" <uid> : 7 byte UID (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf mfu pwdgen r");
PrintAndLog(" hf mfu pwdgen 11223344556677");
PrintAndLog(" hf mfu pwdgen t");

5
client/cmdlf.c
View file

@ -37,7 +37,7 @@ int usage_lf_read(void){
PrintAndLog(" d #samples # samples to collect (optional)");
PrintAndLog("Use 'lf config' to set parameters.");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf read s d 12000 - collects 12000samples silent");
PrintAndLog(" lf read s");
return 0;
@ -90,7 +90,8 @@ int usage_lf_simfsk(void) {
//PrintAndLog(" s TBD- -STT to enable a gap between playback repetitions - default: no gap");
PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
PrintAndLog("\n NOTE: if you set one clock manually set them all manually");
PrintAndLog("\nSamples:");
PrintAndLog("");
PrintAndLog("Examples:");
PrintAndLog(" lf simfsk c 40 H 8 L 5 d 010203 - FSK1 rf/40 data 010203");
PrintAndLog(" lf simfsk c 40 H 5 L 8 d 010203 - FSK1a rf/40 data 010203");
PrintAndLog(" lf simfsk c 64 H 10 L 8 d 010203 - FSK2 rf/64 data 010203");

8
client/cmdlfawid.c
View file

@ -24,7 +24,7 @@ int usage_lf_awid_read(void) {
PrintAndLog(" h : This help");
PrintAndLog(" 1 : (optional) stop after reading a single card");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf awid read");
PrintAndLog(" lf awid read 1");
return 0;
@ -41,7 +41,7 @@ int usage_lf_awid_sim(void) {
PrintAndLog(" <facility-code> : 8|16bit value facility code");
PrintAndLog(" <card number> : 16|32-bit value card number");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf awid sim 26 224 1337");
PrintAndLog(" lf awid sim 50 2001 deadc0de");
return 0;
@ -59,7 +59,7 @@ int usage_lf_awid_clone(void) {
PrintAndLog(" <card number> : 16|32-bit value card number");
PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf awid clone 26 224 1337");
PrintAndLog(" lf awid clone 50 2001 13371337");
return 0;
@ -79,7 +79,7 @@ int usage_lf_awid_brute(void){
PrintAndLog(" d <delay> : delay betweens attempts in ms. Default 1000ms");
PrintAndLog(" v : verbose logging, show all tries");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf awid brute a 26 f 224");
PrintAndLog(" lf awid brute a 50 f 2001 d 2000");
PrintAndLog(" lf awid brute v a 50 f 2001 c 200 d 2000");

2
client/cmdlfcotag.c
View file

@ -19,7 +19,7 @@ int usage_lf_cotag_read(void){
PrintAndLog(" : 1 - translation of HI/LO into bytes with manchester 0,1");
PrintAndLog(" : 2 - raw signal; maxlength bigbuff");
PrintAndLog("");
PrintAndLog("Sample:");
PrintAndLog("Example:");
PrintAndLog(" lf cotag read 0");
PrintAndLog(" lf cotag read 1");
return 0;

35
client/cmdlfem4x.c
View file

@ -23,11 +23,12 @@ int usage_lf_em410x_demod(void){
PrintAndLog(" <0|1> - 0 normal output, 1 for invert output");
PrintAndLog(" maxerror - set maximum allowed errors, default = 100.");
PrintAndLog("");
PrintAndLog(" sample: lf em 410x_demod = demod an EM410x Tag ID from GraphBuffer");
PrintAndLog(" : lf em 410x_demod 32 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32");
PrintAndLog(" : lf em 410x_demod 32 1 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : lf em 410x_demod 1 = demod an EM410x Tag ID from GraphBuffer while inverting data");
PrintAndLog(" : lf em 410x_demod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors");
PrintAndLog("Examples:");
PrintAndLog(" lf em 410x_demod = demod an EM410x Tag ID from GraphBuffer");
PrintAndLog(" lf em 410x_demod 32 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32");
PrintAndLog(" lf em 410x_demod 32 1 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" lf em 410x_demod 1 = demod an EM410x Tag ID from GraphBuffer while inverting data");
PrintAndLog(" lf em 410x_demod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors");
return 0;
}
int usage_lf_em410x_write(void) {
@ -39,7 +40,7 @@ int usage_lf_em410x_write(void) {
PrintAndLog(" <id> - ID number");
PrintAndLog(" <card> - 0|1 T5555 (Q5) / T55x7");
PrintAndLog(" <clock> - 16|32|40|64, optional, set R/F clock rate, defaults to 64");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 410x_write 0F0368568B");
return 0;
}
@ -49,7 +50,7 @@ int usage_lf_em410x_ws(void) {
PrintAndLog("Usage: lf em 410x_spoof [h]");
PrintAndLog("Options:");
PrintAndLog(" h - this help");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 410x_spoof");
return 0;
}
@ -61,7 +62,7 @@ int usage_lf_em410x_clone(void) {
PrintAndLog(" h - this help");
PrintAndLog(" uid - uid (10 HEX symbols)");
PrintAndLog(" clock - clock (32|64) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 410x_clone 0F0368568B");
PrintAndLog(" lf em 410x_clone 0F0368568B 32");
return 0;
@ -74,7 +75,7 @@ int usage_lf_em410x_sim(void) {
PrintAndLog(" h - this help");
PrintAndLog(" uid - uid (10 HEX symbols)");
PrintAndLog(" clock - clock (32|64) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 410x_sim 0F0368568B");
PrintAndLog(" lf em 410x_sim 0F0368568B 32");
return 0;
@ -88,7 +89,7 @@ int usage_lf_em410x_brute(void) {
PrintAndLog(" ids.txt - file with UIDs in HEX format, one per line");
PrintAndLog(" d (2000) - pause delay in milliseconds between UIDs simulation, default 1000 ms (optional)");
PrintAndLog(" c (32) - clock (32|64), default 64 (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 410x_brute ids.txt");
PrintAndLog(" lf em 410x_brute ids.txt c 32");
PrintAndLog(" lf em 410x_brute ids.txt d 3000");
@ -104,7 +105,7 @@ int usage_lf_em4x50_dump(void) {
PrintAndLog("Options:");
PrintAndLog(" h - this help");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x50_dump");
PrintAndLog(" lf em 4x50_dump 11223344");
return 0;
@ -117,7 +118,7 @@ int usage_lf_em4x50_read(void) {
PrintAndLog(" h - this help");
PrintAndLog(" address - memory address to read. (0-15)");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x50_read 1");
PrintAndLog(" lf em 4x50_read 1 11223344");
return 0;
@ -131,7 +132,7 @@ int usage_lf_em4x50_write(void) {
PrintAndLog(" address - memory address to write to. (0-15)");
PrintAndLog(" data - data to write (hex)");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x50_write 1 deadc0de");
PrintAndLog(" lf em 4x50_write 1 deadc0de 11223344");
return 0;
@ -145,7 +146,7 @@ int usage_lf_em4x05_dump(void) {
PrintAndLog("Options:");
PrintAndLog(" h - this help");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x05_dump");
PrintAndLog(" lf em 4x05_dump 11223344");
return 0;
@ -158,7 +159,7 @@ int usage_lf_em4x05_read(void) {
PrintAndLog(" h - this help");
PrintAndLog(" address - memory address to read. (0-15)");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x05_read 1");
PrintAndLog(" lf em 4x05_read 1 11223344");
return 0;
@ -172,7 +173,7 @@ int usage_lf_em4x05_write(void) {
PrintAndLog(" address - memory address to write to. (0-15)");
PrintAndLog(" data - data to write (hex)");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x05_write 1 deadc0de");
PrintAndLog(" lf em 4x05_write 1 deadc0de 11223344");
return 0;
@ -184,7 +185,7 @@ int usage_lf_em4x05_info(void) {
PrintAndLog("Options:");
PrintAndLog(" h - this help");
PrintAndLog(" pwd - password (hex) (optional)");
PrintAndLog("samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf em 4x05_info");
PrintAndLog(" lf em 4x05_info deadc0de");
return 0;

6
client/cmdlffdx.c
View file

@ -44,7 +44,8 @@ int usage_lf_fdx_clone(void){
// extended data
PrintAndLog(" <Q5> : Specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample: lf fdx clone 999 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf fdx clone 999 112233");
return 0;
}
@ -58,7 +59,8 @@ int usage_lf_fdx_sim(void) {
PrintAndLog(" <country id> : Country ID");
PrintAndLog(" <animal id> : Animal ID");
PrintAndLog("");
PrintAndLog("Sample: lf fdx sim 999 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf fdx sim 999 112233");
return 0;
}

10
client/cmdlfguard.c
View file

@ -17,12 +17,13 @@ int usage_lf_guard_clone(void){
PrintAndLog("Currently work only on 26bit");
PrintAndLog("");
PrintAndLog("Usage: lf gprox clone [h] <format> <Facility-Code> <Card-Number>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" <format> : format length 26|32|36|40");
PrintAndLog(" <Facility-Code> : 8-bit value facility code");
PrintAndLog(" <Card Number> : 16-bit value card number");
PrintAndLog("");
PrintAndLog("Sample : lf gprox clone 26 123 11223");
PrintAndLog("Examples:");
PrintAndLog(" lf gprox clone 26 123 11223");
return 0;
}
@ -33,12 +34,13 @@ int usage_lf_guard_sim(void) {
PrintAndLog("Currently work only on 26bit");
PrintAndLog("");
PrintAndLog("Usage: lf gprox sim [h] <format> <Facility-Code> <Card-Number>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" <format> : format length 26|32|36|40");
PrintAndLog(" <Facility-Code> : 8-bit value facility code");
PrintAndLog(" <Card Number> : 16-bit value card number");
PrintAndLog("");
PrintAndLog("Sample : lf gprox sim 26 123 11223");
PrintAndLog("Examples:");
PrintAndLog(" lf gprox sim 26 123 11223");
return 0;
}

12
client/cmdlfhid.c
View file

@ -26,7 +26,7 @@ int usage_lf_hid_read(void){
PrintAndLog(" h : This help");
PrintAndLog(" 1 : (optional) stop after reading a single card");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf hid read");
PrintAndLog(" lf hid read 1");
return 0;
@ -40,7 +40,7 @@ int usage_lf_hid_wiegand(void){
PrintAndLog(" OEM - OEM number / site code");
PrintAndLog(" FC - facility code");
PrintAndLog(" CN - card number");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf hid wiegand 0 101 2001");
return 0;
}
@ -52,7 +52,7 @@ int usage_lf_hid_sim(void){
PrintAndLog("Options:");
PrintAndLog(" h - This help");
PrintAndLog(" ID - HID id");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf hid sim 2006ec0c86");
return 0;
}
@ -64,7 +64,7 @@ int usage_lf_hid_clone(void){
PrintAndLog(" h - This help");
PrintAndLog(" ID - HID id");
PrintAndLog(" L - 84bit ID");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf hid clone 2006ec0c86");
PrintAndLog(" lf hid clone 2006ec0c86 L");
return 0;
@ -75,7 +75,7 @@ int usage_lf_hid_brute(void){
PrintAndLog("if cardnumber is not given, it starts with 1 and goes up to 65535");
PrintAndLog("");
PrintAndLog("Usage: lf hid brute [h] [v] a <format> f <facility-code> c <cardnumber> d <delay>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" a <format> : 26|33|34|35|37|40|44|84");
PrintAndLog(" f <facility-code> : 8-bit value HID facility code");
@ -83,7 +83,7 @@ int usage_lf_hid_brute(void){
PrintAndLog(" d <delay> : delay betweens attempts in ms. Default 1000ms");
PrintAndLog(" v : verbose logging, show all tries");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" lf hid brute a 26 f 224");
PrintAndLog(" lf hid brute a 26 f 21 d 2000");
PrintAndLog(" lf hid brute v a 26 f 21 c 200 d 2000");

12
client/cmdlfindala.c
View file

@ -17,10 +17,10 @@ int usage_lf_indala_demod(void) {
PrintAndLog("By default, values are printed and logged until the button is pressed or another USB command is issued.");
PrintAndLog("");
PrintAndLog("Usage: lf indala demod [h]");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog("");
PrintAndLog("Samples");
PrintAndLog("Examples:");
PrintAndLog(" lf indala demod");
return 0;
}
@ -30,11 +30,11 @@ int usage_lf_indala_sim(void) {
PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
PrintAndLog("");
PrintAndLog("Usage: lf indala sim [h] <uid>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" <uid> : 64/224 UID");
PrintAndLog("");
PrintAndLog("Samples");
PrintAndLog("Examples:");
PrintAndLog(" lf indala sim deadc0de");
return 0;
}
@ -44,12 +44,12 @@ int usage_lf_indala_clone(void) {
PrintAndLog("The T55x7 must be on the antenna when issuing this command. T55x7 blocks are calculated and printed in the process.");
PrintAndLog("");
PrintAndLog("Usage: lf indala clone [h] <uid> [Q5]");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" <uid> : 64/224 UID");
PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip");
PrintAndLog("");
PrintAndLog("Samples");
PrintAndLog("Examples:");
PrintAndLog(" lf indala clone 112233");
return 0;
}

12
client/cmdlfio.c
View file

@ -18,11 +18,11 @@ int usage_lf_io_read(void) {
PrintAndLog("If the [1] option is provided, reader mode is exited after reading a single card.");
PrintAndLog("");
PrintAndLog("Usage: lf io read [h] [1]");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" 1 : (optional) stop after reading a single card");
PrintAndLog("");
PrintAndLog("Samples");
PrintAndLog("Examples:");
PrintAndLog(" lf io read");
PrintAndLog(" lf io read 1");
return 0;
@ -33,13 +33,13 @@ int usage_lf_io_sim(void) {
PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
PrintAndLog("");
PrintAndLog("Usage: lf io sim [h] <version> <facility-code> <card-number>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" <version> : 8bit version");
PrintAndLog(" <facility-code> : 8bit value facility code");
PrintAndLog(" <card number> : 16bit value card number");
PrintAndLog("");
PrintAndLog("Samples");
PrintAndLog("Examples:");
PrintAndLog(" lf io sim 26 101 1337");
return 0;
}
@ -49,14 +49,14 @@ int usage_lf_io_clone(void) {
PrintAndLog("The T55x7 must be on the antenna when issuing this command. T55x7 blocks are calculated and printed in the process.");
PrintAndLog("");
PrintAndLog("Usage: lf io clone [h] <version> <facility-code> <card-number> [Q5]");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : This help");
PrintAndLog(" <version> : 8bit version");
PrintAndLog(" <facility-code> : 8bit value facility code");
PrintAndLog(" <card number> : 16bit value card number");
PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip");
PrintAndLog("");
PrintAndLog("Samples");
PrintAndLog("Examples:");
PrintAndLog(" lf io clone 26 101 1337");
return 0;
}

6
client/cmdlfjablotron.c
View file

@ -20,7 +20,8 @@ int usage_lf_jablotron_clone(void){
PrintAndLog(" <card ID> : jablotron card ID");
PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample: lf jablotron clone 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf jablotron clone 112233");
return 0;
}
@ -33,7 +34,8 @@ int usage_lf_jablotron_sim(void) {
PrintAndLog(" h : This help");
PrintAndLog(" <card ID> : jablotron card ID");
PrintAndLog("");
PrintAndLog("Sample: lf jablotron sim 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf jablotron sim 112233");
return 0;
}

6
client/cmdlfnedap.c
View file

@ -19,7 +19,8 @@ int usage_lf_nedap_clone(void){
PrintAndLog(" <Card Number> : 24-bit value card number");
// PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip");
PrintAndLog("");
PrintAndLog("Sample: lf nedap clone 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf nedap clone 112233");
return 0;
}
@ -32,7 +33,8 @@ int usage_lf_nedap_sim(void) {
PrintAndLog(" h : This help");
PrintAndLog(" <Card Number> : 24-bit value card number");
PrintAndLog("");
PrintAndLog("Sample: lf nedap sim 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf nedap sim 112233");
return 0;
}

6
client/cmdlfnoralsy.c
View file

@ -20,7 +20,8 @@ int usage_lf_noralsy_clone(void){
PrintAndLog(" <year> : Tag allocation year");
PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample: lf noralsy clone 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf noralsy clone 112233");
return 0;
}
@ -34,7 +35,8 @@ int usage_lf_noralsy_sim(void) {
PrintAndLog(" <card id> : Noralsy card ID");
PrintAndLog(" <year> : Tag allocation year");
PrintAndLog("");
PrintAndLog("Sample: lf noralsy sim 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf noralsy sim 112233");
return 0;
}

5
client/cmdlfparadox.c
View file

@ -27,12 +27,13 @@ int usage_lf_paradox_sim(void) {
PrintAndLog("The facility-code is 8-bit and the card number is 16-bit. Larger values are truncated.");
PrintAndLog("");
PrintAndLog("Usage: lf paradox sim [h] <Facility-Code> <Card-Number>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" <Facility-Code> : 8-bit value facility code");
PrintAndLog(" <Card Number> : 16-bit value card number");
PrintAndLog("");
PrintAndLog("Sample : lf paradox sim 123 11223");
PrintAndLog("Examples:");
PrintAndLog(" lf paradox sim 123 11223");
return 0;
}

10
client/cmdlfpresco.c
View file

@ -13,13 +13,14 @@ static int CmdHelp(const char *Cmd);
int usage_lf_presco_clone(void){
PrintAndLog("clone a Presco tag to a T55x7 tag.");
PrintAndLog("Usage: lf presco clone [h] d <Card-ID> H <hex-ID> <Q5>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" d <Card-ID> : 9 digit presco card ID");
PrintAndLog(" H <hex-ID> : 8 digit hex card number");
PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample : lf presco clone d 123456789");
PrintAndLog("Examples:");
PrintAndLog(" lf presco clone d 123456789");
return 0;
}
@ -29,12 +30,13 @@ int usage_lf_presco_sim(void) {
PrintAndLog("Per presco format, the card number is 9 digit number and can contain *# chars. Larger values are truncated.");
PrintAndLog("");
PrintAndLog("Usage: lf presco sim [h] d <Card-ID> or H <hex-ID>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" d <Card-ID> : 9 digit presco card number");
PrintAndLog(" H <hex-ID> : 8 digit hex card number");
PrintAndLog("");
PrintAndLog("Sample : lf presco sim d 123456789");
PrintAndLog("Examples:");
PrintAndLog(" lf presco sim d 123456789");
return 0;
}

10
client/cmdlfpyramid.c
View file

@ -17,13 +17,14 @@ int usage_lf_pyramid_clone(void){
PrintAndLog("Currently only works on 26bit");
PrintAndLog("");
PrintAndLog("Usage: lf pyramid clone [h] <Facility-Code> <Card-Number> [Q5]");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" <Facility-Code> : 8-bit value facility code");
PrintAndLog(" <Card Number> : 16-bit value card number");
PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip");
PrintAndLog("");
PrintAndLog("Sample : lf pyramid clone 123 11223");
PrintAndLog("Examples:");
PrintAndLog(" lf pyramid clone 123 11223");
return 0;
}
@ -34,12 +35,13 @@ int usage_lf_pyramid_sim(void) {
PrintAndLog("Currently work only on 26bit");
PrintAndLog("");
PrintAndLog("Usage: lf pyramid sim [h] <Facility-Code> <Card-Number>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog(" <Facility-Code> : 8-bit value facility code");
PrintAndLog(" <Card Number> : 16-bit value card number");
PrintAndLog("");
PrintAndLog("Sample : lf pyramid sim 123 11223");
PrintAndLog("Examples:");
PrintAndLog(" lf pyramid sim 123 11223");
return 0;
}

10
client/cmdlfviking.c
View file

@ -14,11 +14,12 @@ static int CmdHelp(const char *Cmd);
int usage_lf_viking_clone(void) {
PrintAndLog("clone a Viking AM tag to a T55x7 tag.");
PrintAndLog("Usage: lf viking clone <Card ID - 8 hex digits> <Q5>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" <Card Number> : 8 digit hex viking card number");
PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample : lf viking clone 1A337 Q5");
PrintAndLog("Examples:");
PrintAndLog(" lf viking clone 1A337 Q5");
return 0;
}
@ -28,10 +29,11 @@ int usage_lf_viking_sim(void) {
PrintAndLog("Per viking format, the card number is 8 digit hex number. Larger values are truncated.");
PrintAndLog("");
PrintAndLog("Usage: lf viking sim <Card-Number>");
PrintAndLog("Options :");
PrintAndLog("Options:");
PrintAndLog(" <Card Number> : 8 digit hex viking card number");
PrintAndLog("");
PrintAndLog("Sample : lf viking sim 1A337");
PrintAndLog("Examples:");
PrintAndLog(" lf viking sim 1A337");
return 0;
}

6
client/cmdlfvisa2000.c
View file

@ -23,7 +23,8 @@ int usage_lf_visa2k_clone(void){
PrintAndLog(" <card ID> : Visa2k card ID");
PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample: lf visa2000 clone 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf visa2000 clone 112233");
return 0;
}
@ -36,7 +37,8 @@ int usage_lf_visa2k_sim(void) {
PrintAndLog(" h : This help");
PrintAndLog(" <card ID> : Visa2k card ID");
PrintAndLog("");
PrintAndLog("Sample: lf visa2000 sim 112233");
PrintAndLog("Examples:");
PrintAndLog(" lf visa2000 sim 112233");
return 0;
}

18
client/emv/cmdemv.c
View file

@ -16,12 +16,12 @@ static int CmdHelp(const char *Cmd);
int usage_emv_select(void) {
PrintAndLog("Executes select applet command:\n");
PrintAndLog("Usage: hf emv select [-s][-k][-a][-t] <HEX applet AID>\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" -s : select card");
PrintAndLog(" -k : keep field for next command");
PrintAndLog(" -a : show APDU reqests and responses\n");
PrintAndLog(" -t : TLV decode results\n");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv select -s a00000000101 -> select card, select applet");
PrintAndLog(" hf emv select -s -t a00000000101 -> select card, select applet, show result in TLV");
return 0;
@ -108,12 +108,12 @@ int CmdHFEMVSelect(const char *cmd) {
int usage_emv_search(void) {
PrintAndLog("Tries to select all applets from applet list:\n");
PrintAndLog("Usage: hf emv search [-s][-k][-a][-t]\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" -s : select card");
PrintAndLog(" -k : keep field for next command");
PrintAndLog(" -a : show APDU reqests and responses\n");
PrintAndLog(" -t : TLV decode results of selected applets\n");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv search -s -> select card and search");
PrintAndLog(" hf emv search -s -t -> select card, search and show result in TLV");
return 0;
@ -185,14 +185,14 @@ int CmdHFEMVSearch(const char *cmd) {
int usage_emv_ppse(void) {
PrintAndLog("Executes PSE/PPSE select command. It returns list of applet on the card:\n");
PrintAndLog("Usage: hf emv pse [-s][-k][-1][-2][-a][-t]\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" -s : select card");
PrintAndLog(" -k : keep field for next command");
PrintAndLog(" -1 : ppse (1PAY.SYS.DDF01)");
PrintAndLog(" -2 : pse (2PAY.SYS.DDF01)");
PrintAndLog(" -a : show APDU reqests and responses\n");
PrintAndLog(" -t : TLV decode results\n");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv pse -s -1 -> select, get pse");
PrintAndLog(" hf emv pse -s -k -2 -> select, get ppse, keep field");
PrintAndLog(" hf emv pse -s -t -2 -> select, get ppse, show result in TLV");
@ -269,7 +269,7 @@ int CmdHFEMVPPSE(const char *cmd) {
int usage_emv_exec(void) {
PrintAndLog("Executes EMV contactless transaction:\n");
PrintAndLog("Usage: hf emv exec [-s][-a][-t][-f][-v][-c][-x][-g]\n");
PrintAndLog(" Options:");
PrintAndLog("Options:");
PrintAndLog(" -s : select card");
PrintAndLog(" -a : show APDU reqests and responses\n");
PrintAndLog(" -t : TLV decode results\n");
@ -279,7 +279,7 @@ int usage_emv_exec(void) {
PrintAndLog(" -x : transaction type - VSDC. For test only. Not a standart behavior.\n");
PrintAndLog(" -g : VISA. generate AC from GPO\n");
PrintAndLog("By default : transaction type - MSD.\n");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv exec -s -a -t -> execute MSD transaction");
PrintAndLog(" hf emv exec -s -a -t -c -> execute CDA transaction");
return 0;
@ -816,7 +816,7 @@ int usage_emv_getrnd(void){
PrintAndLog("Options:");
PrintAndLog(" h : this help");
PrintAndLog("");
PrintAndLog("Samples:");
PrintAndLog("Examples:");
PrintAndLog(" hf emv getrnd");
return 0;
}