// Indala 26 bit decode
// by marshmellow
// optional arguments - same as PSKDemod (clock & invert & maxerr)
int CmdIndalaDemod(const char *Cmd) {
int ans;
if (strlen(Cmd) > 0)
ans = PSKDemod(Cmd, 0);
else //default to RF/32
ans = PSKDemod("32", 0);
if (!ans){
PrintAndLogEx(DEBUG, "DEBUG: Error - Indala can't demod signal: %d",ans);
return 0;
}
uint8_t invert = 0;
size_t size = DemodBufferLen;
int idx = indala64decode(DemodBuffer, &size, &invert);
if (idx < 0 || size != 64) {
// try 224 indala
invert = 0;
size = DemodBufferLen;
idx = indala224decode(DemodBuffer, &size, &invert);
if (idx < 0 || size != 224) {
PrintAndLogEx(DEBUG, "DEBUG: Error - Indala wrong size, expected [64|224] got: %d (startindex %i)", size, idx);
return -1;
}
}
setDemodBuf(DemodBuffer, size, (size_t)idx);
setClockGrid(g_DemodClock, g_DemodStartIdx + (idx * g_DemodClock));
if (invert) {
PrintAndLogEx(DEBUG, "DEBUG: Error - Indala had to invert bits");
for (size_t i = 0; i < size; i++)
DemodBuffer[i] ^= 1;
}
//convert UID to HEX
uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
uid1 = bytebits_to_byte(DemodBuffer,32);
uid2 = bytebits_to_byte(DemodBuffer+32,32);
if (DemodBufferLen == 64){
PrintAndLogEx(SUCCESS, "Indala Found - bitlength %d, UID = (0x%x%08x)\n%s",
DemodBufferLen, uid1, uid2, sprint_bin_break(DemodBuffer,DemodBufferLen,32)
);
} else {
uid3 = bytebits_to_byte(DemodBuffer+64,32);
uid4 = bytebits_to_byte(DemodBuffer+96,32);
uid5 = bytebits_to_byte(DemodBuffer+128,32);
uid6 = bytebits_to_byte(DemodBuffer+160,32);
uid7 = bytebits_to_byte(DemodBuffer+192,32);
PrintAndLogEx(SUCCESS, "Indala Found - bitlength %d, UID = (0x%x%08x%08x%08x%08x%08x%08x)\n%s",
DemodBufferLen,
uid1, uid2, uid3, uid4, uid5, uid6, uid7, sprint_bin_break(DemodBuffer, DemodBufferLen, 32)
);
}
if (g_debugMode){
PrintAndLogEx(DEBUG, "DEBUG: Indala - printing demodbuffer:");
printDemodBuff();
}
return 1;
}
int CmdLFNedapSim(const char *Cmd) {
uint32_t cardnumber = 0, cn = 0;
char cmdp = param_getchar(Cmd, 0);
if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_nedap_sim();
if (sscanf(Cmd, "%u", &cn ) != 1) return usage_lf_nedap_sim();
cardnumber = (cn & 0x00FFFFFF);
uint8_t bs[128];
size_t size = sizeof(bs);
memset(bs, 0x00, size);
// NEDAP, Biphase = 2, clock 64, inverted, (DIPhase == inverted BIphase
uint8_t clk = 64, encoding = 2, separator = 0, invert = 1;
uint16_t arg1, arg2;
arg1 = clk << 8 | encoding;
arg2 = invert << 8 | separator;
if ( !GetNedapBits(cardnumber, bs)) {
PrintAndLogEx(WARNING, "Error with tag bitstream generation.");
return 1;
}
PrintAndLogEx(NORMAL, "bin %s", sprint_bin_break(bs, 128, 32));
PrintAndLogEx(NORMAL, "Simulating Nedap - CardNumber: %u", cardnumber );
UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
memcpy(c.d.asBytes, bs, size);
clearCommandBuffer();
SendCommand(&c);
return 0;
}
char *sprint_bin(const uint8_t *data, const size_t len) {
return sprint_bin_break(data, len, 0);
}
int CmdFdxDemod(const char *Cmd){
//Differential Biphase / di-phase (inverted biphase)
//get binary from ask wave
if (!ASKbiphaseDemod("0 32 1 0", false)) {
if (g_debugMode) PrintAndLog("DEBUG: Error - FDX-B ASKbiphaseDemod failed");
return 0;
}
size_t size = DemodBufferLen;
int preambleIndex = FDXBdemodBI(DemodBuffer, &size);
if (preambleIndex < 0){
if (g_debugMode){
if (preambleIndex == -1)
PrintAndLog("DEBUG: Error - FDX-B too few bits found");
else if (preambleIndex == -2)
PrintAndLog("DEBUG: Error - FDX-B preamble not found");
else if (preambleIndex == -3)
PrintAndLog("DEBUG: Error - FDX-B Size not correct: %d", size);
else
PrintAndLog("DEBUG: Error - FDX-B ans: %d", preambleIndex);
}
return 0;
}
// set and leave DemodBuffer intact
setDemodBuf(DemodBuffer, 128, preambleIndex);
setClockGrid(g_DemodClock, g_DemodStartIdx + (preambleIndex*g_DemodClock));
uint8_t bits_no_spacer[117];
memcpy(bits_no_spacer, DemodBuffer + 11, 117);
// remove marker bits (1's every 9th digit after preamble) (pType = 2)
size = removeParity(bits_no_spacer, 0, 9, 2, 117);
if ( size != 104 ) {
if (g_debugMode) PrintAndLog("DEBUG: Error removeParity:: %d", size);
return 0;
}
//got a good demod
uint64_t NationalCode = ((uint64_t)(bytebits_to_byteLSBF(bits_no_spacer+32,6)) << 32) | bytebits_to_byteLSBF(bits_no_spacer,32);
uint32_t countryCode = bytebits_to_byteLSBF(bits_no_spacer+38,10);
uint8_t dataBlockBit = bits_no_spacer[48];
uint32_t reservedCode = bytebits_to_byteLSBF(bits_no_spacer+49,14);
uint8_t animalBit = bits_no_spacer[63];
uint32_t crc16 = bytebits_to_byteLSBF(bits_no_spacer+64,16);
uint32_t extended = bytebits_to_byteLSBF(bits_no_spacer+80,24);
uint64_t rawid = ((uint64_t)bytebits_to_byte(bits_no_spacer,32)<<32) | bytebits_to_byte(bits_no_spacer+32,32);
uint8_t raw[8];
num_to_bytes(rawid, 8, raw);
if (g_debugMode) {
PrintAndLog("DEBUG: bits_no_spacer:\n%s",sprint_bin_break(bits_no_spacer,size,16));
PrintAndLog("DEBUG: Start marker %d; Size %d", preambleIndex, size);
PrintAndLog("DEBUG: Raw ID Hex: %s", sprint_hex(raw,8));
}
uint16_t calcCrc = crc16_ccitt_kermit(raw, 8);
PrintAndLog("\nFDX-B / ISO 11784/5 Animal Tag ID Found:");
PrintAndLog("Animal ID: %04u-%012" PRIu64, countryCode, NationalCode);
PrintAndLog("National Code: %012" PRIu64, NationalCode);
PrintAndLog("CountryCode: %04u", countryCode);
PrintAndLog("Reserved Code: %u", reservedCode);
PrintAndLog("Animal Tag: %s", animalBit ? "True" : "False");
PrintAndLog("Has Extended: %s [0x%X]", dataBlockBit ? "True" : "False", extended);
PrintAndLog("CRC: 0x%04X - 0x%04X - [%s]\n", crc16, calcCrc, (calcCrc == crc16) ? "Passed" : "Failed");
// set block 0 for later
//g_DemodConfig = T55x7_MODULATION_DIPHASE | T55x7_BITRATE_RF_32 | 4 << T55x7_MAXBLOCK_SHIFT;
return 1;
}
int CmdLFNedapDemod(const char *Cmd) {
//raw ask demod no start bit finding just get binary from wave
if (!ASKbiphaseDemod("0 64 1 0", false)) {
if (g_debugMode) PrintAndLogEx(DEBUG, "DEBUG: Error - Nedap ASKbiphaseDemod failed");
return 0;
}
size_t size = DemodBufferLen;
int idx = detectNedap(DemodBuffer, &size);
if (idx < 0){
if (g_debugMode){
// if (idx == -5)
// PrintAndLogEx(DEBUG, "DEBUG: Error - not enough samples");
// else if (idx == -1)
// PrintAndLogEx(DEBUG, "DEBUG: Error - only noise found");
// else if (idx == -2)
// PrintAndLogEx(DEBUG, "DEBUG: Error - problem during ASK/Biphase demod");
if (idx == -3)
PrintAndLogEx(DEBUG, "DEBUG: Error - Nedap Size not correct: %d", size);
else if (idx == -4)
PrintAndLogEx(DEBUG, "DEBUG: Error - Nedap preamble not found");
else
PrintAndLogEx(DEBUG, "DEBUG: Error - Nedap idx: %d",idx);
}
return 0;
}
/* Index map E E
preamble enc tag type encrypted uid P d 33 d 90 d 04 d 71 d 40 d 45 d E7 P
1111111110 00101101000001011010001100100100001011010100110101100 1 0 00110011 0 10010000 0 00000100 0 01110001 0 01000000 0 01000101 0 11100111 1
uid2 uid1 uid0 I I R R
1111111110 00101101000001011010001100100100001011010100110101100 1
0 00110011
0 10010000
0 00000100
0 01110001
0 01000000
0 01000101
0 11100111
1
Tag ID is 049033
I = Identical on all tags
R = Random ?
UID2, UID1, UID0 == card number
*/
//get raw ID before removing parities
uint32_t raw[4] = {0,0,0,0};
raw[0] = bytebits_to_byte(DemodBuffer+idx+96,32);
raw[1] = bytebits_to_byte(DemodBuffer+idx+64,32);
raw[2] = bytebits_to_byte(DemodBuffer+idx+32,32);
raw[3] = bytebits_to_byte(DemodBuffer+idx,32);
setDemodBuf(DemodBuffer, 128, idx);
setClockGrid(g_DemodClock, g_DemodStartIdx + (idx*g_DemodClock));
uint8_t firstParity = GetParity( DemodBuffer, EVEN, 63);
if ( firstParity != DemodBuffer[63] ) {
PrintAndLogEx(DEBUG, "DEBUG: Error - Nedap 1st 64bit parity check failed: %d|%d ", DemodBuffer[63], firstParity);
return 0;
}
uint8_t secondParity = GetParity( DemodBuffer+64, EVEN, 63);
if ( secondParity != DemodBuffer[127] ) {
PrintAndLogEx(DEBUG, "DEBUG: Error - Nedap 2st 64bit parity check failed: %d|%d ", DemodBuffer[127], secondParity);
return 0;
}
// ok valid card found!
uint32_t uid = 0;
uid = bytebits_to_byte(DemodBuffer+65, 8);
uid |= bytebits_to_byte(DemodBuffer+74, 8) << 8;
uid |= bytebits_to_byte(DemodBuffer+83, 8) << 16;
uint16_t two = 0;
two = bytebits_to_byte(DemodBuffer+92, 8);
two |= bytebits_to_byte(DemodBuffer+101, 8) << 8;
uint16_t chksum2 = 0;
chksum2 = bytebits_to_byte(DemodBuffer+110, 8);
chksum2 |= bytebits_to_byte(DemodBuffer+119, 8) << 8;
PrintAndLogEx(NORMAL, "NEDAP ID Found - Raw: %08x%08x%08x%08x", raw[3], raw[2], raw[1], raw[0]);
PrintAndLogEx(NORMAL, " - UID: %06X", uid);
PrintAndLogEx(NORMAL, " - i: %04X", two);
PrintAndLogEx(NORMAL, " - Checksum2 %04X", chksum2);
if (g_debugMode){
PrintAndLogEx(DEBUG, "DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128);
printDemodBuff();
PrintAndLogEx(NORMAL, "BIN:\n%s", sprint_bin_break( DemodBuffer, 128, 64) );
}
return 1;
}
