RfidResearchGroup/proxmark3
1
1
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-03-20 03:48:33 +08:00
Code Issues Projects Releases Packages Wiki Activity

lf Bug Fixes and lf demod additions

Browse source 
added data fskparadoxdemod
added data setdebugmode (for demods)
added data shiftgraphzero (to help clean weak reads)
fixed a few bugs with the data detectaskclock
added data fskfcdetect to detect FSK clocks
adjusted most of my demods to put raw tag binary to demod buffer for
future sim and clone commands (psk still needs work)
This commit is contained in:
marshmellow42 2015-01-20 17:28:51 -05:00
parent 53d85a8fa1
commit ec75f5c10a
7 changed files with 429 additions and 231 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
armsrc/lfops.c
View file

@ -633,7 +633,7 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0; //, found=0; size_t size=sizeof(BigBuf), idx=0; //, found=0;
uint32_t hi2=0, hi=0, lo=0; uint32_t hi2=0, hi=0, lo=0;
// Configure to go in 125Khz listen mode // Configure to go in 125Khz listen mode
@ -646,11 +646,11 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
DoAcquisition125k_internal(-1,true); DoAcquisition125k_internal(-1,true);
// FSK demodulator // FSK demodulator
size = HIDdemodFSK(dest, sizeof(BigBuf), &hi2, &hi, &lo); idx = HIDdemodFSK(dest, &size, &hi2, &hi, &lo);
WDT_HIT(); WDT_HIT();
if (size>0 && lo>0){ if (idx>0 && lo>0){
// final loop, go over previously decoded manchester data and decode into usable tag ID // final loop, go over previously decoded manchester data and decode into usable tag ID
// 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0 // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
if (hi2 != 0){ //extra large HID tags if (hi2 != 0){ //extra large HID tags
@ -721,7 +721,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0; size_t size=0, idx=0;
int clk=0, invert=0, errCnt=0; int clk=0, invert=0, errCnt=0;
uint64_t lo=0; uint64_t lo=0;
// Configure to go in 125Khz listen mode // Configure to go in 125Khz listen mode
@ -741,7 +741,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
WDT_HIT(); WDT_HIT();
if (errCnt>=0){ if (errCnt>=0){
lo = Em410xDecode(dest,size); lo = Em410xDecode(dest, &size, &idx);
//Dbprintf("DEBUG: EM GOT"); //Dbprintf("DEBUG: EM GOT");
if (lo>0){ if (lo>0){
Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)", Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",

355
client/cmddata.c
View file

@ -22,21 +22,30 @@
#include "cmddata.h" #include "cmddata.h"
#include "lfdemod.h" #include "lfdemod.h"
uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN]; uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
uint8_t g_debugMode;
int DemodBufferLen; int DemodBufferLen;
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);
//set the demod buffer with given array of binary (one bit per byte) //set the demod buffer with given array of binary (one bit per byte)
//by marshmellow //by marshmellow
void setDemodBuf(uint8_t *buff,int size) void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx)
{ {
int i=0; size_t i = 0;
for (; i < size; ++i){ for (; i < size; i++){
DemodBuffer[i]=buff[i]; DemodBuffer[i]=buff[startIdx++];
} }
DemodBufferLen=size; DemodBufferLen=size;
return; return;
} }
int CmdSetDebugMode(const char *Cmd)
{
int demod=0;
sscanf(Cmd, "%i", &demod);
g_debugMode=(uint8_t)demod;
return 1;
}
//by marshmellow //by marshmellow
void printDemodBuff() void printDemodBuff()
{ {
@ -206,7 +215,7 @@ void printEM410x(uint64_t id)
{ {
if (id !=0){ if (id !=0){
uint64_t iii=1; uint64_t iii=1;
uint64_t id2lo=0; //id2hi=0, uint64_t id2lo=0;
uint32_t ii=0; uint32_t ii=0;
uint32_t i=0; uint32_t i=0;
for (ii=5; ii>0;ii--){ for (ii=5; ii>0;ii--){
@ -216,7 +225,7 @@ void printEM410x(uint64_t id)
} }
//output em id //output em id
PrintAndLog("EM TAG ID : %010llx", id); PrintAndLog("EM TAG ID : %010llx", id);
PrintAndLog("Unique TAG ID: %010llx", id2lo); //id2hi, PrintAndLog("Unique TAG ID: %010llx", id2lo);
PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF); PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF);
PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF); PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF);
PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF)); PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
@ -233,12 +242,17 @@ void printEM410x(uint64_t id)
int CmdEm410xDecode(const char *Cmd) int CmdEm410xDecode(const char *Cmd)
{ {
uint64_t id=0; uint64_t id=0;
// uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; size_t size = DemodBufferLen, idx=0;
// uint32_t i=0; id = Em410xDecode(DemodBuffer, &size, &idx);
// i=getFromGraphBuf(BitStream); if (id>0){
id = Em410xDecode(DemodBuffer,DemodBufferLen); setDemodBuf(DemodBuffer, size, idx);
printEM410x(id); if (g_debugMode){
if (id>0) return 1; PrintAndLog("DEBUG: Printing demod buffer:");
printDemodBuff();
}
printEM410x(id);
return 1;
}
return 0; return 0;
} }
@ -249,7 +263,7 @@ int CmdEm410xDecode(const char *Cmd)
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int Cmdaskmandemod(const char *Cmd) int Cmdaskmandemod(const char *Cmd)
{ {
int invert=0; int invert=0;
int clk=0; int clk=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert); sscanf(Cmd, "%i %i", &clk, &invert);
@ -259,11 +273,11 @@ int Cmdaskmandemod(const char *Cmd)
} }
size_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
// PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
int errCnt=0; int errCnt=0;
errCnt = askmandemod(BitStream, &BitLen,&clk,&invert); errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
if (errCnt<0||BitLen<16){ //if fatal error (or -1) if (errCnt<0||BitLen<16){ //if fatal error (or -1)
// PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0; return 0;
} }
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen); PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
@ -274,17 +288,22 @@ int Cmdaskmandemod(const char *Cmd)
} }
PrintAndLog("ASK/Manchester decoded bitstream:"); PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
setDemodBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen,0);
printDemodBuff(); printDemodBuff();
uint64_t lo =0; uint64_t lo =0;
lo = Em410xDecode(BitStream,BitLen); size_t idx=0;
lo = Em410xDecode(BitStream, &BitLen, &idx);
if (lo>0){ if (lo>0){
//set GraphBuffer for clone or sim command //set GraphBuffer for clone or sim command
setDemodBuf(BitStream, BitLen, idx);
if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
printDemodBuff();
}
PrintAndLog("EM410x pattern found: "); PrintAndLog("EM410x pattern found: ");
printEM410x(lo); printEM410x(lo);
return 1; return 1;
} }
//if (BitLen>16) return 1;
return 0; return 0;
} }
@ -317,9 +336,14 @@ int Cmdmandecoderaw(const char *Cmd)
printBitStream(BitStream, size); printBitStream(BitStream, size);
if (errCnt==0){ if (errCnt==0){
uint64_t id = 0; uint64_t id = 0;
id = Em410xDecode(BitStream, size); size_t idx=0;
if (id>0) setDemodBuf(BitStream, size); id = Em410xDecode(BitStream, &size, &idx);
printEM410x(id); if (id>0){
//need to adjust to set bitstream back to manchester encoded data
//setDemodBuf(BitStream, size, idx);
printEM410x(id);
}
} }
return 1; return 1;
} }
@ -366,7 +390,6 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
return 1; return 1;
} }
//by marshmellow //by marshmellow
//takes 2 arguments - clock and invert both as integers //takes 2 arguments - clock and invert both as integers
//attempts to demodulate ask only //attempts to demodulate ask only
@ -386,14 +409,15 @@ int Cmdaskrawdemod(const char *Cmd)
errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert); errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
PrintAndLog("no data found"); PrintAndLog("no data found");
if (g_debugMode==1) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
return 0; return 0;
} }
PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
//PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
//move BitStream back to DemodBuffer //move BitStream back to DemodBuffer
setDemodBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen,0);
//output //output
if (errCnt>0){ if (errCnt>0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
} }
@ -541,6 +565,27 @@ int CmdDec(const char *Cmd)
return 0; return 0;
} }
//by marshmellow
//shift graph zero up or down based on input + or -
int CmdGraphShiftZero(const char *Cmd)
{
int shift=0;
//set options from parameters entered with the command
sscanf(Cmd, "%i", &shift);
int shiftedVal=0;
for(int i = 0; i<GraphTraceLen; i++){
shiftedVal=GraphBuffer[i]+shift;
if (shiftedVal>127)
shiftedVal=127;
else if (shiftedVal<-127)
shiftedVal=-127;
GraphBuffer[i]= shiftedVal;
}
CmdNorm("");
return 0;
}
/* Print our clock rate */ /* Print our clock rate */
// uses data from graphbuffer // uses data from graphbuffer
int CmdDetectClockRate(const char *Cmd) int CmdDetectClockRate(const char *Cmd)
@ -567,7 +612,6 @@ int CmdFSKrawdemod(const char *Cmd)
sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow); sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
if (strlen(Cmd)>0 && strlen(Cmd)<=2) { if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
//rfLen=param_get8(Cmd, 0); //if rfLen option only is used
if (rfLen==1){ if (rfLen==1){
invert=1; //if invert option only is used invert=1; //if invert option only is used
rfLen = 50; rfLen = 50;
@ -579,7 +623,7 @@ int CmdFSKrawdemod(const char *Cmd)
int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow); int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
if (size>0){ if (size>0){
PrintAndLog("FSK decoded bitstream:"); PrintAndLog("FSK decoded bitstream:");
setDemodBuf(BitStream,size); setDemodBuf(BitStream,size,0);
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size
@ -601,20 +645,20 @@ int CmdFSKdemodHID(const char *Cmd)
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t BitLen = getFromGraphBuf(BitStream); size_t BitLen = getFromGraphBuf(BitStream);
//get binary from fsk wave //get binary from fsk wave
size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo); size_t idx = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
if (size<0){ if (idx<0){
PrintAndLog("Error demoding fsk"); if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk");
return 0;
}
if (hi2==0 && hi==0 && lo==0) {
if (g_debugMode) PrintAndLog("DEBUG: Error - no values found");
return 0; return 0;
} }
if (hi2==0 && hi==0 && lo==0) return 0;
if (hi2 != 0){ //extra large HID tags if (hi2 != 0){ //extra large HID tags
PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)", PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
setDemodBuf(BitStream,BitLen);
return 1;
} }
else { //standard HID tags <38 bits else { //standard HID tags <38 bits
//Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
uint8_t fmtLen = 0; uint8_t fmtLen = 0;
uint32_t fc = 0; uint32_t fc = 0;
uint32_t cardnum = 0; uint32_t cardnum = 0;
@ -654,12 +698,49 @@ int CmdFSKdemodHID(const char *Cmd)
PrintAndLog("HID Prox TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d", PrintAndLog("HID Prox TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
(unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum); (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
setDemodBuf(BitStream,BitLen);
return 1;
} }
return 0; setDemodBuf(BitStream,BitLen,idx);
if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
printDemodBuff();
}
return 1;
} }
//by marshmellow (based on existing demod + holiman's refactor)
//Paradox Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
//print full Paradox Prox ID and some bit format details if found
int CmdFSKdemodParadox(const char *Cmd)
{
//raw fsk demod no manchester decoding no start bit finding just get binary from wave
uint32_t hi2=0, hi=0, lo=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t BitLen = getFromGraphBuf(BitStream);
//get binary from fsk wave
size_t idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
if (idx<0){
if (g_debugMode) PrintAndLog("DEBUG: Error demoding fsk");
return 0;
}
if (hi2==0 && hi==0 && lo==0){
if (g_debugMode) PrintAndLog("DEBUG: Error - no value found");
return 0;
}
uint32_t fc = ((hi & 0x3)<<6) | (lo>>26);
uint32_t cardnum = (lo>>10)&0xFFFF;
PrintAndLog("Paradox TAG ID: %x%08x - FC: %d - Card: %d - Checksum: %02x",
hi>>10, (hi & 0x3)<<26 | (lo>>10), fc, cardnum, (lo>>2) & 0xFF );
setDemodBuf(BitStream,BitLen,idx);
if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, len: %d, Printing Demod Buffer:", idx, BitLen);
printDemodBuff();
}
return 1;
}
//by marshmellow //by marshmellow
//IO-Prox demod - FSK RF/64 with preamble of 000000001 //IO-Prox demod - FSK RF/64 with preamble of 000000001
//print ioprox ID and some format details //print ioprox ID and some format details
@ -668,21 +749,25 @@ int CmdFSKdemodIO(const char *Cmd)
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults //set defaults
int idx=0; int idx=0;
//something in graphbuffer //something in graphbuffer?
if (GraphTraceLen < 65) return 0; if (GraphTraceLen < 65) {
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; if (g_debugMode)PrintAndLog("DEBUG: not enough samples in GraphBuffer");
size_t BitLen = getFromGraphBuf(BitStream); return 0;
//get binary from fsk wave }
// PrintAndLog("DEBUG: got buff"); uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
idx = IOdemodFSK(BitStream,BitLen); size_t BitLen = getFromGraphBuf(BitStream);
if (idx<0){
//PrintAndLog("Error demoding fsk"); //get binary from fsk wave
idx = IOdemodFSK(BitStream,BitLen);
if (idx<0){
if (g_debugMode==1) PrintAndLog("DEBUG: demoding fsk error: %d", idx);
return 0; return 0;
} }
// PrintAndLog("DEBUG: Got IOdemodFSK");
if (idx==0){ if (idx==0){
//PrintAndLog("IO Prox Data not found - FSK Data:"); if (g_debugMode==1){
//if (BitLen > 92) printBitStream(BitStream,92); PrintAndLog("DEBUG: IO Prox Data not found - FSK Bits: %d",BitLen);
if (BitLen > 92) printBitStream(BitStream,92);
}
return 0; return 0;
} }
//Index map //Index map
@ -694,7 +779,10 @@ int CmdFSKdemodIO(const char *Cmd)
// //
//XSF(version)facility:codeone+codetwo (raw) //XSF(version)facility:codeone+codetwo (raw)
//Handle the data //Handle the data
if (idx+64>BitLen) return 0; if (idx+64>BitLen) {
if (g_debugMode==1) PrintAndLog("not enough bits found - bitlen: %d",BitLen);
return 0;
}
PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx], BitStream[idx+1], BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]); PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx], BitStream[idx+1], BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]);
PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9], BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]); PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9], BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]);
PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]); PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]);
@ -709,12 +797,12 @@ int CmdFSKdemodIO(const char *Cmd)
uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ; uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ;
uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9 uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
PrintAndLog("IO Prox XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2); PrintAndLog("IO Prox XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);
int i; setDemodBuf(BitStream,64,idx);
for (i=0;i<64;++i) if (g_debugMode){
DemodBuffer[i]=BitStream[idx++]; PrintAndLog("DEBUG: idx: %d, Len: %d, Printing demod buffer:",idx,64);
printDemodBuff();
DemodBufferLen=64; }
return 1; return 1;
} }
@ -724,8 +812,8 @@ int CmdFSKdemodIO(const char *Cmd)
int CmdFSKdemodAWID(const char *Cmd) int CmdFSKdemodAWID(const char *Cmd)
{ {
int verbose=1; //int verbose=1;
sscanf(Cmd, "%i", &verbose); //sscanf(Cmd, "%i", &verbose);
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
@ -734,17 +822,21 @@ int CmdFSKdemodAWID(const char *Cmd)
//get binary from fsk wave //get binary from fsk wave
int idx = AWIDdemodFSK(BitStream, size); int idx = AWIDdemodFSK(BitStream, size);
if (idx<=0){ if (idx<=0){
if (verbose){ if (g_debugMode==1){
if (idx == -1) if (idx == -1)
PrintAndLog("Error: not enough samples"); PrintAndLog("DEBUG: Error - not enough samples");
else if (idx == -2) else if (idx == -2)
PrintAndLog("Error: only noise found - no waves"); PrintAndLog("DEBUG: Error - only noise found - no waves");
else if (idx == -3) else if (idx == -3)
PrintAndLog("Error: problem during FSK demod"); PrintAndLog("DEBUG: Error - problem during FSK demod");
// else if (idx == -3) // else if (idx == -3)
// PrintAndLog("Error: thought we had a tag but the parity failed"); // PrintAndLog("Error: thought we had a tag but the parity failed");
else if (idx == -4) else if (idx == -4)
PrintAndLog("Error: AWID preamble not found"); PrintAndLog("DEBUG: Error - AWID preamble not found");
else if (idx == -5)
PrintAndLog("DEBUG: Error - Second AWID preamble not found");
else
PrintAndLog("DEBUG: Error %d",idx);
} }
return 0; return 0;
} }
@ -766,9 +858,11 @@ int CmdFSKdemodAWID(const char *Cmd)
uint32_t rawLo = bytebits_to_byte(BitStream+idx+64,32); uint32_t rawLo = bytebits_to_byte(BitStream+idx+64,32);
uint32_t rawHi = bytebits_to_byte(BitStream+idx+32,32); uint32_t rawHi = bytebits_to_byte(BitStream+idx+32,32);
uint32_t rawHi2 = bytebits_to_byte(BitStream+idx,32); uint32_t rawHi2 = bytebits_to_byte(BitStream+idx,32);
setDemodBuf(BitStream,96,idx);
size = removeParity(BitStream, idx+8, 4, 1, 88); size = removeParity(BitStream, idx+8, 4, 1, 88);
if (size != 66){ if (size != 66){
if (verbose) PrintAndLog("Error: at parity check-tag size does not match AWID format"); if (g_debugMode==1) PrintAndLog("DEBUG: Error - at parity check-tag size does not match AWID format");
return 0; return 0;
} }
// ok valid card found! // ok valid card found!
@ -807,9 +901,11 @@ int CmdFSKdemodAWID(const char *Cmd)
PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x, Raw: %x%08x%08x", fmtLen, cardnum, code1, rawHi2, rawHi, rawLo); PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x, Raw: %x%08x%08x", fmtLen, cardnum, code1, rawHi2, rawHi, rawLo);
} }
} }
if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, Len: %d Printing Demod Buffer:", idx, 96);
printDemodBuff();
}
//todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands
return 1; return 1;
} }
@ -818,10 +914,6 @@ int CmdFSKdemodAWID(const char *Cmd)
//print full Farpointe Data/Pyramid Prox ID and some bit format details if found //print full Farpointe Data/Pyramid Prox ID and some bit format details if found
int CmdFSKdemodPyramid(const char *Cmd) int CmdFSKdemodPyramid(const char *Cmd)
{ {
int verbose=1;
sscanf(Cmd, "%i", &verbose);
//raw fsk demod no manchester decoding no start bit finding just get binary from wave //raw fsk demod no manchester decoding no start bit finding just get binary from wave
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t size = getFromGraphBuf(BitStream); size_t size = getFromGraphBuf(BitStream);
@ -829,23 +921,22 @@ int CmdFSKdemodPyramid(const char *Cmd)
//get binary from fsk wave //get binary from fsk wave
int idx = PyramiddemodFSK(BitStream, size); int idx = PyramiddemodFSK(BitStream, size);
if (idx < 0){ if (idx < 0){
if (verbose){ if (g_debugMode==1){
if (idx == -5) if (idx == -5)
PrintAndLog("Error: not enough samples"); PrintAndLog("DEBUG: Error - not enough samples");
else if (idx == -1) else if (idx == -1)
PrintAndLog("Error: only noise found - no waves"); PrintAndLog("DEBUG: Error - only noise found - no waves");
else if (idx == -2) else if (idx == -2)
PrintAndLog("Error: problem during FSK demod"); PrintAndLog("DEBUG: Error - problem during FSK demod");
//else if (idx == -3) else if (idx == -3)
// PrintAndLog("Error: thought we had a tag but the parity failed"); PrintAndLog("DEBUG: Error - Second Pyramid preamble not found");
else if (idx == -4) else if (idx == -4)
PrintAndLog("Error: AWID preamble not found"); PrintAndLog("DEBUG: Error - Pyramid preamble not found");
else
PrintAndLog("DEBUG: Error - idx: %d",idx);
} }
PrintAndLog("idx: %d",idx);
return 0; return 0;
} }
//PrintAndLog("DEBUG: idx: %d",idx);
// Index map // Index map
// 0 10 20 30 40 50 60 // 0 10 20 30 40 50 60
// | | | | | | | // | | | | | | |
@ -872,9 +963,11 @@ int CmdFSKdemodPyramid(const char *Cmd)
uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32); uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32);
uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32); uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32);
uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32); uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32);
setDemodBuf(BitStream,128,idx);
size = removeParity(BitStream, idx+8, 8, 1, 120); size = removeParity(BitStream, idx+8, 8, 1, 120);
if (size != 105){ if (size != 105){
if (verbose) PrintAndLog("Error: at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3); if (g_debugMode==1) PrintAndLog("DEBUG: Error at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
return 0; return 0;
} }
@ -902,10 +995,9 @@ int CmdFSKdemodPyramid(const char *Cmd)
// (26 bit format shown) // (26 bit format shown)
//find start bit to get fmtLen //find start bit to get fmtLen
idx = 0;
int j; int j;
for (j=0; j<size; j++){ for (j=0; j<size; j++){
if(BitStream[idx+j]) break; if(BitStream[j]) break;
} }
uint8_t fmtLen = size-j-8; uint8_t fmtLen = size-j-8;
uint32_t fc = 0; uint32_t fc = 0;
@ -916,25 +1008,28 @@ int CmdFSKdemodPyramid(const char *Cmd)
fc = bytebits_to_byte(BitStream+73, 8); fc = bytebits_to_byte(BitStream+73, 8);
cardnum = bytebits_to_byte(BitStream+81, 16); cardnum = bytebits_to_byte(BitStream+81, 16);
code1 = bytebits_to_byte(BitStream+72,fmtLen); code1 = bytebits_to_byte(BitStream+72,fmtLen);
PrintAndLog("AWID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, code1, rawHi3, rawHi2, rawHi, rawLo); PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, code1, rawHi3, rawHi2, rawHi, rawLo);
} else if (fmtLen==45){ } else if (fmtLen==45){
fmtLen=42; //end = 10 bits not 7 like 26 bit fmt fmtLen=42; //end = 10 bits not 7 like 26 bit fmt
fc = bytebits_to_byte(BitStream+53, 10); fc = bytebits_to_byte(BitStream+53, 10);
cardnum = bytebits_to_byte(BitStream+63, 32); cardnum = bytebits_to_byte(BitStream+63, 32);
PrintAndLog("AWID Found - BitLength: %d, FC: %d, Card: %d - Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, rawHi3, rawHi2, rawHi, rawLo); PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, rawHi3, rawHi2, rawHi, rawLo);
} else { } else {
cardnum = bytebits_to_byte(BitStream+81, 16); cardnum = bytebits_to_byte(BitStream+81, 16);
if (fmtLen>32){ if (fmtLen>32){
//code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32); //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32);
//code2 = bytebits_to_byte(BitStream+(size-32),32); //code2 = bytebits_to_byte(BitStream+(size-32),32);
PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
} else{ } else{
//code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen); //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen);
PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo); PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
} }
} }
//todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands
if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128);
printDemodBuff();
}
return 1; return 1;
} }
@ -1057,6 +1152,8 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
return 0; return 0;
} }
//by marshmellow
//attempt to detect the field clock and bit clock for FSK
int CmdFSKfcDetect(const char *Cmd) int CmdFSKfcDetect(const char *Cmd)
{ {
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
@ -1078,7 +1175,8 @@ int CmdDetectNRZpskClockRate(const char *Cmd)
return 0; return 0;
} }
int PSKnrzDemod(const char *Cmd){ int PSKnrzDemod(const char *Cmd)
{
int invert=0; int invert=0;
int clk=0; int clk=0;
sscanf(Cmd, "%i %i", &clk, &invert); sscanf(Cmd, "%i %i", &clk, &invert);
@ -1091,13 +1189,13 @@ int PSKnrzDemod(const char *Cmd){
int errCnt=0; int errCnt=0;
errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert); errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert);
if (errCnt<0|| BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) if (errCnt<0|| BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
//PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt); if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
return -1; return -1;
} }
PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen); PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
//prime demod buffer for output //prime demod buffer for output
setDemodBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen,0);
return errCnt; return errCnt;
} }
// Indala 26 bit decode // Indala 26 bit decode
@ -1105,35 +1203,30 @@ int PSKnrzDemod(const char *Cmd){
// optional arguments - same as CmdpskNRZrawDemod (clock & invert) // optional arguments - same as CmdpskNRZrawDemod (clock & invert)
int CmdIndalaDecode(const char *Cmd) int CmdIndalaDecode(const char *Cmd)
{ {
uint8_t verbose = 1;
int ans; int ans;
if (strlen(Cmd)>0){ if (strlen(Cmd)>0){
if (Cmd[0]=='0'){ ans = PSKnrzDemod(Cmd);
verbose=0;
ans = PSKnrzDemod("32");
}else{
ans = PSKnrzDemod(Cmd);
}
} else{ //default to RF/32 } else{ //default to RF/32
ans = PSKnrzDemod("32"); ans = PSKnrzDemod("32");
} }
if (ans < 0){ if (ans < 0){
if (verbose) if (g_debugMode==1)
PrintAndLog("Error1: %d",ans); PrintAndLog("Error1: %d",ans);
return 0; return 0;
} }
uint8_t invert=0; uint8_t invert=0;
ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert); ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert);
if (ans < 1) { if (ans < 1) {
if (verbose) if (g_debugMode==1)
PrintAndLog("Error2: %d",ans); PrintAndLog("Error2: %d",ans);
return -1; return -1;
} }
char showbits[251]; char showbits[251];
if (invert) if (invert)
if (verbose) if (g_debugMode==1)
PrintAndLog("Had to invert bits"); PrintAndLog("Had to invert bits");
//convert UID to HEX //convert UID to HEX
uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7; uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
int idx; int idx;
@ -1197,25 +1290,28 @@ int CmdPskClean(const char *Cmd)
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int CmdpskNRZrawDemod(const char *Cmd) int CmdpskNRZrawDemod(const char *Cmd)
{ {
uint8_t verbose = 1;
int errCnt; int errCnt;
if (strlen(Cmd)>0){
if (Cmd[0]=='0')
verbose=0;
}
errCnt = PSKnrzDemod(Cmd); errCnt = PSKnrzDemod(Cmd);
//output //output
if (errCnt<0) return 0; if (errCnt<0){
if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);
return 0;
}
if (errCnt>0){ if (errCnt>0){
if (verbose) if (g_debugMode){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
} PrintAndLog("PSK or NRZ demoded bitstream:");
PrintAndLog("PSK or NRZ demoded bitstream:"); // Now output the bitstream to the scrollback by line of 16 bits
// Now output the bitstream to the scrollback by line of 16 bits printDemodBuff();
printDemodBuff(); }
}else{
return 1; PrintAndLog("PSK or NRZ demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printDemodBuff();
return 1;
}
return 0;
} }
int CmdGrid(const char *Cmd) int CmdGrid(const char *Cmd)
@ -1367,14 +1463,14 @@ int CmdTuneSamples(const char *Cmd)
int CmdLoad(const char *Cmd) int CmdLoad(const char *Cmd)
{ {
char filename[FILE_PATH_SIZE] = {0x00}; char filename[FILE_PATH_SIZE] = {0x00};
int len = 0; int len = 0;
len = strlen(Cmd); len = strlen(Cmd);
if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
memcpy(filename, Cmd, len); memcpy(filename, Cmd, len);
FILE *f = fopen(filename, "r"); FILE *f = fopen(filename, "r");
if (!f) { if (!f) {
PrintAndLog("couldn't open '%s'", filename); PrintAndLog("couldn't open '%s'", filename);
return 0; return 0;
@ -1403,6 +1499,8 @@ int CmdLtrim(const char *Cmd)
RepaintGraphWindow(); RepaintGraphWindow();
return 0; return 0;
} }
// trim graph to input argument length
int CmdRtrim(const char *Cmd) int CmdRtrim(const char *Cmd)
{ {
int ds = atoi(Cmd); int ds = atoi(Cmd);
@ -1683,12 +1781,12 @@ int CmdPlot(const char *Cmd)
int CmdSave(const char *Cmd) int CmdSave(const char *Cmd)
{ {
char filename[FILE_PATH_SIZE] = {0x00}; char filename[FILE_PATH_SIZE] = {0x00};
int len = 0; int len = 0;
len = strlen(Cmd); len = strlen(Cmd);
if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE; if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
memcpy(filename, Cmd, len); memcpy(filename, Cmd, len);
FILE *f = fopen(filename, "w"); FILE *f = fopen(filename, "w");
@ -1814,6 +1912,7 @@ static command_t CommandTable[] =
{"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK tag using raw"}, {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK tag using raw"},
{"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox tag FSK using raw"}, {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox tag FSK using raw"},
{"fskpyramiddemod",CmdFSKdemodPyramid,1, "Demodulate graph window as a Pyramid FSK tag using raw"}, {"fskpyramiddemod",CmdFSKdemodPyramid,1, "Demodulate graph window as a Pyramid FSK tag using raw"},
{"fskparadoxdemod",CmdFSKdemodParadox,1, "Demodulate graph window as a Paradox FSK tag using raw"},
{"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to bin (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"}, {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to bin (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"},
{"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"}, {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
{"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"}, {"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
@ -1834,6 +1933,8 @@ static command_t CommandTable[] =
{"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"}, {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"},
{"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"}, {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
{"scale", CmdScale, 1, "<int> -- Set cursor display scale"}, {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
{"setdebugmode", CmdSetDebugMode, 1, "<0|1> -- Turn on or off Debugging Mode for demods"},
{"shiftgraphzero",CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
{"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"}, {"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"}, {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},

1
client/cmddata.h
View file

@ -30,6 +30,7 @@ int CmdFSKdemodAWID(const char *Cmd);
int CmdFSKdemod(const char *Cmd); int CmdFSKdemod(const char *Cmd);
int CmdFSKdemodHID(const char *Cmd); int CmdFSKdemodHID(const char *Cmd);
int CmdFSKdemodIO(const char *Cmd); int CmdFSKdemodIO(const char *Cmd);
int CmdFSKdemodParadox(const char *Cmd);
int CmdFSKdemodPyramid(const char *Cmd); int CmdFSKdemodPyramid(const char *Cmd);
int CmdFSKrawdemod(const char *Cmd); int CmdFSKrawdemod(const char *Cmd);
int CmdDetectNRZpskClockRate(const char *Cmd); int CmdDetectNRZpskClockRate(const char *Cmd);

25
client/cmdlf.c
View file

@ -575,36 +575,41 @@ int CmdLFfind(const char *Cmd)
} }
PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag"); PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag");
PrintAndLog("Checking for known tags:"); PrintAndLog("\nChecking for known tags:\n");
ans=CmdFSKdemodIO(""); ans=CmdFSKdemodIO("");
if (ans>0) { if (ans>0) {
PrintAndLog("Valid IO Prox ID Found!"); PrintAndLog("\nValid IO Prox ID Found!");
return 1; return 1;
} }
ans=CmdFSKdemodPyramid("0"); ans=CmdFSKdemodPyramid("");
if (ans>0) { if (ans>0) {
PrintAndLog("Valid Pyramid ID Found!"); PrintAndLog("\nValid Pyramid ID Found!");
return 1; return 1;
} }
ans=CmdFSKdemodAWID("0"); ans=CmdFSKdemodParadox("");
if (ans>0) { if (ans>0) {
PrintAndLog("Valid AWID ID Found!"); PrintAndLog("\nValid Paradox ID Found!");
return 1;
}
ans=CmdFSKdemodAWID("");
if (ans>0) {
PrintAndLog("\nValid AWID ID Found!");
return 1; return 1;
} }
ans=CmdFSKdemodHID(""); ans=CmdFSKdemodHID("");
if (ans>0) { if (ans>0) {
PrintAndLog("Valid HID Prox ID Found!"); PrintAndLog("\nValid HID Prox ID Found!");
return 1; return 1;
} }
//add psk and indala //add psk and indala
ans=CmdIndalaDecode("0"); ans=CmdIndalaDecode("");
if (ans>0) { if (ans>0) {
PrintAndLog("Valid Indala ID Found!"); PrintAndLog("\nValid Indala ID Found!");
return 1; return 1;
} }
ans=Cmdaskmandemod(""); ans=Cmdaskmandemod("");
if (ans>0) { if (ans>0) {
PrintAndLog("Valid EM410x ID Found!"); PrintAndLog("\nValid EM410x ID Found!");
return 1; return 1;
} }
PrintAndLog("No Known Tags Found!\n"); PrintAndLog("No Known Tags Found!\n");

2
client/graph.c
View file

@ -69,6 +69,8 @@ size_t getFromGraphBuf(uint8_t *buff)
} }
return i; return i;
} }
// Get or auto-detect clock rate // Get or auto-detect clock rate
int GetClock(const char *str, int peak, int verbose) int GetClock(const char *str, int peak, int verbose)
{ {

261
common/lfdemod.c
View file

@ -31,7 +31,7 @@ int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi
//by marshmellow //by marshmellow
//takes 1s and 0s and searches for EM410x format - output EM ID //takes 1s and 0s and searches for EM410x format - output EM ID
uint64_t Em410xDecode(uint8_t *BitStream, size_t size) uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx)
{ {
//no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
// otherwise could be a void with no arguments // otherwise could be a void with no arguments
@ -48,17 +48,18 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
uint32_t idx = 0; uint32_t idx = 0;
uint32_t ii=0; uint32_t ii=0;
uint8_t resetCnt = 0; uint8_t resetCnt = 0;
while( (idx + 64) < size) { while( (idx + 64) < *size) {
restart: restart:
// search for a start of frame marker // search for a start of frame marker
if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ // frame marker found { // frame marker found
*startIdx=idx;
idx+=9; idx+=9;
for (i=0; i<10;i++){ for (i=0; i<10;i++){
for(ii=0; ii<5; ++ii){ for(ii=0; ii<5; ++ii){
parityTest ^= BitStream[(i*5)+ii+idx]; parityTest ^= BitStream[(i*5)+ii+idx];
} }
if (!parityTest){ if (!parityTest){ //even parity
parityTest=0; parityTest=0;
for (ii=0; ii<4;++ii){ for (ii=0; ii<4;++ii){
lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]); lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);
@ -74,6 +75,7 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
} }
} }
//skip last 5 bit parity test for simplicity. //skip last 5 bit parity test for simplicity.
*size = 64;
return lo; return lo;
}else{ }else{
idx++; idx++;
@ -89,10 +91,12 @@ uint64_t Em410xDecode(uint8_t *BitStream, size_t size)
int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert) int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
{ {
int i; int i;
int clk2=*clk;
*clk=DetectASKClock(BinStream, *size, *clk); //clock default *clk=DetectASKClock(BinStream, *size, *clk); //clock default
if (*clk<8) *clk =64; // if autodetected too low then adjust //MAY NEED ADJUSTMENT
if (*clk<32) *clk=32; if (clk2==0 && *clk<8) *clk =64;
if (clk2==0 && *clk<32) *clk=32;
if (*invert != 0 && *invert != 1) *invert=0; if (*invert != 0 && *invert != 1) *invert=0;
uint32_t initLoopMax = 200; uint32_t initLoopMax = 200;
if (initLoopMax > *size) initLoopMax=*size; if (initLoopMax > *size) initLoopMax=*size;
@ -106,7 +110,7 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
int lastBit = 0; //set first clock check int lastBit = 0; //set first clock check
uint32_t bitnum = 0; //output counter uint32_t bitnum = 0; //output counter
int tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave int tol = 0; //clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
if (*clk==32)tol=1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely if (*clk<=32)tol=1; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely
int iii = 0; int iii = 0;
uint32_t gLen = *size; uint32_t gLen = *size;
if (gLen > 3000) gLen=3000; if (gLen > 3000) gLen=3000;
@ -198,6 +202,22 @@ int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
return bestErrCnt; return bestErrCnt;
} }
//by marshmellow
//encode binary data into binary manchester
int ManchesterEncode(uint8_t *BitStream, size_t size)
{
size_t modIdx=20000, i=0;
if (size>modIdx) return -1;
for (size_t idx=0; idx < size; idx++){
BitStream[idx+modIdx++] = BitStream[idx];
BitStream[idx+modIdx++] = BitStream[idx]^1;
}
for (; i<(size*2); i++){
BitStream[i] = BitStream[i+20000];
}
return i;
}
//by marshmellow //by marshmellow
//take 10 and 01 and manchester decode //take 10 and 01 and manchester decode
//run through 2 times and take least errCnt //run through 2 times and take least errCnt
@ -245,7 +265,6 @@ int manrawdecode(uint8_t * BitStream, size_t *size)
return errCnt; return errCnt;
} }
//by marshmellow //by marshmellow
//take 01 or 10 = 0 and 11 or 00 = 1 //take 01 or 10 = 0 and 11 or 00 = 1
int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert) int BiphaseRawDecode(uint8_t *BitStream, size_t *size, int offset, int invert)
@ -282,8 +301,8 @@ int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert)
//uint8_t BitStream[502] = {0}; //uint8_t BitStream[502] = {0};
//HACK: if clock not detected correctly - default //HACK: if clock not detected correctly - default
if (*clk<8) *clk =64; if (clk2==0 && *clk<8) *clk =64;
if (*clk<32 && clk2==0) *clk=32; if (clk2==0 && *clk<32 && clk2==0) *clk=32;
if (*invert != 0 && *invert != 1) *invert =0; if (*invert != 0 && *invert != 1) *invert =0;
uint32_t initLoopMax = 200; uint32_t initLoopMax = 200;
if (initLoopMax > *size) initLoopMax=*size; if (initLoopMax > *size) initLoopMax=*size;
@ -534,12 +553,13 @@ int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t
return size; return size;
} }
// loop to get raw HID waveform then FSK demodulate the TAG ID from it // loop to get raw HID waveform then FSK demodulate the TAG ID from it
int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo) int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
{ {
size_t idx=0; //, found=0; //size=0, size_t idx=0, size2=*size, startIdx=0;
// FSK demodulator // FSK demodulator
size = fskdemod(dest, size,50,0,10,8);
*size = fskdemod(dest, size2,50,0,10,8);
// final loop, go over previously decoded manchester data and decode into usable tag ID // final loop, go over previously decoded manchester data and decode into usable tag ID
// 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0 // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
@ -547,12 +567,13 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
int numshifts = 0; int numshifts = 0;
idx = 0; idx = 0;
//one scan //one scan
while( idx + sizeof(frame_marker_mask) < size) { while( idx + sizeof(frame_marker_mask) < *size) {
// search for a start of frame marker // search for a start of frame marker
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ // frame marker found { // frame marker found
startIdx=idx;
idx+=sizeof(frame_marker_mask); idx+=sizeof(frame_marker_mask);
while(dest[idx] != dest[idx+1] && idx < size-2) while(dest[idx] != dest[idx+1] && idx < *size-2)
{ {
// Keep going until next frame marker (or error) // Keep going until next frame marker (or error)
// Shift in a bit. Start by shifting high registers // Shift in a bit. Start by shifting high registers
@ -567,12 +588,13 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
idx += 2; idx += 2;
} }
// Hopefully, we read a tag and hit upon the next frame marker // Hopefully, we read a tag and hit upon the next frame marker
if(idx + sizeof(frame_marker_mask) < size) if(idx + sizeof(frame_marker_mask) < *size)
{ {
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ {
//good return //good return
return idx; *size=idx-startIdx;
return startIdx;
} }
} }
// reset // reset
@ -585,6 +607,61 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
return -1; return -1;
} }
// loop to get raw paradox waveform then FSK demodulate the TAG ID from it
size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo)
{
size_t idx=0, size2=*size;
// FSK demodulator
*size = fskdemod(dest, size2,50,1,10,8);
// final loop, go over previously decoded manchester data and decode into usable tag ID
// 00001111 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
uint8_t frame_marker_mask[] = {0,0,0,0,1,1,1,1};
uint16_t numshifts = 0;
idx = 0;
//one scan
while( idx + sizeof(frame_marker_mask) < *size) {
// search for a start of frame marker
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ // frame marker found
size2=idx;
idx+=sizeof(frame_marker_mask);
while(dest[idx] != dest[idx+1] && idx < *size-2)
{
// Keep going until next frame marker (or error)
// Shift in a bit. Start by shifting high registers
*hi2 = (*hi2<<1)|(*hi>>31);
*hi = (*hi<<1)|(*lo>>31);
//Then, shift in a 0 or one into low
if (dest[idx] && !dest[idx+1]) // 1 0
*lo=(*lo<<1)|1;
else // 0 1
*lo=(*lo<<1)|0;
numshifts++;
idx += 2;
}
// Hopefully, we read a tag and hit upon the next frame marker and got enough bits
if(idx + sizeof(frame_marker_mask) < *size && numshifts > 40)
{
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{
//good return - return start grid position and bits found
*size = ((numshifts*2)+8);
return size2;
}
}
// reset
*hi2 = *hi = *lo = 0;
numshifts = 0;
}else {
idx++;
}
}
return 0;
}
uint32_t bytebits_to_byte(uint8_t* src, size_t numbits) uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
{ {
uint32_t num = 0; uint32_t num = 0;
@ -638,10 +715,10 @@ int IOdemodFSK(uint8_t *dest, size_t size)
// by marshmellow // by marshmellow
// pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType // pass bits to be tested in bits, length bits passed in bitLen, and parity type (even=0 | odd=1) in pType
// returns 1 if passed // returns 1 if passed
int parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType) uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
{ {
uint8_t ans = 0; uint8_t ans = 0;
for (int i = 0; i < bitLen; i++){ for (uint8_t i = 0; i < bitLen; i++){
ans ^= ((bits >> i) & 1); ans ^= ((bits >> i) & 1);
} }
//PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType); //PrintAndLog("DEBUG: ans: %d, ptype: %d",ans,pType);
@ -676,7 +753,7 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
int AWIDdemodFSK(uint8_t *dest, size_t size) int AWIDdemodFSK(uint8_t *dest, size_t size)
{ {
static const uint8_t THRESHOLD = 123; static const uint8_t THRESHOLD = 123;
uint32_t idx=0; uint32_t idx=0, idx2=0;
//make sure buffer has data //make sure buffer has data
if (size < 96*50) return -1; if (size < 96*50) return -1;
//test samples are not just noise //test samples are not just noise
@ -694,9 +771,12 @@ int AWIDdemodFSK(uint8_t *dest, size_t size)
for( idx=0; idx < (size - 96); idx++) { for( idx=0; idx < (size - 96); idx++) {
if ( memcmp(dest + idx, mask, sizeof(mask))==0) { if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
// frame marker found // frame marker found
//return ID start index and size //return ID start index
return idx; if (idx2 == 0) idx2=idx;
//size should always be 96 else if(idx-idx2==96) return idx2;
else return -5;
// should always get 96 bits if it is awid
} }
} }
//never found mask //never found mask
@ -708,8 +788,8 @@ int AWIDdemodFSK(uint8_t *dest, size_t size)
int PyramiddemodFSK(uint8_t *dest, size_t size) int PyramiddemodFSK(uint8_t *dest, size_t size)
{ {
static const uint8_t THRESHOLD = 123; static const uint8_t THRESHOLD = 123;
uint32_t idx=0; uint32_t idx=0, idx2=0;
// size_t size2 = size; // size_t size2 = size;
//make sure buffer has data //make sure buffer has data
if (size < 128*50) return -5; if (size < 128*50) return -5;
//test samples are not just noise //test samples are not just noise
@ -727,78 +807,85 @@ int PyramiddemodFSK(uint8_t *dest, size_t size)
for( idx=0; idx < (size - 128); idx++) { for( idx=0; idx < (size - 128); idx++) {
if ( memcmp(dest + idx, mask, sizeof(mask))==0) { if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
// frame marker found // frame marker found
return idx; if (idx2==0) idx2=idx;
else if (idx-idx2==128) return idx2;
else return -3;
} }
} }
//never found mask //never found mask
return -4; return -4;
} }
// by marshmellow // by marshmellow
// not perfect especially with lower clocks or VERY good antennas (heavy wave clipping) // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
// maybe somehow adjust peak trimming value based on samples to fix? // maybe somehow adjust peak trimming value based on samples to fix?
int DetectASKClock(uint8_t dest[], size_t size, int clock) int DetectASKClock(uint8_t dest[], size_t size, int clock)
{ {
int i=0; int i=0;
int clk[]={8,16,32,40,50,64,100,128,256}; int clk[]={8,16,32,40,50,64,100,128,256};
int loopCnt = 256; //don't need to loop through entire array... int loopCnt = 256; //don't need to loop through entire array...
if (size<loopCnt) loopCnt = size; if (size<loopCnt) loopCnt = size;
//if we already have a valid clock quit //if we already have a valid clock quit
for (;i<8;++i) for (;i<8;++i)
if (clk[i] == clock) return clock; if (clk[i] == clock) return clock;
//get high and low peak //get high and low peak
int peak, low; int peak, low;
getHiLo(dest, loopCnt, &peak, &low, 75, 75); getHiLo(dest, loopCnt, &peak, &low, 75, 75);
int ii; int ii;
int clkCnt; int clkCnt;
int tol = 0; int tol = 0;
int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000}; int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
int errCnt=0; int errCnt=0;
//test each valid clock from smallest to greatest to see which lines up //test each valid clock from smallest to greatest to see which lines up
for(clkCnt=0; clkCnt < 6; ++clkCnt){ for(clkCnt=0; clkCnt < 8; ++clkCnt){
if (clk[clkCnt] == 32){ if (clk[clkCnt] == 32){
tol=1; tol=1;
}else{ }else{
tol=0; tol=0;
} }
bestErr[clkCnt]=1000; bestErr[clkCnt]=1000;
//try lining up the peaks by moving starting point (try first 256) //try lining up the peaks by moving starting point (try first 256)
for (ii=0; ii< loopCnt; ++ii){ for (ii=0; ii < loopCnt; ++ii){
if ((dest[ii] >= peak) || (dest[ii] <= low)){ if ((dest[ii] >= peak) || (dest[ii] <= low)){
errCnt=0; errCnt=0;
// now that we have the first one lined up test rest of wave array // now that we have the first one lined up test rest of wave array
for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){ for (i=0; i<((int)((size-ii-tol)/clk[clkCnt])-1); ++i){
if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){ if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
}else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){ }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
}else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){ }else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){
}else{ //error no peak detected }else{ //error no peak detected
errCnt++; errCnt++;
} }
} }
//if we found no errors this is correct one - return this clock //if we found no errors then we can stop here
if(errCnt==0) return clk[clkCnt]; // this is correct one - return this clock
//if we found errors see if it is lowest so far and save it as best run //PrintAndLog("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i);
if(errCnt<bestErr[clkCnt]) bestErr[clkCnt]=errCnt; if(errCnt==0 && clkCnt<6) return clk[clkCnt];
} //if we found errors see if it is lowest so far and save it as best run
} if(errCnt<bestErr[clkCnt]) bestErr[clkCnt]=errCnt;
} }
int iii=0; }
int best=0; }
for (iii=0; iii<8;++iii){ uint8_t iii=0;
if (bestErr[iii]<bestErr[best]){ uint8_t best=0;
// current best bit to error ratio vs new bit to error ratio for (iii=0; iii<8; ++iii){
if (((size/clk[best])/bestErr[best] < (size/clk[iii])/bestErr[iii]) ){ if (bestErr[iii]<bestErr[best]){
best = iii; if (bestErr[iii]==0) bestErr[iii]=1;
} // current best bit to error ratio vs new bit to error ratio
} if (((size/clk[best])/bestErr[best] < (size/clk[iii])/bestErr[iii]) ){
} best = iii;
return clk[best]; }
}
}
return clk[best];
} }
//by marshmellow //by marshmellow
//detect psk clock by reading #peaks vs no peaks(or errors) //detect psk clock by reading #peaks vs no peaks(or errors)
int DetectpskNRZClock(uint8_t dest[], size_t size, int clock) int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
@ -809,7 +896,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
if (size<loopCnt) loopCnt = size; if (size<loopCnt) loopCnt = size;
//if we already have a valid clock quit //if we already have a valid clock quit
for (; i < 8; ++i) for (; i < 7; ++i)
if (clk[i] == clock) return clock; if (clk[i] == clock) return clock;
//get high and low peak //get high and low peak
@ -822,11 +909,11 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
uint8_t tol = 0; uint8_t tol = 0;
int peakcnt=0; int peakcnt=0;
int errCnt=0; int errCnt=0;
int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000}; int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000};
int peaksdet[]={0,0,0,0,0,0,0,0,0}; int peaksdet[]={0,0,0,0,0,0,0,0};
//test each valid clock from smallest to greatest to see which lines up //test each valid clock from smallest to greatest to see which lines up
for(clkCnt=0; clkCnt < 6; ++clkCnt){ for(clkCnt=0; clkCnt < 7; ++clkCnt){
if (clk[clkCnt] >= 32){ if (clk[clkCnt] <= 32){
tol=1; tol=1;
}else{ }else{
tol=0; tol=0;
@ -837,7 +924,7 @@ int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
errCnt=0; errCnt=0;
peakcnt=0; peakcnt=0;
// now that we have the first one lined up test rest of wave array // now that we have the first one lined up test rest of wave array
for (i=0; i < ((int)(size/clk[clkCnt])-1); ++i){ for (i=0; i < ((int)((size-ii-tol)/clk[clkCnt])-1); ++i){
if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){ if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
peakcnt++; peakcnt++;
}else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){ }else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){

6
common/lfdemod.h
View file

@ -17,11 +17,12 @@
int DetectASKClock(uint8_t dest[], size_t size, int clock); int DetectASKClock(uint8_t dest[], size_t size, int clock);
int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert); int askmandemod(uint8_t *BinStream, size_t *size, int *clk, int *invert);
uint64_t Em410xDecode(uint8_t *BitStream,size_t size); uint64_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx);
int ManchesterEncode(uint8_t *BitStream, size_t size);
int manrawdecode(uint8_t *BitStream, size_t *size); int manrawdecode(uint8_t *BitStream, size_t *size);
int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert); int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert); int askrawdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert);
int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_t *lo); int HIDdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
int IOdemodFSK(uint8_t *dest, size_t size); int IOdemodFSK(uint8_t *dest, size_t size);
int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow); int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow);
uint32_t bytebits_to_byte(uint8_t* src, size_t numbits); uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);
@ -34,5 +35,6 @@ int AWIDdemodFSK(uint8_t *dest, size_t size);
size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen); size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen);
uint32_t countFC(uint8_t *BitStream, size_t size); uint32_t countFC(uint8_t *BitStream, size_t size);
int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo); int getHiLo(uint8_t *BitStream, size_t size, int *high, int *low, uint8_t fuzzHi, uint8_t fuzzLo);
size_t ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, uint32_t *lo);
#endif #endif