X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/35147d51e3961db75a852368fffa31006da90199..b44e523300b3fbe0a5d9b3081aaa588be3095b14:/client/ui.c diff --git a/client/ui.c b/client/ui.c index 6486d524..4f1b5d85 100644 --- a/client/ui.c +++ b/client/ui.c @@ -92,24 +92,18 @@ void SetLogFilename(char *fn) } -uint8_t manchester_decode(const uint8_t * data, const size_t len, uint8_t * dataout){ +int manchester_decode(const int * data, const size_t len, uint8_t * dataout){ - size_t bytelength = len; - - uint8_t bitStream[bytelength]; - memset(bitStream, 0x00, bytelength); - - int clock,high, low, bit, hithigh, hitlow, first, bit2idx, lastpeak; - int i,invert, lastval; - int bitidx = 0; - int lc = 0; - int warnings = 0; + int bitlength = 0; + int i, clock, high, low, startindex; + low = startindex = 0; high = 1; - low = bit = bit2idx = lastpeak = invert = lastval = hithigh = hitlow = first = 0; - clock = 0xFFFF; + uint8_t bitStream[len]; + memset(bitStream, 0x00, len); + /* Detect high and lows */ - for (i = 0; i < bytelength; i++) { + for (i = 0; i < len; i++) { if (data[i] > high) high = data[i]; else if (data[i] < low) @@ -117,47 +111,106 @@ uint8_t manchester_decode(const uint8_t * data, const size_t len, uint8_t * data } /* get clock */ - int j=0; - for (i = 1; i < bytelength; i++) { + clock = GetT55x7Clock( data, len, high ); + startindex = DetectFirstTransition(data, len, high, low); + + PrintAndLog(" Clock : %d", clock); + PrintAndLog(" startindex : %d", startindex); + + if (high != 1) + bitlength = ManchesterConvertFrom255(data, len, bitStream, high, low, clock, startindex); + else + bitlength= ManchesterConvertFrom1(data, len, bitStream, clock, startindex); + + if ( bitlength > 0 ){ + PrintPaddedManchester(bitStream, bitlength, clock); + } + + memcpy(dataout, bitStream, bitlength); + + free(bitStream); + 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 */ - j = i-1; - if ( data[j] != data[i] && - data[i] == high) - { + if ( data[i-1] != data[i] && data[i] == peak) { /* find lowest difference between peaks */ if (lastpeak && i - lastpeak < clock) clock = i - lastpeak; lastpeak = i; } } - - int tolerance = clock/4; - PrintAndLog(" Detected clock: %d",clock); - - /* Detect first transition */ - /* Lo-Hi (arbitrary) */ - /* skip to the first high */ - for (i= 0; i < bytelength; i++) + //return clock; + //defaults clock to precise values. + switch(clock){ + case 8: + case 16: + case 32: + case 40: + case 50: + case 64: + case 100: + case 128: + return clock; + break; + default: break; + } + return 32; + } + + int DetectFirstTransition(const int * data, const size_t len, int high, int low){ + + int i, retval; + retval = 0; + /* + Detect first transition Lo-Hi (arbitrary) + skip to the first high + */ + for (i = 0; i < len; ++i) if (data[i] == high) break; /* now look for the first low */ - for (; i < bytelength; i++) { + for (; i < len; ++i) { if (data[i] == low) { - lastval = i; + retval = i; break; } } - - /* If we're not working with 1/0s, demod based off clock */ - if (high != 1) + return retval; + } + + int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout, int high, int low, int clock, int startIndex){ + + int i, j, hithigh, hitlow, first, bit, bitIndex; + i = startIndex; + bitIndex = 0; + + /* + * We assume the 1st bit is zero, it may not be + * the case: this routine (I think) has an init problem. + * Ed. + */ + bit = 0; + + for (; i < (int)(len / clock); i++) { - bit = 0; /* We assume the 1st bit is zero, it may not be - * the case: this routine (I think) has an init problem. - * Ed. - */ - for (; i < (int)(bytelength / clock); i++) - { hithigh = 0; hitlow = 0; first = 1; @@ -179,94 +232,125 @@ uint8_t manchester_decode(const uint8_t * data, const size_t len, uint8_t * data if (hithigh && hitlow) break; - } + } - /* If we didn't hit both high and low peaks, we had a bit transition */ - if (!hithigh || !hitlow) + /* If we didn't hit both high and low peaks, we had a bit transition */ + if (!hithigh || !hitlow) bit ^= 1; - bitStream[bit2idx++] = bit ^ invert; - } + dataout[bitIndex++] = bit; } - /* standard 1/0 bitstream */ - else { - /* Then detect duration between 2 successive transitions */ - for (bitidx = 1; i < bytelength; i++) { - - if (data[i-1] != data[i]) { - lc = i-lastval; - lastval = i; - - // Error check: if bitidx becomes too large, we do not - // have a Manchester encoded bitstream or the clock is really - // wrong! - if (bitidx > (bytelength*2/clock+8) ) { - PrintAndLog("Error: the clock you gave is probably wrong, aborting."); - return 0; - } - // Then switch depending on lc length: - // Tolerance is 1/4 of clock rate (arbitrary) - if (abs(lc-clock/2) < tolerance) { - // Short pulse : either "1" or "0" - bitStream[bitidx++] = data[i-1]; - } else if (abs(lc-clock) < tolerance) { - // Long pulse: either "11" or "00" - bitStream[bitidx++] = data[i-1]; - bitStream[bitidx++] = data[i-1]; - } else { - // Error - warnings++; - PrintAndLog("Warning: Manchester decode error for pulse width detection."); - if (warnings > 10) { - PrintAndLog("Error: too many detection errors, aborting."); - return 0; - } + return bitIndex; + } + + int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout, int clock, int startIndex){ + + int i,j, bitindex, lc, tolerance, warnings; + warnings = 0; + int upperlimit = len*2/clock+8; + i = startIndex; + j = 0; + tolerance = clock/4; + uint8_t decodedArr[len]; + + /* Then detect duration between 2 successive transitions */ + for (bitindex = 1; i < len; i++) { + + if (data[i-1] != data[i]) { + lc = i - startIndex; + startIndex = i; + + // Error check: if bitindex becomes too large, we do not + // have a Manchester encoded bitstream or the clock is really wrong! + if (bitindex > upperlimit ) { + PrintAndLog("Error: the clock you gave is probably wrong, aborting."); + return 0; + } + // Then switch depending on lc length: + // Tolerance is 1/4 of clock rate (arbitrary) + if (abs((lc-clock)/2) < tolerance) { + // Short pulse : either "1" or "0" + decodedArr[bitindex++] = data[i-1]; + } else if (abs(lc-clock) < tolerance) { + // Long pulse: either "11" or "00" + decodedArr[bitindex++] = data[i-1]; + decodedArr[bitindex++] = data[i-1]; + } else { + ++warnings; + PrintAndLog("Warning: Manchester decode error for pulse width detection."); + if (warnings > 10) { + PrintAndLog("Error: too many detection errors, aborting."); + return 0; } } } } - // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream - // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful - // to stop output at the final bitidx2 value, not bitidx - for (i = 0; i < bitidx; i += 2) { - if ((bitStream[i] == 0) && (bitStream[i+1] == 1)) { - bitStream[bit2idx++] = 1 ^ invert; - } - else if ((bitStream[i] == 1) && (bitStream[i+1] == 0)) { - bitStream[bit2idx++] = 0 ^ invert; - } - else { - // We cannot end up in this state, this means we are unsynchronized, - // move up 1 bit: + + /* + * We have a decodedArr of "01" ("1") or "10" ("0") + * parse it into final decoded dataout + */ + for (i = 0; i < bitindex; i += 2) { + + if ((decodedArr[i] == 0) && (decodedArr[i+1] == 1)) { + dataout[j++] = 1; + } else if ((decodedArr[i] == 1) && (decodedArr[i+1] == 0)) { + dataout[j++] = 0; + } else { i++; warnings++; PrintAndLog("Unsynchronized, resync..."); - if (warnings > 10) { + PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)"); + + if (warnings > 10) { PrintAndLog("Error: too many decode errors, aborting."); return 0; } } } + + PrintAndLog("%s", sprint_hex(dataout, j)); + return j; + } + + void ManchesterDiffDecodedString(const uint8_t* bitstream, size_t len, uint8_t invert){ + /* + * We have a bitstream of "01" ("1") or "10" ("0") + * parse it into final decoded bitstream + */ + int i, j, warnings; + uint8_t decodedArr[(len/2)+1]; - // PrintAndLog(" Manchester decoded bitstream : %d bits", (bit2idx-16)); - // uint8_t mod = (bit2idx-16) % blocksize; - // uint8_t div = (bit2idx-16) / blocksize; - - // // Now output the bitstream to the scrollback by line of 16 bits - // for (i = 0; i < div*blocksize; i+=blocksize) { - // PrintAndLog(" %s", sprint_bin(bitStream+i,blocksize) ); - // } - // if ( mod > 0 ){ - // PrintAndLog(" %s", sprint_bin(bitStream+i, mod) ); - // } + j = warnings = 0; - if ( bit2idx > 0 ) - memcpy(dataout, bitStream, bit2idx); + uint8_t lastbit = 0; - free(bitStream); - return bit2idx; -} + for (i = 0; i < len; i += 2) { + + uint8_t first = bitstream[i]; + uint8_t second = bitstream[i+1]; + if ( first == second ) { + ++i; + ++warnings; + if (warnings > 10) { + PrintAndLog("Error: too many decode errors, aborting."); + return; + } + } + else if ( lastbit != first ) { + decodedArr[j++] = 0 ^ invert; + } + else { + decodedArr[j++] = 1 ^ invert; + } + lastbit = second; + } + + PrintAndLog("%s", sprint_hex(decodedArr, j)); +} + + void PrintPaddedManchester( uint8_t* bitStream, size_t len, size_t blocksize){ PrintAndLog(" Manchester decoded bitstream : %d bits", len);