[proxmark3-svn] / client / cmdlfjablotron.c

//-----------------------------------------------------------------------------
//
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Low frequency Presco tag commands
//-----------------------------------------------------------------------------
#include <math.h>
#include "cmdlfjablotron.h"

static int CmdHelp(const char *Cmd);

int usage_lf_jablotron_clone(void){
	PrintAndLog("clone a Jablotron tag to a T55x7 tag.");
	PrintAndLog("Usage: lf jablotron clone [h] <card ID> <Q5>");
	PrintAndLog("Options:");
	PrintAndLog("      h          : This help");
	PrintAndLog("      <card ID>  : jablotron card ID");
	PrintAndLog("      <Q5>       : specify write to Q5 (t5555 instead of t55x7)");
	PrintAndLog("");
	PrintAndLog("Sample: lf jablotron clone 112233");
	return 0;
}

int usage_lf_jablotron_sim(void) {
	PrintAndLog("Enables simulation of jablotron card with specified card number.");
	PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
	PrintAndLog("");
	PrintAndLog("Usage:  lf jablotron sim [h] <card ID>");
	PrintAndLog("Options:");
	PrintAndLog("      h          : This help");
	PrintAndLog("      <card ID>  : jablotron card ID");
	PrintAndLog("");
	PrintAndLog("Sample: lf jablotron sim 112233");
	return 0;
}

static uint8_t jablontron_chksum(uint8_t *bits){
	uint8_t chksum = 0;
	for (int i=16; i < 56; i += 8) {
		chksum += bytebits_to_byte(bits+i,8);
	}
	chksum ^= 0x3A;	
	return chksum;
}

int getJablotronBits(uint64_t fullcode, uint8_t *bits) {	
	//preamp
	num_to_bytebits(0xFFFF, 16, bits);

	//fullcode
	num_to_bytebits(fullcode, 40, bits+16);

	//chksum byte
	uint8_t chksum = jablontron_chksum(bits);
	num_to_bytebits(chksum, 8, bits+56);
	return 1;
}

static uint64_t getJablontronCardId( uint64_t rawcode ){
	uint64_t id = 0;
	uint8_t bytes[] = {0,0,0,0,0};
	num_to_bytes(rawcode, 5, bytes);
	for ( int i = 4, j = 0; i > -1;  --i, j += 2 ) {
		id += NIBBLE_LOW( bytes[i] ) * (int)pow(10,j);
		id += NIBBLE_HIGH( bytes[i] ) * (int)pow(10,j+1);
	}
	return id;
}

//see ASKDemod for what args are accepted
int CmdJablotronDemod(const char *Cmd) {

	//Differential Biphase / di-phase (inverted biphase)
	//get binary from ask wave
	if (!ASKbiphaseDemod("0 64 1 0", FALSE)) {
		if (g_debugMode) PrintAndLog("Error Jablotron: ASKbiphaseDemod failed");
		return 0;
	}
	size_t size = DemodBufferLen;
	int ans = JablotronDemod(DemodBuffer, &size);
	if (ans < 0){
		if (g_debugMode){
			// if (ans == -5)
				// PrintAndLog("DEBUG: Error - not enough samples");
			if (ans == -1)
				PrintAndLog("DEBUG: Error - Jablotron too few bits found");
			// else if (ans == -2)
				// PrintAndLog("DEBUG: Error - problem during ASK/Biphase demod");
			else if (ans == -3)
				PrintAndLog("DEBUG: Error - Jablotron Size not correct: %d", size);
			else if (ans == -4)
				PrintAndLog("DEBUG: Error - Jablotron preamble not found");
			else if (ans == -5)
				PrintAndLog("DEBUG: Error - Jablotron checksum failed");
			else
				PrintAndLog("DEBUG: Error - ans: %d", ans);
		}
		return 0;
	}

	setDemodBuf(DemodBuffer+ans, 64, 0);
	
	//got a good demod
	uint32_t raw1 = bytebits_to_byte(DemodBuffer, 32);
	uint32_t raw2 = bytebits_to_byte(DemodBuffer+32, 32);

	uint64_t rawid = bytebits_to_byte(DemodBuffer+16, 40);
	uint64_t id = getJablontronCardId(rawid);

	PrintAndLog("Jablotron Tag Found: Card ID %u", id);
	PrintAndLog("Raw: %08X%08X", raw1 ,raw2);

	uint8_t chksum = raw2 & 0xFF;
	PrintAndLog("Checksum: %02X [%s]",
		chksum,
		(chksum == jablontron_chksum(DemodBuffer)) ? "OK":"FAIL"		
	);

	id = DEC2BCD(id);
	// Printed format: 1410-nn-nnnn-nnnn	
	PrintAndLog("Printed: 1410-%02X-%04X-%04X",
		(uint8_t)(id >> 32) & 0xFF,
		(uint16_t)(id >> 16) & 0xFFFF,
		(uint16_t)id & 0xFFFF
	);
	return 1;
}

int CmdJablotronRead(const char *Cmd) {
	CmdLFRead("s");
	getSamples("30000",false);
	return CmdJablotronDemod(Cmd);
}

int CmdJablotronClone(const char *Cmd) {

	uint64_t fullcode = 0;
	uint32_t blocks[3] = {T55x7_MODULATION_DIPHASE | T55x7_BITRATE_RF_64 | 2<<T55x7_MAXBLOCK_SHIFT, 0, 0};

	uint8_t bits[64];
	uint8_t *bs = bits;
	memset(bs, 0, sizeof(bits));
	
	char cmdp = param_getchar(Cmd, 0);
	if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_jablotron_clone();

	fullcode = param_get64ex(Cmd, 0, 0, 16);
	
	//Q5
	if (param_getchar(Cmd, 1) == 'Q' || param_getchar(Cmd, 1) == 'q') {
		//t5555 (Q5) BITRATE = (RF-2)/2 (iceman)
		blocks[0] = T5555_MODULATION_BIPHASE | T5555_INVERT_OUTPUT | 64<<T5555_BITRATE_SHIFT | 2<<T5555_MAXBLOCK_SHIFT;
	}
	
	// clearing the topbit needed for the preambl detection. 
	if ((fullcode & 0x7FFFFFFFFF) != fullcode) {
		fullcode &= 0x7FFFFFFFFF;
		PrintAndLog("Card Number Truncated to 39bits: %"PRIx64, fullcode);
	}
	
	if ( !getJablotronBits(fullcode, bs)) {
		PrintAndLog("Error with tag bitstream generation.");
		return 1;
	}	
	
	// 
	blocks[1] = bytebits_to_byte(bs,32);
	blocks[2] = bytebits_to_byte(bs+32,32);

	PrintAndLog("Preparing to clone Jablotron to T55x7 with FullCode: %"PRIx64, fullcode);
	PrintAndLog("Blk | Data ");
	PrintAndLog("----+------------");
	PrintAndLog(" 00 | 0x%08x", blocks[0]);
	PrintAndLog(" 01 | 0x%08x", blocks[1]);
	PrintAndLog(" 02 | 0x%08x", blocks[2]);
	
	UsbCommand resp;
	UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}};

	for (int i=4; i>=0; i--) {
		c.arg[0] = blocks[i];
		c.arg[1] = i;
		clearCommandBuffer();
		SendCommand(&c);
		if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){
			PrintAndLog("Error occurred, device did not respond during write operation.");
			return -1;
		}
	}
    return 0;
}

int CmdJablotronSim(const char *Cmd) {
	uint64_t fullcode = 0;

	char cmdp = param_getchar(Cmd, 0);
	if (strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_jablotron_sim();

	fullcode = param_get64ex(Cmd, 0, 0, 16);

	// clearing the topbit needed for the preambl detection. 
	if ((fullcode & 0x7FFFFFFFFF) != fullcode) {
		fullcode &= 0x7FFFFFFFFF;
		PrintAndLog("Card Number Truncated to 39bits: %"PRIx64, fullcode);
	}
	
	uint8_t clk = 64, encoding = 2, separator = 0, invert = 1;
	uint16_t arg1, arg2;
	size_t size = 64;
	arg1 = clk << 8 | encoding;
	arg2 = invert << 8 | separator;

	PrintAndLog("Simulating Jablotron - FullCode: %"PRIx64, fullcode);

	UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
	getJablotronBits(fullcode, c.d.asBytes);
	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}

static command_t CommandTable[] = {
    {"help",	CmdHelp,			1, "This help"},
	{"read",	CmdJablotronRead,	0, "Attempt to read and extract tag data"},
	{"clone",	CmdJablotronClone,	0, "clone jablotron tag"},
	{"sim",		CmdJablotronSim,	0, "simulate jablotron tag"},
    {NULL, NULL, 0, NULL}
};

int CmdLFJablotron(const char *Cmd) {
	clearCommandBuffer();
    CmdsParse(CommandTable, Cmd);
    return 0;
}

int CmdHelp(const char *Cmd) {
    CmdsHelp(CommandTable);
    return 0;
}
Commit	Line	Data
6c283951	1	//-----------------------------------------------------------------------------
	2	//
	3	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	4	// at your option, any later version. See the LICENSE.txt file for the text of
	5	// the license.
	6	//-----------------------------------------------------------------------------
	7	// Low frequency Presco tag commands
	8	//-----------------------------------------------------------------------------
dc6c90c3	9	#include <math.h>
6c283951	10	#include "cmdlfjablotron.h"
	11
	12	static int CmdHelp(const char *Cmd);
	13
	14	int usage_lf_jablotron_clone(void){
	15	PrintAndLog("clone a Jablotron tag to a T55x7 tag.");
8ae9b358	16	PrintAndLog("Usage: lf jablotron clone [h] <card ID> <Q5>");
	17	PrintAndLog("Options:");
	18	PrintAndLog(" h : This help");
	19	PrintAndLog(" <card ID> : jablotron card ID");
	20	PrintAndLog(" <Q5> : specify write to Q5 (t5555 instead of t55x7)");
6c283951	21	PrintAndLog("");
514ddaa2	22	PrintAndLog("Sample: lf jablotron clone 112233");
6c283951	23	return 0;
	24	}
	25
	26	int usage_lf_jablotron_sim(void) {
	27	PrintAndLog("Enables simulation of jablotron card with specified card number.");
	28	PrintAndLog("Simulation runs until the button is pressed or another USB command is issued.");
6c283951	29	PrintAndLog("");
8ae9b358	30	PrintAndLog("Usage: lf jablotron sim [h] <card ID>");
	31	PrintAndLog("Options:");
	32	PrintAndLog(" h : This help");
	33	PrintAndLog(" <card ID> : jablotron card ID");
6c283951	34	PrintAndLog("");
514ddaa2	35	PrintAndLog("Sample: lf jablotron sim 112233");
6c283951	36	return 0;
	37	}
	38
29ce214c	39	static uint8_t jablontron_chksum(uint8_t *bits){
	40	uint8_t chksum = 0;
	41	for (int i=16; i < 56; i += 8) {
	42	chksum += bytebits_to_byte(bits+i,8);
	43	}
	44	chksum ^= 0x3A;
	45	return chksum;
	46	}
	47
6c283951	48	int getJablotronBits(uint64_t fullcode, uint8_t *bits) {
	49	//preamp
	50	num_to_bytebits(0xFFFF, 16, bits);
	51
	52	//fullcode
	53	num_to_bytebits(fullcode, 40, bits+16);
	54
	55	//chksum byte
29ce214c	56	uint8_t chksum = jablontron_chksum(bits);
29ce214c	57	num_to_bytebits(chksum, 8, bits+56);
6c283951	58	return 1;
	59	}
	60
dc6c90c3	61	static uint64_t getJablontronCardId( uint64_t rawcode ){
	62	uint64_t id = 0;
	63	uint8_t bytes[] = {0,0,0,0,0};
	64	num_to_bytes(rawcode, 5, bytes);
	65	for ( int i = 4, j = 0; i > -1; --i, j += 2 ) {
	66	id += NIBBLE_LOW( bytes[i] ) * (int)pow(10,j);
	67	id += NIBBLE_HIGH( bytes[i] ) * (int)pow(10,j+1);
	68	}
	69	return id;
	70	}
	71
6c283951	72	//see ASKDemod for what args are accepted
	73	int CmdJablotronDemod(const char *Cmd) {
	74
	75	//Differential Biphase / di-phase (inverted biphase)
	76	//get binary from ask wave
	77	if (!ASKbiphaseDemod("0 64 1 0", FALSE)) {
	78	if (g_debugMode) PrintAndLog("Error Jablotron: ASKbiphaseDemod failed");
	79	return 0;
	80	}
	81	size_t size = DemodBufferLen;
	82	int ans = JablotronDemod(DemodBuffer, &size);
	83	if (ans < 0){
	84	if (g_debugMode){
	85	// if (ans == -5)
	86	// PrintAndLog("DEBUG: Error - not enough samples");
29ce214c	87	if (ans == -1)
29ce214c	88	PrintAndLog("DEBUG: Error - Jablotron too few bits found");
6c283951	89	// else if (ans == -2)
6c283951	90	// PrintAndLog("DEBUG: Error - problem during ASK/Biphase demod");
29ce214c	91	else if (ans == -3)
29ce214c	92	PrintAndLog("DEBUG: Error - Jablotron Size not correct: %d", size);
6c283951	93	else if (ans == -4)
6c283951	94	PrintAndLog("DEBUG: Error - Jablotron preamble not found");
29ce214c	95	else if (ans == -5)
29ce214c	96	PrintAndLog("DEBUG: Error - Jablotron checksum failed");
6c283951	97	else
	98	PrintAndLog("DEBUG: Error - ans: %d", ans);
	99	}
	100	return 0;
	101	}
29ce214c	102
	103	setDemodBuf(DemodBuffer+ans, 64, 0);
	104
6c283951	105	//got a good demod
29ce214c	106	uint32_t raw1 = bytebits_to_byte(DemodBuffer, 32);
29ce214c	107	uint32_t raw2 = bytebits_to_byte(DemodBuffer+32, 32);
dc6c90c3	108
	109	uint64_t rawid = bytebits_to_byte(DemodBuffer+16, 40);
	110	uint64_t id = getJablontronCardId(rawid);
	111
	112	PrintAndLog("Jablotron Tag Found: Card ID %u", id);
6c283951	113	PrintAndLog("Raw: %08X%08X", raw1 ,raw2);
6c283951	114
29ce214c	115	uint8_t chksum = raw2 & 0xFF;
	116	PrintAndLog("Checksum: %02X [%s]",
	117	chksum,
	118	(chksum == jablontron_chksum(DemodBuffer)) ? "OK":"FAIL"
	119	);
dc6c90c3	120
dc6c90c3	121	id = DEC2BCD(id);
29ce214c	122	// Printed format: 1410-nn-nnnn-nnnn
dc6c90c3	123	PrintAndLog("Printed: 1410-%02X-%04X-%04X",
	124	(uint8_t)(id >> 32) & 0xFF,
	125	(uint16_t)(id >> 16) & 0xFFFF,
	126	(uint16_t)id & 0xFFFF
	127	);
6c283951	128	return 1;
	129	}
	130
	131	int CmdJablotronRead(const char *Cmd) {
6c283951	132	CmdLFRead("s");
6c283951	133	getSamples("30000",false);
6c283951	134	return CmdJablotronDemod(Cmd);
	135	}
	136
	137	int CmdJablotronClone(const char *Cmd) {
	138
	139	uint64_t fullcode = 0;
	140	uint32_t blocks[3] = {T55x7_MODULATION_DIPHASE \| T55x7_BITRATE_RF_64 \| 2<<T55x7_MAXBLOCK_SHIFT, 0, 0};
	141
	142	uint8_t bits[64];
	143	uint8_t *bs = bits;
	144	memset(bs, 0, sizeof(bits));
	145
	146	char cmdp = param_getchar(Cmd, 0);
	147	if (strlen(Cmd) == 0 \|\| cmdp == 'h' \|\| cmdp == 'H') return usage_lf_jablotron_clone();
	148
8ae9b358	149	fullcode = param_get64ex(Cmd, 0, 0, 16);
6c283951	150
6c283951	151	//Q5
8ae9b358	152	if (param_getchar(Cmd, 1) == 'Q' \|\| param_getchar(Cmd, 1) == 'q') {
6c283951	153	//t5555 (Q5) BITRATE = (RF-2)/2 (iceman)
	154	blocks[0] = T5555_MODULATION_BIPHASE \| T5555_INVERT_OUTPUT \| 64<<T5555_BITRATE_SHIFT \| 2<<T5555_MAXBLOCK_SHIFT;
	155	}
	156
29ce214c	157	// clearing the topbit needed for the preambl detection.
	158	if ((fullcode & 0x7FFFFFFFFF) != fullcode) {
	159	fullcode &= 0x7FFFFFFFFF;
f5538c1c	160	PrintAndLog("Card Number Truncated to 39bits: %"PRIx64, fullcode);
6c283951	161	}
29ce214c	162
6c283951	163	if ( !getJablotronBits(fullcode, bs)) {
	164	PrintAndLog("Error with tag bitstream generation.");
	165	return 1;
	166	}
	167
	168	//
	169	blocks[1] = bytebits_to_byte(bs,32);
	170	blocks[2] = bytebits_to_byte(bs+32,32);
	171
29ce214c	172	PrintAndLog("Preparing to clone Jablotron to T55x7 with FullCode: %"PRIx64, fullcode);
6c283951	173	PrintAndLog("Blk \| Data ");
	174	PrintAndLog("----+------------");
	175	PrintAndLog(" 00 \| 0x%08x", blocks[0]);
	176	PrintAndLog(" 01 \| 0x%08x", blocks[1]);
	177	PrintAndLog(" 02 \| 0x%08x", blocks[2]);
	178
	179	UsbCommand resp;
	180	UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {0,0,0}};
	181
	182	for (int i=4; i>=0; i--) {
	183	c.arg[0] = blocks[i];
	184	c.arg[1] = i;
	185	clearCommandBuffer();
	186	SendCommand(&c);
	187	if (!WaitForResponseTimeout(CMD_ACK, &resp, 1000)){
	188	PrintAndLog("Error occurred, device did not respond during write operation.");
	189	return -1;
	190	}
	191	}
	192	return 0;
	193	}
	194
	195	int CmdJablotronSim(const char *Cmd) {
	196	uint64_t fullcode = 0;
	197
	198	char cmdp = param_getchar(Cmd, 0);
	199	if (strlen(Cmd) == 0 \|\| cmdp == 'h' \|\| cmdp == 'H') return usage_lf_jablotron_sim();
	200
8ae9b358	201	fullcode = param_get64ex(Cmd, 0, 0, 16);
29ce214c	202
	203	// clearing the topbit needed for the preambl detection.
	204	if ((fullcode & 0x7FFFFFFFFF) != fullcode) {
	205	fullcode &= 0x7FFFFFFFFF;
f5538c1c	206	PrintAndLog("Card Number Truncated to 39bits: %"PRIx64, fullcode);
29ce214c	207	}
6c283951	208
	209	uint8_t clk = 64, encoding = 2, separator = 0, invert = 1;
	210	uint16_t arg1, arg2;
	211	size_t size = 64;
	212	arg1 = clk << 8 \| encoding;
	213	arg2 = invert << 8 \| separator;
	214
29ce214c	215	PrintAndLog("Simulating Jablotron - FullCode: %"PRIx64, fullcode);
6c283951	216
	217	UsbCommand c = {CMD_ASK_SIM_TAG, {arg1, arg2, size}};
	218	getJablotronBits(fullcode, c.d.asBytes);
	219	clearCommandBuffer();
	220	SendCommand(&c);
	221	return 0;
	222	}
	223
	224	static command_t CommandTable[] = {
	225	{"help", CmdHelp, 1, "This help"},
8ae9b358	226	{"read", CmdJablotronRead, 0, "Attempt to read and extract tag data"},
	227	{"clone", CmdJablotronClone, 0, "clone jablotron tag"},
	228	{"sim", CmdJablotronSim, 0, "simulate jablotron tag"},
6c283951	229	{NULL, NULL, 0, NULL}
	230	};
	231
	232	int CmdLFJablotron(const char *Cmd) {
	233	clearCommandBuffer();
	234	CmdsParse(CommandTable, Cmd);
	235	return 0;
	236	}
	237
	238	int CmdHelp(const char *Cmd) {
	239	CmdsHelp(CommandTable);
	240	return 0;
	241	}