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

style

Browse source
This commit is contained in:
iceman1001 2021-04-16 17:10:08 +02:00
parent 5775a283e9
commit d2646122e7
16 changed files with 404 additions and 404 deletions
Download patch file Download diff file Expand all files Collapse all files

4
client/luascripts/hf_legic_buffer2card.lua
View file

@ -8,8 +8,8 @@ author = 'Mosci'
version = 'v1.0.3' version = 'v1.0.3'
desc = desc =
[[ [[
This is a script which writes value 0x01 to bytes from This is a script which writes value 0x01 to bytes from
position 0x07 until 0xFF on a Legic Prime Tag (MIM256 or MIM1024) position 0x07 until 0xFF on a Legic Prime Tag (MIM256 or MIM1024)
-- (created with 'hf legic dump -f my_dump.hex') -- -- (created with 'hf legic dump -f my_dump.hex') --
]] ]]
example = [[ example = [[

2
client/luascripts/hf_mf_dump-luxeo.lua
View file

@ -14,7 +14,7 @@ copyright = ''
author = '0xdrrb' author = '0xdrrb'
version = 'v0.1.2' version = 'v0.1.2'
desc = [[ desc = [[
This is a script that tries to dump and decrypt the data of a specific type of Mifare laundromat token. This is a script that tries to dump and decrypt the data of a specific type of Mifare laundromat token.
OBS! Tag must be on the antenna. OBS! Tag must be on the antenna.
]] ]]
example = [[ example = [[

268
client/src/cmddata.c
View file

@ -1,6 +1,6 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Copyright (C) 2010 iZsh <izsh at fail0verflow.com> // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
// modified Marshmellow, // modified Marshmellow,
// modified Iceman 2019, 2020, 2021 // modified Iceman 2019, 2020, 2021
// //
// This code is licensed to you under the terms of the GNU GPL, version 2 or, // This code is licensed to you under the terms of the GNU GPL, version 2 or,
@ -309,9 +309,9 @@ void save_restoreDB(uint8_t saveOpt) {
static int CmdSetDebugMode(const char *Cmd) { static int CmdSetDebugMode(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data setdebugmode", CLIParserInit(&ctx, "data setdebugmode",
"Set debugging level on client side", "Set debugging level on client side",
"data setdebugmode" "data setdebugmode"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("0", NULL, "no debug messages"), arg_lit0("0", NULL, "no debug messages"),
@ -326,7 +326,7 @@ static int CmdSetDebugMode(const char *Cmd) {
bool dg_2 = arg_get_lit(ctx, 3); bool dg_2 = arg_get_lit(ctx, 3);
CLIParserFree(ctx); CLIParserFree(ctx);
if (dg_0 + dg_1 + dg_2 > 1 ) { if (dg_0 + dg_1 + dg_2 > 1) {
PrintAndLogEx(INFO, "Select only one option"); PrintAndLogEx(INFO, "Select only one option");
return PM3_EINVARG; return PM3_EINVARG;
} }
@ -339,7 +339,7 @@ static int CmdSetDebugMode(const char *Cmd) {
if (dg_2) if (dg_2)
g_debugMode = 2; g_debugMode = 2;
switch(g_debugMode) { switch (g_debugMode) {
case 0: case 0:
PrintAndLogEx(INFO, "client debug level... %u ( no debug messages )", g_debugMode); PrintAndLogEx(INFO, "client debug level... %u ( no debug messages )", g_debugMode);
break; break;
@ -428,15 +428,15 @@ int printDemodBuff(uint8_t offset, bool strip_leading, bool invert, bool print_h
int CmdPrintDemodBuff(const char *Cmd) { int CmdPrintDemodBuff(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data print", CLIParserInit(&ctx, "data print",
"Print the data in the DemodBuffer as hex or binary.\n" "Print the data in the DemodBuffer as hex or binary.\n"
"Defaults to binary output", "Defaults to binary output",
"data print" "data print"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("i", "inv", "invert Demodbuffer before printing"), arg_lit0("i", "inv", "invert Demodbuffer before printing"),
// arg_int0("l","len", "<dec>", "length to print in # of bits or hex characters respectively"), // arg_int0("l","len", "<dec>", "length to print in # of bits or hex characters respectively"),
arg_int0("o","offset", "<dec>", "offset in # of bits"), arg_int0("o", "offset", "<dec>", "offset in # of bits"),
arg_lit0("s", "strip", "strip leading zeroes, i.e. set offset to first bit equal to one"), arg_lit0("s", "strip", "strip leading zeroes, i.e. set offset to first bit equal to one"),
arg_lit0("x", "hex", "output in hex (omit for binary output)"), arg_lit0("x", "hex", "output in hex (omit for binary output)"),
arg_param_end arg_param_end
@ -458,11 +458,11 @@ int CmdPrintDemodBuff(const char *Cmd) {
int CmdGetBitStream(const char *Cmd) { int CmdGetBitStream(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data getbitstream", CLIParserInit(&ctx, "data getbitstream",
"Convert GraphBuffer's value accordingly\n" "Convert GraphBuffer's value accordingly\n"
" - larger or equal to ONE becomes ONE\n" " - larger or equal to ONE becomes ONE\n"
" - less than ONE becomes ZERO", " - less than ONE becomes ZERO",
"data getbitstream" "data getbitstream"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -482,9 +482,9 @@ static int CmdConvertBitStream(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data convertbitstream", CLIParserInit(&ctx, "data convertbitstream",
"Convert GraphBuffer's 0|1 values to 127|-127", "Convert GraphBuffer's 0|1 values to 127|-127",
"data convertbitstream" "data convertbitstream"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -644,11 +644,11 @@ static int Cmdaskmandemod(const char *Cmd) {
static int Cmdmandecoderaw(const char *Cmd) { static int Cmdmandecoderaw(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data manrawdecode", CLIParserInit(&ctx, "data manrawdecode",
"Manchester decode binary stream in DemodBuffer\n" "Manchester decode binary stream in DemodBuffer\n"
"Converts 10 and 01 and converts to 0 and 1 respectively\n" "Converts 10 and 01 and converts to 0 and 1 respectively\n"
" - must have binary sequence in demodbuffer (run `data rawdemod ar` before)", " - must have binary sequence in demodbuffer (run `data rawdemod ar` before)",
"data manrawdecode" "data manrawdecode"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("i", "inv", "invert output"), arg_lit0("i", "inv", "invert output"),
@ -658,7 +658,7 @@ static int Cmdmandecoderaw(const char *Cmd) {
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
bool invert = arg_get_lit(ctx, 1); bool invert = arg_get_lit(ctx, 1);
int max_err = arg_get_int_def(ctx, 2, 20); int max_err = arg_get_int_def(ctx, 2, 20);
CLIParserFree(ctx); CLIParserFree(ctx);
if (DemodBufferLen == 0) { if (DemodBufferLen == 0) {
PrintAndLogEx(WARNING, "DemodBuffer empty, run " _YELLOW_("`data rawdemod ar`")); PrintAndLogEx(WARNING, "DemodBuffer empty, run " _YELLOW_("`data rawdemod ar`"));
@ -726,13 +726,13 @@ static int Cmdmandecoderaw(const char *Cmd) {
static int CmdBiphaseDecodeRaw(const char *Cmd) { static int CmdBiphaseDecodeRaw(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data biphaserawdecode", CLIParserInit(&ctx, "data biphaserawdecode",
"Biphase decode binary stream in DemodBuffer\n" "Biphase decode binary stream in DemodBuffer\n"
"Converts 10 or 01 -> 1 and 11 or 00 -> 0\n" "Converts 10 or 01 -> 1 and 11 or 00 -> 0\n"
" - must have binary sequence in demodbuffer (run `data rawdemod ar` before)\n" " - must have binary sequence in demodbuffer (run `data rawdemod ar` before)\n"
" - invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester", " - invert for Conditional Dephase Encoding (CDP) AKA Differential Manchester",
"data biphaserawdecode --> decode biphase bitstream from the demodbuffer\n" "data biphaserawdecode --> decode biphase bitstream from the demodbuffer\n"
"data biphaserawdecode -oi --> decode biphase bitstream from the demodbuffer, adjust offset, and invert output" "data biphaserawdecode -oi --> decode biphase bitstream from the demodbuffer, adjust offset, and invert output"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("o", "offset", "set to adjust decode start position"), arg_lit0("o", "offset", "set to adjust decode start position"),
@ -744,7 +744,7 @@ static int CmdBiphaseDecodeRaw(const char *Cmd) {
int offset = arg_get_lit(ctx, 1); int offset = arg_get_lit(ctx, 1);
bool invert = arg_get_lit(ctx, 2); bool invert = arg_get_lit(ctx, 2);
int max_err = arg_get_int_def(ctx, 3, 20); int max_err = arg_get_int_def(ctx, 3, 20);
CLIParserFree(ctx); CLIParserFree(ctx);
if (DemodBufferLen == 0) { if (DemodBufferLen == 0) {
PrintAndLogEx(WARNING, "DemodBuffer empty, run " _YELLOW_("`data rawdemod ar`")); PrintAndLogEx(WARNING, "DemodBuffer empty, run " _YELLOW_("`data rawdemod ar`"));
@ -942,11 +942,11 @@ int AutoCorrelate(const int *in, int *out, size_t len, size_t window, bool SaveG
static int CmdAutoCorr(const char *Cmd) { static int CmdAutoCorr(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data autocorr", CLIParserInit(&ctx, "data autocorr",
"Autocorrelate over window is used to detect repeating sequences.\n" "Autocorrelate over window is used to detect repeating sequences.\n"
"We use it as detection of how long in bits a message inside the signal is", "We use it as detection of how long in bits a message inside the signal is",
"data autocorr -w 4000\n" "data autocorr -w 4000\n"
"data autocorr -w 4000 -g" "data autocorr -w 4000 -g"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("g", NULL, "save back to GraphBuffer (overwrite)"), arg_lit0("g", NULL, "save back to GraphBuffer (overwrite)"),
@ -979,9 +979,9 @@ static int CmdBitsamples(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data bitsamples", CLIParserInit(&ctx, "data bitsamples",
"Get raw samples from device as bitstring", "Get raw samples from device as bitstring",
"data bitsamples" "data bitsamples"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -1013,10 +1013,10 @@ static int CmdBitsamples(const char *Cmd) {
static int CmdBuffClear(const char *Cmd) { static int CmdBuffClear(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data clear", CLIParserInit(&ctx, "data clear",
"This function clears the bigbuff on deviceside\n" "This function clears the bigbuff on deviceside\n"
"and graph window", "and graph window",
"data clear" "data clear"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -1105,10 +1105,10 @@ static int CmdGraphShiftZero(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data shiftgraphzero", CLIParserInit(&ctx, "data shiftgraphzero",
"Shift 0 for Graphed wave + or - shift value", "Shift 0 for Graphed wave + or - shift value",
"data shiftgraphzero -n 10 --> shift 10 points\n" "data shiftgraphzero -n 10 --> shift 10 points\n"
"data shiftgraphzero -n -22 --> shift negative 22 points" "data shiftgraphzero -n -22 --> shift negative 22 points"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_int1("n", NULL, "<dec>", "shift + or -"), arg_int1("n", NULL, "<dec>", "shift + or -"),
@ -1150,10 +1150,10 @@ static int CmdAskEdgeDetect(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data askedgedetect", CLIParserInit(&ctx, "data askedgedetect",
"Adjust Graph for manual ASK demod using the length of sample differences\n" "Adjust Graph for manual ASK demod using the length of sample differences\n"
"to detect the edge of a wave", "to detect the edge of a wave",
"data askedgedetect -t 20" "data askedgedetect -t 20"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_int0("t", "thres", "<dec>", "threshold, use 20 - 45 (def 25)"), arg_int0("t", "thres", "<dec>", "threshold, use 20 - 45 (def 25)"),
@ -1175,12 +1175,12 @@ static int CmdAskEdgeDetect(const char *Cmd) {
static int CmdDetectClockRate(const char *Cmd) { static int CmdDetectClockRate(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data detectclock", CLIParserInit(&ctx, "data detectclock",
"Detect ASK, FSK, NRZ, PSK clock rate of wave in GraphBuffer", "Detect ASK, FSK, NRZ, PSK clock rate of wave in GraphBuffer",
"data detectclock -A --> detect clock of an ask wave in GraphBuffer\n" "data detectclock -A --> detect clock of an ask wave in GraphBuffer\n"
"data detectclock -F --> detect clock of an fsk wave in GraphBuffer\n" "data detectclock -F --> detect clock of an fsk wave in GraphBuffer\n"
"data detectclock -N --> detect clock of an psk wave in GraphBuffer\n" "data detectclock -N --> detect clock of an psk wave in GraphBuffer\n"
"data detectclock -P --> detect clock of an nrz/direct wave in GraphBuffer" "data detectclock -P --> detect clock of an nrz/direct wave in GraphBuffer"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("A", "ASK", "specify ASK modulation clock detection"), arg_lit0("A", "ASK", "specify ASK modulation clock detection"),
@ -1538,11 +1538,11 @@ void setClockGrid(uint32_t clk, int offset) {
int CmdGrid(const char *Cmd) { int CmdGrid(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data grid", CLIParserInit(&ctx, "data grid",
"This function overlay grid on graph plot window.\n" "This function overlay grid on graph plot window.\n"
"use zero value to turn off either", "use zero value to turn off either",
"data grid --> turn off\n" "data grid --> turn off\n"
"data grid -x 64 -y 50" "data grid -x 64 -y 50"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_dbl0("x", NULL, "<dec>", "plot grid X coord"), arg_dbl0("x", NULL, "<dec>", "plot grid X coord"),
@ -1563,10 +1563,10 @@ int CmdGrid(const char *Cmd) {
static int CmdSetGraphMarkers(const char *Cmd) { static int CmdSetGraphMarkers(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data setgraphmarkers", CLIParserInit(&ctx, "data setgraphmarkers",
"Set blue and orange marker in graph window", "Set blue and orange marker in graph window",
"data setgraphmarkers --> turn off\n" "data setgraphmarkers --> turn off\n"
"data setgraphmarkers -a 64 -b 50" "data setgraphmarkers -a 64 -b 50"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_u64_0("a", NULL, "<dec>", "orange marker"), arg_u64_0("a", NULL, "<dec>", "orange marker"),
@ -1586,9 +1586,9 @@ static int CmdHexsamples(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data hexsamples", CLIParserInit(&ctx, "data hexsamples",
"Dump big buffer as hex bytes", "Dump big buffer as hex bytes",
"data hexsamples -n 128 --> dumps 128 bytes from offset 0" "data hexsamples -n 128 --> dumps 128 bytes from offset 0"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_u64_0("b", "breaks", "<dec>", "row break, def 16"), arg_u64_0("b", "breaks", "<dec>", "row break, def 16"),
@ -1603,7 +1603,7 @@ static int CmdHexsamples(const char *Cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
// sanity checks // sanity checks
if (requested > pm3_capabilities.bigbuf_size) { if (requested > pm3_capabilities.bigbuf_size) {
requested = pm3_capabilities.bigbuf_size; requested = pm3_capabilities.bigbuf_size;
PrintAndLogEx(INFO, "n is larger than big buffer size, will use %u", requested); PrintAndLogEx(INFO, "n is larger than big buffer size, will use %u", requested);
} }
@ -1611,10 +1611,10 @@ static int CmdHexsamples(const char *Cmd) {
uint8_t got[pm3_capabilities.bigbuf_size]; uint8_t got[pm3_capabilities.bigbuf_size];
if (offset + requested > sizeof(got)) { if (offset + requested > sizeof(got)) {
PrintAndLogEx(NORMAL, "Tried to read past end of buffer, <bytes %u> + <offset %u> > %d" PrintAndLogEx(NORMAL, "Tried to read past end of buffer, <bytes %u> + <offset %u> > %d"
, requested , requested
, offset , offset
, pm3_capabilities.bigbuf_size , pm3_capabilities.bigbuf_size
); );
return PM3_EINVARG; return PM3_EINVARG;
} }
@ -1630,9 +1630,9 @@ static int CmdHexsamples(const char *Cmd) {
static int CmdHide(const char *Cmd) { static int CmdHide(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data hide", CLIParserInit(&ctx, "data hide",
"Show graph window", "Show graph window",
"data hide" "data hide"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -1647,9 +1647,9 @@ static int CmdHide(const char *Cmd) {
int CmdHpf(const char *Cmd) { int CmdHpf(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data hpf", CLIParserInit(&ctx, "data hpf",
"Remove DC offset from trace. It should centralize around 0", "Remove DC offset from trace. It should centralize around 0",
"data hpf" "data hpf"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -1762,13 +1762,13 @@ static int CmdSamples(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data samples", CLIParserInit(&ctx, "data samples",
"Get raw samples for graph window (GraphBuffer) from device.\n" "Get raw samples for graph window (GraphBuffer) from device.\n"
"If 0, then get whole big buffer from device.", "If 0, then get whole big buffer from device.",
"data samples" "data samples"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_int0("n","", "<dec>", "num of samples (512 - 40000)"), arg_int0("n", "", "<dec>", "num of samples (512 - 40000)"),
arg_lit0("v", "verbose", "verbose"), arg_lit0("v", "verbose", "verbose"),
arg_param_end arg_param_end
}; };
@ -1783,11 +1783,11 @@ int CmdTuneSamples(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data tune", CLIParserInit(&ctx, "data tune",
"Measure tuning of device antenna. Results shown in graph window.\n" "Measure tuning of device antenna. Results shown in graph window.\n"
"This command doesn't actively tune your antennas, \n" "This command doesn't actively tune your antennas, \n"
"it's only informative by measuring voltage that the antennas will generate", "it's only informative by measuring voltage that the antennas will generate",
"data tune" "data tune"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -2038,9 +2038,9 @@ static int CmdLoad(const char *Cmd) {
int CmdLtrim(const char *Cmd) { int CmdLtrim(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data ltrim", CLIParserInit(&ctx, "data ltrim",
"Trim samples from left of trace", "Trim samples from left of trace",
"data ltrim -i 300 --> keep 300 - end" "data ltrim -i 300 --> keep 300 - end"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_u64_1("i", "idx", "<dec>", "from index to beginning trace"), arg_u64_1("i", "idx", "<dec>", "from index to beginning trace"),
@ -2070,9 +2070,9 @@ static int CmdRtrim(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data rtrim", CLIParserInit(&ctx, "data rtrim",
"Trim samples from right of trace", "Trim samples from right of trace",
"data rtrim -i 4000 --> keep 0 - 4000" "data rtrim -i 4000 --> keep 0 - 4000"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_u64_1("i", "idx", "<dec>", "from index to end trace"), arg_u64_1("i", "idx", "<dec>", "from index to end trace"),
@ -2098,9 +2098,9 @@ static int CmdMtrim(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data mtrim", CLIParserInit(&ctx, "data mtrim",
"Trim out samples from the specified start to the specified end point", "Trim out samples from the specified start to the specified end point",
"data mtrim -s 1000 -e 2000 --> keep between 1000 and 2000" "data mtrim -s 1000 -e 2000 --> keep between 1000 and 2000"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_u64_1("s", "start", "<dec>", "start point"), arg_u64_1("s", "start", "<dec>", "start point"),
@ -2132,9 +2132,9 @@ int CmdNorm(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data norm", CLIParserInit(&ctx, "data norm",
"Normalize max/min to +/-128", "Normalize max/min to +/-128",
"data norm" "data norm"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -2169,10 +2169,10 @@ int CmdNorm(const char *Cmd) {
int CmdPlot(const char *Cmd) { int CmdPlot(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data plot", CLIParserInit(&ctx, "data plot",
"Show graph window \n" "Show graph window \n"
"hit 'h' in window for detail keystroke help available", "hit 'h' in window for detail keystroke help available",
"data plot" "data plot"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -2280,9 +2280,9 @@ int directionalThreshold(const int *in, int *out, size_t len, int8_t up, int8_t
static int CmdDirectionalThreshold(const char *Cmd) { static int CmdDirectionalThreshold(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data dirthreshold", CLIParserInit(&ctx, "data dirthreshold",
"Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev.", "Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev.",
"data dirthreshold -u 10 -d -10" "data dirthreshold -u 10 -d -10"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_int1("d", "down", "<dec>", "threshold down"), arg_int1("d", "down", "<dec>", "threshold down"),
@ -2311,9 +2311,9 @@ static int CmdDirectionalThreshold(const char *Cmd) {
static int CmdZerocrossings(const char *Cmd) { static int CmdZerocrossings(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data zerocrossings", CLIParserInit(&ctx, "data zerocrossings",
"Count time between zero-crossings", "Count time between zero-crossings",
"data zerocrossings" "data zerocrossings"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_param_end arg_param_end
@ -2359,10 +2359,10 @@ static int Cmdbin2hex(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data bin2hex", CLIParserInit(&ctx, "data bin2hex",
"This function converts binary to hexadecimal. It will ignore all\n" "This function converts binary to hexadecimal. It will ignore all\n"
"characters not 1 or 0 but stop reading on whitespace", "characters not 1 or 0 but stop reading on whitespace",
"data bin2hex -d 0101111001010" "data bin2hex -d 0101111001010"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_strx0("d", "data", "<bin>", "binary string to convert"), arg_strx0("d", "data", "<bin>", "binary string to convert"),
@ -2378,8 +2378,8 @@ static int Cmdbin2hex(const char *Cmd) {
PrintAndLogEx(FAILED, "Error parsing binary string"); PrintAndLogEx(FAILED, "Error parsing binary string");
return PM3_EINVARG; return PM3_EINVARG;
} }
// Number of digits supplied as argument // Number of digits supplied as argument
size_t bytelen = (blen + 7) / 8; size_t bytelen = (blen + 7) / 8;
uint8_t *arr = (uint8_t *) calloc(bytelen, sizeof(uint8_t)); uint8_t *arr = (uint8_t *) calloc(bytelen, sizeof(uint8_t));
memset(arr, 0, bytelen); memset(arr, 0, bytelen);
@ -2406,10 +2406,10 @@ static int Cmdbin2hex(const char *Cmd) {
static int Cmdhex2bin(const char *Cmd) { static int Cmdhex2bin(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data hex2bin", CLIParserInit(&ctx, "data hex2bin",
"This function converts hexadecimal to binary. It will ignore all\n" "This function converts hexadecimal to binary. It will ignore all\n"
"non-hexadecimal characters but stop reading on whitespace", "non-hexadecimal characters but stop reading on whitespace",
"data hex2bin -d 01020304" "data hex2bin -d 01020304"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_str0("d", "data", "<hex>", "bytes to convert"), arg_str0("d", "data", "<hex>", "bytes to convert"),
@ -2427,11 +2427,11 @@ static int Cmdhex2bin(const char *Cmd) {
} }
for (int i = 0; i < dlen; i++) { for (int i = 0; i < dlen; i++) {
char x = data[i]; char x = data[i];
if (isxdigit(x) == false) { if (isxdigit(x) == false) {
PrintAndLogEx(ERR, "Non hex digit found"); PrintAndLogEx(ERR, "Non hex digit found");
return PM3_EINVARG; return PM3_EINVARG;
} }
} }
PrintAndLogEx(SUCCESS, "" NOLF); PrintAndLogEx(SUCCESS, "" NOLF);
@ -2598,7 +2598,7 @@ static int FSKToNRZ(int *data, size_t *dataLen, uint8_t clk, uint8_t LowToneFC,
} }
static int CmdFSKToNRZ(const char *Cmd) { static int CmdFSKToNRZ(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data fsktonrz", CLIParserInit(&ctx, "data fsktonrz",
"Convert fsk2 to nrz wave for alternate fsk demodulating (for weak fsk)\n" "Convert fsk2 to nrz wave for alternate fsk demodulating (for weak fsk)\n"
@ -2632,9 +2632,9 @@ static int CmdDataIIR(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "data iir", CLIParserInit(&ctx, "data iir",
"Apply IIR buttersworth filter on plot data", "Apply IIR buttersworth filter on plot data",
"data iir -n 2" "data iir -n 2"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_u64_1("n", NULL, "<dec>", "factor n"), arg_u64_1("n", NULL, "<dec>", "factor n"),
@ -2703,7 +2703,7 @@ typedef struct {
static int print_modulation(lf_modulation_t b) { static int print_modulation(lf_modulation_t b) {
PrintAndLogEx(INFO, " Modulation........ " _GREEN_("%s"), GetSelectedModulationStr(b.modulation)); PrintAndLogEx(INFO, " Modulation........ " _GREEN_("%s"), GetSelectedModulationStr(b.modulation));
PrintAndLogEx(INFO, " Bit clock......... " _GREEN_("RF/%d"), b.bitrate); PrintAndLogEx(INFO, " Bit clock......... " _GREEN_("RF/%d"), b.bitrate);
PrintAndLogEx(INFO, " Approx baudrate... " _GREEN_("%.f") "bauds", (125000 / (float)b.bitrate) ); PrintAndLogEx(INFO, " Approx baudrate... " _GREEN_("%.f") "bauds", (125000 / (float)b.bitrate));
switch (b.modulation) { switch (b.modulation) {
case DEMOD_PSK1: case DEMOD_PSK1:
case DEMOD_PSK2: case DEMOD_PSK2:

4
client/src/cmdhf14b.c
View file

@ -1151,7 +1151,7 @@ static int CmdHF14BWriteSri(const char *Cmd) {
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int blockno = arg_get_int_def(ctx, 1, -1); int blockno = arg_get_int_def(ctx, 1, -1);
int dlen = 0; int dlen = 0;
uint8_t data[4] = {0,0,0,0}; uint8_t data[4] = {0, 0, 0, 0};
int res = CLIParamHexToBuf(arg_get_str(ctx, 2), data, sizeof(data), &dlen); int res = CLIParamHexToBuf(arg_get_str(ctx, 2), data, sizeof(data), &dlen);
if (res) { if (res) {
CLIParserFree(ctx); CLIParserFree(ctx);
@ -1170,7 +1170,7 @@ static int CmdHF14BWriteSri(const char *Cmd) {
if (use_sri512 + use_srix4k > 1) { if (use_sri512 + use_srix4k > 1) {
PrintAndLogEx(FAILED, "Select only one card type"); PrintAndLogEx(FAILED, "Select only one card type");
return PM3_EINVARG; return PM3_EINVARG;
} }
if (use_srix4k && blockno > 0x7F) { if (use_srix4k && blockno > 0x7F) {

92
client/src/cmdhf15.c
View file

@ -442,7 +442,7 @@ static int getUID(bool loop, uint8_t *buf) {
if (loop == false) { if (loop == false) {
break; break;
} }
} }
} }
} while (loop && kbd_enter_pressed() == false); } while (loop && kbd_enter_pressed() == false);
@ -470,7 +470,7 @@ static uint8_t arg_add_default(void *at[]) {
at[5] = arg_lit0("o", "opt", "set OPTION Flag (needed for TI)"); at[5] = arg_lit0("o", "opt", "set OPTION Flag (needed for TI)");
return 6; return 6;
} }
static uint16_t arg_get_raw_flag(uint8_t uidlen, bool unaddressed, bool scan, bool add_option ) { static uint16_t arg_get_raw_flag(uint8_t uidlen, bool unaddressed, bool scan, bool add_option) {
uint16_t flags = 0; uint16_t flags = 0;
if (unaddressed) { if (unaddressed) {
// unaddressed mode may not be supported by all vendors // unaddressed mode may not be supported by all vendors
@ -800,15 +800,15 @@ static int NxpSysInfo(uint8_t *uid) {
*/ */
static int CmdHF15Info(const char *Cmd) { static int CmdHF15Info(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "hf 15 info", CLIParserInit(&ctx, "hf 15 info",
"Uses the optional command `get_systeminfo` 0x2B to try and extract information", "Uses the optional command `get_systeminfo` 0x2B to try and extract information",
"hf 15 info\n" "hf 15 info\n"
"hf 15 info -*\n" "hf 15 info -*\n"
"hf 15 info -u E011223344556677" "hf 15 info -u E011223344556677"
); );
void *argtable[6+1] = {}; void *argtable[6 + 1] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_param_end; argtable[arglen++] = arg_param_end;
@ -844,7 +844,7 @@ static int CmdHF15Info(const char *Cmd) {
if (getUID(false, uid) != PM3_SUCCESS) { if (getUID(false, uid) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "no tag found"); PrintAndLogEx(WARNING, "no tag found");
return PM3_EINVARG; return PM3_EINVARG;
} }
uidlen = 8; uidlen = 8;
} }
@ -853,7 +853,7 @@ static int CmdHF15Info(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
AddCrc15(req, reqlen); AddCrc15(req, reqlen);
@ -1079,9 +1079,9 @@ static int CmdHF15WriteAfi(const char *Cmd) {
"Write AFI on card", "Write AFI on card",
"hf 15 writeafi -* --afi 12\n" "hf 15 writeafi -* --afi 12\n"
"hf 15 writeafi -u E011223344556677 --afi 12" "hf 15 writeafi -u E011223344556677 --afi 12"
); );
void *argtable[6+2] = {}; void *argtable[6 + 2] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_int1(NULL, "afi", "<dec>", "AFI number (0-255)"); argtable[arglen++] = arg_int1(NULL, "afi", "<dec>", "AFI number (0-255)");
argtable[arglen++] = arg_param_end; argtable[arglen++] = arg_param_end;
@ -1124,7 +1124,7 @@ static int CmdHF15WriteAfi(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
} }
// enforce, since we are writing // enforce, since we are writing
@ -1176,9 +1176,9 @@ static int CmdHF15WriteDsfid(const char *Cmd) {
"Write DSFID on card", "Write DSFID on card",
"hf 15 writedsfid -* --dsfid 12\n" "hf 15 writedsfid -* --dsfid 12\n"
"hf 15 writedsfid -u E011223344556677 --dsfid 12" "hf 15 writedsfid -u E011223344556677 --dsfid 12"
); );
void *argtable[6+2] = {}; void *argtable[6 + 2] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_int1(NULL, "dsfid", "<dec>", "DSFID number (0-255)"); argtable[arglen++] = arg_int1(NULL, "dsfid", "<dec>", "DSFID number (0-255)");
argtable[arglen++] = arg_param_end; argtable[arglen++] = arg_param_end;
@ -1223,7 +1223,7 @@ static int CmdHF15WriteDsfid(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
} }
// dsfid // dsfid
@ -1239,7 +1239,7 @@ static int CmdHF15WriteDsfid(const char *Cmd) {
// arg2 (recv == 1 == expect a response) // arg2 (recv == 1 == expect a response)
uint8_t read_respone = 1; uint8_t read_respone = 1;
PrintAndLogEx(DEBUG, "cmd %s", sprint_hex(req, reqlen) ); PrintAndLogEx(DEBUG, "cmd %s", sprint_hex(req, reqlen));
PacketResponseNG resp; PacketResponseNG resp;
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(CMD_HF_ISO15693_COMMAND, reqlen, fast, read_respone, req, reqlen); SendCommandMIX(CMD_HF_ISO15693_COMMAND, reqlen, fast, read_respone, req, reqlen);
@ -1277,12 +1277,12 @@ static int CmdHF15Dump(const char *Cmd) {
"hf 15 dump\n" "hf 15 dump\n"
"hf 15 dump -*\n" "hf 15 dump -*\n"
"hf 15 dump -u E011223344556677 -f hf-15-my-dump.bin" "hf 15 dump -u E011223344556677 -f hf-15-my-dump.bin"
); );
void *argtable[6+2] = {}; void *argtable[6 + 2] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_str0("f", "file", "<fn>", "filename of dump"), argtable[arglen++] = arg_str0("f", "file", "<fn>", "filename of dump"),
argtable[arglen++] = arg_param_end; argtable[arglen++] = arg_param_end;
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
@ -1321,7 +1321,7 @@ static int CmdHF15Dump(const char *Cmd) {
if (getUID(false, uid) != PM3_SUCCESS) { if (getUID(false, uid) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "no tag found"); PrintAndLogEx(WARNING, "no tag found");
return PM3_EINVARG; return PM3_EINVARG;
} }
uidlen = 8; uidlen = 8;
} }
@ -1330,7 +1330,7 @@ static int CmdHF15Dump(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
// detect blocksize from card :) // detect blocksize from card :)
@ -1409,12 +1409,12 @@ static int CmdHF15Dump(const char *Cmd) {
sprintf(lck, "%d", mem[i].lock); sprintf(lck, "%d", mem[i].lock);
} }
PrintAndLogEx(INFO, "%3d/0x%02X | %s | %s | %s" PrintAndLogEx(INFO, "%3d/0x%02X | %s | %s | %s"
, i , i
, i , i
, sprint_hex(mem[i].block, 4) , sprint_hex(mem[i].block, 4)
, lck , lck
, sprint_ascii(mem[i].block, 4) , sprint_ascii(mem[i].block, 4)
); );
} }
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
@ -1449,7 +1449,7 @@ static int CmdHF15Raw(const char *Cmd) {
"Sends raw bytes over ISO-15693 to card", "Sends raw bytes over ISO-15693 to card",
"hf 15 raw -c -d 260100 --> add crc\n" "hf 15 raw -c -d 260100 --> add crc\n"
"hf 15 raw -krc -d 260100 --> add crc, keep field on, skip response" "hf 15 raw -krc -d 260100 --> add crc, keep field on, skip response"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -1517,9 +1517,9 @@ static int CmdHF15Readmulti(const char *Cmd) {
"Read multiple pages on a ISO-15693 tag ", "Read multiple pages on a ISO-15693 tag ",
"hf 15 rdmulti -* -b 1 --cnt 6 -> read 6 blocks\n" "hf 15 rdmulti -* -b 1 --cnt 6 -> read 6 blocks\n"
"hf 15 rdmulti -u E011223344556677 -b 12 --cnt 3 -> read three blocks" "hf 15 rdmulti -u E011223344556677 -b 12 --cnt 3 -> read three blocks"
); );
void *argtable[6+3] = {}; void *argtable[6 + 3] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_int1("b", NULL, "<dec>", "first page number (0-255)"); argtable[arglen++] = arg_int1("b", NULL, "<dec>", "first page number (0-255)");
argtable[arglen++] = arg_int1(NULL, "cnt", "<dec>", "number of pages (1-6)"); argtable[arglen++] = arg_int1(NULL, "cnt", "<dec>", "number of pages (1-6)");
@ -1570,7 +1570,7 @@ static int CmdHF15Readmulti(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
} }
// add OPTION flag, in order to get lock-info // add OPTION flag, in order to get lock-info
req[0] |= ISO15_REQ_OPTION; req[0] |= ISO15_REQ_OPTION;
@ -1653,9 +1653,9 @@ static int CmdHF15Readblock(const char *Cmd) {
"Read page on ISO-15693 tag", "Read page on ISO-15693 tag",
"hf 15 rdbl -* -b 12\n" "hf 15 rdbl -* -b 12\n"
"hf 15 rdbl -u E011223344556677 -b 12" "hf 15 rdbl -u E011223344556677 -b 12"
); );
void *argtable[6+2] = {}; void *argtable[6 + 2] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_int1("b", "blk", "<dec>", "page number (0-255)"); argtable[arglen++] = arg_int1("b", "blk", "<dec>", "page number (0-255)");
argtable[arglen++] = arg_param_end; argtable[arglen++] = arg_param_end;
@ -1679,7 +1679,7 @@ static int CmdHF15Readblock(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
// default fallback to scan for tag. // default fallback to scan for tag.
// overriding unaddress parameter :) // overriding unaddress parameter :)
if (uidlen != 8) { if (uidlen != 8) {
scan = true; scan = true;
@ -1704,7 +1704,7 @@ static int CmdHF15Readblock(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
} }
// add OPTION flag, in order to get lock-info // add OPTION flag, in order to get lock-info
req[0] |= ISO15_REQ_OPTION; req[0] |= ISO15_REQ_OPTION;
@ -1819,9 +1819,9 @@ static int CmdHF15Write(const char *Cmd) {
"Write block on ISO-15693 tag", "Write block on ISO-15693 tag",
"hf 15 wrbl -* -b 12 -d AABBCCDD\n" "hf 15 wrbl -* -b 12 -d AABBCCDD\n"
"hf 15 wrbl -u E011223344556677 -b 12 -d AABBCCDD" "hf 15 wrbl -u E011223344556677 -b 12 -d AABBCCDD"
); );
void *argtable[6+4] = {}; void *argtable[6 + 4] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_int1("b", "blk", "<dec>", "page number (0-255)"); argtable[arglen++] = arg_int1("b", "blk", "<dec>", "page number (0-255)");
argtable[arglen++] = arg_str1("d", "data", "<hex>", "data, 4 bytes"); argtable[arglen++] = arg_str1("d", "data", "<hex>", "data, 4 bytes");
@ -1856,7 +1856,7 @@ static int CmdHF15Write(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
// default fallback to scan for tag. // default fallback to scan for tag.
// overriding unaddress parameter :) // overriding unaddress parameter :)
if (uidlen != 8) { if (uidlen != 8) {
scan = true; scan = true;
@ -1884,7 +1884,7 @@ static int CmdHF15Write(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
} }
@ -1913,14 +1913,14 @@ static int CmdHF15Restore(const char *Cmd) {
"hf 15 restore\n" "hf 15 restore\n"
"hf 15 restore -*\n" "hf 15 restore -*\n"
"hf 15 restore -u E011223344556677 -f hf-15-my-dump.bin" "hf 15 restore -u E011223344556677 -f hf-15-my-dump.bin"
); );
void *argtable[6+5] = {}; void *argtable[6 + 5] = {};
uint8_t arglen = arg_add_default(argtable); uint8_t arglen = arg_add_default(argtable);
argtable[arglen++] = arg_str0("f", "file", "<fn>", "filename of dump"), argtable[arglen++] = arg_str0("f", "file", "<fn>", "filename of dump"),
argtable[arglen++] = arg_int0("r", "retry", "<dec>", "number of retries (def 3)"), argtable[arglen++] = arg_int0("r", "retry", "<dec>", "number of retries (def 3)"),
argtable[arglen++] = arg_int0(NULL, "bs", "<dec>", "block size (def 4)"), argtable[arglen++] = arg_int0(NULL, "bs", "<dec>", "block size (def 4)"),
argtable[arglen++] = arg_lit0("v", "verbose", "verbose output"); argtable[arglen++] = arg_lit0("v", "verbose", "verbose output");
argtable[arglen++] = arg_param_end; argtable[arglen++] = arg_param_end;
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
@ -1950,7 +1950,7 @@ static int CmdHF15Restore(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
// default fallback to scan for tag. // default fallback to scan for tag.
// overriding unaddress parameter :) // overriding unaddress parameter :)
if (uidlen != 8) { if (uidlen != 8) {
scan = true; scan = true;
@ -1968,7 +1968,7 @@ static int CmdHF15Restore(const char *Cmd) {
if (getUID(false, uid) != PM3_SUCCESS) { if (getUID(false, uid) != PM3_SUCCESS) {
PrintAndLogEx(WARNING, "no tag found"); PrintAndLogEx(WARNING, "no tag found");
return PM3_EINVARG; return PM3_EINVARG;
} }
uidlen = 8; uidlen = 8;
} }
@ -1977,9 +1977,9 @@ static int CmdHF15Restore(const char *Cmd) {
memcpy(req + reqlen, uid, sizeof(uid)); memcpy(req + reqlen, uid, sizeof(uid));
reqlen += sizeof(uid); reqlen += sizeof(uid);
} }
PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid)); PrintAndLogEx(SUCCESS, "Using UID... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
} else { } else {
PrintAndLogEx(SUCCESS, "Using unaddressed mode"); PrintAndLogEx(SUCCESS, "Using unaddressed mode");
} }
PrintAndLogEx(INFO, "Using block size... %d", blocksize); PrintAndLogEx(INFO, "Using block size... %d", blocksize);

142
client/src/cmdhffelica.c
View file

@ -39,10 +39,10 @@ static void print_status_flag1_interpretation(void) {
PrintAndLogEx(INFO, "----+--------------------------------------------------------------------------------------------------------------------"); PrintAndLogEx(INFO, "----+--------------------------------------------------------------------------------------------------------------------");
PrintAndLogEx(INFO, " 00 | Indicates the successful completion of a command."); PrintAndLogEx(INFO, " 00 | Indicates the successful completion of a command.");
PrintAndLogEx(INFO, " FF | If an error occurs during the processing of a command that includes no list in the command packet, \n" PrintAndLogEx(INFO, " FF | If an error occurs during the processing of a command that includes no list in the command packet, \n"
" | or if an error occurs independently of any list, the card returns a response by setting FFh to Status Flag1."); " | or if an error occurs independently of any list, the card returns a response by setting FFh to Status Flag1.");
PrintAndLogEx(INFO, " XX | If an error occurs while processing a command that includes Service Code List or Block List \n" PrintAndLogEx(INFO, " XX | If an error occurs while processing a command that includes Service Code List or Block List \n"
" | in the command packet, the card returns a response by setting a number in the list to Status Flag1,\n" " | in the command packet, the card returns a response by setting a number in the list to Status Flag1,\n"
" | indicating the location of the error."); " | indicating the location of the error.");
PrintAndLogEx(INFO, "----+--------------------------------------------------------------------------------------------------------------------"); PrintAndLogEx(INFO, "----+--------------------------------------------------------------------------------------------------------------------");
} }
@ -51,28 +51,28 @@ static void print_status_flag2_interpration(void) {
PrintAndLogEx(INFO, "----+--------------------------------------------------------------------------------------------------------------------"); PrintAndLogEx(INFO, "----+--------------------------------------------------------------------------------------------------------------------");
PrintAndLogEx(INFO, " 00 | Indicates the successful completion of a command."); PrintAndLogEx(INFO, " 00 | Indicates the successful completion of a command.");
PrintAndLogEx(INFO, " 01 | The calculated result is either less than zero when the purse data is decremented, or exceeds 4\n" PrintAndLogEx(INFO, " 01 | The calculated result is either less than zero when the purse data is decremented, or exceeds 4\n"
" | Bytes when the purse data is incremented."); " | Bytes when the purse data is incremented.");
PrintAndLogEx(INFO, " 02 | The specified data exceeds the value of cashback data at cashback of purse."); PrintAndLogEx(INFO, " 02 | The specified data exceeds the value of cashback data at cashback of purse.");
PrintAndLogEx(INFO, " 70 | Memory error (fatal error)."); PrintAndLogEx(INFO, " 70 | Memory error (fatal error).");
PrintAndLogEx(INFO, " 71 | The number of memory rewrites exceeds the upper limit (this is only a warning; data writing is performed as normal).\n" PrintAndLogEx(INFO, " 71 | The number of memory rewrites exceeds the upper limit (this is only a warning; data writing is performed as normal).\n"
" | The maximum number of rewrites can differ, depending on the product being used.\n" " | The maximum number of rewrites can differ, depending on the product being used.\n"
" | In addition, Status Flag1 is either 00h or FFh depending on the product being used."); " | In addition, Status Flag1 is either 00h or FFh depending on the product being used.");
PrintAndLogEx(INFO, " A1 | Illegal Number of Service| Number of Service or Number of Node specified by the command \n" PrintAndLogEx(INFO, " A1 | Illegal Number of Service| Number of Service or Number of Node specified by the command \n"
" | falls outside the range of the prescribed value."); " | falls outside the range of the prescribed value.");
PrintAndLogEx(INFO, " A2 | Illegal command packet (specified Number of Block) : Number of Block specified by the \n" PrintAndLogEx(INFO, " A2 | Illegal command packet (specified Number of Block) : Number of Block specified by the \n"
" | command falls outside the range of the prescribed values for the product."); " | command falls outside the range of the prescribed values for the product.");
PrintAndLogEx(INFO, " A3 | Illegal Block List (specified order of Service) : Service Code List Order specified by \n" PrintAndLogEx(INFO, " A3 | Illegal Block List (specified order of Service) : Service Code List Order specified by \n"
" | Block List Element falls outside the Number of Service specified by the command \n" " | Block List Element falls outside the Number of Service specified by the command \n"
" | (or the Number of Service specified at the times of mutual authentication)."); " | (or the Number of Service specified at the times of mutual authentication).");
PrintAndLogEx(INFO, " A4 | Illegal Service type : Area Attribute specified by the command or Service Attribute of Service Code is incorrect."); PrintAndLogEx(INFO, " A4 | Illegal Service type : Area Attribute specified by the command or Service Attribute of Service Code is incorrect.");
PrintAndLogEx(INFO, " A5 | Access is not allowed : Area or Service specified by the command cannot be accessed.\n" PrintAndLogEx(INFO, " A5 | Access is not allowed : Area or Service specified by the command cannot be accessed.\n"
" | The parameter specified by the command does not satisfy the conditions for success."); " | The parameter specified by the command does not satisfy the conditions for success.");
PrintAndLogEx(INFO, " A6 | Illegal Service Code List : Target to be accessed, identified by Service Code List Order, specified by Block\n" PrintAndLogEx(INFO, " A6 | Illegal Service Code List : Target to be accessed, identified by Service Code List Order, specified by Block\n"
" | List Element does not exist. Or, Node specified by Node Code List does not exist."); " | List Element does not exist. Or, Node specified by Node Code List does not exist.");
PrintAndLogEx(INFO, " A7 | Illegal Block List (Access Mode) : Access Mode specified by Block List Element is incorrect."); PrintAndLogEx(INFO, " A7 | Illegal Block List (Access Mode) : Access Mode specified by Block List Element is incorrect.");
PrintAndLogEx(INFO, " A8 | Illegal Block Number Block Number (access to the specified data is inhibited) :\n" PrintAndLogEx(INFO, " A8 | Illegal Block Number Block Number (access to the specified data is inhibited) :\n"
" | specified by Block List Element exceeds the number of Blocks assigned to Service."); " | specified by Block List Element exceeds the number of Blocks assigned to Service.");
PrintAndLogEx(INFO, " A9 | Data write failure : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " A9 | Data write failure : This is the error that occurs in issuance commands.");
PrintAndLogEx(INFO, " AA | Key-change failure : Key change failed."); PrintAndLogEx(INFO, " AA | Key-change failure : Key change failed.");
PrintAndLogEx(INFO, " AB | Illegal Package Parity or illegal Package MAC : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " AB | Illegal Package Parity or illegal Package MAC : This is the error that occurs in issuance commands.");
@ -80,7 +80,7 @@ static void print_status_flag2_interpration(void) {
PrintAndLogEx(INFO, " AD | Service exists already : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " AD | Service exists already : This is the error that occurs in issuance commands.");
PrintAndLogEx(INFO, " AE | Illegal System Code : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " AE | Illegal System Code : This is the error that occurs in issuance commands.");
PrintAndLogEx(INFO, " AF | Too many simultaneous cyclic write operations : Number of simultaneous write Blocks\n" PrintAndLogEx(INFO, " AF | Too many simultaneous cyclic write operations : Number of simultaneous write Blocks\n"
" | specified by the command to Cyclic Service exceeds the number of Blocks assigned to Service."); " | specified by the command to Cyclic Service exceeds the number of Blocks assigned to Service.");
PrintAndLogEx(INFO, " C0 | Illegal Package Identifier : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " C0 | Illegal Package Identifier : This is the error that occurs in issuance commands.");
PrintAndLogEx(INFO, " C1 | Discrepancy of parameters inside and outside Package : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " C1 | Discrepancy of parameters inside and outside Package : This is the error that occurs in issuance commands.");
PrintAndLogEx(INFO, " C2 | Command is disabled already : This is the error that occurs in issuance commands."); PrintAndLogEx(INFO, " C2 | Command is disabled already : This is the error that occurs in issuance commands.");
@ -111,9 +111,9 @@ static void print_number_of_block_constraints(void) {
static void print_service_code_list_constraints(void) { static void print_service_code_list_constraints(void) {
PrintAndLogEx(INFO, " - Service Code List: For Service Code List, only Service Code existing in the product shall be specified:"); PrintAndLogEx(INFO, " - Service Code List: For Service Code List, only Service Code existing in the product shall be specified:");
PrintAndLogEx(INFO, " - Even when Service Code exists in the product, Service Code not referenced from Block List shall not \n" PrintAndLogEx(INFO, " - Even when Service Code exists in the product, Service Code not referenced from Block List shall not \n"
" be specified to Service Code List."); " be specified to Service Code List.");
PrintAndLogEx(INFO, " - For existence or nonexistence of Service in a product, please check using the Request Service \n" PrintAndLogEx(INFO, " - For existence or nonexistence of Service in a product, please check using the Request Service \n"
" (or Request Service v2) command."); " (or Request Service v2) command.");
} }
/* /*
@ -209,7 +209,7 @@ static bool add_last_IDm(uint8_t position, uint8_t *data) {
if (last_known_card.IDm[0] != 0 && last_known_card.IDm[1] != 0) { if (last_known_card.IDm[0] != 0 && last_known_card.IDm[1] != 0) {
memcpy(data + position, last_known_card.IDm, sizeof(last_known_card.IDm)); memcpy(data + position, last_known_card.IDm, sizeof(last_known_card.IDm));
return true; return true;
} }
return false; return false;
} }
@ -447,7 +447,7 @@ static bool check_last_idm(uint8_t *data, uint16_t datalen) {
PrintAndLogEx(WARNING, "No last known card! Use `" _YELLOW_("hf felica reader") "` first or set a custom IDm"); PrintAndLogEx(WARNING, "No last known card! Use `" _YELLOW_("hf felica reader") "` first or set a custom IDm");
return false; return false;
} }
PrintAndLogEx(INFO, "Using last known IDm... " _GREEN_("%s"), sprint_hex_inrow(data, datalen)); PrintAndLogEx(INFO, "Using last known IDm... " _GREEN_("%s"), sprint_hex_inrow(data, datalen));
return true; return true;
} }
@ -467,7 +467,7 @@ static int send_wr_plain(uint8_t flags, uint16_t datalen, uint8_t *data, bool ve
if (waitCmdFelica(0, &resp, verbose) == false) { if (waitCmdFelica(0, &resp, verbose) == false) {
PrintAndLogEx(ERR, "no response from card"); PrintAndLogEx(ERR, "no response from card");
return PM3_ERFTRANS; return PM3_ERFTRANS;
} }
memcpy(wr_noCry_resp, (felica_status_response_t *)resp.data.asBytes, sizeof(felica_status_response_t)); memcpy(wr_noCry_resp, (felica_status_response_t *)resp.data.asBytes, sizeof(felica_status_response_t));
return PM3_SUCCESS; return PM3_SUCCESS;
@ -493,13 +493,13 @@ static void reverse_3des_key(uint8_t *master_key, int length, uint8_t *reverse_m
static int CmdHFFelicaAuthentication1(const char *Cmd) { static int CmdHFFelicaAuthentication1(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "hf felica auth1", CLIParserInit(&ctx, "hf felica auth1",
"Initiate mutual authentication. This command must always be executed before Auth2 command\n" "Initiate mutual authentication. This command must always be executed before Auth2 command\n"
"and mutual authentication is achieve only after Auth2 command has succeeded.\n" "and mutual authentication is achieve only after Auth2 command has succeeded.\n"
_RED_("INCOMPLETE / EXPERIMENTAL COMMAND!!!"), _RED_("INCOMPLETE / EXPERIMENTAL COMMAND!!!"),
"hf felica auth1 --an 01 --acl 0000 --sn 01 --scl 8B00 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n" "hf felica auth1 --an 01 --acl 0000 --sn 01 --scl 8B00 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n"
"hf felica auth1 --an 01 --acl 0000 --sn 01 --scl 8B00 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAA\n" "hf felica auth1 --an 01 --acl 0000 --sn 01 --scl 8B00 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBAAAAAAAAAAAAAAAA\n"
"hf felica auth1 -i 11100910C11BC407 --an 01 --acl 0000 --sn 01 ..scl 8B00 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n" "hf felica auth1 -i 11100910C11BC407 --an 01 --acl 0000 --sn 01 ..scl 8B00 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_str0(NULL, "an", "<hex>", "number of areas, 1 byte"), arg_str0(NULL, "an", "<hex>", "number of areas, 1 byte"),
@ -569,7 +569,7 @@ static int CmdHFFelicaAuthentication1(const char *Cmd) {
} }
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x0C; // Static length data[0] = 0x0C; // Static length
data[1] = 0x3E; // Command ID data[1] = 0x3E; // Command ID
@ -580,14 +580,14 @@ static int CmdHFFelicaAuthentication1(const char *Cmd) {
memcpy(data + 2, idm, 8); memcpy(data + 2, idm, 8);
} }
// Length (1), // Length (1),
// Command ID (1), // Command ID (1),
// IDm (8), // IDm (8),
// Number of Area (1), // Number of Area (1),
// Area Code List (2), // Area Code List (2),
// Number of Service (1), // Number of Service (1),
// Service Code List (2), // Service Code List (2),
// M1c (16) // M1c (16)
uint16_t datalen = 32; uint16_t datalen = 32;
data[0] = (datalen & 0xFF); data[0] = (datalen & 0xFF);
data[1] = 0x10; // Command ID data[1] = 0x10; // Command ID
@ -597,14 +597,14 @@ static int CmdHFFelicaAuthentication1(const char *Cmd) {
} }
if (anlen) { if (anlen) {
data[10] = an[0]; data[10] = an[0];
} }
if (acllen) { if (acllen) {
data[11] = acl[0]; data[11] = acl[0];
data[12] = acl[1]; data[12] = acl[1];
} }
if (snlen) { if (snlen) {
data[13] = sn[0]; data[13] = sn[0];
} }
if (scllen) { if (scllen) {
data[14] = scl[0]; data[14] = scl[0];
@ -615,7 +615,7 @@ static int CmdHFFelicaAuthentication1(const char *Cmd) {
} }
// READER CHALLENGE - (RANDOM To Encrypt = Rac) // READER CHALLENGE - (RANDOM To Encrypt = Rac)
uint8_t nonce[8] = {1,2,3,4,5,6,7,8}; uint8_t nonce[8] = {1, 2, 3, 4, 5, 6, 7, 8};
PrintAndLogEx(INFO, "Reader challenge (unencrypted): %s", sprint_hex(nonce, 8)); PrintAndLogEx(INFO, "Reader challenge (unencrypted): %s", sprint_hex(nonce, 8));
// Create M1c Challenge with 3DES (3 Keys = 24, 2 Keys = 16) // Create M1c Challenge with 3DES (3 Keys = 24, 2 Keys = 16)
@ -624,7 +624,7 @@ static int CmdHFFelicaAuthentication1(const char *Cmd) {
mbedtls_des3_init(&des3_ctx); mbedtls_des3_init(&des3_ctx);
if (keylen == 24) { if (keylen == 24) {
mbedtls_des3_set3key_enc(&des3_ctx, master_key); mbedtls_des3_set3key_enc(&des3_ctx, master_key);
PrintAndLogEx(INFO, "3DES Master Secret: %s", sprint_hex(master_key, keylen)); PrintAndLogEx(INFO, "3DES Master Secret: %s", sprint_hex(master_key, keylen));
@ -659,8 +659,8 @@ static int CmdHFFelicaAuthentication1(const char *Cmd) {
if (waitCmdFelica(0, &resp, 1) == false) { if (waitCmdFelica(0, &resp, 1) == false) {
PrintAndLogEx(ERR, "no response from card"); PrintAndLogEx(ERR, "no response from card");
return PM3_ERFTRANS; return PM3_ERFTRANS;
} }
felica_auth1_response_t auth1_response; felica_auth1_response_t auth1_response;
memcpy(&auth1_response, (felica_auth1_response_t *)resp.data.asBytes, sizeof(felica_auth1_response_t)); memcpy(&auth1_response, (felica_auth1_response_t *)resp.data.asBytes, sizeof(felica_auth1_response_t));
@ -710,12 +710,12 @@ static int CmdHFFelicaAuthentication2(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "hf felica auth2", CLIParserInit(&ctx, "hf felica auth2",
"Complete mutual authentication. This command can only be executed subsquent to Auth1\n" "Complete mutual authentication. This command can only be executed subsquent to Auth1\n"
_RED_("INCOMPLETE / EXPERIMENTAL COMMAND!!!\n") _RED_("INCOMPLETE / EXPERIMENTAL COMMAND!!!\n")
_RED_("EXPERIMENTAL COMMAND - M2c/P2c will be not checked"), _RED_("EXPERIMENTAL COMMAND - M2c/P2c will be not checked"),
"hf felica auth2 --cc 0102030405060708 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n" "hf felica auth2 --cc 0102030405060708 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n"
"hf felica auth2 -i 11100910C11BC407 --cc 0102030405060708 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n" "hf felica auth2 -i 11100910C11BC407 --cc 0102030405060708 --key AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBB\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_str0("i", NULL, "<hex>", "set custom IDm"), arg_str0("i", NULL, "<hex>", "set custom IDm"),
@ -758,7 +758,7 @@ static int CmdHFFelicaAuthentication2(const char *Cmd) {
} }
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
bool custom_IDm = false; bool custom_IDm = false;
@ -776,7 +776,7 @@ static int CmdHFFelicaAuthentication2(const char *Cmd) {
} }
if (cclen) { if (cclen) {
memcpy(data + 16, cc, cclen); memcpy(data + 16, cc, cclen);
} }
if (keylen) { if (keylen) {
@ -791,7 +791,7 @@ static int CmdHFFelicaAuthentication2(const char *Cmd) {
// M3c (8) == cc // M3c (8) == cc
// unsigned char m3c[8]; == cc // unsigned char m3c[8]; == cc
mbedtls_des3_context des3_ctx_enc; mbedtls_des3_context des3_ctx_enc;
mbedtls_des3_context des3_ctx_dec; mbedtls_des3_context des3_ctx_dec;
@ -824,7 +824,7 @@ static int CmdHFFelicaAuthentication2(const char *Cmd) {
unsigned char p3c[8]; unsigned char p3c[8];
mbedtls_des3_crypt_ecb(&des3_ctx_dec, cc, p3c); mbedtls_des3_crypt_ecb(&des3_ctx_dec, cc, p3c);
PrintAndLogEx(INFO, "3DES decrypted M3c = P3c... %s", sprint_hex_inrow(p3c, sizeof(p3c))); PrintAndLogEx(INFO, "3DES decrypted M3c = P3c... %s", sprint_hex_inrow(p3c, sizeof(p3c)));
// Encrypt p3c with master_key // Encrypt p3c with master_key
unsigned char m4c[8]; unsigned char m4c[8];
mbedtls_des3_crypt_ecb(&des3_ctx_enc, p3c, m4c); mbedtls_des3_crypt_ecb(&des3_ctx_enc, p3c, m4c);
@ -848,7 +848,7 @@ static int CmdHFFelicaAuthentication2(const char *Cmd) {
if (waitCmdFelica(0, &resp, 1) == false) { if (waitCmdFelica(0, &resp, 1) == false) {
PrintAndLogEx(ERR, "no response from card"); PrintAndLogEx(ERR, "no response from card");
return PM3_ERFTRANS; return PM3_ERFTRANS;
} }
felica_auth2_response_t auth2_response; felica_auth2_response_t auth2_response;
memcpy(&auth2_response, (felica_auth2_response_t *)resp.data.asBytes, sizeof(felica_auth2_response_t)); memcpy(&auth2_response, (felica_auth2_response_t *)resp.data.asBytes, sizeof(felica_auth2_response_t));
@ -954,7 +954,7 @@ static int CmdHFFelicaWritePlain(const char *Cmd) {
} }
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x20; // Static length data[0] = 0x20; // Static length
data[1] = 0x08; // Command ID data[1] = 0x08; // Command ID
@ -1115,7 +1115,7 @@ static int CmdHFFelicaReadPlain(const char *Cmd) {
} }
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x10; // Static length data[0] = 0x10; // Static length
data[1] = 0x06; // Command ID data[1] = 0x06; // Command ID
@ -1152,7 +1152,7 @@ static int CmdHFFelicaReadPlain(const char *Cmd) {
PrintAndLogEx(INFO, "block | data "); PrintAndLogEx(INFO, "block | data ");
PrintAndLogEx(INFO, "------+----------------------------------------"); PrintAndLogEx(INFO, "------+----------------------------------------");
// main loop block reads // main loop block reads
if (all_block_list_elements) { if (all_block_list_elements) {
@ -1217,7 +1217,7 @@ static int CmdHFFelicaRequestResponse(const char *Cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x0A; // Static length data[0] = 0x0A; // Static length
data[1] = 0x04; // Command ID data[1] = 0x04; // Command ID
@ -1294,7 +1294,7 @@ static int CmdHFFelicaRequestSpecificationVersion(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
uint8_t reserved[2] = {0,0}; uint8_t reserved[2] = {0, 0};
int rlen = 0; int rlen = 0;
res = CLIParamHexToBuf(arg_get_str(ctx, 2), reserved, sizeof(reserved), &rlen); res = CLIParamHexToBuf(arg_get_str(ctx, 2), reserved, sizeof(reserved), &rlen);
if (res) { if (res) {
@ -1310,7 +1310,7 @@ static int CmdHFFelicaRequestSpecificationVersion(const char *Cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x0C; // Static length data[0] = 0x0C; // Static length
data[1] = 0x3C; // Command ID data[1] = 0x3C; // Command ID
@ -1322,9 +1322,9 @@ static int CmdHFFelicaRequestSpecificationVersion(const char *Cmd) {
memcpy(data + 2, idm, sizeof(idm)); memcpy(data + 2, idm, sizeof(idm));
} }
// add custom reserved // add custom reserved
if (rlen ) { if (rlen) {
memcpy(data +10, reserved, sizeof(reserved)); memcpy(data + 10, reserved, sizeof(reserved));
} else { } else {
data[10] = 0x00; // Reserved Value data[10] = 0x00; // Reserved Value
data[11] = 0x00; // Reserved Value data[11] = 0x00; // Reserved Value
@ -1337,7 +1337,7 @@ static int CmdHFFelicaRequestSpecificationVersion(const char *Cmd) {
AddCrc(data, datalen); AddCrc(data, datalen);
datalen += 2; datalen += 2;
uint8_t flags = (FELICA_APPEND_CRC |FELICA_RAW); uint8_t flags = (FELICA_APPEND_CRC | FELICA_RAW);
clear_and_send_command(flags, datalen, data, 0); clear_and_send_command(flags, datalen, data, 0);
@ -1346,7 +1346,7 @@ static int CmdHFFelicaRequestSpecificationVersion(const char *Cmd) {
PrintAndLogEx(FAILED, "Got no response from card"); PrintAndLogEx(FAILED, "Got no response from card");
return PM3_ERFTRANS; return PM3_ERFTRANS;
} }
felica_request_spec_response_t spec_response; felica_request_spec_response_t spec_response;
memcpy(&spec_response, (felica_request_spec_response_t *)resp.data.asBytes, sizeof(felica_request_spec_response_t)); memcpy(&spec_response, (felica_request_spec_response_t *)resp.data.asBytes, sizeof(felica_request_spec_response_t));
@ -1401,7 +1401,7 @@ static int CmdHFFelicaResetMode(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
uint8_t reserved[2] = {0,0}; uint8_t reserved[2] = {0, 0};
int rlen = 0; int rlen = 0;
res = CLIParamHexToBuf(arg_get_str(ctx, 2), reserved, sizeof(reserved), &rlen); res = CLIParamHexToBuf(arg_get_str(ctx, 2), reserved, sizeof(reserved), &rlen);
if (res) { if (res) {
@ -1417,7 +1417,7 @@ static int CmdHFFelicaResetMode(const char *Cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x0C; // Static length data[0] = 0x0C; // Static length
data[1] = 0x3E; // Command ID data[1] = 0x3E; // Command ID
@ -1495,7 +1495,7 @@ static int CmdHFFelicaRequestSystemCode(const char *Cmd) {
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
data[0] = 0x0A; // Static length data[0] = 0x0A; // Static length
data[1] = 0x0C; // Command ID data[1] = 0x0C; // Command ID
@ -1578,7 +1578,7 @@ static int CmdHFFelicaRequestService(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
uint8_t code[2] = {0,0}; uint8_t code[2] = {0, 0};
int clen = 0; int clen = 0;
res = CLIParamHexToBuf(arg_get_str(ctx, 3), code, sizeof(code), &clen); res = CLIParamHexToBuf(arg_get_str(ctx, 3), code, sizeof(code), &clen);
if (res) { if (res) {
@ -1596,7 +1596,7 @@ static int CmdHFFelicaRequestService(const char *Cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
bool custom_IDm = false; bool custom_IDm = false;
@ -1608,10 +1608,10 @@ static int CmdHFFelicaRequestService(const char *Cmd) {
if (all_nodes == false) { if (all_nodes == false) {
// Node Number // Node Number
if (nlen == 1) { if (nlen == 1) {
memcpy(data + 10, node, sizeof(node)); memcpy(data + 10, node, sizeof(node));
} }
// code // code
if (clen == 2) { if (clen == 2) {
memcpy(data + 11, code, sizeof(code)); memcpy(data + 11, code, sizeof(code));
} }
@ -2055,7 +2055,7 @@ static int CmdHFFelicaCmdRaw(const char *Cmd) {
int datalen = 0; int datalen = 0;
uint8_t data[PM3_CMD_DATA_SIZE]; uint8_t data[PM3_CMD_DATA_SIZE];
memset(data, 0 , sizeof(data)); memset(data, 0, sizeof(data));
CLIGetHexWithReturn(ctx, 7, data, &datalen); CLIGetHexWithReturn(ctx, 7, data, &datalen);
CLIParserFree(ctx); CLIParserFree(ctx);

4
client/src/cmdhffido.c
View file

@ -181,7 +181,7 @@ static int cmd_hf_fido_register(const char *cmd) {
"hf fido reg -> execute command with 2 parameters, filled 0x00\n" "hf fido reg -> execute command with 2 parameters, filled 0x00\n"
"hf fido reg -p s0 s1 -> execute command with plain parameters\n" "hf fido reg -p s0 s1 -> execute command with plain parameters\n"
"hf fido reg --cp 000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f --ap 000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f\n" "hf fido reg --cp 000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f --ap 000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -693,7 +693,7 @@ static int cmd_hf_fido_2make_credential(const char *cmd) {
"Sample file `fido2.json` in `client/resources/`.", "Sample file `fido2.json` in `client/resources/`.",
"hf fido make -> default parameters file `fido2.json`\n" "hf fido make -> default parameters file `fido2.json`\n"
"hf fido make -f test.json -> use parameters file `text.json`" "hf fido make -f test.json -> use parameters file `text.json`"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,

150
client/src/cmdhfmf.c
View file

@ -352,7 +352,7 @@ static int CmdHF14AMfWrBl(const char *Cmd) {
uint8_t block[MFBLOCK_SIZE] = {0x00}; uint8_t block[MFBLOCK_SIZE] = {0x00};
int blen = 0; int blen = 0;
CLIGetHexWithReturn(ctx, 5, block, &blen); CLIGetHexWithReturn(ctx, 5, block, &blen);
CLIParserFree(ctx); CLIParserFree(ctx);
if (blen != MFBLOCK_SIZE) { if (blen != MFBLOCK_SIZE) {
PrintAndLogEx(WARNING, "block data must include 16 HEX bytes. Got %i", blen); PrintAndLogEx(WARNING, "block data must include 16 HEX bytes. Got %i", blen);
@ -386,7 +386,7 @@ static int CmdHF14AMfWrBl(const char *Cmd) {
} else { } else {
PrintAndLogEx(FAILED, "Write ( " _RED_("fail") " )"); PrintAndLogEx(FAILED, "Write ( " _RED_("fail") " )");
// suggest the opposite keytype than what was used. // suggest the opposite keytype than what was used.
PrintAndLogEx(HINT, "Maybe access rights? Try specify keytype " _YELLOW_("%c") " instead", (keytype == MF_KEY_A) ? 'B' : 'A' ); PrintAndLogEx(HINT, "Maybe access rights? Try specify keytype " _YELLOW_("%c") " instead", (keytype == MF_KEY_A) ? 'B' : 'A');
} }
return PM3_SUCCESS; return PM3_SUCCESS;
} }
@ -423,7 +423,7 @@ static int CmdHF14AMfRdBl(const char *Cmd) {
uint8_t key[6] = {0}; uint8_t key[6] = {0};
CLIGetHexWithReturn(ctx, 4, key, &keylen); CLIGetHexWithReturn(ctx, 4, key, &keylen);
bool verbose = arg_get_lit(ctx, 5); bool verbose = arg_get_lit(ctx, 5);
CLIParserFree(ctx); CLIParserFree(ctx);
if (b > 255) { if (b > 255) {
return PM3_EINVARG; return PM3_EINVARG;
@ -477,7 +477,7 @@ static int CmdHF14AMfRdSc(const char *Cmd) {
int s = arg_get_int_def(ctx, 4, 0); int s = arg_get_int_def(ctx, 4, 0);
bool verbose = arg_get_lit(ctx, 5); bool verbose = arg_get_lit(ctx, 5);
CLIParserFree(ctx); CLIParserFree(ctx);
if (s > MIFARE_4K_MAXSECTOR) { if (s > MIFARE_4K_MAXSECTOR) {
PrintAndLogEx(WARNING, "Sector number must be less then 40"); PrintAndLogEx(WARNING, "Sector number must be less then 40");
@ -504,7 +504,7 @@ static int CmdHF14AMfRdSc(const char *Cmd) {
if (verbose) { if (verbose) {
decode_print_st(start + blocks - 1, data + ((blocks - 1) * MFBLOCK_SIZE)); decode_print_st(start + blocks - 1, data + ((blocks - 1) * MFBLOCK_SIZE));
} }
} }
free(data); free(data);
PrintAndLogEx(NORMAL, ""); PrintAndLogEx(NORMAL, "");
@ -813,7 +813,7 @@ static int CmdHF14AMfRestore(const char *Cmd) {
"The key file and data file will program the card sector trailers.\n" "The key file and data file will program the card sector trailers.\n"
"By default we authenticate to card with key B 0xFFFFFFFFFFFF.\n" "By default we authenticate to card with key B 0xFFFFFFFFFFFF.\n"
"\n" "\n"
"`--uid` param is used for filename templates `hf-mf-<uid>-dump.bin` and `hf-mf-<uid>-key.bin.\n" "`--uid` param is used for filename templates `hf-mf-<uid>-dump.bin` and `hf-mf-<uid>-key.bin.\n"
" If not specified, it will read the card uid instead.\n" " If not specified, it will read the card uid instead.\n"
" `-w` param you can indicate that the key file should be used for authentication instead.\n" " `-w` param you can indicate that the key file should be used for authentication instead.\n"
" if so we also try both B/A keys", " if so we also try both B/A keys",
@ -821,7 +821,7 @@ static int CmdHF14AMfRestore(const char *Cmd) {
"hf mf restore --1k --uid 04010203\n" "hf mf restore --1k --uid 04010203\n"
"hf mf restore --1k --uid 04010203 -k hf-mf-AABBCCDD-key.bin\n" "hf mf restore --1k --uid 04010203 -k hf-mf-AABBCCDD-key.bin\n"
"hf mf restore --4k" "hf mf restore --4k"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -952,7 +952,7 @@ static int CmdHF14AMfRestore(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
// default authentication key // default authentication key
uint8_t default_key[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; uint8_t default_key[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
PrintAndLogEx(INFO, "Restoring " _YELLOW_("%s")" to card", datafilename); PrintAndLogEx(INFO, "Restoring " _YELLOW_("%s")" to card", datafilename);
@ -974,7 +974,7 @@ static int CmdHF14AMfRestore(const char *Cmd) {
if (use_keyfile_for_auth == false) { if (use_keyfile_for_auth == false) {
// sector trailer // sector trailer
if (b == NumBlocksPerSector(s) - 1) { if (b == NumBlocksPerSector(s) - 1) {
bldata[0] = (keyA[s][0]); bldata[0] = (keyA[s][0]);
bldata[1] = (keyA[s][1]); bldata[1] = (keyA[s][1]);
bldata[2] = (keyA[s][2]); bldata[2] = (keyA[s][2]);
@ -1622,7 +1622,7 @@ static int CmdHF14AMfNestedHard(const char *Cmd) {
"hf mf hardnested -r --tk a0a1a2a3a4a5\n" "hf mf hardnested -r --tk a0a1a2a3a4a5\n"
"hf mf hardnested -t --tk a0a1a2a3a4a5\n" "hf mf hardnested -t --tk a0a1a2a3a4a5\n"
"hf mf hardnested --blk 0 -a -k a0a1a2a3a4a5 --tblk 4 --ta --tk FFFFFFFFFFFF" "hf mf hardnested --blk 0 -a -k a0a1a2a3a4a5 --tblk 4 --ta --tk FFFFFFFFFFFF"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -1635,7 +1635,7 @@ static int CmdHF14AMfNestedHard(const char *Cmd) {
arg_lit0(NULL, "tb", "Target key B"), arg_lit0(NULL, "tb", "Target key B"),
arg_str0(NULL, "tk", "<hex>", "Target key, 12 hex bytes"), // 8 arg_str0(NULL, "tk", "<hex>", "Target key, 12 hex bytes"), // 8
arg_str0("u", "uid", "<hex>", "R/W `hf-mf-<UID>-nonces.bin` instead of default name"), arg_str0("u", "uid", "<hex>", "R/W `hf-mf-<UID>-nonces.bin` instead of default name"),
arg_str0("f", "file", "<fn>", "R/W <name> instead of default name"), arg_str0("f", "file", "<fn>", "R/W <name> instead of default name"),
arg_lit0("r", "read", "Read `hf-mf-<UID>-nonces.bin` if tag present, otherwise `nonces.bin`, and start attack"), arg_lit0("r", "read", "Read `hf-mf-<UID>-nonces.bin` if tag present, otherwise `nonces.bin`, and start attack"),
arg_lit0("s", "slow", "Slower acquisition (required by some non standard cards)"), arg_lit0("s", "slow", "Slower acquisition (required by some non standard cards)"),
arg_lit0("t", "tests", "Run tests"), arg_lit0("t", "tests", "Run tests"),
@ -1751,7 +1751,7 @@ static int CmdHF14AMfNestedHard(const char *Cmd) {
free(fptr); free(fptr);
} }
if (uidlen) { if (uidlen) {
snprintf(filename, FILE_PATH_SIZE, "hf-mf-%s-nonces.bin", uid); snprintf(filename, FILE_PATH_SIZE, "hf-mf-%s-nonces.bin", uid);
} }
@ -1774,7 +1774,7 @@ static int CmdHF14AMfNestedHard(const char *Cmd) {
PrintAndLogEx(INFO, "Target block no " _YELLOW_("%3d") ", target key type: " _YELLOW_("%c") ", known target key: " _YELLOW_("%02x%02x%02x%02x%02x%02x%s"), PrintAndLogEx(INFO, "Target block no " _YELLOW_("%3d") ", target key type: " _YELLOW_("%c") ", known target key: " _YELLOW_("%02x%02x%02x%02x%02x%02x%s"),
trg_blockno, trg_blockno,
(trg_keytype == MF_KEY_B)? 'B' : 'A', (trg_keytype == MF_KEY_B) ? 'B' : 'A',
trg_key[0], trg_key[1], trg_key[2], trg_key[3], trg_key[4], trg_key[5], trg_key[0], trg_key[1], trg_key[2], trg_key[3], trg_key[4], trg_key[5],
know_target_key ? "" : " (not set)" know_target_key ? "" : " (not set)"
); );
@ -1808,7 +1808,7 @@ static int CmdHF14AMfNestedHard(const char *Cmd) {
static int CmdHF14AMfAutoPWN(const char *Cmd) { static int CmdHF14AMfAutoPWN(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "hf mf autopwn", CLIParserInit(&ctx, "hf mf autopwn",
"This command automates the key recovery process on MIFARE Classic cards.\n" "This command automates the key recovery process on MIFARE Classic cards.\n"
"It uses the fchk, chk, darkside, nested, hardnested and staticnested to recover keys.\n" "It uses the fchk, chk, darkside, nested, hardnested and staticnested to recover keys.\n"
@ -1817,7 +1817,7 @@ static int CmdHF14AMfAutoPWN(const char *Cmd) {
"hf mf autopwn -s 0 -a -k FFFFFFFFFFFF --> target MFC 1K card, Sector 0 with known key A 'FFFFFFFFFFFF'\n" "hf mf autopwn -s 0 -a -k FFFFFFFFFFFF --> target MFC 1K card, Sector 0 with known key A 'FFFFFFFFFFFF'\n"
"hf mf autopwn --1k -f mfc_default_keys --> target MFC 1K card, default dictionary\n" "hf mf autopwn --1k -f mfc_default_keys --> target MFC 1K card, default dictionary\n"
"hf mf autopwn --1k -s 0 -a -k FFFFFFFFFFFF -f mfc_default_keys --> combo of the two above samples" "hf mf autopwn --1k -s 0 -a -k FFFFFFFFFFFF -f mfc_default_keys --> combo of the two above samples"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -1825,7 +1825,7 @@ static int CmdHF14AMfAutoPWN(const char *Cmd) {
arg_int0("s", "sector", "<dec>", "Input sector number"), arg_int0("s", "sector", "<dec>", "Input sector number"),
arg_lit0("a", NULL, "Input key A (def)"), arg_lit0("a", NULL, "Input key A (def)"),
arg_lit0("b", NULL, "Input key B"), arg_lit0("b", NULL, "Input key B"),
arg_str0("f", "file", "<fn>", "filename of dictionary"), arg_str0("f", "file", "<fn>", "filename of dictionary"),
arg_lit0("s", "slow", "Slower acquisition (required by some non standard cards)"), arg_lit0("s", "slow", "Slower acquisition (required by some non standard cards)"),
arg_lit0("l", "legacy", "legacy mode (use the slow `hf mf chk`)"), arg_lit0("l", "legacy", "legacy mode (use the slow `hf mf chk`)"),
arg_lit0("v", "verbose", "verbose output (statistics)"), arg_lit0("v", "verbose", "verbose output (statistics)"),
@ -2197,7 +2197,7 @@ static int CmdHF14AMfAutoPWN(const char *Cmd) {
} else { } else {
PrintAndLogEx(SUCCESS, "target sector %3u key type %c -- found valid key [ " _GREEN_("%s") " ]", PrintAndLogEx(SUCCESS, "target sector %3u key type %c -- found valid key [ " _GREEN_("%s") " ]",
i, i,
(j == MF_KEY_B)? 'B' : 'A', (j == MF_KEY_B) ? 'B' : 'A',
sprint_hex_inrow(tmp_key, sizeof(tmp_key)) sprint_hex_inrow(tmp_key, sizeof(tmp_key))
); );
} }
@ -3560,7 +3560,7 @@ static int CmdHF14AMfEGetBlk(const char *Cmd) {
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int b = arg_get_int_def(ctx, 1, 0); int b = arg_get_int_def(ctx, 1, 0);
bool verbose = arg_get_lit(ctx, 2); bool verbose = arg_get_lit(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
if (b > 255) { if (b > 255) {
return PM3_EINVARG; return PM3_EINVARG;
@ -3597,7 +3597,7 @@ static int CmdHF14AMfEGetSc(const char *Cmd) {
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int s = arg_get_int_def(ctx, 1, 0); int s = arg_get_int_def(ctx, 1, 0);
bool verbose = arg_get_lit(ctx, 2); bool verbose = arg_get_lit(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
if (s > 39) { if (s > 39) {
PrintAndLogEx(WARNING, "Sector number must be less then 40"); PrintAndLogEx(WARNING, "Sector number must be less then 40");
@ -3636,7 +3636,7 @@ static int CmdHF14AMfEClear(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
CLIParserFree(ctx); CLIParserFree(ctx);
clearCommandBuffer(); clearCommandBuffer();
SendCommandNG(CMD_HF_MIFARE_EML_MEMCLR, NULL, 0); SendCommandNG(CMD_HF_MIFARE_EML_MEMCLR, NULL, 0);
return PM3_SUCCESS; return PM3_SUCCESS;
@ -3662,7 +3662,7 @@ static int CmdHF14AMfESet(const char *Cmd) {
uint8_t data[16] = {0x00}; uint8_t data[16] = {0x00};
int datalen = 0; int datalen = 0;
int res = CLIParamHexToBuf(arg_get_str(ctx, 2), data, sizeof(data), &datalen); int res = CLIParamHexToBuf(arg_get_str(ctx, 2), data, sizeof(data), &datalen);
CLIParserFree(ctx); CLIParserFree(ctx);
if (res) { if (res) {
PrintAndLogEx(FAILED, "Error parsing bytes"); PrintAndLogEx(FAILED, "Error parsing bytes");
return PM3_EINVARG; return PM3_EINVARG;
@ -3701,7 +3701,7 @@ int CmdHF14AMfELoad(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int fnlen = 0; int fnlen = 0;
char filename[FILE_PATH_SIZE]; char filename[FILE_PATH_SIZE];
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
@ -3714,7 +3714,7 @@ int CmdHF14AMfELoad(const char *Cmd) {
int numblks = arg_get_int_def(ctx, 7, -1); int numblks = arg_get_int_def(ctx, 7, -1);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4 + mu) > 1) { if ((m0 + m1 + m2 + m4 + mu) > 1) {
@ -3876,7 +3876,7 @@ static int CmdHF14AMfESave(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
int fnlen = 0; int fnlen = 0;
char filename[FILE_PATH_SIZE]; char filename[FILE_PATH_SIZE];
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
@ -3885,7 +3885,7 @@ static int CmdHF14AMfESave(const char *Cmd) {
bool m1 = arg_get_lit(ctx, 3); bool m1 = arg_get_lit(ctx, 3);
bool m2 = arg_get_lit(ctx, 4); bool m2 = arg_get_lit(ctx, 4);
bool m4 = arg_get_lit(ctx, 5); bool m4 = arg_get_lit(ctx, 5);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4) > 1) { if ((m0 + m1 + m2 + m4) > 1) {
@ -3895,7 +3895,7 @@ static int CmdHF14AMfESave(const char *Cmd) {
m1 = true; m1 = true;
} }
uint16_t block_cnt = MIFARE_1K_MAXBLOCK; uint16_t block_cnt = MIFARE_1K_MAXBLOCK;
if (m0) { if (m0) {
block_cnt = MIFARE_MINI_MAXBLOCK; block_cnt = MIFARE_MINI_MAXBLOCK;
@ -3959,7 +3959,7 @@ static int CmdHF14AMfEView(const char *Cmd) {
bool m1 = arg_get_lit(ctx, 2); bool m1 = arg_get_lit(ctx, 2);
bool m2 = arg_get_lit(ctx, 3); bool m2 = arg_get_lit(ctx, 3);
bool m4 = arg_get_lit(ctx, 4); bool m4 = arg_get_lit(ctx, 4);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4) > 1) { if ((m0 + m1 + m2 + m4) > 1) {
@ -4038,7 +4038,7 @@ static int CmdHF14AMfECFill(const char *Cmd) {
bool m1 = arg_get_lit(ctx, 4); bool m1 = arg_get_lit(ctx, 4);
bool m2 = arg_get_lit(ctx, 5); bool m2 = arg_get_lit(ctx, 5);
bool m4 = arg_get_lit(ctx, 6); bool m4 = arg_get_lit(ctx, 6);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4) > 1) { if ((m0 + m1 + m2 + m4) > 1) {
@ -4099,7 +4099,7 @@ static int CmdHF14AMfEKeyPrn(const char *Cmd) {
bool m1 = arg_get_lit(ctx, 3); bool m1 = arg_get_lit(ctx, 3);
bool m2 = arg_get_lit(ctx, 4); bool m2 = arg_get_lit(ctx, 4);
bool m4 = arg_get_lit(ctx, 5); bool m4 = arg_get_lit(ctx, 5);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4) > 1) { if ((m0 + m1 + m2 + m4) > 1) {
@ -4209,7 +4209,7 @@ static int CmdHF14AMfCSetUID(const char *Cmd) {
int slen = 0; int slen = 0;
uint8_t sak[1] = {0x00}; uint8_t sak[1] = {0x00};
CLIGetHexWithReturn(ctx, 4, sak, &slen); CLIGetHexWithReturn(ctx, 4, sak, &slen);
CLIParserFree(ctx); CLIParserFree(ctx);
// sanity checks // sanity checks
if (uidlen != 4 && uidlen != 7) { if (uidlen != 4 && uidlen != 7) {
@ -4229,14 +4229,14 @@ static int CmdHF14AMfCSetUID(const char *Cmd) {
uint8_t verify_uid[7] = {0}; uint8_t verify_uid[7] = {0};
int res = mfCSetUID( int res = mfCSetUID(
uid, uid,
uidlen, uidlen,
(alen) ? atqa : NULL, (alen) ? atqa : NULL,
(slen) ? sak : NULL, (slen) ? sak : NULL,
old_uid, old_uid,
verify_uid, verify_uid,
wipe_card wipe_card
); );
if (res) { if (res) {
PrintAndLogEx(ERR, "Can't set UID. error %d", res); PrintAndLogEx(ERR, "Can't set UID. error %d", res);
@ -4247,9 +4247,9 @@ static int CmdHF14AMfCSetUID(const char *Cmd) {
PrintAndLogEx(SUCCESS, "Old UID... %s", sprint_hex(old_uid, uidlen)); PrintAndLogEx(SUCCESS, "Old UID... %s", sprint_hex(old_uid, uidlen));
PrintAndLogEx(SUCCESS, "New UID... %s ( %s )", PrintAndLogEx(SUCCESS, "New UID... %s ( %s )",
sprint_hex(verify_uid, uidlen), sprint_hex(verify_uid, uidlen),
(res == 0) ? _GREEN_("verified") : _RED_("fail") (res == 0) ? _GREEN_("verified") : _RED_("fail")
); );
return PM3_SUCCESS; return PM3_SUCCESS;
} }
@ -4273,11 +4273,11 @@ static int CmdHF14AMfCWipe(const char *cmd) {
int uidlen = 0; int uidlen = 0;
uint8_t uid[8] = {0x00}; uint8_t uid[8] = {0x00};
CLIGetHexWithReturn(ctx, 1, uid, &uidlen); CLIGetHexWithReturn(ctx, 1, uid, &uidlen);
int alen = 0; int alen = 0;
uint8_t atqa[2] = {0x00}; uint8_t atqa[2] = {0x00};
CLIGetHexWithReturn(ctx, 2, atqa, &alen); CLIGetHexWithReturn(ctx, 2, atqa, &alen);
int slen = 0; int slen = 0;
uint8_t sak[1] = {0x00}; uint8_t sak[1] = {0x00};
CLIGetHexWithReturn(ctx, 3, sak, &slen); CLIGetHexWithReturn(ctx, 3, sak, &slen);
@ -4329,9 +4329,9 @@ static int CmdHF14AMfCSetBlk(const char *Cmd) {
CLIGetHexWithReturn(ctx, 2, data, &datalen); CLIGetHexWithReturn(ctx, 2, data, &datalen);
uint8_t wipe_card = arg_get_lit(ctx, 3); uint8_t wipe_card = arg_get_lit(ctx, 3);
CLIParserFree(ctx); CLIParserFree(ctx);
if (b < 0 || b >= MIFARE_1K_MAXBLOCK ) { if (b < 0 || b >= MIFARE_1K_MAXBLOCK) {
PrintAndLogEx(FAILED, "target block number out-of-range, got %i", b); PrintAndLogEx(FAILED, "target block number out-of-range, got %i", b);
return PM3_EINVARG; return PM3_EINVARG;
} }
@ -4372,13 +4372,13 @@ static int CmdHF14AMfCLoad(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int fnlen = 0; int fnlen = 0;
char filename[FILE_PATH_SIZE]; char filename[FILE_PATH_SIZE];
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
bool fill_from_emulator = arg_get_lit(ctx, 2); bool fill_from_emulator = arg_get_lit(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
if (fill_from_emulator) { if (fill_from_emulator) {
@ -4458,7 +4458,7 @@ static int CmdHF14AMfCLoad(const char *Cmd) {
// 64 or 256blocks. // 64 or 256blocks.
if (bytes_read != (MIFARE_1K_MAXBLOCK * MFBLOCK_SIZE) && if (bytes_read != (MIFARE_1K_MAXBLOCK * MFBLOCK_SIZE) &&
bytes_read != (MIFARE_4K_MAXBLOCK * MFBLOCK_SIZE)) { bytes_read != (MIFARE_4K_MAXBLOCK * MFBLOCK_SIZE)) {
PrintAndLogEx(ERR, "File content error. Read %zu bytes", bytes_read); PrintAndLogEx(ERR, "File content error. Read %zu bytes", bytes_read);
free(data); free(data);
return PM3_EFILE; return PM3_EFILE;
@ -4508,7 +4508,7 @@ static int CmdHF14AMfCLoad(const char *Cmd) {
// confirm number written blocks. Must be 64 or 256 blocks // confirm number written blocks. Must be 64 or 256 blocks
if (blockno != MIFARE_1K_MAXBLOCK) { if (blockno != MIFARE_1K_MAXBLOCK) {
if (blockno != MIFARE_4K_MAXBLOCK) { if (blockno != MIFARE_4K_MAXBLOCK) {
PrintAndLogEx(ERR, "File content error. There must be %u blocks", MIFARE_4K_MAXBLOCK); PrintAndLogEx(ERR, "File content error. There must be %u blocks", MIFARE_4K_MAXBLOCK);
return PM3_EFILE; return PM3_EFILE;
} }
@ -4538,7 +4538,7 @@ static int CmdHF14AMfCGetBlk(const char *Cmd) {
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int b = arg_get_int_def(ctx, 1, 0); int b = arg_get_int_def(ctx, 1, 0);
bool verbose = arg_get_lit(ctx, 2); bool verbose = arg_get_lit(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
if (b > 255) { if (b > 255) {
return PM3_EINVARG; return PM3_EINVARG;
@ -4555,7 +4555,7 @@ static int CmdHF14AMfCGetBlk(const char *Cmd) {
uint8_t sector = GetSectorFromBlockNo(blockno); uint8_t sector = GetSectorFromBlockNo(blockno);
mf_print_sector_hdr(sector); mf_print_sector_hdr(sector);
mf_print_block(blockno, data); mf_print_block(blockno, data);
if (verbose) { if (verbose) {
decode_print_st(blockno, data); decode_print_st(blockno, data);
} else { } else {
@ -4580,7 +4580,7 @@ static int CmdHF14AMfCGetSc(const char *Cmd) {
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int s = arg_get_int_def(ctx, 1, 0); int s = arg_get_int_def(ctx, 1, 0);
bool verbose = arg_get_lit(ctx, 2); bool verbose = arg_get_lit(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
if (s > 39) { if (s > 39) {
PrintAndLogEx(WARNING, "Sector number must be less then 40"); PrintAndLogEx(WARNING, "Sector number must be less then 40");
return PM3_EINVARG; return PM3_EINVARG;
@ -4636,7 +4636,7 @@ static int CmdHF14AMfCSave(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
int fnlen = 0; int fnlen = 0;
char filename[FILE_PATH_SIZE]; char filename[FILE_PATH_SIZE];
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
@ -4646,7 +4646,7 @@ static int CmdHF14AMfCSave(const char *Cmd) {
bool m2 = arg_get_lit(ctx, 4); bool m2 = arg_get_lit(ctx, 4);
bool m4 = arg_get_lit(ctx, 5); bool m4 = arg_get_lit(ctx, 5);
bool fill_emulator = arg_get_lit(ctx, 6); bool fill_emulator = arg_get_lit(ctx, 6);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4) > 1) { if ((m0 + m1 + m2 + m4) > 1) {
@ -4791,7 +4791,7 @@ static int CmdHF14AMfCView(const char *Cmd) {
bool m1 = arg_get_lit(ctx, 2); bool m1 = arg_get_lit(ctx, 2);
bool m2 = arg_get_lit(ctx, 3); bool m2 = arg_get_lit(ctx, 3);
bool m4 = arg_get_lit(ctx, 4); bool m4 = arg_get_lit(ctx, 4);
CLIParserFree(ctx); CLIParserFree(ctx);
// validations // validations
if ((m0 + m1 + m2 + m4) > 1) { if ((m0 + m1 + m2 + m4) > 1) {
@ -4906,7 +4906,7 @@ static int CmdHf14AMfDecryptBytes(const char *Cmd) {
uint32_t nt = 0; uint32_t nt = 0;
int res = arg_get_u32_hexstr_def(ctx, 1, 0, &nt); int res = arg_get_u32_hexstr_def(ctx, 1, 0, &nt);
if (res != 1) { if (res != 1) {
CLIParserFree(ctx); CLIParserFree(ctx);
PrintAndLogEx(WARNING, "check `nt` parameter"); PrintAndLogEx(WARNING, "check `nt` parameter");
return PM3_EINVARG; return PM3_EINVARG;
} }
@ -4914,7 +4914,7 @@ static int CmdHf14AMfDecryptBytes(const char *Cmd) {
uint32_t ar_enc = 0; uint32_t ar_enc = 0;
res = arg_get_u32_hexstr_def(ctx, 2, 0, &ar_enc); res = arg_get_u32_hexstr_def(ctx, 2, 0, &ar_enc);
if (res != 1) { if (res != 1) {
CLIParserFree(ctx); CLIParserFree(ctx);
PrintAndLogEx(WARNING, "check `ar` parameter"); PrintAndLogEx(WARNING, "check `ar` parameter");
return PM3_EINVARG; return PM3_EINVARG;
} }
@ -4922,7 +4922,7 @@ static int CmdHf14AMfDecryptBytes(const char *Cmd) {
uint32_t at_enc = 0; uint32_t at_enc = 0;
res = arg_get_u32_hexstr_def(ctx, 3, 0, &at_enc); res = arg_get_u32_hexstr_def(ctx, 3, 0, &at_enc);
if (res != 1) { if (res != 1) {
CLIParserFree(ctx); CLIParserFree(ctx);
PrintAndLogEx(WARNING, "check `at` parameter"); PrintAndLogEx(WARNING, "check `at` parameter");
return PM3_EINVARG; return PM3_EINVARG;
} }
@ -4930,7 +4930,7 @@ static int CmdHf14AMfDecryptBytes(const char *Cmd) {
int datalen = 0; int datalen = 0;
uint8_t data[512] = {0x00}; uint8_t data[512] = {0x00};
CLIGetHexWithReturn(ctx, 4, data, &datalen); CLIGetHexWithReturn(ctx, 4, data, &datalen);
CLIParserFree(ctx); CLIParserFree(ctx);
PrintAndLogEx(INFO, "nt....... %08X", nt); PrintAndLogEx(INFO, "nt....... %08X", nt);
PrintAndLogEx(INFO, "ar enc... %08X", ar_enc); PrintAndLogEx(INFO, "ar enc... %08X", ar_enc);
@ -4955,12 +4955,12 @@ static int CmdHf14AMfSetMod(const char *Cmd) {
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
bool m0 = arg_get_lit(ctx, 1); bool m0 = arg_get_lit(ctx, 1);
bool m1 = arg_get_lit(ctx, 2); bool m1 = arg_get_lit(ctx, 2);
int keylen = 0; int keylen = 0;
uint8_t key[6] = {0}; uint8_t key[6] = {0};
CLIGetHexWithReturn(ctx, 3, key, &keylen); CLIGetHexWithReturn(ctx, 3, key, &keylen);
CLIParserFree(ctx); CLIParserFree(ctx);
if (m0 + m1 > 1) { if (m0 + m1 > 1) {
PrintAndLogEx(WARNING, "please select one modulation"); PrintAndLogEx(WARNING, "please select one modulation");
@ -5006,7 +5006,7 @@ static int CmdHf14AMfNack(const char *Cmd) {
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
bool verbose = arg_get_lit(ctx, 1); bool verbose = arg_get_lit(ctx, 1);
CLIParserFree(ctx); CLIParserFree(ctx);
if (verbose) if (verbose)
PrintAndLogEx(INFO, "Started testing card for NACK bug. Press Enter to abort"); PrintAndLogEx(INFO, "Started testing card for NACK bug. Press Enter to abort");
@ -5439,7 +5439,7 @@ static int CmdHFMFPersonalize(const char *cmd) {
"hf mf personalize -f2 -> single size random ID\n" "hf mf personalize -f2 -> single size random ID\n"
"hf mf personalize -f3 -> single size NUID\n" "hf mf personalize -f3 -> single size NUID\n"
"hf mf personalize -b -k B0B1B2B3B4B5 -f3 -> use key B = 0xB0B1B2B3B4B5" "hf mf personalize -b -k B0B1B2B3B4B5 -f3 -> use key B = 0xB0B1B2B3B4B5"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -5449,7 +5449,7 @@ static int CmdHFMFPersonalize(const char *cmd) {
arg_lit0(NULL, "f0", "UIDFO, double size UID"), arg_lit0(NULL, "f0", "UIDFO, double size UID"),
arg_lit0(NULL, "f1", "UIDF1, double size UID, optional usage of selection process shortcut"), arg_lit0(NULL, "f1", "UIDF1, double size UID, optional usage of selection process shortcut"),
arg_lit0(NULL, "f2", "UIDF2, single size random ID"), arg_lit0(NULL, "f2", "UIDF2, single size random ID"),
arg_lit0(NULL, "f3", "UIDF3, single size NUID"), arg_lit0(NULL, "f3", "UIDF3, single size NUID"),
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, cmd, argtable, true); CLIExecWithReturn(ctx, cmd, argtable, true);
@ -5462,7 +5462,7 @@ static int CmdHFMFPersonalize(const char *cmd) {
CLIParserFree(ctx); CLIParserFree(ctx);
return PM3_EINVARG; return PM3_EINVARG;
} }
uint8_t keytype = 0; uint8_t keytype = 0;
if (use_b) { if (use_b) {
keytype = 1; keytype = 1;
@ -5500,7 +5500,7 @@ static int CmdHFMFPersonalize(const char *cmd) {
pers_option = MIFARE_EV1_UIDF1; pers_option = MIFARE_EV1_UIDF1;
} else if (f2) { } else if (f2) {
pers_option = MIFARE_EV1_UIDF2; pers_option = MIFARE_EV1_UIDF2;
} }
CLIParserFree(ctx); CLIParserFree(ctx);
@ -5520,7 +5520,7 @@ static int CmdHFMFPersonalize(const char *cmd) {
return PM3_ETIMEOUT; return PM3_ETIMEOUT;
} }
if ( resp.status == PM3_SUCCESS) { if (resp.status == PM3_SUCCESS) {
PrintAndLogEx(SUCCESS, "Personalization ( %s )", _GREEN_("ok")); PrintAndLogEx(SUCCESS, "Personalization ( %s )", _GREEN_("ok"));
} else { } else {
PrintAndLogEx(FAILED, "Personalization ( %s )", _RED_("fail")); PrintAndLogEx(FAILED, "Personalization ( %s )", _RED_("fail"));
@ -5551,11 +5551,11 @@ static int CmdHf14AGen3UID(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
uint8_t uid[7] = {0}; uint8_t uid[7] = {0};
int uidlen = 0; int uidlen = 0;
CLIGetHexWithReturn(ctx, 1, uid, &uidlen); CLIGetHexWithReturn(ctx, 1, uid, &uidlen);
CLIParserFree(ctx); CLIParserFree(ctx);
// sanity checks // sanity checks
if (uidlen != 4 && uidlen != 7) { if (uidlen != 4 && uidlen != 7) {
@ -5598,11 +5598,11 @@ static int CmdHf14AGen3Block(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
uint8_t data[MFBLOCK_SIZE] = {0x00}; uint8_t data[MFBLOCK_SIZE] = {0x00};
int datalen = 0; int datalen = 0;
CLIGetHexWithReturn(ctx, 1, data, &datalen); CLIGetHexWithReturn(ctx, 1, data, &datalen);
CLIParserFree(ctx); CLIParserFree(ctx);
uint8_t new_block[MFBLOCK_SIZE] = {0x00}; uint8_t new_block[MFBLOCK_SIZE] = {0x00};
int res = mfGen3Block(data, datalen, new_block); int res = mfGen3Block(data, datalen, new_block);
@ -5630,7 +5630,7 @@ static int CmdHf14AGen3Freeze(const char *Cmd) {
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
bool confirm = arg_get_lit(ctx, 1); bool confirm = arg_get_lit(ctx, 1);
CLIParserFree(ctx); CLIParserFree(ctx);
if (confirm == false) { if (confirm == false) {
PrintAndLogEx(INFO, "please confirm that you want to perma lock the card"); PrintAndLogEx(INFO, "please confirm that you want to perma lock the card");
return PM3_SUCCESS; return PM3_SUCCESS;
@ -5907,7 +5907,7 @@ out:
} }
static int CmdHF14AMfView(const char *Cmd) { static int CmdHF14AMfView(const char *Cmd) {
CLIParserContext *ctx; CLIParserContext *ctx;
CLIParserInit(&ctx, "hf mf view", CLIParserInit(&ctx, "hf mf view",
"Print a MIFARE Classic dump file (bin/eml/json)", "Print a MIFARE Classic dump file (bin/eml/json)",
@ -5919,12 +5919,12 @@ static int CmdHF14AMfView(const char *Cmd) {
arg_lit0("v", "verbose", "verbose output"), arg_lit0("v", "verbose", "verbose output"),
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
int fnlen = 0; int fnlen = 0;
char filename[FILE_PATH_SIZE]; char filename[FILE_PATH_SIZE];
CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen); CLIParamStrToBuf(arg_get_str(ctx, 1), (uint8_t *)filename, FILE_PATH_SIZE, &fnlen);
bool verbose = arg_get_lit(ctx, 2); bool verbose = arg_get_lit(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
// reserve memory // reserve memory
uint8_t *dump = calloc(MFBLOCK_SIZE * MIFARE_4K_MAXBLOCK, sizeof(uint8_t)); uint8_t *dump = calloc(MFBLOCK_SIZE * MIFARE_4K_MAXBLOCK, sizeof(uint8_t));

2
client/src/cmdhfmfhard.c
View file

@ -2203,7 +2203,7 @@ static void init_it_all(void) {
known_target_key = 0; known_target_key = 0;
test_state[0] = 0; test_state[0] = 0;
test_state[1] = 0; test_state[1] = 0;
brute_force_per_second=0; brute_force_per_second = 0;
init_book_of_work(); init_book_of_work();
real_sum_a8 = 0; real_sum_a8 = 0;

16
client/src/cmdhfmfp.c
View file

@ -460,13 +460,13 @@ static int CmdHFMFPWritePerso(const char *Cmd) {
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
bool verbose = arg_get_lit(ctx, 1); bool verbose = arg_get_lit(ctx, 1);
uint8_t keyNum[64] = {0}; uint8_t keyNum[64] = {0};
int keyNumLen = 0; int keyNumLen = 0;
CLIGetHexWithReturn(ctx, 2, keyNum, &keyNumLen); CLIGetHexWithReturn(ctx, 2, keyNum, &keyNumLen);
uint8_t key[64] = {0}; uint8_t key[64] = {0};
int keyLen = 0; int keyLen = 0;
CLIGetHexWithReturn(ctx, 3, key, &keyLen); CLIGetHexWithReturn(ctx, 3, key, &keyLen);
@ -546,7 +546,7 @@ static int CmdHFMFPInitPerso(const char *Cmd) {
uint8_t data[250] = {0}; uint8_t data[250] = {0};
int datalen = 0; int datalen = 0;
int res; int res;
mfpSetVerboseMode(verbose2); mfpSetVerboseMode(verbose2);
for (uint16_t sn = 0x4000; sn < 0x4050; sn++) { for (uint16_t sn = 0x4000; sn < 0x4050; sn++) {
keyNum[0] = sn >> 8; keyNum[0] = sn >> 8;
@ -590,8 +590,8 @@ static int CmdHFMFPCommitPerso(const char *Cmd) {
CLIParserInit(&ctx, "hf mfp commitp", CLIParserInit(&ctx, "hf mfp commitp",
"Executes Commit Perso command. Can be used in SL0 mode only.", "Executes Commit Perso command. Can be used in SL0 mode only.",
"hf mfp commitp\n" "hf mfp commitp\n"
// "hf mfp commitp --sl 1" // "hf mfp commitp --sl 1"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -601,7 +601,7 @@ static int CmdHFMFPCommitPerso(const char *Cmd) {
}; };
CLIExecWithReturn(ctx, Cmd, argtable, true); CLIExecWithReturn(ctx, Cmd, argtable, true);
bool verbose = arg_get_lit(ctx, 1); bool verbose = arg_get_lit(ctx, 1);
// int slmode = arg_get_int(ctx, 2); // int slmode = arg_get_int(ctx, 2);
CLIParserFree(ctx); CLIParserFree(ctx);
mfpSetVerboseMode(verbose); mfpSetVerboseMode(verbose);
@ -677,7 +677,7 @@ static int CmdHFMFPRdbl(const char *Cmd) {
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_lit0("v", "verbose", "show internal data"), arg_lit0("v", "verbose", "show internal data"),
arg_int0("n", "count", "<dec>","blocks count (by default 1)"), arg_int0("n", "count", "<dec>", "blocks count (by default 1)"),
arg_lit0("b", "keyb", "use key B (by default keyA)"), arg_lit0("b", "keyb", "use key B (by default keyA)"),
arg_lit0("p", "plain", "plain communication mode between reader and card"), arg_lit0("p", "plain", "plain communication mode between reader and card"),
arg_int1(NULL, "blk", "<dec>", "block number (0..255)"), arg_int1(NULL, "blk", "<dec>", "block number (0..255)"),
@ -882,7 +882,7 @@ static int CmdHFMFPWrbl(const char *Cmd) {
"Writes one block to Mifare Plus card", "Writes one block to Mifare Plus card",
"hf mfp wrbl --blk 1 -d ff0000000000000000000000000000ff --key 000102030405060708090a0b0c0d0e0f -> writes block 1 data\n" "hf mfp wrbl --blk 1 -d ff0000000000000000000000000000ff --key 000102030405060708090a0b0c0d0e0f -> writes block 1 data\n"
"hf mfp wrbl --blk 2 -d ff0000000000000000000000000000ff -v -> writes block 2 data with default key 0xFF..0xFF" "hf mfp wrbl --blk 2 -d ff0000000000000000000000000000ff -v -> writes block 2 data with default key 0xFF..0xFF"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,

56
client/src/cmdlfhitag.c
View file

@ -520,7 +520,7 @@ static int CmdLFHitagReader(const char *Cmd) {
" lf hitag reader --22 --nrar 0102030411223344\n" " lf hitag reader --22 --nrar 0102030411223344\n"
" lf hitag reader --23 -k 4F4E4D494B52\n" " lf hitag reader --23 -k 4F4E4D494B52\n"
" lf hitag reader --26\n" " lf hitag reader --26\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -531,8 +531,8 @@ static int CmdLFHitagReader(const char *Cmd) {
arg_lit0(NULL, "23", "Hitag2, read all pages, crypto mode. Key ISK high + ISK low. def 4F4E4D494B52 (ONMIKR)"), arg_lit0(NULL, "23", "Hitag2, read all pages, crypto mode. Key ISK high + ISK low. def 4F4E4D494B52 (ONMIKR)"),
arg_lit0(NULL, "25", "Hitag2, test recorded authentications (replay?)"), arg_lit0(NULL, "25", "Hitag2, test recorded authentications (replay?)"),
arg_lit0(NULL, "26", "Hitag2, read UID"), arg_lit0(NULL, "26", "Hitag2, read UID"),
arg_str0("k","key", "<hex>", "key, 4 or 6 hex bytes"), arg_str0("k", "key", "<hex>", "key, 4 or 6 hex bytes"),
arg_str0(NULL,"nrar", "<hex>", "nonce / answer reader, 8 hex bytes"), arg_str0(NULL, "nrar", "<hex>", "nonce / answer reader, 8 hex bytes"),
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
@ -592,7 +592,7 @@ static int CmdLFHitagReader(const char *Cmd) {
htf = RHTSF_CHALLENGE; htf = RHTSF_CHALLENGE;
memcpy(htd.auth.NrAr, nrar, sizeof(nrar)); memcpy(htd.auth.NrAr, nrar, sizeof(nrar));
} }
if (s02){ if (s02) {
cmd = CMD_LF_HITAGS_READ; cmd = CMD_LF_HITAGS_READ;
htf = RHTSF_KEY; htf = RHTSF_KEY;
memcpy(htd.crypto.key, key, sizeof(key)); memcpy(htd.crypto.key, key, sizeof(key));
@ -615,7 +615,7 @@ static int CmdLFHitagReader(const char *Cmd) {
if (h26) { if (h26) {
htf = RHT2F_UID_ONLY; htf = RHT2F_UID_ONLY;
} }
clearCommandBuffer(); clearCommandBuffer();
SendCommandMIX(cmd, htf, 0, 0, &htd, sizeof(htd)); SendCommandMIX(cmd, htf, 0, 0, &htd, sizeof(htd));
PacketResponseNG resp; PacketResponseNG resp;
@ -698,7 +698,7 @@ static int CmdLFHitagWriter(const char *Cmd) {
"Hitag 2\n" "Hitag 2\n"
" lf hitag writer --24 -k 4F4E4D494B52 -p 3 -d 01020304\n" " lf hitag writer --24 -k 4F4E4D494B52 -p 3 -d 01020304\n"
" lf hitag writer --27 -k 4D494B52 -p 3 -d 01020304\n" " lf hitag writer --27 -k 4D494B52 -p 3 -d 01020304\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -708,8 +708,8 @@ static int CmdLFHitagWriter(const char *Cmd) {
arg_lit0(NULL, "27", "Hitag2, write page, password mode"), arg_lit0(NULL, "27", "Hitag2, write page, password mode"),
arg_int1("p", "page", "<dec>", "page address to write to"), arg_int1("p", "page", "<dec>", "page address to write to"),
arg_str0("d", "data", "<hex>", "data, 4 hex bytes"), arg_str0("d", "data", "<hex>", "data, 4 hex bytes"),
arg_str0("k","key", "<hex>", "key, 4 or 6 hex bytes"), arg_str0("k", "key", "<hex>", "key, 4 or 6 hex bytes"),
arg_str0(NULL,"nrar", "<hex>", "nonce / answer writer, 8 hex bytes"), arg_str0(NULL, "nrar", "<hex>", "nonce / answer writer, 8 hex bytes"),
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
@ -743,7 +743,7 @@ static int CmdLFHitagWriter(const char *Cmd) {
uint8_t nrar[8]; uint8_t nrar[8];
int nalen = 0; int nalen = 0;
res = CLIParamHexToBuf(arg_get_str(ctx, 8), nrar, sizeof(nrar), &nalen); res = CLIParamHexToBuf(arg_get_str(ctx, 8), nrar, sizeof(nrar), &nalen);
CLIParserFree(ctx); CLIParserFree(ctx);
if (res != 0) { if (res != 0) {
@ -782,7 +782,7 @@ static int CmdLFHitagWriter(const char *Cmd) {
memcpy(htd.auth.NrAr, nrar, sizeof(nrar)); memcpy(htd.auth.NrAr, nrar, sizeof(nrar));
memcpy(htd.auth.data, data, sizeof(data)); memcpy(htd.auth.data, data, sizeof(data));
} }
if (s04){ if (s04) {
htf = WHTSF_KEY; htf = WHTSF_KEY;
memcpy(htd.crypto.key, key, sizeof(key)); memcpy(htd.crypto.key, key, sizeof(key));
memcpy(htd.crypto.data, data, sizeof(data)); memcpy(htd.crypto.data, data, sizeof(data));
@ -822,13 +822,13 @@ static int CmdLFHitag2Dump(const char *Cmd) {
"In crypto mode the default key is 4F4E4D494B52 (ONMIKR) format: ISK high + ISK low.", "In crypto mode the default key is 4F4E4D494B52 (ONMIKR) format: ISK high + ISK low.",
"lf hitag dump -k 4F4E4D494B52\n" "lf hitag dump -k 4F4E4D494B52\n"
"lf hitag dump -k 4D494B52\n" "lf hitag dump -k 4D494B52\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
arg_str0("f", "file", "<fn>", "file name"), arg_str0("f", "file", "<fn>", "file name"),
arg_str0("k","key", "<hex>", "key, 4 or 6 hex bytes"), arg_str0("k", "key", "<hex>", "key, 4 or 6 hex bytes"),
arg_str0(NULL,"nrar", "<hex>", "nonce / answer reader, 8 hex bytes"), arg_str0(NULL, "nrar", "<hex>", "nonce / answer reader, 8 hex bytes"),
arg_param_end arg_param_end
}; };
CLIExecWithReturn(ctx, Cmd, argtable, false); CLIExecWithReturn(ctx, Cmd, argtable, false);
@ -858,23 +858,23 @@ static int CmdLFHitag2Dump(const char *Cmd) {
PrintAndLogEx(WARNING, "to be implememted..."); PrintAndLogEx(WARNING, "to be implememted...");
/* /*
PrintAndLogEx(SUCCESS, "Dumping tag memory..."); PrintAndLogEx(SUCCESS, "Dumping tag memory...");
clearCommandBuffer(); clearCommandBuffer();
//SendCommandNG(CMD_LF_HITAG_DUMP, &htd, sizeof(htd)); //SendCommandNG(CMD_LF_HITAG_DUMP, &htd, sizeof(htd));
PacketResponseNG resp; PacketResponseNG resp;
uint8_t *data = resp.data.asBytes; uint8_t *data = resp.data.asBytes;
if (fnlen < 1) { if (fnlen < 1) {
char *fptr = filename; char *fptr = filename;
fptr += sprintf(fptr, "lf-hitag-"); fptr += sprintf(fptr, "lf-hitag-");
FillFileNameByUID(fptr, data, "-dump", 4); FillFileNameByUID(fptr, data, "-dump", 4);
} }
saveFile(filename, ".bin", data, 48); saveFile(filename, ".bin", data, 48);
saveFileEML(filename, data, 48, 4); saveFileEML(filename, data, 48, 4);
saveFileJSON(filename, jsfHitag, data, 48, NULL); saveFileJSON(filename, jsfHitag, data, 48, NULL);
*/ */
return PM3_SUCCESS; return PM3_SUCCESS;
} }

4
client/src/cmdlft55xx.c
View file

@ -2336,7 +2336,7 @@ static int CmdT55xxRestore(const char *Cmd) {
return PM3_EINVARG; return PM3_EINVARG;
} }
size_t dlen = 0; size_t dlen = 0;
uint8_t *dump = calloc(T55x7_BLOCK_COUNT * 4, sizeof(uint8_t)); uint8_t *dump = calloc(T55x7_BLOCK_COUNT * 4, sizeof(uint8_t));
if (dump == NULL) { if (dump == NULL) {
PrintAndLogEx(WARNING, "Fail, cannot allocate memory"); PrintAndLogEx(WARNING, "Fail, cannot allocate memory");
@ -2387,7 +2387,7 @@ static int CmdT55xxRestore(const char *Cmd) {
if (usepwd) if (usepwd)
snprintf(pwdopt, sizeof(pwdopt), "-p %08X", password); snprintf(pwdopt, sizeof(pwdopt), "-p %08X", password);
uint32_t *data = (uint32_t*) dump; uint32_t *data = (uint32_t *) dump;
uint8_t idx; uint8_t idx;
// Restore endien for writing to card // Restore endien for writing to card
for (idx = 0; idx < 12; idx++) { for (idx = 0; idx < 12; idx++) {

2
client/src/cmdwiegand.c
View file

@ -137,7 +137,7 @@ int CmdWiegandDecode(const char *Cmd) {
uint32_t top = 0, mid = 0, bot = 0; uint32_t top = 0, mid = 0, bot = 0;
if (hlen) { if (hlen) {
res = hexstring_to_u96(&top, &mid, &bot, hex); res = hexstring_to_u96(&top, &mid, &bot, hex);
if (res != hlen) { if (res != hlen) {
PrintAndLogEx(ERR, "hex string contains none hex chars"); PrintAndLogEx(ERR, "hex string contains none hex chars");

6
client/src/emv/cmdemv.c
View file

@ -1083,7 +1083,7 @@ static int CmdEMVExec(const char *Cmd) {
PrintAndLogEx(NORMAL, "AC: %s", sprint_hex(AC->value, AC->len)); PrintAndLogEx(NORMAL, "AC: %s", sprint_hex(AC->value, AC->len));
if (IAD) { if (IAD) {
PrintAndLogEx(NORMAL, "IAD: %s", sprint_hex(IAD->value, IAD->len)); PrintAndLogEx(NORMAL, "IAD: %s", sprint_hex(IAD->value, IAD->len));
// https://mst-company.ru/blog/ekvajring-emv-tranzaktsiya-emv-transaction-flow-chast-4-pdol-i-beskontaktnye-karty-osobennosti-qvsdc-i-quics // https://mst-company.ru/blog/ekvajring-emv-tranzaktsiya-emv-transaction-flow-chast-4-pdol-i-beskontaktnye-karty-osobennosti-qvsdc-i-quics
if (IAD->value[0] == 0x1f) { if (IAD->value[0] == 0x1f) {
PrintAndLogEx(NORMAL, " Key index: 0x%02x", IAD->value[2]); PrintAndLogEx(NORMAL, " Key index: 0x%02x", IAD->value[2]);
@ -1421,7 +1421,7 @@ static int CmdEMVScan(const char *Cmd) {
"It executes EMV contactless transaction and saves result to a file which can be used for emulation\n", "It executes EMV contactless transaction and saves result to a file which can be used for emulation\n",
"emv scan -at -> scan MSD transaction mode and show APDU and TLV\n" "emv scan -at -> scan MSD transaction mode and show APDU and TLV\n"
"emv scan -c -> scan CDA transaction mode\n" "emv scan -c -> scan CDA transaction mode\n"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,
@ -1818,7 +1818,7 @@ static int CmdEMVTest(const char *Cmd) {
"Executes tests\n", "Executes tests\n",
"emv test -i\n" "emv test -i\n"
"emv test --long" "emv test --long"
); );
void *argtable[] = { void *argtable[] = {
arg_param_begin, arg_param_begin,

32
client/src/mifare/mifare4.c
View file

@ -45,25 +45,25 @@ const char *mfpGetErrorDescription(uint8_t errorCode) {
} }
AccessConditions_t MFAccessConditions[] = { AccessConditions_t MFAccessConditions[] = {
{0x00, "read AB; write AB; increment AB; decrement transfer restore AB"}, {0x00, "read AB; write AB; increment AB; decrement transfer restore AB"},
{0x01, "read AB; decrement transfer restore AB"}, {0x01, "read AB; decrement transfer restore AB"},
{0x02, "read AB"}, {0x02, "read AB"},
{0x03, "read B; write B"}, {0x03, "read B; write B"},
{0x04, "read AB; writeB"}, {0x04, "read AB; writeB"},
{0x05, "read B"}, {0x05, "read B"},
{0x06, "read AB; write B; increment B; decrement transfer restore AB"}, {0x06, "read AB; write B; increment B; decrement transfer restore AB"},
{0x07, "none"} {0x07, "none"}
}; };
AccessConditions_t MFAccessConditionsTrailer[] = { AccessConditions_t MFAccessConditionsTrailer[] = {
{0x00, "read A by A; read ACCESS by A; read B by A; write B by A"}, {0x00, "read A by A; read ACCESS by A; read B by A; write B by A"},
{0x01, "write A by A; read ACCESS by A write ACCESS by A; read B by A; write B by A"}, {0x01, "write A by A; read ACCESS by A write ACCESS by A; read B by A; write B by A"},
{0x02, "read ACCESS by A; read B by A"}, {0x02, "read ACCESS by A; read B by A"},
{0x03, "write A by B; read ACCESS by AB; write ACCESS by B; write B by B"}, {0x03, "write A by B; read ACCESS by AB; write ACCESS by B; write B by B"},
{0x04, "write A by B; read ACCESS by AB; write B by B"}, {0x04, "write A by B; read ACCESS by AB; write B by B"},
{0x05, "read ACCESS by AB; write ACCESS by B"}, {0x05, "read ACCESS by AB; write ACCESS by B"},
{0x06, "read ACCESS by AB"}, {0x06, "read ACCESS by AB"},
{0x07, "read ACCESS by AB"} {0x07, "read ACCESS by AB"}
}; };
const char *mfGetAccessConditionsDesc(uint8_t blockn, uint8_t *data) { const char *mfGetAccessConditionsDesc(uint8_t blockn, uint8_t *data) {

24
tools/mf_nonce_brute/mf_nonce_brute.c
View file

@ -58,7 +58,7 @@ typedef struct thread_key_args {
uint32_t nt_enc; uint32_t nt_enc;
uint32_t nr_enc; uint32_t nr_enc;
uint16_t enc_len; uint16_t enc_len;
uint8_t enc[ENC_LEN]; // next encrypted command + a full read/write uint8_t enc[ENC_LEN]; // next encrypted command + a full read/write
} targs_key; } targs_key;
//------------------------------------------------------------------ //------------------------------------------------------------------
@ -155,7 +155,7 @@ static int param_gethex_to_eol(const char *line, int paramnum, uint8_t *data, in
} }
static void hex_to_buffer(const uint8_t *buf, const uint8_t *hex_data, const size_t hex_len, const size_t hex_max_len, static void hex_to_buffer(const uint8_t *buf, const uint8_t *hex_data, const size_t hex_len, const size_t hex_max_len,
const size_t min_str_len, const size_t spaces_between, bool uppercase) { const size_t min_str_len, const size_t spaces_between, bool uppercase) {
if (buf == NULL) return; if (buf == NULL) return;
@ -444,13 +444,13 @@ static void *brute_thread(void *arguments) {
if (args->ev1) { if (args->ev1) {
// if it was EV1, we know for sure xxxAAAAAAAA recovery // if it was EV1, we know for sure xxxAAAAAAAA recovery
printf("\nKey candidate [ " _YELLOW_("....%08" PRIx64 )" ]\n\n", key & 0xFFFFFFFF); printf("\nKey candidate [ " _YELLOW_("....%08" PRIx64)" ]\n\n", key & 0xFFFFFFFF);
__sync_fetch_and_add(&global_found_candidate, 1); __sync_fetch_and_add(&global_found_candidate, 1);
} else { } else {
printf("\nKey candidate [ " _GREEN_("....%08" PRIx64) " ]\n\n", key & 0xFFFFFFFF); printf("\nKey candidate [ " _GREEN_("....%08" PRIx64) " ]\n\n", key & 0xFFFFFFFF);
__sync_fetch_and_add(&global_found, 1); __sync_fetch_and_add(&global_found, 1);
} }
__sync_fetch_and_add(&global_candiate_key, key); __sync_fetch_and_add(&global_candiate_key, key);
//release lock //release lock
pthread_mutex_unlock(&print_lock); pthread_mutex_unlock(&print_lock);
break; break;
@ -493,14 +493,14 @@ static void *brute_key_thread(void *arguments) {
// check if cmd exists // check if cmd exists
uint8_t isOK = checkValidCmdByte(dec, args->enc_len); uint8_t isOK = checkValidCmdByte(dec, args->enc_len);
if (isOK == false) { if (isOK == false) {
continue; continue;
} }
// lock this section to avoid interlacing prints from different threats // lock this section to avoid interlacing prints from different threats
pthread_mutex_lock(&print_lock); pthread_mutex_lock(&print_lock);
printf("\nenc: %s\n", sprint_hex_inrow_ex(local_enc, args->enc_len, 0)); printf("\nenc: %s\n", sprint_hex_inrow_ex(local_enc, args->enc_len, 0));
printf("dec: %s\n", sprint_hex_inrow_ex(dec, args->enc_len, 0)); printf("dec: %s\n", sprint_hex_inrow_ex(dec, args->enc_len, 0));
printf("\nValid Key found [ " _GREEN_("%012" PRIx64) " ]\n\n", key); printf("\nValid Key found [ " _GREEN_("%012" PRIx64) " ]\n\n", key);
pthread_mutex_unlock(&print_lock); pthread_mutex_unlock(&print_lock);
__sync_fetch_and_add(&global_found, 1); __sync_fetch_and_add(&global_found, 1);
@ -547,7 +547,7 @@ int main(int argc, char *argv[]) {
sscanf(argv[8], "%x", &at_par_err); sscanf(argv[8], "%x", &at_par_err);
int enc_len = 0; int enc_len = 0;
uint8_t enc[ENC_LEN] = {0}; // next encrypted command + a full read/write uint8_t enc[ENC_LEN] = {0}; // next encrypted command + a full read/write
if (argc > 9) { if (argc > 9) {
// sscanf(argv[9], "%x", &cmd_enc); // sscanf(argv[9], "%x", &cmd_enc);
param_gethex_to_eol(argv[9], 0, enc, sizeof(enc), &enc_len); param_gethex_to_eol(argv[9], 0, enc, sizeof(enc), &enc_len);
@ -565,7 +565,7 @@ int main(int argc, char *argv[]) {
printf("at parity err........ %04x\n", at_par_err); printf("at parity err........ %04x\n", at_par_err);
if (argc > 9) { if (argc > 9) {
printf("next encrypted cmd... %s\n", sprint_hex_inrow_ex(enc, enc_len ,0)); printf("next encrypted cmd... %s\n", sprint_hex_inrow_ex(enc, enc_len, 0));
} }
clock_t t1 = clock(); clock_t t1 = clock();
@ -615,11 +615,11 @@ int main(int argc, char *argv[]) {
t1 = clock() - t1; t1 = clock() - t1;
printf("execution time %.2f sec\n", (float)t1 / 1000000.0); printf("execution time %.2f sec\n", (float)t1 / 1000000.0);
if (!global_found && !global_found_candidate) { if (!global_found && !global_found_candidate) {
printf("\nFailed to find a key\n\n"); printf("\nFailed to find a key\n\n");
goto out; goto out;
} }
if (enc_len < 4) { if (enc_len < 4) {
printf("Too few next cmd bytes, skipping phase 2\n"); printf("Too few next cmd bytes, skipping phase 2\n");
@ -635,7 +635,7 @@ int main(int argc, char *argv[]) {
printf("partial key.. %08x\n", (uint32_t)(global_candiate_key & 0xFFFFFFFF)); printf("partial key.. %08x\n", (uint32_t)(global_candiate_key & 0xFFFFFFFF));
printf("nt enc....... %08x\n", nt_enc); printf("nt enc....... %08x\n", nt_enc);
printf("nr enc....... %08x\n", nr_enc); printf("nr enc....... %08x\n", nr_enc);
printf("next encrypted cmd: %s\n", sprint_hex_inrow_ex(enc, enc_len ,0)); printf("next encrypted cmd: %s\n", sprint_hex_inrow_ex(enc, enc_len, 0));
printf("\nlooking for the upper 16 bits of key\n"); printf("\nlooking for the upper 16 bits of key\n");
fflush(stdout); fflush(stdout);