]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - common/lfdemod.c
Code cleanup: Refactoring nonce2key
[proxmark3-svn] / common / lfdemod.c
index 125112088e09fc57b44768e0743bcb2b67a0c356..1b53c44560fac2c7722903cd5d8f89fd90be1191 100644 (file)
@@ -218,8 +218,8 @@ uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_
        uint8_t FmtLen = 10; // sets of 4 bits = end data 
        *startIdx = 0;
        errChk = preambleSearch(BitStream, preamble, sizeof(preamble), size, startIdx);
-       if (errChk == 0 || *size < 64) return 0;
-       if (*size == 110) FmtLen = 22; // 22 sets of 4 bits
+       if ( errChk == 0 || (*size != 64 && *size != 128) ) return 0;
+       if (*size == 128) FmtLen = 22; // 22 sets of 4 bits
 
        //skip last 4bit parity row for simplicity
        *size = removeParity(BitStream, *startIdx + sizeof(preamble), 5, 0, FmtLen * 5);
@@ -337,7 +337,7 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
        int lastBit;              //set first clock check - can go negative
        size_t i, bitnum = 0;     //output counter
        uint8_t midBit = 0;
-       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
+       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
        size_t MaxBits = 3072;    //max bits to collect
        lastBit = start - *clk;
@@ -819,12 +819,12 @@ 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};
        size_t startwave;
        size_t i = 100;
        size_t minClk = 255;
+       int shortestWaveIdx = 0;
                // get to first full low to prime loop and skip incomplete first pulse
        while ((dest[i] < high) && (i < size))
                ++i;
@@ -836,20 +836,24 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
                // measure from low to low
                while ((dest[i] > low) && (i < size))
                        ++i;
-               startwave= i;
+               startwave = i;
                while ((dest[i] < high) && (i < size))
                        ++i;
                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 >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) {
+                       *clock = fndClk[clkCnt];
+                       return shortestWaveIdx;
+               }
        }
        return 0;
 }
@@ -879,15 +883,10 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
        //test for large clean peaks
        if (!clockFnd){
                if (DetectCleanAskWave(dest, size, peak, low)==1){
-                       int ans = DetectStrongAskClock(dest, size, peak, low);
-                       if (g_debugMode==2) prnt("DEBUG ASK: detectaskclk Clean Ask Wave Detected: clk %d",ans);
-                       for (i=clkEnd-1; i>0; 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 position
                        }
                }
        }
@@ -960,11 +959,16 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
        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)
-{
+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;
@@ -1003,8 +1007,8 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
                        }
                }
        }
+       *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--){
                lastClkBit = firstFullWave; //set end of wave as clock align
@@ -1087,10 +1091,15 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){
        return lowestTransition;
 }
 
+int DetectNRZClock(uint8_t dest[], size_t size, int clock) {
+       size_t 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)
-{
+int DetectNRZClock_ext(uint8_t dest[], size_t size, int clock, size_t *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...
@@ -1137,6 +1146,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
        uint8_t ignoreWindow = 4;
        bool lastPeakHigh = 0;
        int lastBit = 0; 
+       size_t 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){
@@ -1183,6 +1193,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
                                        }
                                }
                                if(peakcnt>peaksdet[clkCnt]) {
+                                       bestStart[clkCnt]=ii;
                                        peaksdet[clkCnt]=peakcnt;
                                }
                        }
@@ -1200,7 +1211,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
                }
                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);
        }
-
+       *clockStartIdx  = bestStart[best];
        return clk[best];
 }
 
@@ -1293,10 +1304,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};
@@ -1352,6 +1367,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;
@@ -1596,9 +1612,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};
@@ -1751,7 +1772,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)
@@ -1764,6 +1785,11 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) {
                        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<datalen; ++i) {
                        if (i+newloc < bufsize) {
                                if (i+newloc < dataloc)
@@ -1780,3 +1806,16 @@ bool DetectST(uint8_t buffer[], size_t *size, int *foundclock) {
        *size = newloc;
        return true;
 }
+
+// by iceman
+// find Visa2000 preamble in already demoded data
+int Visa2kDemod_AM(uint8_t *dest, size_t *size) {
+       if (*size < 96) return -1; //make sure buffer has data
+       size_t startIdx = 0;
+       uint8_t preamble[] = {0,1,0,1,0,1,1,0,0,1,0,0,1,0,0,1,0,1,0,1,0,0,1,1,0,0,1,1,0,0,1,0};
+       if (preambleSearch(dest, preamble, sizeof(preamble), size, &startIdx) == 0)
+               return -2; //preamble not found
+       if (*size != 96) return -3; //wrong demoded size
+       //return start position
+       return (int)startIdx;
+}
Impressum, Datenschutz