[proxmark3-svn] / client / cmdlft55xx.c

//-----------------------------------------------------------------------------\r
//\r
// This code is licensed to you under the terms of the GNU GPL, version 2 or,\r
// at your option, any later version. See the LICENSE.txt file for the text of\r
// the license.\r
//-----------------------------------------------------------------------------\r
// Low frequency T55xx commands\r
//-----------------------------------------------------------------------------\r
\r
#include <stdio.h>\r
#include <string.h>\r
#include <inttypes.h>\r
#include "proxmark3.h"\r
#include "ui.h"\r
#include "graph.h"\r
#include "cmdmain.h"\r
#include "cmdparser.h"\r
#include "cmddata.h"\r
#include "cmdlf.h"\r
#include "cmdlft55xx.h"\r
#include "util.h"\r
#include "data.h"\r
#include "lfdemod.h"\r
\r
\r
#define LF_TRACE_BUFF_SIZE 20000 // 32 x 32 x 10  (32 bit times numofblock (7), times clock skip..)\r
#define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend..  8block * 4 bytes * 8bits = \r
static int CmdHelp(const char *Cmd);\r
\r
// int CmdReadBlk(const char *Cmd)\r
// {\r
	// int block = -1;\r
	// sscanf(Cmd, "%d", &block);\r
\r
	// if ((block > 7) | (block < 0)) {\r
		// PrintAndLog("Block must be between 0 and 7");\r
		// return 1;\r
	// }	\r
\r
	// UsbCommand c;\r
	// c.cmd = CMD_T55XX_READ_BLOCK;\r
	// c.d.asBytes[0] = 0x00;\r
	// c.arg[0] = 0;\r
	// c.arg[1] = block;\r
	// c.arg[2] = 0;\r
	// SendCommand(&c);\r
	// WaitForResponse(CMD_ACK, NULL);\r
	\r
	// uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
	\r
	// GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..\r
	// WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
\r
	// for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
		// GraphBuffer[j] = (int)data[j];\r
	// }\r
	// GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
	// ManchesterDemod(block);\r
	// RepaintGraphWindow();\r
  // return 0;\r
// }\r
\r
int CmdReadBlk(const char *Cmd)\r
{\r
	int invert = 0;\r
	int clk = 0;\r
	int block = -1;\r
	uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};\r
\r
	sscanf(Cmd, "%d", &block);\r
	\r
	if ((block > 7) | (block < 0)) {\r
		PrintAndLog("Block must be between 0 and 7");\r
		return 1;\r
	}\r
\r
	UsbCommand c = { CMD_T55XX_READ_BLOCK, { 0, block, 0 } };\r
	SendCommand(&c);\r
	if ( !WaitForResponseTimeout(CMD_ACK,NULL,1500) ) {\r
		PrintAndLog("command execution time out");\r
		return 1;\r
	}\r
	\r
	CmdSamples("");\r
\r
	size_t bitlen = getFromGraphBuf(bits);\r
	\r
	int errCnt = askrawdemod(bits, &bitlen, &clk, &invert);\r
	\r
	//throw away static - allow 1 and -1 (in case of threshold command first)\r
	if ( errCnt == -1 || bitlen < 16 ){  \r
		PrintAndLog("no data found");\r
		if (g_debugMode) \r
			PrintAndLog("errCnt: %d, bitlen: %d, clk: %d, invert: %d", errCnt, bitlen, clk, invert);\r
		return 0;\r
	}\r
	if (g_debugMode) \r
		PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, bitlen);\r
\r
	//move bits back to DemodBuffer\r
	setDemodBuf(bits, bitlen, 0);\r
	printBitStream(bits,bitlen);\r
	return 0;\r
}\r
\r
int CmdReadBlkPWD(const char *Cmd)\r
{\r
	int Block = -1; //default to invalid block\r
	int Password = 0xFFFFFFFF; //default to blank Block 7\r
\r
\r
	sscanf(Cmd, "%d %x", &Block, &Password);\r
\r
	if ((Block > 7) | (Block < 0)) {\r
		PrintAndLog("Block must be between 0 and 7");\r
		return 1;\r
	}	\r
\r
	PrintAndLog("Reading page 0 block %d pwd %08X", Block, Password);\r
\r
	UsbCommand c = {CMD_T55XX_READ_BLOCK, {0, Block, Password} };\r
	c.d.asBytes[0] = 0x1; //Password mode\r
	SendCommand(&c);\r
	WaitForResponse(CMD_ACK, NULL);\r
		\r
	uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
\r
	GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);\r
	WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
\r
	for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
		GraphBuffer[j] = ((int)data[j]);\r
	}\r
	GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
	ManchesterDemod(Block);	\r
\r
	RepaintGraphWindow();\r
  return 0;\r
}\r
\r
int CmdWriteBlk(const char *Cmd)\r
{\r
  int Block = 8; //default to invalid block\r
  int Data = 0xFFFFFFFF; //default to blank Block \r
\r
	sscanf(Cmd, "%d %x", &Block, &Data);\r
\r
  if (Block > 7) {\r
  	PrintAndLog("Block must be between 0 and 7");\r
  	return 1;\r
  }	\r
\r
	PrintAndLog("Writing block %d  data %08X", Block, Data);\r
\r
	UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {Data, Block, 0}};\r
  c.d.asBytes[0] = 0x0; //Normal mode\r
  SendCommand(&c);\r
  return 0;\r
}\r
\r
int CmdWriteBlkPWD(const char *Cmd)\r
{\r
  int Block = 8; //default to invalid block\r
  int Data = 0xFFFFFFFF; //default to blank Block \r
  int Password = 0xFFFFFFFF; //default to blank Block 7\r
\r
\r
	sscanf(Cmd, "%d %x %x",&Block, &Data, &Password);\r
\r
  if (Block > 7) {\r
  	PrintAndLog("Block must be between 0 and 7");\r
  	return 1;\r
  }	\r
\r
	PrintAndLog("Writing block %d  data %08X  password %08X", Block, Data, Password);\r
\r
	UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {Data, Block, Password}};\r
  c.d.asBytes[0] = 0x1; //Password mode\r
  SendCommand(&c);\r
  return 0;\r
}\r
\r
int CmdReadTrace(const char *Cmd)\r
{\r
	char cmdp = param_getchar(Cmd, 0);\r
\r
	if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r
		PrintAndLog("Usage:  lf t55xx trace  [use data from Graphbuffer]");\r
		PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");\r
		PrintAndLog("");\r
		PrintAndLog("     sample: lf t55xx trace");\r
		PrintAndLog("           : lf t55xx trace 1");\r
		return 0;\r
	}\r
\r
	if ( strlen(Cmd)==0){\r
	\r
		UsbCommand c = {CMD_T55XX_READ_TRACE, {0, 0, 0}};\r
		SendCommand(&c);\r
		WaitForResponse(CMD_ACK, NULL);\r
\r
		uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
\r
		GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);  //3560 -- should be offset..\r
		WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
\r
		for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
			GraphBuffer[j] = ((int)data[j]);\r
		}\r
		GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
	}\r
	\r
	uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
	uint8_t * bitstream = bits;\r
	\r
	manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);\r
	RepaintGraphWindow();\r
\r
	uint8_t si = 5;\r
	uint32_t bl0     = PackBits(si, 32, bitstream);\r
	uint32_t bl1     = PackBits(si+32, 32, bitstream);\r
	\r
	uint32_t acl     = PackBits(si,  8, bitstream); si += 8;\r
	uint32_t mfc     = PackBits(si, 8, bitstream); si += 8;\r
	uint32_t cid     = PackBits(si, 5, bitstream); si += 5;\r
	uint32_t icr     = PackBits(si, 3, bitstream); si += 3;\r
	uint32_t year    = PackBits(si, 4, bitstream); si += 4;\r
	uint32_t quarter = PackBits(si, 2, bitstream); si += 2;\r
	uint32_t lotid    = PackBits(si, 12, bitstream); si += 12;\r
	uint32_t wafer   = PackBits(si, 5, bitstream); si += 5;\r
	uint32_t dw      = PackBits(si, 15, bitstream); \r
	\r
	PrintAndLog("");\r
	PrintAndLog("-- T55xx Trace Information ----------------------------------");\r
	PrintAndLog("-------------------------------------------------------------");\r
	PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1)  : 0x%02X (%d)", acl, acl);\r
	PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6)    : 0x%02X (%d)", mfc, mfc);\r
	PrintAndLog(" CID                                     : 0x%02X (%d)", cid, cid);\r
	PrintAndLog(" ICR IC Revision                         : %d",icr );\r
	PrintAndLog(" Manufactured");\r
	PrintAndLog("     Year/Quarter : %d/%d",2000+year, quarter );\r
	PrintAndLog("     Lot ID       : %d", lotid );\r
	PrintAndLog("     Wafer number : %d", wafer);\r
	PrintAndLog("     Die Number   : %d", dw);\r
	PrintAndLog("-------------------------------------------------------------");\r
	PrintAndLog(" Raw Data - Page 1");\r
	PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(bitstream+5,32) );\r
	PrintAndLog("     Block 0  : 0x%08X  %s", bl1, sprint_bin(bitstream+37,32) );\r
	PrintAndLog("-------------------------------------------------------------");\r
	/*\r
	TRACE - BLOCK O\r
		Bits	Definition								HEX\r
		1-8		ACL Allocation class (ISO/IEC 15963-1)	0xE0 \r
		9-16	MFC Manufacturer ID (ISO/IEC 7816-6)	0x15 Atmel Corporation\r
		17-21	CID										0x1 = Atmel ATA5577M1  0x2 = Atmel ATA5577M2 \r
		22-24	ICR IC revision\r
		25-28	YEAR (BCD encoded) 						9 (= 2009)\r
		29-30	QUARTER									1,2,3,4 \r
		31-32	LOT ID\r
	\r
	TRACE - BLOCK 1\r
		1-12	LOT ID  \r
		13-17	Wafer number\r
		18-32	DW,  die number sequential\r
	*/\r
	\r
  return 0;\r
}\r
\r
int CmdInfo(const char *Cmd){\r
	/*\r
		Page 0 Block 0 Configuration data.\r
		Normal mode\r
		Extended mode\r
	*/\r
	char cmdp = param_getchar(Cmd, 0);\r
\r
	if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r
		PrintAndLog("Usage:  lf t55xx info  [use data from Graphbuffer]");\r
		PrintAndLog("     [use data from Graphbuffer], if not set, try reading data from tag.");\r
		PrintAndLog("");\r
		PrintAndLog("    sample: lf t55xx info");\r
		PrintAndLog("    sample: lf t55xx info 1");\r
		return 0;\r
	}\r
\r
	if ( strlen(Cmd) == 0 ){\r
		CmdReadBlk("0");\r
	}	\r
\r
	uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
\r
	manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);\r
	\r
	uint8_t si = 5;\r
	uint32_t bl0      = PackBits(si, 32, bits);\r
	\r
	uint32_t safer    = PackBits(si, 4, bits); si += 4;	\r
	uint32_t resv     = PackBits(si, 7, bits); si += 7;\r
	uint32_t dbr      = PackBits(si, 3, bits); si += 3;\r
	uint32_t extend   = PackBits(si, 1, bits); si += 1;\r
	uint32_t datamodulation   = PackBits(si, 5, bits); si += 5;\r
	uint32_t pskcf    = PackBits(si, 2, bits); si += 2;\r
	uint32_t aor      = PackBits(si, 1, bits); si += 1;	\r
	uint32_t otp      = PackBits(si, 1, bits); si += 1;	\r
	uint32_t maxblk   = PackBits(si, 3, bits); si += 3;\r
	uint32_t pwd      = PackBits(si, 1, bits); si += 1;	\r
	uint32_t sst      = PackBits(si, 1, bits); si += 1;	\r
	uint32_t fw       = PackBits(si, 1, bits); si += 1;\r
	uint32_t inv      = PackBits(si, 1, bits); si += 1;	\r
	uint32_t por      = PackBits(si, 1, bits); si += 1;\r
		\r
	PrintAndLog("");\r
	PrintAndLog("-- T55xx Configuration & Tag Information --------------------");\r
	PrintAndLog("-------------------------------------------------------------");\r
	PrintAndLog(" Safer key                 : %s", GetSaferStr(safer));\r
	PrintAndLog(" reserved                  : %d", resv);\r
	PrintAndLog(" Data bit rate             : %s", GetBitRateStr(dbr));\r
	PrintAndLog(" eXtended mode             : %s", (extend) ? "Yes - Warning":"No");\r
	PrintAndLog(" Modulation                : %s", GetModulationStr(datamodulation) );\r
	PrintAndLog(" PSK clock freq            : %d", pskcf);\r
	PrintAndLog(" AOR - Answer on Request   : %s", (aor) ? "Yes":"No");\r
	PrintAndLog(" OTP - One Time Pad        : %s", (otp) ? "Yes - Warning":"No" );\r
	PrintAndLog(" Max block                 : %d", maxblk);\r
	PrintAndLog(" Password mode             : %s", (pwd) ? "Yes":"No");\r
	PrintAndLog(" Sequence Start Terminator : %s", (sst) ? "Yes":"No");\r
	PrintAndLog(" Fast Write                : %s", (fw) ? "Yes":"No");\r
	PrintAndLog(" Inverse data              : %s", (inv) ? "Yes":"No");\r
	PrintAndLog(" POR-Delay                 : %s", (por) ? "Yes":"No");\r
	PrintAndLog("-------------------------------------------------------------");\r
	PrintAndLog(" Raw Data - Page 0");\r
	PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(bits+5,32) );\r
	PrintAndLog("-------------------------------------------------------------");\r
	\r
	return 0;\r
}\r
\r
int CmdDump(const char *Cmd){\r
\r
	char cmdp = param_getchar(Cmd, 0);\r
	char s[20];\r
	uint8_t pwd[4] = {0x00};\r
	bool hasPwd = ( strlen(Cmd) > 0);\r
	\r
	if ( cmdp == 'h' || cmdp == 'H') {\r
		PrintAndLog("Usage:  lf t55xx dump <password>");\r
		PrintAndLog("        sample: lf t55xx dump FFFFFFFF");\r
		return 0;\r
	}\r
	\r
	if ( hasPwd ){\r
		if (param_gethex(Cmd, 0, pwd, 8)) {\r
			PrintAndLog("password must include 8 HEX symbols");\r
			return 1;\r
		}\r
	}\r
	\r
	for ( int i = 0; i <8; ++i){\r
		memset(s,0,sizeof(s));\r
		if ( hasPwd ) {\r
			sprintf(s,"%d %02x%02x%02x%02x", i, pwd[0],pwd[1],pwd[2],pwd[3]);\r
			CmdReadBlkPWD(s);\r
		} else {\r
			sprintf(s,"%d", i);\r
			CmdReadBlk(s);\r
		}\r
	}\r
	return 0;\r
}\r
\r
int CmdIceFsk(const char *Cmd){\r
\r
	if (!HasGraphData()) return 0;\r
\r
	iceFsk3(GraphBuffer, LF_TRACE_BUFF_SIZE);\r
	RepaintGraphWindow();\r
	return 0;\r
}\r
int CmdIceManchester(const char *Cmd){\r
	ManchesterDemod( -1);\r
	return 0;\r
}\r
int ManchesterDemod(int blockNum){\r
\r
	if (!HasGraphData()) return 0;\r
		\r
	uint8_t sizebyte = 32;\r
	// the value 5 was selected during empirical studies of the decoded data. Some signal noise to skip.\r
	uint8_t offset = 5;\r
	uint32_t blockData;\r
	uint8_t  bits[LF_BITSSTREAM_LEN] = {0x00};\r
	uint8_t * bitstream = bits;\r
	\r
	//manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);	\r
	manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);	\r
    //blockData = PackBits(offset, sizebyte, bitstream);\r
	blockData = PackBits(offset, sizebyte, bits);\r
\r
	if ( blockNum < 0)\r
		PrintAndLog(" Decoded     : 0x%08X  %s", blockData, sprint_bin(bitstream+offset,sizebyte) );\r
		else\r
		PrintAndLog(" Block %d    : 0x%08X  %s", blockNum, blockData, sprint_bin(bitstream+offset,sizebyte) );\r
	\r
	return 0;\r
} \r
\r
char * GetBitRateStr(uint32_t id){\r
 	static char buf[40];\r
	char *retStr = buf;\r
		switch (id){\r
		case 0: \r
			sprintf(retStr,"%d - RF/8",id);\r
			break;\r
		case 1:\r
			sprintf(retStr,"%d - RF/16",id);\r
			break;\r
		case 2:		\r
			sprintf(retStr,"%d - RF/32",id);\r
			break;\r
		case 3:\r
			sprintf(retStr,"%d - RF/40",id);\r
			break;\r
		case 4:\r
			sprintf(retStr,"%d - RF/50",id);\r
			break;\r
		case 5:\r
			sprintf(retStr,"%d - RF/64",id);\r
			break;\r
		case 6:\r
			sprintf(retStr,"%d - RF/100",id);\r
			break;\r
		case 7:\r
			sprintf(retStr,"%d - RF/128",id);\r
			break;\r
		default:\r
			sprintf(retStr,"%d - (Unknown)",id);\r
			break;\r
		}\r
\r
	return buf;\r
}\r
\r
char * GetSaferStr(uint32_t id){\r
 	static char buf[40];\r
	char *retStr = buf;\r
	\r
	sprintf(retStr,"%d",id);\r
	if (id == 6) {\r
		sprintf(retStr,"%d - pasdwd",id);\r
	}\r
	if (id == 9 ){\r
		sprintf(retStr,"%d - testmode ",id);\r
	}\r
	\r
	return buf;\r
}\r
char * GetModulationStr( uint32_t id){\r
 	static char buf[40];\r
	char *retStr = buf;\r
	\r
	switch (id){\r
		case 0: \r
			sprintf(retStr,"%d - DIRECT (ASK/NRZ)",id);\r
			break;\r
		case 1:\r
			sprintf(retStr,"%d - PSK 1 phase change when input changes",id);\r
			break;\r
		case 2:		\r
			sprintf(retStr,"%d - PSK 2 phase change on bitclk if input high",id);\r
			break;\r
		case 3:\r
			sprintf(retStr,"%d - PSK 3 phase change on rising edge of input",id);\r
			break;\r
		case 4:\r
			sprintf(retStr,"%d - FSK 1 RF/8  RF/5",id);\r
			break;\r
		case 5:\r
			sprintf(retStr,"%d - FSK 2 RF/8  RF/10",id);\r
			break;\r
		case 6:\r
			sprintf(retStr,"%d - FSK 1a RF/5  RF/8",id);\r
			break;\r
		case 7:\r
			sprintf(retStr,"%d - FSK 2a RF/10  RF/8",id);\r
			break;\r
		case 8:\r
			sprintf(retStr,"%d - Manschester",id);\r
			break;\r
		case 16:\r
			sprintf(retStr,"%d - Biphase",id);\r
			break;\r
		case 17:\r
			sprintf(retStr,"%d - Reserved",id);\r
			break;\r
		default:\r
			sprintf(retStr,"0x%02X (Unknown)",id);\r
			break;\r
		}\r
	return buf;\r
}\r
\r
\r
uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bits){\r
	\r
	int i = start;\r
	int j = len-1;\r
	if (len > 32) {\r
		return 0;\r
	}\r
 	uint32_t tmp = 0;\r
	for (; j >= 0; --j, ++i){\r
		tmp	|= bits[i] << j;\r
	}\r
	return tmp;\r
}\r
\r
static command_t CommandTable[] =\r
{\r
  {"help",   CmdHelp,        1, "This help"},\r
  {"rd",     CmdReadBlk,     0, "<block> -- Read T55xx block data (page 0)"},\r
  {"rdpwd",  CmdReadBlkPWD,  0, "<block> <password> -- Read T55xx block data with password mode"},\r
  {"wr",     CmdWriteBlk,    0, "<block> <data> -- Write T55xx block data (page 0)"},\r
  {"wrpwd",  CmdWriteBlkPWD, 0, "<block> <password> <data> -- Write T55xx block data with password"},\r
  {"trace",  CmdReadTrace,   0, "[1] Read T55xx traceability data (page 1/ blk 0-1)"},\r
  {"info",   CmdInfo,        0, "[1] Read T55xx configuration data (page 0/ blk 0)"},\r
  {"dump",   CmdDump,        0, "[password] Dump T55xx card block 0-7. optional with password"},\r
  {"fsk",    CmdIceFsk,      0, "FSK demod"},\r
  {"man",    CmdIceManchester,      0, "Manchester demod (with SST)"},\r
  {NULL, NULL, 0, NULL}\r
};\r
\r
int CmdLFT55XX(const char *Cmd)\r
{\r
  CmdsParse(CommandTable, Cmd);\r
  return 0;\r
}\r
\r
int CmdHelp(const char *Cmd)\r
{\r
  CmdsHelp(CommandTable);\r
  return 0;\r
}\r
Commit	Line	Data
54a942b0	1	//-----------------------------------------------------------------------------\r
	2	//\r
	3	// This code is licensed to you under the terms of the GNU GPL, version 2 or,\r
	4	// at your option, any later version. See the LICENSE.txt file for the text of\r
	5	// the license.\r
	6	//-----------------------------------------------------------------------------\r
	7	// Low frequency T55xx commands\r
	8	//-----------------------------------------------------------------------------\r
	9	\r
	10	#include <stdio.h>\r
	11	#include <string.h>\r
	12	#include <inttypes.h>\r
54a942b0	13	#include "proxmark3.h"\r
	14	#include "ui.h"\r
	15	#include "graph.h"\r
f38a1528	16	#include "cmdmain.h"\r
54a942b0	17	#include "cmdparser.h"\r
	18	#include "cmddata.h"\r
	19	#include "cmdlf.h"\r
	20	#include "cmdlft55xx.h"\r
f38a1528	21	#include "util.h"\r
f38a1528	22	#include "data.h"\r
c4e3b1b6	23	#include "lfdemod.h"\r
54a942b0	24	\r
f6c18637	25	\r
8d0a3e87	26	#define LF_TRACE_BUFF_SIZE 20000 // 32 x 32 x 10 (32 bit times numofblock (7), times clock skip..)\r
c6be64da	27	#define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend.. 8block * 4 bytes * 8bits = \r
54a942b0	28	static int CmdHelp(const char *Cmd);\r
54a942b0	29	\r
c4e3b1b6	30	// int CmdReadBlk(const char *Cmd)\r
	31	// {\r
	32	// int block = -1;\r
	33	// sscanf(Cmd, "%d", &block);\r
	34	\r
	35	// if ((block > 7) \| (block < 0)) {\r
	36	// PrintAndLog("Block must be between 0 and 7");\r
	37	// return 1;\r
	38	// } \r
	39	\r
	40	// UsbCommand c;\r
	41	// c.cmd = CMD_T55XX_READ_BLOCK;\r
	42	// c.d.asBytes[0] = 0x00;\r
	43	// c.arg[0] = 0;\r
	44	// c.arg[1] = block;\r
	45	// c.arg[2] = 0;\r
	46	// SendCommand(&c);\r
	47	// WaitForResponse(CMD_ACK, NULL);\r
	48	\r
	49	// uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
	50	\r
	51	// GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..\r
	52	// WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
	53	\r
	54	// for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
	55	// GraphBuffer[j] = (int)data[j];\r
	56	// }\r
	57	// GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
	58	// ManchesterDemod(block);\r
	59	// RepaintGraphWindow();\r
	60	// return 0;\r
	61	// }\r
	62	\r
54a942b0	63	int CmdReadBlk(const char *Cmd)\r
54a942b0	64	{\r
c4e3b1b6	65	int invert = 0;\r
c4e3b1b6	66	int clk = 0;\r
c6be64da	67	int block = -1;\r
c4e3b1b6	68	uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};\r
54a942b0	69	\r
c4e3b1b6	70	sscanf(Cmd, "%d", &block);\r
c4e3b1b6	71	\r
c6be64da	72	if ((block > 7) \| (block < 0)) {\r
b44e5233	73	PrintAndLog("Block must be between 0 and 7");\r
b44e5233	74	return 1;\r
c4e3b1b6	75	}\r
54a942b0	76	\r
c4e3b1b6	77	UsbCommand c = { CMD_T55XX_READ_BLOCK, { 0, block, 0 } };\r
b44e5233	78	SendCommand(&c);\r
c4e3b1b6	79	if ( !WaitForResponseTimeout(CMD_ACK,NULL,1500) ) {\r
	80	PrintAndLog("command execution time out");\r
	81	return 1;\r
	82	}\r
f38a1528	83	\r
c4e3b1b6	84	CmdSamples("");\r
a501c82b	85	\r
c4e3b1b6	86	size_t bitlen = getFromGraphBuf(bits);\r
	87	\r
	88	int errCnt = askrawdemod(bits, &bitlen, &clk, &invert);\r
	89	\r
	90	//throw away static - allow 1 and -1 (in case of threshold command first)\r
	91	if ( errCnt == -1 \|\| bitlen < 16 ){ \r
	92	PrintAndLog("no data found");\r
	93	if (g_debugMode) \r
	94	PrintAndLog("errCnt: %d, bitlen: %d, clk: %d, invert: %d", errCnt, bitlen, clk, invert);\r
	95	return 0;\r
a501c82b	96	}\r
c4e3b1b6	97	if (g_debugMode) \r
	98	PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d", clk, invert, bitlen);\r
	99	\r
	100	//move bits back to DemodBuffer\r
	101	setDemodBuf(bits, bitlen, 0);\r
	102	printBitStream(bits,bitlen);\r
	103	return 0;\r
54a942b0	104	}\r
	105	\r
	106	int CmdReadBlkPWD(const char *Cmd)\r
	107	{\r
f38a1528	108	int Block = -1; //default to invalid block\r
b44e5233	109	int Password = 0xFFFFFFFF; //default to blank Block 7\r
c4e3b1b6	110	\r
54a942b0	111	\r
b44e5233	112	sscanf(Cmd, "%d %x", &Block, &Password);\r
54a942b0	113	\r
f38a1528	114	if ((Block > 7) \| (Block < 0)) {\r
b44e5233	115	PrintAndLog("Block must be between 0 and 7");\r
	116	return 1;\r
	117	} \r
54a942b0	118	\r
f38a1528	119	PrintAndLog("Reading page 0 block %d pwd %08X", Block, Password);\r
54a942b0	120	\r
c4e3b1b6	121	UsbCommand c = {CMD_T55XX_READ_BLOCK, {0, Block, Password} };\r
b44e5233	122	c.d.asBytes[0] = 0x1; //Password mode\r
b44e5233	123	SendCommand(&c);\r
f38a1528	124	WaitForResponse(CMD_ACK, NULL);\r
f38a1528	125	\r
f6c18637	126	uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
f38a1528	127	\r
c4e3b1b6	128	GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0);\r
f38a1528	129	WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
	130	\r
	131	for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
081151ea	132	GraphBuffer[j] = ((int)data[j]);\r
f38a1528	133	}\r
f38a1528	134	GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
c2d25819	135	ManchesterDemod(Block); \r
c4e3b1b6	136	\r
f6c18637	137	RepaintGraphWindow();\r
54a942b0	138	return 0;\r
	139	}\r
	140	\r
	141	int CmdWriteBlk(const char *Cmd)\r
	142	{\r
	143	int Block = 8; //default to invalid block\r
	144	int Data = 0xFFFFFFFF; //default to blank Block \r
54a942b0	145	\r
c4e3b1b6	146	sscanf(Cmd, "%d %x", &Block, &Data);\r
54a942b0	147	\r
	148	if (Block > 7) {\r
	149	PrintAndLog("Block must be between 0 and 7");\r
	150	return 1;\r
	151	} \r
	152	\r
c4e3b1b6	153	PrintAndLog("Writing block %d data %08X", Block, Data);\r
54a942b0	154	\r
c4e3b1b6	155	UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {Data, Block, 0}};\r
54a942b0	156	c.d.asBytes[0] = 0x0; //Normal mode\r
54a942b0	157	SendCommand(&c);\r
	158	return 0;\r
	159	}\r
	160	\r
	161	int CmdWriteBlkPWD(const char *Cmd)\r
	162	{\r
	163	int Block = 8; //default to invalid block\r
	164	int Data = 0xFFFFFFFF; //default to blank Block \r
	165	int Password = 0xFFFFFFFF; //default to blank Block 7\r
54a942b0	166	\r
c4e3b1b6	167	\r
c4e3b1b6	168	sscanf(Cmd, "%d %x %x",&Block, &Data, &Password);\r
54a942b0	169	\r
	170	if (Block > 7) {\r
	171	PrintAndLog("Block must be between 0 and 7");\r
	172	return 1;\r
	173	} \r
	174	\r
c4e3b1b6	175	PrintAndLog("Writing block %d data %08X password %08X", Block, Data, Password);\r
54a942b0	176	\r
c4e3b1b6	177	UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {Data, Block, Password}};\r
54a942b0	178	c.d.asBytes[0] = 0x1; //Password mode\r
54a942b0	179	SendCommand(&c);\r
	180	return 0;\r
	181	}\r
	182	\r
	183	int CmdReadTrace(const char *Cmd)\r
	184	{\r
fbceacc5	185	char cmdp = param_getchar(Cmd, 0);\r
f38a1528	186	\r
fbceacc5	187	if (strlen(Cmd) > 1 \|\| cmdp == 'h' \|\| cmdp == 'H') {\r
	188	PrintAndLog("Usage: lf t55xx trace [use data from Graphbuffer]");\r
	189	PrintAndLog(" [use data from Graphbuffer], if not set, try reading data from tag.");\r
	190	PrintAndLog("");\r
081151ea	191	PrintAndLog(" sample: lf t55xx trace");\r
c4e3b1b6	192	PrintAndLog(" : lf t55xx trace 1");\r
fbceacc5	193	return 0;\r
fbceacc5	194	}\r
f38a1528	195	\r
fbceacc5	196	if ( strlen(Cmd)==0){\r
c4e3b1b6	197	\r
fbceacc5	198	UsbCommand c = {CMD_T55XX_READ_TRACE, {0, 0, 0}};\r
	199	SendCommand(&c);\r
	200	WaitForResponse(CMD_ACK, NULL);\r
f38a1528	201	\r
fbceacc5	202	uint8_t data[LF_TRACE_BUFF_SIZE] = {0x00};\r
fbceacc5	203	\r
8d0a3e87	204	GetFromBigBuf(data,LF_TRACE_BUFF_SIZE,0); //3560 -- should be offset..\r
fbceacc5	205	WaitForResponseTimeout(CMD_ACK,NULL, 1500);\r
	206	\r
	207	for (int j = 0; j < LF_TRACE_BUFF_SIZE; j++) {\r
	208	GraphBuffer[j] = ((int)data[j]);\r
	209	}\r
	210	GraphTraceLen = LF_TRACE_BUFF_SIZE;\r
f38a1528	211	}\r
f38a1528	212	\r
c6be64da	213	uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
f6c18637	214	uint8_t * bitstream = bits;\r
f38a1528	215	\r
c6be64da	216	manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN);\r
f6c18637	217	RepaintGraphWindow();\r
b44e5233	218	\r
f6c18637	219	uint8_t si = 5;\r
	220	uint32_t bl0 = PackBits(si, 32, bitstream);\r
	221	uint32_t bl1 = PackBits(si+32, 32, bitstream);\r
	222	\r
77376577	223	uint32_t acl = PackBits(si, 8, bitstream); si += 8;\r
	224	uint32_t mfc = PackBits(si, 8, bitstream); si += 8;\r
	225	uint32_t cid = PackBits(si, 5, bitstream); si += 5;\r
	226	uint32_t icr = PackBits(si, 3, bitstream); si += 3;\r
	227	uint32_t year = PackBits(si, 4, bitstream); si += 4;\r
	228	uint32_t quarter = PackBits(si, 2, bitstream); si += 2;\r
	229	uint32_t lotid = PackBits(si, 12, bitstream); si += 12;\r
	230	uint32_t wafer = PackBits(si, 5, bitstream); si += 5;\r
	231	uint32_t dw = PackBits(si, 15, bitstream); \r
f6c18637	232	\r
	233	PrintAndLog("");\r
	234	PrintAndLog("-- T55xx Trace Information ----------------------------------");\r
	235	PrintAndLog("-------------------------------------------------------------");\r
	236	PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1) : 0x%02X (%d)", acl, acl);\r
	237	PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6) : 0x%02X (%d)", mfc, mfc);\r
	238	PrintAndLog(" CID : 0x%02X (%d)", cid, cid);\r
	239	PrintAndLog(" ICR IC Revision : %d",icr );\r
	240	PrintAndLog(" Manufactured");\r
	241	PrintAndLog(" Year/Quarter : %d/%d",2000+year, quarter );\r
77376577	242	PrintAndLog(" Lot ID : %d", lotid );\r
f6c18637	243	PrintAndLog(" Wafer number : %d", wafer);\r
	244	PrintAndLog(" Die Number : %d", dw);\r
	245	PrintAndLog("-------------------------------------------------------------");\r
77376577	246	PrintAndLog(" Raw Data - Page 1");\r
	247	PrintAndLog(" Block 0 : 0x%08X %s", bl0, sprint_bin(bitstream+5,32) );\r
	248	PrintAndLog(" Block 0 : 0x%08X %s", bl1, sprint_bin(bitstream+37,32) );\r
f6c18637	249	PrintAndLog("-------------------------------------------------------------");\r
	250	/*\r
	251	TRACE - BLOCK O\r
	252	Bits Definition HEX\r
	253	1-8 ACL Allocation class (ISO/IEC 15963-1) 0xE0 \r
	254	9-16 MFC Manufacturer ID (ISO/IEC 7816-6) 0x15 Atmel Corporation\r
	255	17-21 CID 0x1 = Atmel ATA5577M1 0x2 = Atmel ATA5577M2 \r
	256	22-24 ICR IC revision\r
	257	25-28 YEAR (BCD encoded) 9 (= 2009)\r
	258	29-30 QUARTER 1,2,3,4 \r
77376577	259	31-32 LOT ID\r
f6c18637	260	\r
f6c18637	261	TRACE - BLOCK 1\r
77376577	262	1-12 LOT ID \r
f6c18637	263	13-17 Wafer number\r
	264	18-32 DW, die number sequential\r
	265	*/\r
	266	\r
	267	return 0;\r
	268	}\r
f38a1528	269	\r
f6c18637	270	int CmdInfo(const char *Cmd){\r
	271	/*\r
	272	Page 0 Block 0 Configuration data.\r
	273	Normal mode\r
	274	Extended mode\r
	275	*/\r
fbceacc5	276	char cmdp = param_getchar(Cmd, 0);\r
	277	\r
	278	if (strlen(Cmd) > 1 \|\| cmdp == 'h' \|\| cmdp == 'H') {\r
	279	PrintAndLog("Usage: lf t55xx info [use data from Graphbuffer]");\r
	280	PrintAndLog(" [use data from Graphbuffer], if not set, try reading data from tag.");\r
	281	PrintAndLog("");\r
081151ea	282	PrintAndLog(" sample: lf t55xx info");\r
081151ea	283	PrintAndLog(" sample: lf t55xx info 1");\r
fbceacc5	284	return 0;\r
	285	}\r
	286	\r
8d0a3e87	287	if ( strlen(Cmd) == 0 ){\r
fbceacc5	288	CmdReadBlk("0");\r
081151ea	289	} \r
fbceacc5	290	\r
c6be64da	291	uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
8d0a3e87	292	\r
8d0a3e87	293	manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN);\r
f6c18637	294	\r
f6c18637	295	uint8_t si = 5;\r
8d0a3e87	296	uint32_t bl0 = PackBits(si, 32, bits);\r
f6c18637	297	\r
8d0a3e87	298	uint32_t safer = PackBits(si, 4, bits); si += 4; \r
	299	uint32_t resv = PackBits(si, 7, bits); si += 7;\r
	300	uint32_t dbr = PackBits(si, 3, bits); si += 3;\r
	301	uint32_t extend = PackBits(si, 1, bits); si += 1;\r
	302	uint32_t datamodulation = PackBits(si, 5, bits); si += 5;\r
	303	uint32_t pskcf = PackBits(si, 2, bits); si += 2;\r
	304	uint32_t aor = PackBits(si, 1, bits); si += 1; \r
	305	uint32_t otp = PackBits(si, 1, bits); si += 1; \r
	306	uint32_t maxblk = PackBits(si, 3, bits); si += 3;\r
	307	uint32_t pwd = PackBits(si, 1, bits); si += 1; \r
	308	uint32_t sst = PackBits(si, 1, bits); si += 1; \r
	309	uint32_t fw = PackBits(si, 1, bits); si += 1;\r
	310	uint32_t inv = PackBits(si, 1, bits); si += 1; \r
	311	uint32_t por = PackBits(si, 1, bits); si += 1;\r
b44e5233	312	\r
f6c18637	313	PrintAndLog("");\r
99a71418	314	PrintAndLog("-- T55xx Configuration & Tag Information --------------------");\r
f6c18637	315	PrintAndLog("-------------------------------------------------------------");\r
	316	PrintAndLog(" Safer key : %s", GetSaferStr(safer));\r
	317	PrintAndLog(" reserved : %d", resv);\r
	318	PrintAndLog(" Data bit rate : %s", GetBitRateStr(dbr));\r
	319	PrintAndLog(" eXtended mode : %s", (extend) ? "Yes - Warning":"No");\r
	320	PrintAndLog(" Modulation : %s", GetModulationStr(datamodulation) );\r
	321	PrintAndLog(" PSK clock freq : %d", pskcf);\r
	322	PrintAndLog(" AOR - Answer on Request : %s", (aor) ? "Yes":"No");\r
	323	PrintAndLog(" OTP - One Time Pad : %s", (otp) ? "Yes - Warning":"No" );\r
	324	PrintAndLog(" Max block : %d", maxblk);\r
	325	PrintAndLog(" Password mode : %s", (pwd) ? "Yes":"No");\r
	326	PrintAndLog(" Sequence Start Terminator : %s", (sst) ? "Yes":"No");\r
	327	PrintAndLog(" Fast Write : %s", (fw) ? "Yes":"No");\r
	328	PrintAndLog(" Inverse data : %s", (inv) ? "Yes":"No");\r
	329	PrintAndLog(" POR-Delay : %s", (por) ? "Yes":"No");\r
	330	PrintAndLog("-------------------------------------------------------------");\r
77376577	331	PrintAndLog(" Raw Data - Page 0");\r
8d0a3e87	332	PrintAndLog(" Block 0 : 0x%08X %s", bl0, sprint_bin(bits+5,32) );\r
f6c18637	333	PrintAndLog("-------------------------------------------------------------");\r
	334	\r
	335	return 0;\r
	336	}\r
	337	\r
77376577	338	int CmdDump(const char *Cmd){\r
	339	\r
	340	char cmdp = param_getchar(Cmd, 0);\r
	341	char s[20];\r
	342	uint8_t pwd[4] = {0x00};\r
149aeada	343	bool hasPwd = ( strlen(Cmd) > 0);\r
	344	\r
	345	if ( cmdp == 'h' \|\| cmdp == 'H') {\r
77376577	346	PrintAndLog("Usage: lf t55xx dump <password>");\r
	347	PrintAndLog(" sample: lf t55xx dump FFFFFFFF");\r
	348	return 0;\r
	349	}\r
77376577	350	\r
77376577	351	if ( hasPwd ){\r
2ae8a312	352	if (param_gethex(Cmd, 0, pwd, 8)) {\r
2ae8a312	353	PrintAndLog("password must include 8 HEX symbols");\r
c4e3b1b6	354	return 1;\r
77376577	355	}\r
77376577	356	}\r
a501c82b	357	\r
77376577	358	for ( int i = 0; i <8; ++i){\r
149aeada	359	memset(s,0,sizeof(s));\r
77376577	360	if ( hasPwd ) {\r
c6be64da	361	sprintf(s,"%d %02x%02x%02x%02x", i, pwd[0],pwd[1],pwd[2],pwd[3]);\r
77376577	362	CmdReadBlkPWD(s);\r
	363	} else {\r
	364	sprintf(s,"%d", i);\r
	365	CmdReadBlk(s);\r
	366	}\r
	367	}\r
	368	return 0;\r
	369	}\r
	370	\r
7bd30f12	371	int CmdIceFsk(const char *Cmd){\r
c6be64da	372	\r
	373	if (!HasGraphData()) return 0;\r
	374	\r
7bd30f12	375	iceFsk3(GraphBuffer, LF_TRACE_BUFF_SIZE);\r
7bd30f12	376	RepaintGraphWindow();\r
	377	return 0;\r
	378	}\r
fbceacc5	379	int CmdIceManchester(const char *Cmd){\r
72e930ef	380	ManchesterDemod( -1);\r
	381	return 0;\r
	382	}\r
c6be64da	383	int ManchesterDemod(int blockNum){\r
fbceacc5	384	\r
c6be64da	385	if (!HasGraphData()) return 0;\r
c6be64da	386	\r
081151ea	387	uint8_t sizebyte = 32;\r
a501c82b	388	// the value 5 was selected during empirical studies of the decoded data. Some signal noise to skip.\r
081151ea	389	uint8_t offset = 5;\r
fbceacc5	390	uint32_t blockData;\r
c6be64da	391	uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};\r
fbceacc5	392	uint8_t * bitstream = bits;\r
fbceacc5	393	\r
8d0a3e87	394	//manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bitstream, LF_BITSSTREAM_LEN); \r
	395	manchester_decode(GraphBuffer, LF_TRACE_BUFF_SIZE, bits, LF_BITSSTREAM_LEN); \r
	396	//blockData = PackBits(offset, sizebyte, bitstream);\r
	397	blockData = PackBits(offset, sizebyte, bits);\r
72e930ef	398	\r
081151ea	399	if ( blockNum < 0)\r
	400	PrintAndLog(" Decoded : 0x%08X %s", blockData, sprint_bin(bitstream+offset,sizebyte) );\r
	401	else\r
	402	PrintAndLog(" Block %d : 0x%08X %s", blockNum, blockData, sprint_bin(bitstream+offset,sizebyte) );\r
	403	\r
fbceacc5	404	return 0;\r
fbceacc5	405	} \r
7bd30f12	406	\r
f6c18637	407	char * GetBitRateStr(uint32_t id){\r
	408	static char buf[40];\r
	409	char *retStr = buf;\r
	410	switch (id){\r
	411	case 0: \r
	412	sprintf(retStr,"%d - RF/8",id);\r
	413	break;\r
	414	case 1:\r
	415	sprintf(retStr,"%d - RF/16",id);\r
	416	break;\r
	417	case 2: \r
	418	sprintf(retStr,"%d - RF/32",id);\r
	419	break;\r
	420	case 3:\r
	421	sprintf(retStr,"%d - RF/40",id);\r
	422	break;\r
	423	case 4:\r
	424	sprintf(retStr,"%d - RF/50",id);\r
	425	break;\r
	426	case 5:\r
	427	sprintf(retStr,"%d - RF/64",id);\r
	428	break;\r
	429	case 6:\r
	430	sprintf(retStr,"%d - RF/100",id);\r
	431	break;\r
	432	case 7:\r
	433	sprintf(retStr,"%d - RF/128",id);\r
	434	break;\r
	435	default:\r
	436	sprintf(retStr,"%d - (Unknown)",id);\r
	437	break;\r
	438	}\r
	439	\r
	440	return buf;\r
	441	}\r
	442	\r
f6c18637	443	char * GetSaferStr(uint32_t id){\r
	444	static char buf[40];\r
	445	char *retStr = buf;\r
	446	\r
	447	sprintf(retStr,"%d",id);\r
	448	if (id == 6) {\r
	449	sprintf(retStr,"%d - pasdwd",id);\r
	450	}\r
	451	if (id == 9 ){\r
	452	sprintf(retStr,"%d - testmode ",id);\r
	453	}\r
	454	\r
	455	return buf;\r
	456	}\r
	457	char * GetModulationStr( uint32_t id){\r
	458	static char buf[40];\r
	459	char *retStr = buf;\r
	460	\r
	461	switch (id){\r
	462	case 0: \r
7bd30f12	463	sprintf(retStr,"%d - DIRECT (ASK/NRZ)",id);\r
f6c18637	464	break;\r
	465	case 1:\r
	466	sprintf(retStr,"%d - PSK 1 phase change when input changes",id);\r
	467	break;\r
	468	case 2: \r
	469	sprintf(retStr,"%d - PSK 2 phase change on bitclk if input high",id);\r
	470	break;\r
	471	case 3:\r
	472	sprintf(retStr,"%d - PSK 3 phase change on rising edge of input",id);\r
	473	break;\r
	474	case 4:\r
	475	sprintf(retStr,"%d - FSK 1 RF/8 RF/5",id);\r
	476	break;\r
	477	case 5:\r
	478	sprintf(retStr,"%d - FSK 2 RF/8 RF/10",id);\r
	479	break;\r
	480	case 6:\r
	481	sprintf(retStr,"%d - FSK 1a RF/5 RF/8",id);\r
	482	break;\r
	483	case 7:\r
	484	sprintf(retStr,"%d - FSK 2a RF/10 RF/8",id);\r
	485	break;\r
	486	case 8:\r
	487	sprintf(retStr,"%d - Manschester",id);\r
	488	break;\r
	489	case 16:\r
	490	sprintf(retStr,"%d - Biphase",id);\r
	491	break;\r
	492	case 17:\r
	493	sprintf(retStr,"%d - Reserved",id);\r
	494	break;\r
	495	default:\r
	496	sprintf(retStr,"0x%02X (Unknown)",id);\r
	497	break;\r
	498	}\r
	499	return buf;\r
	500	}\r
	501	\r
	502	\r
	503	uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bits){\r
	504	\r
	505	int i = start;\r
	506	int j = len-1;\r
3bc3598e	507	if (len > 32) {\r
	508	return 0;\r
	509	}\r
f6c18637	510	uint32_t tmp = 0;\r
	511	for (; j >= 0; --j, ++i){\r
	512	tmp \|= bits[i] << j;\r
	513	}\r
	514	return tmp;\r
54a942b0	515	}\r
	516	\r
	517	static command_t CommandTable[] =\r
	518	{\r
b44e5233	519	{"help", CmdHelp, 1, "This help"},\r
7bd30f12	520	{"rd", CmdReadBlk, 0, "<block> -- Read T55xx block data (page 0)"},\r
c2d25819	521	{"rdpwd", CmdReadBlkPWD, 0, "<block> <password> -- Read T55xx block data with password mode"},\r
c4e3b1b6	522	{"wr", CmdWriteBlk, 0, "<block> <data> -- Write T55xx block data (page 0)"},\r
c4e3b1b6	523	{"wrpwd", CmdWriteBlkPWD, 0, "<block> <password> <data> -- Write T55xx block data with password"},\r
a61b4976	524	{"trace", CmdReadTrace, 0, "[1] Read T55xx traceability data (page 1/ blk 0-1)"},\r
a61b4976	525	{"info", CmdInfo, 0, "[1] Read T55xx configuration data (page 0/ blk 0)"},\r
7bd30f12	526	{"dump", CmdDump, 0, "[password] Dump T55xx card block 0-7. optional with password"},\r
7bd30f12	527	{"fsk", CmdIceFsk, 0, "FSK demod"},\r
72e930ef	528	{"man", CmdIceManchester, 0, "Manchester demod (with SST)"},\r
54a942b0	529	{NULL, NULL, 0, NULL}\r
	530	};\r
	531	\r
	532	int CmdLFT55XX(const char *Cmd)\r
	533	{\r
	534	CmdsParse(CommandTable, Cmd);\r
	535	return 0;\r
	536	}\r
	537	\r
	538	int CmdHelp(const char *Cmd)\r
	539	{\r
	540	CmdsHelp(CommandTable);\r
	541	return 0;\r
	542	}\r