mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-08-21 13:53:55 -07:00
LF t55xx and LF em4x commands now should manchester decode data. However t55xx can have other settings and different encodings.
This commit is contained in:
iceman1001
parent
35147d51e3
commit
b44e523300
9 changed files with 351 additions and 242 deletions
294
client/ui.c
294
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);
|
||||
//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){
|
||||
|
||||
/* Detect first transition */
|
||||
/* Lo-Hi (arbitrary) */
|
||||
/* skip to the first high */
|
||||
for (i= 0; i < bytelength; i++)
|
||||
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;
|
||||
return bitIndex;
|
||||
}
|
||||
|
||||
int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout, int clock, int startIndex){
|
||||
|
||||
// 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;
|
||||
}
|
||||
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);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue