RfidResearchGroup/proxmark3
1
1
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-01-09 09:39:16 +08:00
Code Issues Projects Releases Packages Wiki Activity

adjust ask/biphase handling - more complete

Browse source 
also added XL EM410x formats
This commit is contained in:
marshmellow42 2015-03-15 22:03:50 -04:00
parent 7a8a982bde
commit b41534d142
4 changed files with 222 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

81
armsrc/lfops.c
View file

@ -622,7 +622,7 @@ static void askSimBit(uint8_t c, int *n, uint8_t clock, uint8_t manchester)
uint8_t *dest = BigBuf_get_addr(); uint8_t *dest = BigBuf_get_addr();
uint8_t halfClk = clock/2; uint8_t halfClk = clock/2;
// c = current bit 1 or 0 // c = current bit 1 or 0
if (manchester){ if (manchester==1){
memset(dest+(*n), c, halfClk); memset(dest+(*n), c, halfClk);
memset(dest+(*n) + halfClk, c^1, halfClk); memset(dest+(*n) + halfClk, c^1, halfClk);
} else { } else {
@ -631,26 +631,54 @@ static void askSimBit(uint8_t c, int *n, uint8_t clock, uint8_t manchester)
*n += clock; *n += clock;
} }
static void biphaseSimBit(uint8_t c, int *n, uint8_t clock, uint8_t *phase)
{
uint8_t *dest = BigBuf_get_addr();
uint8_t halfClk = clock/2;
if (c){
memset(dest+(*n), c ^ 1 ^ *phase, halfClk);
memset(dest+(*n) + halfClk, c ^ *phase, halfClk);
} else {
memset(dest+(*n), c ^ *phase, clock);
*phase ^= 1;
}
}
// args clock, ask/man or askraw, invert, transmission separator // args clock, ask/man or askraw, invert, transmission separator
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)
{ {
int ledcontrol = 1; int ledcontrol = 1;
int n=0, i=0; int n=0, i=0;
uint8_t clk = (arg1 >> 8) & 0xFF; uint8_t clk = (arg1 >> 8) & 0xFF;
uint8_t manchester = arg1 & 1; uint8_t encoding = arg1 & 1;
uint8_t separator = arg2 & 1; uint8_t separator = arg2 & 1;
uint8_t invert = (arg2 >> 8) & 1; uint8_t invert = (arg2 >> 8) & 1;
for (i=0; i<size; i++){
askSimBit(BitStream[i]^invert, &n, clk, manchester); if (encoding==2){ //biphase
} uint8_t phase=0;
if (manchester==0 && BitStream[0]==BitStream[size-1]){ //run a second set inverted (for biphase phase)
for (i=0; i<size; i++){ for (i=0; i<size; i++){
askSimBit(BitStream[i]^invert^1, &n, clk, manchester); biphaseSimBit(BitStream[i]^invert, &n, clk, &phase);
}
if (BitStream[0]==BitStream[size-1]){ //run a second set inverted to keep phase in check
for (i=0; i<size; i++){
biphaseSimBit(BitStream[i]^invert, &n, clk, &phase);
}
}
} else { // ask/manchester || ask/raw
for (i=0; i<size; i++){
askSimBit(BitStream[i]^invert, &n, clk, encoding);
}
if (encoding==0 && BitStream[0]==BitStream[size-1]){ //run a second set inverted (for biphase phase)
for (i=0; i<size; i++){
askSimBit(BitStream[i]^invert^1, &n, clk, encoding);
}
} }
} }
if (separator==1) Dbprintf("sorry but separator option not yet available"); if (separator==1) Dbprintf("sorry but separator option not yet available");
Dbprintf("Simulating with clk: %d, invert: %d, manchester: %d, separator: %d, n: %d",clk, invert, manchester, separator, n); Dbprintf("Simulating with clk: %d, invert: %d, encoding: %d, separator: %d, n: %d",clk, invert, encoding, separator, n);
//DEBUG //DEBUG
//Dbprintf("First 32:"); //Dbprintf("First 32:");
//uint8_t *dest = BigBuf_get_addr(); //uint8_t *dest = BigBuf_get_addr();
@ -817,8 +845,9 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = BigBuf_get_addr(); uint8_t *dest = BigBuf_get_addr();
size_t size=0, idx=0; size_t size=0, idx=0;
int clk=0, invert=0, errCnt=0, maxErr=20; int clk=0, invert=0, errCnt=0, maxErr=20;
uint32_t hi=0;
uint64_t lo=0; uint64_t lo=0;
// Configure to go in 125Khz listen mode // Configure to go in 125Khz listen mode
LFSetupFPGAForADC(95, true); LFSetupFPGAForADC(95, true);
@ -828,24 +857,34 @@ void CmdEM410xdemod(int findone, int *high, int *low, int ledcontrol)
WDT_HIT(); WDT_HIT();
if (ledcontrol) LED_A_ON(); if (ledcontrol) LED_A_ON();
DoAcquisition_default(-1,true); DoAcquisition_default(-1,true);
size = BigBuf_max_traceLen(); size = BigBuf_max_traceLen();
//Dbprintf("DEBUG: Buffer got"); //Dbprintf("DEBUG: Buffer got");
//askdemod and manchester decode //askdemod and manchester decode
errCnt = askmandemod(dest, &size, &clk, &invert, maxErr); errCnt = askmandemod(dest, &size, &clk, &invert, maxErr);
//Dbprintf("DEBUG: ASK Got"); //Dbprintf("DEBUG: ASK Got");
WDT_HIT(); WDT_HIT();
if (errCnt>=0){ if (errCnt>=0){
lo = Em410xDecode(dest, &size, &idx); errCnt = Em410xDecode(dest, &size, &idx, &hi, &lo);
//Dbprintf("DEBUG: EM GOT"); //Dbprintf("DEBUG: EM GOT");
if (lo>0){ if (errCnt){
Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)", if (size>64){
(uint32_t)(lo>>32), Dbprintf("EM XL TAG ID: %06x%08x%08x - (%05d_%03d_%08d)",
(uint32_t)lo, hi,
(uint32_t)(lo&0xFFFF), (uint32_t)(lo>>32),
(uint32_t)((lo>>16LL) & 0xFF), (uint32_t)lo,
(uint32_t)(lo & 0xFFFFFF)); (uint32_t)(lo&0xFFFF),
(uint32_t)((lo>>16LL) & 0xFF),
(uint32_t)(lo & 0xFFFFFF));
} else {
Dbprintf("EM TAG ID: %02x%08x - (%05d_%03d_%08d)",
(uint32_t)(lo>>32),
(uint32_t)lo,
(uint32_t)(lo&0xFFFF),
(uint32_t)((lo>>16LL) & 0xFF),
(uint32_t)(lo & 0xFFFFFF));
}
} }
if (findone){ if (findone){
if (ledcontrol) LED_A_OFF(); if (ledcontrol) LED_A_OFF();

256
client/cmddata.c
View file

@ -260,9 +260,9 @@ void printBitStream(uint8_t BitStream[], uint32_t bitLen)
} }
//by marshmellow //by marshmellow
//print 64 bit EM410x ID in multiple formats //print 64 bit EM410x ID in multiple formats
void printEM410x(uint64_t id) void printEM410x(uint32_t hi, uint64_t id)
{ {
if (id !=0){ if (id || hi){
uint64_t iii=1; uint64_t iii=1;
uint64_t id2lo=0; uint64_t id2lo=0;
uint32_t ii=0; uint32_t ii=0;
@ -272,16 +272,21 @@ void printEM410x(uint64_t id)
id2lo=(id2lo<<1LL) | ((id & (iii << (i+((ii-1)*8)))) >> (i+((ii-1)*8))); id2lo=(id2lo<<1LL) | ((id & (iii << (i+((ii-1)*8)))) >> (i+((ii-1)*8)));
} }
} }
//output em id if (hi){
PrintAndLog("EM TAG ID : %010llx", id); //output 88 bit em id
PrintAndLog("Unique TAG ID: %010llx", id2lo); PrintAndLog("EM TAG ID : %06x%016llx", hi, id);
PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF); } else{
PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF); //output 40 bit em id
PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF)); PrintAndLog("EM TAG ID : %010llx", id);
PrintAndLog("DEZ 3.5A : %03lld.%05lld",(id>>32ll),(id & 0xFFFF)); PrintAndLog("Unique TAG ID: %010llx", id2lo);
PrintAndLog("DEZ 14/IK2 : %014lld",id); PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF);
PrintAndLog("DEZ 15/IK3 : %015lld",id2lo); PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF);
PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF)); PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
PrintAndLog("DEZ 3.5A : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
PrintAndLog("DEZ 14/IK2 : %014lld",id);
PrintAndLog("DEZ 15/IK3 : %015lld",id2lo);
PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
}
} }
return; return;
} }
@ -292,9 +297,6 @@ void printEM410x(uint64_t id)
//prints binary found and saves in graphbuffer for further commands //prints binary found and saves in graphbuffer for further commands
int CmdAskEM410xDemod(const char *Cmd) int CmdAskEM410xDemod(const char *Cmd)
{ {
int invert=0;
int clk=0;
int maxErr=100;
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 10 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data askem410xdemod [clock] <0|1> [maxError]"); PrintAndLog("Usage: data askem410xdemod [clock] <0|1> [maxError]");
@ -307,50 +309,21 @@ int CmdAskEM410xDemod(const char *Cmd)
PrintAndLog(" : data askem410xdemod 32 1 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32 and inverting data"); PrintAndLog(" : data askem410xdemod 32 1 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data askem410xdemod 1 = demod an EM410x Tag ID from GraphBuffer while inverting data"); PrintAndLog(" : data askem410xdemod 1 = demod an EM410x Tag ID from GraphBuffer while inverting data");
PrintAndLog(" : data askem410xdemod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors"); PrintAndLog(" : data askem410xdemod 64 1 0 = demod an EM410x Tag ID from GraphBuffer using a clock of RF/64 and inverting data and allowing 0 demod errors");
return 0; return 0;
} }
int ans = ASKmanDemod(Cmd, FALSE, FALSE);
if (!ans) return 0;
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i %i", &clk, &invert, &maxErr);
if (invert != 0 && invert != 1) {
PrintAndLog("Invalid argument: %s", Cmd);
return 0;
}
size_t BitLen = getFromGraphBuf(BitStream);
if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
if (BitLen==0) return 0;
int errCnt=0;
errCnt = askmandemod(BitStream, &BitLen, &clk, &invert, maxErr);
if (errCnt<0||BitLen<16){ //if fatal error (or -1)
if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0;
}
PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
//output
if (errCnt>0){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
}
//PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits
setDemodBuf(BitStream,BitLen,0);
//printDemodBuff();
uint64_t lo =0; uint64_t lo =0;
uint32_t hi =0;
size_t idx=0; size_t idx=0;
lo = Em410xDecode(BitStream, &BitLen, &idx); if (Em410xDecode(DemodBuffer,(size_t *) &DemodBufferLen, &idx, &hi, &lo)){
if (lo>0){
//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); PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, DemodBufferLen);
printDemodBuff(); printDemodBuff();
} }
PrintAndLog("EM410x pattern found: "); PrintAndLog("EM410x pattern found: ");
if (BitLen > 64) PrintAndLog("\nWarning! Length not what is expected - Length: %d bits\n",BitLen); printEM410x(hi, lo);
printEM410x(lo);
return 1; return 1;
} }
return 0; return 0;
@ -381,21 +354,21 @@ int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch)
if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk); if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
return 0; return 0;
} }
if (verbose) PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen); if (verbose || g_debugMode) PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
//output //output
if (errCnt>0){ if (errCnt>0){
if (verbose) PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt); if (verbose || g_debugMode) PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
} }
if (verbose) PrintAndLog("ASK/Manchester decoded bitstream:"); if (verbose || g_debugMode) PrintAndLog("ASK/Manchester decoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
setDemodBuf(BitStream,BitLen,0); setDemodBuf(BitStream,BitLen,0);
if (verbose) printDemodBuff(); if (verbose || g_debugMode) printDemodBuff();
uint64_t lo =0; uint64_t lo =0;
uint32_t hi =0;
size_t idx=0; size_t idx=0;
if (emSearch){ if (emSearch){
lo = Em410xDecode(BitStream, &BitLen, &idx); if (Em410xDecode(BitStream, &BitLen, &idx, &hi, &lo)){
if (lo>0){
//set GraphBuffer for clone or sim command //set GraphBuffer for clone or sim command
setDemodBuf(BitStream, BitLen, idx); setDemodBuf(BitStream, BitLen, idx);
if (g_debugMode){ if (g_debugMode){
@ -403,7 +376,7 @@ int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch)
printDemodBuff(); printDemodBuff();
} }
if (verbose) PrintAndLog("EM410x pattern found: "); if (verbose) PrintAndLog("EM410x pattern found: ");
if (verbose) printEM410x(lo); if (verbose) printEM410x(hi, lo);
return 1; return 1;
} }
} }
@ -473,13 +446,13 @@ int Cmdmandecoderaw(const char *Cmd)
printBitStream(BitStream, size); printBitStream(BitStream, size);
if (errCnt==0){ if (errCnt==0){
uint64_t id = 0; uint64_t id = 0;
uint32_t hi = 0;
size_t idx=0; size_t idx=0;
id = Em410xDecode(BitStream, &size, &idx); if (Em410xDecode(BitStream, &size, &idx, &hi, &id)){
if (id>0){
//need to adjust to set bitstream back to manchester encoded data //need to adjust to set bitstream back to manchester encoded data
//setDemodBuf(BitStream, size, idx); //setDemodBuf(BitStream, size, idx);
printEM410x(id); printEM410x(hi, id);
} }
} }
return 1; return 1;
@ -497,53 +470,52 @@ int Cmdmandecoderaw(const char *Cmd)
// width waves vs small width waves to help the decode positioning) or askbiphdemod // width waves vs small width waves to help the decode positioning) or askbiphdemod
int CmdBiphaseDecodeRaw(const char *Cmd) int CmdBiphaseDecodeRaw(const char *Cmd)
{ {
int i = 0;
int errCnt=0;
size_t size=0; size_t size=0;
int offset=0; int offset=0, invert=0, maxErr=20, errCnt=0;
int invert=0;
int high=0, low=0;
char cmdp = param_getchar(Cmd, 0); char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') { if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data biphaserawdecode [offset] <invert>"); PrintAndLog("Usage: data biphaserawdecode [offset] [invert] [maxErr]");
PrintAndLog(" Converts 10 or 01 to 0 and 11 or 00 to 1"); PrintAndLog(" Converts 10 or 01 to 1 and 11 or 00 to 0");
PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)"); PrintAndLog(" --must have binary sequence in demodbuffer (run data askrawdemod first)");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" [offset <0|1>], set to 0 not to adjust start position or to 1 to adjust decode start position"); PrintAndLog(" [offset <0|1>], set to 0 not to adjust start position or to 1 to adjust decode start position");
PrintAndLog(" [invert <0|1>], set to 1 to invert output"); PrintAndLog(" [invert <0|1>], set to 1 to invert output");
PrintAndLog(" [maxErr int], set max errors tolerated - default=20");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data biphaserawdecode = decode biphase bitstream from the demodbuffer"); PrintAndLog(" sample: data biphaserawdecode = decode biphase bitstream from the demodbuffer");
PrintAndLog(" sample: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output"); PrintAndLog(" sample: data biphaserawdecode 1 1 = decode biphase bitstream from the demodbuffer, set offset, and invert output");
return 0; return 0;
} }
sscanf(Cmd, "%i %i", &offset, &invert); sscanf(Cmd, "%i %i %i", &offset, &invert, &maxErr);
if (DemodBufferLen==0) return 0; if (DemodBufferLen==0){
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; PrintAndLog("DemodBuffer Empty - run 'data rawdemod ar' first");
//get graphbuffer & high and low
for (;i<DemodBufferLen;++i){
if(DemodBuffer[i]>high)high=DemodBuffer[i];
else if(DemodBuffer[i]<low)low=DemodBuffer[i];
BitStream[i]=DemodBuffer[i];
}
if (high>1 || low <0){
PrintAndLog("Error: please raw demod the wave first then decode");
return 0; return 0;
} }
size=i; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
memcpy(BitStream, DemodBuffer, DemodBufferLen);
size = DemodBufferLen;
errCnt=BiphaseRawDecode(BitStream, &size, offset, invert); errCnt=BiphaseRawDecode(BitStream, &size, offset, invert);
if (errCnt>=20){ if (errCnt<0){
PrintAndLog("Error during decode:%d", errCnt);
return 0;
}
if (errCnt>maxErr){
PrintAndLog("Too many errors attempting to decode: %d",errCnt); PrintAndLog("Too many errors attempting to decode: %d",errCnt);
return 0; return 0;
} }
PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
if (errCnt>0){
PrintAndLog("# Errors found during Demod (shown as 77 in bit stream): %d",errCnt);
}
PrintAndLog("Biphase Decoded using offset: %d - # invert:%d - data:",offset,invert);
printBitStream(BitStream, size); printBitStream(BitStream, size);
PrintAndLog("\nif bitstream does not look right try offset=1");
if (offset == 1) setDemodBuf(DemodBuffer,DemodBufferLen-1,1); //remove first bit from raw demod if (offset) setDemodBuf(DemodBuffer,DemodBufferLen-offset, offset); //remove first bit from raw demod
return 1; return 1;
} }
// set demod buffer back to raw after biphase demod // set demod buffer back to raw after biphase demod
void setBiphaseDemodBuf(uint8_t *BitStream, size_t size) void setBiphasetoRawDemodBuf(uint8_t *BitStream, size_t size)
{ {
uint8_t rawStream[512]={0x00}; uint8_t rawStream[512]={0x00};
size_t i=0; size_t i=0;
@ -565,6 +537,7 @@ void setBiphaseDemodBuf(uint8_t *BitStream, size_t size)
setDemodBuf(rawStream,i,0); setDemodBuf(rawStream,i,0);
return; return;
} }
//by marshmellow //by marshmellow
//takes 4 arguments - clock, invert, maxErr as integers and amplify as char //takes 4 arguments - clock, invert, maxErr as integers and amplify as char
//attempts to demodulate ask only //attempts to demodulate ask only
@ -579,7 +552,7 @@ int ASKrawDemod(const char *Cmd, bool verbose)
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0}; uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
sscanf(Cmd, "%i %i %i %c", &clk, &invert, &maxErr, &amp); sscanf(Cmd, "%i %i %i %c", &clk, &invert, &maxErr, &amp);
if (invert != 0 && invert != 1) { if (invert != 0 && invert != 1) {
if (verbose) PrintAndLog("Invalid argument: %s", Cmd); if (verbose || g_debugMode) PrintAndLog("Invalid argument: %s", Cmd);
return 0; return 0;
} }
if (clk==1){ if (clk==1){
@ -592,20 +565,20 @@ int ASKrawDemod(const char *Cmd, bool verbose)
int errCnt=0; int errCnt=0;
errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp); errCnt = askrawdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp);
if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first) if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
if (verbose) PrintAndLog("no data found"); if (verbose || g_debugMode) PrintAndLog("no data found");
if (g_debugMode==1 && verbose) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert); if (g_debugMode) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
return 0; return 0;
} }
if (verbose) PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, BitLen); if (verbose || g_debugMode) PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, BitLen);
//move BitStream back to DemodBuffer //move BitStream back to DemodBuffer
setDemodBuf(BitStream,BitLen,0); setDemodBuf(BitStream,BitLen,0);
//output //output
if (errCnt>0 && verbose){ if (errCnt>0 && (verbose || g_debugMode)){
PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d", errCnt); PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d", errCnt);
} }
if (verbose){ if (verbose || g_debugMode){
PrintAndLog("ASK demoded bitstream:"); PrintAndLog("ASK demoded bitstream:");
// Now output the bitstream to the scrollback by line of 16 bits // Now output the bitstream to the scrollback by line of 16 bits
printBitStream(BitStream,BitLen); printBitStream(BitStream,BitLen);
@ -613,6 +586,71 @@ int ASKrawDemod(const char *Cmd, bool verbose)
return 1; return 1;
} }
//by marshmellow
// - ASK Demod then Biphase decode GraphBuffer samples
int ASKbiphaseDemod(const char *Cmd, bool verbose)
{
//ask raw demod GraphBuffer first
int offset=0, clk=0, invert=0, maxErr=0, ans=0;
ans = sscanf(Cmd, "%i %i %i %i", &offset, &clk, &invert, &maxErr);
if (ans>0)
ans = ASKrawDemod(Cmd+2, FALSE);
else
ans = ASKrawDemod(Cmd, FALSE);
if (!ans) {
if (g_debugMode || verbose) PrintAndLog("Error AskrawDemod: %d", ans);
return 0;
}
//attempt to Biphase decode DemodBuffer
size_t size = DemodBufferLen;
uint8_t BitStream[MAX_DEMOD_BUF_LEN];
memcpy(BitStream, DemodBuffer, DemodBufferLen);
int errCnt = BiphaseRawDecode(BitStream, &size, offset, invert);
if (errCnt < 0){
if (g_debugMode || verbose) PrintAndLog("Error BiphaseRawDecode: %d", errCnt);
return 0;
}
if (errCnt > maxErr) {
if (g_debugMode || verbose) PrintAndLog("Error BiphaseRawDecode too many errors: %d", errCnt);
return 0;
}
//success set DemodBuffer and return
setDemodBuf(BitStream, size, 0);
if (g_debugMode || verbose){
PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
printDemodBuff();
}
return 1;
}
//by marshmellow - see ASKbiphaseDemod
int Cmdaskbiphdemod(const char *Cmd)
{
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) > 12 || cmdp == 'h' || cmdp == 'H') {
PrintAndLog("Usage: data rawdemod ab [offset] [clock] <invert> [maxError] <amplify>");
PrintAndLog(" [offset], offset to begin biphase, default=0");
PrintAndLog(" [set clock as integer] optional, if not set, autodetect");
PrintAndLog(" <invert>, 1 to invert output");
PrintAndLog(" [set maximum allowed errors], default = 100");
PrintAndLog(" <amplify>, 'a' to attempt demod with ask amplification, default = no amp");
PrintAndLog(" NOTE: <invert> can be entered as second or third argument");
PrintAndLog(" NOTE: <amplify> can be entered as first, second or last argument");
PrintAndLog(" NOTE: any other arg must have previous args set to work");
PrintAndLog("");
PrintAndLog(" sample: data rawdemod ab = demod an ask/biph tag from GraphBuffer");
PrintAndLog(" : data rawdemod ab a = demod an ask/biph tag from GraphBuffer, amplified");
PrintAndLog(" : data rawdemod ab 1 32 = demod an ask/biph tag from GraphBuffer using an offset of 1 and a clock of RF/32");
PrintAndLog(" : data rawdemod ab 0 32 1 = demod an ask/biph tag from GraphBuffer using a clock of RF/32 and inverting data");
PrintAndLog(" : data rawdemod ab 0 1 = demod an ask/biph tag from GraphBuffer while inverting data");
PrintAndLog(" : data rawdemod ab 0 64 1 0 = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
PrintAndLog(" : data rawdemod ab 0 64 1 0 a = demod an ask/biph tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors, and amp");
return 0;
}
return ASKbiphaseDemod(Cmd, TRUE);
}
//by marshmellow //by marshmellow
//attempts to demodulate and identify a G_Prox_II verex/chubb card //attempts to demodulate and identify a G_Prox_II verex/chubb card
//WARNING: if it fails during some points it will destroy the DemodBuffer data //WARNING: if it fails during some points it will destroy the DemodBuffer data
@ -620,32 +658,16 @@ int ASKrawDemod(const char *Cmd, bool verbose)
//if successful it will push askraw data back to demod buffer ready for emulation //if successful it will push askraw data back to demod buffer ready for emulation
int CmdG_Prox_II_Demod(const char *Cmd) int CmdG_Prox_II_Demod(const char *Cmd)
{ {
int ans = ASKrawDemod(Cmd, FALSE); if (!ASKbiphaseDemod(Cmd, FALSE)){
if (ans <= 0) { if (g_debugMode) PrintAndLog("ASKbiphaseDemod failed 1st try");
if (g_debugMode) PrintAndLog("Error AskrawDemod: %d",ans); return 0;
return 0; //ans;
} }
size_t size = DemodBufferLen; size_t size = DemodBufferLen;
ans = BiphaseRawDecode(DemodBuffer, &size, 0, 0);
if (ans !=0) {
if (g_debugMode) PrintAndLog("Error BiphaseRawDecode: %d",ans);
return 0; //ans;
}
//call lfdemod.c demod for gProxII //call lfdemod.c demod for gProxII
ans = gProxII_Demod(DemodBuffer, &size); int ans = gProxII_Demod(DemodBuffer, &size);
if (ans < 0){ if (ans < 0){
if (g_debugMode) PrintAndLog("Error gProxII_Demod 1st Try: %d",ans); if (g_debugMode) PrintAndLog("Error gProxII_Demod");
//try biphase again return 0;
ans = BiphaseRawDecode(DemodBuffer, &size, 1, 0);
if (ans != 0) {
if (g_debugMode) PrintAndLog("Error BiphaseRawDecode: %d",ans);
return 0;//ans;
}
ans = gProxII_Demod(DemodBuffer, &size);
if (ans < 0) {
if (g_debugMode) PrintAndLog("Error gProxII_Demod 1st Try: %d",ans);
return ans;
}
} }
//got a good demod //got a good demod
uint32_t ByteStream[65] = {0x00}; uint32_t ByteStream[65] = {0x00};
@ -659,7 +681,7 @@ int CmdG_Prox_II_Demod(const char *Cmd)
//spacer bit - should be 0 //spacer bit - should be 0
if (DemodBuffer[startIdx+idx] != 0) { if (DemodBuffer[startIdx+idx] != 0) {
if (g_debugMode) PrintAndLog("Error spacer not 0: %d, pos: %d",DemodBuffer[startIdx+idx],startIdx+idx); if (g_debugMode) PrintAndLog("Error spacer not 0: %d, pos: %d",DemodBuffer[startIdx+idx],startIdx+idx);
return -1; return 0;
} }
continue; continue;
} }
@ -703,7 +725,7 @@ int CmdG_Prox_II_Demod(const char *Cmd)
PrintAndLog("Unknown G-Prox-II Fmt Found: FmtLen %d",fmtLen); PrintAndLog("Unknown G-Prox-II Fmt Found: FmtLen %d",fmtLen);
} }
PrintAndLog("Raw: %08x%08x%08x", raw1,raw2,raw3); PrintAndLog("Raw: %08x%08x%08x", raw1,raw2,raw3);
setBiphaseDemodBuf(DemodBuffer+ans, 96); setDemodBuf(DemodBuffer+ans, 96, 0);
return 1; return 1;
} }
@ -1950,12 +1972,14 @@ int CmdRawDemod(const char *Cmd)
if (strlen(Cmd) > 14 || cmdp == 'h' || cmdp == 'H' || strlen(Cmd)<2) { if (strlen(Cmd) > 14 || cmdp == 'h' || cmdp == 'H' || strlen(Cmd)<2) {
PrintAndLog("Usage: data rawdemod [modulation] <help>|<options>"); PrintAndLog("Usage: data rawdemod [modulation] <help>|<options>");
PrintAndLog(" [modulation] as 2 char, 'am' for ask/manchester, 'ar' for ask/raw, 'fs' for fsk, 'nr' for nrz/direct, 'p1' for psk1, 'p2' for psk2"); PrintAndLog(" [modulation] as 2 char, 'ab' for ask/biphase, 'am' for ask/manchester, 'ar' for ask/raw, 'fs' for fsk, ...");
PrintAndLog(" 'nr' for nrz/direct, 'p1' for psk1, 'p2' for psk2");
PrintAndLog(" <help> as 'h', prints the help for the specific modulation"); PrintAndLog(" <help> as 'h', prints the help for the specific modulation");
PrintAndLog(" <options> see specific modulation help for optional parameters"); PrintAndLog(" <options> see specific modulation help for optional parameters");
PrintAndLog(""); PrintAndLog("");
PrintAndLog(" sample: data rawdemod fs h = print help for ask/raw demod"); PrintAndLog(" sample: data rawdemod fs h = print help for ask/raw demod");
PrintAndLog(" : data rawdemod fs = demod GraphBuffer using: fsk - autodetect"); PrintAndLog(" : data rawdemod fs = demod GraphBuffer using: fsk - autodetect");
PrintAndLog(" : data rawdemod ab = demod GraphBuffer using: ask/biphase - autodetect");
PrintAndLog(" : data rawdemod am = demod GraphBuffer using: ask/manchester - autodetect"); PrintAndLog(" : data rawdemod am = demod GraphBuffer using: ask/manchester - autodetect");
PrintAndLog(" : data rawdemod ar = demod GraphBuffer using: ask/raw - autodetect"); PrintAndLog(" : data rawdemod ar = demod GraphBuffer using: ask/raw - autodetect");
PrintAndLog(" : data rawdemod nr = demod GraphBuffer using: nrz/direct - autodetect"); PrintAndLog(" : data rawdemod nr = demod GraphBuffer using: nrz/direct - autodetect");
@ -1967,6 +1991,8 @@ int CmdRawDemod(const char *Cmd)
int ans = 0; int ans = 0;
if (cmdp == 'f' && cmdp2 == 's'){ if (cmdp == 'f' && cmdp2 == 's'){
ans = CmdFSKrawdemod(Cmd+3); ans = CmdFSKrawdemod(Cmd+3);
} else if(cmdp == 'a' && cmdp2 == 'b'){
ans = Cmdaskbiphdemod(Cmd+3);
} else if(cmdp == 'a' && cmdp2 == 'm'){ } else if(cmdp == 'a' && cmdp2 == 'm'){
ans = Cmdaskmandemod(Cmd+3); ans = Cmdaskmandemod(Cmd+3);
} else if(cmdp == 'a' && cmdp2 == 'r'){ } else if(cmdp == 'a' && cmdp2 == 'r'){

1
client/cmddata.h
View file

@ -63,6 +63,7 @@ int CmdThreshold(const char *Cmd);
int CmdDirectionalThreshold(const char *Cmd); int CmdDirectionalThreshold(const char *Cmd);
int CmdZerocrossings(const char *Cmd); int CmdZerocrossings(const char *Cmd);
int CmdIndalaDecode(const char *Cmd); int CmdIndalaDecode(const char *Cmd);
int ASKbiphaseDemod(const char *Cmd, bool verbose);
int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch); int ASKmanDemod(const char *Cmd, bool verbose, bool emSearch);
int ASKrawDemod(const char *Cmd, bool verbose); int ASKrawDemod(const char *Cmd, bool verbose);
int FSKrawDemod(const char *Cmd, bool verbose); int FSKrawDemod(const char *Cmd, bool verbose);

31
client/cmdlf.c
View file

@ -570,12 +570,13 @@ int usage_lf_simfsk(void)
int usage_lf_simask(void) int usage_lf_simask(void)
{ {
//print help //print help
PrintAndLog("Usage: lf simask [c <clock>] [i] [m|r] [s] [d <raw hex to sim>]"); PrintAndLog("Usage: lf simask [c <clock>] [i] [b|m|r] [s] [d <raw hex to sim>]");
PrintAndLog("Options: "); PrintAndLog("Options: ");
PrintAndLog(" h This help"); PrintAndLog(" h This help");
PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer"); PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
PrintAndLog(" i invert data"); PrintAndLog(" i invert data");
PrintAndLog(" m sim ask/manchester"); PrintAndLog(" b sim ask/biphase");
PrintAndLog(" m sim ask/manchester - Default");
PrintAndLog(" r sim ask/raw"); PrintAndLog(" r sim ask/raw");
PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap"); PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap");
PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer"); PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
@ -703,7 +704,7 @@ int CmdLFaskSim(const char *Cmd)
{ {
//autodetect clock from Graphbuffer if using demod buffer //autodetect clock from Graphbuffer if using demod buffer
//will need clock, invert, manchester/raw as m or r, separator as s, and bitstream //will need clock, invert, manchester/raw as m or r, separator as s, and bitstream
uint8_t manchester = 1, separator = 0; uint8_t encoding = 1, separator = 0;
//char cmdp = Cmd[0], par3='m', par4=0; //char cmdp = Cmd[0], par3='m', par4=0;
uint8_t clk=0, invert=0; uint8_t clk=0, invert=0;
bool errors = FALSE; bool errors = FALSE;
@ -725,12 +726,16 @@ int CmdLFaskSim(const char *Cmd)
errors |= param_getdec(Cmd,cmdp+1,&clk); errors |= param_getdec(Cmd,cmdp+1,&clk);
cmdp+=2; cmdp+=2;
break; break;
case 'b':
encoding=2; //biphase
cmdp++;
break;
case 'm': case 'm':
manchester=1; encoding=1;
cmdp++; cmdp++;
break; break;
case 'r': case 'r':
manchester=0; encoding=0;
cmdp++; cmdp++;
break; break;
case 's': case 's':
@ -771,10 +776,10 @@ int CmdLFaskSim(const char *Cmd)
setDemodBuf(data, dataLen, 0); setDemodBuf(data, dataLen, 0);
} }
if (clk == 0) clk = 64; if (clk == 0) clk = 64;
if (manchester == 0) clk = clk/2; //askraw needs to double the clock speed if (encoding == 0) clk = clk/2; //askraw needs to double the clock speed
uint16_t arg1, arg2; uint16_t arg1, arg2;
size_t size=DemodBufferLen; size_t size=DemodBufferLen;
arg1 = clk << 8 | manchester; arg1 = clk << 8 | encoding;
arg2 = invert << 8 | separator; arg2 = invert << 8 | separator;
if (size > USB_CMD_DATA_SIZE) { if (size > USB_CMD_DATA_SIZE) {
PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE); PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size, USB_CMD_DATA_SIZE);
@ -1082,24 +1087,28 @@ int CmdLFfind(const char *Cmd)
PrintAndLog("\nChecking for Unknown tags:\n"); PrintAndLog("\nChecking for Unknown tags:\n");
ans=AutoCorrelate(4000, FALSE, FALSE); ans=AutoCorrelate(4000, FALSE, FALSE);
if (ans > 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans); if (ans > 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans);
ans=CmdDetectClockRate("F"); //GetFSKClock("",TRUE,FALSE); ans=GetFskClock("",FALSE,FALSE); //CmdDetectClockRate("F"); //
if (ans != 0){ //fsk if (ans != 0){ //fsk
ans=CmdFSKrawdemod(""); ans=FSKrawDemod("",FALSE);
if (ans>0) { if (ans>0) {
PrintAndLog("\nUnknown FSK Modulated Tag Found!"); PrintAndLog("\nUnknown FSK Modulated Tag Found!");
printDemodBuff();
return 1; return 1;
} }
} }
ans=Cmdaskmandemod(""); ans=ASKmanDemod("",FALSE,FALSE);
if (ans>0) { if (ans>0) {
PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!"); 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'");
printDemodBuff();
return 1; return 1;
} }
ans=CmdPSK1rawDemod(""); ans=CmdPSK1rawDemod("");
if (ans>0) { if (ans>0) {
PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data psk2rawdemod'"); 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 PSK3 - [currently not supported]");
PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod"); PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod");
printDemodBuff();
return 1; return 1;
} }
PrintAndLog("\nNo Data Found!\n"); PrintAndLog("\nNo Data Found!\n");