//----------------------------------------------------------------------------- // 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 #include #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); }