#include "cmddata.h"
#include "lfdemod.h"
#include "usb_cmd.h"
+#include "crc.h"
uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
uint8_t g_debugMode;
return ASKrawDemod(Cmd, TRUE);
}
-int CmdAutoCorr(const char *Cmd)
+int AutoCorrelate(int window, bool SaveGrph, bool verbose)
{
static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];
+ size_t Correlation = 0;
+ int maxSum = 0;
+ int lastMax = 0;
+ if (verbose) PrintAndLog("performing %d correlations", GraphTraceLen - window);
+ for (int i = 0; i < GraphTraceLen - window; ++i) {
+ int sum = 0;
+ for (int j = 0; j < window; ++j) {
+ sum += (GraphBuffer[j]*GraphBuffer[i + j]) / 256;
+ }
+ CorrelBuffer[i] = sum;
+ if (sum >= maxSum-100 && sum <= maxSum+100){
+ //another max
+ Correlation = i-lastMax;
+ lastMax = i;
+ if (sum > maxSum) maxSum = sum;
+ } else if (sum > maxSum){
+ maxSum=sum;
+ lastMax = i;
+ }
+ }
+ if (Correlation==0){
+ //try again with wider margin
+ for (int i = 0; i < GraphTraceLen - window; i++){
+ if (CorrelBuffer[i] >= maxSum-(maxSum*0.05) && CorrelBuffer[i] <= maxSum+(maxSum*0.05)){
+ //another max
+ Correlation = i-lastMax;
+ lastMax = i;
+ //if (CorrelBuffer[i] > maxSum) maxSum = sum;
+ }
+ }
+ }
+ if (verbose && Correlation > 0) PrintAndLog("Possible Correlation: %d samples",Correlation);
+ if (SaveGrph){
+ GraphTraceLen = GraphTraceLen - window;
+ memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen * sizeof (int));
+ RepaintGraphWindow();
+ }
+ return Correlation;
+}
+
+int CmdAutoCorr(const char *Cmd)
+{
int window = atoi(Cmd);
if (window == 0) {
GraphTraceLen);
return 0;
}
-
- PrintAndLog("performing %d correlations", GraphTraceLen - window);
-
- for (int i = 0; i < GraphTraceLen - window; ++i) {
- int sum = 0;
- for (int j = 0; j < window; ++j) {
- sum += (GraphBuffer[j]*GraphBuffer[i + j]) / 256;
- }
- CorrelBuffer[i] = sum;
- }
- GraphTraceLen = GraphTraceLen - window;
- memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen * sizeof (int));
-
- RepaintGraphWindow();
- return 0;
+ return AutoCorrelate(window, TRUE, TRUE);
}
int CmdBitsamples(const char *Cmd)
// w = wiegand parity, x = extra space for other formats
// p = unknown checksum
// (26 bit format shown)
-
+
+ //get bytes for checksum calc
+ uint8_t checksum = bytebits_to_byte(BitStream + idx + 120, 8);
+ uint8_t csBuff[14] = {0x00};
+ for (uint8_t i = 0; i < 13; i++){
+ csBuff[i] = bytebits_to_byte(BitStream + idx + 16 + (i*8), 8);
+ }
+ //check checksum calc
+ int checkCS = CRC8Maxim(csBuff,13);
+
//get raw ID before removing parities
uint32_t rawLo = bytebits_to_byte(BitStream+idx+96,32);
uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32);
size = removeParity(BitStream, idx+8, 8, 1, 120);
if (size != 105){
- if (g_debugMode==1) PrintAndLog("DEBUG: Error at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
+ if (g_debugMode==1)
+ PrintAndLog("DEBUG: Error at parity check - tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
return 0;
}
PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %08x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
}
}
+ if (checksum == checkCS)
+ PrintAndLog("Checksum %02x passed", checksum);
+ else
+ PrintAndLog("Checksum %02x failed - should have been %02x", checksum, checkCS);
+
if (g_debugMode){
PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128);
printDemodBuff();
int CmdG_Prox_II_Demod(const char *Cmd);
int Cmdaskrawdemod(const char *Cmd);
int Cmdaskmandemod(const char *Cmd);
+int AutoCorrelate(int window, bool SaveGrph, bool verbose);
int CmdAutoCorr(const char *Cmd);
int CmdBiphaseDecodeRaw(const char *Cmd);
int CmdBitsamples(const char *Cmd);
if (testRaw=='u' || testRaw=='U'){
//test unknown tag formats (raw mode)
PrintAndLog("\nChecking for Unknown tags:\n");
- ans=CmdDetectClockRate("f");
+ ans=AutoCorrelate(4000, FALSE, FALSE);
+ if (ans > 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans);
+ ans=CmdDetectClockRate("F"); //GetFSKClock("",TRUE,FALSE);
if (ans != 0){ //fsk
ans=CmdFSKrawdemod("");
if (ans>0) {
//-----------------------------------------------------------------------------
// Generic CRC calculation code.
//-----------------------------------------------------------------------------
-
#include "crc.h"
+#include <stdint.h>
+#include <stddef.h>
void crc_init(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor)
{
{
return ( crc->state ^ crc->final_xor ) & crc->mask;
}
+
+uint32_t CRC8Maxim(uint8_t *buff, size_t size )
+{
+ crc_t crc;
+ crc_init(&crc, 9, 0x8c, 0x00, 0x00);
+ crc_clear(&crc);
+
+ for (size_t i=0; i < size; ++i){
+ crc_update(&crc, buff[i], 8);
+ }
+ return crc_finish(&crc);
+}
--- /dev/null
+//-----------------------------------------------------------------------------
+// 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.
+//-----------------------------------------------------------------------------
+// Generic CRC calculation code.
+//-----------------------------------------------------------------------------
+
+#ifndef __CRC_H
+#define __CRC_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef struct crc {
+ uint32_t state;
+ int order;
+ uint32_t polynom;
+ uint32_t initial_value;
+ uint32_t final_xor;
+ uint32_t mask;
+} crc_t;
+
+/* Initialize a crc structure. order is the order of the polynom, e.g. 32 for a CRC-32
+ * polynom is the CRC polynom. initial_value is the initial value of a clean state.
+ * final_xor is XORed onto the state before returning it from crc_result(). */
+extern void crc_init(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor);
+
+/* Update the crc state. data is the data of length data_width bits (only the the
+ * data_width lower-most bits are used).
+ */
+extern void crc_update(crc_t *crc, uint32_t data, int data_width);
+
+/* Clean the crc state, e.g. reset it to initial_value */
+extern void crc_clear(crc_t *crc);
+
+/* Get the result of the crc calculation */
+extern uint32_t crc_finish(crc_t *crc);
+
+// Calculate CRC-8/Maxim checksum
+uint32_t CRC8Maxim(uint8_t *buff, size_t size );
+/* Static initialization of a crc structure */
+#define CRC_INITIALIZER(_order, _polynom, _initial_value, _final_xor) { \
+ .state = ((_initial_value) & ((1L<<(_order))-1)), \
+ .order = (_order), \
+ .polynom = (_polynom), \
+ .initial_value = (_initial_value), \
+ .final_xor = (_final_xor), \
+ .mask = ((1L<<(_order))-1) }
+
+#endif /* __CRC_H */
if (*size<loopCnt) loopCnt = *size;
uint8_t curPhase = *invert;
- size_t i, waveStart=0, waveEnd=0, firstFullWave=0, lastClkBit=0;
+ size_t i, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0;
uint8_t fc=0, fullWaveLen=0, tol=1;
uint16_t errCnt=0, waveLenCnt=0;
fc = countPSK_FC(dest, *size);
//find first phase shift
for (i=0; i<loopCnt; i++){
if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
- if (waveStart == 0) {
- waveStart = i+1;
- avgWaveVal=dest[i+1];
- //PrintAndLog("DEBUG: waveStart: %d",waveStart);
- } else {
- waveEnd = i+1;
- //PrintAndLog("DEBUG: waveEnd: %d",waveEnd);
- waveLenCnt = waveEnd-waveStart;
- lastAvgWaveVal = avgWaveVal/waveLenCnt;
- if (waveLenCnt > fc){
- firstFullWave = waveStart;
- fullWaveLen=waveLenCnt;
- //if average wave value is > graph 0 then it is an up wave or a 1
- if (lastAvgWaveVal > 128) curPhase^=1;
- break;
- }
- waveStart=0;
- avgWaveVal=0;
- }
+ waveEnd = i+1;
+ //PrintAndLog("DEBUG: waveEnd: %d",waveEnd);
+ waveLenCnt = waveEnd-waveStart;
+ if (waveLenCnt > fc && waveStart > fc){ //not first peak and is a large wave
+ lastAvgWaveVal = avgWaveVal/(waveLenCnt);
+ firstFullWave = waveStart;
+ fullWaveLen=waveLenCnt;
+ //if average wave value is > graph 0 then it is an up wave or a 1
+ if (lastAvgWaveVal > 123) curPhase^=1; //fudge graph 0 a little 123 vs 128
+ break;
+ }
+ waveStart = i+1;
+ avgWaveVal = 0;
}
- avgWaveVal+=dest[i+1];
+ avgWaveVal+=dest[i+2];
}
//PrintAndLog("DEBUG: firstFullWave: %d, waveLen: %d",firstFullWave,fullWaveLen);
lastClkBit = firstFullWave; //set start of wave as clock align
errCnt=0;
size_t numBits=0;
//PrintAndLog("DEBUG: clk: %d, lastClkBit: %d", *clock, lastClkBit);
-
+ dest[numBits++] = curPhase; //set first read bit
for (i = firstFullWave+fullWaveLen-1; i < *size-3; i++){
//top edge of wave = start of new wave
if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
waveEnd = i+1;
waveLenCnt = waveEnd-waveStart;
lastAvgWaveVal = avgWaveVal/waveLenCnt;
- if (waveLenCnt > fc){
+ if (waveLenCnt > fc){
//PrintAndLog("DEBUG: avgWaveVal: %d, waveSum: %d",lastAvgWaveVal,avgWaveVal);
//if this wave is a phase shift
//PrintAndLog("DEBUG: phase shift at: %d, len: %d, nextClk: %d, i: %d, fc: %d",waveStart,waveLenCnt,lastClkBit+*clock-tol,i+1,fc);
if (i+1 >= lastClkBit + *clock - tol){ //should be a clock bit
curPhase^=1;
- dest[numBits] = curPhase;
- numBits++;
+ dest[numBits++] = curPhase;
lastClkBit += *clock;
- } else if (i<lastClkBit+10){
+ } else if (i<lastClkBit+10+fc){
//noise after a phase shift - ignore
} else { //phase shift before supposed to based on clock
errCnt++;
- dest[numBits] = 77;
- numBits++;
+ dest[numBits++] = 77;
}
} else if (i+1 > lastClkBit + *clock + tol + fc){
lastClkBit += *clock; //no phase shift but clock bit
- dest[numBits] = curPhase;
- numBits++;
+ dest[numBits++] = curPhase;
}
avgWaveVal=0;
waveStart=i+1;
+++ /dev/null
-//-----------------------------------------------------------------------------
-// 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.
-//-----------------------------------------------------------------------------
-// Generic CRC calculation code.
-//-----------------------------------------------------------------------------
-
-#ifndef __CRC_H
-#define __CRC_H
-
-#include <stdint.h>
-
-typedef struct crc {
- uint32_t state;
- int order;
- uint32_t polynom;
- uint32_t initial_value;
- uint32_t final_xor;
- uint32_t mask;
-} crc_t;
-
-/* Initialize a crc structure. order is the order of the polynom, e.g. 32 for a CRC-32
- * polynom is the CRC polynom. initial_value is the initial value of a clean state.
- * final_xor is XORed onto the state before returning it from crc_result(). */
-extern void crc_init(crc_t *crc, int order, uint32_t polynom, uint32_t initial_value, uint32_t final_xor);
-
-/* Update the crc state. data is the data of length data_width bits (only the the
- * data_width lower-most bits are used).
- */
-extern void crc_update(crc_t *crc, uint32_t data, int data_width);
-
-/* Clean the crc state, e.g. reset it to initial_value */
-extern void crc_clear(crc_t *crc);
-
-/* Get the result of the crc calculation */
-extern uint32_t crc_finish(crc_t *crc);
-
-/* Static initialization of a crc structure */
-#define CRC_INITIALIZER(_order, _polynom, _initial_value, _final_xor) { \
- .state = ((_initial_value) & ((1L<<(_order))-1)), \
- .order = (_order), \
- .polynom = (_polynom), \
- .initial_value = (_initial_value), \
- .final_xor = (_final_xor), \
- .mask = ((1L<<(_order))-1) }
-
-#endif /* __CRC_H */
projects / proxmark3-svn / commitdiff