X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/8ad1e731c8561ba050db2e80daff7b1e97e575ca..c6e5c7ea46eae6180eee3eb592a291257a0400b1:/common/lfdemod.c diff --git a/common/lfdemod.c b/common/lfdemod.c index 21695ec1..61d01c27 100644 --- a/common/lfdemod.c +++ b/common/lfdemod.c @@ -74,7 +74,7 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p parityWd = (parityWd << 1) | BitStream[startIdx+word+bit]; BitStream[j++] = (BitStream[startIdx+word+bit]); } - if (word+pLen >= bLen) break; + if (word+pLen > bLen) break; j--; // overwrite parity with next data // if parity fails then return 0 @@ -158,7 +158,7 @@ bool preambleSearchEx(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t uint8_t foundCnt = 0; for (int idx = 0; idx < *size - pLen; idx++){ if (memcmp(BitStream+idx, preamble, pLen) == 0){ - if (g_debugMode) prnt("DEBUG: preamble found at %u", idx); + if (g_debugMode) prnt("DEBUG: preamble found at %i", idx); //first index found foundCnt++; if (foundCnt == 1){ @@ -203,45 +203,50 @@ size_t findModStart(uint8_t dest[], size_t size, uint8_t threshold_value, uint8_ //by marshmellow //takes 1s and 0s and searches for EM410x format - output EM ID // actually, no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future -uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) +int Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo) { - //allow only 1s and 0s - // only checking first bitvalue?! - if (BitStream[1] > 1) return 0; + // sanity check + if (*size < 64) return -3; + if (BitStream[1] > 1) return -1; - uint32_t i = 0, idx = 0, parityBits = 0; - uint8_t fmtlen = 0; + uint8_t fmtlen; *startIdx = 0; // 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)) - return 0; - if (*size < 64) return 0; + if (!preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx)) + return -2; + + //XL and normal size. + if (*size != 64 && *size != 128) return -3; - fmtlen = (*size > 64) ? 22 : 10; + fmtlen = (*size == 128) ? 22 : 10; - idx = *startIdx + sizeof(preamble); + //skip last 4bit parity row for simplicity + *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, fmtlen * 5); - //loop through 10 or 22 sets of 5 bits (50-10p = 40 bits or 88 bits) - for (i=0; i < fmtlen; i++){ - parityBits = bytebits_to_byte(BitStream + (i*5) + idx, 5); - //check even parity - if (parityTest(parityBits, 5, 0) == 0) return 0; - //set uint64 with ID from BitStream - for (uint8_t j = 0; j < 4; j++){ - *hi = (*hi << 1) | (*lo >> 63); - *lo = (*lo << 1) | (BitStream[(i*5) + j + idx]); - } + switch (*size) { + case 40: { + // std em410x format + *hi = 0; + *lo = ((uint64_t)(bytebits_to_byte(BitStream, 8)) << 32) | (bytebits_to_byte(BitStream + 8, 32)); + break; + } + case 88: { + // long em format + *hi = (bytebits_to_byte(BitStream, 24)); + *lo = ((uint64_t)(bytebits_to_byte(BitStream + 24, 32)) << 32) | (bytebits_to_byte(BitStream + 24 + 32, 32)); + break; + } + default: return -4; } - //skip last 5 bit parity test for simplicity. - // *size = 64 | 128; return 1; } //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; @@ -385,25 +390,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){ @@ -411,9 +421,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; } @@ -930,6 +940,10 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low) } return 0; } +void SetGraphClock( int clock, int startidx){ + PlotClock = clock; + PlockClockStartIndex = startidx; +} // by marshmellow // not perfect especially with lower clocks or VERY good antennas (heavy wave clipping) @@ -937,15 +951,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) { + 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 { @@ -1016,6 +1030,8 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d", clk[clkCnt], errCnt, ii, i); if (errCnt==0 && clkCnt<7) { if (!clockFnd) *clock = clk[clkCnt]; + + SetGraphClock(*clock, ii); return ii; } //if we found errors see if it is lowest so far and save it as best run @@ -1038,6 +1054,8 @@ 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]; + + SetGraphClock(*clock, bestStart[best]); return bestStart[best]; } @@ -1046,27 +1064,30 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr) // 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 + 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; @@ -1084,10 +1105,10 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock) } } } - if (g_debugMode ==2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); + 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; @@ -1121,19 +1142,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]; @@ -1170,16 +1189,20 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){ //by marshmellow //detect nrz clock by reading #peaks vs no peaks(or errors) +//iceman: shouldn't param clock be reference? like DetectASKClock 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}; + 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; @@ -1208,7 +1231,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; } } } @@ -1218,7 +1241,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) uint8_t ignoreWindow = 4; bool lastPeakHigh = 0; int lastBit = 0; - peakcnt=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 @@ -1238,7 +1261,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; @@ -1250,9 +1273,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--; @@ -1263,23 +1287,23 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock) errBitHigh=true; } } - if(peakcnt>peaksdet[clkCnt]) { - peaksdet[clkCnt]=peakcnt; + if (peakcnt > peaksdet[clkCnt]) { + 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); } return clk[best]; @@ -1673,9 +1697,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}; @@ -1830,7 +1859,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) @@ -1838,6 +1867,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