plugins/mifare.c

   1 /*
   2  *
   3  *  neard - Near Field Communication manager
   4  *
   5  *  Copyright (C) 2012  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdint.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <sys/socket.h>
  30
  31 #include <linux/socket.h>
  32 #include <linux/nfc.h>
  33
  34 #include <near/plugin.h>
  35 #include <near/log.h>
  36 #include <near/types.h>
  37 #include <near/adapter.h>
  38 #include <near/target.h>
  39 #include <near/tag.h>
  40 #include <near/ndef.h>
  41 #include <near/tlv.h>
  42
  43 /* NXP Application Notes:
  44  * AN1304, AN1305, ...
  45  * http://www.nxp.com/technical-support-portal/53420/71108/application-notes
  46  * */
  47
  48 /* Prototype */
  49 int mifare_read_tag(uint32_t adapter_idx, uint32_t target_idx,
  50                 near_tag_io_cb cb, enum near_tag_sub_type tgt_subtype);
  51
  52 /* MIFARE command set */
  53 #define MF_CMD_WRITE            0xA2
  54 #define MF_CMD_READ             0x30
  55 #define MF_CMD_AUTH_KEY_A       0x60
  56
  57 #define NFC_AID_TAG             0xE103
  58
  59 /* Define boundaries for 1K / 2K / 4K
  60  * 1K:   sector 0 to 15 (3 blocks each + trailer block )
  61  * 2K:   sector 0 to 31 (3 blocks each + trailer block )
  62  * 4K:   sector 0 to 31 (3 blocks each + trailer block )
  63  *      and sector 32 to 39 (15 blocks each + trailer block )
  64  * */
  65 #define DEFAULT_BLOCK_SIZE      16      /* MF_CMD_READ */
  66
  67 #define STD_BLK_SECT_TRAILER    4       /* bl per sect with trailer 1K/2K */
  68 #define EXT_BLK_SECT_TRAILER    16      /* bl per sect with trailer 4K */
  69
  70 #define STD_BLK_PER_SECT        3       /* 1 sect == 3blocks */
  71 #define EXT_BLK_PER_SECT        15      /* for 4K tags */
  72
  73 /* Usual sector size, including trailer */
  74 #define STD_SECTOR_SIZE         (4 * DEFAULT_BLOCK_SIZE)        /* 00-31 */
  75 #define EXT_SECTOR_SIZE         (16 * DEFAULT_BLOCK_SIZE)       /* 32-39 */
  76
  77 /* Usual sector size, without trailer */
  78 #define SECTOR_SIZE             (3 * DEFAULT_BLOCK_SIZE)
  79 #define BIG_SECTOR_SIZE         (15 * DEFAULT_BLOCK_SIZE)
  80
  81 #define T4K_BOUNDARY            32
  82 #define T4K_BLK_OFF             0x80    /* blocks count before sector 32 */
  83
  84 #define NO_TRAILER      0
  85 #define WITH_TRAILER    1
  86 #define SECT_IS_NFC     1
  87
  88 /* Default MAD keys. Key length = 6 bytes */
  89 #define MAD_KEY_LEN     6
  90 static uint8_t MAD_public_key[] = {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5};
  91 static uint8_t MAD_NFC_key[] = {0xd3, 0xf7, 0xd3, 0xf7, 0xd3, 0xf7};
  92
  93 #define MAD1_SECTOR             0x00    /* Sector 0 is for MAD1 */
  94 #define MAD1_1ST_BLOCK          0x00    /* 1st block of sector 0 */
  95 #define MAD2_GPB_BITS           0x02    /* MAD v2 flag */
  96
  97 #define MAD2_SECTOR             0x10    /* Sector 0 is for MAD2 */
  98 #define MAD2_1ST_BLOCK          0x40    /* 1st block of MAD2 */
  99
 100 #define MAD_V1_AIDS_LEN         15      /* 1 to 0x0F */
 101 #define MAD_V2_AIDS_LEN         23      /*0x11 to 0x27 */
 102
 103 /* MAD1 sector structure. Start at block 0x00 */
 104 struct MAD_1 {
 105         uint8_t man_info[16];
 106         uint16_t crc_dir;
 107         uint16_t aids[MAD_V1_AIDS_LEN];
 108         /* Trailer */
 109         uint8_t key_A[MAD_KEY_LEN];
 110         uint8_t access_cond[3];
 111         uint8_t GPB;
 112         uint8_t key_B[MAD_KEY_LEN];
 113 } __attribute__((packed));
 114
 115 /* MAD2 sector structure. Start at block 0x40 */
 116 struct MAD_2 {
 117         uint16_t crc_dir;
 118         uint16_t aids[MAD_V2_AIDS_LEN];
 119         /* Trailer */
 120         uint8_t key_A[MAD_KEY_LEN];
 121         uint8_t access_cond[3];
 122         uint8_t GPB;
 123         uint8_t key_B[MAD_KEY_LEN];
 124 } __attribute__((packed));
 125
 126 struct mifare_cookie {
 127         uint32_t adapter_idx;
 128         uint32_t target_idx;
 129         uint8_t *nfcid1;
 130         uint8_t nfcid1_len;
 131
 132         struct near_tag *tag;
 133         near_tag_io_cb cb;
 134         near_recv next_far_func;
 135
 136         /* For MAD access */
 137         struct MAD_1 *mad_1;
 138         struct MAD_2 *mad_2;
 139         GSList *g_sect_list;            /* Global sectors list */
 140
 141         /* For read functions */
 142         near_recv rs_next_fct;          /* next function */
 143         int rs_block_start;             /* first block */
 144         int rs_block_end;               /* last block */
 145         int rs_completed;               /* read blocks */
 146         int rs_length;                  /* read length */
 147         uint8_t *rs_pmem;               /* Stored read sector */
 148         int rs_max_length;              /* available size */
 149         uint8_t *nfc_data;
 150         int nfc_data_length;
 151 };
 152
 153 struct type2_cmd {
 154         uint8_t cmd;
 155         uint8_t block;
 156         uint8_t data[];
 157 } __attribute__((packed));
 158
 159 struct mifare_cmd {
 160         uint8_t cmd;
 161         uint8_t block;
 162         uint8_t key[MAD_KEY_LEN];
 163         uint8_t nfcid[NFC_NFCID1_MAXSIZE];
 164 } __attribute__((packed));
 165
 166 /* Common free func */
 167 static int mifare_release(int err, struct mifare_cookie *cookie)
 168 {
 169         DBG("%p", cookie);
 170
 171         if (cookie == NULL)
 172                 return err;
 173
 174         if (err < 0 && cookie->cb) {
 175                 cookie->cb(cookie->adapter_idx, cookie->target_idx, err);
 176                 near_adapter_disconnect(cookie->adapter_idx);
 177         }
 178
 179         /* Now free allocs */
 180         g_free(cookie->nfcid1);
 181         g_slist_free(cookie->g_sect_list);
 182         g_free(cookie->mad_1);
 183         g_free(cookie->mad_2);
 184         g_free(cookie);
 185         cookie = NULL;
 186
 187         return err;
 188 }
 189
 190 /* Mifare_generic MAD unlock block function
 191  * This function send unlock code to the tag, and so, allow access
 192  * to the complete related sector.
 193  */
 194 static int mifare_unlock_sector(int block_id,
 195                                 near_recv next_far_fct,
 196                                 void *data)
 197 {
 198         struct mifare_cmd cmd;
 199         struct mifare_cookie *cookie = data;
 200         uint8_t *key_ref;
 201
 202         /* For MADs sectors we use public key A (a0a1a2a3a4a5) but
 203          * for NFC sectors we use NFC_KEY_A (d3f7d3f7d3f7)
 204          *  */
 205         if ((block_id == MAD1_1ST_BLOCK) || (block_id == MAD2_1ST_BLOCK))
 206                 key_ref = MAD_public_key;
 207         else
 208                 key_ref = MAD_NFC_key;
 209
 210          /* CMD AUTHENTICATION */
 211         cmd.cmd = MF_CMD_AUTH_KEY_A;
 212
 213         /* We want to authenticate the 1st bloc of the sector */
 214         cmd.block = block_id;
 215
 216         /* Store the AUTH KEY */
 217         memcpy(&cmd.key, key_ref, MAD_KEY_LEN);
 218
 219         /* add the UID */
 220         memcpy(&cmd.nfcid, cookie->nfcid1, cookie->nfcid1_len);
 221
 222         return near_adapter_send(cookie->adapter_idx, (uint8_t *)&cmd,
 223                 sizeof(cmd) - NFC_NFCID1_MAXSIZE + cookie->nfcid1_len,
 224                 next_far_fct,
 225                 cookie);
 226 }
 227
 228 /* Common MIFARE Bloc read:
 229  * Each call will read 16 bytes from tag... so to read 1 sector,
 230  * we must call it 4 times or 16 times (minus 1 or not for the trailer block)
 231  *
 232  * data: mifare_cookie *mf_ck
 233  * mf_ck->read_block: block number to read
 234  * */
 235 static int mifare_read_block(uint8_t block_id,
 236                                 void *data,
 237                                 near_recv far_func)
 238 {
 239         struct type2_cmd cmd;
 240         struct mifare_cookie *mf_ck = data;
 241
 242         cmd.cmd = MF_CMD_READ; /* MIFARE READ */
 243         cmd.block = block_id;
 244
 245         return near_adapter_send(mf_ck->adapter_idx,
 246                         (uint8_t *) &cmd, 2,
 247                         far_func, data);
 248 }
 249
 250 static int mifare_read_sector_cb(uint8_t *resp, int length, void *data)
 251 {
 252         struct mifare_cookie *mf_ck = data;
 253         int err = -1;
 254
 255         if (length < 0) {
 256                 err = length;
 257                 goto out_err;
 258         }
 259
 260         /* Save the data */
 261         length = length - 1; /* ignore first byte - Reader byte */
 262
 263         /* save the length: */
 264         mf_ck->rs_length = mf_ck->rs_length + length;
 265
 266         memcpy(mf_ck->rs_pmem + mf_ck->rs_completed * DEFAULT_BLOCK_SIZE,
 267                         resp + 1,/* ignore reader byte */
 268                         length);
 269
 270         /* Next block */
 271         mf_ck->rs_completed = mf_ck->rs_completed + 1;
 272
 273         if ((mf_ck->rs_block_start + mf_ck->rs_completed) < mf_ck->rs_block_end)
 274                 err = mifare_read_block(
 275                                 (mf_ck->rs_block_start + mf_ck->rs_completed),
 276                                 data,
 277                                 mifare_read_sector_cb);
 278         else {
 279                 /* Now Process the callback ! */
 280                 err = (*mf_ck->rs_next_fct)(mf_ck->rs_pmem,
 281                                                 mf_ck->rs_length, data);
 282         }
 283
 284         if (err < 0)
 285                 goto out_err;
 286         return err;
 287
 288 out_err:
 289         return mifare_release(err, mf_ck);
 290 }
 291
 292 static int mifare_read_sector_unlocked(uint8_t *resp, int length, void *data)
 293 {
 294         struct mifare_cookie *mf_ck = data;
 295         int err;
 296
 297         if (length < 0) {
 298                 err = length;
 299                 return err;
 300         }
 301         /* And run the read process on the first block of the sector */
 302         err = mifare_read_block(mf_ck->rs_block_start, data,
 303                                 mifare_read_sector_cb);
 304
 305         if (err < 0)
 306                 goto out_err;
 307         return err;
 308
 309 out_err:
 310         return err;
 311 }
 312
 313 /* This function reads a complete sector, using block per block function.
 314  * sector sizes can be:
 315  * Sectors 0 to 31:
 316  *      48 bytes: 3*16 no trailer
 317  *      64 bytes: 4*16 with trailer
 318  * Sectors 32 to 39:
 319  *      240 bytes: 15*16 no trailer
 320  *      256 bytes: 16*16 with trailer
 321  *
 322  * Unlock is done at the beginning of first sector.
 323  */
 324 static int mifare_read_sector(void *cookie,
 325                         uint8_t *pmem,          /* memory to fill */
 326                         uint16_t memsize,       /* remaining free size */
 327                         uint8_t sector_id,      /* sector to read */
 328                         near_bool_t trailer,    /* Add trailer or not */
 329                         near_recv next_func)
 330 {
 331         struct mifare_cookie *mf_ck = cookie;
 332         int err;
 333         int blocks_count;
 334
 335         DBG("");
 336
 337         /* Prepare call values */
 338         mf_ck->rs_pmem = pmem;                  /* where to store */
 339         mf_ck->rs_max_length = memsize;         /* max size to store */
 340         mf_ck->rs_length = 0;                   /* no bytes yet */
 341         mf_ck->rs_completed = 0;                /* blocks read */
 342
 343         /* According to tag size, compute the correct block offset */
 344         if (sector_id < T4K_BOUNDARY)
 345                 mf_ck->rs_block_start = sector_id * 4;  /* 1st block to read */
 346         else
 347                 mf_ck->rs_block_start =
 348                                 (sector_id - T4K_BOUNDARY) * 16 + T4K_BLK_OFF;
 349
 350         /* Find blocks_per_sect, according to position and trailer or not */
 351         if (sector_id < T4K_BOUNDARY)
 352                 blocks_count = (STD_BLK_PER_SECT + trailer);
 353         else
 354                 blocks_count = (EXT_BLK_PER_SECT + trailer);
 355
 356         mf_ck->rs_block_end = mf_ck->rs_block_start + blocks_count;
 357
 358         mf_ck->rs_next_fct = next_func;         /* leaving function */
 359
 360         /* As we are on the first block of a sector, we unlock it */
 361         err = mifare_unlock_sector(mf_ck->rs_block_start,
 362                         mifare_read_sector_unlocked, mf_ck);
 363
 364         return err;
 365 }
 366
 367 static int mifare_read_NFC_loop(uint8_t *resp, int length, void *data)
 368 {
 369         struct mifare_cookie *mf_ck = data;
 370         int err = 0;
 371
 372         DBG("");
 373
 374         if (length < 0) {
 375                 err = length;
 376                 return err;
 377         }
 378
 379         /* ptr to the next read ptr */
 380         mf_ck->nfc_data = mf_ck->nfc_data + length;
 381
 382         /* remaining free mem */
 383         mf_ck->nfc_data_length = mf_ck->nfc_data_length - length;
 384
 385
 386         /* Addtionnal sectors to read ? */;
 387         if (mf_ck->g_sect_list->next != NULL) {
 388
 389                 err = mifare_read_sector(data,  /* cookie */
 390                         mf_ck->nfc_data,                /* where to store */
 391                         (int) mf_ck->nfc_data_length,   /* global length */
 392                         GPOINTER_TO_INT(mf_ck->g_sect_list->data), /* id */
 393                         NO_TRAILER,                     /* Trailer ? */
 394                         mifare_read_NFC_loop);          /* next function */
 395
 396                 mf_ck->g_sect_list = g_slist_remove(mf_ck->g_sect_list,
 397                                                 mf_ck->g_sect_list->data);
 398
 399                 if (err < 0)
 400                         goto out_err;
 401                 return err;
 402         } else {
 403                 DBG("READ DONE");
 404                 err = near_tlv_parse(mf_ck->tag, mf_ck->cb);
 405         }
 406
 407 out_err:
 408         return mifare_release(err, mf_ck);
 409 }
 410
 411 /* Prepare read NFC loop
 412  */
 413 static int mifare_read_NFC(void *data)
 414 {
 415         struct mifare_cookie *mf_ck = data;
 416         int err;
 417
 418         /* save tag memory pointer to data_block */
 419         mf_ck->nfc_data = near_tag_get_data(mf_ck->tag,
 420                         (size_t *)&mf_ck->nfc_data_length);
 421
 422         /* First read here: */
 423         err = mifare_read_sector(data,          /* cookie */
 424                 mf_ck->nfc_data,                /* where to store */
 425                 mf_ck->nfc_data_length,         /* global length */
 426                 GPOINTER_TO_INT(mf_ck->g_sect_list->data), /* sector id */
 427                 NO_TRAILER,                     /* Don't want Trailer */
 428                 mifare_read_NFC_loop);          /* next function */
 429
 430         mf_ck->g_sect_list = g_slist_remove(mf_ck->g_sect_list,
 431                                                 mf_ck->g_sect_list->data);
 432         if (err < 0)
 433                 goto out_err;
 434         return err;
 435
 436 out_err:
 437         return mifare_release(err, mf_ck);
 438 }
 439
 440 static int mifare_process_MADs(void *data)
 441 {
 442         struct mifare_cookie *mf_ck = data;
 443         int err;
 444         int i;
 445         int global_tag_size = 0;
 446         int ioffset;
 447
 448         DBG("");
 449
 450         /* Parse MAD entries to get the global size and fill the array */
 451         if (mf_ck->mad_1 == NULL) {
 452                 err = -EINVAL;
 453                 goto out_err;
 454         }
 455
 456         for (i = 0; i < MAD_V1_AIDS_LEN; i++) {
 457                 if (mf_ck->mad_1->aids[i] != NFC_AID_TAG)
 458                         continue;
 459
 460                 /* Save in the global list */
 461                 mf_ck->g_sect_list = g_slist_append(mf_ck->g_sect_list,
 462                                                 GINT_TO_POINTER(i + 1));
 463                 global_tag_size += SECTOR_SIZE;
 464         }
 465
 466         /* Now MAD 2 */
 467         ioffset = MAD_V1_AIDS_LEN + 1 + 1; /* skip 0x10 */
 468         if (mf_ck->mad_2 == NULL)
 469                 goto done_mad;
 470
 471         for (i = 0; i < MAD_V2_AIDS_LEN; i++) {
 472                 if (mf_ck->mad_2->aids[i] != NFC_AID_TAG)
 473                         continue;
 474
 475                 mf_ck->g_sect_list = g_slist_append( mf_ck->g_sect_list,
 476                                                 GINT_TO_POINTER(ioffset + i));
 477                 if (i < EXT_BLK_PER_SECT)
 478                         global_tag_size += SECTOR_SIZE;
 479                 else
 480                         global_tag_size += BIG_SECTOR_SIZE;
 481         }
 482
 483 done_mad:
 484         /* n sectors, each sector is 3 blocks, each block is 16 bytes */
 485         DBG("TAG Global size: [%d]", global_tag_size);
 486
 487         err = near_tag_add_data(mf_ck->adapter_idx,
 488                                                 mf_ck->target_idx,
 489                                                 NULL, /* Empty */
 490                                                 global_tag_size);
 491         if (err < 0)
 492                 goto out_err;
 493
 494         mf_ck->tag = near_tag_get_tag(mf_ck->adapter_idx, mf_ck->target_idx);
 495         if (mf_ck->tag == NULL) {
 496                 err = -ENOMEM;
 497                 goto out_err;
 498         }
 499
 500         /* Time to read the NFC data */
 501         err = mifare_read_NFC(mf_ck);
 502
 503         return err;
 504
 505 out_err:
 506         return mifare_release(err, mf_ck);
 507 }
 508
 509 /* Transitional function - async
 510  */
 511 static int read_MAD2_complete(uint8_t *empty, int iempty, void *data)
 512 {
 513         return mifare_process_MADs(data);
 514 }
 515
 516 /* This function reads the MAD2 sector
 517  */
 518 static int mifare_read_MAD2(void *data)
 519 {
 520         struct mifare_cookie *mf_ck = data;
 521         int err = 0;
 522
 523         DBG("");
 524
 525         /* As auth is ok, we allocate Mifare Access Directory v1 */
 526         mf_ck->mad_2 = g_try_malloc0(STD_SECTOR_SIZE);
 527         if (mf_ck->mad_2 == NULL) {
 528                 near_error("Memory allocation failed (MAD2)");
 529                 err = -ENOMEM;
 530                 goto out_err;
 531         }
 532
 533         err = mifare_read_sector(data,
 534                         (uint8_t *) mf_ck->mad_2,
 535                         (int) STD_SECTOR_SIZE,
 536                         MAD2_SECTOR,                    /* sector 0x10 */
 537                         WITH_TRAILER,                   /* Want Trailer */
 538                         read_MAD2_complete);
 539
 540         if (err < 0)
 541                 goto out_err;
 542         return err;
 543
 544 out_err:
 545         return mifare_release(err, mf_ck);
 546 }
 547
 548 /* This function checks, in MAD1, if there's a MAD2 directory
 549  * available. This is is the case for 2K and 4K tag
 550  * If MAD2 exists, we want to read it, elsewhere we process the
 551  * current MAD
 552  */
 553 static int read_MAD1_complete(uint8_t *empty, int iempty, void *data)
 554 {
 555         struct mifare_cookie *mf_ck = data;
 556         int err;
 557
 558         DBG("");
 559
 560         /* Check if we need to get MAD2 sector (bits 0..1)*/
 561         if ((mf_ck->mad_1->GPB & 0x03) == MAD2_GPB_BITS)
 562                 err = mifare_read_MAD2(mf_ck);
 563         else
 564                 err = mifare_process_MADs(data);
 565
 566         return err;
 567 }
 568
 569 /* Function called to read the first MAD sector
 570  * MAD is mandatory
 571  */
 572 static int mifare_read_MAD1(uint8_t *resp, int length, void *data)
 573 {
 574         struct mifare_cookie *mf_ck = data;
 575         int err = 0;
 576
 577         DBG("%p %d", data, length);
 578
 579         if (length < 0) {
 580                 err = length;
 581                 return err;
 582         }
 583
 584         /* As auth is ok, we allocate Mifare Access Directory v1
 585          * allocated size is also STD_SECTOR_SIZE */
 586         mf_ck->mad_1 = g_try_malloc0(STD_SECTOR_SIZE);
 587         if (mf_ck->mad_1 == NULL) {
 588                 near_error("Memory allocation failed (MAD1)");
 589                 err = -ENOMEM;
 590                 goto out_err;
 591         }
 592
 593         /* Call to mifare_read_sector */
 594         err = mifare_read_sector(data,
 595                         (uint8_t *)mf_ck->mad_1,        /* where to store */
 596                         (int) STD_SECTOR_SIZE,          /* allocated size */
 597                         MAD1_SECTOR,                    /* sector 0 */
 598                         WITH_TRAILER,                   /* Want Trailer */
 599                         read_MAD1_complete);
 600
 601         if (err < 0)
 602                 goto out_err;
 603         return err;
 604
 605 out_err:
 606         return mifare_release(err, mf_ck);
 607 }
 608
 609
 610 /* MIFARE: entry point:
 611  * Read all the MAD sectors (0x00, 0x10) to get the Application Directory
 612  * entries.
 613  * On sector 0x00, App. directory is on block 0x01 & block 0x02
 614  * On sector 0x10, App. directory is on block 0x40, 0x41 & 0x42
 615  * On reading, we ignore the CRC.
 616  */
 617 int mifare_read_tag(uint32_t adapter_idx, uint32_t target_idx,
 618                 near_tag_io_cb cb, enum near_tag_sub_type tgt_subtype)
 619 {
 620         struct mifare_cookie *cookie;
 621         int err;
 622
 623         DBG("");
 624
 625         /*Check supported and tested Mifare type */
 626         switch (tgt_subtype) {
 627         case NEAR_TAG_NFC_T2_MIFARE_CLASSIC_1K:
 628         case NEAR_TAG_NFC_T2_MIFARE_CLASSIC_4K:
 629                 break;
 630         default:
 631                 near_error("Mifare tag type [%d] not supported.", tgt_subtype);
 632                 return -1;
 633         }
 634
 635         /* Alloc global cookie */
 636         cookie = g_try_malloc0(sizeof(struct mifare_cookie));
 637
 638         /* Get the nfcid1 */
 639         cookie->nfcid1 = near_tag_get_nfcid(adapter_idx, target_idx,
 640                                 &cookie->nfcid1_len);
 641         cookie->adapter_idx = adapter_idx;
 642         cookie->target_idx = target_idx;
 643         cookie->cb = cb;
 644
 645         /* Need to unlock before reading
 646          * This will check if public keys are allowed (and, so, NDEF could
 647          * be "readable"...
 648          * */
 649         err = mifare_unlock_sector(MAD1_1ST_BLOCK,      /* related block */
 650                                 mifare_read_MAD1,       /* callback function */
 651                                 cookie);                /* target data */
 652         if (err < 0)
 653                 return mifare_release(err, cookie);
 654
 655
 656         return 0;
 657 }