X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/a8fd088d8b142520fbb686b315df7216a81d481f..e0a241f76ed8aea5f23745fb3775c6916406aea4:/common/lfdemod.c diff --git a/common/lfdemod.c b/common/lfdemod.c index 439699c6..cdbe2c6f 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -11,23 +11,29 @@ //un_comment to allow debug print calls when used not on device void dummy(char *fmt, ...){} - +void dummy_sgc (int clock, int startidx) {} #ifndef ON_DEVICE -# include "ui.h" +# include "ui.h" // plotclock, plotclockstartindex # include "cmdparser.h" # include "cmddata.h" # define prnt PrintAndLog +# define sgc SetGraphClock +void SetGraphClock(int clock, int startidx){ + PlotClock = clock; + PlockClockStartIndex = startidx; +} #else - uint8_t g_debugMode=0; + uint8_t g_debugMode = 0; # define prnt dummy +# define sgc dummy_sgc #endif //test samples are not just noise uint8_t justNoise(uint8_t *bits, size_t size) { #define THRESHOLD 123 uint8_t val = 1; - for(size_t idx=0; idx < size && val ;idx++) + for(size_t idx = 0; idx < size && val; idx++) val = bits[idx] < THRESHOLD; return val; } @@ -206,6 +212,7 @@ size_t findModStart(uint8_t dest[], size_t size, uint8_t threshold_value, uint8_ int Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) { // sanity check + if (*size < 64) return -3; if (BitStream[1] > 1) return -1; uint8_t fmtlen; @@ -214,11 +221,13 @@ int Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *h // preamble 0111111111 // include 0 in front to help get start pos uint8_t preamble[] = {0,1,1,1,1,1,1,1,1,1}; - if (!preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx)) + if (!preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx)) return -2; - if (*size < 64) return -3; + + //XL and normal size. + if (*size != 64 && *size != 128) return -3; - fmtlen = (*size == 110) ? 22 : 10; + fmtlen = (*size == 128) ? 22 : 10; //skip last 4bit parity row for simplicity *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, fmtlen * 5); @@ -243,6 +252,7 @@ int Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *h //by marshmellow //demodulates strong heavily clipped samples +//RETURN: num of errors. if 0, is ok. int cleanAskRawDemod(uint8_t *BinStream, size_t *size, int clk, int invert, int high, int low) { size_t bitCnt=0, smplCnt=0, errCnt=0; @@ -314,12 +324,13 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr { if (*size==0) return -1; int start = DetectASKClock(BinStream, *size, clk, maxErr); //clock default - if (*clk==0 || start < 0) return -3; if (*invert != 1) *invert = 0; if (amp==1) askAmp(BinStream, *size); if (g_debugMode==2) prnt("DEBUG ASK: clk %d, beststart %d, amp %d", *clk, start, amp); + sgc(*clk, start); + uint8_t initLoopMax = 255; if (initLoopMax > *size) initLoopMax = *size; // Detect high and lows @@ -386,25 +397,30 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr //by marshmellow //take 10 and 01 and manchester decode //run through 2 times and take least errCnt -int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert){ +int manrawdecode(uint8_t *BitStream, size_t *size, uint8_t invert){ + + // sanity check + if (*size < 16) return -1; + int errCnt = 0, bestErr = 1000; uint16_t bitnum = 0, MaxBits = 512, bestRun = 0; size_t i, k; - if (*size < 16) return -1; + //find correct start position [alignment] - for (k=0; k < 2; ++k){ - for (i=k; i<*size-3; i += 2) + for (k = 0; k < 2; ++k){ + for (i = k; i < *size-3; i += 2) { if (BitStream[i] == BitStream[i+1]) errCnt++; - + } if (bestErr > errCnt){ bestErr = errCnt; bestRun = k; } - errCnt=0; + errCnt = 0; } + //decode - for (i=bestRun; i < *size-3; i += 2){ + for (i = bestRun; i < *size-3; i += 2){ if (BitStream[i] == 1 && (BitStream[i+1] == 0)){ BitStream[bitnum++] = invert; } else if ((BitStream[i] == 0) && BitStream[i+1] == 1){ @@ -412,9 +428,9 @@ int manrawdecode(uint8_t * BitStream, size_t *size, uint8_t invert){ } else { BitStream[bitnum++] = 7; } - if (bitnum>MaxBits) break; + if (bitnum > MaxBits) break; } - *size=bitnum; + *size = bitnum; return bestErr; } @@ -897,13 +913,14 @@ uint8_t DetectCleanAskWave(uint8_t dest[], size_t size, uint8_t high, uint8_t lo // by marshmellow // to help detect clocks on heavily clipped samples // based on count of low to low -int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) +int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low, int *clock) { - uint8_t fndClk[] = {8,16,32,40,50,64,128}; + uint8_t clocks[] = {8,16,32,40,50,64,128}; size_t startwave; size_t i = 100; size_t minClk = 255; - // get to first full low to prime loop and skip incomplete first pulse + int shortestWaveIdx = 0; + // get to first full low to prime loop and skip incomplete first pulse while ((dest[i] < high) && (i < size)) ++i; while ((dest[i] > low) && (i < size)) @@ -920,14 +937,17 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) while ((dest[i] > low) && (i < size)) ++i; //get minimum measured distance - if (i-startwave < minClk && i < size) + if (i-startwave < minClk && i < size) { minClk = i - startwave; + shortestWaveIdx = startwave; + } } // set clock if (g_debugMode==2) prnt("DEBUG ASK: detectstrongASKclk smallest wave: %d",minClk); for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { - if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) - return fndClk[clkCnt]; + if (minClk >= clocks[clkCnt]-(clocks[clkCnt]/8) && minClk <= clocks[clkCnt]+1) + *clock = clocks[clkCnt]; + return shortestWaveIdx; } return 0; } @@ -938,15 +958,15 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) // return start index of best starting position for that clock and return clock (by reference) int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) { - size_t i=1; + size_t i = 1; uint8_t clk[] = {255,8,16,32,40,50,64,100,128,255}; uint8_t clkEnd = 9; uint8_t loopCnt = 255; //don't need to loop through entire array... - if (size <= loopCnt+60) return -1; //not enough samples + if (size <= loopCnt + 60) return -1; //not enough samples size -= 60; //sometimes there is a strange end wave - filter out this.... //if we already have a valid clock - uint8_t clockFnd=0; - for (;i0; i--){ - if (clk[i] == ans) { - *clock = ans; - //clockFnd = i; - return 0; // for strong waves i don't use the 'best start position' yet... - //break; //clock found but continue to find best startpos [not yet] - } + int ans = DetectStrongAskClock(dest, size, peak, low, clock); + if (g_debugMode==2) prnt("DEBUG ASK: detectaskclk Clean Ask Wave Detected: clk %i, ShortestWave: %i", clock ,ans); + if (ans > 0){ + return ans; // return shortest wave start pos } } } @@ -976,15 +991,15 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) size_t errCnt = 0; size_t arrLoc, loopEnd; - if (clockFnd>0) { + if (clockFnd > 0) { clkCnt = clockFnd; clkEnd = clockFnd+1; } else { - clkCnt=1; + clkCnt = 1; } //test each valid clock from smallest to greatest to see which lines up - for(; clkCnt < clkEnd; clkCnt++) { + for (; clkCnt < clkEnd; clkCnt++) { if (clk[clkCnt] <= 32) { tol=1; } else { @@ -1039,35 +1054,42 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d", clk[k], bestErr[k], clk[best], bestStart[best]); } if (!clockFnd) *clock = clk[best]; + return bestStart[best]; } +int DetectPSKClock(uint8_t dest[], size_t size, int clock) { + int firstPhaseShift = 0; + return DetectPSKClock_ext(dest, size, clock, &firstPhaseShift); +} + //by marshmellow //detect psk clock by reading each phase shift // a phase shift is determined by measuring the sample length of each wave -int DetectPSKClock(uint8_t dest[], size_t size, int clock) -{ - uint8_t clk[]={255,16,32,40,50,64,100,128,255}; //255 is not a valid clock +int DetectPSKClock_ext(uint8_t dest[], size_t size, int clock, int *firstPhaseShift) { + uint8_t clk[] = {255,16,32,40,50,64,100,128,255}; //255 is not a valid clock uint16_t loopCnt = 4096; //don't need to loop through entire array... - if (size == 0) return 0; - if (size= dest[i+2]){ if (waveStart == 0) { waveStart = i+1; @@ -1085,10 +1107,11 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) } } } - if (g_debugMode ==2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); + *firstPhaseShift = firstFullWave; + if (g_debugMode == 2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); //test each valid clock from greatest to smallest to see which lines up - for(clkCnt=7; clkCnt >= 1 ; clkCnt--){ + for (clkCnt=7; clkCnt >= 1 ; clkCnt--){ lastClkBit = firstFullWave; //set end of wave as clock align waveStart = 0; errCnt=0; @@ -1122,19 +1145,17 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) } } } - if (errCnt == 0){ - return clk[clkCnt]; - } - if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt]=errCnt; - if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt]=peakcnt; + if (errCnt == 0) return clk[clkCnt]; + if (errCnt <= bestErr[clkCnt]) bestErr[clkCnt] = errCnt; + if (peakcnt > peaksdet[clkCnt]) peaksdet[clkCnt] = peakcnt; } //all tested with errors //return the highest clk with the most peaks found - uint8_t best=7; - for (i=7; i>=1; i--){ - if (peaksdet[i] > peaksdet[best]) { + uint8_t best = 7; + for (i=7; i >= 1; i--){ + if (peaksdet[i] > peaksdet[best]) best = i; - } + if (g_debugMode == 2) prnt("DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[i],peaksdet[i],bestErr[i],clk[best]); } return clk[best]; @@ -1169,18 +1190,25 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){ return lowestTransition; } +int DetectNRZClock(uint8_t dest[], size_t size, int clock) { + int bestStart = 0; + return DetectNRZClock_ext(dest, size, clock, &bestStart); +} + //by marshmellow //detect nrz clock by reading #peaks vs no peaks(or errors) -int DetectNRZClock(uint8_t dest[], size_t size, int clock) -{ - size_t i=0; - uint8_t clk[]={8,16,32,40,50,64,100,128,255}; +int DetectNRZClock_ext(uint8_t dest[], size_t size, int clock, int *clockStartIdx) { + size_t i = 0; + uint8_t clk[] = {8,16,32,40,50,64,100,128,255}; size_t loopCnt = 4096; //don't need to loop through entire array... - if (size == 0) return 0; - if (size 6 ){ if (maxPeak > smplCnt){ maxPeak = smplCnt; @@ -1209,7 +1237,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) } peakcnt++; //prnt("maxPk: %d, smplCnt: %d, peakcnt: %d",maxPeak,smplCnt,peakcnt); - smplCnt=0; + smplCnt = 0; } } } @@ -1219,7 +1247,8 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) uint8_t ignoreWindow = 4; bool lastPeakHigh = 0; int lastBit = 0; - peakcnt=0; + int bestStart[] = {0,0,0,0,0,0,0,0,0}; + peakcnt = 0; //test each valid clock from smallest to greatest to see which lines up for(clkCnt=0; clkCnt < 8; ++clkCnt){ //ignore clocks smaller than smallest peak @@ -1239,7 +1268,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) if (dest[i] >= peak || dest[i] <= low) { //if same peak don't count it if ((dest[i] >= peak && !lastPeakHigh) || (dest[i] <= low && lastPeakHigh)) { - peakcnt++; + peakcnt++; } lastPeakHigh = (dest[i] >= peak); bitHigh = true; @@ -1251,9 +1280,10 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) } //else if not a clock bit and no peaks } else if (dest[i] < peak && dest[i] > low){ - if (ignoreCnt==0){ + if (ignoreCnt == 0){ bitHigh=false; - if (errBitHigh==true) peakcnt--; + if (errBitHigh==true) + peakcnt--; errBitHigh=false; } else { ignoreCnt--; @@ -1264,25 +1294,26 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) errBitHigh=true; } } - if(peakcnt>peaksdet[clkCnt]) { - peaksdet[clkCnt]=peakcnt; + if (peakcnt > peaksdet[clkCnt]) { + bestStart[clkCnt]=ii; + peaksdet[clkCnt] = peakcnt; } } } } - int iii=7; - uint8_t best=0; - for (iii=7; iii > 0; iii--){ - if ((peaksdet[iii] >= (peaksdet[best]-1)) && (peaksdet[iii] <= peaksdet[best]+1) && lowestTransition) { - if (clk[iii] > (lowestTransition - (clk[iii]/8)) && clk[iii] < (lowestTransition + (clk[iii]/8))) { - best = iii; - } - } else if (peaksdet[iii] > peaksdet[best]){ - best = iii; + + uint8_t best = 0; + for (int m = 7; m > 0; m--){ + if ((peaksdet[m] >= (peaksdet[best]-1)) && (peaksdet[m] <= peaksdet[best]+1) && lowestTransition) { + if (clk[m] > (lowestTransition - (clk[m]/8)) && clk[m] < (lowestTransition + (clk[m]/8))) { + best = m; + } + } else if (peaksdet[m] > peaksdet[best]){ + best = m; } - if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition); + if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d", clk[m], peaksdet[m], maxPeak, clk[best], lowestTransition); } - + *clockStartIdx = bestStart[best]; return clk[best]; } @@ -1371,10 +1402,14 @@ int nrzRawDemod(uint8_t *dest, size_t *size, int *clk, int *invert){ return 0; } +uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) { + int firstClockEdge = 0; + return detectFSKClk_ext(BitStream, size, fcHigh, fcLow, &firstClockEdge); +} + //by marshmellow //detects the bit clock for FSK given the high and low Field Clocks -uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow) -{ +uint8_t detectFSKClk_ext(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fcLow, int *firstClockEdge) { uint8_t clk[] = {8,16,32,40,50,64,100,128,0}; uint16_t rfLens[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; uint8_t rfCnts[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; @@ -1430,6 +1465,7 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc rfLens[rfLensFnd++] = rfCounter; } } else { + *firstClockEdge = i; firstBitFnd++; } rfCounter=0; @@ -1674,9 +1710,14 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert) return errCnt; } +bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { + size_t ststart = 0, stend = 0; + return DetectST_ext(buffer, size, foundclock, &ststart, &stend); +} + //by marshmellow //attempt to identify a Sequence Terminator in ASK modulated raw wave -bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { +bool DetectST_ext(uint8_t buffer[], size_t *size, int *foundclock, size_t *ststart, size_t *stend) { size_t bufsize = *size; //need to loop through all samples and identify our clock, look for the ST pattern uint8_t fndClk[] = {8,16,32,40,50,64,128}; @@ -1831,7 +1872,7 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { size_t newloc = 0; i=0; if (g_debugMode==2) prnt("DEBUG STT: Starting STT trim - start: %d, datalen: %d ",dataloc, datalen); - + bool firstrun = true; // warning - overwriting buffer given with raw wave data with ST removed... while ( dataloc < bufsize-(clk/2) ) { //compensate for long high at end of ST not being high due to signal loss... (and we cut out the start of wave high part) @@ -1839,6 +1880,15 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) { for(i=0; i < clk/2-tol; ++i) { buffer[dataloc+i] = high+5; } + } //test for single sample outlier (high between two lows) in the case of very strong waves + if (buffer[dataloc] >= high && buffer[dataloc+2] <= low) { + buffer[dataloc] = buffer[dataloc+2]; + buffer[dataloc+1] = buffer[dataloc+2]; + } + if (firstrun) { + *stend = dataloc; + *ststart = dataloc-(clk*4); + firstrun=false; } for (i=0; i