src/openpgp-do.c

   1 /*
   2  * openpgp-do.c -- OpenPGP card Data Objects (DO) handling
   3  *
   4  * Copyright (C) 2010, 2011, 2012 Free Software Initiative of Japan
   5  * Author: NIIBE Yutaka <gniibe@fsij.org>
   6  *
   7  * This file is a part of Gnuk, a GnuPG USB Token implementation.
   8  *
   9  * Gnuk is free software: you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * Gnuk is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  *
  22  */
  23
  24 #include <stdlib.h>
  25
  26 #include "config.h"
  27 #include "ch.h"
  28 #include "sys.h"
  29 #include "gnuk.h"
  30 #include "openpgp.h"
  31
  32 #include "polarssl/config.h"
  33 #include "polarssl/aes.h"
  34 #include "polarssl/sha1.h"
  35
  36 #define PASSWORD_ERRORS_MAX 3   /* >= errors, it will be locked */
  37 static const uint8_t *pw_err_counter_p[3];
  38
  39 static int
  40 gpg_pw_get_err_counter (uint8_t which)
  41 {
  42   return flash_cnt123_get_value (pw_err_counter_p[which]);
  43 }
  44
  45 int
  46 gpg_pw_locked (uint8_t which)
  47 {
  48   if (gpg_pw_get_err_counter (which) >= PASSWORD_ERRORS_MAX)
  49     return 1;
  50   else
  51     return 0;
  52 }
  53
  54 void
  55 gpg_pw_reset_err_counter (uint8_t which)
  56 {
  57   flash_cnt123_clear (&pw_err_counter_p[which]);
  58   if (pw_err_counter_p[which] != NULL)
  59     GPG_MEMORY_FAILURE ();
  60 }
  61
  62 void
  63 gpg_pw_increment_err_counter (uint8_t which)
  64 {
  65   flash_cnt123_increment (which, &pw_err_counter_p[which]);
  66 }
  67
  68
  69 uint16_t data_objects_number_of_bytes;
  70
  71 /*
  72  * Compile time vars:
  73  *   Historical Bytes (template), Extended Capabilities,
  74  *   and Algorithm Attributes
  75  */
  76
  77 /* Historical Bytes (template) */
  78 static const uint8_t historical_bytes[] __attribute__ ((aligned (1))) = {
  79   10,
  80   0x00,
  81   0x31, 0x84,                   /* Full DF name, GET DATA, MF */
  82   0x73,
  83   0x80, 0x01, 0x80,             /* Full DF name */
  84                                 /* 1-byte */
  85                                 /* Command chaining, No extended Lc and Le */
  86   0x00, 0x90, 0x00              /* Status info (no life cycle management) */
  87 };
  88
  89 /* Extended Capabilities */
  90 static const uint8_t extended_capabilities[] __attribute__ ((aligned (1))) = {
  91   10,
  92   0x30,                         /*
  93                                  * No SM,
  94                                  * No get challenge,
  95                                  * Key import supported,
  96                                  * PW status byte can be put,
  97                                  * No private_use_DO,
  98                                  * No algo change allowed
  99                                  */
 100   0,              /* Secure Messaging Algorithm: N/A (TDES=0, AES=1) */
 101   0x00, 0x00,     /* Max get challenge (0: Get challenge not supported) */
 102 #ifdef CERTDO_SUPPORT
 103   0x08, 0x00,     /* max. length of cardholder certificate (2KiB) */
 104 #else
 105   0x00, 0x00,
 106 #endif
 107   /* Max. length of command APDU data */
 108   0x00, 0xff,
 109   /* Max. length of response APDU data */
 110   0x01, 0x00,
 111 };
 112
 113 /* Algorithm Attributes */
 114 static const uint8_t algorithm_attr[] __attribute__ ((aligned (1))) = {
 115   6,
 116   0x01, /* RSA */
 117   0x08, 0x00,         /* Length modulus (in bit): 2048 */
 118   0x00, 0x20,         /* Length exponent (in bit): 32  */
 119   0x00                /* 0: p&q , 3: CRT with N (not yet supported) */
 120 };
 121
 122 #define PW_LEN_MAX 127
 123 /*
 124  * Representation of PW1_LIFETIME:
 125  *    0: PW1_LIEFTIME_P == NULL : PW1 is valid for single PSO:CDS command
 126  *    1: PW1_LIEFTIME_P != NULL : PW1 is valid for several PSO:CDS commands
 127  *
 128  * The address in the variable PW1_LIEFTIME_P is used when filling zero
 129  * in flash memory
 130  */
 131 static const uint8_t *pw1_lifetime_p;
 132
 133 static int
 134 gpg_get_pw1_lifetime (void)
 135 {
 136   if (pw1_lifetime_p == NULL)
 137     return 0;
 138   else
 139     return 1;
 140 }
 141
 142
 143 static uint32_t digital_signature_counter;
 144
 145 static const uint8_t *
 146 gpg_write_digital_signature_counter (const uint8_t *p, uint32_t dsc)
 147 {
 148   uint16_t hw0, hw1;
 149
 150   if ((dsc >> 10) == 0)
 151     { /* no upper bits */
 152       hw1 = NR_COUNTER_DS_LSB | ((dsc & 0x0300) >> 8) | ((dsc & 0x00ff) << 8);
 153       flash_put_data_internal (p, hw1);
 154       return p+2;
 155     }
 156   else
 157     {
 158       hw0 = NR_COUNTER_DS | ((dsc & 0xfc0000) >> 18) | ((dsc & 0x03fc00) >> 2);
 159       hw1 = NR_COUNTER_DS_LSB;
 160       flash_put_data_internal (p, hw0);
 161       flash_put_data_internal (p+2, hw1);
 162       return p+4;
 163     }
 164 }
 165
 166 static void
 167 gpg_reset_digital_signature_counter (void)
 168 {
 169   if (digital_signature_counter != 0)
 170     {
 171       flash_put_data (NR_COUNTER_DS);
 172       flash_put_data (NR_COUNTER_DS_LSB);
 173       digital_signature_counter = 0;
 174     }
 175 }
 176
 177 void
 178 gpg_increment_digital_signature_counter (void)
 179 {
 180   uint16_t hw0, hw1;
 181   uint32_t dsc = (digital_signature_counter + 1) & 0x00ffffff;
 182
 183   if ((dsc & 0x03ff) == 0)
 184     { /* carry occurs from l10 to h14 */
 185       hw0 = NR_COUNTER_DS | ((dsc & 0xfc0000) >> 18) | ((dsc & 0x03fc00) >> 2);
 186       hw1 = NR_COUNTER_DS_LSB;  /* zero */
 187       flash_put_data (hw0);
 188       flash_put_data (hw1);
 189     }
 190   else
 191     {
 192       hw1 = NR_COUNTER_DS_LSB | ((dsc & 0x0300) >> 8) | ((dsc & 0x00ff) << 8);
 193       flash_put_data (hw1);
 194     }
 195
 196   digital_signature_counter = dsc;
 197
 198   if (gpg_get_pw1_lifetime () == 0)
 199     ac_reset_pso_cds ();
 200 }
 201
 202
 203 #define SIZE_FINGER_PRINT 20
 204 #define SIZE_KEYGEN_TIME 4      /* RFC4880 */
 205
 206 enum do_type {
 207   DO_FIXED,
 208   DO_VAR,
 209   DO_CMP_READ,
 210   DO_PROC_READ,
 211   DO_PROC_WRITE,
 212   DO_PROC_READWRITE,
 213 };
 214
 215 struct do_table_entry {
 216   uint16_t tag;
 217   enum do_type do_type;
 218   uint8_t ac_read;
 219   uint8_t ac_write;
 220   const void *obj;
 221 };
 222
 223 static uint8_t *res_p;
 224
 225 static void copy_do_1 (uint16_t tag, const uint8_t *do_data, int with_tag);
 226 static const struct do_table_entry *get_do_entry (uint16_t tag);
 227
 228 #define GPG_DO_AID              0x004f
 229 #define GPG_DO_NAME             0x005b
 230 #define GPG_DO_LOGIN_DATA       0x005e
 231 #define GPG_DO_CH_DATA          0x0065
 232 #define GPG_DO_APP_DATA         0x006e
 233 /* XXX: 0x0073 ??? */
 234 #define GPG_DO_SS_TEMP          0x007a
 235 #define GPG_DO_DS_COUNT         0x0093
 236 #define GPG_DO_EXTCAP           0x00c0
 237 #define GPG_DO_ALG_SIG          0x00c1
 238 #define GPG_DO_ALG_DEC          0x00c2
 239 #define GPG_DO_ALG_AUT          0x00c3
 240 #define GPG_DO_PW_STATUS        0x00c4
 241 #define GPG_DO_FP_ALL           0x00c5
 242 #define GPG_DO_CAFP_ALL         0x00c6
 243 #define GPG_DO_FP_SIG           0x00c7
 244 #define GPG_DO_FP_DEC           0x00c8
 245 #define GPG_DO_FP_AUT           0x00c9
 246 #define GPG_DO_CAFP_1           0x00ca
 247 #define GPG_DO_CAFP_2           0x00cb
 248 #define GPG_DO_CAFP_3           0x00cc
 249 #define GPG_DO_KGTIME_ALL       0x00cd
 250 #define GPG_DO_KGTIME_SIG       0x00ce
 251 #define GPG_DO_KGTIME_DEC       0x00cf
 252 #define GPG_DO_KGTIME_AUT       0x00d0
 253 #define GPG_DO_RESETTING_CODE   0x00d3
 254 #define GPG_DO_KEY_IMPORT       0x3fff
 255 #define GPG_DO_LANGUAGE         0x5f2d
 256 #define GPG_DO_SEX              0x5f35
 257 #define GPG_DO_URL              0x5f50
 258 #define GPG_DO_HIST_BYTES       0x5f52
 259 #define GPG_DO_CH_CERTIFICATE   0x7f21
 260
 261 static const uint8_t *do_ptr[NR_DO__LAST__];
 262
 263 static uint8_t
 264 do_tag_to_nr (uint16_t tag)
 265 {
 266   switch (tag)
 267     {
 268     case GPG_DO_SEX:
 269       return NR_DO_SEX;
 270     case GPG_DO_FP_SIG:
 271       return NR_DO_FP_SIG;
 272     case GPG_DO_FP_DEC:
 273       return NR_DO_FP_DEC;
 274     case GPG_DO_FP_AUT:
 275       return NR_DO_FP_AUT;
 276     case GPG_DO_CAFP_1:
 277       return NR_DO_CAFP_1;
 278     case GPG_DO_CAFP_2:
 279       return NR_DO_CAFP_2;
 280     case GPG_DO_CAFP_3:
 281       return NR_DO_CAFP_3;
 282     case GPG_DO_KGTIME_SIG:
 283       return NR_DO_KGTIME_SIG;
 284     case GPG_DO_KGTIME_DEC:
 285       return NR_DO_KGTIME_DEC;
 286     case GPG_DO_KGTIME_AUT:
 287       return NR_DO_KGTIME_AUT;
 288     case GPG_DO_LOGIN_DATA:
 289       return NR_DO_LOGIN_DATA;
 290     case GPG_DO_URL:
 291       return NR_DO_URL;
 292     case GPG_DO_NAME:
 293       return NR_DO_NAME;
 294     case GPG_DO_LANGUAGE:
 295       return NR_DO_LANGUAGE;
 296     default:
 297       return NR_NONE;
 298     }
 299 }
 300
 301 static void
 302 copy_tag (uint16_t tag)
 303 {
 304   if (tag < 0x0100)
 305     *res_p++ = (tag & 0xff);
 306   else
 307     {
 308       *res_p++ = (tag >> 8);
 309       *res_p++ = (tag & 0xff);
 310     }
 311 }
 312
 313 static int
 314 do_hist_bytes (uint16_t tag, int with_tag)
 315 {
 316   /* XXX: For now, no life cycle management, just return template as is. */
 317   /* XXX: Supporing TERMINATE DF / ACTIVATE FILE, we need to fix here */
 318   copy_do_1 (tag, historical_bytes, with_tag);
 319   return 1;
 320 }
 321
 322 #define SIZE_FP 20
 323 #define SIZE_KGTIME 4
 324
 325 static int
 326 do_fp_all (uint16_t tag, int with_tag)
 327 {
 328   const uint8_t *data;
 329
 330   if (with_tag)
 331     {
 332       copy_tag (tag);
 333       *res_p++ = SIZE_FP*3;
 334     }
 335
 336   data = gpg_do_read_simple (NR_DO_FP_SIG);
 337   if (data)
 338     memcpy (res_p, data, SIZE_FP);
 339   else
 340     memset (res_p, 0, SIZE_FP);
 341   res_p += SIZE_FP;
 342
 343   data = gpg_do_read_simple (NR_DO_FP_DEC);
 344   if (data)
 345     memcpy (res_p, data, SIZE_FP);
 346   else
 347     memset (res_p, 0, SIZE_FP);
 348   res_p += SIZE_FP;
 349
 350   data = gpg_do_read_simple (NR_DO_FP_AUT);
 351   if (data)
 352     memcpy (res_p, data, SIZE_FP);
 353   else
 354     memset (res_p, 0, SIZE_FP);
 355   res_p += SIZE_FP;
 356   return 1;
 357 }
 358
 359 static int
 360 do_cafp_all (uint16_t tag, int with_tag)
 361 {
 362   const uint8_t *data;
 363
 364   if (with_tag)
 365     {
 366       copy_tag (tag);
 367       *res_p++ = SIZE_FP*3;
 368     }
 369
 370   data = gpg_do_read_simple (NR_DO_CAFP_1);
 371   if (data)
 372     memcpy (res_p, data, SIZE_FP);
 373   else
 374     memset (res_p, 0, SIZE_FP);
 375   res_p += SIZE_FP;
 376
 377   data = gpg_do_read_simple (NR_DO_CAFP_2);
 378   if (data)
 379     memcpy (res_p, data, SIZE_FP);
 380   else
 381     memset (res_p, 0, SIZE_FP);
 382   res_p += SIZE_FP;
 383
 384   data = gpg_do_read_simple (NR_DO_CAFP_2);
 385   if (data)
 386     memcpy (res_p, data, SIZE_FP);
 387   else
 388     memset (res_p, 0, SIZE_FP);
 389   res_p += SIZE_FP;
 390   return 1;
 391 }
 392
 393 static int
 394 do_kgtime_all (uint16_t tag, int with_tag)
 395 {
 396   const uint8_t *data;
 397
 398   if (with_tag)
 399     {
 400       copy_tag (tag);
 401       *res_p++ = SIZE_KGTIME*3;
 402     }
 403
 404   data = gpg_do_read_simple (NR_DO_KGTIME_SIG);
 405   if (data)
 406     memcpy (res_p, data, SIZE_KGTIME);
 407   else
 408     memset (res_p, 0, SIZE_KGTIME);
 409   res_p += SIZE_KGTIME;
 410
 411   data = gpg_do_read_simple (NR_DO_KGTIME_DEC);
 412   if (data)
 413     memcpy (res_p, data, SIZE_KGTIME);
 414   else
 415     memset (res_p, 0, SIZE_KGTIME);
 416   res_p += SIZE_KGTIME;
 417
 418   data = gpg_do_read_simple (NR_DO_KGTIME_AUT);
 419   if (data)
 420     memcpy (res_p, data, SIZE_KGTIME);
 421   else
 422     memset (res_p, 0, SIZE_KGTIME);
 423   res_p += SIZE_KGTIME;
 424   return 1;
 425 }
 426
 427 const uint8_t openpgpcard_aid[] = {
 428   0xd2, 0x76,               /* D: National, 276: DEU ISO 3166-1 */
 429   0x00, 0x01, 0x24,         /* Registered Application Provider Identifier */
 430   0x01,                     /* Application: OpenPGPcard */
 431   0x02, 0x00,               /* Version 2.0 */
 432   /* v. id */ /*   serial number   */
 433   0xff, 0xff, 0xff, 0xff,  0xff, 0xff, /* To be overwritten */
 434 };
 435
 436 static int
 437 do_openpgpcard_aid (uint16_t tag, int with_tag)
 438 {
 439   uint16_t vid = *((const volatile uint16_t *)&openpgpcard_aid[8]);
 440
 441   if (with_tag)
 442     {
 443       copy_tag (tag);
 444       *res_p++ = 16;
 445     }
 446
 447   if (vid == 0xffff || vid == 0x0000)
 448     {
 449       const uint8_t *u = unique_device_id ();
 450
 451       memcpy (res_p, openpgpcard_aid, 8);
 452       res_p += 8;
 453
 454       /* vid == 0xfffe: serial number is random byte */
 455       *res_p++ = 0xff;
 456       *res_p++ = 0xfe;
 457       memcpy (res_p, u, 4);
 458       res_p += 4;
 459     }
 460   else
 461     {
 462       memcpy (res_p, openpgpcard_aid, 14);
 463       res_p += 14;
 464     }
 465
 466   *res_p++ = 0;
 467   *res_p++ = 0;
 468
 469   return 1;
 470 }
 471
 472 static int
 473 do_ds_count (uint16_t tag, int with_tag)
 474 {
 475   if (with_tag)
 476     {
 477       copy_tag (tag);
 478       *res_p++ = 3;
 479     }
 480
 481   *res_p++ = (digital_signature_counter >> 16) & 0xff;
 482   *res_p++ = (digital_signature_counter >> 8) & 0xff;
 483   *res_p++ = digital_signature_counter & 0xff;
 484   return 1;
 485 }
 486
 487 static int
 488 rw_pw_status (uint16_t tag, int with_tag,
 489               const uint8_t *data, int len, int is_write)
 490 {
 491   if (is_write)
 492     {
 493       (void)len;                /* Should be SIZE_PW_STATUS_BYTES */
 494
 495       /* Only the first byte of DATA is checked */
 496       if (data[0] == 0)
 497         {
 498           flash_bool_clear (&pw1_lifetime_p);
 499           if (pw1_lifetime_p == NULL)
 500             return 1;
 501           else
 502             return 0;
 503         }
 504       else
 505         {
 506           pw1_lifetime_p = flash_bool_write (NR_BOOL_PW1_LIFETIME);
 507           if (pw1_lifetime_p != NULL)
 508             return 1;
 509           else
 510             return 0;
 511         }
 512     }
 513   else
 514     {
 515       if (with_tag)
 516         {
 517           copy_tag (tag);
 518           *res_p++ = SIZE_PW_STATUS_BYTES;
 519         }
 520
 521       *res_p++ = gpg_get_pw1_lifetime ();
 522       *res_p++ = PW_LEN_MAX;
 523       *res_p++ = PW_LEN_MAX;
 524       *res_p++ = PW_LEN_MAX;
 525       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW1);
 526       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_RC);
 527       *res_p++ = PASSWORD_ERRORS_MAX - gpg_pw_get_err_counter (PW_ERR_PW3);
 528       return 1;
 529     }
 530 }
 531
 532 static int
 533 proc_resetting_code (const uint8_t *data, int len)
 534 {
 535   const uint8_t *old_ks = keystring_md_pw3;
 536   uint8_t new_ks0[KEYSTRING_MD_SIZE+1];
 537   uint8_t *new_ks = &new_ks0[1];
 538   const uint8_t *newpw;
 539   int newpw_len;
 540   int r;
 541
 542   DEBUG_INFO ("Resetting Code!\r\n");
 543
 544   newpw_len = len;
 545   newpw = data;
 546   sha1 (newpw, newpw_len, new_ks);
 547   new_ks0[0] = newpw_len;
 548   r = gpg_change_keystring (admin_authorized, old_ks, BY_RESETCODE, new_ks);
 549   if (r <= -2)
 550     {
 551       DEBUG_INFO ("memory error.\r\n");
 552       return 0;
 553     }
 554   else if (r < 0)
 555     {
 556       DEBUG_INFO ("security error.\r\n");
 557       return 0;
 558     }
 559   else if (r == 0)
 560     {
 561       DEBUG_INFO ("done (no prvkey).\r\n");
 562       gpg_do_write_simple (NR_DO_KEYSTRING_RC, new_ks0, KEYSTRING_SIZE_RC);
 563     }
 564   else
 565     {
 566       DEBUG_INFO ("done.\r\n");
 567       gpg_do_write_simple (NR_DO_KEYSTRING_RC, new_ks0, 1);
 568     }
 569
 570   gpg_pw_reset_err_counter (PW_ERR_RC);
 571   return 1;
 572 }
 573
 574 static void
 575 encrypt (const uint8_t *key_str, uint8_t *data, int len)
 576 {
 577   aes_context aes;
 578   uint8_t iv[16];
 579   int iv_offset;
 580
 581   DEBUG_INFO ("ENC\r\n");
 582   DEBUG_BINARY (data, len);
 583
 584   aes_setkey_enc (&aes, key_str, 128);
 585   memset (iv, 0, 16);
 586   iv_offset = 0;
 587   aes_crypt_cfb128 (&aes, AES_ENCRYPT, len, &iv_offset, iv, data, data);
 588 }
 589
 590 /* Signing, Decryption, and Authentication */
 591 struct key_data kd[3];
 592
 593 static void
 594 decrypt (const uint8_t *key_str, uint8_t *data, int len)
 595 {
 596   aes_context aes;
 597   uint8_t iv[16];
 598   int iv_offset;
 599
 600   aes_setkey_enc (&aes, key_str, 128);
 601   memset (iv, 0, 16);
 602   iv_offset = 0;
 603   aes_crypt_cfb128 (&aes, AES_DECRYPT, len, &iv_offset, iv, data, data);
 604
 605   DEBUG_INFO ("DEC\r\n");
 606   DEBUG_BINARY (data, len);
 607 }
 608
 609 static uint8_t
 610 get_do_ptr_nr_for_kk (enum kind_of_key kk)
 611 {
 612   switch (kk)
 613     {
 614     case GPG_KEY_FOR_SIGNING:
 615       return NR_DO_PRVKEY_SIG;
 616     case GPG_KEY_FOR_DECRYPTION:
 617       return NR_DO_PRVKEY_DEC;
 618     case GPG_KEY_FOR_AUTHENTICATION:
 619       return NR_DO_PRVKEY_AUT;
 620     }
 621   return NR_DO_PRVKEY_SIG;
 622 }
 623
 624 void
 625 gpg_do_clear_prvkey (enum kind_of_key kk)
 626 {
 627   memset ((void *)&kd[kk], 0, sizeof (struct key_data));
 628 }
 629
 630 /*
 631  * Return  1 on success,
 632  *         0 if none,
 633  *        -1 on error,
 634  */
 635 int
 636 gpg_do_load_prvkey (enum kind_of_key kk, int who, const uint8_t *keystring)
 637 {
 638   uint8_t nr = get_do_ptr_nr_for_kk (kk);
 639   const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
 640   uint8_t *key_addr;
 641   uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
 642   struct key_data_internal kdi;
 643
 644   DEBUG_INFO ("Loading private key: ");
 645   DEBUG_BYTE (kk);
 646
 647   if (do_data == NULL)
 648     return 0;
 649
 650   key_addr = *(uint8_t **)&(do_data)[1];
 651   memcpy (kdi.data, key_addr, KEY_CONTENT_LEN);
 652   memcpy (((uint8_t *)&kdi.check), do_data+5, ADDITIONAL_DATA_SIZE);
 653
 654   memcpy (dek, do_data+5+16*who, DATA_ENCRYPTION_KEY_SIZE);
 655   decrypt (keystring, dek, DATA_ENCRYPTION_KEY_SIZE);
 656
 657   decrypt (dek, (uint8_t *)&kdi, sizeof (struct key_data_internal));
 658   if (memcmp (kdi.magic, GNUK_MAGIC, KEY_MAGIC_LEN) != 0)
 659     {
 660       DEBUG_INFO ("gpg_do_load_prvkey failed.\r\n");
 661       return -1;
 662     }
 663   /* more sanity check??? */
 664
 665   memcpy (kd[kk].data, kdi.data, KEY_CONTENT_LEN);
 666   DEBUG_BINARY (&kd[kk], KEY_CONTENT_LEN);
 667   return 1;
 668 }
 669
 670 static uint32_t
 671 calc_check32 (const uint8_t *p, int len)
 672 {
 673   uint32_t check = 0;
 674   uint32_t *data = (uint32_t *)p;
 675   int i;
 676
 677   for (i = 0; i < len/4; i++)
 678     check += data[i];
 679
 680   return check;
 681 }
 682
 683 static int8_t num_prv_keys;
 684
 685 static int
 686 gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data, int key_len,
 687                      const uint8_t *keystring_admin, const uint8_t *modulus)
 688 {
 689   uint8_t nr = get_do_ptr_nr_for_kk (kk);
 690   const uint8_t *p;
 691   int r;
 692   struct prvkey_data *pd;
 693   uint8_t *key_addr;
 694   const uint8_t *dek;
 695   const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
 696   const uint8_t *ks_pw1;
 697   const uint8_t *ks_rc;
 698   struct key_data_internal kdi;
 699   int modulus_allocated_here = 0;
 700
 701   DEBUG_INFO ("Key import\r\n");
 702   DEBUG_SHORT (key_len);
 703
 704   if (do_data)
 705     /* No replace support, you need to remove it first.  */
 706     return -1;
 707
 708   if (key_len != KEY_CONTENT_LEN)
 709     return -1;
 710
 711   pd = (struct prvkey_data *)malloc (sizeof (struct prvkey_data));
 712   if (pd == NULL)
 713     return -1;
 714
 715   if (modulus == NULL)
 716     {
 717       modulus = modulus_calc (key_data, key_len);
 718       if (modulus == NULL)
 719         {
 720           free (pd);
 721           return -1;
 722         }
 723
 724       modulus_allocated_here = 1;
 725     }
 726
 727   DEBUG_INFO ("Getting keystore address...\r\n");
 728   key_addr = flash_key_alloc ();
 729   if (key_addr == NULL)
 730     {
 731       free (pd);
 732       if (modulus_allocated_here)
 733         modulus_free (modulus);
 734       return -1;
 735     }
 736
 737   DEBUG_INFO ("key_addr: ");
 738   DEBUG_WORD ((uint32_t)key_addr);
 739
 740   memcpy (kdi.data, key_data, KEY_CONTENT_LEN);
 741   kdi.check = calc_check32 (key_data, KEY_CONTENT_LEN);
 742   kdi.random = get_salt ();
 743   memcpy (kdi.magic, GNUK_MAGIC, KEY_MAGIC_LEN);
 744
 745   dek = random_bytes_get (); /* 16-byte random bytes */
 746   memcpy (pd->dek_encrypted_1, dek, DATA_ENCRYPTION_KEY_SIZE);
 747   memcpy (pd->dek_encrypted_2, dek, DATA_ENCRYPTION_KEY_SIZE);
 748   memcpy (pd->dek_encrypted_3, dek, DATA_ENCRYPTION_KEY_SIZE);
 749   ks_pw1 = gpg_do_read_simple (NR_DO_KEYSTRING_PW1);
 750   ks_rc = gpg_do_read_simple (NR_DO_KEYSTRING_RC);
 751
 752   encrypt (dek, (uint8_t *)&kdi, sizeof (struct key_data_internal));
 753
 754   r = flash_key_write (key_addr, kdi.data, modulus);
 755   if (modulus_allocated_here)
 756     modulus_free (modulus);
 757
 758   if (r < 0)
 759     {
 760       random_bytes_free (dek);
 761       free (pd);
 762       return r;
 763     }
 764
 765   pd->key_addr = key_addr;
 766   memcpy (pd->crm_encrypted, (uint8_t *)&kdi.check, ADDITIONAL_DATA_SIZE);
 767
 768   if (kk == GPG_KEY_FOR_SIGNING)
 769     {
 770       ac_reset_pso_cds ();
 771       gpg_reset_digital_signature_counter ();
 772     }
 773   else
 774     ac_reset_other ();
 775
 776   if (ks_pw1)
 777     encrypt (ks_pw1+1, pd->dek_encrypted_1, DATA_ENCRYPTION_KEY_SIZE);
 778   else
 779     {
 780       uint8_t ks123_pw1[KEYSTRING_SIZE_PW1];
 781
 782       ks123_pw1[0] = strlen (OPENPGP_CARD_INITIAL_PW1);
 783       sha1 ((uint8_t *)OPENPGP_CARD_INITIAL_PW1,
 784             strlen (OPENPGP_CARD_INITIAL_PW1), ks123_pw1+1);
 785       encrypt (ks123_pw1+1, pd->dek_encrypted_1, DATA_ENCRYPTION_KEY_SIZE);
 786     }
 787
 788   if (ks_rc)
 789     encrypt (ks_rc+1, pd->dek_encrypted_2, DATA_ENCRYPTION_KEY_SIZE);
 790   else
 791     memset (pd->dek_encrypted_2, 0, DATA_ENCRYPTION_KEY_SIZE);
 792
 793   if (keystring_admin)
 794     encrypt (keystring_admin, pd->dek_encrypted_3, DATA_ENCRYPTION_KEY_SIZE);
 795   else
 796     memset (pd->dek_encrypted_3, 0, DATA_ENCRYPTION_KEY_SIZE);
 797
 798   p = flash_do_write (nr, (const uint8_t *)pd, sizeof (struct prvkey_data));
 799   do_ptr[nr - NR_DO__FIRST__] = p;
 800
 801   random_bytes_free (dek);
 802   free (pd);
 803   if (p == NULL)
 804     return -1;
 805
 806   if (++num_prv_keys == NUM_ALL_PRV_KEYS) /* All keys are registered.  */
 807     {
 808       /* Remove contents of keystrings from DO, but length */
 809       if (ks_pw1)
 810         {
 811           uint8_t ks_pw1_len = ks_pw1[0];
 812           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, &ks_pw1_len, 1);
 813         }
 814
 815       if (ks_rc)
 816         {
 817           uint8_t ks_rc_len = ks_rc[0];
 818           gpg_do_write_simple (NR_DO_KEYSTRING_RC, &ks_rc_len, 1);
 819         }
 820     }
 821
 822   return 0;
 823 }
 824
 825 int
 826 gpg_do_chks_prvkey (enum kind_of_key kk,
 827                     int who_old, const uint8_t *old_ks,
 828                     int who_new, const uint8_t *new_ks)
 829 {
 830   uint8_t nr = get_do_ptr_nr_for_kk (kk);
 831   const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
 832   uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
 833   struct prvkey_data *pd;
 834   const uint8_t *p;
 835   uint8_t *dek_p;
 836
 837   if (do_data == NULL)
 838     return 0;                   /* No private key */
 839
 840   pd = (struct prvkey_data *)malloc (sizeof (struct prvkey_data));
 841   if (pd == NULL)
 842     return -1;
 843
 844   memcpy (pd, &(do_data)[1], sizeof (struct prvkey_data));
 845   dek_p = ((uint8_t *)pd) + 4 + ADDITIONAL_DATA_SIZE
 846     + DATA_ENCRYPTION_KEY_SIZE * (who_old - 1);
 847   memcpy (dek, dek_p, DATA_ENCRYPTION_KEY_SIZE);
 848   decrypt (old_ks, dek, DATA_ENCRYPTION_KEY_SIZE);
 849   encrypt (new_ks, dek, DATA_ENCRYPTION_KEY_SIZE);
 850   dek_p += DATA_ENCRYPTION_KEY_SIZE * (who_new - who_old);
 851   memcpy (dek_p, dek, DATA_ENCRYPTION_KEY_SIZE);
 852
 853   p = flash_do_write (nr, (const uint8_t *)pd, sizeof (struct prvkey_data));
 854   do_ptr[nr - NR_DO__FIRST__] = p;
 855
 856   flash_do_release (do_data);
 857   free (pd);
 858   if (p == NULL)
 859     return -1;
 860
 861   return 1;
 862 }
 863
 864 /*
 865  * 4d, xx, xx, xx:    Extended Header List
 866  *   b6 00 (SIG) / b8 00 (DEC) / a4 00 (AUT)
 867  *   7f48, xx: cardholder private key template
 868  *       91 xx
 869  *       92 xx xx
 870  *       93 xx xx
 871  *   5f48, xx xx xx: cardholder private key
 872  */
 873 static int
 874 proc_key_import (const uint8_t *data, int len)
 875 {
 876   int r;
 877   enum kind_of_key kk;
 878   const uint8_t *keystring_admin;
 879   const uint8_t *p = data;
 880
 881   if (admin_authorized == BY_ADMIN)
 882     keystring_admin = keystring_md_pw3;
 883   else
 884     keystring_admin = NULL;
 885
 886   DEBUG_BINARY (data, len);
 887
 888   if (*p++ != 0x4d)
 889     return 0;
 890
 891   /* length field */
 892   if (*p == 0x82)
 893     p += 3;
 894   else if (*p == 0x81)
 895     p += 2;
 896   else
 897     p += 1;
 898
 899   if (*p == 0xb6)
 900     kk = GPG_KEY_FOR_SIGNING;
 901   else if (*p == 0xb8)
 902     kk = GPG_KEY_FOR_DECRYPTION;
 903   else                          /* 0xa4 */
 904     kk = GPG_KEY_FOR_AUTHENTICATION;
 905
 906   if (len <= 22)
 907     {                                       /* Deletion of the key */
 908       uint8_t nr = get_do_ptr_nr_for_kk (kk);
 909       const uint8_t *do_data = do_ptr[nr - NR_DO__FIRST__];
 910
 911       if (do_data == NULL)
 912         return 1;
 913
 914       do_ptr[nr - NR_DO__FIRST__] = NULL;
 915       flash_do_release (do_data);
 916
 917       if (--num_prv_keys == 0)
 918         {
 919           flash_keystore_release ();
 920
 921           /* Delete PW1 and RC if any */
 922           gpg_do_write_simple (NR_DO_KEYSTRING_PW1, NULL, 0);
 923           gpg_do_write_simple (NR_DO_KEYSTRING_RC, NULL, 0);
 924         }
 925
 926       return 1;
 927     }
 928
 929   /* It should starts with 00 01 00 01 (E) */
 930   /* Skip E, 4-byte */
 931   r = gpg_do_write_prvkey (kk, &data[26], len - 26, keystring_admin, NULL);
 932   if (r < 0)
 933     return 0;
 934   else
 935     return 1;
 936 }
 937
 938 static const uint16_t cmp_ch_data[] = {
 939   3,
 940   GPG_DO_NAME,
 941   GPG_DO_LANGUAGE,
 942   GPG_DO_SEX,
 943 };
 944
 945 static const uint16_t cmp_app_data[] = {
 946   10,
 947   GPG_DO_AID,
 948   GPG_DO_HIST_BYTES,
 949   /* XXX Discretionary data objects 0x0073 ??? */
 950   GPG_DO_EXTCAP,
 951   GPG_DO_ALG_SIG, GPG_DO_ALG_DEC, GPG_DO_ALG_AUT,
 952   GPG_DO_PW_STATUS,
 953   GPG_DO_FP_ALL, GPG_DO_CAFP_ALL, GPG_DO_KGTIME_ALL
 954 };
 955
 956 static const uint16_t cmp_ss_temp[] = { 1, GPG_DO_DS_COUNT };
 957
 958 static const struct do_table_entry
 959 gpg_do_table[] = {
 960   /* Variables: Fixed size */
 961   { GPG_DO_SEX, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[0] },
 962   { GPG_DO_FP_SIG, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[1] },
 963   { GPG_DO_FP_DEC, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[2] },
 964   { GPG_DO_FP_AUT, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[3] },
 965   { GPG_DO_CAFP_1, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[4] },
 966   { GPG_DO_CAFP_2, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[5] },
 967   { GPG_DO_CAFP_3, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[6] },
 968   { GPG_DO_KGTIME_SIG, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[7] },
 969   { GPG_DO_KGTIME_DEC, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[8] },
 970   { GPG_DO_KGTIME_AUT, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[9] },
 971   /* Variables: Variable size */
 972   { GPG_DO_LOGIN_DATA, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[10] },
 973   { GPG_DO_URL, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[11] },
 974   { GPG_DO_NAME, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[12] },
 975   { GPG_DO_LANGUAGE, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, &do_ptr[13] },
 976   /* Pseudo DO READ: calculated */
 977   { GPG_DO_HIST_BYTES, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_hist_bytes },
 978   { GPG_DO_FP_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_fp_all },
 979   { GPG_DO_CAFP_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_cafp_all },
 980   { GPG_DO_KGTIME_ALL, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_kgtime_all },
 981   /* Pseudo DO READ: calculated, not changeable by user */
 982   { GPG_DO_DS_COUNT, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_ds_count },
 983   { GPG_DO_AID, DO_PROC_READ, AC_ALWAYS, AC_NEVER, do_openpgpcard_aid },
 984   /* Pseudo DO READ/WRITE: calculated */
 985   { GPG_DO_PW_STATUS, DO_PROC_READWRITE, AC_ALWAYS, AC_ADMIN_AUTHORIZED,
 986     rw_pw_status },
 987   /* Fixed data */
 988   { GPG_DO_EXTCAP, DO_FIXED, AC_ALWAYS, AC_NEVER, extended_capabilities },
 989   { GPG_DO_ALG_SIG, DO_FIXED, AC_ALWAYS, AC_NEVER, algorithm_attr },
 990   { GPG_DO_ALG_DEC, DO_FIXED, AC_ALWAYS, AC_NEVER, algorithm_attr },
 991   { GPG_DO_ALG_AUT, DO_FIXED, AC_ALWAYS, AC_NEVER, algorithm_attr },
 992   /* Compound data: Read access only */
 993   { GPG_DO_CH_DATA, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_ch_data },
 994   { GPG_DO_APP_DATA, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_app_data },
 995   { GPG_DO_SS_TEMP, DO_CMP_READ, AC_ALWAYS, AC_NEVER, cmp_ss_temp },
 996   /* Simple data: write access only */
 997   { GPG_DO_RESETTING_CODE, DO_PROC_WRITE, AC_NEVER, AC_ADMIN_AUTHORIZED,
 998     proc_resetting_code },
 999   /* Compound data: Write access only */
1000   { GPG_DO_KEY_IMPORT, DO_PROC_WRITE, AC_NEVER, AC_ADMIN_AUTHORIZED,
1001     proc_key_import },
1002 #if 0
1003   /* Card holder certificate is handled in special way, as its size is big */
1004   { GPG_DO_CH_CERTIFICATE, DO_VAR, AC_ALWAYS, AC_ADMIN_AUTHORIZED, NULL },
1005 #endif
1006 };
1007
1008 #define NUM_DO_ENTRIES (int)(sizeof (gpg_do_table) \
1009                              / sizeof (struct do_table_entry))
1010
1011 /*
1012  * Reading data from Flash ROM, initialize DO_PTR, PW_ERR_COUNTERS, etc.
1013  */
1014 void
1015 gpg_data_scan (const uint8_t *p_start)
1016 {
1017   const uint8_t *p;
1018   int i;
1019   const uint8_t *dsc_h14_p, *dsc_l10_p;
1020   int dsc_h14, dsc_l10;
1021
1022   dsc_h14_p = dsc_l10_p = NULL;
1023   pw1_lifetime_p = NULL;
1024   pw_err_counter_p[PW_ERR_PW1] = NULL;
1025   pw_err_counter_p[PW_ERR_RC] = NULL;
1026   pw_err_counter_p[PW_ERR_PW3] = NULL;
1027
1028   /* Traverse DO, counters, etc. in DATA pool */
1029   p = p_start;
1030   while (*p != NR_EMPTY)
1031     {
1032       uint8_t nr = *p++;
1033       uint8_t second_byte = *p;
1034
1035       if (nr == 0x00 && second_byte == 0x00)
1036         p++;                    /* Skip released word */
1037       else
1038         {
1039           if (nr < 0x80)
1040             {
1041               /* It's Data Object */
1042               do_ptr[nr - NR_DO__FIRST__] = p;
1043               p += second_byte + 1; /* second_byte has length */
1044
1045               if (((uint32_t)p & 1))
1046                 p++;
1047             }
1048           else if (nr >= 0x80 && nr <= 0xbf)
1049             /* Encoded data of Digital Signature Counter: upper 14-bit */
1050             {
1051               dsc_h14_p = p - 1;
1052               p++;
1053             }
1054           else if (nr >= 0xc0 && nr <= 0xc3)
1055             /* Encoded data of Digital Signature Counter: lower 10-bit */
1056             {
1057               dsc_l10_p = p - 1;
1058               p++;
1059             }
1060           else
1061             switch (nr)
1062             {
1063             case NR_BOOL_PW1_LIFETIME:
1064               pw1_lifetime_p = p - 1;
1065               p++;
1066               continue;
1067             case NR_COUNTER_123:
1068               p++;
1069               if (second_byte <= PW_ERR_PW3)
1070                 pw_err_counter_p[second_byte] = p;
1071               p += 2;
1072               break;
1073             }
1074         }
1075     }
1076
1077   flash_set_data_pool_last (p);
1078
1079   num_prv_keys = 0;
1080   if (do_ptr[NR_DO_PRVKEY_SIG - NR_DO__FIRST__] != NULL)
1081     num_prv_keys++;
1082   if (do_ptr[NR_DO_PRVKEY_DEC - NR_DO__FIRST__] != NULL)
1083     num_prv_keys++;
1084   if (do_ptr[NR_DO_PRVKEY_AUT - NR_DO__FIRST__] != NULL)
1085     num_prv_keys++;
1086
1087   data_objects_number_of_bytes = 0;
1088   for (i = NR_DO__FIRST__; i < NR_DO__LAST__; i++)
1089     if (do_ptr[i - NR_DO__FIRST__] != NULL)
1090       data_objects_number_of_bytes += *do_ptr[i - NR_DO__FIRST__];
1091
1092   if (dsc_l10_p == NULL)
1093     dsc_l10 = 0;
1094   else
1095     dsc_l10 = ((*dsc_l10_p - 0xc0) << 8) | *(dsc_l10_p + 1);
1096
1097   if (dsc_h14_p == NULL)
1098     dsc_h14 = 0;
1099   else
1100     {
1101       dsc_h14 = ((*dsc_h14_p - 0x80) << 8) | *(dsc_h14_p + 1);
1102       if (dsc_l10_p == NULL)
1103         DEBUG_INFO ("something wrong in DSC\r\n"); /* weird??? */
1104       else if (dsc_l10_p < dsc_h14_p)
1105         /* Possibly, power off during writing dsc_l10 */
1106         dsc_l10 = 0;
1107     }
1108
1109   digital_signature_counter = (dsc_h14 << 10) | dsc_l10;
1110 }
1111
1112 /*
1113  * Write all data to newly allocated Flash ROM page (from P_START),
1114  * updating PW1_LIFETIME_P, PW_ERR_COUNTER_P, and DO_PTR.
1115  * Called by flash_copying_gc.
1116  */
1117 void
1118 gpg_data_copy (const uint8_t *p_start)
1119 {
1120   const uint8_t *p;
1121   int i;
1122   int v;
1123
1124   p = gpg_write_digital_signature_counter (p_start, digital_signature_counter);
1125
1126   if (pw1_lifetime_p != NULL)
1127     {
1128       flash_bool_write_internal (p, NR_BOOL_PW1_LIFETIME);
1129       pw1_lifetime_p = p;
1130       p += 2;
1131     }
1132
1133   for (i = 0; i < 3; i++)
1134     if ((v = flash_cnt123_get_value (pw_err_counter_p[i])) != 0)
1135       {
1136         flash_cnt123_write_internal (p, i, v);
1137         pw_err_counter_p[i] = p + 2;
1138         p += 4;
1139       }
1140
1141   data_objects_number_of_bytes = 0;
1142   for (i = NR_DO__FIRST__; i < NR_DO__LAST__; i++)
1143     if (do_ptr[i - NR_DO__FIRST__] != NULL)
1144       {
1145         const uint8_t *do_data = do_ptr[i - NR_DO__FIRST__];
1146         int len = do_data[0];
1147
1148         flash_do_write_internal (p, i, &do_data[1], len);
1149         do_ptr[i - NR_DO__FIRST__] = p + 1;
1150         p += 2 + ((len + 1) & ~1);
1151         data_objects_number_of_bytes += len;
1152       }
1153
1154   flash_set_data_pool_last (p);
1155 }
1156
1157 static const struct do_table_entry *
1158 get_do_entry (uint16_t tag)
1159 {
1160   int i;
1161
1162   for (i = 0; i < NUM_DO_ENTRIES; i++)
1163     if (gpg_do_table[i].tag == tag)
1164       return &gpg_do_table[i];
1165
1166   return NULL;
1167 }
1168
1169 static void
1170 copy_do_1 (uint16_t tag, const uint8_t *do_data, int with_tag)
1171 {
1172   int len;
1173
1174   if (with_tag)
1175     {
1176       copy_tag (tag);
1177
1178       if (do_data[0] >= 128)
1179         *res_p++ = 0x81;
1180
1181       len = do_data[0] + 1;
1182     }
1183   else
1184     {
1185       len = do_data[0];
1186       do_data++;
1187     }
1188
1189   memcpy (res_p, do_data, len);
1190   res_p += len;
1191 }
1192
1193 static int
1194 copy_do (const struct do_table_entry *do_p, int with_tag)
1195 {
1196   if (do_p == NULL)
1197     return 0;
1198
1199   if (!ac_check_status (do_p->ac_read))
1200     return -1;
1201
1202   switch (do_p->do_type)
1203     {
1204     case DO_FIXED:
1205       {
1206         const uint8_t *do_data = (const uint8_t *)do_p->obj;
1207         if (do_data == NULL)
1208           return 0;
1209         else
1210           copy_do_1 (do_p->tag, do_data, with_tag);
1211         break;
1212       }
1213     case DO_VAR:
1214       {
1215         const uint8_t *do_data = *(const uint8_t **)do_p->obj;
1216         if (do_data == NULL)
1217           return 0;
1218         else
1219           copy_do_1 (do_p->tag, do_data, with_tag);
1220         break;
1221       }
1222     case DO_CMP_READ:
1223       {
1224         int i;
1225         const uint16_t *cmp_data = (const uint16_t *)do_p->obj;
1226         int num_components = cmp_data[0];
1227         uint8_t *len_p = NULL;
1228
1229         if (with_tag)
1230           {
1231             copy_tag (do_p->tag);
1232             *res_p++ = 0x81;    /* Assume it's less than 256 */
1233             len_p = res_p;
1234             *res_p++ = 0;       /* for now */
1235           }
1236
1237         for (i = 0; i < num_components; i++)
1238           {
1239             uint16_t tag0;
1240             const struct do_table_entry *do0_p;
1241
1242             tag0 = cmp_data[i+1];
1243             do0_p = get_do_entry (tag0);
1244             if (copy_do (do0_p, 1) < 0)
1245               return -1;
1246           }
1247
1248         if (len_p)
1249           *len_p = res_p - len_p - 1;
1250         break;
1251       }
1252     case DO_PROC_READ:
1253       {
1254         int (*do_func)(uint16_t, int) = (int (*)(uint16_t, int))do_p->obj;
1255
1256         return do_func (do_p->tag, with_tag);
1257       }
1258     case DO_PROC_READWRITE:
1259       {
1260         int (*rw_func)(uint16_t, int, uint8_t *, int, int)
1261           = (int (*)(uint16_t, int, uint8_t *, int, int))do_p->obj;
1262
1263         return rw_func (do_p->tag, with_tag, NULL, 0, 0);
1264       }
1265     case DO_PROC_WRITE:
1266       return -1;
1267     }
1268
1269   return 1;
1270 }
1271
1272 /*
1273  * Process GET_DATA request on Data Object specified by TAG
1274  *   Call write_res_adpu to fill data returned
1275  */
1276 void
1277 gpg_do_get_data (uint16_t tag, int with_tag)
1278 {
1279 #if defined(CERTDO_SUPPORT)
1280   if (tag == GPG_DO_CH_CERTIFICATE)
1281     {
1282       apdu.res_apdu_data = &ch_certificate_start;
1283       apdu.res_apdu_data_len = ((apdu.res_apdu_data[2] << 8) | apdu.res_apdu_data[3]);
1284       if (apdu.res_apdu_data_len == 0xffff)
1285         {
1286           apdu.res_apdu_data_len = 0;
1287           GPG_NO_RECORD ();
1288         }
1289       else
1290         /* Add length of (tag+len) */
1291         apdu.res_apdu_data_len += 4;
1292     }
1293   else
1294 #endif
1295     {
1296       const struct do_table_entry *do_p = get_do_entry (tag);
1297
1298       res_p = res_APDU;
1299
1300       DEBUG_INFO ("   ");
1301       DEBUG_SHORT (tag);
1302
1303       if (do_p)
1304         {
1305           if (copy_do (do_p, with_tag) < 0)
1306             /* Overwriting partially written result  */
1307             GPG_SECURITY_FAILURE ();
1308           else
1309             {
1310               res_APDU_size = res_p - res_APDU;
1311               GPG_SUCCESS ();
1312             }
1313         }
1314       else
1315         GPG_NO_RECORD ();
1316     }
1317 }
1318
1319 void
1320 gpg_do_put_data (uint16_t tag, const uint8_t *data, int len)
1321 {
1322   const struct do_table_entry *do_p = get_do_entry (tag);
1323
1324   DEBUG_INFO ("   ");
1325   DEBUG_SHORT (tag);
1326
1327   if (do_p)
1328     {
1329       if (!ac_check_status (do_p->ac_write))
1330         {
1331           GPG_SECURITY_FAILURE ();
1332           return;
1333         }
1334
1335       switch (do_p->do_type)
1336         {
1337         case DO_FIXED:
1338         case DO_CMP_READ:
1339         case DO_PROC_READ:
1340           GPG_SECURITY_FAILURE ();
1341           break;
1342         case DO_VAR:
1343           {
1344             const uint8_t **do_data_p = (const uint8_t **)do_p->obj;
1345
1346             if (*do_data_p)
1347               flash_do_release (*do_data_p);
1348
1349             if (len == 0)
1350               /* make DO empty */
1351               *do_data_p = NULL;
1352             else if (len > 255)
1353               GPG_MEMORY_FAILURE ();
1354             else
1355               {
1356                 uint8_t nr = do_tag_to_nr (tag);
1357
1358                 if (nr == NR_NONE)
1359                   GPG_MEMORY_FAILURE ();
1360                 else
1361                   {
1362                     *do_data_p = flash_do_write (nr, data, len);
1363                     if (*do_data_p)
1364                       GPG_SUCCESS ();
1365                     else
1366                       GPG_MEMORY_FAILURE ();
1367                   }
1368               }
1369             break;
1370           }
1371         case DO_PROC_READWRITE:
1372           {
1373             int (*rw_func)(uint16_t, int, const uint8_t *, int, int)
1374               = (int (*)(uint16_t, int, const uint8_t *, int, int))do_p->obj;
1375
1376             if (rw_func (tag, 0, data, len, 1))
1377               GPG_SUCCESS ();
1378             else
1379               GPG_ERROR ();
1380             break;
1381           }
1382         case DO_PROC_WRITE:
1383           {
1384             int (*proc_func)(const uint8_t *, int)
1385               = (int (*)(const uint8_t *, int))do_p->obj;
1386
1387             if (proc_func (data, len))
1388               GPG_SUCCESS ();
1389             else
1390               GPG_ERROR ();
1391             break;
1392           }
1393         }
1394     }
1395   else
1396     GPG_NO_RECORD ();
1397 }
1398
1399 void
1400 gpg_do_public_key (uint8_t kk_byte)
1401 {
1402   const uint8_t *do_data;
1403   const uint8_t *key_addr;
1404
1405   DEBUG_INFO ("Public key\r\n");
1406   DEBUG_BYTE (kk_byte);
1407
1408   if (kk_byte == 0xb6)
1409     do_data = do_ptr[NR_DO_PRVKEY_SIG - NR_DO__FIRST__];
1410   else if (kk_byte == 0xb8)
1411     do_data = do_ptr[NR_DO_PRVKEY_DEC - NR_DO__FIRST__];
1412   else                          /* 0xa4 */
1413     do_data = do_ptr[NR_DO_PRVKEY_AUT - NR_DO__FIRST__];
1414
1415   if (do_data == NULL)
1416     {
1417       DEBUG_INFO ("none.\r\n");
1418       GPG_NO_RECORD ();
1419       return;
1420     }
1421
1422   key_addr = *(const uint8_t **)&do_data[1];
1423
1424   res_p = res_APDU;
1425
1426   /* TAG */
1427   *res_p++ = 0x7f; *res_p++ = 0x49;
1428   /* LEN = 9+256 */
1429   *res_p++ = 0x82; *res_p++ = 0x01; *res_p++ = 0x09;
1430
1431   {
1432     /*TAG*/          /*LEN = 256 */
1433     *res_p++ = 0x81; *res_p++ = 0x82; *res_p++ = 0x01; *res_p++ = 0x00;
1434     /* 256-byte binary (big endian) */
1435     memcpy (res_p, key_addr + KEY_CONTENT_LEN, KEY_CONTENT_LEN);
1436     res_p += 256;
1437   }
1438   {
1439     /*TAG*/          /*LEN= 3 */
1440     *res_p++ = 0x82; *res_p++ = 3;
1441     /* 3-byte E=0x10001 (big endian) */
1442     *res_p++ = 0x01; *res_p++ = 0x00; *res_p++ = 0x01;
1443
1444     /* Success */
1445     res_APDU_size = res_p - res_APDU;
1446     GPG_SUCCESS ();
1447   }
1448
1449   DEBUG_INFO ("done.\r\n");
1450   return;
1451 }
1452
1453 const uint8_t *
1454 gpg_do_read_simple (uint8_t nr)
1455 {
1456   const uint8_t *do_data;
1457
1458   do_data = do_ptr[nr - NR_DO__FIRST__];
1459   if (do_data == NULL)
1460     return NULL;
1461
1462   return do_data+1;
1463 }
1464
1465 void
1466 gpg_do_write_simple (uint8_t nr, const uint8_t *data, int size)
1467 {
1468   const uint8_t **do_data_p;
1469
1470   do_data_p = (const uint8_t **)&do_ptr[nr - NR_DO__FIRST__];
1471   if (*do_data_p)
1472     flash_do_release (*do_data_p);
1473
1474   if (data != NULL)
1475     {
1476       *do_data_p = flash_do_write (nr, data, size);
1477       if (*do_data_p == NULL)
1478         flash_warning ("DO WRITE ERROR");
1479     }
1480   else
1481     *do_data_p = NULL;
1482 }
1483
1484 #ifdef KEYGEN_SUPPORT
1485 void
1486 gpg_do_keygen (uint8_t kk_byte)
1487 {
1488   enum kind_of_key kk;
1489   const uint8_t *keystring_admin;
1490   const uint8_t *p_q_modulus;
1491   const uint8_t *p_q;
1492   const uint8_t *modulus;
1493   int r;
1494
1495   DEBUG_INFO ("Keygen\r\n");
1496   DEBUG_BYTE (kk_byte);
1497
1498   if (kk_byte == 0xb6)
1499     kk = GPG_KEY_FOR_SIGNING;
1500   else if (kk_byte == 0xb8)
1501     kk = GPG_KEY_FOR_DECRYPTION;
1502   else                          /* 0xa4 */
1503     kk = GPG_KEY_FOR_AUTHENTICATION;
1504
1505   if (admin_authorized == BY_ADMIN)
1506     keystring_admin = keystring_md_pw3;
1507   else
1508     keystring_admin = NULL;
1509
1510   chEvtSignal (main_thread, LED_WAIT_MODE);
1511   p_q_modulus = rsa_genkey ();
1512   chEvtSignal (main_thread, LED_STATUS_MODE);
1513   if (p_q_modulus == NULL)
1514     {
1515       GPG_MEMORY_FAILURE ();
1516       return;
1517     }
1518
1519   p_q = p_q_modulus;
1520   modulus = p_q_modulus + KEY_CONTENT_LEN;
1521
1522   r = gpg_do_write_prvkey (kk, p_q, KEY_CONTENT_LEN,
1523                            keystring_admin, modulus);
1524   free ((uint8_t *)p_q_modulus);
1525   if (r < 0)
1526     {
1527       GPG_ERROR ();
1528       return;
1529     }
1530
1531   DEBUG_INFO ("Calling gpg_do_public_key...\r\n");
1532
1533   if (kk == GPG_KEY_FOR_SIGNING)
1534     {
1535       /* Authintication has been reset within gpg_do_write_prvkey. */
1536       /* But GnuPG expects it's ready for signing. */
1537       /* Thus, we call verify_pso_cds here. */
1538       const uint8_t *ks_pw1 = gpg_do_read_simple (NR_DO_KEYSTRING_PW1);
1539       const uint8_t *pw;
1540       int pw_len;
1541
1542       if (ks_pw1)
1543         {
1544           pw = ks_pw1+1;
1545           pw_len = ks_pw1[0];
1546         }
1547       else
1548         {
1549           pw = (const uint8_t *)OPENPGP_CARD_INITIAL_PW1;
1550           pw_len = strlen (OPENPGP_CARD_INITIAL_PW3);
1551         }
1552
1553       verify_pso_cds (pw, pw_len);
1554     }
1555
1556   gpg_do_public_key (kk_byte);
1557 }
1558 #endif