mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-02-13 10:43:01 +08:00
CHG: lf em - added @marshmellow42 's changes
This commit is contained in:
iceman1001
parent
03d73c0b8d
commit
4ac9f07840
3 changed files with 308 additions and 112 deletions
|
|
@ -1690,7 +1690,7 @@ void EM4xLogin(uint32_t pwd) {
|
|||
len = Prepare_Cmd( FWD_CMD_LOGIN );
|
||||
len += Prepare_Data( pwd & 0xFFFF, pwd >> 16 );
|
||||
SendForward(len);
|
||||
//WaitMS(20); - no wait for login command.
|
||||
WaitMS(20); // no wait for login command.
|
||||
// should receive
|
||||
// 0000 1010 ok.
|
||||
// 0000 0001 fail
|
||||
|
|
@ -1719,7 +1719,7 @@ void EM4xReadWord(uint8_t addr, uint32_t pwd, uint8_t usepwd) {
|
|||
|
||||
SendForward(len);
|
||||
|
||||
DoAcquisition_config(TRUE);
|
||||
DoAcquisition_default(0, TRUE);
|
||||
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
|
||||
cmd_send(CMD_ACK,0,0,0,0,0);
|
||||
|
|
@ -1752,8 +1752,12 @@ void EM4xWriteWord(uint32_t flag, uint32_t data, uint32_t pwd) {
|
|||
|
||||
SendForward(len);
|
||||
|
||||
//Wait 20ms for write to complete
|
||||
WaitMS(20);
|
||||
//Wait 20ms for write to complete?
|
||||
WaitMS(10);
|
||||
|
||||
//Capture response if one exists
|
||||
DoAcquisition_default(20, TRUE);
|
||||
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
|
||||
cmd_send(CMD_ACK,0,0,0,0,0);
|
||||
LED_A_OFF();
|
||||
|
|
|
|||
|
|
@ -251,6 +251,48 @@ bool EM_ByteParityTest(uint8_t *BitStream, size_t size, uint8_t rows, uint8_t co
|
|||
return true;
|
||||
}
|
||||
|
||||
|
||||
//////////////// 4050 / 4450 commands
|
||||
int usage_lf_em4x50_dump(void) {
|
||||
PrintAndLog("Dump EM4x50/EM4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em 4x50dump [h] <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em 4x50dump");
|
||||
PrintAndLog(" lf em 4x50dump 11223344");
|
||||
return 0;
|
||||
}
|
||||
int usage_lf_em4x50_read(void) {
|
||||
PrintAndLog("Read EM 4x50/EM4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em 4x50read [h] <address> <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" address - memory address to read. (0-15)");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em 4x50read 1");
|
||||
PrintAndLog(" lf em 4x50read 1 11223344");
|
||||
return 0;
|
||||
}
|
||||
int usage_lf_em4x50_write(void) {
|
||||
PrintAndLog("Write EM 4x50/4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em 4x50write [h] <address> <data> <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" address - memory address to write to. (0-15)");
|
||||
PrintAndLog(" data - data to write (hex)");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em 4x50write 1 deadc0de");
|
||||
PrintAndLog(" lf em 4x50write 1 deadc0de 11223344");
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool pTest)
|
||||
{
|
||||
if (size<45) return 0;
|
||||
|
|
@ -283,6 +325,8 @@ uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool
|
|||
}
|
||||
return code;
|
||||
}
|
||||
|
||||
|
||||
/* Read the transmitted data of an EM4x50 tag from the graphbuffer
|
||||
* Format:
|
||||
*
|
||||
|
|
@ -303,8 +347,7 @@ uint32_t OutputEM4x50_Block(uint8_t *BitStream, size_t size, bool verbose, bool
|
|||
* Word Read values. UID is stored in block 32.
|
||||
*/
|
||||
//completed by Marshmellow
|
||||
int EM4x50Read(const char *Cmd, bool verbose)
|
||||
{
|
||||
int EM4x50Read(const char *Cmd, bool verbose) {
|
||||
uint8_t fndClk[] = {8,16,32,40,50,64,128};
|
||||
int clk = 0;
|
||||
int invert = 0;
|
||||
|
|
@ -495,35 +538,21 @@ int EM4x50Read(const char *Cmd, bool verbose)
|
|||
}
|
||||
|
||||
int CmdEM4x50Read(const char *Cmd) {
|
||||
uint8_t ctmp = param_getchar(Cmd, 0);
|
||||
if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x50_read();
|
||||
return EM4x50Read(Cmd, true);
|
||||
}
|
||||
|
||||
int usage_lf_em_read(void) {
|
||||
PrintAndLog("Read EM 4x05/4x50/EM4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em readword [h] <address> <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" address - memory address to read. (0-15)");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em readword 1");
|
||||
PrintAndLog(" lf em readword 1 11223344");
|
||||
int CmdEM4x50Write(const char *Cmd){
|
||||
uint8_t ctmp = param_getchar(Cmd, 0);
|
||||
if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x50_write();
|
||||
PrintAndLog("no implemented yet");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int usage_lf_em_write(void) {
|
||||
PrintAndLog("Write EM 4x05/4x50/4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em writeword [h] <address> <data> <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" address - memory address to write to. (0-15)");
|
||||
PrintAndLog(" data - data to write (hex)");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em writeword 1");
|
||||
PrintAndLog(" lf em writeword 1 deadc0de 11223344");
|
||||
int CmdEM4x50Dump(const char *Cmd){
|
||||
uint8_t ctmp = param_getchar(Cmd, 0);
|
||||
if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x50_dump();
|
||||
PrintAndLog("no implemented yet");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -554,8 +583,8 @@ bool doPreambleSearch(size_t *startIdx){
|
|||
// skip first two 0 bits as they might have been missed in the demod
|
||||
uint8_t preamble[EM_PREAMBLE_LEN] = {0,0,1,0,1,0};
|
||||
|
||||
// set size to 10 to only test first 4 positions for the preamble
|
||||
size_t size = (10 > DemodBufferLen) ? DemodBufferLen : 10;
|
||||
// set size to 15 to only test first 4 positions for the preamble
|
||||
size_t size = (15 > DemodBufferLen) ? DemodBufferLen : 15;
|
||||
*startIdx = 0;
|
||||
uint8_t found = 0;
|
||||
|
||||
|
|
@ -579,13 +608,13 @@ bool doPreambleSearch(size_t *startIdx){
|
|||
bool detectFSK(){
|
||||
// detect fsk clock
|
||||
if (!GetFskClock("", FALSE, FALSE)) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: FSK clock failed");
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: FSK clock failed");
|
||||
return FALSE;
|
||||
}
|
||||
// demod
|
||||
int ans = FSKrawDemod("0 0", FALSE);
|
||||
if (!ans) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: FSK Demod failed");
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: FSK Demod failed");
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
|
|
@ -594,10 +623,24 @@ bool detectFSK(){
|
|||
bool detectPSK(){
|
||||
int ans = GetPskClock("", FALSE, FALSE);
|
||||
if (ans <= 0) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: PSK clock failed");
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: PSK clock failed");
|
||||
return FALSE;
|
||||
}
|
||||
PrintAndLog("PSK response possibly found, run `data rawd p1` to attempt to demod");
|
||||
//demod
|
||||
//try psk1 -- 0 0 6 (six errors?!?)
|
||||
ans = PSKDemod("0 0 6", FALSE);
|
||||
if (!ans) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: PSK1 Demod failed");
|
||||
|
||||
//try psk1 inverted
|
||||
ans = PSKDemod("0 1 6", FALSE);
|
||||
if (!ans) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: PSK1 inverted Demod failed");
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
// either PSK1 or PSK1 inverted is ok from here.
|
||||
// lets check PSK2 later.
|
||||
return TRUE;
|
||||
}
|
||||
// try manchester - NOTE: ST only applies to T55x7 tags.
|
||||
|
|
@ -605,7 +648,7 @@ bool detectASK_MAN(){
|
|||
bool stcheck = FALSE;
|
||||
int ans = ASKDemod_ext("0 0 0", FALSE, FALSE, 1, &stcheck);
|
||||
if (!ans) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/Manchester Demod failed");
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: ASK/Manchester Demod failed");
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
|
|
@ -613,11 +656,11 @@ bool detectASK_MAN(){
|
|||
bool detectASK_BI(){
|
||||
int ans = ASKbiphaseDemod("0 0 1", FALSE);
|
||||
if (!ans) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase normal demod failed");
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: ASK/biphase normal demod failed");
|
||||
|
||||
ans = ASKbiphaseDemod("0 1 1", FALSE);
|
||||
if (!ans) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM4305: ASK/biphase inverted demod failed");
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error - EM: ASK/biphase inverted demod failed");
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
|
@ -625,41 +668,136 @@ bool detectASK_BI(){
|
|||
}
|
||||
|
||||
// param: idx - start index in demoded data.
|
||||
int setDemodBufferEM(uint8_t bitsNeeded, size_t idx){
|
||||
if ( bitsNeeded < DemodBufferLen) {
|
||||
setDemodBuf(DemodBuffer + idx + EM_PREAMBLE_LEN, bitsNeeded, 0);
|
||||
CmdPrintDemodBuff("x");
|
||||
return 1;
|
||||
bool setDemodBufferEM(uint32_t *word, size_t idx){
|
||||
|
||||
//test for even parity bits.
|
||||
size_t size = removeParity(DemodBuffer, idx + EM_PREAMBLE_LEN, 9, 0, 44);
|
||||
if (!size) {
|
||||
if (g_debugMode) PrintAndLog("DEBUG: Error -EM Parity not detected");
|
||||
return FALSE;
|
||||
}
|
||||
return -1;
|
||||
|
||||
//todo test last 8 bits for even parity || (xor)
|
||||
setDemodBuf(DemodBuffer, 40, 0);
|
||||
|
||||
*word = bytebits_to_byteLSBF(DemodBuffer, 32);
|
||||
|
||||
uint8_t lo = (uint8_t) bytebits_to_byteLSBF(DemodBuffer , 8);
|
||||
uint8_t lo2 = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 8, 8);
|
||||
uint8_t hi = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 16, 8);
|
||||
uint8_t hi2 = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 24, 8);
|
||||
uint8_t cs = (uint8_t) bytebits_to_byteLSBF(DemodBuffer + 32, 8);
|
||||
uint8_t cs2 = lo ^ lo2 ^ hi ^ hi2;
|
||||
if (g_debugMode) PrintAndLog("EM4x05/4x69 : %08X CS: %02X %s"
|
||||
, *word
|
||||
, cs
|
||||
, (cs2==cs) ? "Passed" : "Failed"
|
||||
);
|
||||
|
||||
return (cs2==cs);
|
||||
}
|
||||
|
||||
// FSK, PSK, ASK/MANCHESTER, ASK/BIPHASE, ASK/DIPHASE
|
||||
// should cover 90% of known used configs
|
||||
// the rest will need to be manually demoded for now...
|
||||
int demodEM4x05resp(uint8_t bitsNeeded) {
|
||||
size_t startIdx = 0;
|
||||
bool demodEM4x05resp(uint32_t *word) {
|
||||
size_t idx = 0;
|
||||
|
||||
if (detectASK_MAN() && doPreambleSearch( &startIdx ))
|
||||
return setDemodBufferEM(bitsNeeded, startIdx);
|
||||
if (detectASK_MAN() && doPreambleSearch( &idx ))
|
||||
return setDemodBufferEM(word, idx);
|
||||
|
||||
if (detectASK_BI() && doPreambleSearch( &startIdx ))
|
||||
return setDemodBufferEM(bitsNeeded, startIdx);
|
||||
if (detectASK_BI() && doPreambleSearch( &idx ))
|
||||
return setDemodBufferEM(word, idx);
|
||||
|
||||
if (detectFSK() && doPreambleSearch( &startIdx ))
|
||||
return setDemodBufferEM(bitsNeeded, startIdx);
|
||||
if (detectFSK() && doPreambleSearch( &idx ))
|
||||
return setDemodBufferEM(word, idx);
|
||||
|
||||
if (detectPSK() && doPreambleSearch( &startIdx ))
|
||||
return setDemodBufferEM(bitsNeeded, startIdx);
|
||||
|
||||
return -1;
|
||||
if (detectPSK()) {
|
||||
if (doPreambleSearch( &idx ))
|
||||
return setDemodBufferEM(word, idx);
|
||||
|
||||
psk1TOpsk2(DemodBuffer, DemodBufferLen);
|
||||
if (doPreambleSearch( &idx ))
|
||||
return setDemodBufferEM(word, idx);
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
int CmdReadWord(const char *Cmd) {
|
||||
//////////////// 4205 / 4305 commands
|
||||
int usage_lf_em4x05_dump(void) {
|
||||
PrintAndLog("Dump EM4x05/EM4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em 4x05dump [h] <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em 4x05dump");
|
||||
PrintAndLog(" lf em 4x05dump 11223344");
|
||||
return 0;
|
||||
}
|
||||
int usage_lf_em4x05_read(void) {
|
||||
PrintAndLog("Read EM4x05/EM4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em 4x05read [h] <address> <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" address - memory address to read. (0-15)");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em 4x05read 1");
|
||||
PrintAndLog(" lf em 4x05read 1 11223344");
|
||||
return 0;
|
||||
}
|
||||
int usage_lf_em4x05_write(void) {
|
||||
PrintAndLog("Write EM4x05/4x69. Tag must be on antenna. ");
|
||||
PrintAndLog("");
|
||||
PrintAndLog("Usage: lf em 4x05write [h] <address> <data> <pwd>");
|
||||
PrintAndLog("Options:");
|
||||
PrintAndLog(" h - this help");
|
||||
PrintAndLog(" address - memory address to write to. (0-15)");
|
||||
PrintAndLog(" data - data to write (hex)");
|
||||
PrintAndLog(" pwd - password (hex) (optional)");
|
||||
PrintAndLog("samples:");
|
||||
PrintAndLog(" lf em 4x05write 1 deadc0de");
|
||||
PrintAndLog(" lf em 4x05write 1 deadc0de 11223344");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdEM4x05Dump(const char *Cmd) {
|
||||
uint8_t addr = 0;
|
||||
uint32_t pwd;
|
||||
bool usePwd = false;
|
||||
uint8_t ctmp = param_getchar(Cmd, 0);
|
||||
if ( ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x05_dump();
|
||||
|
||||
// for now use default input of 1 as invalid (unlikely 1 will be a valid password...)
|
||||
pwd = param_get32ex(Cmd, 0, 1, 16);
|
||||
|
||||
if ( pwd != 1 ) {
|
||||
usePwd = true;
|
||||
}
|
||||
int success = 1;
|
||||
for (; addr < 16; addr++) {
|
||||
if (addr == 2) {
|
||||
if (usePwd) {
|
||||
PrintAndLog("PWD Address %02u | %08X",addr,pwd);
|
||||
} else {
|
||||
PrintAndLog("PWD Address 02 | cannot read");
|
||||
}
|
||||
} else {
|
||||
//success &= EM4x05Read(addr, pwd, usePwd);
|
||||
}
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
int CmdEM4x05Read(const char *Cmd) {
|
||||
int addr, pwd;
|
||||
bool usePwd = false;
|
||||
uint8_t ctmp = param_getchar(Cmd, 0);
|
||||
if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em_read();
|
||||
if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x05_read();
|
||||
|
||||
addr = param_get8ex(Cmd, 0, -1, 10);
|
||||
pwd = param_get32ex(Cmd, 1, -1, 16);
|
||||
|
|
@ -693,18 +831,20 @@ int CmdReadWord(const char *Cmd) {
|
|||
return -1;
|
||||
}
|
||||
|
||||
//attempt demod:
|
||||
//need 32 bits from a read word
|
||||
int result = demodEM4x05resp(44);
|
||||
if (result == -1)
|
||||
//attempt demod
|
||||
uint32_t word = 0;
|
||||
int isOk = demodEM4x05resp(&word);
|
||||
if (isOk)
|
||||
PrintAndLog("Got Address %02d | %08X",addr, word);
|
||||
else
|
||||
PrintAndLog("Read failed");
|
||||
|
||||
return result;
|
||||
return isOk;
|
||||
}
|
||||
|
||||
int CmdWriteWord(const char *Cmd) {
|
||||
int CmdEM4x05Write(const char *Cmd) {
|
||||
uint8_t ctmp = param_getchar(Cmd, 0);
|
||||
if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em_write();
|
||||
if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_em4x05_write();
|
||||
|
||||
bool usePwd = false;
|
||||
int addr = 16; // default to invalid address
|
||||
|
|
@ -732,7 +872,7 @@ int CmdWriteWord(const char *Cmd) {
|
|||
clearCommandBuffer();
|
||||
SendCommand(&c);
|
||||
UsbCommand resp;
|
||||
if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){
|
||||
if (!WaitForResponseTimeout(CMD_ACK, &resp, 2000)){
|
||||
PrintAndLog("Error occurred, device did not respond during write operation.");
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -744,24 +884,28 @@ int CmdWriteWord(const char *Cmd) {
|
|||
|
||||
//attempt demod:
|
||||
//need 0 bits demoded (after preamble) to verify write cmd
|
||||
int result = demodEM4x05resp(0);
|
||||
if (result == 1)
|
||||
uint32_t dummy = 0;
|
||||
int isOk = demodEM4x05resp(&dummy);
|
||||
if (isOk)
|
||||
PrintAndLog("Write Verified");
|
||||
|
||||
return result;
|
||||
return isOk;
|
||||
}
|
||||
|
||||
static command_t CommandTable[] = {
|
||||
{"help", CmdHelp, 1, "This help"},
|
||||
{"em410xdemod", CmdEMdemodASK, 0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},
|
||||
{"em410xread", CmdEM410xRead, 1, "[clock rate] -- Extract ID from EM410x tag in GraphBuffer"},
|
||||
{"em410xsim", CmdEM410xSim, 0, "<UID> -- Simulate EM410x tag"},
|
||||
{"em410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
|
||||
{"em410xspoof", CmdEM410xWatchnSpoof, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
|
||||
{"em410xwrite", CmdEM410xWrite, 0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
|
||||
{"em4x50read", CmdEM4x50Read, 1, "demod data from EM4x50 tag from the graphbuffer"},
|
||||
{"readword", CmdReadWord, 1, "read EM4x05/4x69 data"},
|
||||
{"writeword", CmdWriteWord, 1, "write EM405/4x69 data"},
|
||||
{"410xdemod", CmdEMdemodASK, 0, "[findone] -- Extract ID from EM410x tag (option 0 for continuous loop, 1 for only 1 tag)"},
|
||||
{"410xread", CmdEM410xRead, 1, "[clock rate] -- Extract ID from EM410x tag in GraphBuffer"},
|
||||
{"410xsim", CmdEM410xSim, 0, "<UID> -- Simulate EM410x tag"},
|
||||
{"410xwatch", CmdEM410xWatch, 0, "['h'] -- Watches for EM410x 125/134 kHz tags (option 'h' for 134)"},
|
||||
{"410xspoof", CmdEM410xWatchnSpoof, 0, "['h'] --- Watches for EM410x 125/134 kHz tags, and replays them. (option 'h' for 134)" },
|
||||
{"410xwrite", CmdEM410xWrite, 0, "<UID> <'0' T5555> <'1' T55x7> [clock rate] -- Write EM410x UID to T5555(Q5) or T55x7 tag, optionally setting clock rate"},
|
||||
{"4x05read", CmdEM4x05Read, 0, "read word data from EM4205/4305"},
|
||||
{"4x05write", CmdEM4x05Write, 0, "write word data to EM4205/4305"},
|
||||
{"4x05dump", CmdEM4x05Dump, 0, "dump EM4205/4305 tag"},
|
||||
{"4x50read", CmdEM4x50Read, 0, "read word data from EM4x50"},
|
||||
{"4x50write", CmdEM4x50Write, 0, "write word data to EM4x50"},
|
||||
{"4x50dump", CmdEM4x50Dump, 0, "dump EM4x50 tag"},
|
||||
{NULL, NULL, 0, NULL}
|
||||
};
|
||||
|
||||
|
|
|
|||
114
common/lfdemod.c
114
common/lfdemod.c
|
|
@ -58,7 +58,7 @@ uint8_t parityTest(uint32_t bits, uint8_t bitLen, uint8_t pType)
|
|||
for (uint8_t i = 0; i < bitLen; i++){
|
||||
ans ^= ((bits >> i) & 1);
|
||||
}
|
||||
//prnt("DEBUG: ans: %d, ptype: %d",ans,pType);
|
||||
if (g_debugMode) prnt("DEBUG: ans: %d, ptype: %d, bits: %08X",ans,pType,bits);
|
||||
return (ans == pType);
|
||||
}
|
||||
|
||||
|
|
@ -74,6 +74,8 @@ size_t removeParity(uint8_t *BitStream, size_t startIdx, uint8_t pLen, uint8_t p
|
|||
parityWd = (parityWd << 1) | BitStream[startIdx+word+bit];
|
||||
BitStream[j++] = (BitStream[startIdx+word+bit]);
|
||||
}
|
||||
if (word+pLen >= bLen) break;
|
||||
|
||||
j--; // overwrite parity with next data
|
||||
// if parity fails then return 0
|
||||
switch (pType) {
|
||||
|
|
@ -480,19 +482,42 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
|
|||
size_t preLastSample = 0;
|
||||
size_t LastSample = 0;
|
||||
size_t currSample = 0;
|
||||
// sync to first lo-hi transition, and threshold
|
||||
if ( size < 1024 ) return 0; // not enough samples
|
||||
|
||||
// jump to modulating data by finding the first 4 threshold crossings (or first 2 waves)
|
||||
// in case you have junk or noise at the beginning of the trace...
|
||||
uint8_t thresholdCnt = 0;
|
||||
size_t waveSizeCnt = 0;
|
||||
bool isAboveThreshold = dest[idx++] >= threshold_value;
|
||||
for (; idx < size-20; idx++ ) {
|
||||
if(dest[idx] < threshold_value && isAboveThreshold) {
|
||||
thresholdCnt++;
|
||||
if (thresholdCnt > 2 && waveSizeCnt < fchigh+1) break;
|
||||
isAboveThreshold = false;
|
||||
waveSizeCnt = 0;
|
||||
} else if (dest[idx] >= threshold_value && !isAboveThreshold) {
|
||||
thresholdCnt++;
|
||||
if (thresholdCnt > 2 && waveSizeCnt < fchigh+1) break;
|
||||
isAboveThreshold = true;
|
||||
waveSizeCnt = 0;
|
||||
} else {
|
||||
waveSizeCnt++;
|
||||
}
|
||||
if (thresholdCnt > 10) break;
|
||||
}
|
||||
if (g_debugMode == 2) prnt("threshold Count reached at %u",idx);
|
||||
|
||||
// Need to threshold first sample
|
||||
// skip 160 samples to allow antenna/samples to settle
|
||||
if(dest[160] < threshold_value) dest[0] = 0;
|
||||
if(dest[idx] < threshold_value) dest[0] = 0;
|
||||
else dest[0] = 1;
|
||||
idx++;
|
||||
|
||||
size_t numBits = 0;
|
||||
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
|
||||
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with anywhere
|
||||
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
|
||||
// (could also be fc/5 && fc/7 for fsk1 = 4-9)
|
||||
for(idx = 161; idx < size-20; idx++) {
|
||||
for(; idx < size-20; idx++) {
|
||||
// threshold current value
|
||||
|
||||
if (dest[idx] < threshold_value) dest[idx] = 0;
|
||||
|
|
@ -507,13 +532,14 @@ size_t fsk_wave_demod(uint8_t * dest, size_t size, uint8_t fchigh, uint8_t fclow
|
|||
//do nothing with extra garbage
|
||||
} else if (currSample < (fchigh-1)) { //6-8 = 8 sample waves (or 3-6 = 5)
|
||||
//correct previous 9 wave surrounded by 8 waves (or 6 surrounded by 5)
|
||||
if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1) || preLastSample == 0 )){
|
||||
if (LastSample > (fchigh-2) && (preLastSample < (fchigh-1))){
|
||||
dest[numBits-1]=1;
|
||||
}
|
||||
dest[numBits++]=1;
|
||||
|
||||
} else if (currSample > (fchigh) && !numBits) { //12 + and first bit = unusable garbage
|
||||
//do nothing with beginning garbage
|
||||
} else if (currSample > (fchigh+1) && numBits < 3) { //12 + and first two bit = unusable garbage
|
||||
//do nothing with beginning garbage and reset.. should be rare..
|
||||
numBits = 0;
|
||||
} else if (currSample == (fclow+1) && LastSample == (fclow-1)) { // had a 7 then a 9 should be two 8's (or 4 then a 6 should be two 5's)
|
||||
dest[numBits++]=1;
|
||||
} else { //9+ = 10 sample waves (or 6+ = 7)
|
||||
|
|
@ -1248,36 +1274,32 @@ int DetectNRZClock(uint8_t dest[], size_t size, int clock)
|
|||
// by marshmellow
|
||||
// convert psk1 demod to psk2 demod
|
||||
// only transition waves are 1s
|
||||
void psk1TOpsk2(uint8_t *BitStream, size_t size)
|
||||
{
|
||||
size_t i=1;
|
||||
uint8_t lastBit=BitStream[0];
|
||||
for (; i<size; i++){
|
||||
if (BitStream[i]==7){
|
||||
//ignore errors
|
||||
} else if (lastBit!=BitStream[i]){
|
||||
lastBit=BitStream[i];
|
||||
BitStream[i]=1;
|
||||
void psk1TOpsk2(uint8_t *bits, size_t size) {
|
||||
uint8_t lastBit = bits[0];
|
||||
for (size_t i = 1; i < size; i++){
|
||||
//ignore errors
|
||||
if (bits[i] == 7) continue;
|
||||
|
||||
if (lastBit != bits[i]){
|
||||
lastBit = bits[i];
|
||||
bits[i] = 1;
|
||||
} else {
|
||||
BitStream[i]=0;
|
||||
bits[i] = 0;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// by marshmellow
|
||||
// convert psk2 demod to psk1 demod
|
||||
// from only transition waves are 1s to phase shifts change bit
|
||||
void psk2TOpsk1(uint8_t *BitStream, size_t size)
|
||||
{
|
||||
uint8_t phase=0;
|
||||
for (size_t i=0; i<size; i++){
|
||||
if (BitStream[i]==1){
|
||||
phase ^=1;
|
||||
void psk2TOpsk1(uint8_t *bits, size_t size) {
|
||||
uint8_t phase = 0;
|
||||
for (size_t i = 0; i < size; i++){
|
||||
if (bits[i] == 1){
|
||||
phase ^= 1;
|
||||
}
|
||||
BitStream[i]=phase;
|
||||
bits[i] = phase;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// redesigned by marshmellow adjusted from existing decode functions
|
||||
|
|
@ -1538,7 +1560,7 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
|||
|
||||
size_t numBits=0;
|
||||
uint8_t curPhase = *invert;
|
||||
size_t i, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0;
|
||||
size_t i=0, waveStart=1, waveEnd=0, firstFullWave=0, lastClkBit=0;
|
||||
uint8_t fc=0, fullWaveLen=0, tol=1;
|
||||
uint16_t errCnt=0, waveLenCnt=0;
|
||||
fc = countFC(dest, *size, 0);
|
||||
|
|
@ -1546,19 +1568,45 @@ int pskRawDemod(uint8_t dest[], size_t *size, int *clock, int *invert)
|
|||
//prnt("DEBUG: FC: %d",fc);
|
||||
*clock = DetectPSKClock(dest, *size, *clock);
|
||||
if (*clock == 0) return -1;
|
||||
// jump to modulating data by finding the first 2 threshold crossings (or first 1 waves)
|
||||
// in case you have junk or noise at the beginning of the trace...
|
||||
uint8_t thresholdCnt = 0;
|
||||
size_t waveSizeCnt = 0;
|
||||
uint8_t threshold_value = 123; //-5
|
||||
bool isAboveThreshold = dest[i++] >= threshold_value;
|
||||
for (; i < *size-20; i++ ) {
|
||||
if(dest[i] < threshold_value && isAboveThreshold) {
|
||||
thresholdCnt++;
|
||||
if (thresholdCnt > 2 && waveSizeCnt < fc+1) break;
|
||||
isAboveThreshold = false;
|
||||
waveSizeCnt = 0;
|
||||
} else if (dest[i] >= threshold_value && !isAboveThreshold) {
|
||||
thresholdCnt++;
|
||||
if (thresholdCnt > 2 && waveSizeCnt < fc+1) break;
|
||||
isAboveThreshold = true;
|
||||
waveSizeCnt = 0;
|
||||
} else {
|
||||
waveSizeCnt++;
|
||||
}
|
||||
if (thresholdCnt > 10) break;
|
||||
}
|
||||
if (g_debugMode == 2) prnt("DEBUG PSK: threshold Count reached at %u, count: %u",i, thresholdCnt);
|
||||
|
||||
|
||||
int avgWaveVal=0, lastAvgWaveVal=0;
|
||||
waveStart = i+1;
|
||||
//find first phase shift
|
||||
for (i=0; i<loopCnt; i++){
|
||||
for (; i<loopCnt; i++){
|
||||
if (dest[i]+fc < dest[i+1] && dest[i+1] >= dest[i+2]){
|
||||
waveEnd = i+1;
|
||||
//prnt("DEBUG: waveEnd: %d",waveEnd);
|
||||
if (g_debugMode == 2) prnt("DEBUG PSK: waveEnd: %u, waveStart: %u",waveEnd, waveStart);
|
||||
waveLenCnt = waveEnd-waveStart;
|
||||
if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+2)){ //not first peak and is a large wave but not out of whack
|
||||
if (waveLenCnt > fc && waveStart > fc && !(waveLenCnt > fc+3)){ //not first peak and is a large wave but not out of whack
|
||||
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
|
||||
if (lastAvgWaveVal > threshold_value) curPhase ^= 1; //fudge graph 0 a little 123 vs 128
|
||||
break;
|
||||
}
|
||||
waveStart = i+1;
|
||||
|
|
|
|||
Loading…
Reference in a new issue