mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2024-09-23 08:46:13 +08:00
218 lines
7.3 KiB
C
218 lines
7.3 KiB
C
//-----------------------------------------------------------------------------
|
|
// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// See LICENSE.txt for the text of the license.
|
|
//-----------------------------------------------------------------------------
|
|
// Low frequency COTAG commands
|
|
//-----------------------------------------------------------------------------
|
|
#include "cmdlfcotag.h" // COTAG function declarations
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include "cmdparser.h" // command_t
|
|
#include "comms.h"
|
|
#include "lfdemod.h"
|
|
#include "cmddata.h" // getSamples
|
|
#include "ui.h" // PrintAndLog
|
|
#include "ctype.h" // tolower
|
|
#include "cliparser.h"
|
|
#include "commonutil.h" // reflect32
|
|
|
|
static int CmdHelp(const char *Cmd);
|
|
|
|
// COTAG demod should be able to use g_GraphBuffer,
|
|
// when data load samples
|
|
int demodCOTAG(bool verbose) {
|
|
(void) verbose; // unused so far
|
|
|
|
uint8_t bits[COTAG_BITS] = {0};
|
|
size_t bitlen = COTAG_BITS;
|
|
memcpy(bits, g_DemodBuffer, COTAG_BITS);
|
|
|
|
uint8_t inv_bits[COTAG_BITS] = {0};
|
|
memcpy(inv_bits, g_DemodBuffer, COTAG_BITS);
|
|
|
|
uint8_t alignPos = 0;
|
|
uint16_t err = manrawdecode(bits, &bitlen, 1, &alignPos);
|
|
if (err > 50) {
|
|
PrintAndLogEx(DEBUG, "DEBUG: Error - COTAG too many errors: %d", err);
|
|
return PM3_ESOFT;
|
|
}
|
|
|
|
setDemodBuff(bits, bitlen, 0);
|
|
|
|
//got a good demod
|
|
uint16_t cn = bytebits_to_byteLSBF(bits + 1, 16);
|
|
uint32_t fc = bytebits_to_byteLSBF(bits + 1 + 16, 8);
|
|
|
|
uint32_t raw1 = bytebits_to_byteLSBF(bits, 32);
|
|
uint32_t raw2 = bytebits_to_byteLSBF(bits + 32, 32);
|
|
uint32_t raw3 = bytebits_to_byteLSBF(bits + 64, 32);
|
|
uint32_t raw4 = bytebits_to_byteLSBF(bits + 96, 32);
|
|
|
|
|
|
/*
|
|
fc 161: 1010 0001 -> LSB 1000 0101
|
|
cn 33593 1000 0011 0011 1001 -> LSB 1001 1100 1100 0001
|
|
cccc cccc cccc cccc ffffffff
|
|
0 1001 1100 1100 0001 1000 0101 0000 0000 100001010000000001111011100000011010000010000000000000000000000000000000000000000000000000000000100111001100000110000101000
|
|
1001 1100 1100 0001 10000101
|
|
|
|
COTAG FC/272
|
|
1 7 7 D E 2 0 0 8 0 0 0 3 9 2 0 D 0 4 0000000000000
|
|
0001 0111 0111 1101 1110 0010 0000 0000 1000 0000 0000 0000 0011 1001 0010 0000 1101 0000 0100 0000000000000000000000000000000000000000000000000000000
|
|
0001 0111 0111 1101 1110 001 0010 1001 0011 1000 0110 0100
|
|
|
|
*/
|
|
PrintAndLogEx(SUCCESS, "COTAG Found: FC " _GREEN_("%u")", CN: " _GREEN_("%u")" Raw: %08X%08X%08X%08X", fc, cn, raw1, raw2, raw3, raw4);
|
|
|
|
bitlen = COTAG_BITS;
|
|
err = manrawdecode(inv_bits, &bitlen, 0, &alignPos);
|
|
if (err < 50) {
|
|
uint32_t cn_large = bytebits_to_byte(inv_bits + 1, 23);
|
|
cn_large = reflect32(cn_large) >> 9;
|
|
uint8_t a = bytebits_to_byte(inv_bits + 48, 4);
|
|
uint8_t b = bytebits_to_byte(inv_bits + 52, 4);
|
|
uint8_t c = bytebits_to_byte(inv_bits + 56, 4);
|
|
uint16_t fc_large = NIBBLE_LOW(c) << 8 | NIBBLE_LOW(b) << 4 | NIBBLE_LOW(a);
|
|
|
|
raw1 = bytebits_to_byte(inv_bits, 32);
|
|
raw2 = bytebits_to_byte(inv_bits + 32, 32);
|
|
raw3 = bytebits_to_byte(inv_bits + 64, 32);
|
|
raw4 = bytebits_to_byte(inv_bits + 96, 32);
|
|
PrintAndLogEx(SUCCESS, " FC " _GREEN_("%u")", CN: " _GREEN_("%u")" Raw: %08X%08X%08X%08X", fc_large, cn_large, raw1, raw2, raw3, raw4);
|
|
}
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static int CmdCOTAGDemod(const char *Cmd) {
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf cotag demod",
|
|
"Try to find COTAG preamble, if found decode / descramble data",
|
|
"lf cotag demod"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("v", "verbose", "verbose output"),
|
|
arg_param_end
|
|
};
|
|
CLIExecWithReturn(ctx, Cmd, argtable, true);
|
|
bool verbose = arg_get_lit(ctx, 1);
|
|
CLIParserFree(ctx);
|
|
return demodCOTAG(verbose);
|
|
}
|
|
|
|
// When reading a COTAG.
|
|
// 0 = HIGH/LOW signal - maxlength bigbuff
|
|
// 1 = translation for HI/LO into bytes with manchester 0,1 - length 300
|
|
// 2 = raw signal - maxlength bigbuff
|
|
static int CmdCOTAGReader(const char *Cmd) {
|
|
|
|
CLIParserContext *ctx;
|
|
CLIParserInit(&ctx, "lf cotag reader",
|
|
"read a COTAG tag, the current support for COTAG is limited. ",
|
|
"lf cotag reader -2"
|
|
);
|
|
|
|
void *argtable[] = {
|
|
arg_param_begin,
|
|
arg_lit0("1", NULL, "HIGH/LOW signal; maxlength bigbuff"),
|
|
arg_lit0("2", NULL, "translation of HIGH/LOW into bytes with manchester 0,1"),
|
|
arg_lit0("3", NULL, "raw signal; maxlength bigbuff"),
|
|
arg_param_end
|
|
};
|
|
|
|
CLIExecWithReturn(ctx, Cmd, argtable, false);
|
|
bool mode0 = arg_get_lit(ctx, 1);
|
|
bool mode1 = arg_get_lit(ctx, 2);
|
|
bool mode2 = arg_get_lit(ctx, 3);
|
|
CLIParserFree(ctx);
|
|
|
|
if ((mode0 + mode1 + mode2) > 1) {
|
|
PrintAndLogEx(ERR, "You can only use one option at a time");
|
|
return PM3_EINVARG;
|
|
}
|
|
uint8_t mode = 0xFF;
|
|
if (mode0)
|
|
mode = 0;
|
|
if (mode1)
|
|
mode = 1;
|
|
if (mode2)
|
|
mode = 2;
|
|
|
|
struct p {
|
|
uint8_t mode;
|
|
} PACKED payload;
|
|
payload.mode = mode;
|
|
|
|
PacketResponseNG resp;
|
|
clearCommandBuffer();
|
|
SendCommandNG(CMD_LF_COTAG_READ, (uint8_t *)&payload, sizeof(payload));
|
|
|
|
uint8_t timeout = 3;
|
|
int res = PM3_SUCCESS;
|
|
while (!WaitForResponseTimeout(CMD_LF_COTAG_READ, &resp, 1000)) {
|
|
timeout--;
|
|
if (timeout == 0) {
|
|
PrintAndLogEx(NORMAL, "");
|
|
PrintAndLogEx(WARNING, "command execution time out");
|
|
SendCommandNG(CMD_BREAK_LOOP, NULL, 0);
|
|
res = PM3_ETIMEOUT;
|
|
}
|
|
}
|
|
|
|
if (res != PM3_SUCCESS) {
|
|
return res;
|
|
}
|
|
|
|
if (timeout != 3)
|
|
PrintAndLogEx(NORMAL, "");
|
|
|
|
switch (payload.mode) {
|
|
case 0:
|
|
case 2: {
|
|
CmdPlot("");
|
|
CmdGrid("-x 384");
|
|
getSamples(0, false);
|
|
break;
|
|
}
|
|
case 1: {
|
|
memcpy(g_DemodBuffer, resp.data.asBytes, resp.length);
|
|
g_DemodBufferLen = resp.length;
|
|
return demodCOTAG(true);
|
|
}
|
|
}
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
static command_t CommandTable[] = {
|
|
{"help", CmdHelp, AlwaysAvailable, "This help"},
|
|
{"demod", CmdCOTAGDemod, AlwaysAvailable, "demodulate an COTAG tag"},
|
|
{"reader", CmdCOTAGReader, IfPm3Lf, "attempt to read and extract tag data"},
|
|
{NULL, NULL, NULL, NULL}
|
|
};
|
|
static int CmdHelp(const char *Cmd) {
|
|
(void)Cmd; // Cmd is not used so far
|
|
CmdsHelp(CommandTable);
|
|
return PM3_SUCCESS;
|
|
}
|
|
|
|
int CmdLFCOTAG(const char *Cmd) {
|
|
clearCommandBuffer();
|
|
return CmdsParse(CommandTable, Cmd);
|
|
}
|
|
|
|
int readCOTAGUid(void) {
|
|
return (CmdCOTAGReader("-2") == PM3_SUCCESS);
|
|
}
|