X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/40148ab609cdcf58ae6ef517c319a758006e1c6d..1fbf89561686188fa869a10e1251406740238234:/client/cmdlf.c diff --git a/client/cmdlf.c b/client/cmdlf.c index 2215aff6..0fab2adf 100644 --- a/client/cmdlf.c +++ b/client/cmdlf.c @@ -28,6 +28,7 @@ #include "cmdlft55xx.h" #include "cmdlfpcf7931.h" #include "cmdlfio.h" +#include "lfdemod.h" static int CmdHelp(const char *Cmd); @@ -361,6 +362,7 @@ int usage_lf_read() PrintAndLog("Usage: lf read"); PrintAndLog("Options: "); PrintAndLog(" h This help"); + PrintAndLog(" s silent run no printout"); PrintAndLog("This function takes no arguments. "); PrintAndLog("Use 'lf config' to set parameters."); return 0; @@ -480,13 +482,15 @@ int CmdLFSetConfig(const char *Cmd) int CmdLFRead(const char *Cmd) { - uint8_t cmdp =0; - if(param_getchar(Cmd, cmdp) == 'h') + uint8_t cmdp = 0; + bool arg1 = false; + if (param_getchar(Cmd, cmdp) == 'h') { return usage_lf_read(); } + if (param_getchar(Cmd, cmdp) == 's') arg1 = true; //suppress print //And ship it to device - UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K}; + UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, {arg1,0,0}}; SendCommand(&c); WaitForResponse(CMD_ACK,NULL); return 0; @@ -509,11 +513,11 @@ int CmdLFSnoop(const char *Cmd) static void ChkBitstream(const char *str) { int i; - + /* convert to bitstream if necessary */ for (i = 0; i < (int)(GraphTraceLen / 2); i++){ if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0) { - CmdBitstream(str); + CmdGetBitStream(""); break; } } @@ -521,29 +525,30 @@ static void ChkBitstream(const char *str) //appears to attempt to simulate manchester int CmdLFSim(const char *Cmd) { - int i,j; + int i,j; static int gap; sscanf(Cmd, "%i", &gap); /* convert to bitstream if necessary */ + ChkBitstream(Cmd); //can send 512 bits at a time (1 byte sent per bit...) - printf("Sending [%d bytes]", GraphTraceLen); - for (i = 0; i < GraphTraceLen; i += USB_CMD_DATA_SIZE) { + printf("Sending [%d bytes]", GraphTraceLen); + for (i = 0; i < GraphTraceLen; i += USB_CMD_DATA_SIZE) { UsbCommand c={CMD_DOWNLOADED_SIM_SAMPLES_125K, {i, 0, 0}}; - for (j = 0; j < USB_CMD_DATA_SIZE; j++) { + for (j = 0; j < USB_CMD_DATA_SIZE; j++) { c.d.asBytes[j] = GraphBuffer[i+j]; } SendCommand(&c); WaitForResponse(CMD_ACK,NULL); - printf("."); + printf("."); } - printf("\n"); - PrintAndLog("Starting to simulate"); + printf("\n"); + PrintAndLog("Starting to simulate"); UsbCommand c = {CMD_SIMULATE_TAG_125K, {GraphTraceLen, gap, 0}}; SendCommand(&c); return 0; @@ -561,29 +566,46 @@ int usage_lf_simfsk(void) PrintAndLog(" L Manually set the smaller Field Clock"); //PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap"); PrintAndLog(" d Data to sim as hex - omit to sim from DemodBuffer"); + PrintAndLog("\n NOTE: if you set one clock manually set them all manually"); return 0; } int usage_lf_simask(void) { //print help - PrintAndLog("Usage: lf simask [c ] [i] [m|r] [s] [d ]"); + PrintAndLog("Usage: lf simask [c ] [i] [b|m|r] [s] [d ]"); PrintAndLog("Options: "); PrintAndLog(" h This help"); PrintAndLog(" c Manually set clock - can autodetect if using DemodBuffer"); PrintAndLog(" i invert data"); - PrintAndLog(" m sim ask/manchester"); + PrintAndLog(" b sim ask/biphase"); + PrintAndLog(" m sim ask/manchester - Default"); PrintAndLog(" r sim ask/raw"); PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap"); PrintAndLog(" d Data to sim as hex - omit to sim from DemodBuffer"); return 0; } +int usage_lf_simpsk(void) +{ + //print help + PrintAndLog("Usage: lf simpsk [1|2|3] [c ] [i] [r ] [d ]"); + PrintAndLog("Options: "); + PrintAndLog(" h This help"); + PrintAndLog(" c Manually set clock - can autodetect if using DemodBuffer"); + PrintAndLog(" i invert data"); + PrintAndLog(" 1 set PSK1 (default)"); + PrintAndLog(" 2 set PSK2"); + PrintAndLog(" 3 set PSK3"); + PrintAndLog(" r 2|4|8 are valid carriers: default = 2"); + PrintAndLog(" d Data to sim as hex - omit to sim from DemodBuffer"); + return 0; +} + // by marshmellow - sim ask data given clock, fcHigh, fcLow, invert // - allow pull data from DemodBuffer int CmdLFfskSim(const char *Cmd) { - //todo - allow data from demodbuffer or parameters //might be able to autodetect FC and clock from Graphbuffer if using demod buffer //will need FChigh, FClow, Clock, and bitstream uint8_t fcHigh=0, fcLow=0, clk=0; @@ -625,7 +647,8 @@ int CmdLFfskSim(const char *Cmd) errors=TRUE; } else { dataLen = hextobinarray((char *)data, hexData); - } if (dataLen==0) errors=TRUE; + } + if (dataLen==0) errors=TRUE; if (errors) PrintAndLog ("Error getting hex data"); cmdp+=2; break; @@ -646,13 +669,14 @@ int CmdLFfskSim(const char *Cmd) { return usage_lf_simfsk(); } - if (dataLen == 0){ //using DemodBuffer - if (clk==0 || fcHigh==0 || fcLow==0){ + + if (dataLen == 0){ //using DemodBuffer + if (clk==0 || fcHigh==0 || fcLow==0){ //manual settings must set them all uint8_t ans = fskClocks(&fcHigh, &fcLow, &clk, 0); if (ans==0){ - fcHigh=10; - fcLow=8; - clk=50; + if (!fcHigh) fcHigh=10; + if (!fcLow) fcLow=8; + if (!clk) clk=50; } } } else { @@ -665,11 +689,14 @@ int CmdLFfskSim(const char *Cmd) uint16_t arg1, arg2; arg1 = fcHigh << 8 | fcLow; arg2 = invert << 8 | clk; - UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, DemodBufferLen}}; - if (DemodBufferLen > USB_CMD_DATA_SIZE) { - PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", DemodBufferLen, USB_CMD_DATA_SIZE); - } - memcpy(c.d.asBytes, DemodBuffer, DemodBufferLen); + size_t size = DemodBufferLen; + if (size > USB_CMD_DATA_SIZE) { + PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE); + size = USB_CMD_DATA_SIZE; + } + UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}}; + + memcpy(c.d.asBytes, DemodBuffer, size); SendCommand(&c); return 0; } @@ -678,10 +705,9 @@ int CmdLFfskSim(const char *Cmd) // - allow pull data from DemodBuffer int CmdLFaskSim(const char *Cmd) { - //todo - allow data from demodbuffer or parameters //autodetect clock from Graphbuffer if using demod buffer //will need clock, invert, manchester/raw as m or r, separator as s, and bitstream - uint8_t manchester = 1, separator = 0; + uint8_t encoding = 1, separator = 0; //char cmdp = Cmd[0], par3='m', par4=0; uint8_t clk=0, invert=0; bool errors = FALSE; @@ -703,12 +729,16 @@ int CmdLFaskSim(const char *Cmd) errors |= param_getdec(Cmd,cmdp+1,&clk); cmdp+=2; break; + case 'b': + encoding=2; //biphase + cmdp++; + break; case 'm': - manchester=1; + encoding=1; cmdp++; break; case 'r': - manchester=0; + encoding=0; cmdp++; break; case 's': @@ -749,20 +779,129 @@ int CmdLFaskSim(const char *Cmd) setDemodBuf(data, dataLen, 0); } if (clk == 0) clk = 64; - + if (encoding == 0) clk = clk/2; //askraw needs to double the clock speed uint16_t arg1, arg2; - arg1 = clk << 8 | manchester; + size_t size=DemodBufferLen; + arg1 = clk << 8 | encoding; arg2 = invert << 8 | separator; - UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, DemodBufferLen}}; - if (DemodBufferLen > USB_CMD_DATA_SIZE) { - PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", DemodBufferLen, USB_CMD_DATA_SIZE); + if (size > USB_CMD_DATA_SIZE) { + PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE); + size = USB_CMD_DATA_SIZE; } - PrintAndLog("preparing to sim ask data: %d bits", DemodBufferLen); - memcpy(c.d.asBytes, DemodBuffer, DemodBufferLen); + UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}}; + PrintAndLog("preparing to sim ask data: %d bits", size); + memcpy(c.d.asBytes, DemodBuffer, size); SendCommand(&c); return 0; } +// by marshmellow - sim psk data given carrier, clock, invert +// - allow pull data from DemodBuffer or parameters +int CmdLFpskSim(const char *Cmd) +{ + //might be able to autodetect FC and clock from Graphbuffer if using demod buffer + //will need carrier, Clock, and bitstream + uint8_t carrier=0, clk=0; + uint8_t invert=0; + bool errors = FALSE; + char hexData[32] = {0x00}; // store entered hex data + uint8_t data[255] = {0x00}; + int dataLen = 0; + uint8_t cmdp = 0; + uint8_t pskType = 1; + while(param_getchar(Cmd, cmdp) != 0x00) + { + switch(param_getchar(Cmd, cmdp)) + { + case 'h': + return usage_lf_simpsk(); + case 'i': + invert = 1; + cmdp++; + break; + case 'c': + errors |= param_getdec(Cmd,cmdp+1,&clk); + cmdp+=2; + break; + case 'r': + errors |= param_getdec(Cmd,cmdp+1,&carrier); + cmdp+=2; + break; + case '1': + pskType=1; + cmdp++; + break; + case '2': + pskType=2; + cmdp++; + break; + case '3': + pskType=3; + cmdp++; + break; + case 'd': + dataLen = param_getstr(Cmd, cmdp+1, hexData); + if (dataLen==0) { + errors=TRUE; + } else { + dataLen = hextobinarray((char *)data, hexData); + } + if (dataLen==0) errors=TRUE; + if (errors) PrintAndLog ("Error getting hex data"); + cmdp+=2; + break; + default: + PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp)); + errors = TRUE; + break; + } + if (errors) break; + } + if (cmdp == 0 && DemodBufferLen == 0) + { + errors = TRUE;// No args + } + + //Validations + if (errors) + { + return usage_lf_simpsk(); + } + if (dataLen == 0){ //using DemodBuffer + PrintAndLog("Getting Clocks"); + if (clk==0) clk = GetPskClock("", FALSE, FALSE); + PrintAndLog("clk: %d",clk); + if (!carrier) carrier = GetPskCarrier("", FALSE, FALSE); + PrintAndLog("carrier: %d", carrier); + } else { + setDemodBuf(data, dataLen, 0); + } + + if (clk <= 0) clk = 32; + if (carrier == 0) carrier = 2; + if (pskType != 1){ + if (pskType == 2){ + //need to convert psk2 to psk1 data before sim + psk2TOpsk1(DemodBuffer, DemodBufferLen); + } else { + PrintAndLog("Sorry, PSK3 not yet available"); + } + } + uint16_t arg1, arg2; + arg1 = clk << 8 | carrier; + arg2 = invert; + size_t size=DemodBufferLen; + if (size > USB_CMD_DATA_SIZE) { + PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE); + size=USB_CMD_DATA_SIZE; + } + UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}}; + PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size); + memcpy(c.d.asBytes, DemodBuffer, size); + SendCommand(&c); + + return 0; +} int CmdLFSimBidir(const char *Cmd) { @@ -775,6 +914,7 @@ int CmdLFSimBidir(const char *Cmd) } /* simulate an LF Manchester encoded tag with specified bitstream, clock rate and inter-id gap */ +/* int CmdLFSimManchester(const char *Cmd) { static int clock, gap; @@ -795,7 +935,7 @@ int CmdLFSimManchester(const char *Cmd) CmdLFSim(gapstring); return 0; } - +*/ int CmdVchDemod(const char *Cmd) { @@ -879,7 +1019,7 @@ int CmdLFfind(const char *Cmd) int ans=0; char cmdp = param_getchar(Cmd, 0); char testRaw = param_getchar(Cmd, 1); - if (strlen(Cmd) > 2 || cmdp == 'h' || cmdp == 'H') { + if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') { PrintAndLog("Usage: lf search <0|1> [u]"); PrintAndLog(" , if not set, try reading data from tag."); PrintAndLog(" [Search for Unknown tags] , if not set, reads only known tags."); @@ -900,67 +1040,88 @@ int CmdLFfind(const char *Cmd) return 0; } if (cmdp == 'u' || cmdp == 'U') testRaw = 'u'; + PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag"); PrintAndLog("False Positives ARE possible\n"); PrintAndLog("\nChecking for known tags:\n"); + ans=CmdFSKdemodIO(""); if (ans>0) { PrintAndLog("\nValid IO Prox ID Found!"); return 1; } + ans=CmdFSKdemodPyramid(""); if (ans>0) { PrintAndLog("\nValid Pyramid ID Found!"); return 1; } + ans=CmdFSKdemodParadox(""); if (ans>0) { PrintAndLog("\nValid Paradox ID Found!"); return 1; } + ans=CmdFSKdemodAWID(""); if (ans>0) { PrintAndLog("\nValid AWID ID Found!"); return 1; } + ans=CmdFSKdemodHID(""); if (ans>0) { PrintAndLog("\nValid HID Prox ID Found!"); return 1; } + //add psk and indala ans=CmdIndalaDecode(""); if (ans>0) { PrintAndLog("\nValid Indala ID Found!"); return 1; } + ans=CmdAskEM410xDemod(""); if (ans>0) { PrintAndLog("\nValid EM410x ID Found!"); return 1; } + + ans=CmdG_Prox_II_Demod(""); + if (ans>0) { + PrintAndLog("\nValid G Prox II ID Found!"); + return 1; + } + PrintAndLog("\nNo Known Tags Found!\n"); if (testRaw=='u' || testRaw=='U'){ //test unknown tag formats (raw mode) PrintAndLog("\nChecking for Unknown tags:\n"); - ans=CmdDetectClockRate("f"); + ans=AutoCorrelate(4000, FALSE, FALSE); + if (ans > 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans); + ans=GetFskClock("",FALSE,FALSE); //CmdDetectClockRate("F"); // if (ans != 0){ //fsk - ans=CmdFSKrawdemod(""); + ans=FSKrawDemod("",FALSE); if (ans>0) { PrintAndLog("\nUnknown FSK Modulated Tag Found!"); + printDemodBuff(); return 1; } } - ans=Cmdaskmandemod(""); + ans=ASKmanDemod("",FALSE,FALSE); if (ans>0) { 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'"); + printDemodBuff(); return 1; } ans=CmdPSK1rawDemod(""); if (ans>0) { - PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data psk2rawdemod'"); + PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data rawdemod p2'"); PrintAndLog("\nCould also be PSK3 - [currently not supported]"); PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod"); + printDemodBuff(); return 1; } PrintAndLog("\nNo Data Found!\n"); @@ -979,13 +1140,14 @@ static command_t CommandTable[] = {"io", CmdLFIO, 1, "{ ioProx tags... }"}, {"indalademod", CmdIndalaDemod, 1, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"}, {"indalaclone", CmdIndalaClone, 0, " ['l']-- Clone Indala to T55x7 (tag must be in antenna)(UID in HEX)(option 'l' for 224 UID"}, - {"read", CmdLFRead, 0, "Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"}, + {"read", CmdLFRead, 0, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"}, {"search", CmdLFfind, 1, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) - 'u' to search for unknown tags"}, {"sim", CmdLFSim, 0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"}, - {"simask", CmdLFaskSim, 0, "[clock] [invert <1|0>] [manchester/raw <'m'|'r'>] [trs separator 's'] -- Simulate LF ASK tag from demodbuffer"}, - {"simfsk", CmdLFfskSim, 0, "[invert <1|0>] -- Simulate LF FSK tag from demodbuffer"}, + {"simask", CmdLFaskSim, 0, "[clock] [invert <1|0>] [manchester/raw <'m'|'r'>] [msg separator 's'] [d ] -- Simulate LF ASK tag from demodbuffer or input"}, + {"simfsk", CmdLFfskSim, 0, "[c ] [i] [H ] [L ] [d ] -- Simulate LF FSK tag from demodbuffer or input"}, + {"simpsk", CmdLFpskSim, 0, "[1|2|3] [c ] [i] [r ] [d ] -- Simulate LF PSK tag from demodbuffer or input"}, {"simbidir", CmdLFSimBidir, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"}, - {"simman", CmdLFSimManchester, 0, " [GAP] Simulate arbitrary Manchester LF tag"}, + //{"simman", CmdLFSimManchester, 0, " [GAP] Simulate arbitrary Manchester LF tag"}, {"snoop", CmdLFSnoop, 0, "['l'|'h'|] [trigger threshold]-- Snoop LF (l:125khz, h:134khz)"}, {"ti", CmdLFTI, 1, "{ TI RFIDs... }"}, {"hitag", CmdLFHitag, 1, "{ Hitag tags and transponders... }"},