github/proxmark3
1
0
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2025-08-20 21:33:19 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of https://github.com/Proxmark/proxmark3

Browse source
This commit is contained in:
pwpiwi 2017-04-10 19:37:05 +02:00
commit 68541dddc2
29 changed files with 177 additions and 218 deletions
Download patch file Download diff file Expand all files Collapse all files

49
client/cmddata.c
View file

@ -40,8 +40,8 @@ void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx)
if (buff == NULL)
return;
if ( size >= MAX_DEMOD_BUF_LEN)
size = MAX_DEMOD_BUF_LEN;
if ( size > MAX_DEMOD_BUF_LEN - startIdx)
size = MAX_DEMOD_BUF_LEN - startIdx;
size_t i = 0;
for (; i < size; i++){
@ -51,18 +51,30 @@ void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx)
return;
}
bool getDemodBuf(uint8_t *buff, size_t *size) {
if (buff == NULL) return false;
if (size == NULL) return false;
if (*size == 0) return false;
*size = (*size > DemodBufferLen) ? DemodBufferLen : *size;
memcpy(buff, DemodBuffer, *size);
return true;
}
// option '1' to save DemodBuffer any other to restore
void save_restoreDB(uint8_t saveOpt)
{
static uint8_t SavedDB[MAX_GRAPH_TRACE_LEN];
static uint8_t SavedDB[MAX_DEMOD_BUF_LEN];
static size_t SavedDBlen;
static bool DB_Saved = false;
if (saveOpt==1) { //save
memcpy(SavedDB, DemodBuffer, sizeof(DemodBuffer));
SavedDBlen = DemodBufferLen;
DB_Saved=true;
} else if (DB_Saved){ //restore
} else if (DB_Saved) { //restore
memcpy(DemodBuffer, SavedDB, sizeof(DemodBuffer));
DemodBufferLen = SavedDBlen;
}
@ -212,8 +224,8 @@ int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType,
bool st = false;
size_t ststart = 0, stend = 0;
if (*stCheck) st = DetectST_ext(BitStream, &BitLen, &foundclk, &ststart, &stend);
*stCheck = st;
if (st) {
*stCheck = st;
clk = (clk == 0) ? foundclk : clk;
CursorCPos = ststart;
CursorDPos = stend;
@ -311,7 +323,7 @@ int Cmdmandecoderaw(const char *Cmd)
return 0;
}
if (DemodBufferLen==0) return 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
uint8_t BitStream[MAX_DEMOD_BUF_LEN]={0};
int high=0,low=0;
for (;i<DemodBufferLen;++i){
if (DemodBuffer[i]>high) high=DemodBuffer[i];
@ -373,13 +385,13 @@ int CmdBiphaseDecodeRaw(const char *Cmd)
return 0;
}
sscanf(Cmd, "%i %i %i", &offset, &invert, &maxErr);
if (DemodBufferLen==0){
if (DemodBufferLen==0) {
PrintAndLog("DemodBuffer Empty - run 'data rawdemod ar' first");
return 0;
}
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
memcpy(BitStream, DemodBuffer, DemodBufferLen);
size = DemodBufferLen;
uint8_t BitStream[MAX_DEMOD_BUF_LEN]={0};
size = sizeof(BitStream);
if ( !getDemodBuf(BitStream, &size) ) return 0;
errCnt=BiphaseRawDecode(BitStream, &size, offset, invert);
if (errCnt<0){
PrintAndLog("Error during decode:%d", errCnt);
@ -408,7 +420,7 @@ int ASKbiphaseDemod(const char *Cmd, bool verbose)
int offset=0, clk=0, invert=0, maxErr=0;
sscanf(Cmd, "%i %i %i %i", &offset, &clk, &invert, &maxErr);
uint8_t BitStream[MAX_DEMOD_BUF_LEN];
uint8_t BitStream[MAX_GRAPH_TRACE_LEN];
size_t size = getFromGraphBuf(BitStream);
//invert here inverts the ask raw demoded bits which has no effect on the demod, but we need the pointer
int errCnt = askdemod(BitStream, &size, &clk, &invert, maxErr, 0, 0);
@ -1126,7 +1138,7 @@ uint8_t getByte(uint8_t bits_per_sample, BitstreamIn* b)
return val;
}
int getSamples(const char *Cmd, bool silent)
int getSamples(int n, bool silent)
{
//If we get all but the last byte in bigbuf,
// we don't have to worry about remaining trash
@ -1135,14 +1147,12 @@ int getSamples(const char *Cmd, bool silent)
uint8_t got[BIGBUF_SIZE-1] = { 0 };
int n = strtol(Cmd, NULL, 0);
if (n == 0 || n > sizeof(got))
n = sizeof(got);
PrintAndLog("Reading %d bytes from device memory\n", n);
if (!silent) PrintAndLog("Reading %d bytes from device memory\n", n);
GetFromBigBuf(got,n,0);
PrintAndLog("Data fetched");
if (!silent) PrintAndLog("Data fetched");
UsbCommand response;
WaitForResponse(CMD_ACK, &response);
uint8_t bits_per_sample = 8;
@ -1151,13 +1161,13 @@ int getSamples(const char *Cmd, bool silent)
if(response.arg[0] > 0)
{
sample_config *sc = (sample_config *) response.d.asBytes;
PrintAndLog("Samples @ %d bits/smpl, decimation 1:%d ", sc->bits_per_sample
if (!silent) PrintAndLog("Samples @ %d bits/smpl, decimation 1:%d ", sc->bits_per_sample
, sc->decimation);
bits_per_sample = sc->bits_per_sample;
}
if(bits_per_sample < 8)
{
PrintAndLog("Unpacking...");
if (!silent) PrintAndLog("Unpacking...");
BitstreamIn bout = { got, bits_per_sample * n, 0};
int j =0;
for (j = 0; j * bits_per_sample < n * 8 && j < n; j++) {
@ -1180,7 +1190,8 @@ int getSamples(const char *Cmd, bool silent)
int CmdSamples(const char *Cmd)
{
return getSamples(Cmd, false);
int n = strtol(Cmd, NULL, 0);
return getSamples(n, false);
}
int CmdTuneSamples(const char *Cmd)

3
client/cmddata.h
View file

@ -22,6 +22,7 @@ command_t * CmdDataCommands();
int CmdData(const char *Cmd);
void printDemodBuff(void);
void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx);
bool getDemodBuf(uint8_t *buff, size_t *size);
void save_restoreDB(uint8_t saveOpt);// option '1' to save DemodBuffer any other to restore
int CmdPrintDemodBuff(const char *Cmd);
int Cmdaskrawdemod(const char *Cmd);
@ -62,7 +63,7 @@ int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType,
int FSKrawDemod(const char *Cmd, bool verbose);
int PSKDemod(const char *Cmd, bool verbose);
int NRZrawDemod(const char *Cmd, bool verbose);
int getSamples(const char *Cmd, bool silent);
int getSamples(int n, bool silent);
#define MAX_DEMOD_BUF_LEN (1024*128)

62
client/cmdlf.c
View file

@ -12,6 +12,8 @@
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include "proxmark3.h"
#include "cmdlf.h"
#include "lfdemod.h" // for psk2TOpsk1
@ -211,7 +213,7 @@ int usage_lf_read(void)
PrintAndLog("Options: ");
PrintAndLog(" h This help");
PrintAndLog(" s silent run no printout");
PrintAndLog("This function takes no arguments. ");
PrintAndLog(" [# samples] # samples to collect (optional)");
PrintAndLog("Use 'lf config' to set parameters.");
return 0;
}
@ -331,29 +333,41 @@ int CmdLFSetConfig(const char *Cmd)
return 0;
}
bool lf_read(bool silent, uint32_t samples) {
if (offline) return false;
UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, {silent,samples,0}};
clearCommandBuffer();
//And ship it to device
SendCommand(&c);
UsbCommand resp;
if (g_lf_threshold_set) {
WaitForResponse(CMD_ACK,&resp);
} else {
if ( !WaitForResponseTimeout(CMD_ACK,&resp,2500) ) {
PrintAndLog("command execution time out");
return false;
}
}
getSamples(resp.arg[0], silent);
return true;
}
int CmdLFRead(const char *Cmd)
{
if (offline) return 0;
uint8_t cmdp = 0;
bool arg1 = false;
bool silent = false;
if (param_getchar(Cmd, cmdp) == 'h')
{
return usage_lf_read();
}
if (param_getchar(Cmd, cmdp) == 's') arg1 = true; //suppress print
//And ship it to device
UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, {arg1,0,0}};
clearCommandBuffer();
SendCommand(&c);
if (g_lf_threshold_set) {
WaitForResponse(CMD_ACK,NULL);
} else {
if ( !WaitForResponseTimeout(CMD_ACK,NULL,2500) ) {
PrintAndLog("command execution time out");
return 1;
}
if (param_getchar(Cmd, cmdp) == 's') {
silent = true; //suppress print
cmdp++;
}
return 0;
uint32_t samples = param_get32ex(Cmd, cmdp, 0, 10);
return lf_read(silent, samples);
}
int CmdLFSnoop(const char *Cmd)
@ -368,6 +382,8 @@ int CmdLFSnoop(const char *Cmd)
clearCommandBuffer();
SendCommand(&c);
WaitForResponse(CMD_ACK,NULL);
getSamples(0, true);
return 0;
}
@ -905,9 +921,8 @@ int CmdLFfind(const char *Cmd)
return 0;
}
if (!offline && (cmdp != '1')){
CmdLFRead("s");
getSamples("30000",false);
if (!offline && (cmdp != '1')) {
lf_read(true, 30000);
} else if (GraphTraceLen < minLength) {
PrintAndLog("Data in Graphbuffer was too small.");
return 0;
@ -1051,7 +1066,7 @@ int CmdLFfind(const char *Cmd)
ans=FSKrawDemod("",true);
if (ans>0) {
PrintAndLog("\nUnknown FSK Modulated Tag Found!");
return 1;
return CheckChipType(cmdp);;
}
}
bool st = true;
@ -1059,15 +1074,16 @@ int CmdLFfind(const char *Cmd)
if (ans>0) {
PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!");
PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'");
return 1;
return CheckChipType(cmdp);;
}
ans=CmdPSK1rawDemod("");
if (ans>0) {
PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data rawdemod p2'");
PrintAndLog("\nCould also be PSK3 - [currently not supported]");
PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod");
return 1;
PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod'");
return CheckChipType(cmdp);;
}
ans = CheckChipType(cmdp);
PrintAndLog("\nNo Data Found!\n");
}
return 0;

32
client/cmdlf.h
View file

@ -11,20 +11,24 @@
#ifndef CMDLF_H__
#define CMDLF_H__
int CmdLF(const char *Cmd);
#include <stdbool.h>
#include <stdint.h>
int CmdLFCommandRead(const char *Cmd);
int CmdFlexdemod(const char *Cmd);
int CmdIndalaDemod(const char *Cmd);
int CmdIndalaClone(const char *Cmd);
int CmdLFRead(const char *Cmd);
int CmdLFSim(const char *Cmd);
int CmdLFaskSim(const char *Cmd);
int CmdLFfskSim(const char *Cmd);
int CmdLFpskSim(const char *Cmd);
int CmdLFSimBidir(const char *Cmd);
int CmdLFSnoop(const char *Cmd);
int CmdVchDemod(const char *Cmd);
int CmdLFfind(const char *Cmd);
extern int CmdLF(const char *Cmd);
extern int CmdLFCommandRead(const char *Cmd);
extern int CmdFlexdemod(const char *Cmd);
extern int CmdIndalaDemod(const char *Cmd);
extern int CmdIndalaClone(const char *Cmd);
extern int CmdLFRead(const char *Cmd);
extern int CmdLFSim(const char *Cmd);
extern int CmdLFaskSim(const char *Cmd);
extern int CmdLFfskSim(const char *Cmd);
extern int CmdLFpskSim(const char *Cmd);
extern int CmdLFSimBidir(const char *Cmd);
extern int CmdLFSnoop(const char *Cmd);
extern int CmdVchDemod(const char *Cmd);
extern int CmdLFfind(const char *Cmd);
extern bool lf_read(bool silent, uint32_t samples);
#endif

1
client/cmdlfawid.c
View file

@ -8,6 +8,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency AWID26 commands
// FSK2a, RF/50, 96 bits (complete)
//-----------------------------------------------------------------------------
#include <string.h>

2
client/cmdlfcotag.c
View file

@ -96,7 +96,7 @@ int CmdCOTAGRead(const char *Cmd) {
case 2: {
CmdPlot("");
CmdGrid("384");
getSamples("", true); break;
getSamples(0, true); break;
}
case 1: {
GetFromBigBuf(DemodBuffer, COTAG_BITS, 0);

17
client/cmdlfem4x.c
View file

@ -146,17 +146,18 @@ void printEM410x(uint32_t hi, uint64_t id)
int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
{
size_t idx = 0;
size_t BitLen = DemodBufferLen;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
memcpy(BitStream, DemodBuffer, BitLen);
if (Em410xDecode(BitStream, &BitLen, &idx, hi, lo)){
uint8_t BitStream[512]={0};
size_t BitLen = sizeof(BitStream);
if ( !getDemodBuf(BitStream, &BitLen) ) return 0;
if (Em410xDecode(BitStream, &BitLen, &idx, hi, lo)) {
//set GraphBuffer for clone or sim command
setDemodBuf(BitStream, BitLen, idx);
if (g_debugMode){
if (g_debugMode) {
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
printDemodBuff();
}
if (verbose){
if (verbose) {
PrintAndLog("EM410x pattern found: ");
printEM410x(*hi, *lo);
g_em410xId = *lo;
@ -298,9 +299,7 @@ int CmdEM410xWatch(const char *Cmd)
printf("\naborted via keyboard!\n");
break;
}
CmdLFRead("s");
getSamples("8201",true);
lf_read(true, 8201);
} while (!CmdAskEM410xDemod(""));
return 0;

4
client/cmdlffdx.c
View file

@ -5,6 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency fdx-b tag commands
// Differential Biphase, rf/32, 128 bits (known)
//-----------------------------------------------------------------------------
#include "cmdlffdx.h"
@ -203,8 +204,7 @@ int CmdFdxDemod(const char *Cmd){
}
int CmdFdxRead(const char *Cmd) {
CmdLFRead("s");
getSamples("10000", true);
lf_read(true, 10000);
return CmdFdxDemod(Cmd);
}

5
client/cmdlfgproxii.c
View file

@ -5,6 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency G Prox II tag commands
// Biphase, rf/ , 96 bits (unknown key calc + some bits)
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
@ -89,9 +90,7 @@ int CmdG_Prox_II_Demod(const char *Cmd)
//see ASKDemod for what args are accepted
int CmdG_Prox_II_Read(const char *Cmd) {
// read lf silently
CmdLFRead("s");
// get samples silently
getSamples("10000",false);
lf_read(true, 10000);
// demod and output viking ID
return CmdG_Prox_II_Demod(Cmd);
}

2
client/cmdlfhid.c
View file

@ -5,7 +5,7 @@
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Low frequency HID commands
// Low frequency HID commands (known)
//-----------------------------------------------------------------------------
#include <stdio.h>

4
client/cmdlfindala.c
View file

@ -5,6 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Indala commands
// PSK1, rf/32, 64 or 224 bits (known)
//-----------------------------------------------------------------------------
#include <stdio.h>
@ -73,8 +74,7 @@ int CmdIndalaDecode(const char *Cmd) {
}
int CmdIndalaRead(const char *Cmd) {
CmdLFRead("s");
getSamples("30000",false);
lf_read(true, 30000);
return CmdIndalaDecode("");
}

10
client/cmdlfio.c
View file

@ -1,3 +1,13 @@
//-----------------------------------------------------------------------------
//
// 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 ioProx commands
// FSK2a, rf/64, 64 bits (complete)
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

5
client/cmdlfjablotron.c
View file

@ -5,7 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency jablotron tag commands
// Differential Biphase, RF/64, 64 bits long
// Differential Biphase, RF/64, 64 bits long (complete)
//-----------------------------------------------------------------------------
#include "cmdlfjablotron.h"
@ -141,8 +141,7 @@ int CmdJablotronDemod(const char *Cmd) {
}
int CmdJablotronRead(const char *Cmd) {
CmdLFRead("s");
getSamples("10000", true);
lf_read(true, 10000);
return CmdJablotronDemod(Cmd);
}

6
client/cmdlfnexwatch.c
View file

@ -5,7 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Honeywell NexWatch tag commands
// PSK1 RF/16, RF/2, 128 bits long
// PSK1 RF/16, RF/2, 128 bits long (known)
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
@ -66,9 +66,7 @@ int CmdPSKNexWatch(const char *Cmd)
//see ASKDemod for what args are accepted
int CmdNexWatchRead(const char *Cmd) {
// read lf silently
CmdLFRead("s");
// get samples silently
getSamples("10000",false);
lf_read(true, 10000);
// demod and output viking ID
return CmdPSKNexWatch(Cmd);
}

12
client/cmdlfnoralsy.c
View file

@ -5,7 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Noralsy tag commands
// ASK/Manchester, STT, RF/32, 96 bits long
// ASK/Manchester, STT, RF/32, 96 bits long (some bits unknown)
//-----------------------------------------------------------------------------
#include "cmdlfnoralsy.h"
#include <string.h>
@ -98,13 +98,14 @@ int NoralsyDemod_AM(uint8_t *dest, size_t *size) {
/*
*
* 2520116 | BB0214FF2529900116360000 | 10111011 00000011 00010100 11111111 00100101 00101001 10010000 00000001 00010110 00110110 00000000 00000000
* aaaaaaaaiii***iiiicc---- iiiiiiii iiiiYYYY YYYY**** iiiiiiii iiiiiiii cccccccc
* aaa*aaaaiiiYY*iiiicc---- **** iiiiiiii iiiiYYYY YYYY**** iiiiiiii iiiiiiii cccccccc
*
* a = fixed value BB0314FF
* a = fixed value BB0*14FF
* i = printed id, BCD-format
* Y = year
* c = checksum
*
* * = unknown
*
**/
//see ASKDemod for what args are accepted
@ -171,8 +172,7 @@ int CmdNoralsyDemod(const char *Cmd) {
}
int CmdNoralsyRead(const char *Cmd) {
CmdLFRead("s");
getSamples("8000",true);
lf_read(true, 8000);
return CmdNoralsyDemod(Cmd);
}

5
client/cmdlfparadox.c
View file

@ -5,6 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Paradox tag commands
// FSK2a, rf/50, 96 bits (completely known)
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
@ -72,9 +73,7 @@ int CmdFSKdemodParadox(const char *Cmd)
//see ASKDemod for what args are accepted
int CmdParadoxRead(const char *Cmd) {
// read lf silently
CmdLFRead("s");
// get samples silently
getSamples("10000",false);
lf_read(true, 10000);
// demod and output viking ID
return CmdFSKdemodParadox(Cmd);
}

7
client/cmdlfpresco.c
View file

@ -5,6 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Presco tag commands
// ASK/Manchester, rf/32, 128 bits (complete)
//-----------------------------------------------------------------------------
#include <string.h>
#include <inttypes.h>
@ -129,7 +130,7 @@ int CmdPrescoDemod(const char *Cmd) {
return 0;
}
size_t size = DemodBufferLen;
//call lfdemod.c demod for Viking
//call lfdemod.c demod for presco
int ans = PrescoDemod(DemodBuffer, &size);
if (ans < 0) {
if (g_debugMode) PrintAndLog("Error Presco_Demod %d", ans);
@ -160,9 +161,7 @@ int CmdPrescoRead(const char *Cmd) {
// Presco Number: 123456789 --> Sitecode 30 | usercode 8665
// read lf silently
CmdLFRead("s");
// get samples silently
getSamples("30000",false);
lf_read(true, 10000);
// demod and output Presco ID
return CmdPrescoDemod(Cmd);
}

4
client/cmdlfpyramid.c
View file

@ -5,6 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Farpoint / Pyramid tag commands
// FSK2a, rf/50, 128 bits (complete)
//-----------------------------------------------------------------------------
#include <string.h>
#include <inttypes.h>
@ -225,8 +226,7 @@ int CmdFSKdemodPyramid(const char *Cmd)
}
int CmdPyramidRead(const char *Cmd) {
CmdLFRead("s");
getSamples("30000",false);
lf_read(true, 15000);
return CmdFSKdemodPyramid("");
}

5
client/cmdlfsecurakey.c
View file

@ -5,7 +5,7 @@
// the license.
//-----------------------------------------------------------------------------
// Low frequency Securakey tag commands
// ASK/Manchester, RF/40, 96 bits long
// ASK/Manchester, RF/40, 96 bits long (unknown cs)
//-----------------------------------------------------------------------------
#include "cmdlfsecurakey.h"
#include <string.h>
@ -123,8 +123,7 @@ int CmdSecurakeyDemod(const char *Cmd) {
}
int CmdSecurakeyRead(const char *Cmd) {
CmdLFRead("s");
getSamples("8000",true);
lf_read(true, 8000);
return CmdSecurakeyDemod(Cmd);
}

9
client/cmdlft55xx.c
View file

@ -810,6 +810,7 @@ bool test(uint8_t mode, uint8_t *offset, int *fndBitRate, uint8_t clk, bool *Q5)
if (!testBitRate(bitRate, clk)) continue;
} else { //extended mode bitrate = same function to calc bitrate as em4x05
if (EM4x05_GET_BITRATE(bitRate) != clk) continue;
}
//test modulation
if (!testModulation(mode, modread)) continue;
@ -869,7 +870,7 @@ int special(const char *Cmd) {
int printConfiguration( t55xx_conf_block_t b){
PrintAndLog("Chip Type : %s", (b.Q5) ? "T5555(Q5)" : "T55x7");
PrintAndLog("Modulation : %s", GetSelectedModulationStr(b.modulation) );
PrintAndLog("Bit Rate : %s", GetBitRateStr(b.bitrate, (b.block0 & T55x7_X_MODE)) );
PrintAndLog("Bit Rate : %s", GetBitRateStr(b.bitrate, (b.block0 & T55x7_X_MODE && (b.block0>>28==6 || b.block0>>28==9))) );
PrintAndLog("Inverted : %s", (b.inverted) ? "Yes" : "No" );
PrintAndLog("Offset : %d", b.offset);
PrintAndLog("Seq. Term. : %s", (b.ST) ? "Yes" : "No" );
@ -1233,11 +1234,7 @@ int AquireData( uint8_t page, uint8_t block, bool pwdmode, uint32_t password ){
PrintAndLog("command execution time out");
return 0;
}
uint8_t got[12000];
GetFromBigBuf(got,sizeof(got),0);
WaitForResponse(CMD_ACK,NULL);
setGraphBuf(got, sizeof(got));
getSamples(12000,true);
return 1;
}

7
client/cmdlfviking.c
View file

@ -4,7 +4,8 @@
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Low frequency Viking tag commands
// Low frequency Viking tag commands (AKA FDI Matalec Transit)
// ASK/Manchester, RF/32, 64 bits (complete)
//-----------------------------------------------------------------------------
#include <stdio.h>
#include <string.h>
@ -80,9 +81,7 @@ int CmdVikingDemod(const char *Cmd) {
//see ASKDemod for what args are accepted
int CmdVikingRead(const char *Cmd) {
// read lf silently
CmdLFRead("s");
// get samples silently
getSamples("10000",false);
lf_read(true, 10000);
// demod and output viking ID
return CmdVikingDemod(Cmd);
}

8
client/cmdlfvisa2000.c
View file

@ -6,6 +6,7 @@
//-----------------------------------------------------------------------------
// Low frequency visa 2000 tag commands
// by iceman
// ASK/Manchester, RF/64, STT, 96 bits (complete)
//-----------------------------------------------------------------------------
#include "cmdlfvisa2000.h"
@ -83,12 +84,12 @@ static uint8_t visa_parity( uint32_t id) {
/**
*
* 56495332 00096ebd 00000077 —> tag id 618173
* aaaaaaaa iiiiiiii -----..c
* aaaaaaaa iiiiiiii -----ppc
*
* a = fixed value ascii 'VIS2'
* i = card id
* p = even parity bit for each nibble in card id.
* c = checksum (xor of card id)
* . = unknown
*
**/
//see ASKDemod for what args are accepted
@ -146,9 +147,8 @@ int CmdVisa2kDemod(const char *Cmd) {
}
int CmdVisa2kRead(const char *Cmd) {
CmdLFRead("s");
//64*96*2=12288 samples just in case we just missed the first preamble we can still catch 2 of them
getSamples("12500",true);
lf_read(true, 12500);
return CmdVisa2kDemod(Cmd);
}

2
client/util.c
View file

@ -174,7 +174,7 @@ char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t brea
if (data[in_index]<10)
sprintf(tmp++, "%u", (unsigned int) data[in_index]);
// check if a line break is needed and we have room to print it in our array
if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != max_len) ) {
if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 < max_len) ) {
// increment and print line break
out_index++;
sprintf(tmp++, "%s","\n");