git.zerfleddert.de Git - proxmark3-svn/blob - client/cmdhf14b.c

   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 // High frequency ISO14443B commands
   9 //-----------------------------------------------------------------------------
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <stdbool.h>
  14 #include <string.h>
  15 #include <stdint.h>
  16 #include "iso14443crc.h"
  17 #include "proxmark3.h"
  18 #include "data.h"
  19 #include "graph.h"
  20 #include "util.h"
  21 #include "ui.h"
  22 #include "cmdparser.h"
  23 #include "cmdhf14b.h"
  24 #include "cmdmain.h"
  25 #include "cmdhf14a.h"
  26
  27 static int CmdHelp(const char *Cmd);
  28
  29 int CmdHF14BList(const char *Cmd)
  30 {
  31         PrintAndLog("Deprecated command, use 'hf list 14b' instead");
  32
  33         return 0;
  34 }
  35
  36 int CmdHF14BSim(const char *Cmd)
  37 {
  38   UsbCommand c={CMD_SIMULATE_TAG_ISO_14443B};
  39   clearCommandBuffer();
  40   SendCommand(&c);
  41   return 0;
  42 }
  43
  44 int CmdHF14BSnoop(const char *Cmd)
  45 {
  46   UsbCommand c = {CMD_SNOOP_ISO_14443B};
  47   clearCommandBuffer();
  48   SendCommand(&c);
  49   return 0;
  50 }
  51
  52 /* New command to read the contents of a SRI512 tag
  53  * SRI512 tags are ISO14443-B modulated memory tags,
  54  * this command just dumps the contents of the memory
  55  */
  56 int CmdSri512Read(const char *Cmd)
  57 {
  58   UsbCommand c = {CMD_READ_SRI512_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
  59   clearCommandBuffer();
  60   SendCommand(&c);
  61   return 0;
  62 }
  63
  64 /* New command to read the contents of a SRIX4K tag
  65  * SRIX4K tags are ISO14443-B modulated memory tags,
  66  * this command just dumps the contents of the memory/
  67  */
  68 int CmdSrix4kRead(const char *Cmd)
  69 {
  70   UsbCommand c = {CMD_READ_SRIX4K_TAG, {strtol(Cmd, NULL, 0), 0, 0}};
  71   clearCommandBuffer();
  72   SendCommand(&c);
  73   return 0;
  74 }
  75
  76 int rawClose(void){
  77         UsbCommand resp;
  78         UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}};
  79         clearCommandBuffer();
  80         SendCommand(&c);
  81         if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
  82                 return 0;
  83         }
  84         return 0;
  85 }
  86
  87 int HF14BCmdRaw(bool reply, bool *crc, bool power, uint8_t *data, uint8_t *datalen, bool verbose){
  88         UsbCommand resp;
  89         UsbCommand c = {CMD_ISO_14443B_COMMAND, {0, 0, 0}}; // len,recv,power
  90         if(*crc)
  91         {
  92                 uint8_t first, second;
  93                 ComputeCrc14443(CRC_14443_B, data, *datalen, &first, &second);
  94                 data[*datalen] = first;
  95                 data[*datalen + 1] = second;
  96                 *datalen += 2;
  97         }
  98
  99         c.arg[0] = *datalen;
 100         c.arg[1] = reply;
 101         c.arg[2] = power;
 102         memcpy(c.d.asBytes,data,*datalen);
 103         clearCommandBuffer();
 104         SendCommand(&c);
 105
 106         if (!reply) return 1;
 107
 108         if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
 109                 if (verbose) PrintAndLog("timeout while waiting for reply.");
 110                 return 0;
 111         }
 112         *datalen = resp.arg[0];
 113         if (verbose) PrintAndLog("received %u octets", *datalen);
 114         if(*datalen<2) return 0;
 115
 116         memcpy(data, resp.d.asBytes, *datalen);
 117         if (verbose) PrintAndLog("%s", sprint_hex(data, *datalen));
 118
 119         uint8_t first, second;
 120         ComputeCrc14443(CRC_14443_B, data, *datalen-2, &first, &second);
 121         if(data[*datalen-2] == first && data[*datalen-1] == second) {
 122                 if (verbose) PrintAndLog("CRC OK");
 123                 *crc = true;
 124         } else {
 125                 if (verbose) PrintAndLog("CRC failed");
 126                 *crc = false;
 127         }
 128         return 1;
 129 }
 130
 131 int CmdHF14BCmdRaw (const char *Cmd) {
 132         bool reply = true;
 133         bool crc = false;
 134         bool power = false;
 135         bool select = false;
 136         char buf[5] = "";
 137         uint8_t data[100] = {0x00};
 138         uint8_t datalen = 0;
 139         unsigned int temp;
 140         int i = 0;
 141         if (strlen(Cmd)<3) {
 142                         PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] <0A 0B 0C ... hex>");
 143                         PrintAndLog("       -r    do not read response");
 144                         PrintAndLog("       -c    calculate and append CRC");
 145                         PrintAndLog("       -p    leave the field on after receive");
 146                         PrintAndLog("       -s    active signal field ON with select");
 147                         return 0;
 148         }
 149
 150         // strip
 151         while (*Cmd==' ' || *Cmd=='\t') Cmd++;
 152
 153         while (Cmd[i]!='\0') {
 154                 if (Cmd[i]==' ' || Cmd[i]=='\t') { i++; continue; }
 155                 if (Cmd[i]=='-') {
 156                         switch (Cmd[i+1]) {
 157                                 case 'r':
 158                                 case 'R':
 159                                         reply = false;
 160                                         break;
 161                                 case 'c':
 162                                 case 'C':
 163                                         crc = true;
 164                                         break;
 165                                 case 'p':
 166                                 case 'P':
 167                                         power = true;
 168                                         break;
 169                                 case 's':
 170                                 case 'S':
 171                                         select = true;
 172                                         break;
 173                                 default:
 174                                         PrintAndLog("Invalid option");
 175                                         return 0;
 176                         }
 177                         i+=2;
 178                         continue;
 179                 }
 180                 if ((Cmd[i]>='0' && Cmd[i]<='9') ||
 181                     (Cmd[i]>='a' && Cmd[i]<='f') ||
 182                     (Cmd[i]>='A' && Cmd[i]<='F') ) {
 183                         buf[strlen(buf)+1]=0;
 184                         buf[strlen(buf)]=Cmd[i];
 185                         i++;
 186
 187                         if (strlen(buf)>=2) {
 188                                 sscanf(buf,"%x",&temp);
 189                                 data[datalen++]=(uint8_t)(temp & 0xff);
 190                                 *buf=0;
 191                         }
 192                         continue;
 193                 }
 194                 PrintAndLog("Invalid char on input");
 195                 return 1;
 196         }
 197         if (datalen == 0)
 198         {
 199                 PrintAndLog("Missing data input");
 200                 return 0;
 201         }
 202
 203         if (select){ //auto select 14b tag
 204                 uint8_t cmd2[16];
 205                 uint8_t cmdLen = 3;
 206                 bool crc2 = true;
 207                 cmd2[0] = 0x05;
 208                 cmd2[1] = 0x00;
 209                 cmd2[2] = 0x08;
 210
 211                 // REQB
 212                 if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false)==0) return rawClose();
 213
 214                 if (cmd2[0] != 0x50 || cmdLen != 14 || !crc2) return rawClose();
 215
 216                 cmd2[0] = 0x1D;
 217                 // UID from data[1 - 4]
 218                 cmd2[5] = 0x00;
 219                 cmd2[6] = 0x08;
 220                 cmd2[7] = 0x01;
 221                 cmd2[8] = 0x00;
 222                 cmdLen = 9;
 223
 224                 // attrib
 225                 if (HF14BCmdRaw(true, &crc2, true, cmd2, &cmdLen, false)==0) return rawClose();
 226
 227                 if (cmd2[0] != 0x10 || cmdLen != 3 || !crc2) return rawClose();
 228         }
 229
 230         return HF14BCmdRaw(reply, &crc, power, data, &datalen, true);
 231 }
 232
 233 // print full atqb info
 234 static void print_atqb_resp(uint8_t *data){
 235         PrintAndLog ("           UID: %s", sprint_hex(data+1,4));
 236         PrintAndLog ("      App Data: %s", sprint_hex(data+5,4));
 237         PrintAndLog ("      Protocol: %s", sprint_hex(data+9,3));
 238         uint8_t BitRate = data[9];
 239         if (!BitRate)
 240                 PrintAndLog ("      Bit Rate: 106 kbit/s only PICC <-> PCD");
 241         if (BitRate & 0x10)
 242                 PrintAndLog ("      Bit Rate: 212 kbit/s PICC -> PCD supported");
 243         if (BitRate & 0x20)
 244                 PrintAndLog ("      Bit Rate: 424 kbit/s PICC -> PCD supported");
 245         if (BitRate & 0x40)
 246                 PrintAndLog ("      Bit Rate: 847 kbit/s PICC -> PCD supported");
 247         if (BitRate & 0x01)
 248                 PrintAndLog ("      Bit Rate: 212 kbit/s PICC <- PCD supported");
 249         if (BitRate & 0x02)
 250                 PrintAndLog ("      Bit Rate: 424 kbit/s PICC <- PCD supported");
 251         if (BitRate & 0x04)
 252                 PrintAndLog ("      Bit Rate: 847 kbit/s PICC <- PCD supported");
 253         if (BitRate & 0x80)
 254                 PrintAndLog ("                Same bit rate <-> required");
 255
 256         uint16_t maxFrame = data[10]>>4;
 257         if (maxFrame < 5)
 258                 maxFrame = 8*maxFrame + 16;
 259         else if (maxFrame == 5)
 260                 maxFrame = 64;
 261         else if (maxFrame == 6)
 262                 maxFrame = 96;
 263         else if (maxFrame == 7)
 264                 maxFrame = 128;
 265         else if (maxFrame == 8)
 266                 maxFrame = 256;
 267         else
 268                 maxFrame = 257;
 269
 270         PrintAndLog ("Max Frame Size: %d%s",maxFrame, (maxFrame == 257) ? "+ RFU" : "");
 271
 272         uint8_t protocolT = data[10] & 0xF;
 273         PrintAndLog (" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT) ? "" : "not " );
 274         PrintAndLog ("Frame Wait Int: %d", data[11]>>4);
 275         PrintAndLog (" App Data Code: Application is %s",(data[11]&4) ? "Standard" : "Proprietary");
 276         PrintAndLog (" Frame Options: NAD is %ssupported",(data[11]&2) ? "" : "not ");
 277         PrintAndLog (" Frame Options: CID is %ssupported",(data[11]&1) ? "" : "not ");
 278
 279         return;
 280 }
 281
 282 // get SRx chip model (from UID) // from ST Microelectronics
 283 char *get_ST_Chip_Model(uint8_t data){
 284         static char model[20];
 285         char *retStr = model;
 286         memset(model,0, sizeof(model));
 287
 288         switch (data) {
 289                 case 0x0: sprintf(retStr, "SRIX4K (Special)"); break;
 290                 case 0x2: sprintf(retStr, "SR176"); break;
 291                 case 0x3: sprintf(retStr, "SRIX4K"); break;
 292                 case 0x4: sprintf(retStr, "SRIX512"); break;
 293                 case 0x6: sprintf(retStr, "SRI512"); break;
 294                 case 0x7: sprintf(retStr, "SRI4K"); break;
 295                 case 0xC: sprintf(retStr, "SRT512"); break;
 296                 default : sprintf(retStr, "Unknown"); break;
 297         }
 298         return retStr;
 299 }
 300
 301 int print_ST_Lock_info(uint8_t model){
 302         //assume connection open and tag selected...
 303         uint8_t data[16] = {0x00};
 304         uint8_t datalen = 2;
 305         bool crc = true;
 306         uint8_t resplen;
 307         uint8_t blk1;
 308         data[0] = 0x08;
 309
 310         if (model == 0x2) { //SR176 has special command:
 311                 data[1] = 0xf;
 312                 resplen = 4;
 313         } else {
 314                 data[1] = 0xff;
 315                 resplen = 6;
 316         }
 317
 318         //std read cmd
 319         if (HF14BCmdRaw(true, &crc, true, data, &datalen, false)==0) return rawClose();
 320
 321         if (datalen != resplen || !crc) return rawClose();
 322
 323         PrintAndLog("Chip Write Protection Bits:");
 324         // now interpret the data
 325         switch (model){
 326                 case 0x0: //fall through (SRIX4K special)
 327                 case 0x3: //fall through (SRIx4K)
 328                 case 0x7: //             (SRI4K)
 329                         //only need data[3]
 330                         blk1 = 9;
 331                         PrintAndLog("   raw: %s",printBits(1,data+3));
 332                         PrintAndLog(" 07/08:%slocked", (data[3] & 1) ? " not " : " " );
 333                         for (uint8_t i = 1; i<8; i++){
 334                                 PrintAndLog("    %02u:%slocked", blk1, (data[3] & (1 << i)) ? " not " : " " );
 335                                 blk1++;
 336                         }
 337                         break;
 338                 case 0x4: //fall through (SRIX512)
 339                 case 0x6: //fall through (SRI512)
 340                 case 0xC: //             (SRT512)
 341                         //need data[2] and data[3]
 342                         blk1 = 0;
 343                         PrintAndLog("   raw: %s",printBits(2,data+2));
 344                         for (uint8_t b=2; b<4; b++){
 345                                 for (uint8_t i=0; i<8; i++){
 346                                         PrintAndLog("    %02u:%slocked", blk1, (data[b] & (1 << i)) ? " not " : " " );
 347                                         blk1++;
 348                                 }
 349                         }
 350                         break;
 351                 case 0x2: //             (SR176)
 352                         //need data[2]
 353                         blk1 = 0;
 354                         PrintAndLog("   raw: %s",printBits(1,data+2));
 355                         for (uint8_t i = 0; i<8; i++){
 356                                 PrintAndLog(" %02u/%02u:%slocked", blk1, blk1+1, (data[2] & (1 << i)) ? " " : " not " );
 357                                 blk1+=2;
 358                         }
 359                         break;
 360                 default:
 361                         return rawClose();
 362         }
 363         return 1;
 364 }
 365
 366 // print UID info from SRx chips (ST Microelectronics)
 367 static void print_st_general_info(uint8_t *data){
 368         //uid = first 8 bytes in data
 369         PrintAndLog("   UID: %s", sprint_hex(SwapEndian64(data,8,8),8));
 370         PrintAndLog("   MFG: %02X, %s", data[6], getTagInfo(data[6]));
 371         PrintAndLog("  Chip: %02X, %s", data[5]>>2, get_ST_Chip_Model(data[5]>>2));
 372         return;
 373 }
 374
 375 // 14b get and print UID only (general info)
 376 int HF14BStdReader(uint8_t *data, uint8_t *datalen){
 377         //05 00 00 = find one tag in field
 378         //1d xx xx xx xx 00 08 01 00 = attrib xx=UID (resp 10 [f9 e0])
 379         //a3 = ?  (resp 03 [e2 c2])
 380         //02 = ?  (resp 02 [6a d3])
 381         // 022b (resp 02 67 00 [29  5b])
 382         // 0200a40400 (resp 02 67 00 [29 5b])
 383         // 0200a4040c07a0000002480300 (resp 02 67 00 [29 5b])
 384         // 0200a4040c07a0000002480200 (resp 02 67 00 [29 5b])
 385         // 0200a4040006a0000000010100 (resp 02 6a 82 [4b 4c])
 386         // 0200a4040c09d27600002545500200 (resp 02 67 00 [29 5b])
 387         // 0200a404000cd2760001354b414e4d30310000 (resp 02 6a 82 [4b 4c])
 388         // 0200a404000ca000000063504b43532d313500 (resp 02 6a 82 [4b 4c])
 389         // 0200a4040010a000000018300301000000000000000000 (resp 02 6a 82 [4b 4c])
 390         //03 = ?  (resp 03 [e3 c2])
 391         //c2 = ?  (resp c2 [66 15])
 392         //b2 = ?  (resp a3 [e9 67])
 393         bool crc = true;
 394         *datalen = 3;
 395         //std read cmd
 396         data[0] = 0x05;
 397         data[1] = 0x00;
 398         data[2] = 0x08;
 399
 400         if (HF14BCmdRaw(true, &crc, false, data, datalen, false)==0) return 0;
 401
 402         if (data[0] != 0x50 || *datalen != 14 || !crc) return 0;
 403
 404         PrintAndLog ("\n14443-3b tag found:");
 405         PrintAndLog ("           UID: %s", sprint_hex(data+1,4));
 406
 407         return 1;
 408 }
 409
 410 // 14b get and print Full Info (as much as we know)
 411 int HF14BStdInfo(uint8_t *data, uint8_t *datalen){
 412         if (!HF14BStdReader(data,datalen)) return 0;
 413
 414         //add more info here
 415         print_atqb_resp(data);
 416
 417         return 1;
 418 }
 419
 420 // SRx get and print general info about SRx chip from UID
 421 int HF14B_ST_Reader(uint8_t *data, uint8_t *datalen, bool closeCon){
 422         bool crc = true;
 423         *datalen = 2;
 424         //wake cmd
 425         data[0] = 0x06;
 426         data[1] = 0x00;
 427
 428         //leave power on
 429         // verbose on for now for testing - turn off when functional
 430         if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose();
 431
 432         if (*datalen != 3 || !crc) return rawClose();
 433
 434         uint8_t chipID = data[0];
 435         // select
 436         data[0] = 0x0E;
 437         data[1] = chipID;
 438         *datalen = 2;
 439
 440         //leave power on
 441         if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose();
 442
 443         if (*datalen != 3 || !crc || data[0] != chipID) return rawClose();
 444
 445         // get uid
 446         data[0] = 0x0B;
 447         *datalen = 1;
 448
 449         //leave power on
 450         if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose();
 451
 452         if (*datalen != 10 || !crc) return rawClose();
 453
 454         //power off ?
 455         if (closeCon) rawClose();
 456
 457         PrintAndLog("\n14443-3b ST tag found:");
 458         print_st_general_info(data);
 459         return 1;
 460 }
 461
 462 // SRx get and print full info (needs more info...)
 463 int HF14B_ST_Info(uint8_t *data, uint8_t *datalen){
 464         if (!HF14B_ST_Reader(data, datalen, false)) return 0;
 465
 466         //add locking bit information here.
 467         if (print_ST_Lock_info(data[5]>>2))
 468                 rawClose();
 469
 470         return 1;
 471 }
 472
 473 // test for other 14b type tags (mimic another reader - don't have tags to identify)
 474 int HF14B_Other_Reader(uint8_t *data, uint8_t *datalen){
 475         bool crc = true;
 476         *datalen = 4;
 477         //std read cmd
 478         data[0] = 0x00;
 479         data[1] = 0x0b;
 480         data[2] = 0x3f;
 481         data[3] = 0x80;
 482
 483         if (HF14BCmdRaw(true, &crc, true, data, datalen, false)!=0) {
 484                 if (*datalen > 2 || !crc) {
 485                         PrintAndLog ("\n14443-3b tag found:");
 486                         PrintAndLog ("Unknown tag type answered to a 0x000b3f80 command ans:");
 487                         PrintAndLog ("%s",sprint_hex(data,*datalen));
 488                         rawClose();
 489                         return 1;
 490                 }
 491         }
 492
 493         crc = false;
 494         *datalen = 1;
 495         data[0] = 0x0a;
 496
 497         if (HF14BCmdRaw(true, &crc, true, data, datalen, false)!=0) {
 498                 if (*datalen > 0) {
 499                         PrintAndLog ("\n14443-3b tag found:");
 500                         PrintAndLog ("Unknown tag type answered to a 0x0A command ans:");
 501                         PrintAndLog ("%s",sprint_hex(data,*datalen));
 502                         rawClose();
 503                         return 1;
 504                 }
 505         }
 506
 507         crc = false;
 508         *datalen = 1;
 509         data[0] = 0x0c;
 510
 511         if (HF14BCmdRaw(true, &crc, true, data, datalen, false)!=0) {
 512                 if (*datalen > 0) {
 513                         PrintAndLog ("\n14443-3b tag found:");
 514                         PrintAndLog ("Unknown tag type answered to a 0x0C command ans:");
 515                         PrintAndLog ("%s",sprint_hex(data,*datalen));
 516                         rawClose();
 517                         return 1;
 518                 }
 519         }
 520         rawClose();
 521         return 0;
 522 }
 523
 524 // get and print all info known about any known 14b tag
 525 int HF14BInfo(bool verbose){
 526         uint8_t data[100];
 527         uint8_t datalen = 5;
 528
 529         // try std 14b (atqb)
 530         if (HF14BStdInfo(data, &datalen)) return 1;
 531
 532         // try st 14b
 533         if (HF14B_ST_Info(data, &datalen)) return 1;
 534
 535         // try unknown 14b read commands (to be identified later)
 536         //   could be read of calypso, CEPAS, moneo, or pico pass.
 537         if (HF14B_Other_Reader(data, &datalen)) return 1;
 538
 539         if (verbose) PrintAndLog("no 14443B tag found");
 540         return 0;
 541 }
 542
 543 // menu command to get and print all info known about any known 14b tag
 544 int CmdHF14Binfo(const char *Cmd){
 545         return HF14BInfo(true);
 546 }
 547
 548 // get and print general info about all known 14b chips
 549 int HF14BReader(bool verbose){
 550         uint8_t data[100];
 551         uint8_t datalen = 5;
 552
 553         // try std 14b (atqb)
 554         if (HF14BStdReader(data, &datalen)) return 1;
 555
 556         // try st 14b
 557         if (HF14B_ST_Reader(data, &datalen, true)) return 1;
 558
 559         // try unknown 14b read commands (to be identified later)
 560         //   could be read of calypso, CEPAS, moneo, or pico pass.
 561         if (HF14B_Other_Reader(data, &datalen)) return 1;
 562
 563         if (verbose) PrintAndLog("no 14443B tag found");
 564         return 0;
 565 }
 566
 567 // menu command to get and print general info about all known 14b chips
 568 int CmdHF14BReader(const char *Cmd){
 569         return HF14BReader(true);
 570 }
 571
 572 int CmdSriWrite( const char *Cmd){
 573 /*
 574  * For SRIX4K  blocks 00 - 7F
 575  * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
 576  *
 577  * For SR512  blocks 00 - 0F
 578  * hf 14b raw -c -p 09 $sr512wblock $sr512wdata
 579  *
 580  * Special block FF =  otp_lock_reg block.
 581  * Data len 4 bytes-
 582  */
 583         char cmdp = param_getchar(Cmd, 0);
 584         uint8_t blockno = -1;
 585         uint8_t data[4] = {0x00};
 586         bool isSrix4k = true;
 587         char str[20];
 588
 589         if (strlen(Cmd) < 1 || cmdp == 'h' || cmdp == 'H') {
 590                 PrintAndLog("Usage:  hf 14b write <1|2> <BLOCK> <DATA>");
 591                 PrintAndLog("    [1 = SRIX4K]");
 592                 PrintAndLog("    [2 = SRI512]");
 593                 PrintAndLog("    [BLOCK number depends on tag, special block == FF]");
 594                 PrintAndLog("     sample: hf 14b write 1 7F 11223344");
 595                 PrintAndLog("           : hf 14b write 1 FF 11223344");
 596                 PrintAndLog("           : hf 14b write 2 15 11223344");
 597                 PrintAndLog("           : hf 14b write 2 FF 11223344");
 598                 return 0;
 599         }
 600
 601         if ( cmdp == '2' )
 602                 isSrix4k = false;
 603
 604         //blockno = param_get8(Cmd, 1);
 605
 606         if ( param_gethex(Cmd,1, &blockno, 2) ) {
 607                 PrintAndLog("Block number must include 2 HEX symbols");
 608                 return 0;
 609         }
 610
 611         if ( isSrix4k ){
 612                 if ( blockno > 0x7f && blockno != 0xff ){
 613                         PrintAndLog("Block number out of range");
 614                         return 0;
 615                 }
 616         } else {
 617                 if ( blockno > 0x0f && blockno != 0xff ){
 618                         PrintAndLog("Block number out of range");
 619                         return 0;
 620                 }
 621         }
 622
 623         if (param_gethex(Cmd, 2, data, 8)) {
 624                 PrintAndLog("Data must include 8 HEX symbols");
 625                 return 0;
 626         }
 627
 628         if ( blockno == 0xff)
 629                 PrintAndLog("[%s] Write special block %02X [ %s ]", (isSrix4k)?"SRIX4K":"SRI512" , blockno,  sprint_hex(data,4) );
 630         else
 631                 PrintAndLog("[%s] Write block %02X [ %s ]", (isSrix4k)?"SRIX4K":"SRI512", blockno,  sprint_hex(data,4) );
 632
 633         sprintf(str, "-c 09 %02x %02x%02x%02x%02x", blockno, data[0], data[1], data[2], data[3]);
 634
 635         CmdHF14BCmdRaw(str);
 636         return 0;
 637 }
 638
 639 static command_t CommandTable[] =
 640 {
 641   {"help",        CmdHelp,        1, "This help"},
 642   {"info",        CmdHF14Binfo,   0, "Find and print details about a 14443B tag"},
 643   {"list",        CmdHF14BList,   0, "[Deprecated] List ISO 14443B history"},
 644   {"reader",      CmdHF14BReader, 0, "Act as a 14443B reader to identify a tag"},
 645   {"sim",         CmdHF14BSim,    0, "Fake ISO 14443B tag"},
 646   {"snoop",       CmdHF14BSnoop,  0, "Eavesdrop ISO 14443B"},
 647   {"sri512read",  CmdSri512Read,  0, "Read contents of a SRI512 tag"},
 648   {"srix4kread",  CmdSrix4kRead,  0, "Read contents of a SRIX4K tag"},
 649   {"sriwrite",    CmdSriWrite,    0, "Write data to a SRI512 | SRIX4K tag"},
 650   {"raw",         CmdHF14BCmdRaw, 0, "Send raw hex data to tag"},
 651   {NULL, NULL, 0, NULL}
 652 };
 653
 654 int CmdHF14B(const char *Cmd)
 655 {
 656   CmdsParse(CommandTable, Cmd);
 657   return 0;
 658 }
 659
 660 int CmdHelp(const char *Cmd)
 661 {
 662   CmdsHelp(CommandTable);
 663   return 0;
 664 }