Some more nasty bugs fixed in the lf t55xx manchester_decode method.

ADD: a little function to see if GraphBuffer is not used.

diff --git a/client/cmdlfem4x.c b/client/cmdlfem4x.c
index 0449e34ab4333c88ba02bb7c730091060ebeaaf7..1ce937d97e58350508d28c5b90dd46ef5ceac260 100644 (file)
--- a/client/cmdlfem4x.c
+++ b/client/cmdlfem4x.c
@@ -22,6 +22,7 @@
 #include "util.h"
 #include "data.h"
 #define LF_TRACE_BUFF_SIZE 12000
+#define LF_BITSSTREAM_LEN 1000
 
 char *global_em410xId;
 
@@ -530,9 +531,9 @@ int CmdReadWord(const char *Cmd)
        }
        GraphTraceLen = LF_TRACE_BUFF_SIZE;
        
-       uint8_t bits[1000] = {0x00};
+       uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};
        uint8_t * bitstream = bits;
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream,LF_BITSSTREAM_LEN);
        RepaintGraphWindow();
   return 0;
 }
@@ -570,10 +571,9 @@ int CmdReadWordPWD(const char *Cmd)
        }
        GraphTraceLen = LF_TRACE_BUFF_SIZE;
        
-       uint8_t bits[1000] = {0x00};
-       uint8_t * bitstream = bits;
-       
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);
+       uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};
+       uint8_t * bitstream = bits;     
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);
        RepaintGraphWindow();
   return 0;
 }

diff --git a/client/cmdlft55xx.c b/client/cmdlft55xx.c
index 31261a4f112f8aef120da47e50afa5b06a1f7fa3..09ba1ee769c1b7072a993ceaedfcfb878a9f2148 100644 (file)
--- a/client/cmdlft55xx.c
+++ b/client/cmdlft55xx.c
@@ -23,15 +23,16 @@
 \r
 \r
 #define LF_TRACE_BUFF_SIZE 12000 // 32 x 32 x 10  (32 bit times numofblock (7), times clock skip..)\r
+#define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend..  8block * 4 bytes * 8bits = \r
 static int CmdHelp(const char *Cmd);\r
 \r
 \r
 int CmdReadBlk(const char *Cmd)\r
 {\r
-       int Block = -1;\r
-       sscanf(Cmd, "%d", &Block);\r
+       int block = -1;\r
+       sscanf(Cmd, "%d", &block);\r
 \r
-       if ((Block > 7) | (Block < 0)) {\r
+       if ((block > 7) | (block < 0)) {\r
                PrintAndLog("Block must be between 0 and 7");\r
                return 1;\r
        }       \r
@@ -55,7 +56,7 @@ int CmdReadBlk(const char *Cmd)
        // }\r
        // GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
        CmdSamples("12000");\r
-       ManchesterDemod(Block);\r
+       ManchesterDemod(block);\r
        // RepaintGraphWindow();\r
   return 0;\r
 }\r
@@ -175,10 +176,10 @@ int CmdReadTrace(const char *Cmd)
                GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
        }\r
        \r
-       uint8_t bits[1000] = {0x00};\r
+       uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
        uint8_t * bitstream = bits;\r
        \r
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);\r
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);\r
        RepaintGraphWindow();\r
 \r
        uint8_t si = 5;\r
@@ -253,10 +254,10 @@ int CmdInfo(const char *Cmd){
                CmdReadBlk("0");\r
        }       \r
 \r
-       uint8_t bits[1000] = {0x00};\r
+       uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
        uint8_t * bitstream = bits;\r
        \r
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);\r
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);\r
        \r
        uint8_t si = 5;\r
        uint32_t bl0      = PackBits(si, 32, bitstream);\r
@@ -324,7 +325,7 @@ int CmdDump(const char *Cmd){
        for ( int i = 0; i <8; ++i){\r
                memset(s,0,sizeof(s));\r
                if ( hasPwd ) {\r
-                       sprintf(s,"%d %s", i, sprint_hex(pwd,4));\r
+                       sprintf(s,"%d %02x%02x%02x%02x", i, pwd[0],pwd[1],pwd[2],pwd[3]);\r
                        CmdReadBlkPWD(s);\r
                } else {\r
                        sprintf(s,"%d", i);\r
@@ -335,6 +336,9 @@ int CmdDump(const char *Cmd){
 }\r
 \r
 int CmdIceFsk(const char *Cmd){\r
+\r
+       if (!HasGraphData()) return 0;\r
+\r
        iceFsk3(GraphBuffer, LF_TRACE_BUFF_SIZE);\r
        RepaintGraphWindow();\r
        return 0;\r
@@ -343,16 +347,17 @@ int CmdIceManchester(const char *Cmd){
        ManchesterDemod( -1);\r
        return 0;\r
 }\r
-int ManchesterDemod(int block){\r
+int ManchesterDemod(int blockNum){\r
 \r
-       int  blockNum = -1;\r
+       if (!HasGraphData()) return 0;\r
+               \r
        uint8_t sizebyte = 32;\r
        uint8_t offset = 5;\r
        uint32_t blockData;\r
-       uint8_t  bits[1000] = {0x00};\r
+       uint8_t  bits[LF_BITSSTREAM_LEN] = {0x00};\r
        uint8_t * bitstream = bits;\r
        \r
-       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream);  \r
+       manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);       \r
     blockData = PackBits(offset, sizebyte, bitstream);\r
 \r
        if ( blockNum < 0)\r

diff --git a/client/cmdmain.c b/client/cmdmain.c
index bf69c5ad83a7d3493399dfe4bfd7a2284bb73482..b35ba63c8cf0a7c0ed1aad2a27ed3dff8936d878 100644 (file)
--- a/client/cmdmain.c
+++ b/client/cmdmain.c
@@ -51,9 +51,9 @@ static command_t CommandTable[] =
 {
   {"help",  CmdHelp,  1, "This help. Use '<command> help' for details of a particular command."},
   {"data",  CmdData,  1, "{ Plot window / data buffer manipulation... }"},
-  {"hf",    CmdHF,    1, "{ HF commands... }"},
+  {"hf",    CmdHF,    1, "{ High Frequency commands... }"},
   {"hw",    CmdHW,    1, "{ Hardware commands... }"},
-  {"lf",    CmdLF,    1, "{ LF commands... }"},
+  {"lf",    CmdLF,    1, "{ Low Frequency commands... }"},
   {"script", CmdScript,   1,"{ Scripting commands }"},
   {"quit",  CmdQuit,  1, "Exit program"},
   {"exit",  CmdQuit,  1, "Exit program"},

diff --git a/client/graph.c b/client/graph.c
index 541e68f3404a30c98de216c16afc70b7c7da1349..8974f4c32567bc30af8b9348f4395cb7bd52cc72 100644 (file)
--- a/client/graph.c
+++ b/client/graph.c
@@ -9,6 +9,7 @@
 //-----------------------------------------------------------------------------
 
 #include <stdio.h>
+#include <stdbool.h>
 #include <string.h>
 #include "ui.h"
 #include "graph.h"
@@ -93,3 +94,15 @@ int GetClock(const char *str, int peak, int verbose)
 
   return clock;
 }
+
+
+/* A simple test to see if there is any data inside Graphbuffer. 
+*/
+bool HasGraphData(){
+
+       if ( GraphTraceLen <= 0) {
+               PrintAndLog("No data available, try reading something first");
+               return false;
+       }
+       return true;    
+}
\ No newline at end of file

diff --git a/client/graph.h b/client/graph.h
index cbe8116149a18342fa782ef058f9a0781ecc05f3..ce803c82a7d101645346fc7ace6662e2acd46a23 100644 (file)
--- a/client/graph.h
+++ b/client/graph.h
@@ -15,9 +15,9 @@ void AppendGraph(int redraw, int clock, int bit);
 int ClearGraph(int redraw);
 int DetectClock(int peak);
 int GetClock(const char *str, int peak, int verbose);
+bool HasGraphData();
 
 #define MAX_GRAPH_TRACE_LEN (1024*128)
 extern int GraphBuffer[MAX_GRAPH_TRACE_LEN];
 extern int GraphTraceLen;
-
 #endif

diff --git a/client/ui.c b/client/ui.c
index 966ab2ca12f696501340b06fdafd7b981c5906fc..816bff44058dea8230617a1da3ad8e466b00d45d 100644 (file)
--- a/client/ui.c
+++ b/client/ui.c
@@ -95,14 +95,14 @@ void SetLogFilename(char *fn)
   logfilename = fn;
 }
 
-int manchester_decode( int * data, const size_t len, uint8_t * dataout){
+int manchester_decode( int * data, const size_t len, uint8_t * dataout,  size_t dataoutlen){
        
        int bitlength = 0;
        int i, clock, high, low, startindex;
        low = startindex = 0;
        high = 1;
-       uint8_t * bitStream =  (uint8_t* ) malloc(sizeof(uint8_t) * len);       
-       memset(bitStream, 0x00, len);
+       uint8_t * bitStream =  (uint8_t* ) malloc(sizeof(uint8_t) * dataoutlen);        
+       memset(bitStream, 0x00, dataoutlen);    
        
        /* Detect high and lows */
        for (i = 0; i < len; i++) {
@@ -116,12 +116,12 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout){
        clock = GetT55x7Clock( data, len, high );       
        startindex = DetectFirstTransition(data, len, high);
   
-       PrintAndLog(" Clock       : %d", clock);
+       //PrintAndLog(" Clock       : %d", clock);
 
        if (high != 1)
-               bitlength = ManchesterConvertFrom255(data, len, bitStream, high, low, clock, startindex);
+               bitlength = ManchesterConvertFrom255(data, len, bitStream, dataoutlen, high, low, clock, startindex);
        else
-               bitlength= ManchesterConvertFrom1(data, len, bitStream, clock, startindex);
+               bitlength= ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex);
 
        memcpy(dataout, bitStream, bitlength);
        free(bitStream);
@@ -192,7 +192,7 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout){
        return i;
  }
 
- int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout, int high, int low, int clock, int startIndex){
+ int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout, int dataoutlen, int high, int low, int clock, int startIndex){
 
        int i, j, z, hithigh, hitlow, bitIndex, startType;
        i = 0;
@@ -205,7 +205,7 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout){
        int firstST = 0;
 
        // i = clock frame of data
-       for (; i < (int)(len / clock); i++)
+       for (; i < (int)(len/clock); i++)
        {
                hithigh = 0;
                hitlow = 0;
@@ -261,11 +261,13 @@ int manchester_decode( int * data, const size_t len, uint8_t * dataout){
                
                if ( firstST == 4)
                        break;
+               if ( bitIndex >= dataoutlen-1 )
+                       break;
        }
        return bitIndex;
  }
  
- int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout, int clock, int startIndex){
+ int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout,int dataoutlen, int clock, int startIndex){
 
        PrintAndLog(" Path B");
  

diff --git a/client/ui.h b/client/ui.h
index 8d16e0592940a04da8146ae82c75fa8a2e716a3d..6a45fcfdabb65a545478bcf77d5f9a31a41331b0 100644 (file)
--- a/client/ui.h
+++ b/client/ui.h
@@ -27,13 +27,13 @@ extern int PlotGridX, PlotGridY, PlotGridXdefault, PlotGridYdefault;
 extern int offline;
 extern int flushAfterWrite;   //buzzy
 
-int manchester_decode( int * data, const size_t len, uint8_t * dataout);
+int manchester_decode( int * data, const size_t len, uint8_t * dataout,  size_t dataoutlen);
 int GetT55x7Clock( const int * data, const size_t len, int high );
 int DetectFirstTransition(const int * data, const size_t len, int low);
 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);
+int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout,int dataoutlen, int high, int low, int clock, int startIndex);
+int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout, int dataoutlen, int clock, int startIndex);
 void iceFsk2(int * data, const size_t len);
 void iceFsk3(int * data, const size_t len);
 #endif