+//by marshmellow
+//demod GraphBuffer wave to 0s and 1s for each wave - 0s for short waves 1s for long waves
+size_t fsk_wave_demod(int size)
+{
+ uint32_t last_transition = 0;
+ uint32_t idx = 1;
+ uint32_t maxVal = 0;
+ // we don't care about actual value, only if it's more or less than a
+ // threshold essentially we capture zero crossings for later analysis
+ for(idx=1; idx<size; idx++){
+ if(maxVal<GraphBuffer[idx]) maxVal = GraphBuffer[idx];
+ }
+ // set close to the top of the wave threshold with 13% margin for error
+ // less likely to get a false transition up there.
+ // (but have to be careful not to go too high and miss some short waves)
+ uint32_t threshold_value = (uint32_t)(maxVal*.87);
+ idx=1;
+ // int threshold_value = 100;
+
+ // sync to first lo-hi transition, and threshold
+ // PrintAndLog("FSK init complete size: %d",size);//debug
+ // Need to threshold first sample
+ if(GraphBuffer[0] < threshold_value) GraphBuffer[0] = 0;
+ else GraphBuffer[0] = 1;
+ size_t numBits = 0;
+ // count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
+ // or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
+ // between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
+ for(idx = 1; idx < size; idx++) {
+ // threshold current value
+ if (GraphBuffer[idx] < threshold_value) GraphBuffer[idx] = 0;
+ else GraphBuffer[idx] = 1;
+ // Check for 0->1 transition
+ if (GraphBuffer[idx-1] < GraphBuffer[idx]) { // 0 -> 1 transition
+ if (idx-last_transition<6){
+ // do nothing with extra garbage (shouldn't be any) noise tolerance?
+ } else if(idx-last_transition < 9) {
+ GraphBuffer[numBits]=1;
+ // Other fsk demods reverse this making the short waves 1 and long waves 0
+ // this is really backwards... smaller waves will typically be 0 and larger 1 [marshmellow]
+ // but will leave as is and invert when needed later
+ } else{
+ GraphBuffer[numBits]=0;
+ }
+ last_transition = idx;
+ numBits++;
+ // PrintAndLog("numbits %d",numBits);
+ }
+ }
+ return numBits; //Actually, it returns the number of bytes, but each byte represents a bit: 1 or 0
+}
+uint32_t myround(float f)
+{
+ if (f >= UINT_MAX) return UINT_MAX;
+ return (uint32_t) (f + (float)0.5);
+}
+
+//by marshmellow (from holiman's base)
+//translate 11111100000 to 10
+size_t aggregate_bits(int size, uint8_t rfLen, uint8_t maxConsequtiveBits, uint8_t invert) //,uint8_t l2h_crossing_value
+{
+ int lastval=GraphBuffer[0];
+ uint32_t idx=0;
+ size_t numBits=0;
+ uint32_t n=1;
+ uint32_t n2=0;
+ for( idx=1; idx < size; idx++) {
+
+ if (GraphBuffer[idx]==lastval) {
+ n++;
+ continue;
+ }
+ // if lastval was 1, we have a 1->0 crossing
+ if ( GraphBuffer[idx-1]==1 ) {
+ n=myround((float)(n+1)/((float)(rfLen)/(float)8)); //-2 noise tolerance
+
+ // n=(n+1) / h2l_crossing_value;
+ //truncating could get us into trouble
+ //now we will try with actual clock (RF/64 or RF/50) variable instead
+ //then devide with float casting then truncate after more acurate division
+ //and round to nearest int
+ //like n = (((float)n)/(float)rfLen/(float)10);
+ } else {// 0->1 crossing
+ n=myround((float)(n+1)/((float)(rfLen-2)/(float)10)); // as int 120/6 = 20 as float 120/(64/10) = 18 (18.75)
+ //n=(n+1) / l2h_crossing_value;
+ }
+ if (n == 0) n = 1; //this should never happen... should we error if it does?
+
+ if (n < maxConsequtiveBits) // Consecutive //when the consecutive bits are low - the noise tolerance can be high
+ //if it is high then we must be careful how much noise tolerance we allow
+ {
+ if (invert==0){ // do not invert bits
+ for (n2=0; n2<n; n2++){
+ GraphBuffer[numBits+n2]=GraphBuffer[idx-1];
+ }
+ //memset(GraphBuffer+numBits, GraphBuffer[idx-1] , n);
+ }else{ // invert bits
+ for (n2=0; n2<n; n2++){
+ GraphBuffer[numBits+n2]=GraphBuffer[idx-1]^1;
+ }
+ //memset(GraphBuffer+numBits, GraphBuffer[idx-1]^1 , n);
+ }
+ numBits += n;
+ }
+ n=0;
+ lastval=GraphBuffer[idx];
+ }//end for
+ return numBits;
+}
+
+//by marshmellow (from holiman's base)
+// full fsk demod from GraphBuffer wave to decoded 1s and 0s (no mandemod)
+size_t fskdemod(uint8_t rfLen, uint8_t invert)
+{
+ //uint8_t h2l_crossing_value = 6;
+ //uint8_t l2h_crossing_value = 5;
+
+ // if (rfLen==64) //currently only know settings for RF/64 change from default if option entered
+ // {
+ // h2l_crossing_value=8; //or 8 as 64/8 = 8
+ // l2h_crossing_value=6; //or 6.4 as 64/10 = 6.4
+ // }
+ size_t size = GraphTraceLen;
+ // FSK demodulator
+ size = fsk_wave_demod(size);
+ size = aggregate_bits(size,rfLen,192,invert);
+ // size = aggregate_bits(size, h2l_crossing_value, l2h_crossing_value,192, invert); //192=no limit to same values
+ //done messing with GraphBuffer - repaint
+ RepaintGraphWindow();
+ return size;
+}
+uint32_t bytebits_to_byte(int* src, int numbits)
+{
+ uint32_t num = 0;
+ for(int i = 0 ; i < numbits ; i++)
+ {
+ num = (num << 1) | (*src);
+ src++;
+ }
+ return num;
+}
+
+//by marshmellow
+//fsk demod and print binary
+int CmdFSKrawdemod(const char *Cmd)
+{
+ //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+ //set defaults
+ uint8_t rfLen = 50;
+ uint8_t invert=0;
+ //set options from parameters entered with the command
+ if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
+ rfLen=param_get8(Cmd, 0); //if rfLen option only is used
+ if (rfLen==1){
+ invert=1; //if invert option only is used
+ rfLen = 50;
+ } else if(rfLen==0) rfLen=50;
+ }
+ if (strlen(Cmd)>2) {
+ rfLen=param_get8(Cmd, 0); //if both options are used
+ invert=param_get8(Cmd,1);
+ }
+ PrintAndLog("Args invert: %d \nClock:%d",invert,rfLen);
+
+ size_t size = fskdemod(rfLen,invert);
+
+ PrintAndLog("FSK decoded bitstream:");
+ // Now output the bitstream to the scrollback by line of 16 bits
+ if(size > (7*32)+2) size = (7*32)+2; //only output a max of 7 blocks of 32 bits most tags will have full bit stream inside that sample size
+ printBitStream(GraphBuffer,size);
+
+ ClearGraph(1);
+ return 0;
+}
+
+//by marshmellow
+int CmdFSKdemodHID(const char *Cmd)
+{
+ //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+ //set defaults
+ uint8_t rfLen = 50;
+ uint8_t invert=0;//param_get8(Cmd, 0);
+ size_t idx=0;
+ uint32_t hi2=0, hi=0, lo=0;
+
+ //get binary from fsk wave
+ size_t size = fskdemod(rfLen,invert);
+
+ // final loop, go over previously decoded fsk data and now manchester decode into usable tag ID
+ // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
+ int frame_marker_mask[] = {1,1,1,0,0,0};
+ int numshifts = 0;
+ idx = 0;
+ while( idx + 6 < size) {
+ // search for a start of frame marker
+
+ if ( memcmp(GraphBuffer+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
+ { // frame marker found
+ idx+=6;//sizeof(frame_marker_mask); //size of int is >6
+ while(GraphBuffer[idx] != GraphBuffer[idx+1] && idx < size-2)
+ {
+ // Keep going until next frame marker (or error)
+ // Shift in a bit. Start by shifting high registers
+ hi2 = (hi2<<1)|(hi>>31);
+ hi = (hi<<1)|(lo>>31);
+ //Then, shift in a 0 or one into low
+ if (GraphBuffer[idx] && !GraphBuffer[idx+1]) // 1 0
+ lo=(lo<<1)|0;
+ else // 0 1
+ lo=(lo<<1)|1;
+ numshifts++;
+ idx += 2;
+ }
+
+ //PrintAndLog("Num shifts: %d ", numshifts);
+ // Hopefully, we read a tag and hit upon the next frame marker
+ if(idx + 6 < size)
+ {
+ if ( memcmp(GraphBuffer+(idx), frame_marker_mask, sizeof(frame_marker_mask)) == 0)
+ {
+ if (hi2 != 0){ //extra large HID tags
+ PrintAndLog("TAG ID: %x%08x%08x (%d)",
+ (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
+ }
+ else { //standard HID tags <38 bits
+ //Dbprintf("TAG ID: %x%08x (%d)",(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); //old print cmd
+ uint8_t bitlen = 0;
+ uint32_t fc = 0;
+ uint32_t cardnum = 0;
+ if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
+ uint32_t lo2=0;
+ lo2=(((hi & 15) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
+ uint8_t idx3 = 1;
+ while(lo2>1){ //find last bit set to 1 (format len bit)
+ lo2=lo2>>1;
+ idx3++;
+ }
+ bitlen =idx3+19;
+ fc =0;
+ cardnum=0;
+ if(bitlen==26){
+ cardnum = (lo>>1)&0xFFFF;
+ fc = (lo>>17)&0xFF;
+ }
+ if(bitlen==37){
+ cardnum = (lo>>1)&0x7FFFF;
+ fc = ((hi&0xF)<<12)|(lo>>20);
+ }
+ if(bitlen==34){
+ cardnum = (lo>>1)&0xFFFF;
+ fc= ((hi&1)<<15)|(lo>>17);
+ }
+ if(bitlen==35){
+ cardnum = (lo>>1)&0xFFFFF;
+ fc = ((hi&1)<<11)|(lo>>21);
+ }
+ }
+ else { //if bit 38 is not set then 37 bit format is used
+ bitlen= 37;
+ fc =0;
+ cardnum=0;
+ if(bitlen==37){
+ cardnum = (lo>>1)&0x7FFFF;
+ fc = ((hi&0xF)<<12)|(lo>>20);
+ }
+ }
+
+ PrintAndLog("TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
+ (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
+ (unsigned int) bitlen, (unsigned int) fc, (unsigned int) cardnum);
+ ClearGraph(1);
+ return 0;
+ }
+ }
+ }
+ // reset
+ hi2 = hi = lo = 0;
+ numshifts = 0;
+ }else
+ {
+ idx++;
+ }
+ }
+ if (idx + sizeof(frame_marker_mask) >= size){
+ PrintAndLog("start bits for hid not found");
+ PrintAndLog("FSK decoded bitstream:");
+ // Now output the bitstream to the scrollback by line of 16 bits
+ printBitStream(GraphBuffer,size);
+
+ }
+ ClearGraph(1);
+ return 0;
+}
+
+//by marshmellow
+int CmdFSKdemodIO(const char *Cmd)
+{
+ //raw fsk demod no manchester decoding no start bit finding just get binary from wave
+ //set defaults
+ uint8_t rfLen = 64;
+ uint8_t invert=1;
+ size_t idx=0;
+ uint8_t testMax=0;
+ //test samples are not just noise
+ if (GraphTraceLen < 64) return 0;
+ for(idx=0;idx<64;idx++){
+ if (testMax<GraphBuffer[idx]) testMax=GraphBuffer[idx];
+ }
+ idx=0;
+ //get full binary from fsk wave
+ size_t size = fskdemod(rfLen,invert);
+
+ //if not just noise
+ //PrintAndLog("testMax %d",testMax);
+ if (testMax>40){
+ //Index map
+ //0 10 20 30 40 50 60
+ //| | | | | | |
+ //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
+ //-----------------------------------------------------------------------------
+ //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
+ //
+ //XSF(version)facility:codeone+codetwo (raw)
+ //Handle the data
+ int mask[] = {0,0,0,0,0,0,0,0,0,1};
+ for( idx=0; idx < (size - 74); idx++) {
+ if ( memcmp(GraphBuffer + idx, mask, sizeof(mask))==0) {
+ //frame marker found
+ if (GraphBuffer[idx+17]==1 && GraphBuffer[idx+26]==1 && GraphBuffer[idx+35]==1 && GraphBuffer[idx+44]==1 && GraphBuffer[idx+53]==1){
+ //confirmed proper separator bits found
+
+ PrintAndLog("%d%d%d%d%d%d%d%d %d",GraphBuffer[idx], GraphBuffer[idx+1], GraphBuffer[idx+2], GraphBuffer[idx+3], GraphBuffer[idx+4], GraphBuffer[idx+5], GraphBuffer[idx+6], GraphBuffer[idx+7], GraphBuffer[idx+8]);
+ PrintAndLog("%d%d%d%d%d%d%d%d %d",GraphBuffer[idx+9], GraphBuffer[idx+10], GraphBuffer[idx+11],GraphBuffer[idx+12],GraphBuffer[idx+13],GraphBuffer[idx+14],GraphBuffer[idx+15],GraphBuffer[idx+16],GraphBuffer[idx+17]);
+ PrintAndLog("%d%d%d%d%d%d%d%d %d",GraphBuffer[idx+18], GraphBuffer[idx+19], GraphBuffer[idx+20],GraphBuffer[idx+21],GraphBuffer[idx+22],GraphBuffer[idx+23],GraphBuffer[idx+24],GraphBuffer[idx+25],GraphBuffer[idx+26]);
+ PrintAndLog("%d%d%d%d%d%d%d%d %d",GraphBuffer[idx+27], GraphBuffer[idx+28], GraphBuffer[idx+29],GraphBuffer[idx+30],GraphBuffer[idx+31],GraphBuffer[idx+32],GraphBuffer[idx+33],GraphBuffer[idx+34],GraphBuffer[idx+35]);
+ PrintAndLog("%d%d%d%d%d%d%d%d %d",GraphBuffer[idx+36], GraphBuffer[idx+37], GraphBuffer[idx+38],GraphBuffer[idx+39],GraphBuffer[idx+40],GraphBuffer[idx+41],GraphBuffer[idx+42],GraphBuffer[idx+43],GraphBuffer[idx+44]);
+ PrintAndLog("%d%d%d%d%d%d%d%d %d",GraphBuffer[idx+45], GraphBuffer[idx+46], GraphBuffer[idx+47],GraphBuffer[idx+48],GraphBuffer[idx+49],GraphBuffer[idx+50],GraphBuffer[idx+51],GraphBuffer[idx+52],GraphBuffer[idx+53]);
+ PrintAndLog("%d%d%d%d%d%d%d%d %d%d",GraphBuffer[idx+54],GraphBuffer[idx+55],GraphBuffer[idx+56],GraphBuffer[idx+57],GraphBuffer[idx+58],GraphBuffer[idx+59],GraphBuffer[idx+60],GraphBuffer[idx+61],GraphBuffer[idx+62],GraphBuffer[idx+63]);
+
+ uint32_t code = bytebits_to_byte(GraphBuffer+idx,32);
+ uint32_t code2 = bytebits_to_byte(GraphBuffer+idx+32,32);
+ short version = bytebits_to_byte(GraphBuffer+idx+27,8); //14,4
+ uint8_t facilitycode = bytebits_to_byte(GraphBuffer+idx+19,8) ;
+ uint16_t number = (bytebits_to_byte(GraphBuffer+idx+36,8)<<8)|(bytebits_to_byte(GraphBuffer+idx+45,8)); //36,9
+
+ PrintAndLog("XSF(%02d)%02x:%d (%08x%08x)",version,facilitycode,number,code,code2);
+ ClearGraph(1);
+ return 0;
+ } else {
+ PrintAndLog("thought we had a valid tag but did not match format");
+ }
+ }
+ }
+ if (idx >= (size-74)){
+ PrintAndLog("start bits for io prox not found");
+ PrintAndLog("FSK decoded bitstream:");
+ // Now output the bitstream to the scrollback by line of 16 bits
+ printBitStream(GraphBuffer,size);
+ }
+ }
+ ClearGraph(1);
+ return 0;
+}
+int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
projects / proxmark3-svn / blobdiff