github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-19 21:03:48 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

ADD: @marshmellow's fixes to awid, viking and T55x7

Browse source 
ADD: 'lf t55xx detect' now can be called with a password.
ADD: trying to add the read counter and increase counter commands for ntag sim.
This commit is contained in:
iceman1001 2015-11-22 17:33:41 +01:00
commit a126332a7b
14 changed files with 406 additions and 336 deletions
Download patch file Download diff file Expand all files Collapse all files

4
armsrc/appmain.c
View file

@ -1007,10 +1007,8 @@ void UsbPacketReceived(uint8_t *packet, int len)
CmdAWIDdemodFSK(c->arg[0], 0, 0, 1); CmdAWIDdemodFSK(c->arg[0], 0, 0, 1);
break; break;
case CMD_VIKING_CLONE_TAG: case CMD_VIKING_CLONE_TAG:
CopyViKingtoT55x7(c->arg[0],c->arg[1]); CopyVikingtoT55xx(c->arg[0], c->arg[1], c->arg[2]);
break; break;
#endif #endif
#ifdef WITH_HITAG #ifdef WITH_HITAG

9
armsrc/apps.h
View file

@ -74,6 +74,7 @@ void WriteTItag(uint32_t idhi, uint32_t idlo, uint16_t crc);
void AcquireTiType(void); void AcquireTiType(void);
void AcquireRawBitsTI(void); void AcquireRawBitsTI(void);
void SimulateTagLowFrequency(int period, int gap, int ledcontrol); void SimulateTagLowFrequency(int period, int gap, int ledcontrol);
void SimulateTagLowFrequencyBidir(int divisor, int max_bitlen);
void CmdHIDsimTAG(int hi, int lo, int ledcontrol); void CmdHIDsimTAG(int hi, int lo, int ledcontrol);
void CmdFSKsimTAG(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream); void CmdFSKsimTAG(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream);
void CmdASKsimTag(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream); void CmdASKsimTag(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream);
@ -83,21 +84,19 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol); // Realt
void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol); void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol);
void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol); void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol);
void CopyIOtoT55x7(uint32_t hi, uint32_t lo); // Clone an ioProx card to T5557/T5567 void CopyIOtoT55x7(uint32_t hi, uint32_t lo); // Clone an ioProx card to T5557/T5567
void SimulateTagLowFrequencyBidir(int divisor, int max_bitlen);
void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT); // Clone an HID card to T5557/T5567 void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT); // Clone an HID card to T5557/T5567
void CopyVikingtoT55xx(uint32_t block1, uint32_t block2, uint8_t Q5);
void WriteEM410x(uint32_t card, uint32_t id_hi, uint32_t id_lo); void WriteEM410x(uint32_t card, uint32_t id_hi, uint32_t id_lo);
void CopyIndala64toT55x7(uint32_t hi, uint32_t lo); // Clone Indala 64-bit tag by UID to T55x7 void CopyIndala64toT55x7(uint32_t hi, uint32_t lo); // Clone Indala 64-bit tag by UID to T55x7
void CopyIndala224toT55x7(uint32_t uid1, uint32_t uid2, uint32_t uid3, uint32_t uid4, uint32_t uid5, uint32_t uid6, uint32_t uid7); // Clone Indala 224-bit tag by UID to T55x7 void CopyIndala224toT55x7(uint32_t uid1, uint32_t uid2, uint32_t uid3, uint32_t uid4, uint32_t uid5, uint32_t uid6, uint32_t uid7); // Clone Indala 224-bit tag by UID to T55x7
void T55xxResetRead(void); void T55xxResetRead(void);
void T55xxWriteBlock(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t arg); void T55xxWriteBlock(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t PwdMode);
void T55xxWriteBlockExt(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t arg); void T55xxWriteBlockExt(uint32_t Data, uint8_t Block, uint32_t Pwd, uint8_t PwdMode);
void T55xxReadBlock(uint16_t arg0, uint8_t Block, uint32_t Pwd); void T55xxReadBlock(uint16_t arg0, uint8_t Block, uint32_t Pwd);
void T55xxWakeUp(uint32_t Pwd); void T55xxWakeUp(uint32_t Pwd);
void TurnReadLFOn(); void TurnReadLFOn();
void EM4xReadWord(uint8_t Address, uint32_t Pwd, uint8_t PwdMode); void EM4xReadWord(uint8_t Address, uint32_t Pwd, uint8_t PwdMode);
void EM4xWriteWord(uint32_t Data, uint8_t Address, uint32_t Pwd, uint8_t PwdMode); void EM4xWriteWord(uint32_t Data, uint8_t Address, uint32_t Pwd, uint8_t PwdMode);
void CopyViKingtoT55x7(uint32_t block1,uint32_t block2);
/// iso14443.h /// iso14443.h
void SimulateIso14443bTag(void); void SimulateIso14443bTag(void);

25
armsrc/iso14443a.c
View file

@ -1,4 +1,4 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Merlok - June 2011, 2012 // Merlok - June 2011, 2012
// Gerhard de Koning Gans - May 2008 // Gerhard de Koning Gans - May 2008
// Hagen Fritsch - June 2010 // Hagen Fritsch - June 2010
@ -939,6 +939,7 @@ bool prepare_allocated_tag_modulation(tag_response_info_t* response_info) {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void SimulateIso14443aTag(int tagType, int flags, byte_t* data) void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
{ {
uint32_t counters[] = {0,0,0};
//Here, we collect UID,NT,AR,NR,UID2,NT2,AR2,NR2 //Here, we collect UID,NT,AR,NR,UID2,NT2,AR2,NR2
// This can be used in a reader-only attack. // This can be used in a reader-only attack.
// (it can also be retrieved via 'hf 14a list', but hey... // (it can also be retrieved via 'hf 14a list', but hey...
@ -1182,7 +1183,7 @@ void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
// We already responded, do not send anything with the EmSendCmd14443aRaw() that is called below // We already responded, do not send anything with the EmSendCmd14443aRaw() that is called below
p_response = NULL; p_response = NULL;
} }
} else if(receivedCmd[0] == 0x3A) { // Received a FAST READ (ranged read) -- just returns all zeros. } else if(receivedCmd[0] == 0x3A) { // Received a FAST READ (ranged read)
uint8_t emdata[MAX_FRAME_SIZE]; uint8_t emdata[MAX_FRAME_SIZE];
int start = receivedCmd[1] * 4; int start = receivedCmd[1] * 4;
@ -1202,15 +1203,19 @@ void SimulateIso14443aTag(int tagType, int flags, byte_t* data)
AppendCrc14443a(data, sizeof(data)-2); AppendCrc14443a(data, sizeof(data)-2);
EmSendCmdEx(data,sizeof(data),false); EmSendCmdEx(data,sizeof(data),false);
p_response = NULL; p_response = NULL;
} else if(receivedCmd[0] == 0x39 && tagType == 7) { // Received a READ COUNTER -- } else if (receivedCmd[0] == 0x39 && tagType == 7) { // Received a READ COUNTER --
uint8_t data[] = {0x00,0x00,0x00,0x14,0xa5}; uint8_t counter = receivedCmd[1];
EmSendCmdEx(data,sizeof(data),false); uint32_t value = counters[counter];
p_response = NULL; uint8_t data[] = {0x00,0x00,0x00,0x14,0xa5};
} else if(receivedCmd[0] == 0xA5 && tagType == 7) { // Received a INC COUNTER -- AppendCrc14443a(data, sizeof(data)-2);
EmSendCmdEx(data,sizeof(data),false);
p_response = NULL;
} else if (receivedCmd[0] == 0xA5 && tagType == 7) { // Received a INC COUNTER --
// number of counter // number of counter
//uint8_t counter = receivedCmd[1]; uint8_t counter = receivedCmd[1];
//uint32_t val = bytes_to_num(receivedCmd+2,4); uint32_t val = bytes_to_num(receivedCmd+2,4);
counters[counter] = val;
// send ACK // send ACK
uint8_t ack[] = {0x0a}; uint8_t ack[] = {0x0a};
EmSendCmdEx(ack,sizeof(ack),false); EmSendCmdEx(ack,sizeof(ack),false);

23
armsrc/lfops.c
View file

@ -839,7 +839,7 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
size = 50*128*2; //big enough to catch 2 sequences of largest format size = 50*128*2; //big enough to catch 2 sequences of largest format
idx = AWIDdemodFSK(dest, &size); idx = AWIDdemodFSK(dest, &size);
if (idx>0 && size==96){ if (idx<=0 || size!=96) continue;
// Index map // Index map
// 0 10 20 30 40 50 60 // 0 10 20 30 40 50 60
// | | | | | | | // | | | | | | |
@ -859,6 +859,7 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
uint32_t rawHi2 = bytebits_to_byte(dest+idx,32); uint32_t rawHi2 = bytebits_to_byte(dest+idx,32);
size = removeParity(dest, idx+8, 4, 1, 88); size = removeParity(dest, idx+8, 4, 1, 88);
if (size != 66) continue;
// ok valid card found! // ok valid card found!
// Index map // Index map
@ -900,7 +901,6 @@ void CmdAWIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
return; return;
} }
// reset // reset
}
idx = 0; idx = 0;
WDT_HIT(); WDT_HIT();
} }
@ -1267,7 +1267,6 @@ void WriteT55xx(uint32_t *blockdata, uint8_t startblock, uint8_t numblocks) {
// Copy HID id to card and setup block 0 config // Copy HID id to card and setup block 0 config
void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT) { void CopyHIDtoT55x7(uint32_t hi2, uint32_t hi, uint32_t lo, uint8_t longFMT) {
uint32_t data[] = {0,0,0,0,0,0,0}; uint32_t data[] = {0,0,0,0,0,0,0};
//int data1=0, data2=0, data3=0, data4=0, data5=0, data6=0; //up to six blocks for long format
uint8_t last_block = 0; uint8_t last_block = 0;
if (longFMT){ if (longFMT){
@ -1357,6 +1356,15 @@ void CopyIndala224toT55x7(uint32_t uid1, uint32_t uid2, uint32_t uid3, uint32_t
// T5567WriteBlock(0x603E10E2,0); // T5567WriteBlock(0x603E10E2,0);
DbpString("DONE!"); DbpString("DONE!");
} }
// clone viking tag to T55xx
void CopyVikingtoT55xx(uint32_t block1, uint32_t block2, uint8_t Q5) {
uint32_t data[] = {T55x7_BITRATE_RF_32 | T55x7_MODULATION_MANCHESTER | (2 << T55x7_MAXBLOCK_SHIFT), block1, block2};
if (Q5) data[0] = (32 << T5555_BITRATE_SHIFT) | T5555_MODULATION_MANCHESTER | 2 << T5555_MAXBLOCK_SHIFT;
// Program the data blocks for supplied ID and the block 0 config
WriteT55xx(data, 0, 3);
LED_D_OFF();
cmd_send(CMD_ACK,0,0,0,0,0);
}
// Define 9bit header for EM410x tags // Define 9bit header for EM410x tags
#define EM410X_HEADER 0x1FF #define EM410X_HEADER 0x1FF
@ -1657,12 +1665,3 @@ void EM4xWriteWord(uint32_t Data, uint8_t Address, uint32_t Pwd, uint8_t PwdMode
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); // field off FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); // field off
LED_D_OFF(); LED_D_OFF();
} }
void CopyViKingtoT55x7(uint32_t block1, uint32_t block2) {
uint32_t data[] = {T55x7_BITRATE_RF_32 | T55x7_MODULATION_MANCHESTER | (2 << T55x7_MAXBLOCK_SHIFT), block1, block2};
// Program the data blocks for supplied ID and the block 0 config
WriteT55xx(data, 0, 3);
LED_D_OFF();
}

31
client/cmddata.c
View file

@ -635,6 +635,32 @@ int CmdG_Prox_II_Demod(const char *Cmd)
return 1; return 1;
} }
//by marshmellow
//see ASKDemod for what args are accepted
int CmdVikingDemod(const char *Cmd)
{
if (!ASKDemod(Cmd, false, false, 1)) {
if (g_debugMode) PrintAndLog("ASKDemod failed");
return 0;
}
size_t size = DemodBufferLen;
//call lfdemod.c demod for Viking
int ans = VikingDemod_AM(DemodBuffer, &size);
if (ans < 0) {
if (g_debugMode) PrintAndLog("Error Viking_Demod %d", ans);
return 0;
}
//got a good demod
uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans, 32);
uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
uint32_t cardid = bytebits_to_byte(DemodBuffer+ans+24, 32);
uint8_t checksum = bytebits_to_byte(DemodBuffer+ans+32+24, 8);
PrintAndLog("Viking Tag Found: Card ID %08X, Checksum: %02X", cardid, checksum);
PrintAndLog("Raw: %08X%08X", raw1,raw2);
setDemodBuf(DemodBuffer+ans, 64, 0);
return 1;
}
//by marshmellow - see ASKDemod //by marshmellow - see ASKDemod
int Cmdaskrawdemod(const char *Cmd) int Cmdaskrawdemod(const char *Cmd)
{ {
@ -1128,8 +1154,6 @@ int CmdFSKdemodParadox(const char *Cmd)
//print ioprox ID and some format details //print ioprox ID and some format details
int CmdFSKdemodIO(const char *Cmd) int CmdFSKdemodIO(const char *Cmd)
{ {
//raw fsk demod no manchester decoding no start bit finding just get binary from wave
//set defaults
int idx=0; int idx=0;
//something in graphbuffer? //something in graphbuffer?
if (GraphTraceLen < 65) { if (GraphTraceLen < 65) {
@ -1218,7 +1242,6 @@ int CmdFSKdemodIO(const char *Cmd)
//print full AWID Prox ID and some bit format details if found //print full AWID Prox ID and some bit format details if found
int CmdFSKdemodAWID(const char *Cmd) int CmdFSKdemodAWID(const char *Cmd)
{ {
//raw fsk demod no manchester decoding no start bit finding just get binary from wave
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
size_t size = getFromGraphBuf(BitStream); size_t size = getFromGraphBuf(BitStream);
if (size==0) return 0; if (size==0) return 0;
@ -2373,7 +2396,7 @@ static command_t CommandTable[] =
{"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"}, {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
{"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"}, {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
{"scale", CmdScale, 1, "<int> -- Set cursor display scale"}, {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
{"setdebugmode", CmdSetDebugMode, 1, "<0|1> -- Turn on or off Debugging Mode for demods"}, {"setdebugmode", CmdSetDebugMode, 1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
{"shiftgraphzero", CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"}, {"shiftgraphzero", CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
{"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."}, {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
{"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"}, {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},

6
client/cmdlf.c
View file

@ -192,7 +192,6 @@ int CmdLFCommandRead(const char *Cmd)
if (errors) return usage_lf_cmdread(); if (errors) return usage_lf_cmdread();
// in case they specified 'H' // in case they specified 'H'
// added to the end..
strcpy((char *)&c.d.asBytes + strLength, dummy); strcpy((char *)&c.d.asBytes + strLength, dummy);
clearCommandBuffer(); clearCommandBuffer();
@ -505,6 +504,7 @@ int CmdIndalaClone(const char *Cmd)
c.arg[1] = uid2; c.arg[1] = uid2;
} }
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
@ -582,6 +582,7 @@ int CmdLFSetConfig(const char *Cmd)
//Averaging is a flag on high-bit of arg[1] //Averaging is a flag on high-bit of arg[1]
UsbCommand c = {CMD_SET_LF_SAMPLING_CONFIG}; UsbCommand c = {CMD_SET_LF_SAMPLING_CONFIG};
memcpy(c.d.asBytes,&config,sizeof(sample_config)); memcpy(c.d.asBytes,&config,sizeof(sample_config));
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
@ -760,6 +761,7 @@ int CmdLFfskSim(const char *Cmd)
UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}}; UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}};
memcpy(c.d.asBytes, DemodBuffer, size); memcpy(c.d.asBytes, DemodBuffer, size);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
@ -853,6 +855,7 @@ int CmdLFaskSim(const char *Cmd)
UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}}; UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
PrintAndLog("preparing to sim ask data: %d bits", size); PrintAndLog("preparing to sim ask data: %d bits", size);
memcpy(c.d.asBytes, DemodBuffer, size); memcpy(c.d.asBytes, DemodBuffer, size);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
@ -960,6 +963,7 @@ int CmdLFpskSim(const char *Cmd)
UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}}; UsbCommand c = {CMD_PSK_SIM_TAG, {arg1, arg2, size}};
PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size); PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size);
memcpy(c.d.asBytes, DemodBuffer, size); memcpy(c.d.asBytes, DemodBuffer, size);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;

235
client/cmdlfawid.c
View file

@ -16,149 +16,93 @@
#include "cmdparser.h" // CmdsParse, CmdsHelp #include "cmdparser.h" // CmdsParse, CmdsHelp
#include "cmdlfawid.h" // AWID function declarations #include "cmdlfawid.h" // AWID function declarations
#include "lfdemod.h" // parityTest #include "lfdemod.h" // parityTest
#include "util.h" // weigandparity
#include "protocols.h" // for T55xx config register definitions
#include "cmdmain.h" #include "cmdmain.h"
static int CmdHelp(const char *Cmd); static int CmdHelp(const char *Cmd);
int usage_lf_awid_fskdemod(void) { int usage_lf_awid_fskdemod(void) {
PrintAndLog("Enables AWID26 compatible reader mode printing details of scanned AWID26 tags."); PrintAndLog("Enables AWID26 compatible reader mode printing details of scanned AWID26 tags.");
PrintAndLog("By default, values are printed and logged until the button is pressed or another USB command is issued."); PrintAndLog("By default, values are printed and logged until the button is pressed or another USB command is issued.");
PrintAndLog("If the ['1'] option is provided, reader mode is exited after reading a single AWID26 card."); PrintAndLog("If the ['1'] option is provided, reader mode is exited after reading a single AWID26 card.");
PrintAndLog(""); PrintAndLog("");
PrintAndLog("Usage: lf awid fskdemod ['1']"); PrintAndLog("Usage: lf awid fskdemod ['1']");
PrintAndLog("Options :"); PrintAndLog("Options :");
PrintAndLog(" 1 : (optional) stop after reading a single card"); PrintAndLog(" 1 : (optional) stop after reading a single card");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample : lf awid fskdemod"); PrintAndLog("Samples : lf awid fskdemod");
PrintAndLog(" : lf awid fskdemod 1"); PrintAndLog(" : lf awid fskdemod 1");
return 0; return 0;
} }
int usage_lf_awid_sim(void) { int usage_lf_awid_sim(void) {
PrintAndLog("Enables simulation of AWID26 card with specified facility-code and card number."); PrintAndLog("Enables simulation of AWID26 card with specified facility-code and card number.");
PrintAndLog("Simulation runs until the button is pressed or another USB command is issued."); PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit. Larger values are truncated."); PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit. Larger values are truncated.");
PrintAndLog(""); PrintAndLog("");
PrintAndLog("Usage: lf awid sim <Facility-Code> <Card-Number>"); PrintAndLog("Usage: lf awid sim <Facility-Code> <Card-Number>");
PrintAndLog("Options :"); PrintAndLog("Options :");
PrintAndLog(" <Facility-Code> : 8-bit value AWID facility code"); PrintAndLog(" <Facility-Code> : 8-bit value AWID facility code");
PrintAndLog(" <Card Number> : 16-bit value AWID card number"); PrintAndLog(" <Card Number> : 16-bit value AWID card number");
PrintAndLog(""); PrintAndLog("");
PrintAndLog("sample : lf awid sim 224 1337"); PrintAndLog("Sample : lf awid sim 224 1337");
return 0; return 0;
} }
int usage_lf_awid_clone(void) { int usage_lf_awid_clone(void) {
PrintAndLog("Enables cloning of AWID26 card with specified facility-code and card number onto T55x7."); PrintAndLog("Enables cloning of AWID26 card with specified facility-code and card number onto T55x7.");
PrintAndLog("The T55x7 must be on the antenna when issuing this command. T55x7 blocks are calculated and printed in the process."); PrintAndLog("The T55x7 must be on the antenna when issuing this command. T55x7 blocks are calculated and printed in the process.");
PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit. Larger values are truncated."); PrintAndLog("Per AWID26 format, the facility-code is 8-bit and the card number is 16-bit. Larger values are truncated.");
PrintAndLog(""); PrintAndLog("");
PrintAndLog("Usage: lf awid clone <Facility-Code> <Card-Number>"); PrintAndLog("Usage: lf awid clone <Facility-Code> <Card-Number>");
PrintAndLog("Options :"); PrintAndLog("Options :");
PrintAndLog(" <Facility-Code> : 8-bit value AWID facility code"); PrintAndLog(" <Facility-Code> : 8-bit value AWID facility code");
PrintAndLog(" <Card Number> : 16-bit value AWID card number"); PrintAndLog(" <Card Number> : 16-bit value AWID card number");
PrintAndLog(""); PrintAndLog(" Q5 : optional - clone to Q5 (T5555) instead of T55x7 chip");
PrintAndLog("sample : lf awid clone 224 1337"); PrintAndLog("");
return 0; PrintAndLog("Sample : lf awid clone 224 1337");
return 0;
} }
int CmdAWIDDemodFSK(const char *Cmd) { int CmdAWIDDemodFSK(const char *Cmd) {
int findone = 0; int findone = 0;
if (Cmd[0] == 'h' || Cmd[0] == 'H') return usage_lf_awid_fskdemod(); if (Cmd[0] == 'h' || Cmd[0] == 'H') return usage_lf_awid_fskdemod();
if (Cmd[0] == '1') findone = 1;
if (Cmd[0] == '1') findone = 1;
UsbCommand c = {CMD_AWID_DEMOD_FSK, {findone, 0, 0}};
UsbCommand c = {CMD_AWID_DEMOD_FSK, {findone, 0, 0}}; clearCommandBuffer();
clearCommandBuffer(); SendCommand(&c);
SendCommand(&c); return 0;
return 0;
} }
int getAWIDBits(unsigned int fc, unsigned int cn, uint8_t *AWIDBits) //refactored by marshmellow
{ int getAWIDBits(uint32_t fc, uint32_t cn, uint8_t *AWIDBits) {
//int i; uint8_t pre[66];
uint32_t fcode = (fc & 0x000000FF); memset(pre, 0, sizeof(pre));
uint32_t cnum = (cn & 0x0000FFFF); AWIDBits[7]=1;
uint32_t uBits = 0; num_to_bytebits(26, 8, pre);
if (fcode != fc)
PrintAndLog("NOTE: Facility code truncated for AWID26 format (8-bit facility code)");
if (cnum!=cn)
PrintAndLog("NOTE: Card number was truncated for AWID26 format (16-bit card number)");
uint8_t pre[] = {0x01, 0x1D, 0x80, 0x00,0x00,0x00,0x00, 0x11, 0x11, 0x11, 0x11, 0x11}; uint8_t wiegand[24];
memcpy(AWIDBits, pre , sizeof(pre)); num_to_bytebits(fc, 8, wiegand);
num_to_bytebits(cn, 16, wiegand+8);
// AWIDBits[0] = 0x01; // 6-bit Preamble with 2 parity bits
// AWIDBits[1] = 0x1D; // First byte from card format (26-bit) plus parity bits
// AWIDBits[2] = 0x80; // Set the next two bits as 0b10 to finish card format
// for (i = 7; i<12; i++) wiegand_add_parity(pre+8, wiegand, 24);
// AWIDBits[i]=0x11;
size_t bitLen = addParity(pre, AWIDBits+8, 66, 4, 1);
uBits = (fcode<<4) + (cnum>>12); if (bitLen != 88) return 0;
//for (uint8_t i = 0; i<3; i++){
if (!parityTest(uBits,12,0)) AWIDBits[2] |= (1<<5); // If not already even parity, set bit to make even // PrintAndLog("DEBUG: %08X", bytebits_to_byte(AWIDBits+(32*i),32));
//}
uBits = AWIDBits[2]>>5;
if (!parityTest(uBits, 3, 1)) AWIDBits[2] |= (1<<4);
uBits = fcode>>5; // first 3 bits of facility-code
AWIDBits[2] += (uBits<<1);
if (!parityTest(uBits, 3, 1)) AWIDBits[2]++; // Set parity bit to make odd parity
uBits = (fcode & 0x1C)>>2;
AWIDBits[3] = 0;
if (!parityTest(uBits,3,1)) AWIDBits[3] |= (1<<4);
AWIDBits[3] += (uBits<<5);
uBits = ((fcode & 0x3)<<1) + ((cnum & 0x8000)>>15); // Grab/shift 2 LSBs from facility code and add shifted MSB from cardnum
if (!parityTest(uBits,3,1)) AWIDBits[3]++; // Set LSB for parity
AWIDBits[3]+= (uBits<<1);
uBits = (cnum & 0x7000)>>12;
AWIDBits[4] = uBits<<5;
if (!parityTest(uBits,3,1)) AWIDBits[4] |= (1<<4);
uBits = (cnum & 0x0E00)>>9;
AWIDBits[4] += (uBits<<1);
if (!parityTest(uBits,3,1)) AWIDBits[4]++; // Set LSB for parity
uBits = (cnum & 0x1C0)>>6; // Next bits from card number
AWIDBits[5]=(uBits<<5);
if (!parityTest(uBits,3,1)) AWIDBits[5] |= (1<<4); // Set odd parity bit as needed
uBits = (cnum & 0x38)>>3;
AWIDBits[5]+= (uBits<<1);
if (!parityTest(uBits,3,1)) AWIDBits[5]++; // Set odd parity bit as needed
uBits = (cnum & 0x7); // Last three bits from card number!
AWIDBits[6] = (uBits<<5);
if (!parityTest(uBits,3,1)) AWIDBits[6] |= (1<<4);
uBits = (cnum & 0x0FFF);
if (!parityTest(uBits,12,1))
AWIDBits[6] |= (1<<3);
else
AWIDBits[6]++;
return 1; return 1;
} }
int CmdAWIDSim(const char *Cmd) int CmdAWIDSim(const char *Cmd) {
{ uint32_t fcode = 0, cnum = 0, fc=0, cn=0;
uint32_t fcode = 0, cnum = 0, fc=0, cn=0, i=0; uint8_t bits[96];
uint8_t bits[12]; uint8_t *bs = bits;
uint8_t *bs=bits; size_t size = sizeof(bits);
memset(bs, 0, size);
uint64_t arg1 = (10<<8) + 8; // fcHigh = 10, fcLow = 8 uint64_t arg1 = (10<<8) + 8; // fcHigh = 10, fcLow = 8
uint64_t arg2 = 50; // clk RF/50 invert=0 uint64_t arg2 = 50; // clk RF/50 invert=0
@ -179,30 +123,28 @@ int CmdAWIDSim(const char *Cmd)
return 1; return 1;
} }
// AWID uses: fcHigh: 10, fcLow: 8, clk: 50, invert: 0 // AWID uses: fcHigh: 10, fcLow: 8, clk: 50, invert: 0
PrintAndLog("Running 'lf simfsk c 50 H 10 L 8 d %s'", sprint_hex(bs, sizeof(bs)));
// arg1 --- fcHigh<<8 + fcLow // arg1 --- fcHigh<<8 + fcLow
// arg2 --- Inversion and clk setting // arg2 --- Inversion and clk setting
// 96 --- Bitstream length: 96-bits == 12 bytes // 96 --- Bitstream length: 96-bits == 12 bytes
UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, 96}}; UsbCommand c = {CMD_FSK_SIM_TAG, {arg1, arg2, size}};
memcpy(c.d.asBytes, bs, size);
for (i=0; i < 96; i++)
c.d.asBytes[i] = (bs[i/8] & (1<<(7-(i%8)))) ? 1 : 0;
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
int CmdAWIDClone(const char *Cmd) int CmdAWIDClone(const char *Cmd) {
{ uint32_t blocks[4] = {T55x7_MODULATION_FSK2a | T55x7_BITRATE_RF_50 | 3<<T55x7_MAXBLOCK_SHIFT, 0, 0, 0};
uint32_t blocks[4] = {0x00107060, 0, 0, 0x11111111}; uint32_t fc=0,cn=0;
uint32_t fc=0, cn=0, i=0; uint8_t bits[96];
uint8_t bits[12];
uint8_t *bs=bits; uint8_t *bs=bits;
memset(bs,0,sizeof(bits));
if (sscanf(Cmd, "%u %u", &fc, &cn ) != 2) return usage_lf_awid_clone(); if (sscanf(Cmd, "%u %u", &fc, &cn ) != 2) return usage_lf_awid_clone();
if (param_getchar(Cmd, 3) == 'Q' || param_getchar(Cmd, 3) == 'q')
blocks[0] = T5555_MODULATION_FSK2 | T5555_INVERT_OUTPUT | 50<<T5555_BITRATE_SHIFT | 3<<T5555_MAXBLOCK_SHIFT;
if ((fc & 0xFF) != fc) { if ((fc & 0xFF) != fc) {
fc &= 0xFF; fc &= 0xFF;
PrintAndLog("Facility-Code Truncated to 8-bits (AWID26): %u", fc); PrintAndLog("Facility-Code Truncated to 8-bits (AWID26): %u", fc);
@ -218,12 +160,12 @@ int CmdAWIDClone(const char *Cmd)
return 1; return 1;
} }
PrintAndLog("Preparing to clone AWID26 to T55x7 with FC: %u, CN: %u ", fc, cn); blocks[1] = bytebits_to_byte(bs,32);
PrintAndLog("Raw: %s", sprint_hex(bs, sizeof(bs))); blocks[2] = bytebits_to_byte(bs+32,32);
blocks[3] = bytebits_to_byte(bs+64,32);
blocks[1] = (bs[0]<<24) + (bs[1]<<16) + (bs[2]<<8) + (bs[3]); PrintAndLog("Preparing to clone AWID26 to T55x7 with FC: %u, CN: %u",
blocks[2] = (bs[4]<<24) + (bs[5]<<16) + (bs[6]<<8) + (bs[7]); fc, cn);
PrintAndLog("Blk | Data "); PrintAndLog("Blk | Data ");
PrintAndLog("----+------------"); PrintAndLog("----+------------");
PrintAndLog(" 00 | 0x%08x", blocks[0]); PrintAndLog(" 00 | 0x%08x", blocks[0]);
@ -234,7 +176,7 @@ int CmdAWIDClone(const char *Cmd)
UsbCommand resp; UsbCommand resp;
UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}}; UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}};
for (i=0; i<4; i++) { for (uint8_t i=0; i<4; i++) {
c.arg[0] = blocks[i]; c.arg[0] = blocks[i];
c.arg[1] = i; c.arg[1] = i;
clearCommandBuffer(); clearCommandBuffer();
@ -247,23 +189,20 @@ int CmdAWIDClone(const char *Cmd)
return 0; return 0;
} }
static command_t CommandTable[] = static command_t CommandTable[] = {
{
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"fskdemod", CmdAWIDDemodFSK, 0, "['1'] Realtime AWID FSK demodulator (option '1' for one tag only)"}, {"fskdemod", CmdAWIDDemodFSK, 0, "['1'] Realtime AWID FSK demodulator (option '1' for one tag only)"},
{"sim", CmdAWIDSim, 0, "<Facility-Code> <Card Number> -- AWID tag simulator"}, {"sim", CmdAWIDSim, 0, "<Facility-Code> <Card Number> -- AWID tag simulator"},
{"clone", CmdAWIDClone, 0, "<Facility-Code> <Card Number> -- Clone AWID to T55x7 (tag must be in range of antenna)"}, {"clone", CmdAWIDClone, 0, "<Facility-Code> <Card Number> <Q5> -- Clone AWID to T55x7"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
int CmdLFAWID(const char *Cmd) int CmdLFAWID(const char *Cmd) {
{
CmdsParse(CommandTable, Cmd); CmdsParse(CommandTable, Cmd);
return 0; return 0;
} }
int CmdHelp(const char *Cmd) int CmdHelp(const char *Cmd) {
{
CmdsHelp(CommandTable); CmdsHelp(CommandTable);
return 0; return 0;
} }

72
client/cmdlft55xx.c
View file

@ -126,13 +126,15 @@ int usage_t55xx_dump(){
return 0; return 0;
} }
int usage_t55xx_detect(){ int usage_t55xx_detect(){
PrintAndLog("Usage: lf t55xx detect [1]"); PrintAndLog("Usage: lf t55xx detect [1] [p <password>]");
PrintAndLog("Options:"); PrintAndLog("Options:");
PrintAndLog(" [graph buffer data] - if set, use Graphbuffer otherwise read data from tag."); PrintAndLog(" 1 - if set, use Graphbuffer otherwise read data from tag.");
PrintAndLog(" p <password> - OPTIONAL password (8 hex characters)");
PrintAndLog(""); PrintAndLog("");
PrintAndLog("Examples:"); PrintAndLog("Examples:");
PrintAndLog(" lf t55xx detect"); PrintAndLog(" lf t55xx detect");
PrintAndLog(" lf t55xx detect 1"); PrintAndLog(" lf t55xx detect 1");
PrintAndLog(" lf t55xx detect 11223344");
PrintAndLog(""); PrintAndLog("");
return 0; return 0;
} }
@ -397,28 +399,41 @@ bool DecodeT55xxBlock(){
int CmdT55xxDetect(const char *Cmd){ int CmdT55xxDetect(const char *Cmd){
//bool override = false; bool errors = FALSE;
//bool pwdmode = false; bool useGB = FALSE;
bool usepwd = FALSE;
uint32_t password = 0;
uint8_t cmdp = 0;
uint32_t password = 0; //default to blank Block 7 while(param_getchar(Cmd, cmdp) != 0x00 && !errors) {
bool usepwd = ( strlen(Cmd) > 0); switch(param_getchar(Cmd, cmdp)) {
if ( usepwd ){ case 'h':
password = param_get32ex(Cmd, 0, 0, 16); case 'H':
// if (param_getchar(Cmd, 1) =='o' ) return usage_t55xx_detect();
// override = true; case 'p':
case 'P':
password = param_get32ex(Cmd, cmdp+1, 0, 16);
usepwd = TRUE;
cmdp += 2;
break;
case '1':
// use Graphbuffer data
useGB = TRUE;
cmdp++;
break;
default:
PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
errors = true;
break;
}
} }
if (errors) return usage_t55xx_detect();
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') return usage_t55xx_detect();
if (strlen(Cmd)==0) { if ( !useGB) {
password = param_get32ex(Cmd, 0, 0, 16); if ( !AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, usepwd, password) )
//if (param_getchar(Cmd, 1) =='o' ) override = true; return 0;
} }
if ( !AquireData(T55x7_PAGE0, T55x7_CONFIGURATION_BLOCK, usepwd, password) )
return 0;
if ( !tryDetectModulation() ) if ( !tryDetectModulation() )
PrintAndLog("Could not detect modulation automatically. Try setting it manually with \'lf t55xx config\'"); PrintAndLog("Could not detect modulation automatically. Try setting it manually with \'lf t55xx config\'");
@ -1242,7 +1257,7 @@ void t55x7_create_config_block( int tagtype ){
static char buf[60]; static char buf[60];
char *retStr = buf; char *retStr = buf;
switch (id){ switch (tagtype){
case 0: snprintf(retStr, sizeof(buf),"%08X - T55X7 Default", T55X7_DEFAULT_CONFIG_BLOCK); break; case 0: snprintf(retStr, sizeof(buf),"%08X - T55X7 Default", T55X7_DEFAULT_CONFIG_BLOCK); break;
case 1: snprintf(retStr, sizeof(buf),"%08X - T55X7 Raw", T55X7_RAW_CONFIG_BLOCK); break; case 1: snprintf(retStr, sizeof(buf),"%08X - T55X7 Raw", T55X7_RAW_CONFIG_BLOCK); break;
default: default:
@ -1292,16 +1307,15 @@ int CmdT55xxWipe(const char *Cmd) {
return 0; return 0;
} }
static command_t CommandTable[] = static command_t CommandTable[] = {
{
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"config", CmdT55xxSetConfig, 1, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"}, {"config", CmdT55xxSetConfig, 1, "Set/Get T55XX configuration (modulation, inverted, offset, rate)"},
{"detect", CmdT55xxDetect, 0, "[1] Try detecting the tag modulation from reading the configuration block."}, {"detect", CmdT55xxDetect, 1, "[1] Try detecting the tag modulation from reading the configuration block."},
{"read", CmdT55xxReadBlock, 0, "b <block> p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"}, {"read", CmdT55xxReadBlock, 0, "b <block> p [password] [o] [1] -- Read T55xx block data. Optional [p password], [override], [page1]"},
{"resetread",CmdResetRead, 0, "Send Reset Cmd then lf read the stream to attempt to identify the start of it (needs a demod and/or plot after)"}, {"resetread",CmdResetRead, 0, "Send Reset Cmd then lf read the stream to attempt to identify the start of it (needs a demod and/or plot after)"},
{"write", CmdT55xxWriteBlock,0, "b <block> d <data> p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"}, {"write", CmdT55xxWriteBlock,0, "b <block> d <data> p [password] [1] -- Write T55xx block data. Optional [p password], [page1]"},
{"trace", CmdT55xxReadTrace, 0, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"}, {"trace", CmdT55xxReadTrace, 1, "[1] Show T55x7 traceability data (page 1/ blk 0-1)"},
{"info", CmdT55xxInfo, 0, "[1] Show T55x7 configuration data (page 0/ blk 0)"}, {"info", CmdT55xxInfo, 1, "[1] Show T55x7 configuration data (page 0/ blk 0)"},
{"dump", CmdT55xxDump, 0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"}, {"dump", CmdT55xxDump, 0, "[password] [o] Dump T55xx card block 0-7. Optional [password], [override]"},
{"special", special, 0, "Show block changes with 64 different offsets"}, {"special", special, 0, "Show block changes with 64 different offsets"},
{"wakeup", CmdT55xxWakeUp, 0, "Send AOR wakeup command"}, {"wakeup", CmdT55xxWakeUp, 0, "Send AOR wakeup command"},
@ -1309,14 +1323,12 @@ static command_t CommandTable[] =
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
int CmdLFT55XX(const char *Cmd) int CmdLFT55XX(const char *Cmd) {
{
CmdsParse(CommandTable, Cmd); CmdsParse(CommandTable, Cmd);
return 0; return 0;
} }
int CmdHelp(const char *Cmd) int CmdHelp(const char *Cmd) {
{
CmdsHelp(CommandTable); CmdsHelp(CommandTable);
return 0; return 0;
} }

139
client/cmdlfviking.c
View file

@ -1,3 +1,11 @@
//-----------------------------------------------------------------------------
//
// 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 Viking tag commands
//-----------------------------------------------------------------------------
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <inttypes.h> #include <inttypes.h>
@ -15,76 +23,111 @@ static int CmdHelp(const char *Cmd);
int usage_lf_viking_clone(void){ int usage_lf_viking_clone(void){
PrintAndLog("clone a Viking AM tag to a T55x7 tag."); PrintAndLog("clone a Viking AM tag to a T55x7 tag.");
PrintAndLog("Usage: lf viking clone <Card ID 16 bytes of hex number>"); PrintAndLog("Usage: lf viking clone <Card ID - 8 hex digits> <Q5>");
PrintAndLog("Options :");
PrintAndLog(" <Card Number> : 8 digit hex viking card number");
PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
PrintAndLog("");
PrintAndLog("Sample : lf viking clone 1A337 Q5");
return 0; return 0;
} }
//by marshmellow int usage_lf_viking_sim(void) {
//see ASKDemod for what args are accepted PrintAndLog("Enables simulation of viking card with specified card number.");
int CmdVikingDemod(const char *Cmd) PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
{ PrintAndLog("Per viking format, the card number is 8 digit hex number. Larger values are truncated.");
//CmdLFRead("s"); PrintAndLog("");
//getSamples("30000",false); PrintAndLog("Usage: lf viking sim <Card-Number>");
PrintAndLog("Options :");
if (!ASKDemod(Cmd, false, false, 1)) { PrintAndLog(" <Card Number> : 8 digit hex viking card number");
if (g_debugMode) PrintAndLog("ASKDemod failed"); PrintAndLog("");
return 0; PrintAndLog("Sample : lf viking sim 1A337");
} return 0;
size_t size = DemodBufferLen;
int ans = VikingDemod_AM(DemodBuffer, &size);
if (ans < 0) {
if (g_debugMode) PrintAndLog("Error Viking_Demod %d", ans);
return 0;
}
//got a good demod
uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans, 32);
uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
uint32_t cardid = bytebits_to_byte(DemodBuffer+ans+24, 32);
uint8_t checksum = bytebits_to_byte(DemodBuffer+ans+32+24, 8);
PrintAndLog("Viking Tag Found: Card ID %08X, Checksum: %02X", cardid, checksum);
PrintAndLog("Raw: %08X%08X", raw1,raw2);
setDemodBuf(DemodBuffer+ans, 64, 0);
return 1;
} }
int CmdVikingClone(const char *Cmd) // calc checksum
{ uint64_t getVikingBits(uint32_t id) {
uint32_t b1,b2; uint8_t checksum = (id>>24) ^ ((id>>16) & 0xFF) ^ ((id>>8) & 0xFF) ^ (id & 0xFF) ^ 0xF2 ^ 0xA8;
// get the tag number 64 bits (8 bytes) in hex uint64_t ret = (uint64_t)0xF2 << 56;
uint8_t id[8]; ret |= (id << 8);
ret |= checksum;
return ret;
}
//by marshmellow
//see ASKDemod for what args are accepted
int CmdVikingRead(const char *Cmd) {
// read lf silently
CmdLFRead("s");
// get samples silently
getSamples("30000",false);
// demod and output viking ID
return CmdVikingDemod(Cmd);
}
int CmdVikingClone(const char *Cmd) {
uint32_t id = 0;
uint64_t rawID = 0;
bool Q5 = false;
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) < 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_viking_clone(); if (strlen(Cmd) < 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_viking_clone();
if (param_gethex(Cmd, 0, id, 16) == 1) id = param_get32ex(Cmd, 0, 0, 16);
return usage_lf_viking_clone(); if (id == 0) return usage_lf_viking_clone();
b1 = bytes_to_num(id, sizeof(uint32_t)); cmdp = param_getchar(Cmd, 1);
b2 = bytes_to_num(id + sizeof(uint32_t), sizeof(uint32_t)); if ( cmdp == 'Q' || cmdp == 'q')
UsbCommand c = {CMD_VIKING_CLONE_TAG,{b1,b2}}; Q5 = true;
rawID = getVikingBits(id);
UsbCommand c = {CMD_VIKING_CLONE_TAG,{rawID >> 32, rawID & 0xFFFF, Q5}};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
//check for ACK? //check for ACK
WaitForResponse(CMD_ACK,NULL);
return 0; return 0;
} }
static command_t CommandTable[] = int CmdVikingSim(const char *Cmd) {
{ uint32_t id = 0;
uint64_t rawID = 0;
uint8_t clk = 32, encoding = 1, separator = 0, invert = 0;
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) < 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_viking_sim();
id = param_get32ex(Cmd, 0, 0, 16);
if (id == 0) return usage_lf_viking_sim();
rawID = getVikingBits(id);
uint16_t arg1, arg2;
size_t size = 64;
arg1 = clk << 8 | encoding;
arg2 = invert << 8 | separator;
UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
PrintAndLog("preparing to sim ask data: %d bits", size);
num_to_bytebits(rawID, 64, c.d.asBytes);
clearCommandBuffer();
SendCommand(&c);
return 0;
}
static command_t CommandTable[] = {
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"demod", CmdVikingDemod, 1, "Extract tag data"}, {"read", CmdVikingRead, 0, "Attempt to read and Extract tag data"},
{"clone", CmdVikingClone, 1, "<16 digits card data> clone viking tag"}, {"clone", CmdVikingClone, 0, "<8 digit ID number> clone viking tag"},
{"sim", CmdVikingSim, 0, "<8 digit ID number> simulate viking tag"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
int CmdLFViking(const char *Cmd) int CmdLFViking(const char *Cmd) {
{
CmdsParse(CommandTable, Cmd); CmdsParse(CommandTable, Cmd);
return 0; return 0;
} }
int CmdHelp(const char *Cmd) int CmdHelp(const char *Cmd) {
{
CmdsHelp(CommandTable); CmdsHelp(CommandTable);
return 0; return 0;
} }

11
client/cmdlfviking.h
View file

@ -1,7 +1,16 @@
//-----------------------------------------------------------------------------
//
// 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 T55xx commands
//-----------------------------------------------------------------------------
#ifndef CMDLFVIKING_H__ #ifndef CMDLFVIKING_H__
#define CMDLFVIKING_H__ #define CMDLFVIKING_H__
int CmdLFViking(const char *Cmd); int CmdLFViking(const char *Cmd);
int CmdVikingDemod(const char *Cmd); int CmdVikingRead(const char *Cmd);
int CmdVikingClone(const char *Cmd); int CmdVikingClone(const char *Cmd);
int CmdVikingSim(const char *Cmd);
#endif #endif

11
client/util.c
View file

@ -159,6 +159,13 @@ uint64_t bytes_to_num(uint8_t* src, size_t len)
return num; return num;
} }
void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest) {
while (len--) {
dest[len] = n & 1;
n >>= 1;
}
}
// aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp // aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
// to // to
// hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii // hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii
@ -445,7 +452,7 @@ void binarraytobinstring(char *target, char *source, int length)
} }
// return parity bit required to match type // return parity bit required to match type
uint8_t GetParity( char *bits, uint8_t type, int length) uint8_t GetParity( uint8_t *bits, uint8_t type, int length)
{ {
int x; int x;
@ -457,7 +464,7 @@ uint8_t GetParity( char *bits, uint8_t type, int length)
} }
// add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half // add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half
void wiegand_add_parity(char *target, char *source, char length) void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length)
{ {
*(target++)= GetParity(source, EVEN, length / 2); *(target++)= GetParity(source, EVEN, length / 2);
memcpy(target, source, length); memcpy(target, source, length);

5
client/util.h
View file

@ -43,6 +43,7 @@ char * sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t bre
void num_to_bytes(uint64_t n, size_t len, uint8_t* dest); void num_to_bytes(uint64_t n, size_t len, uint8_t* dest);
uint64_t bytes_to_num(uint8_t* src, size_t len); uint64_t bytes_to_num(uint8_t* src, size_t len);
void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest);
char * printBits(size_t const size, void const * const ptr); char * printBits(size_t const size, void const * const ptr);
uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize); uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize);
@ -62,8 +63,8 @@ int param_getstr(const char *line, int paramnum, char * str);
int hextobinstring( char *target, char *source); int hextobinstring( char *target, char *source);
int binarraytohex( char *target, char *source, int length); int binarraytohex( char *target, char *source, int length);
void binarraytobinstring(char *target, char *source, int length); void binarraytobinstring(char *target, char *source, int length);
uint8_t GetParity( char *string, uint8_t type, int length); uint8_t GetParity( uint8_t *string, uint8_t type, int length);
void wiegand_add_parity(char *target, char *source, char length); void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length);
void xor(unsigned char * dst, unsigned char * src, size_t len); void xor(unsigned char * dst, unsigned char * src, size_t len);
int32_t le24toh (uint8_t data[3]); int32_t le24toh (uint8_t data[3]);

170
common/lfdemod.c
View file

@ -13,17 +13,18 @@
#include "lfdemod.h" #include "lfdemod.h"
#include "common.h" #include "common.h"
/* //un_comment to allow debug print calls when used not on device //un_comment to allow debug print calls when used not on device
void dummy(char *fmt, ...){} void dummy(char *fmt, ...){}
#ifndef ON_DEVICE #ifndef ON_DEVICE
#include "ui.h" #include "ui.h"
#include "cmdparser.h"
#include "cmddata.h"
#define prnt PrintAndLog #define prnt PrintAndLog
#else #else
uint8_t g_debugMode=0;
#define prnt dummy #define prnt dummy
#endif #endif
*/
uint8_t justNoise(uint8_t *BitStream, size_t size) uint8_t justNoise(uint8_t *BitStream, size_t size)
{ {
@ -66,6 +67,81 @@ uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
return (ans == pType); return (ans == pType);
} }
//by marshmellow
// takes a array of binary values, start position, length of bits per parity (includes parity bit),
// Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run)
size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen)
{
uint32_t parityWd = 0;
size_t j = 0, bitCnt = 0;
for (int word = 0; word < (bLen); word+=pLen){
for (int bit=0; bit < pLen; bit++){
parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
BitStream[j++] = (BitStream[startIdx+word+bit]);
}
j--; // overwrite parity with next data
// if parity fails then return 0
if (pType == 2) { // then marker bit which should be a 1
if (!BitStream[j]) return 0;
} else {
if (parityTest(parityWd, pLen, pType) == 0) return 0;
}
bitCnt+=(pLen-1);
parityWd = 0;
}
// if we got here then all the parities passed
//return ID start index and size
return bitCnt;
}
// by marshmellow
// takes a array of binary values, length of bits per parity (includes parity bit),
// Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run)
size_t addParity(uint8_t *BitSource, uint8_t *dest, uint8_t sourceLen, uint8_t pLen, uint8_t pType)
{
uint32_t parityWd = 0;
size_t j = 0, bitCnt = 0;
for (int word = 0; word < sourceLen; word+=pLen-1) {
for (int bit=0; bit < pLen-1; bit++){
parityWd = (parityWd << 1) | BitSource[word+bit];
dest[j++] = (BitSource[word+bit]);
}
// if parity fails then return 0
if (pType == 2) { // then marker bit which should be a 1
dest[j++]=1;
} else {
dest[j++] = parityTest(parityWd, pLen-1, pType) ^ 1;
}
bitCnt += pLen;
parityWd = 0;
}
// if we got here then all the parities passed
//return ID start index and size
return bitCnt;
}
uint32_t bytebits_to_byte(uint8_t *src, size_t numbits)
{
uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++)
{
num = (num << 1) | (*src);
src++;
}
return num;
}
//least significant bit first
uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits)
{
uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++)
{
num = (num << 1) | *(src + (numbits-(i+1)));
}
return num;
}
//by marshmellow //by marshmellow
//search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length //search for given preamble in given BitStream and return success=1 or fail=0 and startIndex and length
uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx) uint8_t preambleSearch(uint8_t *BitStream, uint8_t *preamble, size_t pLen, size_t *size, size_t *startIdx)
@ -198,6 +274,7 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
if (*clk==0 || start < 0) return -3; if (*clk==0 || start < 0) return -3;
if (*invert != 1) *invert = 0; if (*invert != 1) *invert = 0;
if (amp==1) askAmp(BinStream, *size); if (amp==1) askAmp(BinStream, *size);
if (g_debugMode==2) prnt("DEBUG: clk %d, beststart %d", *clk, start);
uint8_t initLoopMax = 255; uint8_t initLoopMax = 255;
if (initLoopMax > *size) initLoopMax = *size; if (initLoopMax > *size) initLoopMax = *size;
@ -210,6 +287,7 @@ int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr
size_t errCnt = 0; size_t errCnt = 0;
// if clean clipped waves detected run alternate demod // if clean clipped waves detected run alternate demod
if (DetectCleanAskWave(BinStream, *size, high, low)) { if (DetectCleanAskWave(BinStream, *size, high, low)) {
if (g_debugMode==2) prnt("DEBUG: Clean Wave Detected");
errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low); errCnt = cleanAskRawDemod(BinStream, size, *clk, *invert, high, low);
if (askType) //askman if (askType) //askman
return manrawdecode(BinStream, size, 0); return manrawdecode(BinStream, size, 0);
@ -551,28 +629,6 @@ int ParadoxdemodFSK(uint8_t *dest, size_t *size, uint32_t *hi2, uint32_t *hi, ui
return (int)startIdx; return (int)startIdx;
} }
uint32_t bytebits_to_byte(uint8_t* src, size_t numbits)
{
uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++)
{
num = (num << 1) | (*src);
src++;
}
return num;
}
//least significant bit first
uint32_t bytebits_to_byteLSBF(uint8_t *src, size_t numbits)
{
uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++)
{
num = (num << 1) | *(src + (numbits-(i+1)));
}
return num;
}
int IOdemodFSK(uint8_t *dest, size_t size) int IOdemodFSK(uint8_t *dest, size_t size)
{ {
if (justNoise(dest, size)) return -1; if (justNoise(dest, size)) return -1;
@ -622,33 +678,6 @@ int VikingDemod_AM(uint8_t *dest, size_t *size) {
return (int) startIdx; return (int) startIdx;
} }
// by marshmellow
// takes a array of binary values, start position, length of bits per parity (includes parity bit),
// Parity Type (1 for odd; 0 for even; 2 Always 1's), and binary Length (length to run)
size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t pType, size_t bLen)
{
uint32_t parityWd = 0;
size_t j = 0, bitCnt = 0;
for (int word = 0; word < (bLen); word+=pLen){
for (int bit=0; bit < pLen; bit++){
parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
BitStream[j++] = (BitStream[startIdx+word+bit]);
}
j--; // overwrite parity with next data
// if parity fails then return 0
if (pType == 2) { // then marker bit which should be a 1
if (!BitStream[j]) return 0;
} else {
if (parityTest(parityWd, pLen, pType) == 0) return 0;
}
bitCnt+=(pLen-1);
parityWd = 0;
}
// if we got here then all the parities passed
//return ID start index and size
return bitCnt;
}
// Ask/Biphase Demod then try to locate an ISO 11784/85 ID // Ask/Biphase Demod then try to locate an ISO 11784/85 ID
// BitStream must contain previously askrawdemod and biphasedemoded data // BitStream must contain previously askrawdemod and biphasedemoded data
int FDXBdemodBI(uint8_t *dest, size_t *size) int FDXBdemodBI(uint8_t *dest, size_t *size)
@ -756,7 +785,7 @@ int DetectStrongAskClock(uint8_t dest[], size_t size, uint8_t high, uint8_t low)
minClk = i - startwave; minClk = i - startwave;
} }
// set clock // set clock
//prnt("minClk: %d",minClk); if (g_debugMode==2) prnt("DEBUG ASK: detectstrongASKclk smallest wave: %d",minClk);
for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) { for (uint8_t clkCnt = 0; clkCnt<7; clkCnt++) {
if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1) if (minClk >= fndClk[clkCnt]-(fndClk[clkCnt]/8) && minClk <= fndClk[clkCnt]+1)
return fndClk[clkCnt]; return fndClk[clkCnt];
@ -790,6 +819,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
if (!clockFnd){ if (!clockFnd){
if (DetectCleanAskWave(dest, size, peak, low)==1){ if (DetectCleanAskWave(dest, size, peak, low)==1){
int ans = DetectStrongAskClock(dest, size, peak, low); int ans = DetectStrongAskClock(dest, size, peak, low);
if (g_debugMode==2) prnt("DEBUG ASK: detectaskclk Clean Ask Wave Detected: clk %d",ans);
for (i=clkEnd-1; i>0; i--){ for (i=clkEnd-1; i>0; i--){
if (clk[i] == ans) { if (clk[i] == ans) {
*clock = ans; *clock = ans;
@ -800,7 +830,6 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
} }
} }
} }
uint8_t ii; uint8_t ii;
uint8_t clkCnt, tol = 0; uint8_t clkCnt, tol = 0;
uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000}; uint16_t bestErr[]={1000,1000,1000,1000,1000,1000,1000,1000,1000};
@ -842,7 +871,7 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
} }
//if we found no errors then we can stop here and a low clock (common clocks) //if we found no errors then we can stop here and a low clock (common clocks)
// this is correct one - return this clock // this is correct one - return this clock
//prnt("DEBUG: clk %d, err %d, ii %d, i %d",clk[clkCnt],errCnt,ii,i); if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, err %d, startpos %d, endpos %d",clk[clkCnt],errCnt,ii,i);
if(errCnt==0 && clkCnt<7) { if(errCnt==0 && clkCnt<7) {
if (!clockFnd) *clock = clk[clkCnt]; if (!clockFnd) *clock = clk[clkCnt];
return ii; return ii;
@ -864,8 +893,8 @@ int DetectASKClock(uint8_t dest[], size_t size, int *clock, int maxErr)
best = iii; best = iii;
} }
} }
if (g_debugMode == 2) prnt("DEBUG ASK: clk %d, # Errors %d, Current Best Clk %d, bestStart %d",clk[iii],bestErr[iii],clk[best],bestStart[best]);
} }
//if (bestErr[best] > maxErr) return -1;
if (!clockFnd) *clock = clk[best]; if (!clockFnd) *clock = clk[best];
return bestStart[best]; return bestStart[best];
} }
@ -892,7 +921,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0}; uint16_t peaksdet[]={0,0,0,0,0,0,0,0,0};
fc = countFC(dest, size, 0); fc = countFC(dest, size, 0);
if (fc!=2 && fc!=4 && fc!=8) return -1; if (fc!=2 && fc!=4 && fc!=8) return -1;
//prnt("DEBUG: FC: %d",fc); if (g_debugMode==2) prnt("DEBUG PSK: FC: %d",fc);
//find first full wave //find first full wave
for (i=160; i<loopCnt; i++){ for (i=160; i<loopCnt; i++){
@ -913,7 +942,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
} }
} }
} }
//prnt("DEBUG: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen); if (g_debugMode ==2) prnt("DEBUG PSK: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen);
//test each valid clock from greatest to smallest to see which lines up //test each valid clock from greatest to smallest to see which lines up
for(clkCnt=7; clkCnt >= 1 ; clkCnt--){ for(clkCnt=7; clkCnt >= 1 ; clkCnt--){
@ -921,7 +950,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
waveStart = 0; waveStart = 0;
errCnt=0; errCnt=0;
peakcnt=0; peakcnt=0;
//prnt("DEBUG: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit); if (g_debugMode == 2) prnt("DEBUG PSK: clk: %d, lastClkBit: %d",clk[clkCnt],lastClkBit);
for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){ for (i = firstFullWave+fullWaveLen-1; i < loopCnt-2; i++){
//top edge of wave = start of new wave //top edge of wave = start of new wave
@ -934,7 +963,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
waveLenCnt = waveEnd-waveStart; waveLenCnt = waveEnd-waveStart;
if (waveLenCnt > fc){ if (waveLenCnt > fc){
//if this wave is a phase shift //if this wave is a phase shift
//prnt("DEBUG: phase shift at: %d, len: %d, nextClk: %d, ii: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,ii+1,fc); if (g_debugMode == 2) prnt("DEBUG PSK: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+clk[clkCnt]-tol,i+1,fc);
if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit if (i+1 >= lastClkBit + clk[clkCnt] - tol){ //should be a clock bit
peakcnt++; peakcnt++;
lastClkBit+=clk[clkCnt]; lastClkBit+=clk[clkCnt];
@ -963,7 +992,7 @@ int DetectPSKClock(uint8_t dest[], size_t size, int clock)
if (peaksdet[i] > peaksdet[best]) { if (peaksdet[i] > peaksdet[best]) {
best = i; best = i;
} }
//prnt("DEBUG: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[iii],peaksdet[iii],bestErr[iii],clk[best]); if (g_debugMode == 2) prnt("DEBUG PSK: Clk: %d, peaks: %d, errs: %d, bestClk: %d",clk[i],peaksdet[i],bestErr[i],clk[best]);
} }
return clk[best]; return clk[best];
} }
@ -992,8 +1021,8 @@ int DetectStrongNRZClk(uint8_t *dest, size_t size, int peak, int low){
transition1 = i; transition1 = i;
} }
} }
//prnt("DEBUG: LowestTrs: %d",lowestTransition);
if (lowestTransition == 255) lowestTransition = 0; if (lowestTransition == 255) lowestTransition = 0;
if (g_debugMode==2) prnt("DEBUG NRZ: detectstrongNRZclk smallest wave: %d",lowestTransition);
return lowestTransition; return lowestTransition;
} }
@ -1108,7 +1137,7 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
} else if (peaksdet[iii] > peaksdet[best]){ } else if (peaksdet[iii] > peaksdet[best]){
best = iii; best = iii;
} }
//prnt("DEBUG: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition); if (g_debugMode==2) prnt("DEBUG NRZ: Clk: %d, peaks: %d, maxPeak: %d, bestClk: %d, lowestTrs: %d",clk[iii],peaksdet[iii],maxPeak, clk[best], lowestTransition);
} }
return clk[best]; return clk[best];
@ -1269,7 +1298,6 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc
uint8_t rfHighest=15, rfHighest2=15, rfHighest3=15; uint8_t rfHighest=15, rfHighest2=15, rfHighest3=15;
for (i=0; i<15; i++){ for (i=0; i<15; i++){
//prnt("DEBUG: RF %d, cnts %d",rfLens[i], rfCnts[i]);
//get highest 2 RF values (might need to get more values to compare or compare all?) //get highest 2 RF values (might need to get more values to compare or compare all?)
if (rfCnts[i]>rfCnts[rfHighest]){ if (rfCnts[i]>rfCnts[rfHighest]){
rfHighest3=rfHighest2; rfHighest3=rfHighest2;
@ -1281,12 +1309,13 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc
} else if(rfCnts[i]>rfCnts[rfHighest3]){ } else if(rfCnts[i]>rfCnts[rfHighest3]){
rfHighest3=i; rfHighest3=i;
} }
if (g_debugMode==2) prnt("DEBUG FSK: RF %d, cnts %d",rfLens[i], rfCnts[i]);
} }
// set allowed clock remainder tolerance to be 1 large field clock length+1 // set allowed clock remainder tolerance to be 1 large field clock length+1
// we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off // we could have mistakenly made a 9 a 10 instead of an 8 or visa versa so rfLens could be 1 FC off
uint8_t tol1 = fcHigh+1; uint8_t tol1 = fcHigh+1;
//prnt("DEBUG: hightest: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]); if (g_debugMode==2) prnt("DEBUG FSK: most counted rf values: 1 %d, 2 %d, 3 %d",rfLens[rfHighest],rfLens[rfHighest2],rfLens[rfHighest3]);
// loop to find the highest clock that has a remainder less than the tolerance // loop to find the highest clock that has a remainder less than the tolerance
// compare samples counted divided by // compare samples counted divided by
@ -1296,6 +1325,7 @@ uint8_t detectFSKClk(uint8_t *BitStream, size_t size, uint8_t fcHigh, uint8_t fc
if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){ if (rfLens[rfHighest] % clk[ii] < tol1 || rfLens[rfHighest] % clk[ii] > clk[ii]-tol1){
if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){ if (rfLens[rfHighest2] % clk[ii] < tol1 || rfLens[rfHighest2] % clk[ii] > clk[ii]-tol1){
if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){ if (rfLens[rfHighest3] % clk[ii] < tol1 || rfLens[rfHighest3] % clk[ii] > clk[ii]-tol1){
if (g_debugMode==2) prnt("DEBUG FSK: clk %d divides into the 3 most rf values within tolerance",clk[ii]);
break; break;
} }
} }
@ -1362,7 +1392,6 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
uint16_t maxCnt1=0; uint16_t maxCnt1=0;
// go through fclens and find which ones are bigest 2 // go through fclens and find which ones are bigest 2
for (i=0; i<15; i++){ for (i=0; i<15; i++){
//prnt("DEBUG: FC %d, Cnt %d",fcLens[i],fcCnts[i]);
// get the 3 best FC values // get the 3 best FC values
if (fcCnts[i]>maxCnt1) { if (fcCnts[i]>maxCnt1) {
best3=best2; best3=best2;
@ -1375,6 +1404,7 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
} else if(fcCnts[i]>fcCnts[best3]){ } else if(fcCnts[i]>fcCnts[best3]){
best3=i; best3=i;
} }
if (g_debugMode==2) prnt("DEBUG countfc: FC %u, Cnt %u, best fc: %u, best2 fc: %u",fcLens[i],fcCnts[i],fcLens[best1],fcLens[best2]);
} }
if (fcLens[best1]==0) return 0; if (fcLens[best1]==0) return 0;
uint8_t fcH=0, fcL=0; uint8_t fcH=0, fcL=0;
@ -1385,13 +1415,13 @@ uint16_t countFC(uint8_t *BitStream, size_t size, uint8_t fskAdj)
fcH=fcLens[best2]; fcH=fcLens[best2];
fcL=fcLens[best1]; fcL=fcLens[best1];
} }
//prnt("DEBUG: dd %d > %d",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]); if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) {
if ((size-180)/fcH/3 > fcCnts[best1]+fcCnts[best2]) return 0; //lots of waves not psk or fsk if (g_debugMode==2) prnt("DEBUG countfc: fc is too large: %u > %u. Not psk or fsk",(size-180)/fcH/3,fcCnts[best1]+fcCnts[best2]);
return 0; //lots of waves not psk or fsk
}
// TODO: take top 3 answers and compare to known Field clocks to get top 2 // TODO: take top 3 answers and compare to known Field clocks to get top 2
uint16_t fcs = (((uint16_t)fcH)<<8) | fcL; uint16_t fcs = (((uint16_t)fcH)<<8) | fcL;
//prnt("DEBUG: Best %d best2 %d best3 %d",fcLens[best1],fcLens[best2],fcLens[best3]);
if (fskAdj) return fcs; if (fskAdj) return fcs;
return fcLens[best1]; return fcLens[best1];
} }

1
common/lfdemod.h
View file

@ -16,6 +16,7 @@
#include <stdint.h> #include <stdint.h>
//generic //generic
size_t addParity(uint8_t *BitSource, uint8_t *dest, uint8_t sourceLen, uint8_t pLen, uint8_t pType);
int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType); int askdemod(uint8_t *BinStream, size_t *size, int *clk, int *invert, int maxErr, uint8_t amp, uint8_t askType);
int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert); int BiphaseRawDecode(uint8_t * BitStream, size_t *size, int offset, int invert);
uint32_t bytebits_to_byte(uint8_t* src, size_t numbits); uint32_t bytebits_to_byte(uint8_t* src, size_t numbits);