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

Merge pull request #227 from pwpiwi/client_fixes

Browse source 
Client code cleanup:
This commit is contained in:
pwpiwi 2017-03-06 22:19:15 +01:00 • committed by GitHub
commit 300bb58ac1
16 changed files with 343 additions and 338 deletions
Download patch file Download diff file Expand all files Collapse all files

32
client/cmddata.c
View file

@ -277,8 +277,8 @@ int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose) int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose)
{ {
bool st = TRUE; bool st = true;
if (!ASKDemod_ext(Cmd, FALSE, FALSE, 1, &st)) return 0; if (!ASKDemod_ext(Cmd, false, false, 1, &st)) return 0;
return AskEm410xDecode(verbose, hi, lo); return AskEm410xDecode(verbose, hi, lo);
} }
@ -406,13 +406,13 @@ int Cmdaskmandemod(const char *Cmd)
PrintAndLog(" : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); PrintAndLog(" : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
return 0; return 0;
} }
bool st = TRUE; bool st = true;
if (Cmd[0]=='s') if (Cmd[0]=='s')
return ASKDemod_ext(Cmd++, TRUE, TRUE, 1, &st); return ASKDemod_ext(Cmd++, true, true, 1, &st);
else if (Cmd[1] == 's') else if (Cmd[1] == 's')
return ASKDemod_ext(Cmd+=2, TRUE, TRUE, 1, &st); return ASKDemod_ext(Cmd+=2, true, true, 1, &st);
else else
return ASKDemod(Cmd, TRUE, TRUE, 1); return ASKDemod(Cmd, true, true, 1);
} }
//by marshmellow //by marshmellow
@ -587,7 +587,7 @@ int Cmdaskbiphdemod(const char *Cmd)
PrintAndLog(" : data rawdemod ab 0 64 1 0 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp"); PrintAndLog(" : data rawdemod ab 0 64 1 0 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
return 0; return 0;
} }
return ASKbiphaseDemod(Cmd, TRUE); return ASKbiphaseDemod(Cmd, true);
} }
//by marshmellow //by marshmellow
@ -597,7 +597,7 @@ int Cmdaskbiphdemod(const char *Cmd)
//if successful it will push askraw data back to demod buffer ready for emulation //if successful it will push askraw data back to demod buffer ready for emulation
int CmdG_Prox_II_Demod(const char *Cmd) int CmdG_Prox_II_Demod(const char *Cmd)
{ {
if (!ASKbiphaseDemod(Cmd, FALSE)){ if (!ASKbiphaseDemod(Cmd, false)){
if (g_debugMode) PrintAndLog("Error gProxII: ASKbiphaseDemod failed 1st try"); if (g_debugMode) PrintAndLog("Error gProxII: ASKbiphaseDemod failed 1st try");
return 0; return 0;
} }
@ -702,7 +702,7 @@ int Cmdaskrawdemod(const char *Cmd)
PrintAndLog(" : data rawdemod ar 64 1 0 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp"); PrintAndLog(" : data rawdemod ar 64 1 0 0 a = demod an ask tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
return 0; return 0;
} }
return ASKDemod(Cmd, TRUE, FALSE, 0); return ASKDemod(Cmd, true, false, 0);
} }
int AutoCorrelate(int window, bool SaveGrph, bool verbose) int AutoCorrelate(int window, bool SaveGrph, bool verbose)
@ -767,7 +767,7 @@ int CmdAutoCorr(const char *Cmd)
return usage_data_autocorr(); return usage_data_autocorr();
int window = 4000; //set default int window = 4000; //set default
char grph=0; char grph=0;
bool updateGrph = FALSE; bool updateGrph = false;
sscanf(Cmd, "%i %c", &window, &grph); sscanf(Cmd, "%i %c", &window, &grph);
if (window >= GraphTraceLen) { if (window >= GraphTraceLen) {
@ -775,8 +775,8 @@ int CmdAutoCorr(const char *Cmd)
GraphTraceLen); GraphTraceLen);
return 0; return 0;
} }
if (grph == 'g') updateGrph=TRUE; if (grph == 'g') updateGrph=true;
return AutoCorrelate(window, updateGrph, TRUE); return AutoCorrelate(window, updateGrph, true);
} }
int CmdBitsamples(const char *Cmd) int CmdBitsamples(const char *Cmd)
@ -1035,7 +1035,7 @@ int CmdFSKrawdemod(const char *Cmd)
PrintAndLog(" : data rawdemod fs 50 1 10 8 = demod an fsk2a RF/50 tag from GraphBuffer"); PrintAndLog(" : data rawdemod fs 50 1 10 8 = demod an fsk2a RF/50 tag from GraphBuffer");
return 0; return 0;
} }
return FSKrawDemod(Cmd, TRUE); return FSKrawDemod(Cmd, true);
} }
//by marshmellow (based on existing demod + holiman's refactor) //by marshmellow (based on existing demod + holiman's refactor)
@ -1789,7 +1789,7 @@ int CmdNRZrawDemod(const char *Cmd)
PrintAndLog(" : data rawdemod nr 64 1 0 = demod a nrz/direct tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); PrintAndLog(" : data rawdemod nr 64 1 0 = demod a nrz/direct tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
return 0; return 0;
} }
return NRZrawDemod(Cmd, TRUE); return NRZrawDemod(Cmd, true);
} }
// by marshmellow // by marshmellow
@ -1813,7 +1813,7 @@ int CmdPSK1rawDemod(const char *Cmd)
PrintAndLog(" : data rawdemod p1 64 1 0 = demod a psk1 tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors"); PrintAndLog(" : data rawdemod p1 64 1 0 = demod a psk1 tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
return 0; return 0;
} }
ans = PSKDemod(Cmd, TRUE); ans = PSKDemod(Cmd, true);
//output //output
if (!ans){ if (!ans){
if (g_debugMode) PrintAndLog("Error demoding: %d",ans); if (g_debugMode) PrintAndLog("Error demoding: %d",ans);
@ -1845,7 +1845,7 @@ int CmdPSK2rawDemod(const char *Cmd)
PrintAndLog(" : data rawdemod p2 64 1 0 = demod a psk2 tag from GraphBuffer using a clock of RF/64, inverting output and allowing 0 demod errors"); PrintAndLog(" : data rawdemod p2 64 1 0 = demod a psk2 tag from GraphBuffer using a clock of RF/64, inverting output and allowing 0 demod errors");
return 0; return 0;
} }
ans=PSKDemod(Cmd, TRUE); ans=PSKDemod(Cmd, true);
if (!ans){ if (!ans){
if (g_debugMode) PrintAndLog("Error demoding: %d",ans); if (g_debugMode) PrintAndLog("Error demoding: %d",ans);
return 0; return 0;

4
client/cmdhf.c
View file

@ -11,8 +11,10 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "proxmark3.h" #include "proxmark3.h"
#include "graph.h" #include "util.h"
#include "ui.h" #include "ui.h"
#include "iso14443crc.h"
#include "cmdmain.h"
#include "cmdparser.h" #include "cmdparser.h"
#include "cmdhf.h" #include "cmdhf.h"
#include "cmdhf14a.h" #include "cmdhf14a.h"

26
client/cmdhf14a.c
View file

@ -570,14 +570,14 @@ int CmdHF14ASnoop(const char *Cmd) {
int CmdHF14ACmdRaw(const char *cmd) { int CmdHF14ACmdRaw(const char *cmd) {
UsbCommand c = {CMD_READER_ISO_14443a, {0, 0, 0}}; UsbCommand c = {CMD_READER_ISO_14443a, {0, 0, 0}};
bool reply=1; bool reply=1;
bool crc = FALSE; bool crc = false;
bool power = FALSE; bool power = false;
bool active = FALSE; bool active = false;
bool active_select = FALSE; bool active_select = false;
uint16_t numbits = 0; uint16_t numbits = 0;
bool bTimeout = FALSE; bool bTimeout = false;
uint32_t timeout = 0; uint32_t timeout = 0;
bool topazmode = FALSE; bool topazmode = false;
char buf[5]=""; char buf[5]="";
int i = 0; int i = 0;
uint8_t data[USB_CMD_DATA_SIZE]; uint8_t data[USB_CMD_DATA_SIZE];
@ -606,19 +606,19 @@ int CmdHF14ACmdRaw(const char *cmd) {
if (cmd[i]=='-') { if (cmd[i]=='-') {
switch (cmd[i+1]) { switch (cmd[i+1]) {
case 'r': case 'r':
reply = FALSE; reply = false;
break; break;
case 'c': case 'c':
crc = TRUE; crc = true;
break; break;
case 'p': case 'p':
power = TRUE; power = true;
break; break;
case 'a': case 'a':
active = TRUE; active = true;
break; break;
case 's': case 's':
active_select = TRUE; active_select = true;
break; break;
case 'b': case 'b':
sscanf(cmd+i+2,"%d",&temp); sscanf(cmd+i+2,"%d",&temp);
@ -628,7 +628,7 @@ int CmdHF14ACmdRaw(const char *cmd) {
i-=2; i-=2;
break; break;
case 't': case 't':
bTimeout = TRUE; bTimeout = true;
sscanf(cmd+i+2,"%d",&temp); sscanf(cmd+i+2,"%d",&temp);
timeout = temp; timeout = temp;
i+=3; i+=3;
@ -636,7 +636,7 @@ int CmdHF14ACmdRaw(const char *cmd) {
i-=2; i-=2;
break; break;
case 'T': case 'T':
topazmode = TRUE; topazmode = true;
break; break;
default: default:
PrintAndLog("Invalid option"); PrintAndLog("Invalid option");

27
client/cmdhfmf.c
View file

@ -9,8 +9,18 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <inttypes.h> #include <inttypes.h>
#include "cmdhfmf.h" #include <stdio.h>
#include "./nonce2key/nonce2key.h" #include <stdlib.h>
#include "proxmark3.h"
#include "cmdmain.h"
#include "util.h"
#include "ui.h"
#include "mifarehost.h"
#include "mifare.h"
#include "nonce2key/nonce2key.h"
#define NESTED_SECTOR_RETRY 10 // how often we try mfested() until we give up
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);
@ -551,10 +561,17 @@ int CmdHF14AMfRestore(const char *Cmd)
return 0; return 0;
} }
typedef struct {
uint64_t Key[2];
int foundKey[2];
} sector_t;
int CmdHF14AMfNested(const char *Cmd) int CmdHF14AMfNested(const char *Cmd)
{ {
int i, j, res, iterations; int i, j, res, iterations;
sector *e_sector = NULL; sector_t *e_sector = NULL;
uint8_t blockNo = 0; uint8_t blockNo = 0;
uint8_t keyType = 0; uint8_t keyType = 0;
uint8_t trgBlockNo = 0; uint8_t trgBlockNo = 0;
@ -674,7 +691,7 @@ int CmdHF14AMfNested(const char *Cmd)
clock_t time1; clock_t time1;
time1 = clock(); time1 = clock();
e_sector = calloc(SectorsCnt, sizeof(sector)); e_sector = calloc(SectorsCnt, sizeof(sector_t));
if (e_sector == NULL) return 1; if (e_sector == NULL) return 1;
//test current key and additional standard keys first //test current key and additional standard keys first
@ -1768,7 +1785,7 @@ int CmdHF14AMfCSetBlk(const char *Cmd)
{ {
uint8_t memBlock[16] = {0x00}; uint8_t memBlock[16] = {0x00};
uint8_t blockNo = 0; uint8_t blockNo = 0;
bool wipeCard = FALSE; bool wipeCard = false;
int res; int res;
if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') { if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {

69
client/cmdhfmf.h
View file

@ -11,47 +11,34 @@
#ifndef CMDHFMF_H__ #ifndef CMDHFMF_H__
#define CMDHFMF_H__ #define CMDHFMF_H__
#include <stdio.h> extern int CmdHFMF(const char *Cmd);
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "proxmark3.h"
#include "iso14443crc.h"
#include "data.h"
#include "ui.h"
#include "cmdparser.h"
#include "common.h"
#include "util.h"
#include "mifarehost.h"
int CmdHFMF(const char *Cmd);
int CmdHF14AMfDbg(const char* cmd); extern int CmdHF14AMfDbg(const char* cmd);
int CmdHF14AMfRdBl(const char* cmd); extern int CmdHF14AMfRdBl(const char* cmd);
int CmdHF14AMfURdBl(const char* cmd); extern int CmdHF14AMfURdBl(const char* cmd);
int CmdHF14AMfRdSc(const char* cmd); extern int CmdHF14AMfRdSc(const char* cmd);
int CmdHF14SMfURdCard(const char* cmd); extern int CmdHF14SMfURdCard(const char* cmd);
int CmdHF14AMfDump(const char* cmd); extern int CmdHF14AMfDump(const char* cmd);
int CmdHF14AMfRestore(const char* cmd); extern int CmdHF14AMfRestore(const char* cmd);
int CmdHF14AMfWrBl(const char* cmd); extern int CmdHF14AMfWrBl(const char* cmd);
int CmdHF14AMfUWrBl(const char* cmd); extern int CmdHF14AMfUWrBl(const char* cmd);
int CmdHF14AMfChk(const char* cmd); extern int CmdHF14AMfChk(const char* cmd);
int CmdHF14AMifare(const char* cmd); extern int CmdHF14AMifare(const char* cmd);
int CmdHF14AMfNested(const char* cmd); extern int CmdHF14AMfNested(const char* cmd);
int CmdHF14AMfSniff(const char* cmd); extern int CmdHF14AMfSniff(const char* cmd);
int CmdHF14AMf1kSim(const char* cmd); extern int CmdHF14AMf1kSim(const char* cmd);
int CmdHF14AMfEClear(const char* cmd); extern int CmdHF14AMfEClear(const char* cmd);
int CmdHF14AMfEGet(const char* cmd); extern int CmdHF14AMfEGet(const char* cmd);
int CmdHF14AMfESet(const char* cmd); extern int CmdHF14AMfESet(const char* cmd);
int CmdHF14AMfELoad(const char* cmd); extern int CmdHF14AMfELoad(const char* cmd);
int CmdHF14AMfESave(const char* cmd); extern int CmdHF14AMfESave(const char* cmd);
int CmdHF14AMfECFill(const char* cmd); extern int CmdHF14AMfECFill(const char* cmd);
int CmdHF14AMfEKeyPrn(const char* cmd); extern int CmdHF14AMfEKeyPrn(const char* cmd);
int CmdHF14AMfCSetUID(const char* cmd); extern int CmdHF14AMfCSetUID(const char* cmd);
int CmdHF14AMfCSetBlk(const char* cmd); extern int CmdHF14AMfCSetBlk(const char* cmd);
int CmdHF14AMfCGetBlk(const char* cmd); extern int CmdHF14AMfCGetBlk(const char* cmd);
int CmdHF14AMfCGetSc(const char* cmd); extern int CmdHF14AMfCGetSc(const char* cmd);
int CmdHF14AMfCLoad(const char* cmd); extern int CmdHF14AMfCLoad(const char* cmd);
int CmdHF14AMfCSave(const char* cmd); extern int CmdHF14AMfCSave(const char* cmd);
#endif #endif

6
client/cmdhfmfu.c
View file

@ -7,7 +7,11 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// High frequency MIFARE ULTRALIGHT (C) commands // High frequency MIFARE ULTRALIGHT (C) commands
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <ctype.h>
#include "proxmark3.h"
#include "usb_cmd.h"
#include "cmdmain.h"
#include "ui.h"
#include "loclass/des.h" #include "loclass/des.h"
#include "cmdhfmfu.h" #include "cmdhfmfu.h"
#include "cmdhfmf.h" #include "cmdhfmf.h"

48
client/cmdlf.c
View file

@ -63,7 +63,7 @@ int CmdLFCommandRead(const char *Cmd)
{ {
static char dummy[3] = {0x20,0x00,0x00}; static char dummy[3] = {0x20,0x00,0x00};
UsbCommand c = {CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K}; UsbCommand c = {CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K};
bool errors = FALSE; bool errors = false;
//uint8_t divisor = 95; //125khz //uint8_t divisor = 95; //125khz
uint8_t cmdp = 0; uint8_t cmdp = 0;
while(param_getchar(Cmd, cmdp) != 0x00) while(param_getchar(Cmd, cmdp) != 0x00)
@ -484,7 +484,7 @@ int CmdLFSetConfig(const char *Cmd)
uint8_t bps = 0; // Bits per sample uint8_t bps = 0; // Bits per sample
uint8_t decimation = 0; //How many to keep uint8_t decimation = 0; //How many to keep
bool averaging = 1; // Defaults to true bool averaging = 1; // Defaults to true
bool errors = FALSE; bool errors = false;
int trigger_threshold =-1;//Means no change int trigger_threshold =-1;//Means no change
uint8_t unsigned_trigg = 0; uint8_t unsigned_trigg = 0;
@ -700,7 +700,7 @@ int CmdLFfskSim(const char *Cmd)
// otherwise will need FChigh, FClow, Clock, and bitstream // otherwise will need FChigh, FClow, Clock, and bitstream
uint8_t fcHigh=0, fcLow=0, clk=0; uint8_t fcHigh=0, fcLow=0, clk=0;
uint8_t invert=0; uint8_t invert=0;
bool errors = FALSE; bool errors = false;
char hexData[32] = {0x00}; // store entered hex data char hexData[32] = {0x00}; // store entered hex data
uint8_t data[255] = {0x00}; uint8_t data[255] = {0x00};
int dataLen = 0; int dataLen = 0;
@ -734,24 +734,24 @@ int CmdLFfskSim(const char *Cmd)
case 'd': case 'd':
dataLen = param_getstr(Cmd, cmdp+1, hexData); dataLen = param_getstr(Cmd, cmdp+1, hexData);
if (dataLen==0) { if (dataLen==0) {
errors=TRUE; errors=true;
} else { } else {
dataLen = hextobinarray((char *)data, hexData); dataLen = hextobinarray((char *)data, hexData);
} }
if (dataLen==0) errors=TRUE; if (dataLen==0) errors=true;
if (errors) PrintAndLog ("Error getting hex data"); if (errors) PrintAndLog ("Error getting hex data");
cmdp+=2; cmdp+=2;
break; break;
default: default:
PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
errors = TRUE; errors = true;
break; break;
} }
if(errors) break; if(errors) break;
} }
if(cmdp == 0 && DemodBufferLen == 0) if(cmdp == 0 && DemodBufferLen == 0)
{ {
errors = TRUE;// No args errors = true;// No args
} }
//Validations //Validations
@ -802,7 +802,7 @@ int CmdLFaskSim(const char *Cmd)
// needs clock, invert, manchester/raw as m or r, separator as s, and bitstream // needs clock, invert, manchester/raw as m or r, separator as s, and bitstream
uint8_t encoding = 1, separator = 0; uint8_t encoding = 1, separator = 0;
uint8_t clk=0, invert=0; uint8_t clk=0, invert=0;
bool errors = FALSE; bool errors = false;
char hexData[32] = {0x00}; char hexData[32] = {0x00};
uint8_t data[255]= {0x00}; // store entered hex data uint8_t data[255]= {0x00}; // store entered hex data
int dataLen = 0; int dataLen = 0;
@ -840,24 +840,24 @@ int CmdLFaskSim(const char *Cmd)
case 'd': case 'd':
dataLen = param_getstr(Cmd, cmdp+1, hexData); dataLen = param_getstr(Cmd, cmdp+1, hexData);
if (dataLen==0) { if (dataLen==0) {
errors=TRUE; errors=true;
} else { } else {
dataLen = hextobinarray((char *)data, hexData); dataLen = hextobinarray((char *)data, hexData);
} }
if (dataLen==0) errors=TRUE; if (dataLen==0) errors=true;
if (errors) PrintAndLog ("Error getting hex data, datalen: %d",dataLen); if (errors) PrintAndLog ("Error getting hex data, datalen: %d",dataLen);
cmdp+=2; cmdp+=2;
break; break;
default: default:
PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
errors = TRUE; errors = true;
break; break;
} }
if(errors) break; if(errors) break;
} }
if(cmdp == 0 && DemodBufferLen == 0) if(cmdp == 0 && DemodBufferLen == 0)
{ {
errors = TRUE;// No args errors = true;// No args
} }
//Validations //Validations
@ -896,7 +896,7 @@ int CmdLFpskSim(const char *Cmd)
//will need carrier, Clock, and bitstream //will need carrier, Clock, and bitstream
uint8_t carrier=0, clk=0; uint8_t carrier=0, clk=0;
uint8_t invert=0; uint8_t invert=0;
bool errors = FALSE; bool errors = false;
char hexData[32] = {0x00}; // store entered hex data char hexData[32] = {0x00}; // store entered hex data
uint8_t data[255] = {0x00}; uint8_t data[255] = {0x00};
int dataLen = 0; int dataLen = 0;
@ -935,24 +935,24 @@ int CmdLFpskSim(const char *Cmd)
case 'd': case 'd':
dataLen = param_getstr(Cmd, cmdp+1, hexData); dataLen = param_getstr(Cmd, cmdp+1, hexData);
if (dataLen==0) { if (dataLen==0) {
errors=TRUE; errors=true;
} else { } else {
dataLen = hextobinarray((char *)data, hexData); dataLen = hextobinarray((char *)data, hexData);
} }
if (dataLen==0) errors=TRUE; if (dataLen==0) errors=true;
if (errors) PrintAndLog ("Error getting hex data"); if (errors) PrintAndLog ("Error getting hex data");
cmdp+=2; cmdp+=2;
break; break;
default: default:
PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
errors = TRUE; errors = true;
break; break;
} }
if (errors) break; if (errors) break;
} }
if (cmdp == 0 && DemodBufferLen == 0) if (cmdp == 0 && DemodBufferLen == 0)
{ {
errors = TRUE;// No args errors = true;// No args
} }
//Validations //Validations
@ -962,9 +962,9 @@ int CmdLFpskSim(const char *Cmd)
} }
if (dataLen == 0){ //using DemodBuffer if (dataLen == 0){ //using DemodBuffer
PrintAndLog("Getting Clocks"); PrintAndLog("Getting Clocks");
if (clk==0) clk = GetPskClock("", FALSE, FALSE); if (clk==0) clk = GetPskClock("", false, false);
PrintAndLog("clk: %d",clk); PrintAndLog("clk: %d",clk);
if (!carrier) carrier = GetPskCarrier("", FALSE, FALSE); if (!carrier) carrier = GetPskCarrier("", false, false);
PrintAndLog("carrier: %d", carrier); PrintAndLog("carrier: %d", carrier);
} else { } else {
setDemodBuf(data, dataLen, 0); setDemodBuf(data, dataLen, 0);
@ -1236,18 +1236,18 @@ int CmdLFfind(const char *Cmd)
ans=CheckChipType(cmdp); ans=CheckChipType(cmdp);
//test unknown tag formats (raw mode)0 //test unknown tag formats (raw mode)0
PrintAndLog("\nChecking for Unknown tags:\n"); PrintAndLog("\nChecking for Unknown tags:\n");
ans=AutoCorrelate(4000, FALSE, FALSE); ans=AutoCorrelate(4000, false, false);
if (ans > 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans); if (ans > 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans);
ans=GetFskClock("",FALSE,FALSE); ans=GetFskClock("",false,false);
if (ans != 0){ //fsk if (ans != 0){ //fsk
ans=FSKrawDemod("",TRUE); ans=FSKrawDemod("",true);
if (ans>0) { if (ans>0) {
PrintAndLog("\nUnknown FSK Modulated Tag Found!"); PrintAndLog("\nUnknown FSK Modulated Tag Found!");
return 1; return 1;
} }
} }
bool st = TRUE; bool st = true;
ans=ASKDemod_ext("0 0 0",TRUE,FALSE,1,&st); ans=ASKDemod_ext("0 0 0",true,false,1,&st);
if (ans>0) { if (ans>0) {
PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!"); PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!");
PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'"); PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'");

12
client/cmdlfcotag.c
View file

@ -7,7 +7,17 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Low frequency COTAG commands // Low frequency COTAG commands
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include "cmdlfcotag.h" // COTAG function declarations #include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "proxmark3.h"
#include "ui.h"
#include "cmddata.h"
#include "data.h"
#include "cmdlfcotag.h"
#include "lfdemod.h"
#include "usb_cmd.h"
#include "cmdmain.h"
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);

9
client/cmdlfcotag.h
View file

@ -11,15 +11,6 @@
#ifndef CMDLFCOTAG_H__ #ifndef CMDLFCOTAG_H__
#define CMDLFCOTAG_H__ #define CMDLFCOTAG_H__
#include "proxmark3.h"// Definitions, USB controls, COTAG_BITS
#include "util.h" // FALSE / TRUE
#include "cmddata.h" // getSamples
#include "cmdparser.h"// CmdsParse, CmdsHelp
#include "cmdmain.h"
#include "ui.h" // PrintAndLog
#include "cmdlf.h" // Setconfig
#include "lfdemod.h" // manrawdecode, bytebits_tobyteLSBF
#ifndef COTAG_BITS #ifndef COTAG_BITS
#define COTAG_BITS 264 #define COTAG_BITS 264
#endif #endif

192
client/cmdlft55xx.c
View file

@ -30,7 +30,7 @@
#define REGULAR_READ_MODE_BLOCK 0xFF #define REGULAR_READ_MODE_BLOCK 0xFF
// Default configuration // Default configuration
t55xx_conf_block_t config = { .modulation = DEMOD_ASK, .inverted = FALSE, .offset = 0x00, .block0 = 0x00, .Q5 = FALSE }; t55xx_conf_block_t config = { .modulation = DEMOD_ASK, .inverted = false, .offset = 0x00, .block0 = 0x00, .Q5 = false };
t55xx_conf_block_t Get_t55xx_Config(){ t55xx_conf_block_t Get_t55xx_Config(){
return config; return config;
@ -194,7 +194,7 @@ int CmdT55xxSetConfig(const char *Cmd) {
uint8_t bitRate = 0; uint8_t bitRate = 0;
uint8_t rates[9] = {8,16,32,40,50,64,100,128,0}; uint8_t rates[9] = {8,16,32,40,50,64,100,128,0};
uint8_t cmdp = 0; uint8_t cmdp = 0;
bool errors = FALSE; bool errors = false;
while(param_getchar(Cmd, cmdp) != 0x00 && !errors) while(param_getchar(Cmd, cmdp) != 0x00 && !errors)
{ {
tmp = param_getchar(Cmd, cmdp); tmp = param_getchar(Cmd, cmdp);
@ -213,7 +213,7 @@ int CmdT55xxSetConfig(const char *Cmd) {
break; break;
} }
} }
if (i==9) errors = TRUE; if (i==9) errors = true;
} }
cmdp+=2; cmdp+=2;
break; break;
@ -253,7 +253,7 @@ int CmdT55xxSetConfig(const char *Cmd) {
config.inverted=0; config.inverted=0;
} else { } else {
PrintAndLog("Unknown modulation '%s'", modulation); PrintAndLog("Unknown modulation '%s'", modulation);
errors = TRUE; errors = true;
} }
break; break;
case 'i': case 'i':
@ -268,17 +268,17 @@ int CmdT55xxSetConfig(const char *Cmd) {
break; break;
case 'Q': case 'Q':
case 'q': case 'q':
config.Q5 = TRUE; config.Q5 = true;
cmdp++; cmdp++;
break; break;
case 'S': case 'S':
case 's': case 's':
config.ST = TRUE; config.ST = true;
cmdp++; cmdp++;
break; break;
default: default:
PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
errors = TRUE; errors = true;
break; break;
} }
} }
@ -383,28 +383,28 @@ bool DecodeT55xxBlock(){
switch( config.modulation ){ switch( config.modulation ){
case DEMOD_FSK: case DEMOD_FSK:
snprintf(cmdStr, sizeof(buf),"%d %d", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d", bitRate[config.bitrate], config.inverted );
ans = FSKrawDemod(cmdStr, FALSE); ans = FSKrawDemod(cmdStr, false);
break; break;
case DEMOD_FSK1: case DEMOD_FSK1:
case DEMOD_FSK1a: case DEMOD_FSK1a:
snprintf(cmdStr, sizeof(buf),"%d %d 8 5", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 8 5", bitRate[config.bitrate], config.inverted );
ans = FSKrawDemod(cmdStr, FALSE); ans = FSKrawDemod(cmdStr, false);
break; break;
case DEMOD_FSK2: case DEMOD_FSK2:
case DEMOD_FSK2a: case DEMOD_FSK2a:
snprintf(cmdStr, sizeof(buf),"%d %d 10 8", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 10 8", bitRate[config.bitrate], config.inverted );
ans = FSKrawDemod(cmdStr, FALSE); ans = FSKrawDemod(cmdStr, false);
break; break;
case DEMOD_ASK: case DEMOD_ASK:
snprintf(cmdStr, sizeof(buf),"%d %d 1", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 1", bitRate[config.bitrate], config.inverted );
ans = ASKDemod_ext(cmdStr, FALSE, FALSE, 1, &ST); ans = ASKDemod_ext(cmdStr, false, false, 1, &ST);
break; break;
case DEMOD_PSK1: case DEMOD_PSK1:
// skip first 160 samples to allow antenna to settle in (psk gets inverted occasionally otherwise) // skip first 160 samples to allow antenna to settle in (psk gets inverted occasionally otherwise)
save_restoreGB(1); save_restoreGB(1);
CmdLtrim("160"); CmdLtrim("160");
snprintf(cmdStr, sizeof(buf),"%d %d 6", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 6", bitRate[config.bitrate], config.inverted );
ans = PSKDemod(cmdStr, FALSE); ans = PSKDemod(cmdStr, false);
//undo trim samples //undo trim samples
save_restoreGB(0); save_restoreGB(0);
break; break;
@ -414,22 +414,22 @@ bool DecodeT55xxBlock(){
save_restoreGB(1); save_restoreGB(1);
CmdLtrim("160"); CmdLtrim("160");
snprintf(cmdStr, sizeof(buf),"%d 0 6", bitRate[config.bitrate] ); snprintf(cmdStr, sizeof(buf),"%d 0 6", bitRate[config.bitrate] );
ans = PSKDemod(cmdStr, FALSE); ans = PSKDemod(cmdStr, false);
psk1TOpsk2(DemodBuffer, DemodBufferLen); psk1TOpsk2(DemodBuffer, DemodBufferLen);
//undo trim samples //undo trim samples
save_restoreGB(0); save_restoreGB(0);
break; break;
case DEMOD_NRZ: case DEMOD_NRZ:
snprintf(cmdStr, sizeof(buf),"%d %d 1", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"%d %d 1", bitRate[config.bitrate], config.inverted );
ans = NRZrawDemod(cmdStr, FALSE); ans = NRZrawDemod(cmdStr, false);
break; break;
case DEMOD_BI: case DEMOD_BI:
case DEMOD_BIa: case DEMOD_BIa:
snprintf(cmdStr, sizeof(buf),"0 %d %d 1", bitRate[config.bitrate], config.inverted ); snprintf(cmdStr, sizeof(buf),"0 %d %d 1", bitRate[config.bitrate], config.inverted );
ans = ASKbiphaseDemod(cmdStr, FALSE); ans = ASKbiphaseDemod(cmdStr, false);
break; break;
default: default:
return FALSE; return false;
} }
return (bool) ans; return (bool) ans;
} }
@ -438,13 +438,13 @@ bool DecodeT5555TraceBlock() {
DemodBufferLen = 0x00; DemodBufferLen = 0x00;
// According to datasheet. Always: RF/64, not inverted, Manchester // According to datasheet. Always: RF/64, not inverted, Manchester
return (bool) ASKDemod("64 0 1", FALSE, FALSE, 1); return (bool) ASKDemod("64 0 1", false, false, 1);
} }
int CmdT55xxDetect(const char *Cmd){ int CmdT55xxDetect(const char *Cmd){
bool errors = FALSE; bool errors = false;
bool useGB = FALSE; bool useGB = false;
bool usepwd = FALSE; bool usepwd = false;
uint32_t password = 0; uint32_t password = 0;
uint8_t cmdp = 0; uint8_t cmdp = 0;
@ -456,12 +456,12 @@ int CmdT55xxDetect(const char *Cmd){
case 'p': case 'p':
case 'P': case 'P':
password = param_get32ex(Cmd, cmdp+1, 0, 16); password = param_get32ex(Cmd, cmdp+1, 0, 16);
usepwd = TRUE; usepwd = true;
cmdp += 2; cmdp += 2;
break; break;
case '1': case '1':
// use Graphbuffer data // use Graphbuffer data
useGB = TRUE; useGB = true;
cmdp++; cmdp++;
break; break;
default: default:
@ -489,87 +489,87 @@ bool tryDetectModulation(){
t55xx_conf_block_t tests[15]; t55xx_conf_block_t tests[15];
int bitRate=0; int bitRate=0;
uint8_t fc1 = 0, fc2 = 0, clk=0; uint8_t fc1 = 0, fc2 = 0, clk=0;
if (GetFskClock("", FALSE, FALSE)){ if (GetFskClock("", false, false)){
fskClocks(&fc1, &fc2, &clk, FALSE); fskClocks(&fc1, &fc2, &clk, false);
if ( FSKrawDemod("0 0", FALSE) && test(DEMOD_FSK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( FSKrawDemod("0 0", false) && test(DEMOD_FSK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_FSK; tests[hits].modulation = DEMOD_FSK;
if (fc1==8 && fc2 == 5) if (fc1==8 && fc2 == 5)
tests[hits].modulation = DEMOD_FSK1a; tests[hits].modulation = DEMOD_FSK1a;
else if (fc1==10 && fc2 == 8) else if (fc1==10 && fc2 == 8)
tests[hits].modulation = DEMOD_FSK2; tests[hits].modulation = DEMOD_FSK2;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
if ( FSKrawDemod("0 1", FALSE) && test(DEMOD_FSK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( FSKrawDemod("0 1", false) && test(DEMOD_FSK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_FSK; tests[hits].modulation = DEMOD_FSK;
if (fc1 == 8 && fc2 == 5) if (fc1 == 8 && fc2 == 5)
tests[hits].modulation = DEMOD_FSK1; tests[hits].modulation = DEMOD_FSK1;
else if (fc1 == 10 && fc2 == 8) else if (fc1 == 10 && fc2 == 8)
tests[hits].modulation = DEMOD_FSK2a; tests[hits].modulation = DEMOD_FSK2a;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = true;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
} else { } else {
clk = GetAskClock("", FALSE, FALSE); clk = GetAskClock("", false, false);
if (clk>0) { if (clk>0) {
tests[hits].ST = TRUE; tests[hits].ST = true;
if ( ASKDemod_ext("0 0 1", FALSE, FALSE, 1, &tests[hits].ST) && test(DEMOD_ASK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( ASKDemod_ext("0 0 1", false, false, 1, &tests[hits].ST) && test(DEMOD_ASK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_ASK; tests[hits].modulation = DEMOD_ASK;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
tests[hits].ST = TRUE; tests[hits].ST = true;
if ( ASKDemod_ext("0 1 1", FALSE, FALSE, 1, &tests[hits].ST) && test(DEMOD_ASK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( ASKDemod_ext("0 1 1", false, false, 1, &tests[hits].ST) && test(DEMOD_ASK, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_ASK; tests[hits].modulation = DEMOD_ASK;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = true;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
++hits; ++hits;
} }
if ( ASKbiphaseDemod("0 0 0 2", FALSE) && test(DEMOD_BI, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5) ) { if ( ASKbiphaseDemod("0 0 0 2", false) && test(DEMOD_BI, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5) ) {
tests[hits].modulation = DEMOD_BI; tests[hits].modulation = DEMOD_BI;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
if ( ASKbiphaseDemod("0 0 1 2", FALSE) && test(DEMOD_BIa, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5) ) { if ( ASKbiphaseDemod("0 0 1 2", false) && test(DEMOD_BIa, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5) ) {
tests[hits].modulation = DEMOD_BIa; tests[hits].modulation = DEMOD_BIa;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = true;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
} }
//undo trim from ask //undo trim from ask
//save_restoreGB(0); //save_restoreGB(0);
clk = GetNrzClock("", FALSE, FALSE); clk = GetNrzClock("", false, false);
if (clk>0) { if (clk>0) {
if ( NRZrawDemod("0 0 1", FALSE) && test(DEMOD_NRZ, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( NRZrawDemod("0 0 1", false) && test(DEMOD_NRZ, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_NRZ; tests[hits].modulation = DEMOD_NRZ;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
if ( NRZrawDemod("0 1 1", FALSE) && test(DEMOD_NRZ, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( NRZrawDemod("0 1 1", false) && test(DEMOD_NRZ, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_NRZ; tests[hits].modulation = DEMOD_NRZ;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = true;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
} }
@ -578,45 +578,45 @@ bool tryDetectModulation(){
// skip first 160 samples to allow antenna to settle in (psk gets inverted occasionally otherwise) // skip first 160 samples to allow antenna to settle in (psk gets inverted occasionally otherwise)
save_restoreGB(1); save_restoreGB(1);
CmdLtrim("160"); CmdLtrim("160");
clk = GetPskClock("", FALSE, FALSE); clk = GetPskClock("", false, false);
if (clk>0) { if (clk>0) {
if ( PSKDemod("0 0 6", FALSE) && test(DEMOD_PSK1, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( PSKDemod("0 0 6", false) && test(DEMOD_PSK1, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_PSK1; tests[hits].modulation = DEMOD_PSK1;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
if ( PSKDemod("0 1 6", FALSE) && test(DEMOD_PSK1, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) { if ( PSKDemod("0 1 6", false) && test(DEMOD_PSK1, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)) {
tests[hits].modulation = DEMOD_PSK1; tests[hits].modulation = DEMOD_PSK1;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = TRUE; tests[hits].inverted = true;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
// PSK2 - needs a call to psk1TOpsk2. // PSK2 - needs a call to psk1TOpsk2.
if ( PSKDemod("0 0 6", FALSE)) { if ( PSKDemod("0 0 6", false)) {
psk1TOpsk2(DemodBuffer, DemodBufferLen); psk1TOpsk2(DemodBuffer, DemodBufferLen);
if (test(DEMOD_PSK2, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)){ if (test(DEMOD_PSK2, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)){
tests[hits].modulation = DEMOD_PSK2; tests[hits].modulation = DEMOD_PSK2;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
} // inverse waves does not affect this demod } // inverse waves does not affect this demod
// PSK3 - needs a call to psk1TOpsk2. // PSK3 - needs a call to psk1TOpsk2.
if ( PSKDemod("0 0 6", FALSE)) { if ( PSKDemod("0 0 6", false)) {
psk1TOpsk2(DemodBuffer, DemodBufferLen); psk1TOpsk2(DemodBuffer, DemodBufferLen);
if (test(DEMOD_PSK3, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)){ if (test(DEMOD_PSK3, &tests[hits].offset, &bitRate, clk, &tests[hits].Q5)){
tests[hits].modulation = DEMOD_PSK3; tests[hits].modulation = DEMOD_PSK3;
tests[hits].bitrate = bitRate; tests[hits].bitrate = bitRate;
tests[hits].inverted = FALSE; tests[hits].inverted = false;
tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer); tests[hits].block0 = PackBits(tests[hits].offset, 32, DemodBuffer);
tests[hits].ST = FALSE; tests[hits].ST = false;
++hits; ++hits;
} }
} // inverse waves does not affect this demod } // inverse waves does not affect this demod
@ -633,7 +633,7 @@ bool tryDetectModulation(){
config.Q5 = tests[0].Q5; config.Q5 = tests[0].Q5;
config.ST = tests[0].ST; config.ST = tests[0].ST;
printConfiguration( config ); printConfiguration( config );
return TRUE; return true;
} }
if ( hits > 1) { if ( hits > 1) {
@ -643,68 +643,68 @@ bool tryDetectModulation(){
printConfiguration( tests[i] ); printConfiguration( tests[i] );
} }
} }
return FALSE; return false;
} }
bool testModulation(uint8_t mode, uint8_t modread){ bool testModulation(uint8_t mode, uint8_t modread){
switch( mode ){ switch( mode ){
case DEMOD_FSK: case DEMOD_FSK:
if (modread >= DEMOD_FSK1 && modread <= DEMOD_FSK2a) return TRUE; if (modread >= DEMOD_FSK1 && modread <= DEMOD_FSK2a) return true;
break; break;
case DEMOD_ASK: case DEMOD_ASK:
if (modread == DEMOD_ASK) return TRUE; if (modread == DEMOD_ASK) return true;
break; break;
case DEMOD_PSK1: case DEMOD_PSK1:
if (modread == DEMOD_PSK1) return TRUE; if (modread == DEMOD_PSK1) return true;
break; break;
case DEMOD_PSK2: case DEMOD_PSK2:
if (modread == DEMOD_PSK2) return TRUE; if (modread == DEMOD_PSK2) return true;
break; break;
case DEMOD_PSK3: case DEMOD_PSK3:
if (modread == DEMOD_PSK3) return TRUE; if (modread == DEMOD_PSK3) return true;
break; break;
case DEMOD_NRZ: case DEMOD_NRZ:
if (modread == DEMOD_NRZ) return TRUE; if (modread == DEMOD_NRZ) return true;
break; break;
case DEMOD_BI: case DEMOD_BI:
if (modread == DEMOD_BI) return TRUE; if (modread == DEMOD_BI) return true;
break; break;
case DEMOD_BIa: case DEMOD_BIa:
if (modread == DEMOD_BIa) return TRUE; if (modread == DEMOD_BIa) return true;
break; break;
default: default:
return FALSE; return false;
} }
return FALSE; return false;
} }
bool testQ5Modulation(uint8_t mode, uint8_t modread){ bool testQ5Modulation(uint8_t mode, uint8_t modread){
switch( mode ){ switch( mode ){
case DEMOD_FSK: case DEMOD_FSK:
if (modread >= 4 && modread <= 5) return TRUE; if (modread >= 4 && modread <= 5) return true;
break; break;
case DEMOD_ASK: case DEMOD_ASK:
if (modread == 0) return TRUE; if (modread == 0) return true;
break; break;
case DEMOD_PSK1: case DEMOD_PSK1:
if (modread == 1) return TRUE; if (modread == 1) return true;
break; break;
case DEMOD_PSK2: case DEMOD_PSK2:
if (modread == 2) return TRUE; if (modread == 2) return true;
break; break;
case DEMOD_PSK3: case DEMOD_PSK3:
if (modread == 3) return TRUE; if (modread == 3) return true;
break; break;
case DEMOD_NRZ: case DEMOD_NRZ:
if (modread == 7) return TRUE; if (modread == 7) return true;
break; break;
case DEMOD_BI: case DEMOD_BI:
if (modread == 6) return TRUE; if (modread == 6) return true;
break; break;
default: default:
return FALSE; return false;
} }
return FALSE; return false;
} }
int convertQ5bitRate(uint8_t bitRateRead) { int convertQ5bitRate(uint8_t bitRateRead) {
@ -718,7 +718,7 @@ int convertQ5bitRate(uint8_t bitRateRead) {
bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){ bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){
if ( DemodBufferLen < 64 ) return FALSE; if ( DemodBufferLen < 64 ) return false;
uint8_t si = 0; uint8_t si = 0;
for (uint8_t idx = 28; idx < 64; idx++){ for (uint8_t idx = 28; idx < 64; idx++){
si = idx; si = idx;
@ -751,9 +751,9 @@ bool testQ5(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk){
if (*fndBitRate < 0) continue; if (*fndBitRate < 0) continue;
*offset = idx; *offset = idx;
return TRUE; return true;
} }
return FALSE; return false;
} }
bool testBitRate(uint8_t readRate, uint8_t clk){ bool testBitRate(uint8_t readRate, uint8_t clk){
@ -766,7 +766,7 @@ bool testBitRate(uint8_t readRate, uint8_t clk){
bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5){ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5){
if ( DemodBufferLen < 64 ) return FALSE; if ( DemodBufferLen < 64 ) return false;
uint8_t si = 0; uint8_t si = 0;
for (uint8_t idx = 28; idx < 64; idx++){ for (uint8_t idx = 28; idx < 64; idx++){
si = idx; si = idx;
@ -788,7 +788,7 @@ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5)
//uint8_t nml02 = PackBits(si, 2, DemodBuffer); si += 2; //uint8_t nml02 = PackBits(si, 2, DemodBuffer); si += 2;
//if extended mode //if extended mode
bool extMode =( (safer == 0x6 || safer == 0x9) && extend) ? TRUE : FALSE; bool extMode =( (safer == 0x6 || safer == 0x9) && extend) ? true : false;
if (!extMode){ if (!extMode){
if (xtRate) continue; //nml01 || nml02 || caused issues on noralys tags if (xtRate) continue; //nml01 || nml02 || caused issues on noralys tags
@ -798,14 +798,14 @@ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5)
if (!testBitRate(bitRate, clk)) continue; if (!testBitRate(bitRate, clk)) continue;
*fndBitRate = bitRate; *fndBitRate = bitRate;
*offset = idx; *offset = idx;
*Q5 = FALSE; *Q5 = false;
return TRUE; return true;
} }
if (testQ5(mode, offset, fndBitRate, clk)) { if (testQ5(mode, offset, fndBitRate, clk)) {
*Q5 = TRUE; *Q5 = true;
return TRUE; return true;
} }
return FALSE; return false;
} }
void printT55xxBlock(const char *blockNum){ void printT55xxBlock(const char *blockNum){
@ -1471,7 +1471,7 @@ int CmdT55xxBruteForce(const char *Cmd) {
PrintAndLog("Testing %08X", testpwd); PrintAndLog("Testing %08X", testpwd);
if ( !AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, TRUE, testpwd)) { if ( !AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, true, testpwd)) {
PrintAndLog("Aquireing data from device failed. Quitting"); PrintAndLog("Aquireing data from device failed. Quitting");
free(keyBlock); free(keyBlock);
return 0; return 0;
@ -1516,7 +1516,7 @@ int CmdT55xxBruteForce(const char *Cmd) {
return 0; return 0;
} }
if (!AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, TRUE, i)) { if (!AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, true, i)) {
PrintAndLog("Aquireing data from device failed. Quitting"); PrintAndLog("Aquireing data from device failed. Quitting");
free(keyBlock); free(keyBlock);
return 0; return 0;

16
client/cmdmain.h
View file

@ -11,12 +11,16 @@
#ifndef CMDMAIN_H__ #ifndef CMDMAIN_H__
#define CMDMAIN_H__ #define CMDMAIN_H__
#include <stdint.h>
#include <stddef.h>
#include "usb_cmd.h" #include "usb_cmd.h"
#include "cmdparser.h" #include "cmdparser.h"
void UsbCommandReceived(UsbCommand *UC);
int CommandReceived(char *Cmd); extern void UsbCommandReceived(UsbCommand *UC);
bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout); extern int CommandReceived(char *Cmd);
bool WaitForResponse(uint32_t cmd, UsbCommand* response); extern bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout);
void clearCommandBuffer(); extern bool WaitForResponse(uint32_t cmd, UsbCommand* response);
command_t* getTopLevelCommandTable(); extern void clearCommandBuffer();
extern command_t* getTopLevelCommandTable();
#endif #endif

162
client/mifarehost.c
View file

@ -12,10 +12,43 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <pthread.h> #include <pthread.h>
#include "mifarehost.h"
#include "nonce2key/crapto1.h"
#include "proxmark3.h" #include "proxmark3.h"
#include "usb_cmd.h"
#include "cmdmain.h"
#include "ui.h"
#include "util.h"
#include "iso14443crc.h"
#include "mifarehost.h"
// mifare tracer flags used in mfTraceDecode()
#define TRACE_IDLE 0x00
#define TRACE_AUTH1 0x01
#define TRACE_AUTH2 0x02
#define TRACE_AUTH_OK 0x03
#define TRACE_READ_DATA 0x04
#define TRACE_WRITE_OK 0x05
#define TRACE_WRITE_DATA 0x06
#define TRACE_ERROR 0xFF
// MIFARE // MIFARE
int mfCheckKeys (uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t * keyBlock, uint64_t * key){
*key = 0;
UsbCommand c = {CMD_MIFARE_CHKKEYS, {((blockNo & 0xff) | ((keyType&0xff)<<8)), clear_trace, keycnt}};
memcpy(c.d.asBytes, keyBlock, 6 * keycnt);
SendCommand(&c);
UsbCommand resp;
if (!WaitForResponseTimeout(CMD_ACK,&resp,3000)) return 1;
if ((resp.arg[0] & 0xff) != 0x01) return 2;
*key = bytes_to_num(resp.d.asBytes, 6);
return 0;
}
int compar_int(const void * a, const void * b) { int compar_int(const void * a, const void * b) {
// didn't work: (the result is truncated to 32 bits) // didn't work: (the result is truncated to 32 bits)
//return (*(uint64_t*)b - *(uint64_t*)a); //return (*(uint64_t*)b - *(uint64_t*)a);
@ -193,21 +226,6 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo
return 0; return 0;
} }
int mfCheckKeys (uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t * keyBlock, uint64_t * key){
*key = 0;
UsbCommand c = {CMD_MIFARE_CHKKEYS, {((blockNo & 0xff) | ((keyType&0xff)<<8)), clear_trace, keycnt}};
memcpy(c.d.asBytes, keyBlock, 6 * keycnt);
SendCommand(&c);
UsbCommand resp;
if (!WaitForResponseTimeout(CMD_ACK,&resp,3000)) return 1;
if ((resp.arg[0] & 0xff) != 0x01) return 2;
*key = bytes_to_num(resp.d.asBytes, 6);
return 0;
}
// EMULATOR // EMULATOR
int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) { int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) {
@ -229,6 +247,45 @@ int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
// "MAGIC" CARD // "MAGIC" CARD
int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) {
uint8_t isOK = 0;
UsbCommand c = {CMD_MIFARE_CGETBLOCK, {params, 0, blockNo}};
SendCommand(&c);
UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
isOK = resp.arg[0] & 0xff;
memcpy(data, resp.d.asBytes, 16);
if (!isOK) return 2;
} else {
PrintAndLog("Command execute timeout");
return 1;
}
return 0;
}
int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, bool wantWipe, uint8_t params) {
uint8_t isOK = 0;
UsbCommand c = {CMD_MIFARE_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
memcpy(c.d.asBytes, data, 16);
SendCommand(&c);
UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
isOK = resp.arg[0] & 0xff;
if (uid != NULL)
memcpy(uid, resp.d.asBytes, 4);
if (!isOK)
return 2;
} else {
PrintAndLog("Command execute timeout");
return 1;
}
return 0;
}
int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID, bool wantWipe) { int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID, bool wantWipe) {
uint8_t oldblock0[16] = {0x00}; uint8_t oldblock0[16] = {0x00};
uint8_t block0[16] = {0x00}; uint8_t block0[16] = {0x00};
@ -257,45 +314,6 @@ int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID, bool w
return mfCSetBlock(0, block0, oldUID, wantWipe, CSETBLOCK_SINGLE_OPER); return mfCSetBlock(0, block0, oldUID, wantWipe, CSETBLOCK_SINGLE_OPER);
} }
int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, bool wantWipe, uint8_t params) {
uint8_t isOK = 0;
UsbCommand c = {CMD_MIFARE_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
memcpy(c.d.asBytes, data, 16);
SendCommand(&c);
UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
isOK = resp.arg[0] & 0xff;
if (uid != NULL)
memcpy(uid, resp.d.asBytes, 4);
if (!isOK)
return 2;
} else {
PrintAndLog("Command execute timeout");
return 1;
}
return 0;
}
int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) {
uint8_t isOK = 0;
UsbCommand c = {CMD_MIFARE_CGETBLOCK, {params, 0, blockNo}};
SendCommand(&c);
UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
isOK = resp.arg[0] & 0xff;
memcpy(data, resp.d.asBytes, 16);
if (!isOK) return 2;
} else {
PrintAndLog("Command execute timeout");
return 1;
}
return 0;
}
// SNIFFER // SNIFFER
// constants // constants
@ -337,6 +355,23 @@ int isBlockTrailer(int blockN) {
return ((blockN & 0x03) == 0x03); return ((blockN & 0x03) == 0x03);
} }
int saveTraceCard(void) {
FILE * f;
if ((!strlen(traceFileName)) || (isTraceCardEmpty())) return 0;
f = fopen(traceFileName, "w+");
if ( !f ) return 1;
for (int i = 0; i < 64; i++) { // blocks
for (int j = 0; j < 16; j++) // bytes
fprintf(f, "%02x", *(traceCard + i * 16 + j));
fprintf(f,"\n");
}
fclose(f);
return 0;
}
int loadTraceCard(uint8_t *tuid) { int loadTraceCard(uint8_t *tuid) {
FILE * f; FILE * f;
char buf[64] = {0x00}; char buf[64] = {0x00};
@ -383,23 +418,6 @@ int loadTraceCard(uint8_t *tuid) {
return 0; return 0;
} }
int saveTraceCard(void) {
FILE * f;
if ((!strlen(traceFileName)) || (isTraceCardEmpty())) return 0;
f = fopen(traceFileName, "w+");
if ( !f ) return 1;
for (int i = 0; i < 64; i++) { // blocks
for (int j = 0; j < 16; j++) // bytes
fprintf(f, "%02x", *(traceCard + i * 16 + j));
fprintf(f,"\n");
}
fclose(f);
return 0;
}
int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile) { int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile) {
if (traceCrypto1) if (traceCrypto1)

67
client/mifarehost.h
View file

@ -8,63 +8,36 @@
// High frequency ISO14443A commands // High frequency ISO14443A commands
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#include <stdio.h> #include <stdint.h>
#include <stdlib.h> #include <stdbool.h>
#include <unistd.h>
#include "common.h"
#include "cmdmain.h"
#include "ui.h"
#include "data.h" #include "data.h"
#include "util.h"
#include "nonce2key/nonce2key.h"
#include "nonce2key/crapto1.h"
#include "iso14443crc.h"
#define MEM_CHUNK 1000000
#define NESTED_SECTOR_RETRY 10
// mfCSetBlock work flags // mfCSetBlock work flags
#define CSETBLOCK_UID 0x01 #define CSETBLOCK_UID 0x01
#define CSETBLOCK_WUPC 0x02 #define CSETBLOCK_WUPC 0x02
#define CSETBLOCK_HALT 0x04 #define CSETBLOCK_HALT 0x04
#define CSETBLOCK_INIT_FIELD 0x08 #define CSETBLOCK_INIT_FIELD 0x08
#define CSETBLOCK_RESET_FIELD 0x10 #define CSETBLOCK_RESET_FIELD 0x10
#define CSETBLOCK_SINGLE_OPER 0x1F #define CSETBLOCK_SINGLE_OPER 0x1F
// mifare tracer flags
#define TRACE_IDLE 0x00
#define TRACE_AUTH1 0x01
#define TRACE_AUTH2 0x02
#define TRACE_AUTH_OK 0x03
#define TRACE_READ_DATA 0x04
#define TRACE_WRITE_OK 0x05
#define TRACE_WRITE_DATA 0x06
#define TRACE_ERROR 0xFF
typedef struct {
uint64_t Key[2];
int foundKey[2];
} sector;
extern char logHexFileName[FILE_PATH_SIZE]; extern char logHexFileName[FILE_PATH_SIZE];
int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t * ResultKeys, bool calibrate); extern int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t * ResultKeys, bool calibrate);
int mfCheckKeys (uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t * keyBlock, uint64_t * key); extern int mfCheckKeys (uint8_t blockNo, uint8_t keyType, bool clear_trace, uint8_t keycnt, uint8_t * keyBlock, uint64_t * key);
int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount); extern int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount);
int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount); extern int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount);
int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID, bool wantWipe); extern int mfCSetUID(uint8_t *uid, uint8_t *atqa, uint8_t *sak, uint8_t *oldUID, bool wantWipe);
int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, bool wantWipe, uint8_t params); extern int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, bool wantWipe, uint8_t params);
int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params); extern int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params);
int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile); extern int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile);
int mfTraceDecode(uint8_t *data_src, int len, bool wantSaveToEmlFile); extern int mfTraceDecode(uint8_t *data_src, int len, bool wantSaveToEmlFile);
int isTraceCardEmpty(void); extern int isTraceCardEmpty(void);
int isBlockEmpty(int blockN); extern int isBlockEmpty(int blockN);
int isBlockTrailer(int blockN); extern int isBlockTrailer(int blockN);
int loadTraceCard(uint8_t *tuid); extern int loadTraceCard(uint8_t *tuid);
int saveTraceCard(void); extern int saveTraceCard(void);
int tryDecryptWord(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len); extern int tryDecryptWord(uint32_t nt, uint32_t ar_enc, uint32_t at_enc, uint8_t *data, int len);

7
client/nonce2key/nonce2key.c
View file

@ -10,12 +10,13 @@
// MIFARE Darkside hack // MIFARE Darkside hack
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#define __STDC_FORMAT_MACROS
#include <inttypes.h> #include <inttypes.h>
#include <time.h>
#include "nonce2key.h" #include "nonce2key.h"
#include "mifarehost.h" #include "mifarehost.h"
#include "ui.h" #include "ui.h"
#include "util.h"
int compar_state(const void * a, const void * b) { int compar_state(const void * a, const void * b) {
// didn't work: (the result is truncated to 32 bits) // didn't work: (the result is truncated to 32 bits)
@ -161,7 +162,7 @@ bool mfkey32(nonces_t data, uint64_t *outputkey) {
uint32_t nr1_enc = data.nr2; // second encrypted reader challenge uint32_t nr1_enc = data.nr2; // second encrypted reader challenge
uint32_t ar1_enc = data.ar2; // second encrypted reader response uint32_t ar1_enc = data.ar2; // second encrypted reader response
clock_t t1 = clock(); clock_t t1 = clock();
bool isSuccess = FALSE; bool isSuccess = false;
uint8_t counter=0; uint8_t counter=0;
s = lfsr_recovery32(ar0_enc ^ prng_successor(nt, 64), 0); s = lfsr_recovery32(ar0_enc ^ prng_successor(nt, 64), 0);
@ -208,7 +209,7 @@ bool tryMfk32_moebius(nonces_t data, uint64_t *outputkey) {
uint32_t nt1 = data.nonce2; // second tag challenge (nonce) uint32_t nt1 = data.nonce2; // second tag challenge (nonce)
uint32_t nr1_enc = data.nr2; // second encrypted reader challenge uint32_t nr1_enc = data.nr2; // second encrypted reader challenge
uint32_t ar1_enc = data.ar2; // second encrypted reader response uint32_t ar1_enc = data.ar2; // second encrypted reader response
bool isSuccess = FALSE; bool isSuccess = false;
int counter = 0; int counter = 0;
//PrintAndLog("Enter mfkey32_moebius"); //PrintAndLog("Enter mfkey32_moebius");

2
client/util.h
View file

@ -25,8 +25,6 @@
#ifndef MAX #ifndef MAX
# define MAX(a, b) (((a) > (b)) ? (a) : (b)) # define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif #endif
#define TRUE 1
#define FALSE 0
#define EVEN 0 #define EVEN 0
#define ODD 1 #define ODD 1

2
client/whereami.c
View file

@ -261,7 +261,7 @@ int WAI_PREFIX(getModulePath)(char* out, int capacity, int* dirname_length)
if (!fgets(buffer, sizeof(buffer), maps)) if (!fgets(buffer, sizeof(buffer), maps))
break; break;
if (sscanf(buffer, "%" PRIx64 "-%" PRIx64 " %s %" PRIx64 " %x:%x %u %s\n", &low, &high, perms, &offset, &major, &minor, &inode, path) == 8) if (sscanf(buffer, "%" SCNx64 "-%" SCNx64 " %s %" SCNx64 " %x:%x %u %s\n", &low, &high, perms, &offset, &major, &minor, &inode, path) == 8)
{ {
uint64_t addr = (uint64_t)(uintptr_t)WAI_RETURN_ADDRESS(); uint64_t addr = (uint64_t)(uintptr_t)WAI_RETURN_ADDRESS();
if (low <= addr && addr <= high) if (low <= addr && addr <= high)