]> cvs.zerfleddert.de Git - proxmark3-svn/commitdiff
FIX: data mandemod read the wrong part of BigBuffer (no correct offset)
authoriceman1001 <iceman@iuse.se>
Fri, 24 Oct 2014 13:34:50 +0000 (15:34 +0200)
committericeman1001 <iceman@iuse.se>
Fri, 24 Oct 2014 13:34:50 +0000 (15:34 +0200)
client/cmddata.c
client/cmdlfhitag.c
client/cmdlft55xx.c
client/ui.c
client/ui.h

index f5b9fc9cc103450b58cfd53e896c54e5eee0201a..c58f6f62007f669619df8bc5a1d7ff84ade1aee5 100644 (file)
@@ -456,25 +456,23 @@ int CmdHpf(const char *Cmd)
 
 int CmdSamples(const char *Cmd)
 {
 
 int CmdSamples(const char *Cmd)
 {
-  int cnt = 0;
-  int n;
-  uint8_t got[40000];
-
-  n = strtol(Cmd, NULL, 0);
-  if (n == 0) n = 512;
-  if (n > sizeof(got)) n = sizeof(got);
-  
-  PrintAndLog("Reading %d samples from device memory\n", n);
-  GetFromBigBuf(got,n,3560);
-  WaitForResponse(CMD_ACK,NULL);
-  for (int j = 0; j < n; j++) {
-    GraphBuffer[cnt++] = ((int)got[j]) - 128;
-  }
+       uint8_t got[36440] = {0x00};
+       
+       int n = strtol(Cmd, NULL, 0);
+       if (n == 0) 
+               n = 512;
+       if (n > sizeof(got)) 
+               n = sizeof(got);
   
   
-  PrintAndLog("Done!\n");
-  GraphTraceLen = n;
-  RepaintGraphWindow();
-  return 0;
+       PrintAndLog("Reading %d samples from device memory\n", n);
+       GetFromBigBuf(got,n,3560);
+       WaitForResponse(CMD_ACK,NULL);
+       for (int j = 0; j < n; ++j) {
+               GraphBuffer[j] = ((int)got[j]) - 128;
+       }
+       GraphTraceLen = n;
+       RepaintGraphWindow();
+       return 0;
 }
 
 int CmdLoad(const char *Cmd)
 }
 
 int CmdLoad(const char *Cmd)
@@ -684,7 +682,7 @@ int CmdManchesterDemod(const char *Cmd)
       // We cannot end up in this state, this means we are unsynchronized,
       // move up 1 bit:
       i++;
       // We cannot end up in this state, this means we are unsynchronized,
       // move up 1 bit:
       i++;
-        warnings++;
+      warnings++;
       PrintAndLog("Unsynchronized, resync...");
       PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
 
       PrintAndLog("Unsynchronized, resync...");
       PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
 
index 038ec887c9683b17d77f2db7205e8bc7fab7e668..331f2c87a687f42e04c6e73503fbba62267a2816 100644 (file)
@@ -230,7 +230,7 @@ int CmdLFHitagReader(const char *Cmd) {
   return 0;
 }
 
   return 0;
 }
 
-static command_t CommandTableHitag[] = 
+static command_t CommandTable[] = 
 {
   {"help",    CmdHelp,           1, "This help"},
   {"list",    CmdLFHitagList,    1, "List Hitag trace history"},
 {
   {"help",    CmdHelp,           1, "This help"},
   {"list",    CmdLFHitagList,    1, "List Hitag trace history"},
@@ -242,12 +242,12 @@ static command_t CommandTableHitag[] =
 
 int CmdLFHitag(const char *Cmd)
 {
 
 int CmdLFHitag(const char *Cmd)
 {
-  CmdsParse(CommandTableHitag, Cmd);
+  CmdsParse(CommandTable, Cmd);
   return 0;
 }
 
 int CmdHelp(const char *Cmd)
 {
   return 0;
 }
 
 int CmdHelp(const char *Cmd)
 {
-  CmdsHelp(CommandTableHitag);
+  CmdsHelp(CommandTable);
   return 0;
 }
   return 0;
 }
index 63cc2ee4e6624794d541474b25b85e0b75b621a3..5804fbc7eb4921ed0da4d344a9d64ac636493f7c 100644 (file)
@@ -29,7 +29,6 @@ static int CmdHelp(const char *Cmd);
 int CmdReadBlk(const char *Cmd)\r
 {\r
        int Block = -1;\r
 int CmdReadBlk(const char *Cmd)\r
 {\r
        int Block = -1;\r
-\r
        sscanf(Cmd, "%d", &Block);\r
 \r
        if ((Block > 7) | (Block < 0)) {\r
        sscanf(Cmd, "%d", &Block);\r
 \r
        if ((Block > 7) | (Block < 0)) {\r
@@ -37,7 +36,6 @@ int CmdReadBlk(const char *Cmd)
                return 1;\r
        }       \r
 \r
                return 1;\r
        }       \r
 \r
-       // this command fills up BigBuff\r
        UsbCommand c;\r
        c.cmd = CMD_T55XX_READ_BLOCK;\r
        c.d.asBytes[0] = 0x00;\r
        UsbCommand c;\r
        c.cmd = CMD_T55XX_READ_BLOCK;\r
        c.d.asBytes[0] = 0x00;\r
@@ -47,17 +45,18 @@ int CmdReadBlk(const char *Cmd)
        SendCommand(&c);\r
        WaitForResponse(CMD_ACK, NULL);\r
        \r
        SendCommand(&c);\r
        WaitForResponse(CMD_ACK, NULL);\r
        \r
-       uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
+//     uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
        \r
        \r
-       GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..\r
-       WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
-\r
-       for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
-               GraphBuffer[j] = (int)data[j];\r
-       }\r
-       GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
+       // GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,3560);  //3560 -- should be offset..\r
+       // WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
+\r
+       // for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
+               // GraphBuffer[j] = (int)data[j];\r
+       // }\r
+       // GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
+       CmdSamples("12000");\r
        ManchesterDemod(Block);\r
        ManchesterDemod(Block);\r
-       RepaintGraphWindow();\r
+       // RepaintGraphWindow();\r
   return 0;\r
 }\r
 \r
   return 0;\r
 }\r
 \r
@@ -90,7 +89,7 @@ int CmdReadBlkPWD(const char *Cmd)
        WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
 \r
        for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
        WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
 \r
        for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
-               GraphBuffer[j] = ((int)data[j]) - 128;\r
+               GraphBuffer[j] = ((int)data[j]);\r
        }\r
        GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
        ManchesterDemod(Block); \r
        }\r
        GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
        ManchesterDemod(Block); \r
@@ -155,8 +154,8 @@ int CmdReadTrace(const char *Cmd)
                PrintAndLog("Usage:  lf t55xx trace  [use data from Graphbuffer]");\r
                PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");\r
                PrintAndLog("");\r
                PrintAndLog("Usage:  lf t55xx trace  [use data from Graphbuffer]");\r
                PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");\r
                PrintAndLog("");\r
-               PrintAndLog("        sample: lf t55xx trace");\r
-               PrintAndLog("        sample: lf t55xx trace 1");\r
+               PrintAndLog("     sample: lf t55xx trace");\r
+               PrintAndLog("     sample: lf t55xx trace 1");\r
                return 0;\r
        }\r
 \r
                return 0;\r
        }\r
 \r
@@ -245,15 +244,14 @@ int CmdInfo(const char *Cmd){
                PrintAndLog("Usage:  lf t55xx info  [use data from Graphbuffer]");\r
                PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");\r
                PrintAndLog("");\r
                PrintAndLog("Usage:  lf t55xx info  [use data from Graphbuffer]");\r
                PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");\r
                PrintAndLog("");\r
-               PrintAndLog("        sample: lf t55xx info");\r
-               PrintAndLog("        sample: lf t55xx info 1");\r
+               PrintAndLog("    sample: lf t55xx info");\r
+               PrintAndLog("    sample: lf t55xx info 1");\r
                return 0;\r
        }\r
 \r
        if ( strlen(Cmd)==0){\r
                CmdReadBlk("0");\r
                return 0;\r
        }\r
 \r
        if ( strlen(Cmd)==0){\r
                CmdReadBlk("0");\r
-       }\r
-       \r
+       }       \r
 \r
        uint8_t bits[1000] = {0x00};\r
        uint8_t * bitstream = bits;\r
 \r
        uint8_t bits[1000] = {0x00};\r
        uint8_t * bitstream = bits;\r
@@ -349,18 +347,20 @@ int CmdIceManchester(const char *Cmd){
 int ManchesterDemod(int block){\r
 \r
        int  blockNum = -1;\r
 int ManchesterDemod(int block){\r
 \r
        int  blockNum = -1;\r
+       uint8_t sizebyte = 32;\r
+       uint8_t offset = 5;\r
        uint32_t blockData;\r
        uint8_t  bits[1000] = {0x00};\r
        uint8_t * bitstream = bits;\r
        \r
        manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);  \r
        uint32_t blockData;\r
        uint8_t  bits[1000] = {0x00};\r
        uint8_t * bitstream = bits;\r
        \r
        manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);  \r
-    blockData = PackBits(5, 32, bitstream);\r
+    blockData = PackBits(offset, sizebyte, bitstream);\r
 \r
 \r
-       if ( blockNum > -1){\r
-               PrintAndLog("   Block %d : 0x%08X  %s", blockNum, blockData, sprint_bin(bitstream+5,32) );\r
-       }else{\r
-               PrintAndLog("   Decoded : 0x%08X  %s", blockData, sprint_bin(bitstream+5,32) );\r
-       }\r
+       if ( blockNum < 0)\r
+               PrintAndLog(" Decoded     : 0x%08X  %s", blockData, sprint_bin(bitstream+offset,sizebyte) );\r
+               else\r
+               PrintAndLog(" Block %d    : 0x%08X  %s", blockNum, blockData, sprint_bin(bitstream+offset,sizebyte) );\r
+       \r
        return 0;\r
 } \r
 \r
        return 0;\r
 } \r
 \r
index 59ca72dcdc5496b497b2afb4a9a946a1f1c3a2aa..5d05da96c5cb13037ec4d31bbe9a0bfe2131d7c9 100644 (file)
@@ -18,7 +18,8 @@
 #include <pthread.h>
 #include "loclass/cipherutils.h"
 #include "ui.h"
 #include <pthread.h>
 #include "loclass/cipherutils.h"
 #include "ui.h"
-
+#include "cmdmain.h"
+#include "cmddata.h"
 //#include <liquid/liquid.h>
 #define M_PI 3.14159265358979323846264338327
 
 //#include <liquid/liquid.h>
 #define M_PI 3.14159265358979323846264338327
 
@@ -117,7 +118,7 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout){
        startindex = DetectFirstTransition(data, len, high);
   
        PrintAndLog(" Clock       : %d", clock);
        startindex = DetectFirstTransition(data, len, high);
   
        PrintAndLog(" Clock       : %d", clock);
-       PrintAndLog(" startindex  : %d", startindex);
+       //PrintAndLog(" startindex  : %d", startindex);
        
        if (high != 1)
                bitlength = ManchesterConvertFrom255(data, len, bitStream, high, low, clock, startindex);
        
        if (high != 1)
                bitlength = ManchesterConvertFrom255(data, len, bitStream, high, low, clock, startindex);
@@ -235,8 +236,7 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout){
                // No high value found, are we in a dampening field?
                if ( !hithigh ) {
                        //PrintAndLog(" # Entering damp test at index : %d (%d)", z+j, j);
                // No high value found, are we in a dampening field?
                if ( !hithigh ) {
                        //PrintAndLog(" # Entering damp test at index : %d (%d)", z+j, j);
-                       for (j = 0; j < clock; j++)
-                       {
+                       for (j = 0; j < clock; j++) {
                                if ( 
                                     (data[z+j] <= dampHi && data[z+j] >= dampLow)
                                   ){
                                if ( 
                                     (data[z+j] <= dampHi && data[z+j] >= dampLow)
                                   ){
@@ -392,83 +392,6 @@ void PrintPaddedManchester( uint8_t* bitStream, size_t len, size_t blocksize){
                PrintAndLog(" %s", sprint_bin(bitStream+i, mod) );      
 }
 
                PrintAndLog(" %s", sprint_bin(bitStream+i, mod) );      
 }
 
-void iceFsk(int * data, const size_t len){
-
-       //34359738  == 125khz   (2^32 / 125) =
-       
-    // parameters
-    float phase_offset      = 0.00f;   // carrier phase offset
-    float frequency_offset  = 0.30f;   // carrier frequency offset
-    float wn                = 0.01f;   // pll bandwidth
-    float zeta              = 0.707f;  // pll damping factor
-    float K                 = 1000;    // pll loop gain
-    size_t n                = len;     // number of samples
-
-    // generate loop filter parameters (active PI design)
-    float t1 = K/(wn*wn);   // tau_1
-    float t2 = 2*zeta/wn;   // tau_2
-
-    // feed-forward coefficients (numerator)
-    float b0 = (4*K/t1)*(1.+t2/2.0f);
-    float b1 = (8*K/t1);
-    float b2 = (4*K/t1)*(1.-t2/2.0f);
-
-    // feed-back coefficients (denominator)
-    //    a0 =  1.0  is implied
-    float a1 = -2.0f;
-    float a2 =  1.0f;
-
-    // filter buffer
-    float v0=0.0f, v1=0.0f, v2=0.0f;
-    
-    // initialize states
-    float phi     = phase_offset;  // input signal's initial phase
-    float phi_hat = 0.0f;      // PLL's initial phase
-    
-    unsigned int i;
-    float complex x,y;
-       float complex output[n];
-       
-       for (i=0; i<n; i++) {
-               // INPUT SIGNAL
-               x = data[i];
-               phi += frequency_offset;
-               
-               // generate complex sinusoid
-               y = cosf(phi_hat) + _Complex_I*sinf(phi_hat);
-
-               output[i] = y;
-
-               // compute error estimate
-               float delta_phi = cargf( x * conjf(y) );
-
-               
-        // print results to standard output
-        printf("  %6u %12.8f %12.8f %12.8f %12.8f %12.8f\n",
-                  i,
-                  crealf(x), cimagf(x),
-                  crealf(y), cimagf(y),
-                  delta_phi);
-       
-               // push result through loop filter, updating phase estimate
-
-               // advance buffer
-               v2 = v1;  // shift center register to upper register
-               v1 = v0;  // shift lower register to center register
-
-               // compute new lower register
-               v0 = delta_phi - v1*a1 - v2*a2;
-
-               // compute new output
-               phi_hat = v0*b0 + v1*b1 + v2*b2;
-
-       }
-
-       for (i=0; i<len; ++i){
-               data[i] = (int)crealf(output[i]);
-       }
-}
-
 /* Sliding DFT
    Smooths out 
 */ 
 /* Sliding DFT
    Smooths out 
 */ 
@@ -502,21 +425,21 @@ void iceFsk3(int * data, const size_t len){
 
        int i,j;
        int output[len];
 
        int i,j;
        int output[len];
-    float fc            = 0.1125f;          // center frequency
-
+    float fc           = 0.1125f;          // center frequency
+       size_t adjustedLen = len;
+       
     // create very simple low-pass filter to remove images (2nd-order Butterworth)
     float complex iir_buf[3] = {0,0,0};
     float b[3] = {0.003621681514929,  0.007243363029857, 0.003621681514929};
     float a[3] = {1.000000000000000, -1.822694925196308, 0.837181651256023};
     
     // create very simple low-pass filter to remove images (2nd-order Butterworth)
     float complex iir_buf[3] = {0,0,0};
     float b[3] = {0.003621681514929,  0.007243363029857, 0.003621681514929};
     float a[3] = {1.000000000000000, -1.822694925196308, 0.837181651256023};
     
-    // process entire input file one sample at a time
-    float         sample      = 0;      // input sample read from file
-    float complex x_prime     = 1.0f;   // save sample for estimating frequency
+    float sample           = 0;      // input sample read from file
+    float complex x_prime  = 1.0f;   // save sample for estimating frequency
     float complex x;
                
     float complex x;
                
-       for (i=0; i<len; ++i) {
+       for (i=0; i<adjustedLen; ++i) {
 
 
-               sample = data[i];
+               sample = data[i]+128;
                
         // remove DC offset and mix to complex baseband
         x = (sample - 127.5f) * cexpf( _Complex_I * 2 * M_PI * fc * i );
                
         // remove DC offset and mix to complex baseband
         x = (sample - 127.5f) * cexpf( _Complex_I * 2 * M_PI * fc * i );
@@ -538,18 +461,19 @@ void iceFsk3(int * data, const size_t len){
     } 
 
        // show data
     } 
 
        // show data
-       for (j=0; j<len; ++j)
+       for (j=0; j<adjustedLen; ++j)
                data[j] = output[j];
                
        CmdLtrim("30");
                data[j] = output[j];
                
        CmdLtrim("30");
+       adjustedLen -= 30;
        
        // zero crossings.
        
        // zero crossings.
-       for (j=0; j<len; ++j){
+       for (j=0; j<adjustedLen; ++j){
                if ( data[j] == 10) break;
        }
        int startOne =j;
        
                if ( data[j] == 10) break;
        }
        int startOne =j;
        
-       for (;j<len; ++j){
+       for (;j<adjustedLen; ++j){
                if ( data[j] == -10 ) break;
        }
        int stopOne = j-1;
                if ( data[j] == -10 ) break;
        }
        int stopOne = j-1;
@@ -560,13 +484,13 @@ void iceFsk3(int * data, const size_t len){
        fieldlen = (fieldlen == 59 || fieldlen == 51)? 50 : fieldlen;
        if ( fieldlen != 40 && fieldlen != 50){
                printf("Detected field Length: %d \n", fieldlen);
        fieldlen = (fieldlen == 59 || fieldlen == 51)? 50 : fieldlen;
        if ( fieldlen != 40 && fieldlen != 50){
                printf("Detected field Length: %d \n", fieldlen);
-               printf("Can only handle len 40 or 50.  Aborting...");
+               printf("Can only handle 40 or 50.  Aborting...\n");
                return;
        }
        
        // FSK sequence start == 000111
        int startPos = 0;
                return;
        }
        
        // FSK sequence start == 000111
        int startPos = 0;
-       for (i =0; i<len; ++i){
+       for (i =0; i<adjustedLen; ++i){
                int dec = 0;
                for ( j = 0; j < 6*fieldlen; ++j){
                        dec += data[i + j];
                int dec = 0;
                for ( j = 0; j < 6*fieldlen; ++j){
                        dec += data[i + j];
@@ -584,14 +508,14 @@ void iceFsk3(int * data, const size_t len){
        int bit =0;
        printf("BINARY\n");
        printf("R/40 :  ");
        int bit =0;
        printf("BINARY\n");
        printf("R/40 :  ");
-       for (i =startPos ; i < len; i += 40){
+       for (i =startPos ; i < adjustedLen; i += 40){
                bit = data[i]>0 ? 1:0;
                printf("%d", bit );
        }
        printf("\n");   
        
        printf("R/50 :  ");
                bit = data[i]>0 ? 1:0;
                printf("%d", bit );
        }
        printf("\n");   
        
        printf("R/50 :  ");
-       for (i =startPos ; i < len; i += 50){
+       for (i =startPos ; i < adjustedLen; i += 50){
                bit = data[i]>0 ? 1:0;
                printf("%d", bit );     }
        printf("\n");   
                bit = data[i]>0 ? 1:0;
                printf("%d", bit );     }
        printf("\n");   
index 666d7002c5978afd82dcea1b9e09b816dc1107b7..8d16e0592940a04da8146ae82c75fa8a2e716a3d 100644 (file)
@@ -34,7 +34,6 @@ void PrintPaddedManchester( uint8_t * bitStream, size_t len, size_t blocksize);
 void ManchesterDiffDecodedString( const uint8_t *bitStream, size_t len, uint8_t invert );
 int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout, int high, int low, int clock, int startIndex);
 int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout, int clock, int startIndex);
 void ManchesterDiffDecodedString( const uint8_t *bitStream, size_t len, uint8_t invert );
 int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout, int high, int low, int clock, int startIndex);
 int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout, int clock, int startIndex);
-void iceFsk(int * data, const size_t len);
 void iceFsk2(int * data, const size_t len);
 void iceFsk3(int * data, const size_t len);
 #endif
 void iceFsk2(int * data, const size_t len);
 void iceFsk3(int * data, const size_t len);
 #endif
Impressum, Datenschutz