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

added data psk* cmds for pskdemod

Browse source 
fixed a couple small bugs in other lf functions as well including
detectaskclock,  stopped changes from being made to graphbuffer.
This commit is contained in:
marshmellow42 2015-01-06 09:20:36 -05:00
parent 4df54240c1
commit 4118b74dc8
11 changed files with 18827 additions and 2078 deletions
Download patch file Download diff file Expand all files Collapse all files

18
armsrc/lfops.c
View file

@ -179,6 +179,8 @@ void ReadTItag(void)
signed char *dest = (signed char *)BigBuf; signed char *dest = (signed char *)BigBuf;
int n = sizeof(BigBuf); int n = sizeof(BigBuf);
// int *dest = GraphBuffer;
// int n = GraphTraceLen;
// 128 bit shift register [shift3:shift2:shift1:shift0] // 128 bit shift register [shift3:shift2:shift1:shift0]
uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0; uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
@ -623,7 +625,6 @@ void CmdHIDsimTAG(int hi, int lo, int ledcontrol)
if (ledcontrol) if (ledcontrol)
LED_A_ON(); LED_A_ON();
SimulateTagLowFrequency(n, 0, ledcontrol); SimulateTagLowFrequency(n, 0, ledcontrol);
if (ledcontrol) if (ledcontrol)
@ -717,6 +718,7 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
hi2 = hi = lo = 0; hi2 = hi = lo = 0;
} }
WDT_HIT(); WDT_HIT();
//SpinDelay(50);
} }
DbpString("Stopped"); DbpString("Stopped");
if (ledcontrol) LED_A_OFF(); if (ledcontrol) LED_A_OFF();
@ -727,7 +729,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; //, found=0; size_t size=0; //, found=0;
uint32_t bitLen=0; int bitLen=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
@ -778,6 +780,7 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol) void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0;
int idx=0; int idx=0;
uint32_t code=0, code2=0; uint32_t code=0, code2=0;
uint8_t version=0; uint8_t version=0;
@ -790,9 +793,12 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
WDT_HIT(); WDT_HIT();
if (ledcontrol) LED_A_ON(); if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1,true); DoAcquisition125k_internal(-1,true);
size = sizeof(BigBuf);
//make sure buffer has data
if (size < 2000) continue;
//fskdemod and get start index //fskdemod and get start index
WDT_HIT(); WDT_HIT();
idx = IOdemodFSK(dest,sizeof(BigBuf)); idx = IOdemodFSK(dest,size);
if (idx>0){ if (idx>0){
//valid tag found //valid tag found
@ -1335,6 +1341,7 @@ void WriteEM410x(uint32_t card, uint32_t id_hi, uint32_t id_lo)
// Clone Indala 64-bit tag by UID to T55x7 // Clone Indala 64-bit tag by UID to T55x7
void CopyIndala64toT55x7(int hi, int lo) void CopyIndala64toT55x7(int hi, int lo)
{ {
//Program the 2 data blocks for supplied 64bit UID //Program the 2 data blocks for supplied 64bit UID
// and the block 0 for Indala64 format // and the block 0 for Indala64 format
T55xxWriteBlock(hi,1,0,0); T55xxWriteBlock(hi,1,0,0);
@ -1348,10 +1355,12 @@ void CopyIndala64toT55x7(int hi, int lo)
// T5567WriteBlock(0x603E1042,0); // T5567WriteBlock(0x603E1042,0);
DbpString("DONE!"); DbpString("DONE!");
} }
void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int uid6, int uid7) void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int uid6, int uid7)
{ {
//Program the 7 data blocks for supplied 224bit UID //Program the 7 data blocks for supplied 224bit UID
// and the block 0 for Indala224 format // and the block 0 for Indala224 format
T55xxWriteBlock(uid1,1,0,0); T55xxWriteBlock(uid1,1,0,0);
@ -1370,6 +1379,7 @@ void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int
// T5567WriteBlock(0x603E10E2,0); // T5567WriteBlock(0x603E10E2,0);
DbpString("DONE!"); DbpString("DONE!");
} }
@ -1519,6 +1529,7 @@ int IsBlock1PCF7931(uint8_t *Block) {
return 0; return 0;
} }
#define ALLOC 16 #define ALLOC 16
void ReadPCF7931() { void ReadPCF7931() {
@ -1778,7 +1789,6 @@ void SendForward(uint8_t fwd_bit_count) {
} }
} }
void EM4xLogin(uint32_t Password) { void EM4xLogin(uint32_t Password) {
uint8_t fwd_bit_count; uint8_t fwd_bit_count;

329
client/cmddata.c
View file

@ -21,9 +21,55 @@
#include "cmdmain.h" #include "cmdmain.h"
#include "cmddata.h" #include "cmddata.h"
#include "lfdemod.h" #include "lfdemod.h"
uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
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)
//by marshmellow
void setDemodBuf(uint8_t *buff,int size)
{
int i=0;
for (; i < size; ++i){
DemodBuffer[i]=buff[i];
}
DemodBufferLen=size;
return;
}
//by marshmellow
void printDemodBuff()
{
uint32_t i = 0;
int bitLen = DemodBufferLen;
if (bitLen<16) {
PrintAndLog("no bits found in demod buffer");
return;
}
if (bitLen>512) bitLen=512; //max output to 512 bits if we have more - should be plenty
for (i = 0; i <= (bitLen-16); i+=16) {
PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
DemodBuffer[i],
DemodBuffer[i+1],
DemodBuffer[i+2],
DemodBuffer[i+3],
DemodBuffer[i+4],
DemodBuffer[i+5],
DemodBuffer[i+6],
DemodBuffer[i+7],
DemodBuffer[i+8],
DemodBuffer[i+9],
DemodBuffer[i+10],
DemodBuffer[i+11],
DemodBuffer[i+12],
DemodBuffer[i+13],
DemodBuffer[i+14],
DemodBuffer[i+15]);
}
return;
}
int CmdAmp(const char *Cmd) int CmdAmp(const char *Cmd)
{ {
int i, rising, falling; int i, rising, falling;
@ -185,10 +231,10 @@ 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}; // uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t i=0; // uint32_t i=0;
i=getFromGraphBuf(BitStream); // i=getFromGraphBuf(BitStream);
id = Em410xDecode(BitStream,i); id = Em410xDecode(DemodBuffer,DemodBufferLen);
printEM410x(id); printEM410x(id);
if (id>0) return 1; if (id>0) return 1;
return 0; return 0;
@ -209,15 +255,15 @@ int Cmdaskmandemod(const char *Cmd)
PrintAndLog("Invalid argument: %s", Cmd); PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
uint32_t BitLen = getFromGraphBuf(BitStream);
int BitLen = getFromGraphBuf(BitStream);
// PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen); // 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){ //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); // PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0; return 0;
} }
if (BitLen<16) 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);
//output //output
@ -226,12 +272,12 @@ 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
printBitStream(BitStream,BitLen); setDemodBuf(BitStream,BitLen);
printDemodBuff();
uint64_t lo =0; uint64_t lo =0;
lo = Em410xDecode(BitStream,BitLen); lo = Em410xDecode(BitStream,BitLen);
if (lo>0){ if (lo>0){
//set GraphBuffer for clone or sim command //set GraphBuffer for clone or sim command
setGraphBuf(BitStream,BitLen);
PrintAndLog("EM410x pattern found: "); PrintAndLog("EM410x pattern found: ");
printEM410x(lo); printEM410x(lo);
return 1; return 1;
@ -250,10 +296,10 @@ int Cmdmandecoderaw(const char *Cmd)
int bitnum=0; int bitnum=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
int high=0,low=0; int high=0,low=0;
for (;i<GraphTraceLen;++i){ for (;i<DemodBufferLen;++i){
if (GraphBuffer[i]>high) high=GraphBuffer[i]; if (DemodBuffer[i]>high) high=DemodBuffer[i];
else if(GraphBuffer[i]<low) low=GraphBuffer[i]; else if(DemodBuffer[i]<low) low=DemodBuffer[i];
BitStream[i]=GraphBuffer[i]; BitStream[i]=DemodBuffer[i];
} }
if (high>1 || low <0 ){ if (high>1 || low <0 ){
PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode"); PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
@ -268,15 +314,9 @@ int Cmdmandecoderaw(const char *Cmd)
PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt); PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
printBitStream(BitStream,bitnum); printBitStream(BitStream,bitnum);
if (errCnt==0){ if (errCnt==0){
//put back in graphbuffer
ClearGraph(0);
for (i=0; i<bitnum;++i){
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=bitnum;
RepaintGraphWindow();
uint64_t id = 0; uint64_t id = 0;
id = Em410xDecode(BitStream,i); id = Em410xDecode(BitStream,bitnum);
if (id>0) setDemodBuf(BitStream,bitnum);
printEM410x(id); printEM410x(id);
} }
return 1; return 1;
@ -301,10 +341,10 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
sscanf(Cmd, "%i", &offset); sscanf(Cmd, "%i", &offset);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
//get graphbuffer & high and low //get graphbuffer & high and low
for (;i<GraphTraceLen;++i){ for (;i<DemodBufferLen;++i){
if(GraphBuffer[i]>high)high=GraphBuffer[i]; if(DemodBuffer[i]>high)high=DemodBuffer[i];
else if(GraphBuffer[i]<low)low=GraphBuffer[i]; else if(DemodBuffer[i]<low)low=DemodBuffer[i];
BitStream[i]=GraphBuffer[i]; BitStream[i]=DemodBuffer[i];
} }
if (high>1 || low <0){ if (high>1 || low <0){
PrintAndLog("Error: please raw demod the wave first then decode"); PrintAndLog("Error: please raw demod the wave first then decode");
@ -329,7 +369,6 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int Cmdaskrawdemod(const char *Cmd) int Cmdaskrawdemod(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};
@ -341,22 +380,20 @@ int Cmdaskrawdemod(const char *Cmd)
int BitLen = getFromGraphBuf(BitStream); int BitLen = getFromGraphBuf(BitStream);
int errCnt=0; int errCnt=0;
errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert); errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
if (errCnt==-1){ //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");
return 0; return 0;
} }
if (BitLen<16) 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); //PrintAndLog("Data start pos:%d, lastBit:%d, stop pos:%d, numBits:%d",iii,lastBit,i,bitnum);
//move BitStream back to GraphBuffer //move BitStream back to DemodBuffer
setGraphBuf(BitStream, BitLen); setDemodBuf(BitStream,BitLen);
//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);
} }
PrintAndLog("ASK demoded bitstream:"); PrintAndLog("ASK 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
printBitStream(BitStream,BitLen); printBitStream(BitStream,BitLen);
@ -472,6 +509,10 @@ int CmdBitstream(const char *Cmd)
bit ^= 1; bit ^= 1;
AppendGraph(0, clock, bit); AppendGraph(0, clock, bit);
// for (j = 0; j < (int)(clock/2); j++)
// GraphBuffer[(i * clock) + j] = bit ^ 1;
// for (j = (int)(clock/2); j < clock; j++)
// GraphBuffer[(i * clock) + j] = bit;
} }
RepaintGraphWindow(); RepaintGraphWindow();
@ -501,6 +542,8 @@ int CmdDec(const char *Cmd)
int CmdDetectClockRate(const char *Cmd) int CmdDetectClockRate(const char *Cmd)
{ {
GetClock("",0,0); GetClock("",0,0);
//int clock = DetectASKClock(0);
//PrintAndLog("Auto-detected clock rate: %d", clock);
return 0; return 0;
} }
@ -527,18 +570,12 @@ int CmdFSKrawdemod(const char *Cmd)
} else if(rfLen==0) rfLen=50; } else if(rfLen==0) rfLen=50;
} }
PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow); PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow);
uint32_t i=0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t BitLen = getFromGraphBuf(BitStream); uint32_t BitLen = getFromGraphBuf(BitStream);
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:");
ClearGraph(0); setDemodBuf(BitStream,size);
for (i=0;i<size;++i){
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=size;
RepaintGraphWindow();
// 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
@ -567,9 +604,9 @@ int CmdFSKdemodHID(const char *Cmd)
} }
if (hi2==0 && hi==0 && lo==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("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);
setGraphBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen);
return 1; return 1;
} }
else { //standard HID tags <38 bits else { //standard HID tags <38 bits
@ -614,10 +651,10 @@ int CmdFSKdemodHID(const char *Cmd)
fc = ((hi&0xF)<<12)|(lo>>20); fc = ((hi&0xF)<<12)|(lo>>20);
} }
} }
PrintAndLog("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);
setGraphBuf(BitStream,BitLen); setDemodBuf(BitStream,BitLen);
return 1; return 1;
} }
return 0; return 0;
@ -671,9 +708,12 @@ int CmdFSKdemodIO(const char *Cmd)
uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4 uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
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);
int i;
for (i=0;i<64;++i)
DemodBuffer[i]=BitStream[idx++];
PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2); DemodBufferLen=64;
setGraphBuf(BitStream,BitLen);
return 1; return 1;
} }
int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
@ -762,7 +802,8 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
PrintAndLog("actual data bits start at sample %d", maxPos); PrintAndLog("actual data bits start at sample %d", maxPos);
PrintAndLog("length %d/%d", highLen, lowLen); PrintAndLog("length %d/%d", highLen, lowLen);
uint8_t bits[46] = {0x00}; uint8_t bits[46];
bits[sizeof(bits)-1] = '\0';
// find bit pairs and manchester decode them // find bit pairs and manchester decode them
for (i = 0; i < arraylen(bits) - 1; ++i) { for (i = 0; i < arraylen(bits) - 1; ++i) {
@ -794,6 +835,160 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
return 0; return 0;
} }
int CmdDetectNRZpskClockRate(const char *Cmd)
{
GetNRZpskClock("",0,0);
return 0;
}
int PSKnrzDemod(const char *Cmd){
int invert=0;
int clk=0;
sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd);
return -1;
}
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
int BitLen = getFromGraphBuf(BitStream);
int errCnt=0;
errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert);
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);
return -1;
}
PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
//prime demod buffer for output
setDemodBuf(BitStream,BitLen);
return errCnt;
}
// Indala 26 bit decode
// by marshmellow
// optional arguments - same as CmdpskNRZrawDemod (clock & invert)
int CmdIndalaDecode(const char *Cmd)
{
int ans=PSKnrzDemod(Cmd);
if (ans < 0){
PrintAndLog("Error1: %d",ans);
return 0;
}
uint8_t invert=0;
ans = indala26decode(DemodBuffer, &DemodBufferLen, &invert);
if (ans < 1) {
PrintAndLog("Error2: %d",ans);
return -1;
}
char showbits[251];
if(invert==1) PrintAndLog("Had to invert bits");
//convert UID to HEX
uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
int idx;
uid1=0;
uid2=0;
PrintAndLog("BitLen: %d",DemodBufferLen);
if (DemodBufferLen==64){
for( idx=0; idx<64; idx++) {
uid1=(uid1<<1)|(uid2>>31);
if (DemodBuffer[idx] == 0) {
uid2=(uid2<<1)|0;
showbits[idx]='0';
} else {
uid2=(uid2<<1)|1;
showbits[idx]='1';
}
}
showbits[idx]='\0';
PrintAndLog("Indala UID=%s (%x%08x)", showbits, uid1, uid2);
}
else {
uid3=0;
uid4=0;
uid5=0;
uid6=0;
uid7=0;
for( idx=0; idx<DemodBufferLen; idx++) {
uid1=(uid1<<1)|(uid2>>31);
uid2=(uid2<<1)|(uid3>>31);
uid3=(uid3<<1)|(uid4>>31);
uid4=(uid4<<1)|(uid5>>31);
uid5=(uid5<<1)|(uid6>>31);
uid6=(uid6<<1)|(uid7>>31);
if (DemodBuffer[idx] == 0) {
uid7=(uid7<<1)|0;
showbits[idx]='0';
}
else {
uid7=(uid7<<1)|1;
showbits[idx]='1';
}
}
showbits[idx]='\0';
PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
}
return 1;
}
/*
//by marshmellow (attempt to get rid of high immediately after a low)
void pskCleanWave2(uint8_t *bitStream, int bitLen)
{
int i;
int low=128;
int gap = 4;
// int loopMax = 2048;
int newLow=0;
for (i=0; i<bitLen; ++i)
if (bitStream[i]<low) low=bitStream[i];
low = (int)(((low-128)*.80)+128);
PrintAndLog("low: %d",low);
for (i=0; i<bitLen; ++i){
if (newLow==1){
bitStream[i]=low+5;
gap--;
if (gap==0){
newLow=0;
gap=4;
}
}
if (bitStream[i]<=low) newLow=1;
}
return;
}
*/
int CmdPskClean(const char *Cmd)
{
uint8_t bitStream[MAX_GRAPH_TRACE_LEN]={0};
int bitLen = getFromGraphBuf(bitStream);
pskCleanWave(bitStream, bitLen);
setGraphBuf(bitStream, bitLen);
return 0;
}
//by marshmellow
//takes 2 arguments - clock and invert both as integers
//attempts to demodulate ask only
//prints binary found and saves in graphbuffer for further commands
int CmdpskNRZrawDemod(const char *Cmd)
{
int errCnt= PSKnrzDemod(Cmd);
//output
if (errCnt<0) return 0;
if (errCnt>0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
}
PrintAndLog("PSK or NRZ demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printDemodBuff();
return 1;
}
int CmdGrid(const char *Cmd) int CmdGrid(const char *Cmd)
{ {
sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY); sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
@ -869,21 +1064,22 @@ int CmdHpf(const char *Cmd)
int CmdSamples(const char *Cmd) int CmdSamples(const char *Cmd)
{ {
uint8_t got[40000] = {0x00}; int cnt = 0;
int n;
uint8_t got[40000];
int n = strtol(Cmd, NULL, 0); n = strtol(Cmd, NULL, 0);
if (n == 0) if (n == 0) n = 6000;
n = 20000; if (n > sizeof(got)) n = sizeof(got);
if (n > sizeof(got)) PrintAndLog("Reading %d samples\n", n);
n = sizeof(got);
PrintAndLog("Reading %d samples from device memory\n", n);
GetFromBigBuf(got,n,0); GetFromBigBuf(got,n,0);
WaitForResponse(CMD_ACK,NULL); WaitForResponse(CMD_ACK,NULL);
for (int j = 0; j < n; ++j) { for (int j = 0; j < n; j++) {
GraphBuffer[j] = ((int)got[j]) - 128; GraphBuffer[cnt++] = ((int)got[j]) - 128;
} }
PrintAndLog("Done!\n");
GraphTraceLen = n; GraphTraceLen = n;
RepaintGraphWindow(); RepaintGraphWindow();
return 0; return 0;
@ -1203,8 +1399,9 @@ int CmdNorm(const char *Cmd)
if (max != min) { if (max != min) {
for (i = 0; i < GraphTraceLen; ++i) { for (i = 0; i < GraphTraceLen; ++i) {
GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 1000 / GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 256 /
(max - min); (max - min);
//marshmelow: adjusted *1000 to *256 to make +/- 128 so demod commands still work
} }
} }
RepaintGraphWindow(); RepaintGraphWindow();
@ -1327,15 +1524,15 @@ static command_t CommandTable[] =
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"amp", CmdAmp, 1, "Amplify peaks"}, {"amp", CmdAmp, 1, "Amplify peaks"},
{"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"}, {"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
{"askmandemod", Cmdaskmandemod, 1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary"}, {"askmandemod", Cmdaskmandemod, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional[clock will try Auto-detect])"},
{"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK tags and output binary"}, {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"},
{"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"}, {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},
{"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"}, {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] Biphase decode binary stream already in graph buffer (offset = bit to start decode from)"},
{"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"}, {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
{"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"}, {"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},
{"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"}, {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},
{"dec", CmdDec, 1, "Decimate samples"}, {"dec", CmdDec, 1, "Decimate samples"},
{"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"}, {"detectclock", CmdDetectClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},
{"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"}, {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
{"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK using raw"}, {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK using raw"},
{"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox FSK using raw"}, {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox FSK using raw"},
@ -1350,15 +1547,19 @@ static command_t CommandTable[] =
{"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"}, {"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
{"manrawdecode", Cmdmandecoderaw, 1, "Manchester decode binary stream already in graph buffer"}, {"manrawdecode", Cmdmandecoderaw, 1, "Manchester decode binary stream already in graph buffer"},
{"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"}, {"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"},
{"norm", CmdNorm, 1, "Normalize max/min to +/-500"}, {"norm", CmdNorm, 1, "Normalize max/min to +/-128"},
{"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"}, {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"},
{"pskclean", CmdPskClean, 1, "Attempt to clean psk wave"},
{"pskdetectclock",CmdDetectNRZpskClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},
{"pskindalademod",CmdIndalaDecode, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate psk indala tags and output ID binary & hex (args optional[clock will try Auto-detect])"},
{"psknrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0 or 1>] -- Attempt to demodulate psk or nrz tags and output binary (args optional[clock will try Auto-detect])"},
{"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"}, {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"},
{"tune", CmdTuneSamples, 0, "Get hw tune 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"},
{"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"},
{"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
{"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"},
{"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };

9
client/cmddata.h
View file

@ -14,7 +14,7 @@
command_t * CmdDataCommands(); command_t * CmdDataCommands();
int CmdData(const char *Cmd); int CmdData(const char *Cmd);
void printDemodBuff();
int CmdAmp(const char *Cmd); int CmdAmp(const char *Cmd);
int Cmdaskdemod(const char *Cmd); int Cmdaskdemod(const char *Cmd);
int Cmdaskrawdemod(const char *Cmd); int Cmdaskrawdemod(const char *Cmd);
@ -30,6 +30,8 @@ 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 CmdFSKrawdemod(const char *Cmd); int CmdFSKrawdemod(const char *Cmd);
int CmdDetectNRZpskClockRate(const char *Cmd);
int CmdpskNRZrawDemod(const char *Cmd);
int CmdGrid(const char *Cmd); int CmdGrid(const char *Cmd);
int CmdHexsamples(const char *Cmd); int CmdHexsamples(const char *Cmd);
int CmdHide(const char *Cmd); int CmdHide(const char *Cmd);
@ -49,5 +51,10 @@ int CmdScale(const char *Cmd);
int CmdThreshold(const char *Cmd); int CmdThreshold(const char *Cmd);
int CmdDirectionalThreshold(const char *Cmd); int CmdDirectionalThreshold(const char *Cmd);
int CmdZerocrossings(const char *Cmd); int CmdZerocrossings(const char *Cmd);
int CmdIndalaDecode(const char *Cmd);
#define MAX_DEMOD_BUF_LEN (1024*128)
extern uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
extern int DemodBufferLen;
#endif #endif

28
client/cmdlf.c
View file

@ -559,18 +559,32 @@ int CmdLFfind(const char *Cmd)
ans=CmdSamples("20000"); ans=CmdSamples("20000");
} }
if (GraphTraceLen<1000) return 0; if (GraphTraceLen<1000) return 0;
PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag");
PrintAndLog("Checking for known tags:"); PrintAndLog("Checking for known tags:");
ans=Cmdaskmandemod(""); ans=Cmdaskmandemod("");
if (ans>0) return 1; if (ans>0) {
PrintAndLog("Valid EM410x ID Found!");
return 1;
}
ans=CmdFSKdemodHID(""); ans=CmdFSKdemodHID("");
if (ans>0) return 1; if (ans>0) {
PrintAndLog("Valid HID Prox ID Found!");
return 1;
}
ans=CmdFSKdemodIO(""); ans=CmdFSKdemodIO("");
if (ans>0) return 1; if (ans>0) {
PrintAndLog("Valid IO Prox ID Found!");
return 1;
}
//add psk and indala //add psk and indala
ans=CmdIndalaDemod(""); ans=CmdIndalaDecode("");
if (ans>0) return 1; if (ans>0) {
ans=CmdIndalaDemod("224"); PrintAndLog("Valid Indala ID Found!");
if (ans>0) return 1; return 1;
}
// ans=CmdIndalaDemod("224");
// if (ans>0) return 1;
PrintAndLog("No Known Tags Found!\n"); PrintAndLog("No Known Tags Found!\n");
return 0; return 0;
} }

2
client/cmdlfem4x.c
View file

@ -606,7 +606,7 @@ int CmdWriteWordPWD(const char *Cmd)
static command_t CommandTable[] = static command_t CommandTable[] =
{ {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"em410xdemod", CmdEMdemodASK, 0, "[clock rate] -- Extract ID from EM410x tag"}, {"em410xdemod", CmdEMdemodASK, 0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},
{"em410xread", CmdEM410xRead, 1, "[clock rate] -- Extract ID from EM410x tag"}, {"em410xread", CmdEM410xRead, 1, "[clock rate] -- Extract ID from EM410x tag"},
{"em410xsim", CmdEM410xSim, 0, "<UID> -- Simulate EM410x tag"}, {"em410xsim", CmdEM410xSim, 0, "<UID> -- Simulate EM410x tag"},
{"em410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"}, {"em410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},

52
client/graph.c
View file

@ -146,7 +146,7 @@ void setGraphBuf(uint8_t *buff,int size)
int i=0; int i=0;
ClearGraph(0); ClearGraph(0);
for (; i < size; ++i){ for (; i < size; ++i){
GraphBuffer[i]=buff[i]; GraphBuffer[i]=buff[i]-128;
} }
GraphTraceLen=size; GraphTraceLen=size;
RepaintGraphWindow(); RepaintGraphWindow();
@ -187,3 +187,53 @@ int GetClock(const char *str, int peak, int verbose)
return clock; return clock;
} }
int GetNRZpskClock(const char *str, int peak, int verbose)
{
// return GetClock(str,peak,verbose);
int clock;
// int clock2;
sscanf(str, "%i", &clock);
if (!strcmp(str, ""))
clock = 0;
/* Auto-detect clock */
if (!clock)
{
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
int size = getFromGraphBuf(grph);
clock = DetectpskNRZClock(grph,size,0);
//clock2 = DetectClock2(peak);
/* Only print this message if we're not looping something */
if (!verbose){
PrintAndLog("Auto-detected clock rate: %d", clock);
//PrintAndLog("clock2: %d",clock2);
}
}
return clock;
}
// Get or auto-detect clock rate
/*
int GetNRZpskClock(const char *str, int peak, int verbose)
{
int clock;
// int clock2;
sscanf(str, "%i", &clock);
if (!strcmp(str, ""))
clock = 0;
// Auto-detect clock
if (!clock)
{
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
int size = getFromGraphBuf(grph);
clock = DetectASKClock(grph,size,0);
//clock2 = DetectClock2(peak);
// Only print this message if we're not looping something
if (!verbose){
PrintAndLog("Auto-detected clock rate: %d", clock);
//PrintAndLog("clock2: %d",clock2);
}
}
return clock;
}
*/

1
client/graph.h
View file

@ -17,6 +17,7 @@ int ClearGraph(int redraw);
//int DetectClock(int peak); //int DetectClock(int peak);
int getFromGraphBuf(uint8_t *buff); int getFromGraphBuf(uint8_t *buff);
int GetClock(const char *str, int peak, int verbose); int GetClock(const char *str, int peak, int verbose);
int GetNRZpskClock(const char *str, int peak, int verbose);
void setGraphBuf(uint8_t *buff,int size); void setGraphBuf(uint8_t *buff,int size);
#define MAX_GRAPH_TRACE_LEN (1024*128) #define MAX_GRAPH_TRACE_LEN (1024*128)

493
common/lfdemod.c
View file

@ -14,7 +14,7 @@
//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,uint32_t BitLen) uint64_t Em410xDecode(uint8_t *BitStream, int BitLen)
{ {
//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
@ -82,7 +82,7 @@ restart:
//takes 2 arguments - clock and invert both as integers //takes 2 arguments - clock and invert both as integers
//attempts to demodulate ask while decoding manchester //attempts to demodulate ask while decoding manchester
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert) int askmandemod(uint8_t * BinStream, int *BitLen,int *clk, int *invert)
{ {
int i; int i;
int high = 0, low = 128; int high = 0, low = 128;
@ -592,17 +592,17 @@ uint32_t bytebits_to_byte(uint8_t* src, int numbits)
int IOdemodFSK(uint8_t *dest, size_t size) int IOdemodFSK(uint8_t *dest, size_t size)
{ {
static const uint8_t THRESHOLD = 140;
uint32_t idx=0; uint32_t idx=0;
//make sure buffer has data //make sure buffer has data
if (size < 66) return -1; if (size < 66) return -1;
//test samples are not just noise //test samples are not just noise
uint8_t justNoise = 1; uint8_t testMax=0;
for(idx=0;idx< size && justNoise ;idx++){ for(idx=0;idx<65;idx++){
justNoise = dest[idx] < THRESHOLD; if (testMax<dest[idx]) testMax=dest[idx];
} }
if(justNoise) return 0; idx=0;
//if not just noise
if (testMax>170){
// FSK demodulator // FSK demodulator
size = fskdemod(dest, size,64,1,10,8); // RF/64 and invert size = fskdemod(dest, size,64,1,10,8); // RF/64 and invert
if (size < 65) return -1; //did we get a good demod? if (size < 65) return -1; //did we get a good demod?
@ -626,6 +626,7 @@ int IOdemodFSK(uint8_t *dest, size_t size)
} }
} }
} }
}
return 0; return 0;
} }
@ -654,13 +655,13 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock)
low = dest[i]; low = dest[i];
} }
} }
peak=(int)((peak-128)*.75)+128; peak=(int)(((peak-128)*.75)+128);
low= (int)((low-128)*.75)+128; low= (int)(((low-128)*.75)+128);
int ii; int ii;
int clkCnt; int clkCnt;
int tol = 0; int tol = 0;
int bestErr=1000; int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000};
int errCnt[]={0,0,0,0,0,0,0,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<6;++clkCnt){
if (clk[clkCnt]==32){ if (clk[clkCnt]==32){
@ -668,33 +669,487 @@ int DetectASKClock(uint8_t dest[], size_t size, int clock)
}else{ }else{
tol=0; tol=0;
} }
bestErr=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[clkCnt]=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/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[clkCnt]++; errCnt++;
} }
} }
//if we found no errors this is correct one - return this clock //if we found no errors this is correct one - return this clock
if(errCnt[clkCnt]==0) return clk[clkCnt]; if(errCnt==0) return clk[clkCnt];
//if we found errors see if it is lowest so far and save it as best run //if we found errors see if it is lowest so far and save it as best run
if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt]; if(errCnt<bestErr[clkCnt]) bestErr[clkCnt]=errCnt;
} }
} }
} }
int iii=0; int iii=0;
int best=0; int best=0;
for (iii=0; iii<6;++iii){ for (iii=0; iii<7;++iii){
if (errCnt[iii]<errCnt[best]){ if (bestErr[iii]<bestErr[best]){
// 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; best = iii;
} }
} }
}
return clk[best]; return clk[best];
} }
int DetectpskNRZClock(uint8_t dest[], size_t size, int clock)
{
int i=0;
int peak=0;
int low=128;
int clk[]={16,32,40,50,64,100,128,256};
int loopCnt = 2048; //don't need to loop through entire array...
if (size<loopCnt) loopCnt = size;
//if we already have a valid clock quit
for (;i<8;++i)
if (clk[i]==clock) return clock;
//get high and low peak
for (i=0;i<loopCnt;++i){
if(dest[i]>peak){
peak = dest[i];
}
if(dest[i]<low){
low = dest[i];
}
}
peak=(int)(((peak-128)*.90)+128);
low= (int)(((low-128)*.90)+128);
//PrintAndLog("DEBUG: peak: %d, low: %d",peak,low);
int ii;
int clkCnt;
int tol = 0;
int peakcnt=0;
int errCnt=0;
int bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
int peaksdet[]={0,0,0,0,0,0,0,0,0};
//test each valid clock from smallest to greatest to see which lines up
for(clkCnt=0; clkCnt<6;++clkCnt){
if (clk[clkCnt]==32){
tol=0;
}else{
tol=0;
}
//try lining up the peaks by moving starting point (try first 256)
for (ii=0; ii<loopCnt; ++ii){
if ((dest[ii]>=peak) || (dest[ii]<=low)){
errCnt=0;
peakcnt=0;
// now that we have the first one lined up test rest of wave array
for (i=0; i<((int)(size/clk[clkCnt])-1); ++i){
if (dest[ii+(i*clk[clkCnt])]>=peak || dest[ii+(i*clk[clkCnt])]<=low){
peakcnt++;
}else if(dest[ii+(i*clk[clkCnt])-tol]>=peak || dest[ii+(i*clk[clkCnt])-tol]<=low){
peakcnt++;
}else if(dest[ii+(i*clk[clkCnt])+tol]>=peak || dest[ii+(i*clk[clkCnt])+tol]<=low){
peakcnt++;
}else{ //error no peak detected
errCnt++;
}
}
if(peakcnt>peaksdet[clkCnt]) {
peaksdet[clkCnt]=peakcnt;
bestErr[clkCnt]=errCnt;
}
}
}
}
int iii=0;
int best=0;
//int ratio2; //debug
int ratio;
//int bits;
for (iii=0; iii<7;++iii){
ratio=1000;
//ratio2=1000; //debug
//bits=size/clk[iii]; //debug
if (peaksdet[iii]>0){
ratio=bestErr[iii]/peaksdet[iii];
if (((bestErr[best]/peaksdet[best])>(ratio)+1)){
best = iii;
}
//ratio2=bits/peaksdet[iii]; //debug
}
//PrintAndLog("DEBUG: Clk: %d, peaks: %d, errs: %d, bestClk: %d, ratio: %d, bits: %d, peakbitr: %d",clk[iii],peaksdet[iii],bestErr[iii],clk[best],ratio, bits,ratio2);
}
return clk[best];
}
/*
int DetectNRZpskClock(uint8_t dest[], size_t size, int clock)
{
int i=0;
int peak=0;
int low=128;
int clk[]={16,32,40,50,64,100,128,256};
int loopCnt = 1500; //don't need to loop through entire array...
if (size<loopCnt) loopCnt = size;
//if we already have a valid clock quit
for (;i<8;++i)
if (clk[i]==clock) return clock;
//get high and low peak
for (i=0;i<loopCnt;++i){
if(dest[i]>peak){
peak = dest[i];
}
if(dest[i]<low){
low = dest[i];
}
}
peak=(int)((peak-128)*.75)+128;
low= (int)((low-128)*.75)+128;
int ii;
int clkCnt;
int tol = 0;
int bestErr=1000;
int errCnt[]={0,0,0,0,0,0,0,0};
int lastClk = 0;
uint8_t bitHigh=0;
uint8_t ignorewin;
int lowBitCnt[]={0,0,0,0,0,0,0,0};
int BestLowBit=0;
//test each valid clock from smallest to greatest to see which lines up
for(clkCnt=0; clkCnt<6;++clkCnt){
if (clk[clkCnt]==32){
tol=1;
}else{
tol=0;
}
ignorewin = clk[clkCnt]/8;
bestErr=1000;
//try lining up the peaks by moving starting point (try first 256)
for (ii=1; ii<loopCnt; ++ii){
if ((dest[ii]>=peak) || (dest[ii]<=low)){
lastClk = ii-*clk;
errCnt[clkCnt]=0;
// now that we have the first one lined up test rest of wave array
for (i=ii; i<size; ++i){
if ((dest[i]>=peak || dest[i]<=low) && (i>=lastClk+*clk-tol && i<=lastClk+*clk+tol)){
bitHigh=1;
lastClk=lastClk+*clk;
ignorewin=clk[clkCnt]/8;
}else if(dest[i]<peak && dest[i]>low) {
if (ignorewin==0){
bitHigh=0;
}else ignorewin--;
if (i>=lastClk+*clk+tol){ //past possible bar
lowBitCnt[clkCnt]++;
}
}else if ((dest[i]>=peak || dest[i]<=low) && (i<lastClk+*clk-tol || i>=lastClk+*clk+tol) && (bitHigh==0)){
//error bar found no clock...
errCnt[clkCnt]++;
}
}
//if we found no errors this is correct one - return this clock
if(errCnt[clkCnt]==0 && lowBitCnt[clkCnt]==0) return clk[clkCnt];
//if we found errors see if it is lowest so far and save it as best run
if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
if(lowBitCnt[clkCnt]<BestLowBit && errCnt[clkCnt]==bestErr) BestLowBit=lowBitCnt[clkCnt];
}
}
}
int iii=0;
int best=0;
int best2=0;
//get best run
for (iii=0; iii<7;++iii){
if (errCnt[iii]<errCnt[best]){
best = iii;
}
if (lowBitCnt[iii]<lowBitCnt[best2]){
best2=iii;
}
}
//adjust best to one with least low bit counts (as long as no errors)
if (best!=best2){
if (errCnt[best]==errCnt[best2]) best = best2;
}
return clk[best];
}
*/
//by marshmellow (attempt to get rid of high immediately after a low)
void pskCleanWave(uint8_t *bitStream, int bitLen)
{
int i;
int low=128;
int high=0;
int gap = 4;
// int loopMax = 2048;
int newLow=0;
int newHigh=0;
for (i=0; i<bitLen; ++i){
if (bitStream[i]<low) low=bitStream[i];
if (bitStream[i]>high) high=bitStream[i];
}
high = (int)(((high-128)*.80)+128);
low = (int)(((low-128)*.90)+128);
//low = (uint8_t)(((int)(low)-128)*.80)+128;
for (i=0; i<bitLen; ++i){
if (newLow==1){
bitStream[i]=low+8;
gap--;
if (gap==0){
newLow=0;
gap=4;
}
}else if (newHigh==1){
bitStream[i]=high-8;
gap--;
if (gap==0){
newHigh=0;
gap=4;
}
}
if (bitStream[i]<=low) newLow=1;
if (bitStream[i]>=high) newHigh=1;
}
return;
}
int indala26decode(uint8_t *bitStream, int *bitLen, uint8_t *invert)
{
//26 bit 40134 format (don't know other formats)
// Finding the start of a UID
int i;
int long_wait;
//uidlen = 64;
long_wait = 29;//29 leading zeros in format
int start;
int first = 0;
int first2 = 0;
int bitCnt = 0;
int ii;
for (start = 0; start <= *bitLen - 250; start++) {
first = bitStream[start];
for (i = start; i < start + long_wait; i++) {
if (bitStream[i] != first) {
break;
}
}
if (i == (start + long_wait)) {
break;
}
}
if (start == *bitLen - 250 + 1) {
// did not find start sequence
return -1;
}
//found start once now test length by finding next one
// Inverting signal if needed
if (first == 1) {
for (i = start; i < *bitLen; i++) {
bitStream[i] = !bitStream[i];
}
*invert = 1;
}else *invert=0;
int iii;
for (ii=start+29; ii <= *bitLen - 250; ii++) {
first2 = bitStream[ii];
for (iii = ii; iii < ii + long_wait; iii++) {
if (bitStream[iii] != first2) {
break;
}
}
if (iii == (ii + long_wait)) {
break;
}
}
if (ii== *bitLen - 250 + 1){
// did not find second start sequence
return -2;
}
bitCnt=ii-start;
// Dumping UID
i = start;
for (ii = 0; ii < bitCnt; ii++) {
bitStream[ii] = bitStream[i++];
//showbits[bit] = '0' + bits[bit];
}
*bitLen=bitCnt;
return 1;
}
int pskNRZrawDemod(uint8_t *dest, int *bitLen, int *clk, int *invert)
{
pskCleanWave(dest,*bitLen);
int clk2 = DetectpskNRZClock(dest, *bitLen, *clk);
*clk=clk2;
uint32_t i;
uint8_t high=0, low=128;
uint32_t gLen = *bitLen;
if (gLen > 1280) gLen=1280;
// get high
for (i=0; i<gLen; ++i){
if (dest[i]>high) high = dest[i];
if (dest[i]<low) low=dest[i];
}
//fudge high/low bars by 25%
high = (uint8_t)((((int)(high)-128)*.75)+128);
low = (uint8_t)((((int)(low)-128)*.80)+128);
//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
int lastBit = 0; //set first clock check
uint32_t bitnum = 0; //output counter
uint8_t 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=2; //clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely
uint32_t iii = 0;
uint8_t errCnt =0;
uint32_t bestStart = *bitLen;
uint32_t maxErr = (*bitLen/1000);
uint32_t bestErrCnt = maxErr;
//uint8_t midBit=0;
uint8_t curBit=0;
uint8_t bitHigh=0;
uint8_t ignorewin=*clk/8;
//PrintAndLog("DEBUG - lastbit - %d",lastBit);
//loop to find first wave that works - align to clock
for (iii=0; iii < gLen; ++iii){
if ((dest[iii]>=high)||(dest[iii]<=low)){
lastBit=iii-*clk;
//loop through to see if this start location works
for (i = iii; i < *bitLen; ++i) {
//if we found a high bar and we are at a clock bit
if ((dest[i]>=high ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){
bitHigh=1;
lastBit+=*clk;
//curBit=1-*invert;
//dest[bitnum]=curBit;
ignorewin=*clk/8;
bitnum++;
//else if low bar found and we are at a clock point
}else if ((dest[i]<=low ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){
bitHigh=1;
lastBit+=*clk;
ignorewin=*clk/8;
//curBit=*invert;
//dest[bitnum]=curBit;
bitnum++;
//else if no bars found
}else if(dest[i]<high && dest[i]>low) {
if (ignorewin==0){
bitHigh=0;
}else ignorewin--;
//if we are past a clock point
if (i>=lastBit+*clk+tol){ //clock val
//dest[bitnum]=curBit;
lastBit+=*clk;
bitnum++;
}
//else if bar found but we are not at a clock bit and we did not just have a clock bit
}else if ((dest[i]>=high || dest[i]<=low) && (i<lastBit+*clk-tol || i>lastBit+*clk+tol) && (bitHigh==0)){
//error bar found no clock...
errCnt++;
}
if (bitnum>=1000) break;
}
//we got more than 64 good bits and not all errors
if ((bitnum > (64+errCnt)) && (errCnt<(maxErr))) {
//possible good read
if (errCnt==0){
bestStart = iii;
bestErrCnt=errCnt;
break; //great read - finish
}
if (bestStart == iii) break; //if current run == bestErrCnt run (after exhausted testing) then finish
if (errCnt<bestErrCnt){ //set this as new best run
bestErrCnt=errCnt;
bestStart = iii;
}
}
}
}
if (bestErrCnt<maxErr){
//best run is good enough set to best run and set overwrite BinStream
iii=bestStart;
lastBit=bestStart-*clk;
bitnum=0;
for (i = iii; i < *bitLen; ++i) {
//if we found a high bar and we are at a clock bit
if ((dest[i]>=high ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){
bitHigh=1;
lastBit+=*clk;
curBit=1-*invert;
dest[bitnum]=curBit;
ignorewin=*clk/8;
bitnum++;
//else if low bar found and we are at a clock point
}else if ((dest[i]<=low ) && (i>=lastBit+*clk-tol && i<=lastBit+*clk+tol)){
bitHigh=1;
lastBit+=*clk;
curBit=*invert;
dest[bitnum]=curBit;
ignorewin=*clk/8;
bitnum++;
//else if no bars found
}else if(dest[i]<high && dest[i]>low) {
if (ignorewin==0){
bitHigh=0;
}else ignorewin--;
//if we are past a clock point
if (i>=lastBit+*clk+tol){ //clock val
lastBit+=*clk;
dest[bitnum]=curBit;
bitnum++;
}
//else if bar found but we are not at a clock bit and we did not just have a clock bit
}else if ((dest[i]>=high || dest[i]<=low) && ((i<lastBit+*clk-tol) || (i>lastBit+*clk+tol)) && (bitHigh==0)){
//error bar found no clock...
bitHigh=1;
dest[bitnum]=77;
bitnum++;
errCnt++;
}
if (bitnum >=1000) break;
}
*bitLen=bitnum;
} else{
*bitLen=bitnum;
*clk=bestStart;
return -1;
}
if (bitnum>16){
*bitLen=bitnum;
} else return -1;
return errCnt;
}
/*not needed?
uint32_t i;
uint8_t high=0, low=128;
uint32_t loopMax = 1280; //20 raw bits
// get high
if (size<loopMax) return -1;
for (i=0; i<loopMax; ++i){
if (dest[i]>high) high = dest[i];
if (dest[i]<low) low=dest[i];
}
//fudge high/low bars by 25%
high = (uint8_t)(((int)(high)-128)*.75)+128;
low = (uint8_t)(((int)(low)-128)*.75)+128;
//clean waves
for (i=0;i<size; ++i){
if (dest[i]>=high) dest[i]=high;
else if(dest[i]<=low) dest[i]=low;
else dest[i]=0;
}
*/

8
common/lfdemod.h
View file

@ -12,8 +12,8 @@
#include <stdint.h> #include <stdint.h>
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,uint32_t *BitLen,int *clk, int *invert); int askmandemod(uint8_t *BinStream,int *BitLen,int *clk, int *invert);
uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen); uint64_t Em410xDecode(uint8_t *BitStream,int BitLen);
int manrawdecode(uint8_t *BitStream, int *bitLen); int manrawdecode(uint8_t *BitStream, int *bitLen);
int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset); int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset);
int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert); int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert);
@ -21,5 +21,9 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
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, int numbits); uint32_t bytebits_to_byte(uint8_t* src, int numbits);
int pskNRZrawDemod(uint8_t *dest, int *bitLen, int *clk, int *invert);
int DetectpskNRZClock(uint8_t dest[], size_t size, int clock);
int indala26decode(uint8_t *bitStream, int *bitLen, uint8_t *invert);
void pskCleanWave(uint8_t *bitStream, int bitLen);
#endif #endif

16000
traces/ATA5577-HIDemu-FC1-C9.pm3 Normal file
View file

File diff suppressed because it is too large Load diff

7
traces/README.txt
View file

@ -15,3 +15,10 @@ Transit999-best.pm3: Transit 999 format (UID 99531670)
The files 'modulation-'... are all encoded with identical data (hex 00 01 02 03 04 05 06 07 08 09 0A 0B) The files 'modulation-'... are all encoded with identical data (hex 00 01 02 03 04 05 06 07 08 09 0A 0B)
for the purpose of recognition and testing of demodulation schemes. They were created by writing Q5 tags for the purpose of recognition and testing of demodulation schemes. They were created by writing Q5 tags
appropriately configured. The raw data is in 'modulation-data.dat'. appropriately configured. The raw data is in 'modulation-data.dat'.
ata5577-HIDemu-FC1-C9.pm3: ata5577 in hid prox 26 bit emulation facility code:1 card#:9
casi-12ed825c29.pm3: casi rusco 40 bit (EM410x ID: 12ed825c29)
EM4102-Fob.pm3: (ID: 0400193cbe)
ioprox-XSF-01-3B-44725.pm3: IO Prox FSK RF/64 ID in name
ioprox-XSF-01-BE-03011.pm3: IO Prox FSK RF/64 ID in name
indala-504278295.pm3: PSK 26 bit indala