]> git.zerfleddert.de Git - proxmark3-svn/commitdiff
split lf indala[cmd] to lf indala [cmd] 245/head
authormarshmellow42 <marshmellowrf@gmail.com>
Fri, 24 Mar 2017 23:18:33 +0000 (19:18 -0400)
committermarshmellow42 <marshmellowrf@gmail.com>
Fri, 24 Mar 2017 23:18:33 +0000 (19:18 -0400)
see changelog.md for cli changes!

CHANGELOG.md
client/Makefile
client/cmddata.c
client/cmddata.h
client/cmdlf.c
client/cmdlfindala.c [new file with mode: 0644]
client/cmdlfindala.h [new file with mode: 0644]

index abd2dd372dda283025d8f5ee6549da26edda9d1e..0e6187f47aa554c1479c86d453243d719bb2d2f4 100644 (file)
@@ -5,6 +5,7 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
 ## [unreleased][unreleased]
 
 ### Added
 ## [unreleased][unreleased]
 
 ### Added
+- Added lf indala read - reads an indala tag from the antenna
 - Added lf visa2000 demod, read, clone, sim commands (iceman)
 - Added markers in the graph around found Sequence Terminator after askmandemod.
 - Added data mtrim <start> <stop> command to trim out samples between start and stop
 - Added lf visa2000 demod, read, clone, sim commands (iceman)
 - Added markers in the graph around found Sequence Terminator after askmandemod.
 - Added data mtrim <start> <stop> command to trim out samples between start and stop
@@ -45,6 +46,9 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
 - Added option c to 'hf list' (mark CRC bytes) (piwi)
 
 ### Changed
 - Added option c to 'hf list' (mark CRC bytes) (piwi)
 
 ### Changed
+- `lf indalaclone` has been moved to `lf indala clone`
+- `lf indalademod` has been moved to `lf indala altdemod` (reads from graphbuffer)
+- `data pskindalademod` has been moved to `lf indala demod` (reads from graphbuffer)
 - `data askvikingdemod` has been moved to `lf viking demod` (reads from graphbuffer)
 - `data fskpyramiddemod` has been moved to `lf pyramid demod` (reads from graphbuffer)
 - `data fskiodemod` has been moved to `lf io demod` (reads from graphbuffer)
 - `data askvikingdemod` has been moved to `lf viking demod` (reads from graphbuffer)
 - `data fskpyramiddemod` has been moved to `lf pyramid demod` (reads from graphbuffer)
 - `data fskiodemod` has been moved to `lf io demod` (reads from graphbuffer)
index ac7e6f9804b51da30dc47472262d1e14be88ef07..511aaf2aa39c43ebc2aefb8643e029fe7eae499d 100644 (file)
@@ -95,6 +95,7 @@ CMDSRCS =     crapto1/crapto1.c\
                        cmdlfhid.c \
                        cmdlfhitag.c \
                        cmdlfio.c \
                        cmdlfhid.c \
                        cmdlfhitag.c \
                        cmdlfio.c \
+                       cmdlfindala.c \
                        cmdlfpcf7931.c\
                        cmdlfpresco.c\
                        cmdlfpyramid.c\
                        cmdlfpcf7931.c\
                        cmdlfpresco.c\
                        cmdlfpyramid.c\
index 49c94674c537d237decab1198aa66c68eb02f22c..3a7f3379ea9fe93758eb22e9c52de61f06538c33 100644 (file)
@@ -1056,59 +1056,6 @@ int PSKDemod(const char *Cmd, bool verbose)
        return 1;
 }
 
        return 1;
 }
 
-// Indala 26 bit decode
-// by marshmellow
-// optional arguments - same as CmdpskNRZrawDemod (clock & invert)
-int CmdIndalaDecode(const char *Cmd)
-{
-       int ans;
-       if (strlen(Cmd)>0){
-               ans = PSKDemod(Cmd, 0);
-       } else{ //default to RF/32
-               ans = PSKDemod("32", 0);
-       }
-
-       if (!ans){
-               if (g_debugMode) 
-                       PrintAndLog("Error1: %d",ans);
-               return 0;
-       }
-       uint8_t invert=0;
-       size_t size = DemodBufferLen;
-       int startIdx = indala26decode(DemodBuffer, &size, &invert);
-       if (startIdx < 0 || size > 224) {
-               if (g_debugMode)
-                       PrintAndLog("Error2: %d",ans);
-               return -1;
-       }
-       setDemodBuf(DemodBuffer, size, (size_t)startIdx);
-       if (invert)
-               if (g_debugMode)
-                       PrintAndLog("Had to invert bits");
-
-       PrintAndLog("BitLen: %d",DemodBufferLen);
-       //convert UID to HEX
-       uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
-       uid1=bytebits_to_byte(DemodBuffer,32);
-       uid2=bytebits_to_byte(DemodBuffer+32,32);
-       if (DemodBufferLen==64) {
-               PrintAndLog("Indala UID=%s (%x%08x)", sprint_bin_break(DemodBuffer,DemodBufferLen,16), uid1, uid2);
-       } else {
-               uid3=bytebits_to_byte(DemodBuffer+64,32);
-               uid4=bytebits_to_byte(DemodBuffer+96,32);
-               uid5=bytebits_to_byte(DemodBuffer+128,32);
-               uid6=bytebits_to_byte(DemodBuffer+160,32);
-               uid7=bytebits_to_byte(DemodBuffer+192,32);
-               PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", 
-                   sprint_bin_break(DemodBuffer,DemodBufferLen,16), uid1, uid2, uid3, uid4, uid5, uid6, uid7);
-       }
-       if (g_debugMode){
-               PrintAndLog("DEBUG: printing demodbuffer:");
-               printDemodBuff();
-       }
-       return 1;
-}
-
 int CmdPSKNexWatch(const char *Cmd)
 {
        if (!PSKDemod("", false)) return 0;
 int CmdPSKNexWatch(const char *Cmd)
 {
        if (!PSKDemod("", false)) return 0;
@@ -1854,7 +1801,6 @@ static command_t CommandTable[] =
        {"norm",            CmdNorm,            1, "Normalize max/min to +/-128"},
        {"plot",            CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
        {"printdemodbuffer",CmdPrintDemodBuff,  1, "[x] [o] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"},
        {"norm",            CmdNorm,            1, "Normalize max/min to +/-128"},
        {"plot",            CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
        {"printdemodbuffer",CmdPrintDemodBuff,  1, "[x] [o] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"},
-       {"pskindalademod",  CmdIndalaDecode,    1, "[clock] [invert<0|1>] -- Demodulate an indala tag (PSK1) from GraphBuffer (args optional)"},
        {"psknexwatchdemod",CmdPSKNexWatch,     1, "Demodulate a NexWatch tag (nexkey, quadrakey) (PSK1) from GraphBuffer"},
        {"rawdemod",        CmdRawDemod,        1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},  
        {"samples",         CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
        {"psknexwatchdemod",CmdPSKNexWatch,     1, "Demodulate a NexWatch tag (nexkey, quadrakey) (PSK1) from GraphBuffer"},
        {"rawdemod",        CmdRawDemod,        1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},  
        {"samples",         CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
index 552a37a1390163ba4ddb271757af39d6f8bfb8af..d66e586f0e847f252fe31c79d0cf022ea93e3004 100644 (file)
@@ -59,7 +59,6 @@ int CmdSave(const char *Cmd);
 int CmdScale(const char *Cmd);
 int CmdDirectionalThreshold(const char *Cmd);
 int CmdZerocrossings(const char *Cmd);
 int CmdScale(const char *Cmd);
 int CmdDirectionalThreshold(const char *Cmd);
 int CmdZerocrossings(const char *Cmd);
-int CmdIndalaDecode(const char *Cmd);
 int ASKbiphaseDemod(const char *Cmd, bool verbose);
 int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType);
 int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType, bool *stCheck);
 int ASKbiphaseDemod(const char *Cmd, bool verbose);
 int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType);
 int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType, bool *stCheck);
index f34637db837379a234cac31c0578b9563adafcfc..21203535bb8ffdbe9d4897c24731e49cb9b6a096 100644 (file)
@@ -35,6 +35,7 @@
 #include "cmdlfviking.h" // for viking menu
 #include "cmdlfcotag.h"  // for COTAG menu
 #include "cmdlfvisa2000.h"  // for VISA2000 menu
 #include "cmdlfviking.h" // for viking menu
 #include "cmdlfcotag.h"  // for COTAG menu
 #include "cmdlfvisa2000.h"  // for VISA2000 menu
+#include "cmdlfindala.h" // for indala menu
 
 bool g_lf_threshold_set = false;
 static int CmdHelp(const char *Cmd);
 
 bool g_lf_threshold_set = false;
 static int CmdHelp(const char *Cmd);
@@ -195,243 +196,7 @@ int CmdFlexdemod(const char *Cmd)
 
        RepaintGraphWindow();
        return 0;
 
        RepaintGraphWindow();
        return 0;
-}
-       
-int CmdIndalaDemod(const char *Cmd)
-{
-       // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID
-
-       int state = -1;
-       int count = 0;
-       int i, j;
-
-       // worst case with GraphTraceLen=64000 is < 4096
-       // under normal conditions it's < 2048
-
-       uint8_t rawbits[4096];
-       int rawbit = 0;
-       int worst = 0, worstPos = 0;
-       // PrintAndLog("Expecting a bit less than %d raw bits", GraphTraceLen / 32);
-       
-       // loop through raw signal - since we know it is psk1 rf/32 fc/2 skip every other value (+=2)
-       for (i = 0; i < GraphTraceLen-1; i += 2) {
-               count += 1;
-               if ((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {
-                       // appears redundant - marshmellow
-                       if (state == 0) {
-                               for (j = 0; j <  count - 8; j += 16) {
-                                       rawbits[rawbit++] = 0;
-                               }
-                               if ((abs(count - j)) > worst) {
-                                       worst = abs(count - j);
-                                       worstPos = i;
-                               }
-                       }
-                       state = 1;
-                       count = 0;
-               } else if ((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {
-                       //appears redundant
-                       if (state == 1) {
-                               for (j = 0; j <  count - 8; j += 16) {
-                                       rawbits[rawbit++] = 1;
-                               }
-                               if ((abs(count - j)) > worst) {
-                                       worst = abs(count - j);
-                                       worstPos = i;
-                               }
-                       }
-                       state = 0;
-                       count = 0;
-               }
-       }
-       
-       if (rawbit>0){
-               PrintAndLog("Recovered %d raw bits, expected: %d", rawbit, GraphTraceLen/32);
-               PrintAndLog("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);
-       } else {
-               return 0;
-       }
-
-       // Finding the start of a UID
-       int uidlen, long_wait;
-       if (strcmp(Cmd, "224") == 0) {
-               uidlen = 224;
-               long_wait = 30;
-       } else {
-               uidlen = 64;
-               long_wait = 29;
-       }
-
-       int start;
-       int first = 0;
-       for (start = 0; start <= rawbit - uidlen; start++) {
-               first = rawbits[start];
-               for (i = start; i < start + long_wait; i++) {
-                       if (rawbits[i] != first) {
-                               break;
-                       }
-               }
-               if (i == (start + long_wait)) {
-                       break;
-               }
-       }
-       
-       if (start == rawbit - uidlen + 1) {
-               PrintAndLog("nothing to wait for");
-               return 0;
-       }
-
-       // Inverting signal if needed
-       if (first == 1) {
-               for (i = start; i < rawbit; i++) {
-                       rawbits[i] = !rawbits[i];
-               }
-       }
-
-       // Dumping UID
-       uint8_t bits[224] = {0x00};
-       char showbits[225] = {0x00};
-       int bit;
-       i = start;
-       int times = 0;
-       
-       if (uidlen > rawbit) {
-               PrintAndLog("Warning: not enough raw bits to get a full UID");
-               for (bit = 0; bit < rawbit; bit++) {
-                       bits[bit] = rawbits[i++];
-                       // As we cannot know the parity, let's use "." and "/"
-                       showbits[bit] = '.' + bits[bit];
-               }
-               showbits[bit+1]='\0';
-               PrintAndLog("Partial UID=%s", showbits);
-               return 0;
-       } else {
-               for (bit = 0; bit < uidlen; bit++) {
-                       bits[bit] = rawbits[i++];
-                       showbits[bit] = '0' + bits[bit];
-               }
-               times = 1;
-       }
-       
-       //convert UID to HEX
-       uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
-       int idx;
-       uid1 = uid2 = 0;
-       
-       if (uidlen==64){
-               for( idx=0; idx<64; idx++) {
-                               if (showbits[idx] == '0') {
-                               uid1=(uid1<<1)|(uid2>>31);
-                               uid2=(uid2<<1)|0;
-                               } else {
-                               uid1=(uid1<<1)|(uid2>>31);
-                               uid2=(uid2<<1)|1;
-                               } 
-                       }
-               PrintAndLog("UID=%s (%x%08x)", showbits, uid1, uid2);
-       }
-       else {
-               uid3 = uid4 = uid5 = uid6 = uid7 = 0;
-
-               for( idx=0; idx<224; idx++) {
-                               uid1=(uid1<<1)|(uid2>>31);
-                               uid2=(uid2<<1)|(uid3>>31);
-                               uid3=(uid3<<1)|(uid4>>31);
-                               uid4=(uid4<<1)|(uid5>>31);
-                               uid5=(uid5<<1)|(uid6>>31);
-                               uid6=(uid6<<1)|(uid7>>31);
-                       
-                       if (showbits[idx] == '0') 
-                               uid7 = (uid7<<1) | 0;
-                       else 
-                               uid7 = (uid7<<1) | 1;
-                       }
-               PrintAndLog("UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
-       }
-
-       // Checking UID against next occurrences
-               int failed = 0;
-       for (; i + uidlen <= rawbit;) {
-               failed = 0;
-               for (bit = 0; bit < uidlen; bit++) {
-                       if (bits[bit] != rawbits[i++]) {
-                               failed = 1;
-                               break;
-                       }
-               }
-               if (failed == 1) {
-                       break;
-               }
-               times += 1;
-       }
-
-       PrintAndLog("Occurrences: %d (expected %d)", times, (rawbit - start) / uidlen);
-
-       // Remodulating for tag cloning
-       // HACK: 2015-01-04 this will have an impact on our new way of seening lf commands (demod) 
-       // since this changes graphbuffer data.
-       GraphTraceLen = 32*uidlen;
-       i = 0;
-       int phase = 0;
-       for (bit = 0; bit < uidlen; bit++) {
-               if (bits[bit] == 0) {
-                       phase = 0;
-               } else {
-                       phase = 1;
-               }
-               int j;
-               for (j = 0; j < 32; j++) {
-                       GraphBuffer[i++] = phase;
-                       phase = !phase;
-               }
-       }
-
-       RepaintGraphWindow();
-       return 1;
-}
-
-int CmdIndalaClone(const char *Cmd)
-{
-       UsbCommand c;
-       unsigned int uid1, uid2, uid3, uid4, uid5, uid6, uid7;
-
-       uid1 =  uid2 = uid3 = uid4 = uid5 = uid6 = uid7 = 0;
-       int n = 0, i = 0;
-
-       if (strchr(Cmd,'l') != 0) {
-               while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
-                       uid1 = (uid1 << 4) | (uid2 >> 28);
-                       uid2 = (uid2 << 4) | (uid3 >> 28);
-                       uid3 = (uid3 << 4) | (uid4 >> 28);
-                       uid4 = (uid4 << 4) | (uid5 >> 28);
-                       uid5 = (uid5 << 4) | (uid6 >> 28);
-                       uid6 = (uid6 << 4) | (uid7 >> 28);
-                       uid7 = (uid7 << 4) | (n & 0xf);
-               }
-               PrintAndLog("Cloning 224bit tag with UID %x%08x%08x%08x%08x%08x%08x", uid1, uid2, uid3, uid4, uid5, uid6, uid7);
-               c.cmd = CMD_INDALA_CLONE_TAG_L;
-               c.d.asDwords[0] = uid1;
-               c.d.asDwords[1] = uid2;
-               c.d.asDwords[2] = uid3;
-               c.d.asDwords[3] = uid4;
-               c.d.asDwords[4] = uid5;
-               c.d.asDwords[5] = uid6;
-               c.d.asDwords[6] = uid7;
-       } else {
-               while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
-                       uid1 = (uid1 << 4) | (uid2 >> 28);
-                       uid2 = (uid2 << 4) | (n & 0xf);
-               }
-               PrintAndLog("Cloning 64bit tag with UID %x%08x", uid1, uid2);
-               c.cmd = CMD_INDALA_CLONE_TAG;
-               c.arg[0] = uid1;
-               c.arg[1] = uid2;
-       }
-
-       clearCommandBuffer();
-       SendCommand(&c);
-       return 0;
-}
+}      
 
 int usage_lf_read(void)
 {
 
 int usage_lf_read(void)
 {
@@ -1281,6 +1046,7 @@ static command_t CommandTable[] =
        {"hid",         CmdLFHID,           1, "{ HID RFIDs...     }"},
        {"hitag",       CmdLFHitag,         1, "{ Hitag tags and transponders... }"},
        {"io",          CmdLFIO,            1, "{ ioProx tags...   }"},
        {"hid",         CmdLFHID,           1, "{ HID RFIDs...     }"},
        {"hitag",       CmdLFHitag,         1, "{ Hitag tags and transponders... }"},
        {"io",          CmdLFIO,            1, "{ ioProx tags...   }"},
+       {"indala",      CmdLFINDALA,        1, "{ Indala tags...   }"},
        {"presco",      CmdLFPresco,        1, "{ Presco RFIDs...  }"},
        {"pcf7931",     CmdLFPCF7931,       1, "{ PCF7931 RFIDs... }"},
        {"pyramid",     CmdLFPyramid,       1, "{ Farpointe/Pyramid RFIDs... }"},
        {"presco",      CmdLFPresco,        1, "{ Presco RFIDs...  }"},
        {"pcf7931",     CmdLFPCF7931,       1, "{ PCF7931 RFIDs... }"},
        {"pyramid",     CmdLFPyramid,       1, "{ Farpointe/Pyramid RFIDs... }"},
@@ -1291,8 +1057,6 @@ static command_t CommandTable[] =
        {"cmdread",     CmdLFCommandRead,   0, "<d period> <z period> <o period> <c command> ['H'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'H' for 134)"},
        {"config",      CmdLFSetConfig,     0, "Set config for LF sampling, bit/sample, decimation, frequency"},
        {"flexdemod",   CmdFlexdemod,       1, "Demodulate samples for FlexPass"},
        {"cmdread",     CmdLFCommandRead,   0, "<d period> <z period> <o period> <c command> ['H'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'H' for 134)"},
        {"config",      CmdLFSetConfig,     0, "Set config for LF sampling, bit/sample, decimation, frequency"},
        {"flexdemod",   CmdFlexdemod,       1, "Demodulate samples for FlexPass"},
-       {"indalademod", CmdIndalaDemod,     1, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},
-       {"indalaclone", CmdIndalaClone,     0, "<UID> ['l']-- Clone Indala to T55x7 (tag must be in antenna)(UID in HEX)(option 'l' for 224 UID"},
        {"read",        CmdLFRead,          0, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"},
        {"search",      CmdLFfind,          1, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) - 'u' to search for unknown tags"},
        {"sim",         CmdLFSim,           0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"},
        {"read",        CmdLFRead,          0, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"},
        {"search",      CmdLFfind,          1, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) - 'u' to search for unknown tags"},
        {"sim",         CmdLFSim,           0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"},
diff --git a/client/cmdlfindala.c b/client/cmdlfindala.c
new file mode 100644 (file)
index 0000000..1a1d2a0
--- /dev/null
@@ -0,0 +1,339 @@
+//-----------------------------------------------------------------------------
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Low frequency Indala commands
+//-----------------------------------------------------------------------------
+
+#include <stdio.h>
+#include <string.h>
+#include "cmdlfindala.h"
+#include "proxmark3.h"
+#include "ui.h"
+#include "graph.h"
+#include "cmdparser.h"
+#include "cmddata.h"  //for g_debugMode, demodbuff cmds
+#include "lfdemod.h"  //for indala26decode
+#include "util.h"     //for sprint_bin_break
+#include "cmdlf.h"    //for CmdLFRead
+#include "cmdmain.h"  //for clearCommandBuffer
+
+static int CmdHelp(const char *Cmd);
+
+// Indala 26 bit decode
+// by marshmellow
+// optional arguments - same as PSKDemod (clock & invert & maxerr)
+int CmdIndalaDecode(const char *Cmd) {
+       int ans;
+       if (strlen(Cmd)>0) {
+               ans = PSKDemod(Cmd, 0);
+       } else { //default to RF/32
+               ans = PSKDemod("32", 0);
+       }
+
+       if (!ans) {
+       if (g_debugMode) 
+               PrintAndLog("Error1: %i",ans);
+               return 0;
+       }
+       uint8_t invert=0;
+       size_t size = DemodBufferLen;
+       int startIdx = indala26decode(DemodBuffer, &size, &invert);
+       if (startIdx < 0 || size > 224) {
+               if (g_debugMode)
+               PrintAndLog("Error2: %i",startIdx);
+               return -1;
+       }
+       setDemodBuf(DemodBuffer, size, (size_t)startIdx);
+       if (invert)
+               if (g_debugMode)
+                       PrintAndLog("Had to invert bits");
+
+       PrintAndLog("BitLen: %d",DemodBufferLen);
+       //convert UID to HEX
+       uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
+       uid1=bytebits_to_byte(DemodBuffer,32);
+       uid2=bytebits_to_byte(DemodBuffer+32,32);
+       if (DemodBufferLen==64) {
+               PrintAndLog("Indala UID=%s (%x%08x)", sprint_bin_break(DemodBuffer,DemodBufferLen,16), uid1, uid2);
+       } else if (DemodBufferLen==224) {
+               uid3=bytebits_to_byte(DemodBuffer+64,32);
+               uid4=bytebits_to_byte(DemodBuffer+96,32);
+               uid5=bytebits_to_byte(DemodBuffer+128,32);
+               uid6=bytebits_to_byte(DemodBuffer+160,32);
+               uid7=bytebits_to_byte(DemodBuffer+192,32);
+               PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", 
+                   sprint_bin_break(DemodBuffer,DemodBufferLen,16), uid1, uid2, uid3, uid4, uid5, uid6, uid7);
+       }
+       if (g_debugMode) {
+               PrintAndLog("DEBUG: printing demodbuffer:");
+               printDemodBuff();
+       }
+       return 1;
+}
+
+int CmdIndalaRead(const char *Cmd) {
+       CmdLFRead("s");
+       getSamples("30000",false);
+       return CmdIndalaDecode("");
+}
+
+// older alternative indala demodulate (has some positives and negatives)
+// returns false positives more often - but runs against more sets of samples
+// poor psk signal can be difficult to demod this approach might succeed when the other fails
+// but the other appears to currently be more accurate than this approach most of the time.
+int CmdIndalaDemod(const char *Cmd) {
+       // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID
+
+       int state = -1;
+       int count = 0;
+       int i, j;
+
+       // worst case with GraphTraceLen=64000 is < 4096
+       // under normal conditions it's < 2048
+
+       uint8_t rawbits[4096];
+       int rawbit = 0;
+       int worst = 0, worstPos = 0;
+       // PrintAndLog("Expecting a bit less than %d raw bits", GraphTraceLen / 32);
+       
+       // loop through raw signal - since we know it is psk1 rf/32 fc/2 skip every other value (+=2)
+       for (i = 0; i < GraphTraceLen-1; i += 2) {
+               count += 1;
+               if ((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {
+                       // appears redundant - marshmellow
+                       if (state == 0) {
+                               for (j = 0; j <  count - 8; j += 16) {
+                                       rawbits[rawbit++] = 0;
+                               }
+                               if ((abs(count - j)) > worst) {
+                                       worst = abs(count - j);
+                                       worstPos = i;
+                               }
+                       }
+                       state = 1;
+                       count = 0;
+               } else if ((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {
+                       //appears redundant
+                       if (state == 1) {
+                               for (j = 0; j <  count - 8; j += 16) {
+                                       rawbits[rawbit++] = 1;
+                               }
+                               if ((abs(count - j)) > worst) {
+                                       worst = abs(count - j);
+                                       worstPos = i;
+                               }
+                       }
+                       state = 0;
+                       count = 0;
+               }
+       }
+       
+       if (rawbit>0){
+               PrintAndLog("Recovered %d raw bits, expected: %d", rawbit, GraphTraceLen/32);
+               PrintAndLog("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);
+       } else {
+               return 0;
+       }
+
+       // Finding the start of a UID
+       int uidlen, long_wait;
+       if (strcmp(Cmd, "224") == 0) {
+               uidlen = 224;
+               long_wait = 30;
+       } else {
+               uidlen = 64;
+               long_wait = 29;
+       }
+
+       int start;
+       int first = 0;
+       for (start = 0; start <= rawbit - uidlen; start++) {
+               first = rawbits[start];
+               for (i = start; i < start + long_wait; i++) {
+                       if (rawbits[i] != first) {
+                               break;
+                       }
+               }
+               if (i == (start + long_wait)) {
+                       break;
+               }
+       }
+       
+       if (start == rawbit - uidlen + 1) {
+               PrintAndLog("nothing to wait for");
+               return 0;
+       }
+
+       // Inverting signal if needed
+       if (first == 1) {
+               for (i = start; i < rawbit; i++) {
+                       rawbits[i] = !rawbits[i];
+               }
+       }
+
+       // Dumping UID
+       uint8_t bits[224] = {0x00};
+       char showbits[225] = {0x00};
+       int bit;
+       i = start;
+       int times = 0;
+       
+       if (uidlen > rawbit) {
+               PrintAndLog("Warning: not enough raw bits to get a full UID");
+               for (bit = 0; bit < rawbit; bit++) {
+                       bits[bit] = rawbits[i++];
+                       // As we cannot know the parity, let's use "." and "/"
+                       showbits[bit] = '.' + bits[bit];
+               }
+               showbits[bit+1]='\0';
+               PrintAndLog("Partial UID=%s", showbits);
+               return 0;
+       } else {
+               for (bit = 0; bit < uidlen; bit++) {
+                       bits[bit] = rawbits[i++];
+                       showbits[bit] = '0' + bits[bit];
+               }
+               times = 1;
+       }
+       
+       //convert UID to HEX
+       uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
+       int idx;
+       uid1 = uid2 = 0;
+       
+       if (uidlen==64){
+               for( idx=0; idx<64; idx++) {
+                               if (showbits[idx] == '0') {
+                               uid1=(uid1<<1)|(uid2>>31);
+                               uid2=(uid2<<1)|0;
+                               } else {
+                               uid1=(uid1<<1)|(uid2>>31);
+                               uid2=(uid2<<1)|1;
+                               } 
+                       }
+               PrintAndLog("UID=%s (%x%08x)", showbits, uid1, uid2);
+       }
+       else {
+               uid3 = uid4 = uid5 = uid6 = uid7 = 0;
+
+               for( idx=0; idx<224; idx++) {
+                               uid1=(uid1<<1)|(uid2>>31);
+                               uid2=(uid2<<1)|(uid3>>31);
+                               uid3=(uid3<<1)|(uid4>>31);
+                               uid4=(uid4<<1)|(uid5>>31);
+                               uid5=(uid5<<1)|(uid6>>31);
+                               uid6=(uid6<<1)|(uid7>>31);
+                       
+                       if (showbits[idx] == '0') 
+                               uid7 = (uid7<<1) | 0;
+                       else 
+                               uid7 = (uid7<<1) | 1;
+                       }
+               PrintAndLog("UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
+       }
+
+       // Checking UID against next occurrences
+               int failed = 0;
+       for (; i + uidlen <= rawbit;) {
+               failed = 0;
+               for (bit = 0; bit < uidlen; bit++) {
+                       if (bits[bit] != rawbits[i++]) {
+                               failed = 1;
+                               break;
+                       }
+               }
+               if (failed == 1) {
+                       break;
+               }
+               times += 1;
+       }
+
+       PrintAndLog("Occurrences: %d (expected %d)", times, (rawbit - start) / uidlen);
+
+       // Remodulating for tag cloning
+       // HACK: 2015-01-04 this will have an impact on our new way of seening lf commands (demod) 
+       // since this changes graphbuffer data.
+       GraphTraceLen = 32*uidlen;
+       i = 0;
+       int phase = 0;
+       for (bit = 0; bit < uidlen; bit++) {
+               if (bits[bit] == 0) {
+                       phase = 0;
+               } else {
+                       phase = 1;
+               }
+               int j;
+               for (j = 0; j < 32; j++) {
+                       GraphBuffer[i++] = phase;
+                       phase = !phase;
+               }
+       }
+
+       RepaintGraphWindow();
+       return 1;
+}
+
+int CmdIndalaClone(const char *Cmd) {
+       UsbCommand c;
+       unsigned int uid1, uid2, uid3, uid4, uid5, uid6, uid7;
+
+       uid1 =  uid2 = uid3 = uid4 = uid5 = uid6 = uid7 = 0;
+       int n = 0, i = 0;
+
+       if (strchr(Cmd,'l') != 0) {
+               while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
+                       uid1 = (uid1 << 4) | (uid2 >> 28);
+                       uid2 = (uid2 << 4) | (uid3 >> 28);
+                       uid3 = (uid3 << 4) | (uid4 >> 28);
+                       uid4 = (uid4 << 4) | (uid5 >> 28);
+                       uid5 = (uid5 << 4) | (uid6 >> 28);
+                       uid6 = (uid6 << 4) | (uid7 >> 28);
+                       uid7 = (uid7 << 4) | (n & 0xf);
+               }
+               PrintAndLog("Cloning 224bit tag with UID %x%08x%08x%08x%08x%08x%08x", uid1, uid2, uid3, uid4, uid5, uid6, uid7);
+               c.cmd = CMD_INDALA_CLONE_TAG_L;
+               c.d.asDwords[0] = uid1;
+               c.d.asDwords[1] = uid2;
+               c.d.asDwords[2] = uid3;
+               c.d.asDwords[3] = uid4;
+               c.d.asDwords[4] = uid5;
+               c.d.asDwords[5] = uid6;
+               c.d.asDwords[6] = uid7;
+       } else {
+               while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
+                       uid1 = (uid1 << 4) | (uid2 >> 28);
+                       uid2 = (uid2 << 4) | (n & 0xf);
+               }
+               PrintAndLog("Cloning 64bit tag with UID %x%08x", uid1, uid2);
+               c.cmd = CMD_INDALA_CLONE_TAG;
+               c.arg[0] = uid1;
+               c.arg[1] = uid2;
+       }
+
+       clearCommandBuffer();
+       SendCommand(&c);
+       return 0;
+}
+
+static command_t CommandTable[] = {
+       {"help",     CmdHelp,         1, "This help"},
+       {"demod",    CmdIndalaDecode, 1, "[clock] [invert<0|1>] -- Demodulate an indala tag (PSK1) from GraphBuffer (args optional)"},
+       {"read",     CmdIndalaRead,   0, "Read an Indala Prox tag from the antenna"},
+       {"clone",    CmdIndalaClone,  0, "<UID> ['l']-- Clone Indala to T55x7 (tag must be on antenna)(UID in HEX)(option 'l' for 224 UID"},
+       {"altdemod", CmdIndalaDemod,  1, "['224'] -- Alternative method to Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},
+       //{"sim",      CmdIndalaSim,    0, "<ID> -- indala tag simulator"},
+       {NULL, NULL, 0, NULL}
+};
+
+int CmdLFINDALA(const char *Cmd) {
+       CmdsParse(CommandTable, Cmd);
+       return 0;
+}
+
+int CmdHelp(const char *Cmd) {
+       CmdsHelp(CommandTable);
+       return 0;
+}
diff --git a/client/cmdlfindala.h b/client/cmdlfindala.h
new file mode 100644 (file)
index 0000000..7850241
--- /dev/null
@@ -0,0 +1,18 @@
+//-----------------------------------------------------------------------------
+//
+// This code is licensed to you under the terms of the GNU GPL, version 2 or,
+// at your option, any later version. See the LICENSE.txt file for the text of
+// the license.
+//-----------------------------------------------------------------------------
+// Low frequency Indala commands
+//-----------------------------------------------------------------------------
+
+#ifndef CMDLFINDALA_H__
+#define CMDLFINDALA_H__
+
+extern int CmdLFINDALA(const char *Cmd);
+extern int CmdIndalaDecode(const char *Cmd);
+extern int CmdIndalaRead(const char *Cmd);
+extern int CmdIndalaClone(const char *Cmd);
+
+#endif
Impressum, Datenschutz