mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-02-23 18:27:28 -08:00
split lf indala[cmd] to lf indala [cmd]
see changelog.md for cli changes!
This commit is contained in:
parent
2b4898ec71
commit
0fb65a262b
@ -5,6 +5,7 @@ This project uses the changelog in accordance with [keepchangelog](http://keepac
|
||||
## [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
|
||||
@ -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
|
||||
- `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)
|
||||
|
@ -95,6 +95,7 @@ CMDSRCS = crapto1/crapto1.c\
|
||||
cmdlfhid.c \
|
||||
cmdlfhitag.c \
|
||||
cmdlfio.c \
|
||||
cmdlfindala.c \
|
||||
cmdlfpcf7931.c\
|
||||
cmdlfpresco.c\
|
||||
cmdlfpyramid.c\
|
||||
|
@ -1056,59 +1056,6 @@ int PSKDemod(const char *Cmd, bool verbose)
|
||||
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;
|
||||
@ -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"},
|
||||
{"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)"},
|
||||
|
@ -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 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);
|
||||
|
242
client/cmdlf.c
242
client/cmdlf.c
@ -35,6 +35,7 @@
|
||||
#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);
|
||||
@ -195,243 +196,7 @@ int CmdFlexdemod(const char *Cmd)
|
||||
|
||||
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)
|
||||
{
|
||||
@ -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... }"},
|
||||
{"indala", CmdLFINDALA, 1, "{ Indala tags... }"},
|
||||
{"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"},
|
||||
{"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)"},
|
||||
|
339
client/cmdlfindala.c
Normal file
339
client/cmdlfindala.c
Normal file
@ -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;
|
||||
}
|
18
client/cmdlfindala.h
Normal file
18
client/cmdlfindala.h
Normal file
@ -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
|
Loading…
x
Reference in New Issue
Block a user