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
//search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length
uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx)
{
+ return (preambleSearchEx(BitStream, preamble, pLen, size, startIdx, false)) ? 1 : 0;
+}
+
+// search for given preamble in given BitStream and return success=1 or fail=0 and startIndex (where it was found) and length if not fineone
+// fineone does not look for a repeating preamble for em4x05/4x69 sends preamble once, so look for it once in the first pLen bits
+bool preambleSearchEx(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx, bool findone) {
// Sanity check. If preamble length is bigger than bitstream length.
- if ( *size <= pLen ) return 0;
+ if ( *size <= pLen ) return false;
- uint8_t foundCnt=0;
- for (int idx=0; idx < *size - pLen; idx++){
- if (memcmp(BitStream+idx, preamble, pLen) == 0){
+ uint8_t foundCnt = 0;
+ for (size_t idx = 0; idx < *size - pLen; idx++) {
+ if (memcmp(BitStream+idx, preamble, pLen) == 0) {
//first index found
foundCnt++;
- if (foundCnt == 1){
+ if (foundCnt == 1) {
+ if (g_debugMode) prnt("DEBUG: preamble found at %u", idx);
*startIdx = idx;
- }
- if (foundCnt == 2){
+ if (findone) return true;
+ } else if (foundCnt == 2) {
*size = idx - *startIdx;
- return 1;
+ return true;
}
}
}
- return 0;
-}
-
-// search for given preamble in given BitStream and return success=1 or fail=0 and startIndex (where it was found)
-// does not look for a repeating preamble
-// em4x05/4x69 only sends preamble once, so look for it once in the first pLen bits
-// leave it generic so it could be reused later...
-bool onePreambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t size, size_t *startIdx) {
- // Sanity check. If preamble length is bigger than bitstream length.
- if ( size <= pLen ) return false;
- for (size_t idx = 0; idx < size - pLen; idx++) {
- if (memcmp(BitStream+idx, preamble, pLen) == 0) {
- if (g_debugMode) prnt("DEBUG: preamble found at %u", idx);
- *startIdx = idx;
- return true;
- }
- }
return false;
}
//takes 1s and 0s and searches for EM410x format - output EM ID
uint8_t Em410xDecode(uint8_t *BitStream, size_t *size, size_t *startIdx, uint32_t *hi, uint64_t *lo)
{
- //no arguments needed - built this way in case we want this to be a direct call from "data " cmds in the future
- // otherwise could be a void with no arguments
- //set defaults
- uint32_t i = 0;
+ //sanity checks
+ if (*size < 64) return 0;
if (BitStream[1]>1) return 0; //allow only 1s and 0s
// 111111111 bit pattern represent start of frame
// include 0 in front to help get start pos
uint8_t preamble[] = {0,1,1,1,1,1,1,1,1,1};
- uint32_t idx = 0;
- uint32_t parityBits = 0;
uint8_t errChk = 0;
- uint8_t FmtLen = 10;
+ 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 > 64) FmtLen = 22;
- *startIdx += 1; //get rid of 0 from preamble
- idx = *startIdx + 9;
- for (i=0; i<FmtLen; i++){ //loop through 10 or 22 sets of 5 bits (50-10p = 40 bits or 88 bits)
- parityBits = bytebits_to_byte(BitStream+(i*5)+idx,5);
- //check even parity - quit if failed
- if (parityTest(parityBits, 5, 0) == 0) return 0;
- //set uint64 with ID from BitStream
- for (uint8_t ii=0; ii<4; ii++){
- *hi = (*hi << 1) | (*lo >> 63);
- *lo = (*lo << 1) | (BitStream[(i*5)+ii+idx]);
- }
+ 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);
+ if (*size == 40) { // std em410x format
+ *hi = 0;
+ *lo = ((uint64_t)(bytebits_to_byte(BitStream, 8)) << 32) | (bytebits_to_byte(BitStream + 8, 32));
+ } else if (*size == 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));
+ } else {
+ return 0;
}
- if (errChk != 0) return 1;
- //skip last 5 bit parity test for simplicity.
- // *size = 64 | 128;
- return 0;
+ return 1;
}
//by marshmellow
}
//by marshmellow
+//amplify based on ask edge detection
void askAmp(uint8_t *BitStream, size_t size)
{
uint8_t Last = 128;
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;
// 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;
// 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;
}
//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
}
}
}
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;
}
}
}
+ *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
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...
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){
}
}
if(peakcnt>peaksdet[clkCnt]) {
+ bestStart[clkCnt]=ii;
peaksdet[clkCnt]=peakcnt;
}
}
}
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];
}
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};
rfLens[rfLensFnd++] = rfCounter;
}
} else {
+ *firstClockEdge = i;
firstBitFnd++;
}
rfCounter=0;
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};
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)
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<datalen; ++i) {
if (i+newloc < bufsize) {
*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;
+}
projects / proxmark3-svn / blobdiff