Syntax suger

[proxmark3-svn] / client / cmdhf14b.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.
//-----------------------------------------------------------------------------
// High frequency ISO14443B commands
//-----------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include "cmdhf14b.h"

#define TIMEOUT 2000
static int CmdHelp(const char *Cmd);

int usage_hf_14b_info(void){
	PrintAndLog("Usage: hf 14b info [-h] [-s]");
	PrintAndLog("       -h    this help");
	PrintAndLog("       -s    silently");
	return 0;
}
int usage_hf_14b_reader(void){
	PrintAndLog("Usage: hf 14b reader [-h] [-s]");
	PrintAndLog("       -h    this help");
	PrintAndLog("       -s    silently");
	return 0;
}
int usage_hf_14b_raw(void){
	PrintAndLog("Usage: hf 14b raw [-h] [-r] [-c] [-p] [-s || -ss] <0A 0B 0C ... hex>");
	PrintAndLog("       -h    this help");
	PrintAndLog("       -r    do not read response");
	PrintAndLog("       -c    calculate and append CRC");
	PrintAndLog("       -p    leave the field on after receive");
	PrintAndLog("       -s    active signal field ON with select");
	PrintAndLog("       -ss   active signal field ON with select for SRx ST Microelectronics tags");
	return 0;    
}
int usage_hf_14b_snoop(void){
	PrintAndLog("It get data from the field and saves it into command buffer.");
	PrintAndLog("Buffer accessible from command 'hf list 14b'");
	PrintAndLog("Usage: hf 14b snoop [-h]");
	PrintAndLog("       -h    this help");
	PrintAndLog("sample: hf 14b snoop");
	return 0;    
}
int usage_hf_14b_sim(void){
	PrintAndLog("Emulating ISO/IEC 14443 type B tag with 4 UID");
	PrintAndLog("Usage: hf 14b sim [-h]");
	PrintAndLog("       -h    this help");
	PrintAndLog("sample: hf 14b sim");
	return 0;    
}
int usage_hf_14b_read_srx(void){
	PrintAndLog("Usage:  hf 14b read [h] <1|2>");
	PrintAndLog("Options:");
	PrintAndLog("       h        this help");
	PrintAndLog("       <1|2>    1 = SRIX4K , 2 = SRI512");
	PrintAndLog("sample: hf 14b read 1");
	PrintAndLog("      : hf 14b read 2");
	return 0;
}
int usage_hf_14b_write_srx(void){
	PrintAndLog("Usage:  hf 14b write <1|2> <BLOCK> <DATA>");
	PrintAndLog("Options:");
	PrintAndLog("       h        this help");
	PrintAndLog("       <1|2>    1 = SRIX4K , 2 = SRI512");
	PrintAndLog("       <block>  BLOCK number depends on tag, special block == FF");
	PrintAndLog("       <data>   hex bytes of data to be written");
	PrintAndLog("sample  : hf 14b write 1 7F 11223344");
	PrintAndLog("        : hf 14b write 1 FF 11223344");
	PrintAndLog("        : hf 14b write 2 15 11223344");
	PrintAndLog("        : hf 14b write 2 FF 11223344");
	return 0;
}

static int rawClose(){
	UsbCommand c = {CMD_ISO_14443B_COMMAND, {ISO14B_DISCONNECT, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	return 1;
}

int CmdHF14BList(const char *Cmd) {
	CmdHFList("14b");
	return 0;
}

int CmdHF14BSim(const char *Cmd) {
	char cmdp = param_getchar(Cmd, 0);
	if (cmdp == 'h' || cmdp == 'H') return usage_hf_14b_sim();
	
	UsbCommand c = {CMD_SIMULATE_TAG_ISO_14443B, {0, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}

int CmdHF14BSnoop(const char *Cmd) {
	
	char cmdp = param_getchar(Cmd, 0);
	if (cmdp == 'h' || cmdp == 'H') return usage_hf_14b_snoop();
	
	UsbCommand c = {CMD_SNOOP_ISO_14443B, {0, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}

int CmdHF14BCmdRaw (const char *Cmd) {
	bool reply = TRUE;
	bool power = FALSE;
	bool select = FALSE;
	char buf[5]="";

	int i = 0;
	uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
	uint16_t datalen = 0;
	uint32_t flags = 0;
	uint32_t temp = 0;
	
	if (strlen(Cmd)<3) return usage_hf_14b_raw();

    // strip
    while (*Cmd==' ' || *Cmd=='\t') ++Cmd;
    
    while (Cmd[i]!='\0') {
        if (Cmd[i]==' ' || Cmd[i]=='\t') { ++i; continue; }
        if (Cmd[i]=='-') {
            switch (Cmd[i+1]) {
				case 'H':
				case 'h':
					return usage_hf_14b_raw();
                case 'r': 
                case 'R': 
                    reply = FALSE;
                    break;
                case 'c':
                case 'C':                
                    flags |= ISO14B_APPEND_CRC;
                    break;
                case 'p': 
                case 'P': 
					power = TRUE;
                    break;
				case 's':
				case 'S':
					flags |= ISO14B_CONNECT;
					select = TRUE;
					if (Cmd[i+2]=='s' || Cmd[i+2]=='S') {
						flags |= ISO14B_SELECT_SR;
						++i;
					} else {
						flags |= ISO14B_SELECT_STD;
					}
					break;
                default:
                    return usage_hf_14b_raw();
            }
            i+=2;
            continue;
        }
        if ((Cmd[i]>='0' && Cmd[i]<='9') ||
            (Cmd[i]>='a' && Cmd[i]<='f') ||
            (Cmd[i]>='A' && Cmd[i]<='F') ) {
            buf[strlen(buf)+1]=0;
            buf[strlen(buf)]=Cmd[i];
            i++;
            
            if (strlen(buf)>=2) {
                sscanf(buf,"%x",&temp);
                data[datalen++] = (uint8_t)(temp & 0xff);
                *buf=0;
				memset(buf, 0x00, sizeof(buf));
            }
            continue;
        }
        PrintAndLog("Invalid char on input");
		return 0;
    }
	
	if(!power)
        flags |= ISO14B_DISCONNECT;

    if(datalen>0)
        flags |= ISO14B_RAW;

	// Max buffer is USB_CMD_DATA_SIZE
	datalen = (datalen > USB_CMD_DATA_SIZE) ? USB_CMD_DATA_SIZE : datalen;

	UsbCommand c = {CMD_ISO_14443B_COMMAND, {flags, datalen, 0}}; 
	memcpy(c.d.asBytes, data, datalen);
	clearCommandBuffer();
	SendCommand(&c);

	if (!reply) return 1; 

	bool success = TRUE;
	// get back iso14b_card_select_t, don't print it.
	if(select) 
		success = waitCmd(FALSE);

	// get back response from the raw bytes you sent.
	if(success && datalen>0) waitCmd(TRUE);

    return 1;
}

// print full atqb info
// bytes
// 0,1,2,3 = application data
// 4       = bit rate capacity
// 5       = max frame size / -4 info
// 6       = FWI / Coding options
static void print_atqb_resp(uint8_t *data, uint8_t cid){
	//PrintAndLog("           UID: %s", sprint_hex(data+1,4));
	PrintAndLog("      App Data: %s", sprint_hex(data,4));
	PrintAndLog("      Protocol: %s", sprint_hex(data+4,3));
	uint8_t BitRate = data[4];
	if (!BitRate) PrintAndLog("      Bit Rate: 106 kbit/s only PICC <-> PCD");
	if (BitRate & 0x10)	PrintAndLog("      Bit Rate: 212 kbit/s PICC -> PCD supported");
	if (BitRate & 0x20)	PrintAndLog("      Bit Rate: 424 kbit/s PICC -> PCD supported"); 
	if (BitRate & 0x40)	PrintAndLog("      Bit Rate: 847 kbit/s PICC -> PCD supported"); 
	if (BitRate & 0x01)	PrintAndLog("      Bit Rate: 212 kbit/s PICC <- PCD supported");
	if (BitRate & 0x02)	PrintAndLog("      Bit Rate: 424 kbit/s PICC <- PCD supported"); 
	if (BitRate & 0x04)	PrintAndLog("      Bit Rate: 847 kbit/s PICC <- PCD supported"); 
	if (BitRate & 0x80)	PrintAndLog("                Same bit rate <-> required");

	uint16_t maxFrame = data[5]>>4;
	if (maxFrame < 5) 		maxFrame = 8 * maxFrame + 16;
	else if (maxFrame == 5)	maxFrame = 64;
	else if (maxFrame == 6)	maxFrame = 96;
	else if (maxFrame == 7)	maxFrame = 128;
	else if (maxFrame == 8)	maxFrame = 256;
	else maxFrame = 257;


	
	PrintAndLog("Max Frame Size: %u%s bytes",maxFrame, (maxFrame == 257) ? "+ RFU" : "");

	uint8_t protocolT = data[5] & 0xF;
	PrintAndLog(" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT) ? "" : "not " );
	
	uint8_t fwt = data[6]>>4;
	if ( fwt < 16 ){
		uint32_t etus = (32 << fwt);
		uint32_t fwt_time = (302 << fwt);
		PrintAndLog("Frame Wait Integer: %u - %u ETUs | %u µS", fwt, etus, fwt_time);
	} else {
		PrintAndLog("Frame Wait Integer: %u - RFU", fwt);
	}
	
	PrintAndLog(" App Data Code: Application is %s",(data[6]&4) ? "Standard" : "Proprietary");
	PrintAndLog(" Frame Options: NAD is %ssupported",(data[6]&2) ? "" : "not ");
	PrintAndLog(" Frame Options: CID is %ssupported",(data[6]&1) ? "" : "not ");
	PrintAndLog("Tag :");
	PrintAndLog("  Max Buf Length: %u (MBLI) %s", cid>>4, (cid & 0xF0) ? "" : "chained frames not supported");
	PrintAndLog("  CDI : %u", cid & 0x0f);
	return;
}

// get SRx chip model (from UID) // from ST Microelectronics
char *get_ST_Chip_Model(uint8_t data){
	static char model[20];
	char *retStr = model;
	memset(model,0, sizeof(model));

	switch (data) {
		case 0x0: sprintf(retStr, "SRIX4K (Special)"); break;
		case 0x2: sprintf(retStr, "SR176"); break;
		case 0x3: sprintf(retStr, "SRIX4K"); break;
		case 0x4: sprintf(retStr, "SRIX512"); break;
		case 0x6: sprintf(retStr, "SRI512"); break;
		case 0x7: sprintf(retStr, "SRI4K"); break;
		case 0xC: sprintf(retStr, "SRT512"); break;
		default : sprintf(retStr, "Unknown"); break;
	}
	return retStr;
}

// REMAKE:
int print_ST_Lock_info(uint8_t model){

	// PrintAndLog("Chip Write Protection Bits:");
	// // now interpret the data
	// switch (model){
		// case 0x0: //fall through (SRIX4K special)
		// case 0x3: //fall through (SRIx4K)
		// case 0x7: //             (SRI4K)
			// //only need data[3]
			// blk1 = 9;
			// PrintAndLog("   raw: %s", sprint_bin(data+3, 1));
			// PrintAndLog(" 07/08:%slocked", (data[3] & 1) ? " not " : " " );
			// for (uint8_t i = 1; i<8; i++){
				// PrintAndLog("    %02u:%slocked", blk1, (data[3] & (1 << i)) ? " not " : " " );
				// blk1++;
			// }
			// break;
		// case 0x4: //fall through (SRIX512)
		// case 0x6: //fall through (SRI512)
		// case 0xC: //             (SRT512)
			// //need data[2] and data[3]
			// blk1 = 0;
			// PrintAndLog("   raw: %s", sprint_bin(data+2, 2));
			// for (uint8_t b=2; b<4; b++){
				// for (uint8_t i=0; i<8; i++){
					// PrintAndLog("    %02u:%slocked", blk1, (data[b] & (1 << i)) ? " not " : " " );
					// blk1++;
				// }
			// }
			// break;
		// case 0x2: //             (SR176)
			// //need data[2]
			// blk1 = 0;
			// PrintAndLog("   raw: %s", sprint_bin(data+2, 1));
			// for (uint8_t i = 0; i<8; i++){
				// PrintAndLog(" %02u/%02u:%slocked", blk1, blk1+1, (data[2] & (1 << i)) ? " " : " not " );
				// blk1+=2;
			// }
			// break;
		// default:
			// return rawClose();
	// }
	return 1;
}

// print UID info from SRx chips (ST Microelectronics)
static void print_st_general_info(uint8_t *data, uint8_t len){
	//uid = first 8 bytes in data
	PrintAndLog(" UID: %s", sprint_hex(SwapEndian64(data,8,8), len));
	PrintAndLog(" MFG: %02X, %s", data[6], getTagInfo(data[6]));
	PrintAndLog("Chip: %02X, %s", data[5]>>2, get_ST_Chip_Model(data[5]>>2));
	return;
}

//05 00 00 = find one tag in field
//1d xx xx xx xx 00 08 01 00 = attrib xx=UID (resp 10 [f9 e0])
//a3 = ?  (resp 03 [e2 c2])
//02 = ?  (resp 02 [6a d3])
// 022b (resp 02 67 00 [29  5b])
// 0200a40400 (resp 02 67 00 [29 5b])
// 0200a4040c07a0000002480300 (resp 02 67 00 [29 5b])
// 0200a4040c07a0000002480200 (resp 02 67 00 [29 5b])
// 0200a4040006a0000000010100 (resp 02 6a 82 [4b 4c])
// 0200a4040c09d27600002545500200 (resp 02 67 00 [29 5b])
// 0200a404000cd2760001354b414e4d30310000 (resp 02 6a 82 [4b 4c])
// 0200a404000ca000000063504b43532d313500 (resp 02 6a 82 [4b 4c])
// 0200a4040010a000000018300301000000000000000000 (resp 02 6a 82 [4b 4c])
//03 = ?  (resp 03 [e3 c2])
//c2 = ?  (resp c2 [66 15])
//b2 = ?  (resp a3 [e9 67])		
//a2 = ?  (resp 02 [6a d3])

// 14b get and print Full Info (as much as we know)
bool HF14B_Std_Info(bool verbose){
	//add more info here
	return FALSE;
}

// SRx get and print full info (needs more info...)
bool HF14B_ST_Info(bool verbose){
	
	UsbCommand c = {CMD_ISO_14443B_COMMAND, {ISO14B_CONNECT | ISO14B_SELECT_SR | ISO14B_DISCONNECT, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	UsbCommand resp;

	if (!WaitForResponseTimeout(CMD_ACK, &resp, TIMEOUT)) {
		if (verbose) PrintAndLog("timeout while waiting for reply.");
		return FALSE;
    }

	iso14b_card_select_t card;
	memcpy(&card, (iso14b_card_select_t *)resp.d.asBytes, sizeof(iso14b_card_select_t));
	
	uint64_t status = resp.arg[0];	
	if ( status > 0 ) { 
		rawClose();
		return FALSE;
	}

	//add locking bit information here. uint8_t data[16] = {0x00};
	// uint8_t datalen = 2;
	// uint8_t resplen;
	// uint8_t	blk1;
	// data[0] = 0x08;

	//
	// if (model == 0x2) { //SR176 has special command:
		// data[1] = 0xf;
		// resplen = 4;			
	// } else {
		// data[1] = 0xff;
		// resplen = 6;
	// }

	// //std read cmd
	// if (HF14BCmdRaw(true, true, data, &datalen, false)==0) 
		// return rawClose();
	
	// if (datalen != resplen || !crc) return rawClose();
	//print_ST_Lock_info(data[5]>>2);
	rawClose();
	return TRUE;
}

// get and print all info known about any known 14b tag
bool HF14BInfo(bool verbose){

	// try std 14b (atqb)
	if (HF14B_Std_Info(verbose)) return TRUE;

	// try st 14b
	if (HF14B_ST_Info(verbose)) return TRUE;

	// try unknown 14b read commands (to be identified later)
	//   could be read of calypso, CEPAS, moneo, or pico pass.

	if (verbose) PrintAndLog("no 14443B tag found");
	return FALSE;
}

// menu command to get and print all info known about any known 14b tag
int CmdHF14Binfo(const char *Cmd){
	char cmdp = param_getchar(Cmd, 0);
	if (cmdp == 'h' || cmdp == 'H') return usage_hf_14b_info();
	
	bool verbose = !((cmdp == 's') || (cmdp == 'S'));
	return HF14BInfo(verbose);
}

bool HF14B_ST_Reader(bool verbose){

	bool isSuccess = FALSE;

	// SRx get and print general info about SRx chip from UID
	UsbCommand c = {CMD_ISO_14443B_COMMAND, {ISO14B_CONNECT | ISO14B_SELECT_SR | ISO14B_DISCONNECT, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	UsbCommand resp;
	
	if (!WaitForResponseTimeout(CMD_ACK, &resp, TIMEOUT)) {
		if (verbose) PrintAndLog("timeout while waiting for reply.");
		return FALSE;
    }

	
	iso14b_card_select_t card;
	memcpy(&card, (iso14b_card_select_t *)resp.d.asBytes, sizeof(iso14b_card_select_t));

	uint64_t status = resp.arg[0];

	switch( status ){
		case 0: 
			print_st_general_info(card.uid, card.uidlen);
			isSuccess = TRUE;
			break;
		case 1:
			if (verbose) PrintAndLog("iso14443-3 random chip id fail");
			break;
		case 2:
			if (verbose) PrintAndLog("iso14443-3 ATTRIB fail");
			break;
		case 3: 
			if (verbose) PrintAndLog("iso14443-3 CRC fail");
			break;
		default:
			if (verbose) PrintAndLog("iso14443b card select SRx failed");
			break;
	}
	
	rawClose();
	return isSuccess;		
}

bool HF14B_Std_Reader(bool verbose){

	bool isSuccess = FALSE;

	// 14b get and print UID only (general info) 
	UsbCommand c = {CMD_ISO_14443B_COMMAND, {ISO14B_CONNECT | ISO14B_SELECT_STD | ISO14B_DISCONNECT, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	UsbCommand resp;
	
	if (!WaitForResponseTimeout(CMD_ACK, &resp, TIMEOUT)) {
		if (verbose) PrintAndLog("timeout while waiting for reply.");
		return FALSE;
    }
	
	iso14b_card_select_t card;
	memcpy(&card, (iso14b_card_select_t *)resp.d.asBytes, sizeof(iso14b_card_select_t));
	
	uint64_t status = resp.arg[0];	
	
	switch( status ){
		case 0: 
			PrintAndLog(" UID    : %s", sprint_hex(card.uid, card.uidlen));
			PrintAndLog(" ATQB   : %s", sprint_hex(card.atqb, sizeof(card.atqb)));
			PrintAndLog(" CHIPID : %02X", card.chipid);
			print_atqb_resp(card.atqb, card.cid);
			isSuccess = TRUE;
			break;
		case 2:
			if (verbose) PrintAndLog("iso14443-3 ATTRIB fail");
			break;
		case 3: 
			if (verbose) PrintAndLog("iso14443-3 CRC fail");
			break;
		default:
			if (verbose) PrintAndLog("iso14443b card select failed");
			break;
	}
	
	rawClose();
	return isSuccess;	
}

// test for other 14b type tags (mimic another reader - don't have tags to identify)
bool HF14B_Other_Reader(){

	// uint8_t data[] = {0x00, 0x0b, 0x3f, 0x80};
	// uint8_t datalen = 4;

	// // 14b get and print UID only (general info) 
	// uint32_t flags = ISO14B_CONNECT | ISO14B_SELECT_STD | ISO14B_RAW | ISO14B_APPEND_CRC;
	
	// UsbCommand c = {CMD_ISO_14443B_COMMAND, {flags, datalen, 0}}; 
	// memcpy(c.d.asBytes, data, datalen);

	// clearCommandBuffer();
	// SendCommand(&c);
	// UsbCommand resp;
	// WaitForResponse(CMD_ACK,&resp);
	
	// if (datalen > 2 ) {
		// printandlog ("\n14443-3b tag found:");
		// printandlog ("unknown tag type answered to a 0x000b3f80 command ans:");
		// //printandlog ("%s", sprint_hex(data, datalen));
		// rawclose();
		// return true;
	// }

	// c.arg1 = 1;
	// c.d.asBytes[0] = ISO14443B_AUTHENTICATE;
	// clearCommandBuffer();
	// SendCommand(&c);
	// UsbCommand resp;
	// WaitForResponse(CMD_ACK, &resp);
	
	// if (datalen > 0) {
		// PrintAndLog ("\n14443-3b tag found:");
		// PrintAndLog ("Unknown tag type answered to a 0x0A command ans:");
		// // PrintAndLog ("%s", sprint_hex(data, datalen));
		// rawClose();
		// return TRUE;
	// }

	// c.arg1 = 1;
	// c.d.asBytes[0] = ISO14443B_RESET;
	// clearCommandBuffer();
	// SendCommand(&c);
	// UsbCommand resp;
	// WaitForResponse(CMD_ACK, &resp);

	// if (datalen > 0) {
		// PrintAndLog ("\n14443-3b tag found:");
		// PrintAndLog ("Unknown tag type answered to a 0x0C command ans:");
		// PrintAndLog ("%s", sprint_hex(data, datalen));
		// rawClose();
		// return TRUE;
	// }
	
	// rawClose();
	return FALSE;
}

// get and print general info about all known 14b chips
bool HF14BReader(bool verbose){
	
	// try std 14b (atqb)
	if (HF14B_Std_Reader(verbose)) return TRUE;

	// try ST Microelectronics 14b
	if (HF14B_ST_Reader(verbose)) return TRUE;

	// try unknown 14b read commands (to be identified later)
	//   could be read of calypso, CEPAS, moneo, or pico pass.
	if (HF14B_Other_Reader()) return TRUE;

	if (verbose) PrintAndLog("no 14443B tag found");
	return FALSE;
}

// menu command to get and print general info about all known 14b chips
int CmdHF14BReader(const char *Cmd){
	char cmdp = param_getchar(Cmd, 0);
	if (cmdp == 'h' || cmdp == 'H') return usage_hf_14b_reader();
	
	bool verbose = !((cmdp == 's') || (cmdp == 'S'));
	return HF14BReader(verbose);
}

/* New command to read the contents of a SRI512|SRIX4K tag
 * SRI* tags are ISO14443-B modulated memory tags,
 * this command just dumps the contents of the memory/
 */
int CmdHF14BReadSri(const char *Cmd){
 	char cmdp = param_getchar(Cmd, 0);
	if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') return usage_hf_14b_read_srx();

	uint8_t tagtype = param_get8(Cmd, 0);
	uint8_t blocks = (tagtype == 1) ? 0x7F : 0x0F;
	
	UsbCommand c = {CMD_READ_SRI_TAG, {blocks, 0, 0}};
	clearCommandBuffer();
	SendCommand(&c);
	return 0;
}
// New command to write a SRI512/SRIX4K tag.
int CmdHF14BWriteSri(const char *Cmd){
/*
 * For SRIX4K  blocks 00 - 7F
 * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
 *
 * For SR512  blocks 00 - 0F
 * hf 14b raw -c -p 09 $sr512wblock $sr512wdata
 * 
 * Special block FF =  otp_lock_reg block.
 * Data len 4 bytes-
 */
 	char cmdp = param_getchar(Cmd, 0);
	uint8_t blockno = -1;
	uint8_t data[4] = {0x00};
	bool isSrix4k = true;
	char str[30];	
	memset(str, 0x00, sizeof(str));

	if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') return usage_hf_14b_write_srx();

	if ( cmdp == '2' )
		isSrix4k = false;
	
	//blockno = param_get8(Cmd, 1);
	
	if ( param_gethex(Cmd, 1, &blockno, 2) ) {
		PrintAndLog("Block number must include 2 HEX symbols");
		return 0;
	}
	
	if ( isSrix4k ){
		if ( blockno > 0x7f && blockno != 0xff ){
			PrintAndLog("Block number out of range");
			return 0;
		}		
	} else {
		if ( blockno > 0x0f && blockno != 0xff ){
			PrintAndLog("Block number out of range");
			return 0;
		}		
	}
	
	if (param_gethex(Cmd, 2, data, 8)) {
		PrintAndLog("Data must include 8 HEX symbols");
		return 0;
	}
 
	if ( blockno == 0xff) {
		PrintAndLog("[%s] Write special block %02X [ %s ]",
			(isSrix4k) ? "SRIX4K":"SRI512",
			blockno,
			sprint_hex(data,4)
		);
	} else {
		PrintAndLog("[%s] Write block %02X [ %s ]",
			(isSrix4k) ? "SRIX4K":"SRI512",
			blockno, 
			sprint_hex(data,4)
		);
	}
	
	sprintf(str, "-ss -c %02x %02x %02x%02x%02x%02x", ISO14443B_WRITE_BLK, blockno, data[0], data[1], data[2], data[3]);
	CmdHF14BCmdRaw(str);
	return 0;
}

uint32_t srix4kEncode(uint32_t value) {
/*
// vv = value
// pp = position
//                vv vv vv pp 
4 bytes			: 00 1A 20 01
*/
	// only the lower crumbs.
	uint8_t block = (value & 0xFF);
	uint8_t i = 0;
	uint8_t valuebytes[] = {0,0,0};
		
	num_to_bytes(value, 3, valuebytes);
	
	// Scrambled part
	// Crumb swapping of value.
	uint8_t temp[] = {0,0};
	temp[0] = (CRUMB(value, 22) << 4 | CRUMB(value, 14 ) << 2 | CRUMB(value, 6)) << 4;
	temp[0] |= CRUMB(value, 20) << 4 | CRUMB(value, 12 ) << 2 | CRUMB(value, 4);
	temp[1] = (CRUMB(value, 18) << 4 | CRUMB(value, 10 ) << 2 | CRUMB(value, 2)) << 4;
	temp[1] |= CRUMB(value, 16) << 4 | CRUMB(value, 8  ) << 2 | CRUMB(value, 0);

	// chksum part
	uint32_t chksum = 0xFF - block;
	
	// chksum is reduced by each nibbles of value.
	for (i = 0; i < 3; ++i){
		chksum -= NIBBLE_HIGH(valuebytes[i]);
		chksum -= NIBBLE_LOW(valuebytes[i]);
	}

	// base4 conversion and left shift twice
	i = 3;
	uint8_t base4[] = {0,0,0,0};	
	while( chksum !=0 ){
        base4[i--] = (chksum % 4 << 2);
		chksum /= 4;
    }
	
	// merge scambled and chksum parts
	uint32_t encvalue = 
		( NIBBLE_LOW ( base4[0]) << 28 ) |
		( NIBBLE_HIGH( temp[0])  << 24 ) |
		
		( NIBBLE_LOW ( base4[1]) << 20 ) |
		( NIBBLE_LOW ( temp[0])  << 16 ) |
		
		( NIBBLE_LOW ( base4[2]) << 12 ) |
		( NIBBLE_HIGH( temp[1])  << 8 ) |
		
		( NIBBLE_LOW ( base4[3]) << 4 ) |
		  NIBBLE_LOW ( temp[1] );

	PrintAndLog("ICE encoded | %08X -> %08X", value, encvalue);
	return encvalue;
}
uint32_t srix4kDecode(uint32_t value) {
	switch(value) {
		case 0xC04F42C5: return 0x003139;
		case 0xC1484807: return 0x002943;
		case 0xC0C60848: return 0x001A20;
	}
	return 0;
}
uint32_t srix4kDecodeCounter(uint32_t num) {
	uint32_t value = ~num;
	++value;
	return value;
}

uint32_t srix4kGetMagicbytes( uint64_t uid, uint32_t block6, uint32_t block18, uint32_t block19 ){
#define MASK 0xFFFFFFFF;
	uint32_t uid32 = uid & MASK;
	uint32_t counter = srix4kDecodeCounter(block6);
	uint32_t decodedBlock18 = srix4kDecode(block18);
	uint32_t decodedBlock19 = srix4kDecode(block19);
	uint32_t doubleBlock = (decodedBlock18 << 16 | decodedBlock19) + 1;

	uint32_t result = (uid32 * doubleBlock * counter) & MASK;
	PrintAndLog("Magic bytes | %08X", result);
	return result;
}
int srix4kValid(const char *Cmd){

	uint64_t uid = 0xD00202501A4532F9;
	uint32_t block6 = 0xFFFFFFFF;
	uint32_t block18 = 0xC04F42C5;
	uint32_t block19 = 0xC1484807;
	uint32_t block21 = 0xD1BCABA4;
  
	uint32_t test_b18 = 0x00313918;
	uint32_t test_b18_enc = srix4kEncode(test_b18);
	//uint32_t test_b18_dec = srix4kDecode(test_b18_enc);
	PrintAndLog("ENCODE & CHECKSUM |  %08X -> %08X (%s)", test_b18, test_b18_enc , "");
	
	uint32_t magic = srix4kGetMagicbytes(uid, block6, block18, block19);
	PrintAndLog("BLOCK 21 |  %08X -> %08X (no XOR)", block21, magic ^ block21);
	return 0;
}

int CmdteaSelfTest(const char *Cmd){
	
	uint8_t v[8], v_le[8];
	memset(v, 0x00, sizeof(v));
	memset(v_le, 0x00, sizeof(v_le));
	uint8_t* v_ptr = v_le;

	uint8_t cmdlen = strlen(Cmd);
	cmdlen = ( sizeof(v)<<2 < cmdlen ) ? sizeof(v)<<2 : cmdlen;
	
	if ( param_gethex(Cmd, 0, v, cmdlen) > 0 ){
		PrintAndLog("can't read hex chars, uneven? :: %u", cmdlen);
		return 1;
	}
	
	SwapEndian64ex(v , 8, 4, v_ptr);
	
	// ENCRYPTION KEY:	
	uint8_t key[16] = {0x55,0xFE,0xF6,0x30,0x62,0xBF,0x0B,0xC1,0xC9,0xB3,0x7C,0x34,0x97,0x3E,0x29,0xFB };
	uint8_t keyle[16];
	uint8_t* key_ptr = keyle;
	SwapEndian64ex(key , sizeof(key), 4, key_ptr);
	
	PrintAndLog("TEST LE enc| %s", sprint_hex(v_ptr, 8));
	
	tea_decrypt(v_ptr, key_ptr);	
	PrintAndLog("TEST LE dec | %s", sprint_hex_ascii(v_ptr, 8));
	
	tea_encrypt(v_ptr, key_ptr);	
	tea_encrypt(v_ptr, key_ptr);
	PrintAndLog("TEST enc2 | %s", sprint_hex_ascii(v_ptr, 8));

	return 0;
}

bool waitCmd(bool verbose) {

	bool crc = FALSE;
	uint8_t b1 = 0, b2 = 0;
	uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
	uint8_t status = 0;
	uint16_t len = 0;	
    UsbCommand resp;

    if (WaitForResponseTimeout(CMD_ACK, &resp, TIMEOUT)) {

		status = (resp.arg[0] & 0xFFFF);
		if ( status > 0 ) return FALSE;
		
		len = (resp.arg[1] & 0xFFFF);
		memcpy(data, resp.d.asBytes, len);
		
		if (verbose) {
			
			ComputeCrc14443(CRC_14443_B, data, len-2, &b1, &b2);
			crc = ( data[len-2] == b1 && data[len-1] == b2);
			
			PrintAndLog("[LEN %u] %s[%02X %02X] %s",
				len,
				sprint_hex(data, len-2),
				data[len-2],
				data[len-1],
				(crc) ? "OK" : "FAIL"
			);
		}	
		return TRUE;
    } else {
        PrintAndLog("timeout while waiting for reply.");
		return FALSE;
    }
}

static command_t CommandTable[] = {
	{"help",        CmdHelp,        1, "This help"},
	{"info",        CmdHF14Binfo,   0, "Find and print details about a 14443B tag"},
	{"list",        CmdHF14BList,   0, "[Deprecated] List ISO 14443B history"},
	{"raw",         CmdHF14BCmdRaw, 0, "Send raw hex data to tag"},
	{"reader",      CmdHF14BReader, 0, "Act as a 14443B reader to identify a tag"},
	{"sim",         CmdHF14BSim,    0, "Fake ISO 14443B tag"},
	{"snoop",       CmdHF14BSnoop,  0, "Eavesdrop ISO 14443B"},
	{"sriread",		CmdHF14BReadSri,  0, "Read contents of a SRI512 | SRIX4K tag"},
	{"sriwrite",    CmdHF14BWriteSri, 0, "Write data to a SRI512 | SRIX4K tag"},
	//{"valid",   	srix4kValid,	1, "srix4k checksum test"},
	//{"valid",   	CmdteaSelfTest,	1, "tea test"},
	{NULL, NULL, 0, NULL}
};

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

int CmdHelp(const char *Cmd) {
	CmdsHelp(CommandTable);
	return 0;
}