Merge remote-tracking branch 'origin/DESFireAuth'

[proxmark3-svn] / client / cmddata.c

diff --git a/client/cmddata.c b/client/cmddata.c
index 265b0ed740414696b531a5fcec76044c45c39865..0ba04b794218b068daf347fd3c445c3c135ae504 100644 (file)
--- a/client/cmddata.c
+++ b/client/cmddata.c
@@ -17,9 +17,11 @@
 #include "ui.h"
 #include "graph.h"
 #include "cmdparser.h"
 #include "ui.h"
 #include "graph.h"
 #include "cmdparser.h"

+#include "util.h"

 #include "cmdmain.h"
 #include "cmddata.h"
 
 #include "cmdmain.h"
 #include "cmddata.h"
 

+

 static int CmdHelp(const char *Cmd);
 
 int CmdAmp(const char *Cmd)
 static int CmdHelp(const char *Cmd);
 
 int CmdAmp(const char *Cmd)


@@ -73,12 +75,14 @@ int Cmdaskdemod(const char *Cmd)
   int i;
   int c, high = 0, low = 0;
 
   int i;
   int c, high = 0, low = 0;
 

-  // TODO: complain if we do not give 2 arguments here !
-  // (AL - this doesn't make sense! we're only using one argument!!!)

   sscanf(Cmd, "%i", &c);
 
   sscanf(Cmd, "%i", &c);
 

-  /* Detect high and lows and clock */
-  // (AL - clock???)
+  if (c != 0 && c != 1) {
+    PrintAndLog("Invalid argument: %s", Cmd);
+    return 0;
+  }
+  
+  /* Detect high and lows */

   for (i = 0; i < GraphTraceLen; ++i)
   {
     if (GraphBuffer[i] > high)
   for (i = 0; i < GraphTraceLen; ++i)
   {
     if (GraphBuffer[i] > high)


@@ -86,11 +90,7 @@ int Cmdaskdemod(const char *Cmd)
     else if (GraphBuffer[i] < low)
       low = GraphBuffer[i];
   }
     else if (GraphBuffer[i] < low)
       low = GraphBuffer[i];
   }

-  if (c != 0 && c != 1) {
-    PrintAndLog("Invalid argument: %s", Cmd);
-    return 0;
-  }
-
+  

   if (GraphBuffer[0] > 0) {
     GraphBuffer[0] = 1-c;
   } else {
   if (GraphBuffer[0] > 0) {
     GraphBuffer[0] = 1-c;
   } else {


@@ -457,34 +457,90 @@ 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);
+       uint8_t got[36440] = {0x00};
+       
+       int n = strtol(Cmd, NULL, 0);
+       if (n == 0) 
+               n = 16000;
+       if (n > sizeof(got)) 
+               n = sizeof(got);

   
   

-  PrintAndLog("Reading %d samples\n", n);
-  GetFromBigBuf(got,n,0);
-  WaitForResponse(CMD_ACK,NULL);
-  for (int j = 0; j < n; j++) {
-    GraphBuffer[cnt++] = ((int)got[j]) - 128;
-  }
+       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 CmdTuneSamples(const char *Cmd)
+{
+       int timeout = 0;
+       printf("\nMeasuring antenna characteristics, please wait...");
+
+       UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING};
+       SendCommand(&c);
+
+       UsbCommand resp;
+       while(!WaitForResponseTimeout(CMD_MEASURED_ANTENNA_TUNING,&resp,1000)) {
+               timeout++;
+               printf(".");
+               if (timeout > 7) {
+                       PrintAndLog("\nNo response from Proxmark. Aborting...");
+                       return 1;
+               }
+       }
+
+       int peakv, peakf;
+       int vLf125, vLf134, vHf;
+       vLf125 = resp.arg[0] & 0xffff;
+       vLf134 = resp.arg[0] >> 16;
+       vHf = resp.arg[1] & 0xffff;;
+       peakf = resp.arg[2] & 0xffff;
+       peakv = resp.arg[2] >> 16;
+       PrintAndLog("");
+       PrintAndLog("# LF antenna: %5.2f V @   125.00 kHz", vLf125/1000.0);
+       PrintAndLog("# LF antenna: %5.2f V @   134.00 kHz", vLf134/1000.0);
+       PrintAndLog("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1));
+       PrintAndLog("# HF antenna: %5.2f V @    13.56 MHz", vHf/1000.0);
+       if (peakv<2000)
+               PrintAndLog("# Your LF antenna is unusable.");
+       else if (peakv<10000)
+               PrintAndLog("# Your LF antenna is marginal.");
+       if (vHf<2000)
+               PrintAndLog("# Your HF antenna is unusable.");
+       else if (vHf<5000)
+               PrintAndLog("# Your HF antenna is marginal.");
+
+       for (int i = 0; i < 256; i++) {
+               GraphBuffer[i] = resp.d.asBytes[i] - 128;
+       }

   
   

-  PrintAndLog("Done!\n");
-  GraphTraceLen = n;
-  RepaintGraphWindow();
+       PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
+       PrintAndLog("\n");
+       GraphTraceLen = 256;
+       ShowGraphWindow();
+

   return 0;
 }
 
   return 0;
 }
 

+

 int CmdLoad(const char *Cmd)
 {
 int CmdLoad(const char *Cmd)
 {

-  FILE *f = fopen(Cmd, "r");
-  if (!f) {
-    PrintAndLog("couldn't open '%s'", Cmd);
-    return 0;
-  }
+   char filename[FILE_PATH_SIZE] = {0x00};
+   int len = 0;
+
+   len = strlen(Cmd);
+   if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
+   memcpy(filename, Cmd, len);
+       
+   FILE *f = fopen(filename, "r");
+   if (!f) {
+     PrintAndLog("couldn't open '%s'", filename);
+     return 0;
+   }

 
   GraphTraceLen = 0;
   char line[80];
 
   GraphTraceLen = 0;
   char line[80];


@@ -555,7 +611,7 @@ int CmdManchesterDemod(const char *Cmd)
 
   /* But it does not work if compiling on WIndows: therefore we just allocate a */
   /* large array */
 
   /* But it does not work if compiling on WIndows: therefore we just allocate a */
   /* large array */

-  uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
+  uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0x00};

 
   /* Detect high and lows */
   for (i = 0; i < GraphTraceLen; i++)
 
   /* Detect high and lows */
   for (i = 0; i < GraphTraceLen; i++)


@@ -567,8 +623,7 @@ int CmdManchesterDemod(const char *Cmd)
   }
 
   /* Get our clock */
   }
 
   /* Get our clock */

-  clock = GetClock(Cmd, high, 1);
-
+  clock = GetClock(Cmd, high, 1); 

   int tolerance = clock/4;
 
   /* Detect first transition */
   int tolerance = clock/4;
 
   /* Detect first transition */


@@ -586,14 +641,15 @@ int CmdManchesterDemod(const char *Cmd)
       break;
     }
   }
       break;
     }
   }

-
+  

   /* If we're not working with 1/0s, demod based off clock */
   if (high != 1)
   {
   /* If we're not working with 1/0s, demod based off clock */
   if (high != 1)
   {

+       PrintAndLog("Entering path A"); 

     bit = 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; /* 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)(GraphTraceLen / clock); i++)
     {
       hithigh = 0;
     for (; i < (int)(GraphTraceLen / clock); i++)
     {
       hithigh = 0;


@@ -673,7 +729,9 @@ int CmdManchesterDemod(const char *Cmd)
     // 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
     // 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) {
+       
+       //http://www.proxmark.org/forum/viewtopic.php?id=403
+    for (i = 1; 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)) {
       if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
         BitStream[bit2idx++] = 1 ^ invert;
     } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {


@@ -682,7 +740,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)");
 


@@ -716,28 +774,29 @@ int CmdManchesterDemod(const char *Cmd)
       BitStream[i+14],
       BitStream[i+15]);
   }
       BitStream[i+14],
       BitStream[i+15]);
   }

-  return 0;
+  return bit2idx;

 }
 
 /* Modulate our data into manchester */
 int CmdManchesterMod(const char *Cmd)
 {
   int i, j;
 }
 
 /* Modulate our data into manchester */
 int CmdManchesterMod(const char *Cmd)
 {
   int i, j;

-  int clock;

   int bit, lastbit, wave;
   int bit, lastbit, wave;

-
-  /* Get our clock */
-  clock = GetClock(Cmd, 0, 1);
-
+  int clock = GetClock(Cmd, 0, 1);
+  int clock1 = GetT55x7Clock( GraphBuffer, GraphTraceLen, 0 );
+  PrintAndLog("MAN MOD CLOCKS:  %d  ice %d", clock,clock1);
+  
+  int half = (int)(clock/2);
+  

   wave = 0;
   lastbit = 1;
   for (i = 0; i < (int)(GraphTraceLen / clock); i++)
   {
     bit = GraphBuffer[i * clock] ^ 1;
 
   wave = 0;
   lastbit = 1;
   for (i = 0; i < (int)(GraphTraceLen / clock); i++)
   {
     bit = GraphBuffer[i * clock] ^ 1;
 

-    for (j = 0; j < (int)(clock/2); j++)
+    for (j = 0; j < half; ++j)

       GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;
       GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;

-    for (j = (int)(clock/2); j < clock; j++)
+    for (j = half; j < clock; ++j)

       GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
 
     /* Keep track of how we start our wave and if we changed or not this time */
       GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
 
     /* Keep track of how we start our wave and if we changed or not this time */


@@ -779,9 +838,17 @@ int CmdPlot(const char *Cmd)
 
 int CmdSave(const char *Cmd)
 {
 
 int CmdSave(const char *Cmd)
 {

-  FILE *f = fopen(Cmd, "w");
+   char filename[FILE_PATH_SIZE] = {0x00};
+   int len = 0;
+
+   len = strlen(Cmd);
+   if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
+   memcpy(filename, Cmd, len);
+   
+
+  FILE *f = fopen(filename, "w");

   if(!f) {
   if(!f) {

-    PrintAndLog("couldn't open '%s'", Cmd);
+    PrintAndLog("couldn't open '%s'", filename);

     return 0;
   }
   int i;
     return 0;
   }
   int i;


@@ -818,6 +885,41 @@ int CmdThreshold(const char *Cmd)
   return 0;
 }
 
   return 0;
 }
 

+int CmdDirectionalThreshold(const char *Cmd)
+{
+       int8_t upThres = param_get8(Cmd, 0);
+       int8_t downThres = param_get8(Cmd, 1);
+  
+  printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
+  
+  int lastValue = GraphBuffer[0];
+  GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
+  
+  for (int i = 1; i < GraphTraceLen; ++i) {
+    // Apply first threshold to samples heading up
+    if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
+    {
+      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
+      GraphBuffer[i] = 1;
+    }
+    // Apply second threshold to samples heading down
+    else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
+    {
+      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
+      GraphBuffer[i] = -1;
+    }
+    else
+    {
+      lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
+      GraphBuffer[i] = GraphBuffer[i-1];
+
+    }
+  }
+  GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
+  RepaintGraphWindow();
+  return 0;
+}
+

 int CmdZerocrossings(const char *Cmd)
 {
   // Zero-crossings aren't meaningful unless the signal is zero-mean.
 int CmdZerocrossings(const char *Cmd)
 {
   // Zero-crossings aren't meaningful unless the signal is zero-mean.


@@ -858,6 +960,7 @@ static command_t CommandTable[] =
   {"buffclear",     CmdBuffClear,       1, "Clear sample buffer and graph window"},
   {"dec",           CmdDec,             1, "Decimate samples"},
   {"detectclock",   CmdDetectClockRate, 1, "Detect clock rate"},
   {"buffclear",     CmdBuffClear,       1, "Clear sample buffer and graph window"},
   {"dec",           CmdDec,             1, "Decimate samples"},
   {"detectclock",   CmdDetectClockRate, 1, "Detect clock rate"},

+  {"dirthreshold",  CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},

   {"fskdemod",      CmdFSKdemod,        1, "Demodulate graph window as a HID FSK"},
   {"grid",          CmdGrid,            1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
   {"hexsamples",    CmdHexsamples,      0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},  
   {"fskdemod",      CmdFSKdemod,        1, "Demodulate graph window as a HID FSK"},
   {"grid",          CmdGrid,            1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
   {"hexsamples",    CmdHexsamples,      0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},  


@@ -873,6 +976,7 @@ static command_t CommandTable[] =
   {"save",          CmdSave,            1, "<filename> -- Save trace (from graph window)"},
   {"scale",         CmdScale,           1, "<int> -- Set cursor display scale"},
   {"threshold",     CmdThreshold,       1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
   {"save",          CmdSave,            1, "<filename> -- Save trace (from graph window)"},
   {"scale",         CmdScale,           1, "<int> -- Set cursor display scale"},
   {"threshold",     CmdThreshold,       1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},

+  {"tune",          CmdTuneSamples,     0, "Get hw tune samples for graph window"},

   {"zerocrossings", CmdZerocrossings,   1, "Count time between zero-crossings"},
   {NULL, NULL, 0, NULL}
 };
   {"zerocrossings", CmdZerocrossings,   1, "Count time between zero-crossings"},
   {NULL, NULL, 0, NULL}
 };