github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-19 13:00:42 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

FIX: a shot at fixing the "_" underscore problem in fileutils.c. This one uses _ifdefine. I hope it works. Linux people can let me know if it works.

Browse source 
FIX: changed the DetectASKClock in lfdemod.c to correct detect all clocks in the array.
CHG: I like code with more spaces inside of it and tried change some stuff according to our codestyle in HACKING.txt
ADD: some zero checks and overflows, god knows where it was.

The T55XX commands will be rewritten to use Marshmellows lfdemod.c instead.
CHG: Made the graph window smaller.
CHG: lf read  now does a "data samples" also.  (less writing commands)
CHG: data samples now defaults to samples size of 20000
This commit is contained in:
iceman1001 2015-01-04 22:49:54 +01:00
commit 8d0a3e87d7
12 changed files with 1280 additions and 1275 deletions
Download patch file Download diff file Expand all files Collapse all files

6
armsrc/desfire_crypto.c
View file

@ -321,7 +321,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
*nbytes = -1;
res = NULL;
#ifdef WITH_DEBUG
printf ("No room for MAC!");
Dbprintf ("No room for MAC!");
#endif
break;
}
@ -336,7 +336,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
if (0 != memcmp ((uint8_t *)data + *nbytes - 1, (uint8_t *)edata + edl - 8, 4)) {
#ifdef WITH_DEBUG
printf ("MACing not verified");
Dbprintf ("MACing not verified");
hexdump ((uint8_t *)data + *nbytes - 1, key_macing_length (key), "Expect ", 0);
hexdump ((uint8_t *)edata + edl - 8, key_macing_length (key), "Actual ", 0);
#endif
@ -366,7 +366,7 @@ void* mifare_cryto_postprocess_data (desfiretag_t tag, void *data, ssize_t *nbyt
((uint8_t *)data)[*nbytes - 9] = first_cmac_byte;
if (0 != memcmp (DESFIRE (tag)->cmac, (uint8_t *)data + *nbytes - 9, 8)) {
#ifdef WITH_DEBUG
printf ("CMAC NOT verified :-(");
Dbprintf ("CMAC NOT verified :-(");
hexdump ((uint8_t *)data + *nbytes - 9, 8, "Expect ", 0);
hexdump (DESFIRE (tag)->cmac, 8, "Actual ", 0);
#endif

115
armsrc/lfops.c
View file

@ -64,9 +64,9 @@ void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
// split into two routines so we can avoid timing issues after sending commands //
void DoAcquisition125k_internal(int trigger_threshold, bool silent)
{
uint8_t *dest = get_bigbufptr_recvrespbuf();
uint8_t *dest = (uint8_t *)BigBuf;
uint16_t i = 0;
memset(dest, 0x00, FREE_BUFFER_SIZE);
memset(dest, 0x00, BIGBUF_SIZE);
for(;;) {
if (AT91C_BASE_SSC->SSC_SR & AT91C_SSC_TXRDY) {
@ -80,7 +80,7 @@ void DoAcquisition125k_internal(int trigger_threshold, bool silent)
continue;
else
trigger_threshold = -1;
if (++i >= FREE_BUFFER_SIZE) break;
if (++i >= BIGBUF_SIZE) break;
}
}
if (!silent){
@ -161,8 +161,6 @@ void ReadTItag(void)
signed char *dest = (signed char *)BigBuf;
int n = sizeof(BigBuf);
// int *dest = GraphBuffer;
// int n = GraphTraceLen;
// 128 bit shift register [shift3:shift2:shift1:shift0]
uint32_t shift3 = 0, shift2 = 0, shift1 = 0, shift0 = 0;
@ -569,8 +567,6 @@ void SimulateTagLowFrequency( uint16_t period, uint32_t gap, uint8_t ledcontrol)
void SimulateTagLowFrequencyA(int len, int gap)
{
//Dbprintf("LEN %d || Gap %d",len, gap);
uint8_t *buf = (uint8_t *)BigBuf;
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
@ -725,9 +721,7 @@ void CmdHIDsimTAG(int hi, int lo, uint8_t ledcontrol)
// loop to get raw HID waveform then FSK demodulate the TAG ID from it
void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
{
uint8_t *dest = get_bigbufptr_recvrespbuf();
size_t size=0; //, found=0;
uint8_t *dest = (uint8_t *)BigBuf;
uint32_t hi2 = 0, hi = 0, lo = 0;
// Configure to go in 125Khz listen mode
@ -739,25 +733,31 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1,true);
size = sizeof(BigBuf);
if (size < 2000) continue;
// FSK demodulator
int bitLen = HIDdemodFSK(dest,size,&hi2,&hi,&lo);
// FSK demodulator
int bitLen = HIDdemodFSK(dest,BIGBUF_SIZE,&hi2,&hi,&lo);
WDT_HIT();
if (bitLen > 0 && lo > 0){
// 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
if (hi2 != 0){ //extra large HID tags
if (hi2 != 0){
//extra large HID tags
Dbprintf("TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
}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
(unsigned int) hi2,
(unsigned int) hi,
(unsigned int) lo,
(unsigned int) (lo >> 1) & 0xFFFF);
} else {
//standard HID tags <38 bits
uint8_t bitlen = 0;
uint32_t fc = 0;
uint32_t cardnum = 0;
if ((( hi >> 5 ) & 1) ==1){//if bit 38 is set then < 37 bit format is used
uint32_t lo2 = 0;
lo2 = (((hi & 31) << 12) | (lo >> 20)); //get bits 21-37 to check for format len bit
@ -795,11 +795,13 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
fc = ((hi & 0xF) << 12 ) |(lo >> 20);
}
}
//Dbprintf("TAG ID: %x%08x (%d)",
// (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
Dbprintf("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) bitlen, (unsigned int) fc, (unsigned int) cardnum);
(unsigned int) hi,
(unsigned int) lo,
(unsigned int) (lo >> 1) & 0xFFFF,
(unsigned int) bitlen,
(unsigned int) fc,
(unsigned int) cardnum);
}
if (findone){
if (ledcontrol) LED_A_OFF();
@ -809,7 +811,6 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
hi2 = hi = lo = 0;
}
WDT_HIT();
//SpinDelay(50);
}
DbpString("Stopped");
if (ledcontrol) LED_A_OFF();
@ -818,13 +819,12 @@ void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
{
uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0; //, found=0;
uint32_t bitLen = 0;
int clk = 0, invert = 0, errCnt = 0;
uint64_t lo = 0;
// Configure to go in 125Khz listen mode
LFSetupFPGAForADC(95, true);
LFSetupFPGAForADC(0, true);
while(!BUTTON_PRESS()) {
@ -832,37 +832,33 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1,true);
size = sizeof(BigBuf);
if (size < 2000) continue;
// FSK demodulator
//int askmandemod(uint8_t *BinStream,uint32_t *BitLen,int *clk, int *invert);
bitLen=size;
//Dbprintf("DEBUG: Buffer got");
errCnt = askmandemod(dest,&bitLen,&clk,&invert); //HIDdemodFSK(dest,size,&hi2,&hi,&lo);
//Dbprintf("DEBUG: ASK Got");
bitLen = BIGBUF_SIZE;
errCnt = askmandemod(dest,&bitLen,&clk,&invert);
if ( errCnt < 0 ) continue;
WDT_HIT();
if (errCnt>=0){
lo = Em410xDecode(dest,bitLen);
//Dbprintf("DEBUG: EM GOT");
//printEM410x(lo);
if (lo>0){
Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",(uint32_t)(lo>>32),(uint32_t)lo,(uint32_t)(lo&0xFFFF),(uint32_t)((lo>>16LL) & 0xFF),(uint32_t)(lo & 0xFFFFFF));
}
if ( lo <= 0) continue;
Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",
(uint32_t)(lo >> 32),
(uint32_t)lo,
(uint32_t)(lo & 0xFFFF),
(uint32_t)((lo >> 16LL) & 0xFF),
(uint32_t)(lo & 0xFFFFFF)
);
if (findone){
if (ledcontrol) LED_A_OFF();
return;
}
} else {
//Dbprintf("DEBUG: No Tag");
}
WDT_HIT();
lo = 0;
clk=0;
invert=0;
errCnt=0;
size=0;
//SpinDelay(50);
lo = clk = invert = errCnt = 0;
}
DbpString("Stopped");
if (ledcontrol) LED_A_OFF();
@ -871,30 +867,27 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
{
uint8_t *dest = (uint8_t *)BigBuf;
size_t size=0;
int idx = 0;
uint32_t code = 0, code2 = 0;
uint8_t version = 0;
uint8_t facilitycode = 0;
uint16_t number = 0;
// Configure to go in 125Khz listen mode
LFSetupFPGAForADC(0, true);
while(!BUTTON_PRESS()) {
WDT_HIT();
if (ledcontrol) LED_A_ON();
DoAcquisition125k_internal(-1, true);
size = sizeof(BigBuf);
//make sure buffer has data
if (size < 2000) continue;
//fskdemod and get start index
idx = IOdemodFSK(dest, BIGBUF_SIZE);
if ( idx < 0 )
continue;
WDT_HIT();
idx = IOdemodFSK(dest,size);
if (idx>0){
//valid tag found
//Index map
//0 10 20 30 40 50 60
@ -905,6 +898,7 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
//
//XSF(version)facility:codeone+codetwo
//Handle the data
if(findone){ //only print binary if we are doing one
Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx], dest[idx+1], dest[idx+2],dest[idx+3],dest[idx+4],dest[idx+5],dest[idx+6],dest[idx+7],dest[idx+8]);
Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+9], dest[idx+10],dest[idx+11],dest[idx+12],dest[idx+13],dest[idx+14],dest[idx+15],dest[idx+16],dest[idx+17]);
@ -914,6 +908,7 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
Dbprintf("%d%d%d%d%d%d%d%d %d",dest[idx+45],dest[idx+46],dest[idx+47],dest[idx+48],dest[idx+49],dest[idx+50],dest[idx+51],dest[idx+52],dest[idx+53]);
Dbprintf("%d%d%d%d%d%d%d%d %d%d",dest[idx+54],dest[idx+55],dest[idx+56],dest[idx+57],dest[idx+58],dest[idx+59],dest[idx+60],dest[idx+61],dest[idx+62],dest[idx+63]);
}
code = bytebits_to_byte(dest+idx,32);
code2 = bytebits_to_byte(dest+idx+32,32);
version = bytebits_to_byte(dest+idx+27,8); //14,4
@ -921,7 +916,6 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
number = (bytebits_to_byte(dest+idx+36,8)<<8)|(bytebits_to_byte(dest+idx+45,8)); //36,9
Dbprintf("XSF(%02d)%02x:%05d (%08x%08x)", version, facilitycode, number, code, code2);
// if we're only looking for one tag
if (findone){
if (ledcontrol) LED_A_OFF();
return;
@ -931,8 +925,7 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
number = 0;
idx = 0;
}
WDT_HIT();
}
DbpString("Stopped");
if (ledcontrol) LED_A_OFF();
}

419
client/cmddata.c
View file

@ -29,15 +29,11 @@ int CmdAmp(const char *Cmd)
int i, rising, falling;
int max = INT_MIN, min = INT_MAX;
for (i = 10; i < GraphTraceLen; ++i) {
if (GraphBuffer[i] > max)
max = GraphBuffer[i];
if (GraphBuffer[i] < min)
min = GraphBuffer[i];
}
DetectHighLowInGraph( &max, &min, FALSE);
if (max != min) {
rising = falling = 0;
for (i = 0; i < GraphTraceLen; ++i) {
if (GraphBuffer[i + 1] < GraphBuffer[i]) {
if (rising) {
@ -78,27 +74,23 @@ int Cmdaskdemod(const char *Cmd)
sscanf(Cmd, "%i", &c);
/* Detect high and lows and clock */
// (AL - clock???)
for (i = 0; i < GraphTraceLen; ++i)
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
high=abs(high*.75);
low=abs(low*.75);
if (c != 0 && c != 1) {
PrintAndLog("Invalid argument: %s", Cmd);
return 0;
}
DetectHighLowInGraph( &high, &low, FALSE);
high = abs(high * .75);
low = abs(low * .75);
//prime loop
if (GraphBuffer[0] > 0) {
GraphBuffer[0] = 1-c;
} else {
GraphBuffer[0] = c;
}
for (i = 1; i < GraphTraceLen; ++i) {
/* Transitions are detected at each peak
* Transitions are either:
@ -121,49 +113,59 @@ int Cmdaskdemod(const char *Cmd)
return 0;
}
void printBitStream(uint8_t BitStream[], uint32_t bitLen){
void printBitStream(uint8_t bits[], uint32_t bitLen){
uint32_t i = 0;
if (bitLen < 16) {
PrintAndLog("Too few bits found: %d",bitLen);
return;
}
if (bitLen>512) bitLen=512;
if (bitLen > 512)
bitLen = 512;
if ( ( bitLen % 16 ) > 0) {
bitLen = ((bitLen / 16) * 16);
PrintAndLog("ICE: equally divided with 16 = %d",bitLen);
}
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",
BitStream[i],
BitStream[i+1],
BitStream[i+2],
BitStream[i+3],
BitStream[i+4],
BitStream[i+5],
BitStream[i+6],
BitStream[i+7],
BitStream[i+8],
BitStream[i+9],
BitStream[i+10],
BitStream[i+11],
BitStream[i+12],
BitStream[i+13],
BitStream[i+14],
BitStream[i+15]);
bits[i],
bits[i+1],
bits[i+2],
bits[i+3],
bits[i+4],
bits[i+5],
bits[i+6],
bits[i+7],
bits[i+8],
bits[i+9],
bits[i+10],
bits[i+11],
bits[i+12],
bits[i+13],
bits[i+14],
bits[i+15]);
}
return;
}
void printEM410x(uint64_t id)
{
if (id !=0){
uint64_t iii=1;
uint64_t id2lo=0; //id2hi=0,
uint32_t ii=0;
uint32_t i=0;
for (ii=5; ii>0;ii--){
void printEM410x(uint64_t id) {
if ( id <= 0 ) return;
uint64_t id2lo = 0;
uint32_t i,j;
i = j = 0;
for (j = 5; j > 0; j--){
for (i = 0; i < 8; i++){
id2lo=(id2lo<<1LL)|((id & (iii<<(i+((ii-1)*8))))>>(i+((ii-1)*8)));
id2lo = ( id2lo << 1LL)|((id & ( 1 << ( i +( ( j-1 ) * 8 )))) >> ( i + (( j-1) *8 )));
}
}
//output em 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 10 : %010lld", id & 0xFFFFFF);
PrintAndLog("DEZ 5.5 : %05lld.%05lld", (id>>16LL) & 0xFFFF, (id & 0xFFFF));
@ -172,18 +174,16 @@ void printEM410x(uint64_t id)
PrintAndLog("DEZ 15/IK3 : %015lld", id2lo);
PrintAndLog("Other : %05lld_%03lld_%08lld", (id & 0xFFFF), (( id >> 16LL) & 0xFF), (id & 0xFFFFFF));
}
return;
}
int CmdEm410xDecode(const char *Cmd)
{
uint64_t id = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t i=0;
i=getFromGraphBuf(BitStream);
id = Em410xDecode(BitStream,i);
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t len = GetFromGraphBuf(bits);
id = Em410xDecode(bits, len);
printEM410x(id);
if (id>0) return 1;
if ( id > 0 )
return 1;
return 0;
}
@ -195,38 +195,39 @@ int Cmdaskmandemod(const char *Cmd)
{
int invert = 0;
int clk = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd);
return 0;
}
uint32_t BitLen = getFromGraphBuf(BitStream);
int errCnt=0;
errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
if (errCnt<0){ //if fatal error (or -1)
// PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0;
}
if (BitLen<16) return 0;
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t len = GetFromGraphBuf(bits);
int errCnt = askmandemod(bits, &len, &clk, &invert);
if (errCnt < 0) return 0;
if (len < 16) return 0;
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,len);
if (errCnt > 0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
}
PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printBitStream(BitStream,BitLen);
uint64_t lo =0;
lo = Em410xDecode(BitStream,BitLen);
printBitStream(bits, len);
uint64_t lo = Em410xDecode(bits, len);
if (lo > 0){
//set GraphBuffer for clone or sim command
setGraphBuf(BitStream,BitLen);
SetGraphBuf(bits,len);
PrintAndLog("EM410x pattern found: ");
printEM410x(lo);
return 1;
}
//if (BitLen>16) return 1;
return 0;
}
@ -238,35 +239,36 @@ int Cmdmandecoderaw(const char *Cmd)
int i = 0;
int errCnt = 0;
int bitnum = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
int high = 0, low = 0;
for (; i < GraphTraceLen; ++i){
if (GraphBuffer[i] > high) high = GraphBuffer[i];
else if (GraphBuffer[i] < low) low = GraphBuffer[i];
BitStream[i]=GraphBuffer[i];
bits[i] = GraphBuffer[i];
}
if (high > 1 || low < 0 ){
PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
return 0;
}
bitnum = i;
errCnt=manrawdecode(BitStream,&bitnum);
errCnt = manrawdecode(bits, &bitnum);
if (errCnt>=20){
PrintAndLog("Too many errors: %d",errCnt);
return 0;
}
PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
printBitStream(BitStream,bitnum);
printBitStream(bits,bitnum);
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;
id = Em410xDecode(BitStream,i);
SetGraphBuf(bits, bitnum);
uint64_t id = Em410xDecode(bits,i);
printEM410x(id);
}
return 1;
@ -289,25 +291,27 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
int offset = 0;
int high = 0, low = 0;
sscanf(Cmd, "%i", &offset);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint8_t bits[MAX_GRAPH_TRACE_LEN]={0};
//get graphbuffer & high and low
for (; i<GraphTraceLen; ++i){
if (GraphBuffer[i] > high) high = GraphBuffer[i];
else if (GraphBuffer[i] < low) low = GraphBuffer[i];
BitStream[i]=GraphBuffer[i];
bits[i] = GraphBuffer[i];
}
if (high > 1 || low < 0){
PrintAndLog("Error: please raw demod the wave first then decode");
return 0;
}
bitnum = i;
errCnt=BiphaseRawDecode(BitStream,&bitnum, offset);
errCnt = BiphaseRawDecode(bits, &bitnum, offset);
if (errCnt >= 20){
PrintAndLog("Too many errors attempting to decode: %d", errCnt);
return 0;
}
PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:", offset, errCnt);
printBitStream(BitStream,bitnum);
printBitStream(bits, bitnum);
PrintAndLog("\nif bitstream does not look right try offset=1");
return 1;
}
@ -319,42 +323,48 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
//prints binary found and saves in graphbuffer for further commands
int Cmdaskrawdemod(const char *Cmd)
{
uint32_t i;
int invert = 0;
int clk = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i", &clk, &invert);
if (invert != 0 && invert != 1 ) {
PrintAndLog("Invalid argument: %s", Cmd);
return 0;
}
int BitLen = getFromGraphBuf(BitStream);
if ( clock < 0 ) {
PrintAndLog("Wrong clock argument");
return 0;
}
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
int len = GetFromGraphBuf(bits);
int errCnt = 0;
errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
if (errCnt==-1){ //throw away static - allow 1 and -1 (in case of threshold command first)
errCnt = askrawdemod(bits, &len, &clk, &invert);
//throw away static - allow 1 and -1 (in case of threshold command first)
if (errCnt == -1) {
PrintAndLog("no data found");
return 0;
}
if (BitLen<16) return 0;
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);
if (len < 16) return 0;
PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,len);
//move BitStream back to GraphBuffer
SetGraphBuf(bits, len);
ClearGraph(0);
for (i=0; i < BitLen; ++i){
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=BitLen;
RepaintGraphWindow();
//output
if (errCnt > 0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
}
PrintAndLog("ASK demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printBitStream(BitStream,BitLen);
PrintAndLog("ASK demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
printBitStream(bits,len);
return 1;
}
@ -393,7 +403,7 @@ int CmdAutoCorr(const char *Cmd)
int CmdBitsamples(const char *Cmd)
{
int cnt = 0;
uint8_t got[12288];
uint8_t got[10000];
GetFromBigBuf(got,sizeof(got),0);
WaitForResponse(CMD_ACK,NULL);
@ -426,16 +436,10 @@ int CmdBitstream(const char *Cmd)
int hithigh, hitlow, first;
/* Detect high and lows and clock */
for (i = 0; i < GraphTraceLen; ++i)
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
DetectHighLowInGraph( &high, &low, FALSE);
/* Get our clock */
clock = GetClock(Cmd, high, 1);
clock = GetClock(Cmd, 0);
gtl = ClearGraph(0);
bit = 0;
@ -467,10 +471,6 @@ int CmdBitstream(const char *Cmd)
bit ^= 1;
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();
@ -499,7 +499,7 @@ int CmdDec(const char *Cmd)
// uses data from graphbuffer
int CmdDetectClockRate(const char *Cmd)
{
GetClock("",0,0);
GetClock("",1);
return 0;
}
@ -510,38 +510,43 @@ int CmdDetectClockRate(const char *Cmd)
int CmdFSKrawdemod(const char *Cmd)
{
//raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults
int rfLen = 50;
int invert = 0;
int fchigh = 10;
int fclow = 8;
//set options from parameters entered with the command
sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
// A lots of checks if chigh, clow is out-of bounds.
if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
//rfLen=param_get8(Cmd, 0); //if rfLen option only is used
if (rfLen==1){
invert=1; //if invert option only is used
rfLen = 50;
} else if(rfLen==0) rfLen=50;
//if invert option only is used
if (rfLen == 1){
invert=1;
}
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};
uint32_t BitLen = getFromGraphBuf(BitStream);
int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
}
PrintAndLog("Args invert: %d - Clock:%d - FC high:%d - FC low: %d",invert,rfLen,fchigh, fclow);
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t len = GetFromGraphBuf(bits);
int size = fskdemod(bits, len,(uint8_t)rfLen, (uint8_t)invert, (uint8_t)fchigh, (uint8_t)fclow);
if (size > 0) {
PrintAndLog("FSK decoded bitstream:");
ClearGraph(0);
for (i=0;i<size;++i){
GraphBuffer[i]=BitStream[i];
}
GraphTraceLen=size;
RepaintGraphWindow();
SetGraphBuf(bits, size);
// 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
printBitStream(BitStream,size);
// 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;
printBitStream(bits,size);
} else {
PrintAndLog("no FSK data found");
}
@ -556,37 +561,51 @@ int CmdFSKdemodHID(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};
uint32_t BitLen = getFromGraphBuf(BitStream);
uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t BitLen = GetFromGraphBuf(BitStream);
//get binary from fsk wave
size_t size = HIDdemodFSK(BitStream,BitLen,&hi2,&hi,&lo);
if (size < 0){
PrintAndLog("Error demoding fsk");
return 0;
}
if (hi2==0 && hi==0 && lo==0) return 0;
if (hi2 != 0){ //extra large HID tags
//extra large HID tags
if (hi2 != 0){
PrintAndLog("TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
setGraphBuf(BitStream,BitLen);
(unsigned int) hi2,
(unsigned int) hi,
(unsigned int) lo,
(unsigned int) (lo>>1) & 0xFFFF);
SetGraphBuf(BitStream,BitLen);
return 1;
}
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
} else {
//standard HID tags <38 bits
uint8_t fmtLen = 0;
uint32_t fc = 0;
uint32_t cardnum = 0;
if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
//if bit 38 is set then < 37 bit format is used
if (((hi>>5) & 1)==1){
uint32_t lo2 = 0;
lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
//get bits 21-37 to check for format len bit
lo2 = (((hi & 15) << 12) | (lo>>20));
uint8_t idx3 = 1;
while(lo2>1){ //find last bit set to 1 (format len bit)
//find last bit set to 1 (format len bit)
while( lo2 > 1){
lo2=lo2>>1;
idx3++;
}
fmtLen = idx3 + 19;
fc = 0;
cardnum = 0;
if(fmtLen==26){
cardnum = (lo>>1)&0xFFFF;
fc = (lo>>17)&0xFF;
@ -603,20 +622,25 @@ int CmdFSKdemodHID(const char *Cmd)
cardnum = (lo>>1)&0xFFFFF;
fc = ((hi&1)<<11)|(lo>>21);
}
}
else { //if bit 38 is not set then 37 bit format is used
} else {
//if bit 38 is not set then 37 bit format is used
fmtLen= 37;
fc =0;
cardnum=0;
if (fmtLen==37){
cardnum = (lo>>1) & 0x7FFFF;
fc = ((hi&0xF) << 12) | (lo >> 20);
}
}
PrintAndLog("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) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
setGraphBuf(BitStream,BitLen);
(unsigned int) hi,
(unsigned int) lo,
(unsigned int) (lo>>1) & 0xFFFF,
(unsigned int) fmtLen,
(unsigned int) fc,
(unsigned int) cardnum);
SetGraphBuf(BitStream,BitLen);
return 1;
}
return 0;
@ -627,24 +651,38 @@ int CmdFSKdemodHID(const char *Cmd)
//print ioprox ID and some format details
int CmdFSKdemodIO(const char *Cmd)
{
if (GraphTraceLen < 65) {
PrintAndLog("data samples size is too small");
return 0;
}
//raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults
int idx = 0;
//something in graphbuffer
if (GraphTraceLen < 65) return 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint32_t BitLen = getFromGraphBuf(BitStream);
uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
uint32_t bitlen = GetFromGraphBuf(bits);
//get binary from fsk wave
idx = IOdemodFSK(BitStream,BitLen);
if (idx<0){
//PrintAndLog("Error demoding fsk");
return 0;
}
idx = IOdemodFSK(bits, bitlen);
if (idx == 0) {
//PrintAndLog("IO Prox Data not found - FSK Data:");
//if (BitLen > 92) printBitStream(BitStream,92);
return 0;
}
if (idx == -1) {
PrintAndLog("data samples size is too small");
return 0;
}
if (idx == -2) {
PrintAndLog("Data samples has too much noice");
return 0;
}
if (idx == -3){
PrintAndLog("No good demod");
return 0;
}
if (idx+64 > bitlen) return 0;
//Index map
//0 10 20 30 40 50 60
//| | | | | | |
@ -654,23 +692,23 @@ int CmdFSKdemodIO(const char *Cmd)
//
//XSF(version)facility:codeone+codetwo (raw)
//Handle the data
if (idx+64>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+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 version",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]);
PrintAndLog("%d%d%d%d%d%d%d%d %d code1",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]);
PrintAndLog("%d%d%d%d%d%d%d%d %d code2",BitStream[idx+45], BitStream[idx+46], BitStream[idx+47],BitStream[idx+48],BitStream[idx+49],BitStream[idx+50],BitStream[idx+51],BitStream[idx+52],BitStream[idx+53]);
PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]);
uint32_t code = bytebits_to_byte(BitStream+idx,32);
uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32);
uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
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
PrintAndLog("%d%d%d%d%d%d%d%d %d", bits[idx] , bits[idx+1], bits[idx+2], bits[idx+3], bits[idx+4], bits[idx+5], bits[idx+6], bits[idx+7], bits[idx+8]);
PrintAndLog("%d%d%d%d%d%d%d%d %d", bits[idx+9] , bits[idx+10], bits[idx+11], bits[idx+12], bits[idx+13], bits[idx+14], bits[idx+15], bits[idx+16], bits[idx+17]);
PrintAndLog("%d%d%d%d%d%d%d%d %d facility", bits[idx+18], bits[idx+19], bits[idx+20], bits[idx+21], bits[idx+22], bits[idx+23], bits[idx+24], bits[idx+25], bits[idx+26]);
PrintAndLog("%d%d%d%d%d%d%d%d %d version", bits[idx+27], bits[idx+28], bits[idx+29], bits[idx+30], bits[idx+31], bits[idx+32], bits[idx+33], bits[idx+34], bits[idx+35]);
PrintAndLog("%d%d%d%d%d%d%d%d %d code1", bits[idx+36], bits[idx+37], bits[idx+38], bits[idx+39], bits[idx+40], bits[idx+41], bits[idx+42], bits[idx+43], bits[idx+44]);
PrintAndLog("%d%d%d%d%d%d%d%d %d code2", bits[idx+45], bits[idx+46], bits[idx+47], bits[idx+48], bits[idx+49], bits[idx+50], bits[idx+51], bits[idx+52], bits[idx+53]);
PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum", bits[idx+54], bits[idx+55], bits[idx+56], bits[idx+57], bits[idx+58], bits[idx+59], bits[idx+60], bits[idx+61], bits[idx+62], bits[idx+63]);
uint32_t code = bytebits_to_byte(bits+idx,32);
uint32_t code2 = bytebits_to_byte(bits+idx+32,32);
uint8_t version = bytebits_to_byte(bits+idx+27,8); //14,4
uint8_t facilitycode = bytebits_to_byte(bits+idx+18,8) ;
uint16_t number = (bytebits_to_byte(bits+idx+36,8)<<8)|(bytebits_to_byte(bits+idx+45,8)); //36,9
PrintAndLog("XSF(%02d)%02x:%05d (%08x%08x)", version, facilitycode, number, code, code2);
setGraphBuf(BitStream,BitLen);
SetGraphBuf(bits, bitlen);
return 1;
}
@ -760,8 +798,7 @@ int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
PrintAndLog("actual data bits start at sample %d", maxPos);
PrintAndLog("length %d/%d", highLen, lowLen);
uint8_t bits[46];
bits[sizeof(bits)-1] = '\0';
uint8_t bits[46] = {0x00};
// find bit pairs and manchester decode them
for (i = 0; i < arraylen(bits) - 1; ++i) {
@ -868,16 +905,17 @@ int CmdHpf(const char *Cmd)
int CmdSamples(const char *Cmd)
{
uint8_t got[36440] = {0x00};
uint8_t got[40000] = {0x00};
int n = strtol(Cmd, NULL, 0);
if (n == 0)
n = 20000;
if (n > sizeof(got))
n = sizeof(got);
PrintAndLog("Reading %d samples from device memory\n", n);
GetFromBigBuf(got,n,3560);
GetFromBigBuf(got,n,0);
WaitForResponse(CMD_ACK,NULL);
for (int j = 0; j < n; ++j) {
GraphBuffer[j] = ((int)got[j]) - 128;
@ -1034,16 +1072,10 @@ int CmdManchesterDemod(const char *Cmd)
uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};
/* Detect high and lows */
for (i = 0; i < GraphTraceLen; i++)
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
DetectHighLowInGraph( &high, &low, TRUE);
/* Get our clock */
clock = GetClock(Cmd, high, 1);
clock = GetClock(Cmd, 0);
int tolerance = clock/4;
/* Detect first transition */
@ -1201,9 +1233,7 @@ int CmdManchesterMod(const char *Cmd)
{
int i, j;
int bit, lastbit, wave;
int clock = GetClock(Cmd, 0, 1);
int clock1 = GetT55x7Clock( GraphBuffer, GraphTraceLen, 0 );
PrintAndLog("MAN MOD CLOCKS: %d ice %d", clock,clock1);
int clock = GetClock(Cmd, 0);
int half = (int)(clock/2);
@ -1373,8 +1403,8 @@ static command_t CommandTable[] =
{"help", CmdHelp, 1, "This help"},
{"amp", CmdAmp, 1, "Amplify peaks"},
{"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
{"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 or 1>] -- Attempt to demodulate ASK tags and output binary (args optional[clock will try Auto-detect])"},
{"askmandemod", Cmdaskmandemod, 1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary"},
{"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert <0|1>] -- Attempt to demodulate ASK tags and output binary"},
{"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)"},
{"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
@ -1383,6 +1413,7 @@ static command_t CommandTable[] =
{"dec", CmdDec, 1, "Decimate samples"},
{"detectaskclock",CmdDetectClockRate, 1, "Detect ASK clock rate"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"em4xdecode", CmdEm410xDecode, 1, "decode em4x from graph buffer"},
{"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
{"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"},

16
client/cmdlf.c
View file

@ -375,6 +375,8 @@ int CmdLFRead(const char *Cmd)
// load samples
CmdSamples("");
// show plot
ShowGraphWindow();
return 0;
}
@ -461,12 +463,12 @@ int CmdLFSimManchester(const char *Cmd)
int CmdLFSnoop(const char *Cmd)
{
UsbCommand c = {CMD_LF_SNOOP_RAW_ADC_SAMPLES};
// 'h' means higher-low-frequency, 134 kHz
c.arg[0] = 0;
c.arg[1] = -1;
if (*Cmd == 0) {
// empty
} else if (*Cmd == 'l') {
if (*Cmd == 'l') {
sscanf(Cmd, "l %"lli, &c.arg[1]);
} else if (*Cmd == 'h') {
c.arg[0] = 1;
@ -475,18 +477,20 @@ int CmdLFSnoop(const char *Cmd)
PrintAndLog("use 'snoop' or 'snoop {l,h} [trigger threshold]', or 'snoop <divisor> [trigger threshold]'");
return 0;
}
SendCommand(&c);
WaitForResponse(CMD_ACK,NULL);
size_t BUFF_SIZE = 8000;
uint8_t data[BUFF_SIZE];
GetFromBigBuf(data,BUFF_SIZE,3560); //3560 -- should be offset..
GetFromBigBuf(data,BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < BUFF_SIZE; j++) {
GraphBuffer[j] = ((int)data[j]);
}
GraphTraceLen = BUFF_SIZE;
return 0;
@ -575,8 +579,8 @@ int CmdLFfind(const char *Cmd)
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: lf search [use data from Graphbuffer]");
PrintAndLog(" [use data from Graphbuffer], if not set, try reading data from tag.");
PrintAndLog("Usage: lf search <0|1>");
PrintAndLog(" <use data from Graphbuffer>, if not set, try reading data from tag.");
PrintAndLog("");
PrintAndLog(" sample: lf search");
PrintAndLog(" : lf search 1");

44
client/cmdlfem4x.c
View file

@ -28,20 +28,16 @@ char *global_em410xId;
static int CmdHelp(const char *Cmd);
int CmdEMdemodASK(const char *Cmd)
{
int findone=0;
char cmdp = param_getchar(Cmd, 0);
int findone = (cmdp == '1') ? 1 : 0;
UsbCommand c = { CMD_EM410X_DEMOD };
if(Cmd[0]=='1') findone=1;
c.arg[0] = findone;
SendCommand(&c);
return 0;
}
/* Read the ID of an EM410x tag.
* Format:
* 1111 1111 1 <-- standard non-repeatable header
@ -54,29 +50,25 @@ int CmdEM410xRead(const char *Cmd)
{
int i, j, clock, header, rows, bit, hithigh, hitlow, first, bit2idx, high, low;
int parity[4];
char id[11];
char id2[11];
char id[11] = {0x00};
char id2[11] = {0x00};
int retested = 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
high = low = 0;
/* Detect high and lows and clock */
for (i = 0; i < GraphTraceLen; i++)
{
if (GraphBuffer[i] > high)
high = GraphBuffer[i];
else if (GraphBuffer[i] < low)
low = GraphBuffer[i];
}
// get clock
clock = GetClock(Cmd, 0);
/* get clock */
clock = GetClock(Cmd, high, 0);
// Detect high and lows and clock
DetectHighLowInGraph( &high, &low, TRUE);
/* parity for our 4 columns */
PrintAndLog("NUMNUM");
// parity for our 4 columns
parity[0] = parity[1] = parity[2] = parity[3] = 0;
header = rows = 0;
/* manchester demodulate */
// manchester demodulate
bit = bit2idx = 0;
for (i = 0; i < (int)(GraphTraceLen / clock); i++)
{
@ -87,9 +79,9 @@ int CmdEM410xRead(const char *Cmd)
/* Find out if we hit both high and low peaks */
for (j = 0; j < clock; j++)
{
if (GraphBuffer[(i * clock) + j] == high)
if (GraphBuffer[(i * clock) + j] >= high)
hithigh = 1;
else if (GraphBuffer[(i * clock) + j] == low)
else if (GraphBuffer[(i * clock) + j] <= low)
hitlow = 1;
/* it doesn't count if it's the first part of our read
@ -190,6 +182,7 @@ retest:
/* if we've already retested after flipping bits, return */
if (retested++){
PrintAndLog("Failed to decode");
return 0;
}
@ -290,7 +283,8 @@ int CmdEM410xSim(const char *Cmd)
*/
int CmdEM410xWatch(const char *Cmd)
{
int read_h = (*Cmd == 'h');
char cmdp = param_getchar(Cmd, 0);
int read_h = (cmdp == 'h');
do
{
if (ukbhit()) {
@ -551,7 +545,7 @@ int CmdReadWord(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560); //3560 -- should be offset..
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
@ -591,7 +585,7 @@ int CmdReadWordPWD(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560); //3560 -- should be offset..
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {

49
client/cmdlft55xx.c
View file

@ -22,7 +22,7 @@
#include "data.h"
#define LF_TRACE_BUFF_SIZE 12000 // 32 x 32 x 10 (32 bit times numofblock (7), times clock skip..)
#define LF_TRACE_BUFF_SIZE 20000 // 32 x 32 x 10 (32 bit times numofblock (7), times clock skip..)
#define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend.. 8block * 4 bytes * 8bits =
static int CmdHelp(const char *Cmd);
@ -48,7 +48,7 @@ int CmdReadBlk(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560); //3560 -- should be offset..
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
@ -85,7 +85,7 @@ int CmdReadBlkPWD(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560); //3560 -- should be offset..
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
@ -166,7 +166,7 @@ int CmdReadTrace(const char *Cmd)
uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560); //3560 -- should be offset..
GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..
WaitForResponseTimeout(CMD_ACK,NULL, 1500);
for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {
@ -254,27 +254,26 @@ int CmdInfo(const char *Cmd){
}
uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};
uint8_t * bitstream = bits;
manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);
manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);
uint8_t si = 5;
uint32_t bl0 = PackBits(si, 32, bitstream);
uint32_t bl0 = PackBits(si, 32, bits);
uint32_t safer = PackBits(si, 4, bitstream); si += 4;
uint32_t resv = PackBits(si, 7, bitstream); si += 7;
uint32_t dbr = PackBits(si, 3, bitstream); si += 3;
uint32_t extend = PackBits(si, 1, bitstream); si += 1;
uint32_t datamodulation = PackBits(si, 5, bitstream); si += 5;
uint32_t pskcf = PackBits(si, 2, bitstream); si += 2;
uint32_t aor = PackBits(si, 1, bitstream); si += 1;
uint32_t otp = PackBits(si, 1, bitstream); si += 1;
uint32_t maxblk = PackBits(si, 3, bitstream); si += 3;
uint32_t pwd = PackBits(si, 1, bitstream); si += 1;
uint32_t sst = PackBits(si, 1, bitstream); si += 1;
uint32_t fw = PackBits(si, 1, bitstream); si += 1;
uint32_t inv = PackBits(si, 1, bitstream); si += 1;
uint32_t por = PackBits(si, 1, bitstream); si += 1;
uint32_t safer = PackBits(si, 4, bits); si += 4;
uint32_t resv = PackBits(si, 7, bits); si += 7;
uint32_t dbr = PackBits(si, 3, bits); si += 3;
uint32_t extend = PackBits(si, 1, bits); si += 1;
uint32_t datamodulation = PackBits(si, 5, bits); si += 5;
uint32_t pskcf = PackBits(si, 2, bits); si += 2;
uint32_t aor = PackBits(si, 1, bits); si += 1;
uint32_t otp = PackBits(si, 1, bits); si += 1;
uint32_t maxblk = PackBits(si, 3, bits); si += 3;
uint32_t pwd = PackBits(si, 1, bits); si += 1;
uint32_t sst = PackBits(si, 1, bits); si += 1;
uint32_t fw = PackBits(si, 1, bits); si += 1;
uint32_t inv = PackBits(si, 1, bits); si += 1;
uint32_t por = PackBits(si, 1, bits); si += 1;
PrintAndLog("");
PrintAndLog("-- T55xx Configuration --------------------------------------");
@ -295,7 +294,7 @@ int CmdInfo(const char *Cmd){
PrintAndLog(" POR-Delay : %s", (por) ? "Yes":"No");
PrintAndLog("-------------------------------------------------------------");
PrintAndLog(" Raw Data - Page 0");
PrintAndLog(" Block 0 : 0x%08X %s", bl0, sprint_bin(bitstream+5,32) );
PrintAndLog(" Block 0 : 0x%08X %s", bl0, sprint_bin(bits+5,32) );
PrintAndLog("-------------------------------------------------------------");
return 0;
@ -357,8 +356,10 @@ int ManchesterDemod(int blockNum){
uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};
uint8_t * bitstream = bits;
manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);
blockData = PackBits(offset, sizebyte, bitstream);
//manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);
manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);
//blockData = PackBits(offset, sizebyte, bitstream);
blockData = PackBits(offset, sizebyte, bits);
if ( blockNum < 0)
PrintAndLog(" Decoded : 0x%08X %s", blockData, sprint_bin(bitstream+offset,sizebyte) );

168
client/graph.c
View file

@ -49,106 +49,13 @@ int ClearGraph(int redraw)
return gtl;
}
/*
* Detect clock rate
*/
//decommissioned - has difficulty detecting rf/32
/*
int DetectClockOld(int peak)
void SetGraphBuf(uint8_t *buff, int size)
{
int i;
int clock = 0xFFFF;
int lastpeak = 0;
if ( buff == NULL ) return;
// Detect peak if we don't have one
if (!peak)
for (i = 0; i < GraphTraceLen; ++i)
if (GraphBuffer[i] > peak)
peak = GraphBuffer[i];
// peak=(int)(peak*.75);
for (i = 1; i < GraphTraceLen; ++i)
{
// If this is the beginning of a peak
if (GraphBuffer[i - 1] != GraphBuffer[i] && GraphBuffer[i] >= peak)
{
// Find lowest difference between peaks
if (lastpeak && i - lastpeak < clock)
clock = i - lastpeak;
lastpeak = i;
}
}
return clock;
}
*/
/*
NOW IN LFDEMOD.C
// by marshmellow
// not perfect especially with lower clocks or VERY good antennas (heavy wave clipping)
// maybe somehow adjust peak trimming value based on samples to fix?
int DetectASKClock(int peak)
{
int i=0;
int low=0;
int clk[]={16,32,40,50,64,100,128,256};
int loopCnt = 256;
if (GraphTraceLen<loopCnt) loopCnt = GraphTraceLen;
if (!peak){
for (i=0;i<loopCnt;++i){
if(GraphBuffer[i]>peak){
peak = GraphBuffer[i];
}
if(GraphBuffer[i]<low){
low = GraphBuffer[i];
}
}
peak=(int)(peak*.75);
low= (int)(low*.75);
}
int ii;
int clkCnt;
int tol = 0;
int bestErr=1000;
int errCnt[]={0,0,0,0,0,0,0,0};
for(clkCnt=0; clkCnt<6;++clkCnt){
if (clk[clkCnt]==32){
tol=1;
}else{
tol=0;
}
bestErr=1000;
for (ii=0; ii<loopCnt; ++ii){
if ((GraphBuffer[ii]>=peak) || (GraphBuffer[ii]<=low)){
errCnt[clkCnt]=0;
for (i=0; i<((int)(GraphTraceLen/clk[clkCnt])-1); ++i){
if (GraphBuffer[ii+(i*clk[clkCnt])]>=peak || GraphBuffer[ii+(i*clk[clkCnt])]<=low){
}else if(GraphBuffer[ii+(i*clk[clkCnt])-tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])-tol]<=low){
}else if(GraphBuffer[ii+(i*clk[clkCnt])+tol]>=peak || GraphBuffer[ii+(i*clk[clkCnt])+tol]<=low){
}else{ //error no peak detected
errCnt[clkCnt]++;
}
}
if(errCnt[clkCnt]==0) return clk[clkCnt];
if(errCnt[clkCnt]<bestErr) bestErr=errCnt[clkCnt];
}
}
}
int iii=0;
int best=0;
for (iii=0; iii<6;++iii){
if (errCnt[iii]<errCnt[best]){
best = iii;
}
}
// PrintAndLog("DEBUG: clkCnt: %d, ii: %d, i: %d peak: %d, low: %d, errcnt: %d, errCnt64: %d",clkCnt,ii,i,peak,low,errCnt[best],errCnt[4]);
return clk[best];
}
*/
void setGraphBuf(uint8_t *buff,int size)
{
int i=0;
uint16_t i = 0;
if ( size > MAX_GRAPH_TRACE_LEN )
size = MAX_GRAPH_TRACE_LEN;
ClearGraph(0);
for (; i < size; ++i){
GraphBuffer[i] = buff[i];
@ -157,18 +64,28 @@ void setGraphBuf(uint8_t *buff,int size)
RepaintGraphWindow();
return;
}
int getFromGraphBuf(uint8_t *buff)
// Copies grahpbuff to buff.
// while triming values to the range -127 -- 127.
int GetFromGraphBuf(uint8_t *buff)
{
uint32_t i;
for (i=0;i<GraphTraceLen;++i){
if (GraphBuffer[i]>127) GraphBuffer[i]=127; //trim
if (GraphBuffer[i]<-127) GraphBuffer[i]=-127; //trim
if ( buff == NULL ) return -1;
uint32_t i = 0;
for (; i < GraphTraceLen; ++i){
// trim upper and lower values.
if (GraphBuffer[i] > 127)
GraphBuffer[i] = 127;
else if (GraphBuffer[i] < -127)
GraphBuffer[i] = -127;
buff[i] = (uint8_t)(GraphBuffer[i] + 128);
}
return i;
}
/* Get or auto-detect clock rate */
int GetClock(const char *str, int peak, int verbose)
int GetClock(const char *str, int verbose)
{
int clock;
@ -177,23 +94,24 @@ int GetClock(const char *str, int peak, int verbose)
clock = 0;
/* Auto-detect clock */
if (!clock)
{
uint8_t grph[MAX_GRAPH_TRACE_LEN]={0};
int size = getFromGraphBuf(grph);
if (!clock) {
uint8_t grph[MAX_GRAPH_TRACE_LEN] = {0x00};
int size = GetFromGraphBuf(grph);
if ( size < 0 ) {
PrintAndLog("Failed to copy from graphbuffer");
return -1;
}
clock = DetectASKClock(grph, size, 0);
//clock2 = DetectClock2(peak);
/* Only print this message if we're not looping something */
if (!verbose)
if (verbose)
PrintAndLog("Auto-detected clock rate: %d", clock);
}
return clock;
}
/* A simple test to see if there is any data inside Graphbuffer.
*/
// A simple test to see if there is any data inside Graphbuffer.
bool HasGraphData(){
if ( GraphTraceLen <= 0) {
@ -202,3 +120,25 @@ bool HasGraphData(){
}
return true;
}
// Detect high and lows in Grapbuffer.
// Only loops the first 256 values.
void DetectHighLowInGraph(int *high, int *low, bool addFuzz) {
uint8_t loopMax = 255;
if ( loopMax > GraphTraceLen)
loopMax = GraphTraceLen;
for (uint8_t i = 0; i < loopMax; ++i) {
if (GraphBuffer[i] > *high)
*high = GraphBuffer[i];
else if (GraphBuffer[i] < *low)
*low = GraphBuffer[i];
}
//12% fuzz in case highs and lows aren't clipped
if (addFuzz) {
*high = (int)(*high * .88);
*low = (int)(*low * .88);
}
}

8
client/graph.h
View file

@ -13,11 +13,11 @@
void AppendGraph(int redraw, int clock, int bit);
int ClearGraph(int redraw);
//int DetectClock(int peak);
int getFromGraphBuf(uint8_t *buff);
int GetClock(const char *str, int peak, int verbose);
void setGraphBuf(uint8_t *buff,int size);
int GetFromGraphBuf(uint8_t *buff);
int GetClock(const char *str, int verbose);
void SetGraphBuf(uint8_t *buff,int size);
bool HasGraphData();
void DetectHighLowInGraph(int *high, int *low, bool addFuzz);
#define MAX_GRAPH_TRACE_LEN (1024*128)
extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];

6
client/loclass/fileutils.c
View file

@ -49,8 +49,14 @@
* @return
*/
int fileExists(const char *filename) {
#ifdef _WIN32
struct _stat fileStat;
int result = _stat(filename, &fileStat);
#else
struct stat fileStat;
int result = stat(filename, &fileStat);
#endif
return result == 0;
}

2
client/proxguiqt.cpp
View file

@ -280,7 +280,7 @@ void ProxWidget::paintEvent(QPaintEvent *event)
ProxWidget::ProxWidget(QWidget *parent) : QWidget(parent), GraphStart(0), GraphPixelsPerPoint(1)
{
resize(600, 500);
resize(600, 300);
QPalette palette(QColor(0,0,0,0));
palette.setColor(QPalette::WindowText, QColor(255,255,255));

57
client/ui.c
View file

@ -20,13 +20,14 @@
#include "ui.h"
#include "cmdmain.h"
#include "cmddata.h"
#include "graph.h"
//#include <liquid/liquid.h>
#define M_PI 3.14159265358979323846264338327
double CursorScaleFactor;
int PlotGridX, PlotGridY, PlotGridXdefault= 64, PlotGridYdefault= 64;
int offline;
int flushAfterWrite = 0; //buzzy
int flushAfterWrite = 0;
extern pthread_mutex_t print_lock;
static char *logfilename = "proxmark3.log";
@ -82,8 +83,7 @@ void PrintAndLog(char *fmt, ...)
}
va_end(argptr2);
if (flushAfterWrite == 1) //buzzy
{
if (flushAfterWrite == 1) {
fflush(NULL);
}
//release lock
@ -98,29 +98,25 @@ void SetLogFilename(char *fn)
int manchester_decode( int * data, const size_t len, uint8_t * dataout, size_t dataoutlen){
int bitlength = 0;
int i, clock, high, low, startindex;
int clock, high, low, startindex;
low = startindex = 0;
high = 1;
uint8_t * bitStream = (uint8_t* ) malloc(sizeof(uint8_t) * dataoutlen);
memset(bitStream, 0x00, dataoutlen);
/* Detect high and lows */
for (i = 0; i < len; i++) {
if (data[i] > high)
high = data[i];
else if (data[i] < low)
low = data[i];
}
DetectHighLowInGraph(&high, &low, TRUE);
/* get clock */
clock = GetT55x7Clock( data, len, high );
clock = GetClock("", 0);
startindex = DetectFirstTransition(data, len, high);
//PrintAndLog(" Clock : %d", clock);
if (high != 1)
// decode "raw"
bitlength = ManchesterConvertFrom255(data, len, bitStream, dataoutlen, high, low, clock, startindex);
else
// decode manchester
bitlength = ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex);
memcpy(dataout, bitStream, bitlength);
@ -128,41 +124,6 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout, size_t
return bitlength;
}
int GetT55x7Clock( const int * data, const size_t len, int peak ){
int i,lastpeak,clock;
clock = 0xFFFF;
lastpeak = 0;
/* Detect peak if we don't have one */
if (!peak) {
for (i = 0; i < len; ++i) {
if (data[i] > peak) {
peak = data[i];
}
}
}
for (i = 1; i < len; ++i) {
/* if this is the beginning of a peak */
if ( data[i-1] != data[i] && data[i] == peak) {
/* find lowest difference between peaks */
if (lastpeak && i - lastpeak < clock)
clock = i - lastpeak;
lastpeak = i;
}
}
// When detected clock is 31 or 33 then then return
int clockmod = clock%8;
if ( clockmod == 0) return clock;
if ( clockmod == 7 ) clock += 1;
else if ( clockmod == 1 ) clock -= 1;
return clock;
}
int DetectFirstTransition(const int * data, const size_t len, int threshold){
int i = 0;

403
common/lfdemod.c
View file

@ -8,6 +8,7 @@
// Low frequency commands
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lfdemod.h"
@ -20,11 +21,12 @@ uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen)
// otherwise could be a void with no arguments
//set defaults
int high = 0, low = 128;
uint64_t lo=0; //hi=0,
uint64_t lo = 0;
uint32_t i = 0;
uint32_t initLoopMax = 65;
if (initLoopMax>BitLen) initLoopMax=BitLen;
if (initLoopMax > BitLen)
initLoopMax = BitLen;
for (; i < initLoopMax; ++i) //65 samples should be plenty to find high and low values
{
@ -33,35 +35,36 @@ uint64_t Em410xDecode(uint8_t *BitStream,uint32_t BitLen)
else if (BitStream[i] < low)
low = BitStream[i];
}
if (((high !=1)||(low !=0))){ //allow only 1s and 0s
// PrintAndLog("no data found");
return 0;
}
uint8_t parityTest = 0;
// 111111111 bit pattern represent start of frame
uint8_t frame_marker_mask[] = {1,1,1,1,1,1,1,1,1};
uint32_t idx = 0;
uint32_t ii=0;
uint32_t j = 0;
uint8_t resetCnt = 0;
while( (idx + 64) < BitLen) {
restart:
// search for a start of frame marker
if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ // frame marker found
if ( memcmp(BitStream+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0) {
// frame marker found
idx += 9;//sizeof(frame_marker_mask);
for (i=0; i<10;i++){
for(ii=0; ii<5; ++ii){
parityTest += BitStream[(i*5)+ii+idx];
for ( i = 0; i < 10; ++i){
for( j = 0; j < 5; ++j){
parityTest += BitStream[(i*5) + j + idx];
}
if (parityTest == ( (parityTest >> 1) << 1)){
parityTest = 0;
for (ii=0; ii<4;++ii){
//hi = (hi<<1)|(lo>>31);
lo=(lo<<1LL)|(BitStream[(i*5)+ii+idx]);
for (j = 0; j < 4; ++j){
lo = ( lo << 1LL)|( BitStream[( i * 5 ) + j + idx]);
}
//PrintAndLog("DEBUG: EM parity passed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d,lo: %d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1],lo);
}else {//parity failed
//PrintAndLog("DEBUG: EM parity failed parity val: %d, i:%d, ii:%d,idx:%d, Buffer: %d%d%d%d%d",parityTest,i,ii,idx,BitStream[idx+ii+(i*5)-5],BitStream[idx+ii+(i*5)-4],BitStream[idx+ii+(i*5)-3],BitStream[idx+ii+(i*5)-2],BitStream[idx+ii+(i*5)-1]);
} else {
//parity failed
parityTest = 0;
idx -= 8;
if (resetCnt > 5) return 0;
@ -93,43 +96,52 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
if (*invert != 1) *invert = 0;
uint32_t initLoopMax = 200;
if (initLoopMax>*BitLen) initLoopMax=*BitLen;
if (initLoopMax > *BitLen)
initLoopMax = *BitLen;
// Detect high and lows
for (i = 0; i < initLoopMax; ++i) //200 samples should be enough to find high and low values
{
// 200 samples should be enough to find high and low values
for (i = 0; i < initLoopMax; ++i) {
if (BinStream[i] > high)
high = BinStream[i];
else if (BinStream[i] < low)
low = BinStream[i];
}
if ((high < 158) ){ //throw away static
return -2;
}
//25% fuzz in case highs and lows aren't clipped [marshmellow]
high=(int)((high-128)*.75)+128;
low= (int)((low-128)*.75)+128;
//PrintAndLog("DEBUG - valid high: %d - valid low: %d",high,low);
//throw away static
if ((high < 158) )
return -2;
//25% fuzz in case highs and lows aren't clipped [marshmellow]
high = (int)(high * .75);
low = (int)(low+128 * .25);
int lastBit = 0; // set first clock check
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
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;
// clock tolerance adjust - waves will be accepted as within the clock if they fall + or - this value + clock from last valid wave
//clock tolerance may not be needed anymore currently set to + or - 1 but could be increased for poor waves or removed entirely
int tol = ( *clk == 32 ) ? 1 : 0;
int j = 0;
uint32_t gLen = *BitLen;
if (gLen > 3000) gLen = 3000;
uint8_t errCnt = 0;
uint32_t bestStart = *BitLen;
uint32_t bestErrCnt = (*BitLen/1000);
uint32_t maxErr = (*BitLen/1000);
uint32_t maxErr = bestErrCnt;
//loop to find first wave that works
for (iii=0; iii < gLen; ++iii){
if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
lastBit=iii-*clk;
for (j=0; j < gLen; ++j){
if ((BinStream[j] >= high)||(BinStream[j] <= low)){
lastBit = j - *clk;
errCnt = 0;
//loop through to see if this start location works
for (i = iii; i < *BitLen; ++i) {
for (i = j; i < *BitLen; ++i) {
if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
lastBit += *clk;
} else if ((BinStream[i] <= low) && ((i-lastBit)>(*clk-tol))){
@ -142,32 +154,32 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
errCnt++;
lastBit += *clk;//skip over until hit too many errors
if (errCnt>(maxErr)) break; //allow 1 error for every 1000 samples else start over
if (errCnt > maxErr) break; //allow 1 error for every 1000 samples else start over
}
}
if ((i-iii) >(400 * *clk)) break; //got plenty of bits
if ((i-j) >(400 * *clk)) break; //got plenty of bits
}
//we got more than 64 good bits and not all errors
if ((((i-iii)/ *clk) > (64+errCnt)) && (errCnt<maxErr)) {
if ((((i-j)/ *clk) > (64 + errCnt)) && (errCnt < maxErr)) {
//possible good read
if (errCnt == 0){
bestStart=iii;
bestStart = j;
bestErrCnt = errCnt;
break; //great read - finish
}
if (errCnt < bestErrCnt){ //set this as new best run
bestErrCnt = errCnt;
bestStart = iii;
bestStart = j;
}
}
}
}
if (bestErrCnt < maxErr){
//best run is good enough set to best run and set overwrite BinStream
iii=bestStart;
j = bestStart;
lastBit = bestStart - *clk;
bitnum = 0;
for (i = iii; i < *BitLen; ++i) {
for (i = j; i < *BitLen; ++i) {
if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
lastBit += *clk;
BinStream[bitnum] = *invert;
@ -181,12 +193,10 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
//mid value found or no bar supposed to be here
if ((i-lastBit) > (*clk+tol)){
//should have hit a high or low based on clock!!
if (bitnum > 0){
BinStream[bitnum] = 77;
bitnum++;
}
lastBit += *clk;//skip over error
}
}
@ -195,7 +205,7 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
*BitLen = bitnum;
} else {
*invert = bestStart;
*clk=iii;
*clk = j;
return -1;
}
return bestErrCnt;
@ -204,19 +214,20 @@ int askmandemod(uint8_t * BinStream,uint32_t *BitLen,int *clk, int *invert)
//by marshmellow
//take 10 and 01 and manchester decode
//run through 2 times and take least errCnt
int manrawdecode(uint8_t * BitStream, int *bitLen)
int manrawdecode(uint8_t * bits, int *bitlen)
{
int bitnum = 0;
int errCnt = 0;
int i=1;
int bestErr = 1000;
int bestRun = 0;
int ii=1;
for (ii=1;ii<3;++ii){
int i = 1;
int j = 1;
for (; j < 3; ++j){
i = 1;
for (i=i+ii;i<*bitLen-2;i+=2){
if(BitStream[i]==1 && (BitStream[i+1]==0)){
} else if((BitStream[i]==0)&& BitStream[i+1]==1){
for ( i = i + j; i < *bitlen-2; i += 2){
if ( bits[i]==1 && (bits[i+1]==0)){
} else if ((bits[i]==0)&& bits[i+1]==1){
} else {
errCnt++;
}
@ -224,26 +235,25 @@ int manrawdecode(uint8_t * BitStream, int *bitLen)
}
if (bestErr > errCnt){
bestErr = errCnt;
bestRun=ii;
bestRun = j;
}
errCnt = 0;
}
errCnt = bestErr;
if (errCnt < 20){
ii=bestRun;
j = bestRun;
i = 1;
for (i=i+ii;i<*bitLen-2;i+=2){
if(BitStream[i]==1 && (BitStream[i+1]==0)){
BitStream[bitnum++]=0;
} else if((BitStream[i]==0)&& BitStream[i+1]==1){
BitStream[bitnum++]=1;
for ( i = i+j; i < *bitlen-2; i += 2){
if ( bits[i] == 1 && bits[i + 1] == 0 ){
bits[bitnum++] = 0;
} else if ( bits[i] == 0 && bits[i + 1] == 1 ){
bits[bitnum++] = 1;
} else {
BitStream[bitnum++]=77;
//errCnt++;
bits[bitnum++] = 77;
}
if ( bitnum > 300 ) break;
}
*bitLen=bitnum;
*bitlen = bitnum;
}
return errCnt;
}
@ -251,24 +261,26 @@ int manrawdecode(uint8_t * BitStream, int *bitLen)
//by marshmellow
//take 01 or 10 = 0 and 11 or 00 = 1
int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset)
int BiphaseRawDecode(uint8_t * bits, int *bitlen, int offset)
{
uint8_t bitnum = 0;
uint32_t errCnt = 0;
uint32_t i = 1;
i=offset;
for (;i<*bitLen-2;i+=2){
if((BitStream[i]==1 && BitStream[i+1]==0)||(BitStream[i]==0 && BitStream[i+1]==1)){
BitStream[bitnum++]=1;
} else if((BitStream[i]==0 && BitStream[i+1]==0)||(BitStream[i]==1 && BitStream[i+1]==1)){
BitStream[bitnum++]=0;
uint32_t i = offset;
for (; i < *bitlen-2; i += 2 ){
if ( (bits[i]==1 && bits[i+1]==0)||
(bits[i]==0 && bits[i+1]==1)){
bits[bitnum++] = 1;
} else if ( (bits[i]==0 && bits[i+1]==0)||
(bits[i]==1 && bits[i+1]==1)){
bits[bitnum++] = 0;
} else {
BitStream[bitnum++]=77;
bits[bitnum++] = 77;
errCnt++;
}
if ( bitnum > 250) break;
}
*bitLen=bitnum;
*bitlen = bitnum;
return errCnt;
}
@ -279,17 +291,19 @@ int BiphaseRawDecode(uint8_t * BitStream, int *bitLen, int offset)
int askrawdemod(uint8_t *BinStream, int *bitLen, int *clk, int *invert)
{
uint32_t i;
// int invert=0; //invert default
uint32_t initLoopMax = 200;
int high = 0, low = 128;
uint8_t BitStream[502] = {0x00};
*clk = DetectASKClock(BinStream, *bitLen, *clk); //clock default
uint8_t BitStream[502] = {0};
if (*clk < 8) *clk = 64;
if (*clk < 32) *clk = 32;
if (*invert != 1) *invert = 0;
uint32_t initLoopMax = 200;
if (initLoopMax>*bitLen) initLoopMax=*bitLen;
if (initLoopMax > *bitLen)
initLoopMax = *bitLen;
// Detect high and lows
for (i = 0; i < initLoopMax; ++i) //200 samples should be plenty to find high and low values
{
@ -298,31 +312,39 @@ int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
else if (BinStream[i] < low)
low = BinStream[i];
}
if ((high < 158)){ //throw away static
//throw away static
if ((high < 158)){
return -2;
}
//25% fuzz in case highs and lows aren't clipped [marshmellow]
high=(int)((high-128)*.75)+128;
low= (int)((low-128)*.75)+128;
high = (int)(high * .75);
low = (int)(low+128 * .25);
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 = 1; //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;
uint32_t gLen = *bitLen;
if (gLen > 500) gLen = 500;
uint32_t j = 0;
uint8_t errCnt = 0;
uint32_t bestStart = *bitLen;
uint32_t bestErrCnt = (*bitLen / 1000);
uint32_t errCntLimit = bestErrCnt;
uint8_t midBit = 0;
//loop to find first wave that works
for (iii=0; iii < gLen; ++iii){
if ((BinStream[iii]>=high)||(BinStream[iii]<=low)){
lastBit=iii-*clk;
for (j = 0; j < gLen; ++j){
if ((BinStream[j] >= high)||(BinStream[j] <= low)){
lastBit = j - *clk;
//loop through to see if this start location works
for (i = iii; i < *bitLen; ++i) {
for (i = j; i < *bitLen; ++i) {
if ((BinStream[i] >= high) && ((i-lastBit)>(*clk-tol))){
lastBit += *clk;
BitStream[bitnum] = *invert;
@ -362,7 +384,7 @@ int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
errCnt++;
lastBit += *clk;//skip over until hit too many errors
if (errCnt>((*bitLen/1000))){ //allow 1 error for every 1000 samples else start over
if (errCnt > errCntLimit){ //allow 1 error for every 1000 samples else start over
errCnt = 0;
bitnum = 0;//start over
break;
@ -372,19 +394,26 @@ int askrawdemod(uint8_t *BinStream, int *bitLen,int *clk, int *invert)
if (bitnum > 500) break;
}
//we got more than 64 good bits and not all errors
if ((bitnum > (64+errCnt)) && (errCnt<(*bitLen/1000))) {
//possible good read
if (errCnt==0) 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
if ((bitnum > (64 + errCnt)) && (errCnt < errCntLimit)) {
//great read - finish
if (errCnt == 0) break;
//if current run == bestErrCnt run (after exhausted testing) then finish
if (bestStart == j) break;
//set this as new best run
if (errCnt < bestErrCnt){
bestErrCnt = errCnt;
bestStart = iii;
bestStart = j;
}
}
}
if (iii>=gLen){ //exhausted test
if (j >= gLen){ //exhausted test
//if there was a ok test go back to that one and re-run the best run (then dump after that run)
if (bestErrCnt < (*bitLen/1000)) iii=bestStart;
if (bestErrCnt < errCntLimit)
j = bestStart;
}
}
if (bitnum > 16){
@ -404,36 +433,42 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
uint32_t last_transition = 0;
uint32_t idx = 1;
uint32_t maxVal = 0;
if (fchigh == 0) fchigh = 10;
if (fclow == 0) fclow = 8;
// we do care about the actual theshold value as sometimes near the center of the
// wave we may get static that changes direction of wave for one value
// if our value is too low it might affect the read. and if our tag or
// antenna is weak a setting too high might not see anything. [marshmellow]
if (size<100) return 0;
if ( size < 100)
return 0;
// Find high from first 100 samples
for ( idx = 1; idx < 100; idx++ ){
if(maxVal<dest[idx]) maxVal = dest[idx];
if ( maxVal < dest[idx])
maxVal = dest[idx];
}
// set close to the top of the wave threshold with 25% margin for error
// less likely to get a false transition up there.
// (but have to be careful not to go too high and miss some short waves)
uint8_t threshold_value = (uint8_t)(((maxVal-128)*.75)+128);
uint8_t threshold_value = (uint8_t)(maxVal * .75);
// sync to first lo-hi transition, and threshold
// Need to threshold first sample
if(dest[0] < threshold_value) dest[0] = 0;
else dest[0] = 1;
dest[0] = (dest[0] < threshold_value) ? 0 : 1;
size_t numBits = 0;
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
for(idx = 1; idx < size; idx++) {
// threshold current value
if (dest[idx] < threshold_value) dest[idx] = 0;
else dest[idx] = 1;
// threshold current value
dest[idx] = (dest[idx] < threshold_value) ? 0 : 1;
// Check for 0->1 transition
if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition
@ -448,7 +483,8 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
numBits++;
}
}
return numBits; //Actually, it returns the number of bytes, but each byte represents a bit: 1 or 0
//it returns the number of bytes, but each byte represents a bit: 1 or 0
return numBits;
}
uint32_t myround2(float f)
@ -458,12 +494,12 @@ uint32_t myround2(float f)
}
//translate 11111100000 to 10
size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t rfLen, uint8_t maxConsequtiveBits, uint8_t invert,uint8_t fchigh,uint8_t fclow )// uint8_t h2l_crossing_value,uint8_t l2h_crossing_value,
size_t aggregate_bits(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t maxConsequtiveBits, uint8_t invert, uint8_t fchigh, uint8_t fclow )
{
uint8_t lastval = dest[0];
uint32_t idx = 0;
size_t numBits=0;
uint32_t n = 1;
size_t numBits = 0;
for( idx = 1; idx < size; idx++) {
@ -474,10 +510,8 @@ size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t rfLen, uint8_t maxCons
//if lastval was 1, we have a 1->0 crossing
if ( dest[idx-1] == 1 ) {
n = myround2( (float)( n + 1 ) / ((float)(rfLen)/(float)fclow));
//n=(n+1) / h2l_crossing_value;
} else { // 0->1 crossing
n = myround2( (float)( n + 1 ) / ((float)(rfLen-2)/(float)fchigh)); //-2 for fudge factor
//n=(n+1) / l2h_crossing_value;
}
if (n == 0) n = 1;
@ -495,34 +529,41 @@ size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t rfLen, uint8_t maxCons
}//end for
return numBits;
}
//by marshmellow (from holiman's base)
// full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod)
int fskdemod(uint8_t *dest, size_t size, uint8_t rfLen, uint8_t invert, uint8_t fchigh, uint8_t fclow)
{
// FSK demodulator
size = fsk_wave_demod(dest, size, fchigh, fclow);
if ( size > 0 )
size = aggregate_bits(dest, size, rfLen, 192, invert, fchigh, fclow);
else
return -1;
return size;
}
// 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)
{
size_t idx = 0;
int numshifts = 0;
size_t idx=0; //, found=0; //size=0,
// FSK demodulator
size = fskdemod(dest, size, 50, 0, 10, 8);
// 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
uint8_t frame_marker_mask[] = {1,1,1,0,0,0};
int numshifts = 0;
idx = 0;
uint8_t mask_len = sizeof frame_marker_mask / sizeof frame_marker_mask[0];
//one scan
while( idx + sizeof(frame_marker_mask) < size) {
while( idx + mask_len < size) {
// search for a start of frame marker
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ // frame marker found
idx+=sizeof(frame_marker_mask);
idx += mask_len;
while(dest[idx] != dest[idx+1] && idx < size-2)
{
// Keep going until next frame marker (or error)
@ -538,7 +579,7 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
idx += 2;
}
// Hopefully, we read a tag and hit upon the next frame marker
if(idx + sizeof(frame_marker_mask) < size)
if(idx + mask_len < size)
{
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{
@ -558,8 +599,10 @@ int HIDdemodFSK(uint8_t *dest, size_t size, uint32_t *hi2, uint32_t *hi, uint32_
uint32_t bytebits_to_byte(uint8_t *src, int numbits)
{
//HACK: potential overflow in numbits is larger then uint32 bits.
uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++) {
for(int i = 0 ; i < numbits ; ++i) {
num = (num << 1) | (*src);
src++;
}
@ -568,20 +611,27 @@ uint32_t bytebits_to_byte(uint8_t* src, int numbits)
int IOdemodFSK(uint8_t *dest, size_t size)
{
uint32_t idx=0;
//make sure buffer has data
if (size < 66) return -1;
//test samples are not just noise
if (size < 100) return -1;
uint32_t idx = 0;
uint8_t testMax = 0;
for(idx=0;idx<65;idx++){
if (testMax<dest[idx]) testMax=dest[idx];
//test samples are not just noise
for (; idx < 65; ++idx ){
if (testMax < dest[idx])
testMax = dest[idx];
}
idx=0;
//if not just noise
if (testMax>170){
if (testMax < 170) return -2;
// FSK demodulator
size = fskdemod(dest, size, 64, 1, 10, 8); // RF/64 and invert
if (size < 65) return -1; //did we get a good demod?
//did we get a good demod?
if (size < 65) return -3;
//Index map
//0 10 20 30 40 50 60
//| | | | | | |
@ -591,18 +641,24 @@ int IOdemodFSK(uint8_t *dest, size_t size)
//
//XSF(version)facility:codeone+codetwo
//Handle the data
uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
for( idx=0; idx < (size - 65); idx++) {
for( idx = 0; idx < (size - 65); ++idx) {
if ( memcmp(dest + idx, mask, sizeof(mask))==0) {
//frame marker found
if (!dest[idx+8] && dest[idx+17]==1 && dest[idx+26]==1 && dest[idx+35]==1 && dest[idx+44]==1 && dest[idx+53]==1){
if (!dest[idx+8] &&
dest[idx+17] == 1 &&
dest[idx+26] == 1 &&
dest[idx+35] == 1 &&
dest[idx+44] == 1 &&
dest[idx+53] == 1){
//confirmed proper separator bits found
//return start position
return (int) idx;
}
}
}
}
return 0;
}
@ -612,66 +668,85 @@ int IOdemodFSK(uint8_t *dest, size_t size)
int DetectASKClock(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 = 256; //don't need to loop through entire array...
if (size<loopCnt) loopCnt = size;
uint8_t clkLen = sizeof clk / sizeof clk[0];
//if we already have a valid clock quit
for (;i<8;++i)
if (clk[i]==clock) return clock;
for (; i < clkLen; ++i)
if (clk[i] == clock)
return clock;
int peak = 0;
int low = 128;
int loopCnt = 256;
if (size < loopCnt)
loopCnt = size;
//get high and low peak
for ( i = 0; i < loopCnt; ++i ){
if(dest[i]>peak){
if(dest[i] > peak)
peak = dest[i];
}
if(dest[i]<low){
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};
peak = (int)(peak * .75);
low = (int)(low+128 * .25);
int ii, cnt, bestErr, tol = 0;
int errCnt[clkLen];
memset(errCnt, 0x00, clkLen);
int tmpIndex, tmphigh, tmplow;
//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;
}
for( cnt = 0; cnt < clkLen; ++cnt ){
tol = (clk[cnt] == 32) ? 1 : 0;
bestErr = 1000;
tmpIndex = tmphigh = tmplow = 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[clkCnt]=0;
// not a peak? continue
if ( (dest[ii] < peak) && (dest[ii] > low))
continue;
errCnt[cnt] = 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){
}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
errCnt[clkCnt]++;
for ( i = 0; i < ((int)(size / clk[cnt]) - 1); ++i){
tmpIndex = ii + (i * clk[cnt] );
tmplow = dest[ tmpIndex - tol];
tmphigh = dest[ tmpIndex + tol];
if ( dest[tmpIndex] >= peak || dest[tmpIndex] <= low ) {
}
else if ( tmplow >= peak || tmplow <= low){
}
else if ( tmphigh >= peak || tmphigh <= low){
}
else
errCnt[cnt]++; //error no peak detected
}
//if we found no errors this is correct one - return this clock
if(errCnt[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 ( errCnt[cnt] == 0 )
return clk[cnt];
if ( errCnt[cnt] < bestErr)
bestErr = errCnt[cnt];
}
// save the least error.
errCnt[cnt] = bestErr;
}
// find best clock which has lowest number of errors
int j = 0, bestIndex = 0;
for (; j < clkLen; ++j){
if ( errCnt[j] < errCnt[bestIndex] )
bestIndex = j;
}
int iii=0;
int best=0;
for (iii=0; iii<6;++iii){
if (errCnt[iii]<errCnt[best]){
best = iii;
}
}
return clk[best];
return clk[bestIndex];
}