[proxmark3-svn] / client / cmdlfhid.c

//-----------------------------------------------------------------------------
// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
//
// 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 HID commands
//-----------------------------------------------------------------------------

#include "cmdlfhid.h"

static int CmdHelp(const char *Cmd);

int usage_lf_hid_wiegand(void){
	PrintAndLog("This command converts facility code/card number to Wiegand code");
  	PrintAndLog("Usage: lf hid wiegand [h] [OEM] [FC] [CN]");

	PrintAndLog("Options:");
	PrintAndLog("       h             - This help");
	PrintAndLog("       OEM           - OEM number / site code");
	PrintAndLog("       FC            - facility code");
	PrintAndLog("       CN            - card number");
	PrintAndLog("Examples:");
	PrintAndLog("      lf hid wiegand 0 101 2001");
	return 0;
}
int usage_lf_hid_sim(void){
	PrintAndLog("HID Tag simulator");
	PrintAndLog("");
	PrintAndLog("Usage:  lf hid sim [h] [ID]");
	PrintAndLog("Options:");
	PrintAndLog("       h	- This help");
	PrintAndLog("       ID  - HID id");
	PrintAndLog("Examples:");
	PrintAndLog("      lf hid sim 224");
	return 0;
}
int usage_lf_hid_clone(void){
	PrintAndLog("Clone HID to T55x7.  Tag must be on antenna. ");
	PrintAndLog("");
	PrintAndLog("Usage:  lf hid clone [h] [ID] <L>");
	PrintAndLog("Options:");
	PrintAndLog("       h	- This help");
	PrintAndLog("       ID  - HID id");
	PrintAndLog("       L   - 84bit ID");
	PrintAndLog("Examples:");
	PrintAndLog("      lf hid clone 224");
	PrintAndLog("      lf hid clone 224 L");
	return 0;
}
int usage_lf_hid_brute(void){
	PrintAndLog("Enables bruteforce of HID readers with specified facility code.");
	PrintAndLog("Different formatlength is supported");
	PrintAndLog("This is a incremental attack against reader.");
	PrintAndLog("");
	PrintAndLog("Usage:  lf hid brute [h] <format length> <facility code>");
	PrintAndLog("Options :");
	PrintAndLog("  h				- This help");	
	PrintAndLog("  <format length>	- 26|33|34|35|37|40|44|84");
	PrintAndLog("  <facility code>	- 8-bit value HID facility code");
	PrintAndLog("");
	PrintAndLog("Sample  : lf hid brute 26 224");
	return 0;
}

int CmdHIDDemodFSK(const char *Cmd) {
	int findone = ( Cmd[0] == '1' ) ? 1 : 0;
	UsbCommand c = {CMD_HID_DEMOD_FSK, {findone, 0 , 0}};
	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}

int CmdHIDSim(const char *Cmd) {
	unsigned int hi = 0, lo = 0;
	int n = 0, i = 0;

	uint8_t ctmp = param_getchar(Cmd, 0);
	if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_hid_sim();
	
	while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
		hi = (hi << 4) | (lo >> 28);
		lo = (lo << 4) | (n & 0xf);
	}

	PrintAndLog("Emulating tag with ID %x%16x", hi, lo);
	PrintAndLog("Press pm3-button to abort simulation");

	UsbCommand c = {CMD_HID_SIM_TAG, {hi, lo, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}

int CmdHIDClone(const char *Cmd) {
	
	unsigned int hi2 = 0, hi = 0, lo = 0;
	int n = 0, i = 0;
	UsbCommand c;

	uint8_t ctmp = param_getchar(Cmd, 0);
	if ( strlen(Cmd) == 0 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_hid_clone();

	if (strchr(Cmd,'l') != 0) {
		while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
			hi2 = (hi2 << 4) | (hi >> 28);
			hi = (hi << 4) | (lo >> 28);
			lo = (lo << 4) | (n & 0xf);
		}

		PrintAndLog("Cloning tag with long ID %x%08x%08x", hi2, hi, lo);

		c.d.asBytes[0] = 1;
	} else {
		while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
			hi = (hi << 4) | (lo >> 28);
			lo = (lo << 4) | (n & 0xf);
		}

		PrintAndLog("Cloning tag with ID %x%08x", hi, lo);

		hi2 = 0;
		c.d.asBytes[0] = 0;
	}

	c.cmd = CMD_HID_CLONE_TAG;
	c.arg[0] = hi2;
	c.arg[1] = hi;
	c.arg[2] = lo;

	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}
// struct to handle wiegand
typedef struct {
	uint8_t  FormatLen;
	uint8_t  SiteCode;
	uint8_t  FacilityCode;
	uint8_t  CardNumber;
	uint8_t* Wiegand;
	size_t   Wiegand_n;
 } wiegand_t;

// static void addHIDMarker(uint8_t fmtlen, uint8_t *out) {
	
// }
//static void getParity26(uint32_t *hi, uint32_t *lo){
	// uint32_t result = 0;
	// int i;
	// // even parity
	// for (i = 24;i >= 13;i--)
		// result ^= (*lo >> i) & 1;
	// // even parity 26th bit
	// *lo |= result << 25;

	// // odd parity 
	// result = 0;
	// for (i = 12;i >= 1;i--)
		// result ^= (*lo >> i) & 1;
	// *lo |= !result;
//}

// static void getParity33(uint32_t *hi, uint32_t *lo){

// }
// static void getParity34(uint32_t *hi, uint32_t *lo){
	// uint32_t result = 0;
	// int i;

	// // even parity 
	// for (i = 7;i >= 0;i--)
		// result ^= (*hi >> i) & i;
	// for (i = 31;i >= 24;i--)
		// result ^= (*lo >> i) & 1;

	// *hi |= result << 2; 

	// // odd parity bit
	// result = 0;
	// for (i = 23;i >= 1;i--)
		// result ^= (*lo >> i) & 1;

	// *lo |= !result;
// }
// static void getParity35(uint32_t *hi, uint32_t *lo){	
// }
// static void getParity37S(uint32_t *hi,uint32_t *lo){
	// uint32_t result = 0;
	// int i;

	// // even parity
	// for (i = 4; i >= 0; i--)
		// result ^= (*hi >> i) & 1;
	
	// for (i = 31; i >= 20; i--)
		// result ^= (*lo >> i) & 1;

	// *hi |= result;

	// // odd parity
	// result = 0;
	// for (i = 19; i >= 1; i--)
		// result ^= (*lo >> i) & 1;

	// *lo |= result;
// }
// static void getParity37H(uint32_t *hi, uint32_t *lo){
	// uint32_t result = 0;
	// int i;

	// // even parity
	// for (i = 4;i >= 0;i--)
		// result ^= (*hi >> i) & 1;
	// for (i = 31;i >= 20;i--)
		// result ^= (*lo >> i) & 1;
	// *hi |= result << 4;

	// // odd parity
	// result = 0;
	// for (i = 19;i >= 1;i--)
		// result ^= (*lo >> i) & 1;
	// *lo |= result;
// }

//static void calc26(uint16_t fc, uint32_t cardno, uint32_t *hi, uint32_t *lo){
void calc26(uint16_t fc, uint32_t cardno, uint8_t *out){

	uint8_t wiegand[24];
	num_to_bytebits(fc, 8, wiegand);
	num_to_bytebits(cardno, 16, wiegand+8);
	wiegand_add_parity(out,  wiegand, sizeof(wiegand) );
	
//   *out |= (1 << 26); // why this?
//   *out |= (1 << 37);  // bit format for hid?
}
// static void calc33(uint16_t fc, uint32_t cardno, uint32_t *hi, uint32_t *lo){

// }
// static void calc34(uint16_t fc, uint32_t cardno, uint32_t *hi, uint32_t *lo){
  // // put card number first bit 1 .. 20 //
  // *lo = ((cardno & 0X000F7FFF) << 1) | ((fc & 0XFFFF) << 17);
  // // set bit format for less than 37 bit format
  // *hi = (1 << 5) | (fc >> 15);
// }
// static void calc35(uint16_t fc, uint32_t cardno, uint32_t *hi, uint32_t *lo){
	// *lo = ((cardno & 0xFFFFF) << 1) | fc << 21; 
	// *hi = (1 << 5) | ((fc >> 11) & 1);  
// }
// static void calc37S(uint16_t fc, uint32_t cardno, uint32_t *hi, uint32_t *lo){
	// // FC 2 - 17   - 16 bit  
	// // cardno 18 - 36  - 19 bit
	// // Even P1   1 - 19
	// // Odd  P37  19 - 36

	// fc = fc & 0xFFFF;
	// *lo = ((fc << 20) | (cardno & 0x7FFFF) << 1);
	// *hi = (fc >> 12);
// }
// static void calc37H(uint64_t cardno, uint32_t *hi, uint32_t *lo){
	// // SC NONE
	// // cardno 1-35 34 bits 
	// // Even Parity  0th bit  1-18
	// // Odd  Parity 36th bit 19-35
	// cardno = (cardno & 0x00000003FFFFFFFF);
	// *lo = (cardno << 1);
	// *hi = (cardno >> 31);
// }
// static void calc40(uint64_t cardno, uint32_t *hi, uint32_t *lo){
	// cardno = (cardno & 0xFFFFFFFFFF);
	// *lo = ((cardno & 0xFFFFFFFF) << 1 ); 
	// *hi = (cardno >> 31);  
// }

static void calcWiegand(uint8_t fmtlen, uint16_t fc, uint64_t cardno, uint8_t *bits){

	// uint32_t hi = 0, lo = 0;
	// uint32_t cn32 = (cardno & 0xFFFFFFFF);
	// switch ( fmtlen ) {
		// case 26 : {			
			// calc26(fc, cn32, bits);
			// addHIDFormatMarker(fmtlen, bits);	
			// break;
		// }
		// case 33 : { 
 			// // calc33(fc, cn32, hi, lo);
			// // getParity33(hi, lo);	
			// break;
		// }
		// case 34 : {
 			// calc34(fc, cn32, hi, lo);
			// getParity34(hi, lo);		
			// break;
		// }
		// case 35 : {
			// calc35(fc, cn32, hi, lo);
			// getParity35(hi, lo);
			// break;
		// }
		// case 37 : {
			// calc37S(fc, cn32, hi, lo);
			// getParity37S(hi, lo);
			// break;
		// }
		// case 38 : { 
			// calc37H(cn32, hi, lo);
			// getParity37H(hi, lo);
			// break;
		// }
		// case 40 : calc40(cardno, hi, lo);	break;
		// case 44 : { break; }
		// case 84 : { break; }
	// }

}	

int CmdHIDWiegand(const char *Cmd) {
	uint32_t oem = 0, fc = 0;
	uint64_t cardnum = 0;
	
	uint32_t blocks[2] = {0,0}
	uint32_t wiegand[2] = {0,0}; 

	uint8_t bits[96];
	uint8_t *bs = bits;
	memset(bs, 0, sizeof(bits));
	
	uint8_t ctmp = param_getchar(Cmd, 0);
	if ( strlen(Cmd) == 0 || strlen(Cmd) < 3 || ctmp == 'H' || ctmp == 'h' ) return usage_lf_hid_wiegand();

	oem = param_get8(Cmd, 0);
	fc = param_get32ex(Cmd, 1, 0, 10);
	cardnum = param_get64ex(Cmd, 2, 0, 10);

	// 
	uint8_t ftmlen[] = {26,33,34,35,37,38,40};
	
	PrintAndLog("HID | OEM |  FC |   CN  |  Wiegand  |  HID Formatted");
	PrintAndLog("----+-----+-----+-------+-----------+--------------------");
	for (uint8_t i = 0; i < sizeof(ftmlen); i++){
		calcWiegand( ftmlen[i], fc, cardnum, bs);
		blocks[0] = bytebits_to_byte(bs,32);
		blocks[1] = bytebits_to_byte(bs+32,32);
		PrintAndLog(" %d | %d  | %d  | %llu  | %08X%08X  |  %08X%08X ",
			ftmlen,
			oem,
			fc,
			cardnum,
			wiegand[0],
			wiegand[1],
			blocks[0],
			blocks[1]
			);
	}
	PrintAndLog("----+-----+-----+-------+-----------+--------------------");
	return 0;
}

int CmdHIDBrute(const char *Cmd){
	
	bool error = TRUE;
	uint8_t fc = 0, fmtlen = 0;

	uint8_t bits[96];
	uint8_t *bs = bits;
	memset(bs, 0, sizeof(bits));

	UsbCommand c = {CMD_HID_SIM_TAG, {0, 0, 0}};  
	
	char cmdp = param_getchar(Cmd, 0);
	if (strlen(Cmd) > 2 || strlen(Cmd) == 0 || cmdp == 'h' || cmdp == 'H') return usage_lf_hid_brute();

	fmtlen = param_get8(Cmd, 0);
	uint8_t ftms[] = {26,33,34,35,37};
	for ( uint8_t i = 0; i < sizeof(ftms); i++){
		if ( ftms[i] == fmtlen ) {
			error = FALSE;
		}
	}

	if ( error ) return usage_lf_hid_brute();
	
  	fc =  param_get8(Cmd, 1);
	if ( fc == 0) return usage_lf_hid_brute();
	
	PrintAndLog("Brute-forcing HID reader");
	PrintAndLog("Press pm3-button to abort simulation or run another command");

	for ( uint16_t cn = 1; cn < 0xFFFF; ++cn){
		if (ukbhit()) {
			PrintAndLog("aborted via keyboard!");
			c.cmd = CMD_PING;
			c.arg[0] = 0x00;
			c.arg[1] = 0x00;
			c.arg[2] = 0x00;
			clearCommandBuffer();
			SendCommand(&c);
			return 1;
		}

		calcWiegand( fmtlen, fc, cn, bs);

		c.arg[0] = bytebits_to_byte(bs,32);
		c.arg[1] = bytebits_to_byte(bs+32,32);
		clearCommandBuffer();
		SendCommand(&c);
		
		PrintAndLog("Trying FC: %u; CN: %u", fc, cn);
		// pause
		sleep(1);
	}
	return 0;
}

static command_t CommandTable[] = {
	{"help",    CmdHelp,        1, "This help"},
	{"fskdemod",CmdHIDDemodFSK, 0, "[1] Realtime HID FSK demodulator (option '1' for one tag only)"},
	{"sim",     CmdHIDSim,      0, "<ID> -- HID tag simulator"},
	{"clone",   CmdHIDClone,    0, "<ID> [L] -- Clone HID to T55x7"},
	{"wiegand", CmdHIDWiegand,  0, "<OEM> <facility code> <card number> -- convert facility code/card number to Wiegand code"},
	{"brute",   CmdHIDBrute, 0, "<format length> <facility code> -- brute force card number"},
	{NULL, NULL, 0, NULL}
};

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

int CmdHelp(const char *Cmd) {
	CmdsHelp(CommandTable);
	return 0;
}
Commit	Line	Data
a553f267	1	//-----------------------------------------------------------------------------
	2	// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
	3	//
	4	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	5	// at your option, any later version. See the LICENSE.txt file for the text of
	6	// the license.
	7	//-----------------------------------------------------------------------------
	8	// Low frequency HID commands
	9	//-----------------------------------------------------------------------------
	10
7fe9b0b7	11	#include "cmdlfhid.h"
	12
	13	static int CmdHelp(const char *Cmd);
f4fbfb83	14
3a532acf	15	int usage_lf_hid_wiegand(void){
e13ccb6b	16	PrintAndLog("This command converts facility code/card number to Wiegand code");
758f5ee3	17	PrintAndLog("Usage: lf hid wiegand [h] [OEM] [FC] [CN]");
758f5ee3	18
f4fbfb83	19	PrintAndLog("Options:");
e13ccb6b	20	PrintAndLog(" h - This help");
758f5ee3	21	PrintAndLog(" OEM - OEM number / site code");
e13ccb6b	22	PrintAndLog(" FC - facility code");
e13ccb6b	23	PrintAndLog(" CN - card number");
f4fbfb83	24	PrintAndLog("Examples:");
3a532acf	25	PrintAndLog(" lf hid wiegand 0 101 2001");
	26	return 0;
	27	}
758f5ee3	28	int usage_lf_hid_sim(void){
	29	PrintAndLog("HID Tag simulator");
	30	PrintAndLog("");
	31	PrintAndLog("Usage: lf hid sim [h] [ID]");
	32	PrintAndLog("Options:");
	33	PrintAndLog(" h - This help");
	34	PrintAndLog(" ID - HID id");
	35	PrintAndLog("Examples:");
	36	PrintAndLog(" lf hid sim 224");
	37	return 0;
	38	}
	39	int usage_lf_hid_clone(void){
	40	PrintAndLog("Clone HID to T55x7. Tag must be on antenna. ");
	41	PrintAndLog("");
	42	PrintAndLog("Usage: lf hid clone [h] [ID] <L>");
	43	PrintAndLog("Options:");
	44	PrintAndLog(" h - This help");
	45	PrintAndLog(" ID - HID id");
	46	PrintAndLog(" L - 84bit ID");
	47	PrintAndLog("Examples:");
	48	PrintAndLog(" lf hid clone 224");
	49	PrintAndLog(" lf hid clone 224 L");
	50	return 0;
	51	}
3a532acf	52	int usage_lf_hid_brute(void){
e13ccb6b	53	PrintAndLog("Enables bruteforce of HID readers with specified facility code.");
3a532acf	54	PrintAndLog("Different formatlength is supported");
	55	PrintAndLog("This is a incremental attack against reader.");
	56	PrintAndLog("");
758f5ee3	57	PrintAndLog("Usage: lf hid brute [h] <format length> <facility code>");
3a532acf	58	PrintAndLog("Options :");
758f5ee3	59	PrintAndLog(" h - This help");
e13ccb6b	60	PrintAndLog(" <format length> - 26\|33\|34\|35\|37\|40\|44\|84");
e13ccb6b	61	PrintAndLog(" <facility code> - 8-bit value HID facility code");
3a532acf	62	PrintAndLog("");
3a532acf	63	PrintAndLog("Sample : lf hid brute 26 224");
f4fbfb83	64	return 0;
f4fbfb83	65	}
758f5ee3	66
3a532acf	67	int CmdHIDDemodFSK(const char *Cmd) {
f4fbfb83	68	int findone = ( Cmd[0] == '1' ) ? 1 : 0;
	69	UsbCommand c = {CMD_HID_DEMOD_FSK, {findone, 0 , 0}};
	70	clearCommandBuffer();
	71	SendCommand(&c);
	72	return 0;
7fe9b0b7	73	}
7fe9b0b7	74
3a532acf	75	int CmdHIDSim(const char *Cmd) {
f4fbfb83	76	unsigned int hi = 0, lo = 0;
f4fbfb83	77	int n = 0, i = 0;
38b20f75	78
758f5ee3	79	uint8_t ctmp = param_getchar(Cmd, 0);
	80	if ( strlen(Cmd) == 0 \|\| ctmp == 'H' \|\| ctmp == 'h' ) return usage_lf_hid_sim();
	81
f4fbfb83	82	while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
	83	hi = (hi << 4) \| (lo >> 28);
	84	lo = (lo << 4) \| (n & 0xf);
	85	}
38b20f75	86
f4fbfb83	87	PrintAndLog("Emulating tag with ID %x%16x", hi, lo);
f4fbfb83	88	PrintAndLog("Press pm3-button to abort simulation");
38b20f75	89
f4fbfb83	90	UsbCommand c = {CMD_HID_SIM_TAG, {hi, lo, 0}};
	91	clearCommandBuffer();
	92	SendCommand(&c);
	93	return 0;
38b20f75	94	}
38b20f75	95
3a532acf	96	int CmdHIDClone(const char *Cmd) {
758f5ee3	97
f4fbfb83	98	unsigned int hi2 = 0, hi = 0, lo = 0;
	99	int n = 0, i = 0;
	100	UsbCommand c;
38b20f75	101
758f5ee3	102	uint8_t ctmp = param_getchar(Cmd, 0);
	103	if ( strlen(Cmd) == 0 \|\| ctmp == 'H' \|\| ctmp == 'h' ) return usage_lf_hid_clone();
	104
f4fbfb83	105	if (strchr(Cmd,'l') != 0) {
	106	while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
	107	hi2 = (hi2 << 4) \| (hi >> 28);
	108	hi = (hi << 4) \| (lo >> 28);
	109	lo = (lo << 4) \| (n & 0xf);
	110	}
38b20f75	111
f4fbfb83	112	PrintAndLog("Cloning tag with long ID %x%08x%08x", hi2, hi, lo);
38b20f75	113
f4fbfb83	114	c.d.asBytes[0] = 1;
	115	} else {
	116	while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
	117	hi = (hi << 4) \| (lo >> 28);
	118	lo = (lo << 4) \| (n & 0xf);
	119	}
38b20f75	120
f4fbfb83	121	PrintAndLog("Cloning tag with ID %x%08x", hi, lo);
38b20f75	122
f4fbfb83	123	hi2 = 0;
	124	c.d.asBytes[0] = 0;
	125	}
ec09b62d	126
f4fbfb83	127	c.cmd = CMD_HID_CLONE_TAG;
	128	c.arg[0] = hi2;
	129	c.arg[1] = hi;
	130	c.arg[2] = lo;
	131
	132	clearCommandBuffer();
	133	SendCommand(&c);
	134	return 0;
ec09b62d	135	}
758f5ee3	136	// struct to handle wiegand
	137	typedef struct {
	138	uint8_t FormatLen;
	139	uint8_t SiteCode;
	140	uint8_t FacilityCode;
	141	uint8_t CardNumber;
	142	uint8_t* Wiegand;
	143	size_t Wiegand_n;
	144	} wiegand_t;
	145
	146	// static void addHIDMarker(uint8_t fmtlen, uint8_t *out) {
f4fbfb83	147
758f5ee3	148	// }
	149	//static void getParity26(uint32_t hi, uint32_t lo){
	150	// uint32_t result = 0;
	151	// int i;
	152	// // even parity
	153	// for (i = 24;i >= 13;i--)
	154	// result ^= (*lo >> i) & 1;
	155	// // even parity 26th bit
	156	// *lo \|= result << 25;
	157
	158	// // odd parity
	159	// result = 0;
	160	// for (i = 12;i >= 1;i--)
	161	// result ^= (*lo >> i) & 1;
	162	// *lo \|= !result;
	163	//}
	164
	165	// static void getParity33(uint32_t hi, uint32_t lo){
	166
	167	// }
	168	// static void getParity34(uint32_t hi, uint32_t lo){
	169	// uint32_t result = 0;
	170	// int i;
	171
	172	// // even parity
	173	// for (i = 7;i >= 0;i--)
	174	// result ^= (*hi >> i) & i;
	175	// for (i = 31;i >= 24;i--)
	176	// result ^= (*lo >> i) & 1;
	177
	178	// *hi \|= result << 2;
	179
	180	// // odd parity bit
	181	// result = 0;
	182	// for (i = 23;i >= 1;i--)
	183	// result ^= (*lo >> i) & 1;
	184
	185	// *lo \|= !result;
	186	// }
	187	// static void getParity35(uint32_t hi, uint32_t lo){
	188	// }
	189	// static void getParity37S(uint32_t hi,uint32_t lo){
	190	// uint32_t result = 0;
	191	// int i;
	192
	193	// // even parity
	194	// for (i = 4; i >= 0; i--)
	195	// result ^= (*hi >> i) & 1;
	196
	197	// for (i = 31; i >= 20; i--)
	198	// result ^= (*lo >> i) & 1;
	199
	200	// *hi \|= result;
	201
	202	// // odd parity
	203	// result = 0;
	204	// for (i = 19; i >= 1; i--)
	205	// result ^= (*lo >> i) & 1;
	206
	207	// *lo \|= result;
	208	// }
	209	// static void getParity37H(uint32_t hi, uint32_t lo){
	210	// uint32_t result = 0;
	211	// int i;
212
213	// // even parity
214	// for (i = 4;i >= 0;i--)
215	// result ^= (*hi >> i) & 1;
216	// for (i = 31;i >= 20;i--)
217	// result ^= (*lo >> i) & 1;
218	// *hi \|= result << 4;
219
220	// // odd parity
221	// result = 0;
222	// for (i = 19;i >= 1;i--)
223	// result ^= (*lo >> i) & 1;
224	// *lo \|= result;
225	// }
226
227	//static void calc26(uint16_t fc, uint32_t cardno, uint32_t hi, uint32_t lo){
228	void calc26(uint16_t fc, uint32_t cardno, uint8_t *out){
229
230	uint8_t wiegand[24];
231	num_to_bytebits(fc, 8, wiegand);
232	num_to_bytebits(cardno, 16, wiegand+8);
233	wiegand_add_parity(out, wiegand, sizeof(wiegand) );
234
235	// *out \|= (1 << 26); // why this?
236	// *out \|= (1 << 37); // bit format for hid?
f4fbfb83	237	}
758f5ee3	238	// static void calc33(uint16_t fc, uint32_t cardno, uint32_t hi, uint32_t lo){
	239
	240	// }
	241	// static void calc34(uint16_t fc, uint32_t cardno, uint32_t hi, uint32_t lo){
	242	// // put card number first bit 1 .. 20 //
	243	// *lo = ((cardno & 0X000F7FFF) << 1) \| ((fc & 0XFFFF) << 17);
	244	// // set bit format for less than 37 bit format
	245	// *hi = (1 << 5) \| (fc >> 15);
	246	// }
	247	// static void calc35(uint16_t fc, uint32_t cardno, uint32_t hi, uint32_t lo){
	248	// *lo = ((cardno & 0xFFFFF) << 1) \| fc << 21;
	249	// *hi = (1 << 5) \| ((fc >> 11) & 1);
	250	// }
	251	// static void calc37S(uint16_t fc, uint32_t cardno, uint32_t hi, uint32_t lo){
	252	// // FC 2 - 17 - 16 bit
	253	// // cardno 18 - 36 - 19 bit
	254	// // Even P1 1 - 19
	255	// // Odd P37 19 - 36
	256
	257	// fc = fc & 0xFFFF;
	258	// *lo = ((fc << 20) \| (cardno & 0x7FFFF) << 1);
	259	// *hi = (fc >> 12);
	260	// }
	261	// static void calc37H(uint64_t cardno, uint32_t hi, uint32_t lo){
	262	// // SC NONE
	263	// // cardno 1-35 34 bits
	264	// // Even Parity 0th bit 1-18
	265	// // Odd Parity 36th bit 19-35
	266	// cardno = (cardno & 0x00000003FFFFFFFF);
	267	// *lo = (cardno << 1);
	268	// *hi = (cardno >> 31);
	269	// }
	270	// static void calc40(uint64_t cardno, uint32_t hi, uint32_t lo){
	271	// cardno = (cardno & 0xFFFFFFFFFF);
	272	// *lo = ((cardno & 0xFFFFFFFF) << 1 );
	273	// *hi = (cardno >> 31);
	274	// }
	275
	276	static void calcWiegand(uint8_t fmtlen, uint16_t fc, uint64_t cardno, uint8_t *bits){
	277
	278	// uint32_t hi = 0, lo = 0;
	279	// uint32_t cn32 = (cardno & 0xFFFFFFFF);
	280	// switch ( fmtlen ) {
	281	// case 26 : {
	282	// calc26(fc, cn32, bits);
	283	// addHIDFormatMarker(fmtlen, bits);
	284	// break;
	285	// }
	286	// case 33 : {
	287	// // calc33(fc, cn32, hi, lo);
	288	// // getParity33(hi, lo);
	289	// break;
	290	// }
	291	// case 34 : {
	292	// calc34(fc, cn32, hi, lo);
	293	// getParity34(hi, lo);
	294	// break;
	295	// }
	296	// case 35 : {
	297	// calc35(fc, cn32, hi, lo);
	298	// getParity35(hi, lo);
	299	// break;
	300	// }
	301	// case 37 : {
302	// calc37S(fc, cn32, hi, lo);
303	// getParity37S(hi, lo);
304	// break;
305	// }
306	// case 38 : {
307	// calc37H(cn32, hi, lo);
308	// getParity37H(hi, lo);
309	// break;
310	// }
311	// case 40 : calc40(cardno, hi, lo); break;
312	// case 44 : { break; }
313	// case 84 : { break; }
314	// }
f4fbfb83	315
3a532acf	316	}
	317
	318	int CmdHIDWiegand(const char *Cmd) {
758f5ee3	319	uint32_t oem = 0, fc = 0;
3a532acf	320	uint64_t cardnum = 0;
3a532acf	321
34c81fe0	322	uint32_t blocks[2] = {0,0}
34c81fe0	323	uint32_t wiegand[2] = {0,0};
758f5ee3	324
	325	uint8_t bits[96];
	326	uint8_t *bs = bits;
	327	memset(bs, 0, sizeof(bits));
	328
3a532acf	329	uint8_t ctmp = param_getchar(Cmd, 0);
e1ad67ea	330	if ( strlen(Cmd) == 0 \|\| strlen(Cmd) < 3 \|\| ctmp == 'H' \|\| ctmp == 'h' ) return usage_lf_hid_wiegand();
3a532acf	331
	332	oem = param_get8(Cmd, 0);
	333	fc = param_get32ex(Cmd, 1, 0, 10);
	334	cardnum = param_get64ex(Cmd, 2, 0, 10);
	335
758f5ee3	336	//
3a532acf	337	uint8_t ftmlen[] = {26,33,34,35,37,38,40};
758f5ee3	338
e92948c6	339	PrintAndLog("HID \| OEM \| FC \| CN \| Wiegand \| HID Formatted");
e92948c6	340	PrintAndLog("----+-----+-----+-------+-----------+--------------------");
3a532acf	341	for (uint8_t i = 0; i < sizeof(ftmlen); i++){
758f5ee3	342	calcWiegand( ftmlen[i], fc, cardnum, bs);
	343	blocks[0] = bytebits_to_byte(bs,32);
	344	blocks[1] = bytebits_to_byte(bs+32,32);
e92948c6	345	PrintAndLog(" %d \| %d \| %d \| %llu \| %08X%08X \| %08X%08X ",
758f5ee3	346	ftmlen,
e92948c6	347	oem,
758f5ee3	348	fc,
	349	cardnum,
	350	wiegand[0],
	351	wiegand[1],
	352	blocks[0],
	353	blocks[1]
	354	);
3a532acf	355	}
e92948c6	356	PrintAndLog("----+-----+-----+-------+-----------+--------------------");
3a532acf	357	return 0;
	358	}
	359
	360	int CmdHIDBrute(const char *Cmd){
	361
e1ad67ea	362	bool error = TRUE;
3a532acf	363	uint8_t fc = 0, fmtlen = 0;
758f5ee3	364
	365	uint8_t bits[96];
	366	uint8_t *bs = bits;
	367	memset(bs, 0, sizeof(bits));
3a532acf	368
	369	UsbCommand c = {CMD_HID_SIM_TAG, {0, 0, 0}};
	370
	371	char cmdp = param_getchar(Cmd, 0);
	372	if (strlen(Cmd) > 2 \|\| strlen(Cmd) == 0 \|\| cmdp == 'h' \|\| cmdp == 'H') return usage_lf_hid_brute();
	373
	374	fmtlen = param_get8(Cmd, 0);
e1ad67ea	375	uint8_t ftms[] = {26,33,34,35,37};
	376	for ( uint8_t i = 0; i < sizeof(ftms); i++){
	377	if ( ftms[i] == fmtlen ) {
3a532acf	378	error = FALSE;
3a532acf	379	}
3a532acf	380	}
e1ad67ea	381
3a532acf	382	if ( error ) return usage_lf_hid_brute();
	383
	384	fc = param_get8(Cmd, 1);
	385	if ( fc == 0) return usage_lf_hid_brute();
	386
e13ccb6b	387	PrintAndLog("Brute-forcing HID reader");
3a532acf	388	PrintAndLog("Press pm3-button to abort simulation or run another command");
	389
	390	for ( uint16_t cn = 1; cn < 0xFFFF; ++cn){
	391	if (ukbhit()) {
	392	PrintAndLog("aborted via keyboard!");
	393	c.cmd = CMD_PING;
	394	c.arg[0] = 0x00;
	395	c.arg[1] = 0x00;
	396	c.arg[2] = 0x00;
	397	clearCommandBuffer();
	398	SendCommand(&c);
	399	return 1;
	400	}
	401
758f5ee3	402	calcWiegand( fmtlen, fc, cn, bs);
3a532acf	403
758f5ee3	404	c.arg[0] = bytebits_to_byte(bs,32);
758f5ee3	405	c.arg[1] = bytebits_to_byte(bs+32,32);
3a532acf	406	clearCommandBuffer();
	407	SendCommand(&c);
	408
	409	PrintAndLog("Trying FC: %u; CN: %u", fc, cn);
	410	// pause
	411	sleep(1);
	412	}
f4fbfb83	413	return 0;
	414	}
	415
	416	static command_t CommandTable[] = {
e13ccb6b	417	{"help", CmdHelp, 1, "This help"},
758f5ee3	418	{"fskdemod",CmdHIDDemodFSK, 0, "[1] Realtime HID FSK demodulator (option '1' for one tag only)"},
e13ccb6b	419	{"sim", CmdHIDSim, 0, "<ID> -- HID tag simulator"},
758f5ee3	420	{"clone", CmdHIDClone, 0, "<ID> [L] -- Clone HID to T55x7"},
e13ccb6b	421	{"wiegand", CmdHIDWiegand, 0, "<OEM> <facility code> <card number> -- convert facility code/card number to Wiegand code"},
e13ccb6b	422	{"brute", CmdHIDBrute, 0, "<format length> <facility code> -- brute force card number"},
f4fbfb83	423	{NULL, NULL, 0, NULL}
7fe9b0b7	424	};
7fe9b0b7	425
f4fbfb83	426	int CmdLFHID(const char *Cmd) {
4c36581b	427	clearCommandBuffer();
f4fbfb83	428	CmdsParse(CommandTable, Cmd);
f4fbfb83	429	return 0;
7fe9b0b7	430	}
7fe9b0b7	431
f4fbfb83	432	int CmdHelp(const char *Cmd) {
	433	CmdsHelp(CommandTable);
	434	return 0;
7fe9b0b7	435	}