Line data Source code
1 : /* app-openpgp.c - The OpenPGP card application.
2 : * Copyright (C) 2003, 2004, 2005, 2007, 2008,
3 : * 2009, 2013, 2014, 2015 Free Software Foundation, Inc.
4 : *
5 : * This file is part of GnuPG.
6 : *
7 : * GnuPG is free software; you can redistribute it and/or modify
8 : * it under the terms of the GNU General Public License as published by
9 : * the Free Software Foundation; either version 3 of the License, or
10 : * (at your option) any later version.
11 : *
12 : * GnuPG is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : * GNU General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU General Public License
18 : * along with this program; if not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : /* Some notes:
22 :
23 : CHV means Card Holder Verification and is nothing else than a PIN
24 : or password. That term seems to have been used originally with GSM
25 : cards. Version v2 of the specs changes the term to the clearer
26 : term PW for password. We use the terms here interchangeable
27 : because we do not want to change existing strings i18n wise.
28 :
29 : Version 2 of the specs also drops the separate PW2 which was
30 : required in v1 due to ISO requirements. It is now possible to have
31 : one physical PW but two reference to it so that they can be
32 : individually be verified (e.g. to implement a forced verification
33 : for one key). Thus you will noticed the use of PW2 with the verify
34 : command but not with change_reference_data because the latter
35 : operates directly on the physical PW.
36 :
37 : The Reset Code (RC) as implemented by v2 cards uses the same error
38 : counter as the PW2 of v1 cards. By default no RC is set and thus
39 : that error counter is set to 0. After setting the RC the error
40 : counter will be initialized to 3.
41 :
42 : */
43 :
44 : #include <config.h>
45 : #include <errno.h>
46 : #include <stdio.h>
47 : #include <stdlib.h>
48 : #include <stdarg.h>
49 : #include <string.h>
50 : #include <assert.h>
51 : #include <time.h>
52 :
53 : #if GNUPG_MAJOR_VERSION == 1
54 : /* This is used with GnuPG version < 1.9. The code has been source
55 : copied from the current GnuPG >= 1.9 and is maintained over
56 : there. */
57 : #include "options.h"
58 : #include "errors.h"
59 : #include "memory.h"
60 : #include "cardglue.h"
61 : #else /* GNUPG_MAJOR_VERSION != 1 */
62 : #include "scdaemon.h"
63 : #endif /* GNUPG_MAJOR_VERSION != 1 */
64 :
65 : #include "util.h"
66 : #include "i18n.h"
67 : #include "iso7816.h"
68 : #include "app-common.h"
69 : #include "tlv.h"
70 : #include "host2net.h"
71 : #include "openpgpdefs.h"
72 :
73 :
74 : /* A table describing the DOs of the card. */
75 : static struct {
76 : int tag;
77 : int constructed;
78 : int get_from; /* Constructed DO with this DO or 0 for direct access. */
79 : int binary:1;
80 : int dont_cache:1;
81 : int flush_on_error:1;
82 : int get_immediate_in_v11:1; /* Enable a hack to bypass the cache of
83 : this data object if it is used in 1.1
84 : and later versions of the card. This
85 : does not work with composite DO and
86 : is currently only useful for the CHV
87 : status bytes. */
88 : int try_extlen:1; /* Large object; try to use an extended
89 : length APDU. */
90 : char *desc;
91 : } data_objects[] = {
92 : { 0x005E, 0, 0, 1, 0, 0, 0, 0, "Login Data" },
93 : { 0x5F50, 0, 0, 0, 0, 0, 0, 0, "URL" },
94 : { 0x5F52, 0, 0, 1, 0, 0, 0, 0, "Historical Bytes" },
95 : { 0x0065, 1, 0, 1, 0, 0, 0, 0, "Cardholder Related Data"},
96 : { 0x005B, 0, 0x65, 0, 0, 0, 0, 0, "Name" },
97 : { 0x5F2D, 0, 0x65, 0, 0, 0, 0, 0, "Language preferences" },
98 : { 0x5F35, 0, 0x65, 0, 0, 0, 0, 0, "Sex" },
99 : { 0x006E, 1, 0, 1, 0, 0, 0, 0, "Application Related Data" },
100 : { 0x004F, 0, 0x6E, 1, 0, 0, 0, 0, "AID" },
101 : { 0x0073, 1, 0, 1, 0, 0, 0, 0, "Discretionary Data Objects" },
102 : { 0x0047, 0, 0x6E, 1, 1, 0, 0, 0, "Card Capabilities" },
103 : { 0x00C0, 0, 0x6E, 1, 1, 0, 0, 0, "Extended Card Capabilities" },
104 : { 0x00C1, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Signature" },
105 : { 0x00C2, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Decryption" },
106 : { 0x00C3, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Authentication" },
107 : { 0x00C4, 0, 0x6E, 1, 0, 1, 1, 0, "CHV Status Bytes" },
108 : { 0x00C5, 0, 0x6E, 1, 0, 0, 0, 0, "Fingerprints" },
109 : { 0x00C6, 0, 0x6E, 1, 0, 0, 0, 0, "CA Fingerprints" },
110 : { 0x00CD, 0, 0x6E, 1, 0, 0, 0, 0, "Generation time" },
111 : { 0x007A, 1, 0, 1, 0, 0, 0, 0, "Security Support Template" },
112 : { 0x0093, 0, 0x7A, 1, 1, 0, 0, 0, "Digital Signature Counter" },
113 : { 0x0101, 0, 0, 0, 0, 0, 0, 0, "Private DO 1"},
114 : { 0x0102, 0, 0, 0, 0, 0, 0, 0, "Private DO 2"},
115 : { 0x0103, 0, 0, 0, 0, 0, 0, 0, "Private DO 3"},
116 : { 0x0104, 0, 0, 0, 0, 0, 0, 0, "Private DO 4"},
117 : { 0x7F21, 1, 0, 1, 0, 0, 0, 1, "Cardholder certificate"},
118 : /* V3.0 */
119 : { 0x7F74, 0, 0, 1, 0, 0, 0, 0, "General Feature Management"},
120 : { 0x00D5, 0, 0, 1, 0, 0, 0, 0, "AES key data"},
121 : { 0 }
122 : };
123 :
124 :
125 : /* Type of keys. */
126 : typedef enum
127 : {
128 : KEY_TYPE_ECC,
129 : KEY_TYPE_RSA,
130 : }
131 : key_type_t;
132 :
133 :
134 : /* The format of RSA private keys. */
135 : typedef enum
136 : {
137 : RSA_UNKNOWN_FMT,
138 : RSA_STD,
139 : RSA_STD_N,
140 : RSA_CRT,
141 : RSA_CRT_N
142 : }
143 : rsa_key_format_t;
144 :
145 :
146 : /* One cache item for DOs. */
147 : struct cache_s {
148 : struct cache_s *next;
149 : int tag;
150 : size_t length;
151 : unsigned char data[1];
152 : };
153 :
154 :
155 : /* Object with application (i.e. OpenPGP card) specific data. */
156 : struct app_local_s {
157 : /* A linked list with cached DOs. */
158 : struct cache_s *cache;
159 :
160 : /* Keep track of the public keys. */
161 : struct
162 : {
163 : int read_done; /* True if we have at least tried to read them. */
164 : unsigned char *key; /* This is a malloced buffer with a canonical
165 : encoded S-expression encoding a public
166 : key. Might be NULL if key is not
167 : available. */
168 : size_t keylen; /* The length of the above S-expression. This
169 : is usually only required for cross checks
170 : because the length of an S-expression is
171 : implicitly available. */
172 : } pk[3];
173 :
174 : unsigned char status_indicator; /* The card status indicator. */
175 :
176 : unsigned int manufacturer:16; /* Manufacturer ID from the s/n. */
177 :
178 : /* Keep track of the ISO card capabilities. */
179 : struct
180 : {
181 : unsigned int cmd_chaining:1; /* Command chaining is supported. */
182 : unsigned int ext_lc_le:1; /* Extended Lc and Le are supported. */
183 : } cardcap;
184 :
185 : /* Keep track of extended card capabilities. */
186 : struct
187 : {
188 : unsigned int is_v2:1; /* This is a v2.0 compatible card. */
189 : unsigned int sm_supported:1; /* Secure Messaging is supported. */
190 : unsigned int get_challenge:1;
191 : unsigned int key_import:1;
192 : unsigned int change_force_chv:1;
193 : unsigned int private_dos:1;
194 : unsigned int algo_attr_change:1; /* Algorithm attributes changeable. */
195 : unsigned int has_decrypt:1; /* Support symmetric decryption. */
196 : unsigned int has_button:1;
197 : unsigned int sm_algo:2; /* Symmetric crypto algo for SM. */
198 : unsigned int max_certlen_3:16;
199 : unsigned int max_get_challenge:16; /* Maximum size for get_challenge. */
200 : unsigned int max_cmd_data:16; /* Maximum data size for a command. */
201 : unsigned int max_rsp_data:16; /* Maximum size of a response. */
202 : } extcap;
203 :
204 : /* Flags used to control the application. */
205 : struct
206 : {
207 : unsigned int no_sync:1; /* Do not sync CHV1 and CHV2 */
208 : unsigned int def_chv2:1; /* Use 123456 for CHV2. */
209 : } flags;
210 :
211 : /* Pinpad request specified on card. */
212 : struct
213 : {
214 : unsigned int specified:1;
215 : int fixedlen_user;
216 : int fixedlen_admin;
217 : } pinpad;
218 :
219 : struct
220 : {
221 : key_type_t key_type;
222 : union {
223 : struct {
224 : unsigned int n_bits; /* Size of the modulus in bits. The rest
225 : of this strucuire is only valid if
226 : this is not 0. */
227 : unsigned int e_bits; /* Size of the public exponent in bits. */
228 : rsa_key_format_t format;
229 : } rsa;
230 : struct {
231 : const char *oid;
232 : int flags;
233 : } ecc;
234 : };
235 : } keyattr[3];
236 : };
237 :
238 : #define ECC_FLAG_DJB_TWEAK (1 << 0)
239 :
240 :
241 : /***** Local prototypes *****/
242 : static unsigned long convert_sig_counter_value (const unsigned char *value,
243 : size_t valuelen);
244 : static unsigned long get_sig_counter (app_t app);
245 : static gpg_error_t do_auth (app_t app, const char *keyidstr,
246 : gpg_error_t (*pincb)(void*, const char *, char **),
247 : void *pincb_arg,
248 : const void *indata, size_t indatalen,
249 : unsigned char **outdata, size_t *outdatalen);
250 : static void parse_algorithm_attribute (app_t app, int keyno);
251 : static gpg_error_t change_keyattr_from_string
252 : (app_t app,
253 : gpg_error_t (*pincb)(void*, const char *, char **),
254 : void *pincb_arg,
255 : const void *value, size_t valuelen);
256 :
257 :
258 :
259 :
260 :
261 : /* Deconstructor. */
262 : static void
263 0 : do_deinit (app_t app)
264 : {
265 0 : if (app && app->app_local)
266 : {
267 : struct cache_s *c, *c2;
268 : int i;
269 :
270 0 : for (c = app->app_local->cache; c; c = c2)
271 : {
272 0 : c2 = c->next;
273 0 : xfree (c);
274 : }
275 :
276 0 : for (i=0; i < DIM (app->app_local->pk); i++)
277 : {
278 0 : xfree (app->app_local->pk[i].key);
279 0 : app->app_local->pk[i].read_done = 0;
280 : }
281 0 : xfree (app->app_local);
282 0 : app->app_local = NULL;
283 : }
284 0 : }
285 :
286 :
287 : /* Wrapper around iso7816_get_data which first tries to get the data
288 : from the cache. With GET_IMMEDIATE passed as true, the cache is
289 : bypassed. With TRY_EXTLEN extended lengths APDUs are use if
290 : supported by the card. */
291 : static gpg_error_t
292 0 : get_cached_data (app_t app, int tag,
293 : unsigned char **result, size_t *resultlen,
294 : int get_immediate, int try_extlen)
295 : {
296 : gpg_error_t err;
297 : int i;
298 : unsigned char *p;
299 : size_t len;
300 : struct cache_s *c;
301 : int exmode;
302 :
303 0 : *result = NULL;
304 0 : *resultlen = 0;
305 :
306 0 : if (!get_immediate)
307 : {
308 0 : for (c=app->app_local->cache; c; c = c->next)
309 0 : if (c->tag == tag)
310 : {
311 0 : if(c->length)
312 : {
313 0 : p = xtrymalloc (c->length);
314 0 : if (!p)
315 0 : return gpg_error (gpg_err_code_from_errno (errno));
316 0 : memcpy (p, c->data, c->length);
317 0 : *result = p;
318 : }
319 :
320 0 : *resultlen = c->length;
321 :
322 0 : return 0;
323 : }
324 : }
325 :
326 0 : if (try_extlen && app->app_local->cardcap.ext_lc_le)
327 0 : exmode = app->app_local->extcap.max_rsp_data;
328 : else
329 0 : exmode = 0;
330 :
331 0 : err = iso7816_get_data (app->slot, exmode, tag, &p, &len);
332 0 : if (err)
333 0 : return err;
334 0 : *result = p;
335 0 : *resultlen = len;
336 :
337 : /* Check whether we should cache this object. */
338 0 : if (get_immediate)
339 0 : return 0;
340 :
341 0 : for (i=0; data_objects[i].tag; i++)
342 0 : if (data_objects[i].tag == tag)
343 : {
344 0 : if (data_objects[i].dont_cache)
345 0 : return 0;
346 0 : break;
347 : }
348 :
349 : /* Okay, cache it. */
350 0 : for (c=app->app_local->cache; c; c = c->next)
351 0 : assert (c->tag != tag);
352 :
353 0 : c = xtrymalloc (sizeof *c + len);
354 0 : if (c)
355 : {
356 0 : memcpy (c->data, p, len);
357 0 : c->length = len;
358 0 : c->tag = tag;
359 0 : c->next = app->app_local->cache;
360 0 : app->app_local->cache = c;
361 : }
362 :
363 0 : return 0;
364 : }
365 :
366 : /* Remove DO at TAG from the cache. */
367 : static void
368 0 : flush_cache_item (app_t app, int tag)
369 : {
370 : struct cache_s *c, *cprev;
371 : int i;
372 :
373 0 : if (!app->app_local)
374 0 : return;
375 :
376 0 : for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
377 0 : if (c->tag == tag)
378 : {
379 0 : if (cprev)
380 0 : cprev->next = c->next;
381 : else
382 0 : app->app_local->cache = c->next;
383 0 : xfree (c);
384 :
385 0 : for (c=app->app_local->cache; c ; c = c->next)
386 : {
387 0 : assert (c->tag != tag); /* Oops: duplicated entry. */
388 : }
389 0 : return;
390 : }
391 :
392 : /* Try again if we have an outer tag. */
393 0 : for (i=0; data_objects[i].tag; i++)
394 0 : if (data_objects[i].tag == tag && data_objects[i].get_from
395 0 : && data_objects[i].get_from != tag)
396 0 : flush_cache_item (app, data_objects[i].get_from);
397 : }
398 :
399 : /* Flush all entries from the cache which might be out of sync after
400 : an error. */
401 : static void
402 0 : flush_cache_after_error (app_t app)
403 : {
404 : int i;
405 :
406 0 : for (i=0; data_objects[i].tag; i++)
407 0 : if (data_objects[i].flush_on_error)
408 0 : flush_cache_item (app, data_objects[i].tag);
409 0 : }
410 :
411 :
412 : /* Flush the entire cache. */
413 : static void
414 0 : flush_cache (app_t app)
415 : {
416 0 : if (app && app->app_local)
417 : {
418 : struct cache_s *c, *c2;
419 :
420 0 : for (c = app->app_local->cache; c; c = c2)
421 : {
422 0 : c2 = c->next;
423 0 : xfree (c);
424 : }
425 0 : app->app_local->cache = NULL;
426 : }
427 0 : }
428 :
429 :
430 : /* Get the DO identified by TAG from the card in SLOT and return a
431 : buffer with its content in RESULT and NBYTES. The return value is
432 : NULL if not found or a pointer which must be used to release the
433 : buffer holding value. */
434 : static void *
435 0 : get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
436 : int *r_rc)
437 : {
438 : int rc, i;
439 : unsigned char *buffer;
440 : size_t buflen;
441 : unsigned char *value;
442 : size_t valuelen;
443 : int dummyrc;
444 : int exmode;
445 :
446 0 : if (!r_rc)
447 0 : r_rc = &dummyrc;
448 :
449 0 : *result = NULL;
450 0 : *nbytes = 0;
451 0 : *r_rc = 0;
452 0 : for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
453 : ;
454 :
455 0 : if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
456 : {
457 0 : if (data_objects[i].try_extlen && app->app_local->cardcap.ext_lc_le)
458 0 : exmode = app->app_local->extcap.max_rsp_data;
459 : else
460 0 : exmode = 0;
461 0 : rc = iso7816_get_data (app->slot, exmode, tag, &buffer, &buflen);
462 0 : if (rc)
463 : {
464 0 : *r_rc = rc;
465 0 : return NULL;
466 : }
467 0 : *result = buffer;
468 0 : *nbytes = buflen;
469 0 : return buffer;
470 : }
471 :
472 0 : value = NULL;
473 0 : rc = -1;
474 0 : if (data_objects[i].tag && data_objects[i].get_from)
475 : {
476 0 : rc = get_cached_data (app, data_objects[i].get_from,
477 : &buffer, &buflen,
478 0 : (data_objects[i].dont_cache
479 0 : || data_objects[i].get_immediate_in_v11),
480 0 : data_objects[i].try_extlen);
481 0 : if (!rc)
482 : {
483 : const unsigned char *s;
484 :
485 0 : s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
486 0 : if (!s)
487 0 : value = NULL; /* not found */
488 0 : else if (valuelen > buflen - (s - buffer))
489 : {
490 0 : log_error ("warning: constructed DO too short\n");
491 0 : value = NULL;
492 0 : xfree (buffer); buffer = NULL;
493 : }
494 : else
495 0 : value = buffer + (s - buffer);
496 : }
497 : }
498 :
499 0 : if (!value) /* Not in a constructed DO, try simple. */
500 : {
501 0 : rc = get_cached_data (app, tag, &buffer, &buflen,
502 0 : (data_objects[i].dont_cache
503 0 : || data_objects[i].get_immediate_in_v11),
504 0 : data_objects[i].try_extlen);
505 0 : if (!rc)
506 : {
507 0 : value = buffer;
508 0 : valuelen = buflen;
509 : }
510 : }
511 :
512 0 : if (!rc)
513 : {
514 0 : *nbytes = valuelen;
515 0 : *result = value;
516 0 : return buffer;
517 : }
518 0 : *r_rc = rc;
519 0 : return NULL;
520 : }
521 :
522 :
523 : static void
524 0 : dump_all_do (int slot)
525 : {
526 : int rc, i, j;
527 : unsigned char *buffer;
528 : size_t buflen;
529 :
530 0 : for (i=0; data_objects[i].tag; i++)
531 : {
532 0 : if (data_objects[i].get_from)
533 0 : continue;
534 :
535 : /* We don't try extended length APDU because such large DO would
536 : be pretty useless in a log file. */
537 0 : rc = iso7816_get_data (slot, 0, data_objects[i].tag, &buffer, &buflen);
538 0 : if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
539 : ;
540 0 : else if (rc)
541 0 : log_info ("DO '%s' not available: %s\n",
542 : data_objects[i].desc, gpg_strerror (rc));
543 : else
544 : {
545 0 : if (data_objects[i].binary)
546 : {
547 0 : log_info ("DO '%s': ", data_objects[i].desc);
548 0 : log_printhex ("", buffer, buflen);
549 : }
550 : else
551 0 : log_info ("DO '%s': '%.*s'\n",
552 : data_objects[i].desc,
553 : (int)buflen, buffer); /* FIXME: sanitize */
554 :
555 0 : if (data_objects[i].constructed)
556 : {
557 0 : for (j=0; data_objects[j].tag; j++)
558 : {
559 : const unsigned char *value;
560 : size_t valuelen;
561 :
562 0 : if (j==i || data_objects[i].tag != data_objects[j].get_from)
563 0 : continue;
564 0 : value = find_tlv_unchecked (buffer, buflen,
565 : data_objects[j].tag, &valuelen);
566 0 : if (!value)
567 : ; /* not found */
568 0 : else if (valuelen > buflen - (value - buffer))
569 0 : log_error ("warning: constructed DO too short\n");
570 : else
571 : {
572 0 : if (data_objects[j].binary)
573 : {
574 0 : log_info ("DO '%s': ", data_objects[j].desc);
575 0 : if (valuelen > 200)
576 0 : log_info ("[%u]\n", (unsigned int)valuelen);
577 : else
578 0 : log_printhex ("", value, valuelen);
579 : }
580 : else
581 0 : log_info ("DO '%s': '%.*s'\n",
582 : data_objects[j].desc,
583 : (int)valuelen, value); /* FIXME: sanitize */
584 : }
585 : }
586 : }
587 : }
588 0 : xfree (buffer); buffer = NULL;
589 : }
590 0 : }
591 :
592 :
593 : /* Count the number of bits, assuming the A represents an unsigned big
594 : integer of length LEN bytes. */
595 : static unsigned int
596 0 : count_bits (const unsigned char *a, size_t len)
597 : {
598 0 : unsigned int n = len * 8;
599 : int i;
600 :
601 0 : for (; len && !*a; len--, a++, n -=8)
602 : ;
603 0 : if (len)
604 : {
605 0 : for (i=7; i && !(*a & (1<<i)); i--)
606 0 : n--;
607 : }
608 0 : return n;
609 : }
610 :
611 : /* GnuPG makes special use of the login-data DO, this function parses
612 : the login data to store the flags for later use. It may be called
613 : at any time and should be called after changing the login-data DO.
614 :
615 : Everything up to a LF is considered a mailbox or account name. If
616 : the first LF is followed by DC4 (0x14) control sequence are
617 : expected up to the next LF. Control sequences are separated by FS
618 : (0x18) and consist of key=value pairs. There are two keys defined:
619 :
620 : F=<flags>
621 :
622 : Where FLAGS is a plain hexadecimal number representing flag values.
623 : The lsb is here the rightmost bit. Defined flags bits are:
624 :
625 : Bit 0 = CHV1 and CHV2 are not syncronized
626 : Bit 1 = CHV2 has been been set to the default PIN of "123456"
627 : (this implies that bit 0 is also set).
628 :
629 : P=<pinpad-request>
630 :
631 : Where PINPAD_REQUEST is in the format of: <n> or <n>,<m>.
632 : N for user PIN, M for admin PIN. If M is missing it means M=N.
633 : 0 means to force not to use pinpad.
634 :
635 : */
636 : static void
637 0 : parse_login_data (app_t app)
638 : {
639 : unsigned char *buffer, *p;
640 : size_t buflen, len;
641 : void *relptr;
642 :
643 : /* Set defaults. */
644 0 : app->app_local->flags.no_sync = 0;
645 0 : app->app_local->flags.def_chv2 = 0;
646 0 : app->app_local->pinpad.specified = 0;
647 0 : app->app_local->pinpad.fixedlen_user = -1;
648 0 : app->app_local->pinpad.fixedlen_admin = -1;
649 :
650 : /* Read the DO. */
651 0 : relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
652 0 : if (!relptr)
653 0 : return; /* Ooops. */
654 0 : for (; buflen; buflen--, buffer++)
655 0 : if (*buffer == '\n')
656 0 : break;
657 0 : if (buflen < 2 || buffer[1] != '\x14')
658 : {
659 0 : xfree (relptr);
660 0 : return; /* No control sequences. */
661 : }
662 :
663 0 : buflen--;
664 0 : buffer++;
665 : do
666 : {
667 0 : buflen--;
668 0 : buffer++;
669 0 : if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
670 0 : {
671 : /* Flags control sequence found. */
672 0 : int lastdig = 0;
673 :
674 : /* For now we are only interested in the last digit, so skip
675 : any leading digits but bail out on invalid characters. */
676 0 : for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
677 0 : lastdig = xtoi_1 (p);
678 0 : buffer = p;
679 0 : buflen = len;
680 0 : if (len && !(*p == '\n' || *p == '\x18'))
681 0 : goto next; /* Invalid characters in field. */
682 0 : app->app_local->flags.no_sync = !!(lastdig & 1);
683 0 : app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
684 : }
685 0 : else if (buflen > 1 && *buffer == 'P' && buffer[1] == '=')
686 : {
687 : /* Pinpad request control sequence found. */
688 0 : buffer += 2;
689 0 : buflen -= 2;
690 :
691 0 : if (buflen)
692 : {
693 0 : if (digitp (buffer))
694 : {
695 : char *q;
696 : int n, m;
697 :
698 0 : n = strtol (buffer, &q, 10);
699 0 : if (q >= (char *)buffer + buflen
700 0 : || *q == '\x18' || *q == '\n')
701 0 : m = n;
702 : else
703 : {
704 0 : if (*q++ != ',' || !digitp (q))
705 : goto next;
706 0 : m = strtol (q, &q, 10);
707 : }
708 :
709 0 : if (buflen < ((unsigned char *)q - buffer))
710 0 : break;
711 :
712 0 : buflen -= ((unsigned char *)q - buffer);
713 0 : buffer = q;
714 :
715 0 : if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
716 0 : goto next;
717 0 : app->app_local->pinpad.specified = 1;
718 0 : app->app_local->pinpad.fixedlen_user = n;
719 0 : app->app_local->pinpad.fixedlen_admin = m;
720 : }
721 : }
722 : }
723 : next:
724 : /* Skip to FS (0x18) or LF (\n). */
725 0 : for (; buflen && *buffer != '\x18' && *buffer != '\n'; buflen--)
726 0 : buffer++;
727 : }
728 0 : while (buflen && *buffer != '\n');
729 :
730 0 : xfree (relptr);
731 : }
732 :
733 :
734 : #define MAX_ARGS_STORE_FPR 3
735 :
736 : /* Note, that FPR must be at least 20 bytes. */
737 : static gpg_error_t
738 0 : store_fpr (app_t app, int keynumber, u32 timestamp, unsigned char *fpr,
739 : int algo, ...)
740 : {
741 : unsigned int n, nbits;
742 : unsigned char *buffer, *p;
743 : int tag, tag2;
744 : int rc;
745 : const unsigned char *m[MAX_ARGS_STORE_FPR];
746 : size_t mlen[MAX_ARGS_STORE_FPR];
747 : va_list ap;
748 : int argc;
749 : int i;
750 :
751 0 : n = 6; /* key packet version, 4-byte timestamps, and algorithm */
752 0 : if (algo == PUBKEY_ALGO_ECDH)
753 0 : argc = 3;
754 : else
755 0 : argc = 2;
756 :
757 0 : va_start (ap, algo);
758 0 : for (i = 0; i < argc; i++)
759 : {
760 0 : m[i] = va_arg (ap, const unsigned char *);
761 0 : mlen[i] = va_arg (ap, size_t);
762 0 : if (algo == PUBKEY_ALGO_RSA || i == 1)
763 0 : n += 2;
764 0 : n += mlen[i];
765 : }
766 0 : va_end (ap);
767 :
768 0 : p = buffer = xtrymalloc (3 + n);
769 0 : if (!buffer)
770 0 : return gpg_error_from_syserror ();
771 :
772 0 : *p++ = 0x99; /* ctb */
773 0 : *p++ = n >> 8; /* 2 byte length header */
774 0 : *p++ = n;
775 0 : *p++ = 4; /* key packet version */
776 0 : *p++ = timestamp >> 24;
777 0 : *p++ = timestamp >> 16;
778 0 : *p++ = timestamp >> 8;
779 0 : *p++ = timestamp;
780 0 : *p++ = algo;
781 :
782 0 : for (i = 0; i < argc; i++)
783 : {
784 0 : if (algo == PUBKEY_ALGO_RSA || i == 1)
785 : {
786 0 : nbits = count_bits (m[i], mlen[i]);
787 0 : *p++ = nbits >> 8;
788 0 : *p++ = nbits;
789 : }
790 0 : memcpy (p, m[i], mlen[i]);
791 0 : p += mlen[i];
792 : }
793 :
794 0 : gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
795 :
796 0 : xfree (buffer);
797 :
798 0 : tag = (app->card_version > 0x0007? 0xC7 : 0xC6) + keynumber;
799 0 : flush_cache_item (app, 0xC5);
800 0 : tag2 = 0xCE + keynumber;
801 0 : flush_cache_item (app, 0xCD);
802 :
803 0 : rc = iso7816_put_data (app->slot, 0, tag, fpr, 20);
804 0 : if (rc)
805 0 : log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
806 :
807 0 : if (!rc && app->card_version > 0x0100)
808 : {
809 : unsigned char buf[4];
810 :
811 0 : buf[0] = timestamp >> 24;
812 0 : buf[1] = timestamp >> 16;
813 0 : buf[2] = timestamp >> 8;
814 0 : buf[3] = timestamp;
815 :
816 0 : rc = iso7816_put_data (app->slot, 0, tag2, buf, 4);
817 0 : if (rc)
818 0 : log_error (_("failed to store the creation date: %s\n"),
819 : gpg_strerror (rc));
820 : }
821 :
822 0 : return rc;
823 : }
824 :
825 :
826 : static void
827 0 : send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
828 : int number, const unsigned char *fpr)
829 : {
830 : int i;
831 : char buf[41];
832 : char numbuf[25];
833 :
834 0 : for (i=0; i < 20 && !fpr[i]; i++)
835 : ;
836 0 : if (i==20)
837 0 : return; /* All zero. */
838 0 : bin2hex (fpr, 20, buf);
839 0 : if (number == -1)
840 0 : *numbuf = 0; /* Don't print the key number */
841 : else
842 0 : sprintf (numbuf, "%d", number);
843 0 : send_status_info (ctrl, keyword,
844 : numbuf, (size_t)strlen(numbuf),
845 : buf, (size_t)strlen (buf), NULL, 0);
846 : }
847 :
848 : static void
849 0 : send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
850 : int number, const unsigned char *stamp)
851 : {
852 : char numbuf1[50], numbuf2[50];
853 : unsigned long value;
854 :
855 0 : value = buf32_to_ulong (stamp);
856 0 : if (!value)
857 0 : return;
858 0 : sprintf (numbuf1, "%d", number);
859 0 : sprintf (numbuf2, "%lu", value);
860 0 : send_status_info (ctrl, keyword,
861 : numbuf1, (size_t)strlen(numbuf1),
862 : numbuf2, (size_t)strlen(numbuf2), NULL, 0);
863 : }
864 :
865 : static void
866 0 : send_key_data (ctrl_t ctrl, const char *name,
867 : const unsigned char *a, size_t alen)
868 : {
869 : char *buffer, *buf;
870 : size_t buflen;
871 :
872 0 : buffer = buf = bin2hex (a, alen, NULL);
873 0 : if (!buffer)
874 : {
875 0 : log_error ("memory allocation error in send_key_data\n");
876 0 : return;
877 : }
878 0 : buflen = strlen (buffer);
879 :
880 : /* 768 is the hexified size for the modulus of an 3072 bit key. We
881 : use extra chunks to transmit larger data (i.e for 4096 bit). */
882 0 : for ( ;buflen > 768; buflen -= 768, buf += 768)
883 0 : send_status_info (ctrl, "KEY-DATA",
884 : "-", 1,
885 : buf, 768,
886 : NULL, 0);
887 0 : send_status_info (ctrl, "KEY-DATA",
888 : name, (size_t)strlen(name),
889 : buf, buflen,
890 : NULL, 0);
891 0 : xfree (buffer);
892 : }
893 :
894 :
895 : static void
896 0 : send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int keyno)
897 : {
898 : char buffer[200];
899 :
900 0 : assert (keyno >=0 && keyno < DIM(app->app_local->keyattr));
901 :
902 0 : if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
903 0 : snprintf (buffer, sizeof buffer, "%d 1 rsa%u %u %d",
904 : keyno+1,
905 0 : app->app_local->keyattr[keyno].rsa.n_bits,
906 0 : app->app_local->keyattr[keyno].rsa.e_bits,
907 0 : app->app_local->keyattr[keyno].rsa.format);
908 0 : else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
909 : {
910 0 : snprintf (buffer, sizeof buffer, "%d %d %s",
911 : keyno+1,
912 : keyno==1? PUBKEY_ALGO_ECDH :
913 0 : app->app_local->keyattr[keyno].ecc.flags?
914 0 : PUBKEY_ALGO_EDDSA : PUBKEY_ALGO_ECDSA,
915 0 : openpgp_oid_to_curve (app->app_local->keyattr[keyno].ecc.oid, 0));
916 : }
917 : else
918 0 : snprintf (buffer, sizeof buffer, "%d 0 0 UNKNOWN", keyno+1);
919 :
920 0 : send_status_direct (ctrl, keyword, buffer);
921 0 : }
922 :
923 :
924 : /* Implement the GETATTR command. This is similar to the LEARN
925 : command but returns just one value via the status interface. */
926 : static gpg_error_t
927 0 : do_getattr (app_t app, ctrl_t ctrl, const char *name)
928 : {
929 : static struct {
930 : const char *name;
931 : int tag;
932 : int special;
933 : } table[] = {
934 : { "DISP-NAME", 0x005B },
935 : { "LOGIN-DATA", 0x005E },
936 : { "DISP-LANG", 0x5F2D },
937 : { "DISP-SEX", 0x5F35 },
938 : { "PUBKEY-URL", 0x5F50 },
939 : { "KEY-FPR", 0x00C5, 3 },
940 : { "KEY-TIME", 0x00CD, 4 },
941 : { "KEY-ATTR", 0x0000, -5 },
942 : { "CA-FPR", 0x00C6, 3 },
943 : { "CHV-STATUS", 0x00C4, 1 },
944 : { "SIG-COUNTER", 0x0093, 2 },
945 : { "SERIALNO", 0x004F, -1 },
946 : { "AID", 0x004F },
947 : { "EXTCAP", 0x0000, -2 },
948 : { "PRIVATE-DO-1", 0x0101 },
949 : { "PRIVATE-DO-2", 0x0102 },
950 : { "PRIVATE-DO-3", 0x0103 },
951 : { "PRIVATE-DO-4", 0x0104 },
952 : { "$AUTHKEYID", 0x0000, -3 },
953 : { "$DISPSERIALNO",0x0000, -4 },
954 : { NULL, 0 }
955 : };
956 : int idx, i, rc;
957 : void *relptr;
958 : unsigned char *value;
959 : size_t valuelen;
960 :
961 0 : for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
962 : ;
963 0 : if (!table[idx].name)
964 0 : return gpg_error (GPG_ERR_INV_NAME);
965 :
966 0 : if (table[idx].special == -1)
967 : {
968 : /* The serial number is very special. We could have used the
969 : AID DO to retrieve it, but we have it already in the app
970 : context and the stamp argument is required anyway which we
971 : can't by other means. The AID DO is available anyway but not
972 : hex formatted. */
973 : char *serial;
974 : time_t stamp;
975 : char tmp[50];
976 :
977 0 : if (!app_get_serial_and_stamp (app, &serial, &stamp))
978 : {
979 0 : sprintf (tmp, "%lu", (unsigned long)stamp);
980 0 : send_status_info (ctrl, "SERIALNO",
981 : serial, strlen (serial),
982 : tmp, strlen (tmp),
983 : NULL, 0);
984 0 : xfree (serial);
985 : }
986 0 : return 0;
987 : }
988 0 : if (table[idx].special == -2)
989 : {
990 : char tmp[110];
991 :
992 0 : snprintf (tmp, sizeof tmp,
993 : "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d "
994 : "sm=%d si=%u dec=%d bt=%d",
995 0 : app->app_local->extcap.get_challenge,
996 0 : app->app_local->extcap.key_import,
997 0 : app->app_local->extcap.change_force_chv,
998 0 : app->app_local->extcap.private_dos,
999 0 : app->app_local->extcap.max_certlen_3,
1000 0 : app->app_local->extcap.algo_attr_change,
1001 0 : (app->app_local->extcap.sm_supported
1002 0 : ? (app->app_local->extcap.sm_algo == 0? CIPHER_ALGO_3DES :
1003 0 : (app->app_local->extcap.sm_algo == 1?
1004 0 : CIPHER_ALGO_AES : CIPHER_ALGO_AES256))
1005 : : 0),
1006 0 : app->app_local->status_indicator,
1007 0 : app->app_local->extcap.has_decrypt,
1008 0 : app->app_local->extcap.has_button);
1009 0 : send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1010 0 : return 0;
1011 : }
1012 0 : if (table[idx].special == -3)
1013 : {
1014 0 : char const tmp[] = "OPENPGP.3";
1015 0 : send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1016 0 : return 0;
1017 : }
1018 0 : if (table[idx].special == -4)
1019 : {
1020 : char *serial;
1021 : time_t stamp;
1022 :
1023 0 : if (!app_get_serial_and_stamp (app, &serial, &stamp))
1024 : {
1025 0 : if (strlen (serial) > 16+12)
1026 : {
1027 0 : send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
1028 0 : xfree (serial);
1029 0 : return 0;
1030 : }
1031 0 : xfree (serial);
1032 : }
1033 0 : return gpg_error (GPG_ERR_INV_NAME);
1034 : }
1035 0 : if (table[idx].special == -5)
1036 : {
1037 0 : for (i=0; i < 3; i++)
1038 0 : send_key_attr (ctrl, app, table[idx].name, i);
1039 0 : return 0;
1040 : }
1041 :
1042 0 : relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
1043 0 : if (relptr)
1044 : {
1045 0 : if (table[idx].special == 1)
1046 : {
1047 : char numbuf[7*23];
1048 :
1049 0 : for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
1050 0 : sprintf (numbuf+strlen (numbuf), " %d", value[i]);
1051 0 : send_status_info (ctrl, table[idx].name,
1052 : numbuf, strlen (numbuf), NULL, 0);
1053 : }
1054 0 : else if (table[idx].special == 2)
1055 : {
1056 : char numbuf[50];
1057 :
1058 0 : sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
1059 0 : send_status_info (ctrl, table[idx].name,
1060 : numbuf, strlen (numbuf), NULL, 0);
1061 : }
1062 0 : else if (table[idx].special == 3)
1063 : {
1064 0 : if (valuelen >= 60)
1065 0 : for (i=0; i < 3; i++)
1066 0 : send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1067 : }
1068 0 : else if (table[idx].special == 4)
1069 : {
1070 0 : if (valuelen >= 12)
1071 0 : for (i=0; i < 3; i++)
1072 0 : send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1073 : }
1074 : else
1075 0 : send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1076 :
1077 0 : xfree (relptr);
1078 : }
1079 0 : return rc;
1080 : }
1081 :
1082 : /* Retrieve the fingerprint from the card inserted in SLOT and write
1083 : the according hex representation to FPR. Caller must have provide
1084 : a buffer at FPR of least 41 bytes. Returns 0 on success or an
1085 : error code. */
1086 : #if GNUPG_MAJOR_VERSION > 1
1087 : static gpg_error_t
1088 0 : retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1089 : {
1090 0 : gpg_error_t err = 0;
1091 : void *relptr;
1092 : unsigned char *value;
1093 : size_t valuelen;
1094 :
1095 0 : assert (keyno >=0 && keyno <= 2);
1096 :
1097 0 : relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1098 0 : if (relptr && valuelen >= 60)
1099 0 : bin2hex (value+keyno*20, 20, fpr);
1100 : else
1101 0 : err = gpg_error (GPG_ERR_NOT_FOUND);
1102 0 : xfree (relptr);
1103 0 : return err;
1104 : }
1105 : #endif /*GNUPG_MAJOR_VERSION > 1*/
1106 :
1107 :
1108 : /* Retrieve the public key material for the RSA key, whose fingerprint
1109 : is FPR, from gpg output, which can be read through the stream FP.
1110 : The RSA modulus will be stored at the address of M and MLEN, the
1111 : public exponent at E and ELEN. Returns zero on success, an error
1112 : code on failure. Caller must release the allocated buffers at M
1113 : and E if the function returns success. */
1114 : #if GNUPG_MAJOR_VERSION > 1
1115 : static gpg_error_t
1116 0 : retrieve_key_material (FILE *fp, const char *hexkeyid,
1117 : const unsigned char **m, size_t *mlen,
1118 : const unsigned char **e, size_t *elen)
1119 : {
1120 0 : gcry_error_t err = 0;
1121 0 : char *line = NULL; /* read_line() buffer. */
1122 0 : size_t line_size = 0; /* Helper for for read_line. */
1123 0 : int found_key = 0; /* Helper to find a matching key. */
1124 0 : unsigned char *m_new = NULL;
1125 0 : unsigned char *e_new = NULL;
1126 0 : size_t m_new_n = 0;
1127 0 : size_t e_new_n = 0;
1128 :
1129 : /* Loop over all records until we have found the subkey
1130 : corresponding to the fingerprint. Inm general the first record
1131 : should be the pub record, but we don't rely on that. Given that
1132 : we only need to look at one key, it is sufficient to compare the
1133 : keyid so that we don't need to look at "fpr" records. */
1134 : for (;;)
1135 : {
1136 : char *p;
1137 0 : char *fields[6] = { NULL, NULL, NULL, NULL, NULL, NULL };
1138 : int nfields;
1139 : size_t max_length;
1140 : gcry_mpi_t mpi;
1141 : int i;
1142 :
1143 0 : max_length = 4096;
1144 0 : i = read_line (fp, &line, &line_size, &max_length);
1145 0 : if (!i)
1146 0 : break; /* EOF. */
1147 0 : if (i < 0)
1148 : {
1149 0 : err = gpg_error_from_syserror ();
1150 0 : goto leave; /* Error. */
1151 : }
1152 0 : if (!max_length)
1153 : {
1154 0 : err = gpg_error (GPG_ERR_TRUNCATED);
1155 0 : goto leave; /* Line truncated - we better stop processing. */
1156 : }
1157 :
1158 : /* Parse the line into fields. */
1159 0 : for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1160 : {
1161 0 : fields[nfields] = p;
1162 0 : p = strchr (p, ':');
1163 0 : if (p)
1164 0 : *(p++) = 0;
1165 : }
1166 0 : if (!nfields)
1167 0 : continue; /* No fields at all - skip line. */
1168 :
1169 0 : if (!found_key)
1170 : {
1171 0 : if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1172 0 : && nfields > 4 && !strcmp (fields[4], hexkeyid))
1173 0 : found_key = 1;
1174 0 : continue;
1175 : }
1176 :
1177 0 : if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1178 : break; /* Next key - stop. */
1179 :
1180 0 : if ( strcmp (fields[0], "pkd") )
1181 0 : continue; /* Not a key data record. */
1182 0 : i = 0; /* Avoid erroneous compiler warning. */
1183 0 : if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1184 0 : || (!i && m_new) || (i && e_new))
1185 : {
1186 0 : err = gpg_error (GPG_ERR_GENERAL);
1187 0 : goto leave; /* Error: Invalid key data record or not an RSA key. */
1188 : }
1189 :
1190 0 : err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1191 0 : if (err)
1192 0 : mpi = NULL;
1193 0 : else if (!i)
1194 0 : err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1195 : else
1196 0 : err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1197 0 : gcry_mpi_release (mpi);
1198 0 : if (err)
1199 0 : goto leave;
1200 0 : }
1201 :
1202 0 : if (m_new && e_new)
1203 : {
1204 0 : *m = m_new;
1205 0 : *mlen = m_new_n;
1206 0 : m_new = NULL;
1207 0 : *e = e_new;
1208 0 : *elen = e_new_n;
1209 0 : e_new = NULL;
1210 : }
1211 : else
1212 0 : err = gpg_error (GPG_ERR_GENERAL);
1213 :
1214 : leave:
1215 0 : xfree (m_new);
1216 0 : xfree (e_new);
1217 0 : xfree (line);
1218 0 : return err;
1219 : }
1220 : #endif /*GNUPG_MAJOR_VERSION > 1*/
1221 :
1222 :
1223 : /* Get the public key for KEYNO and store it as an S-expresion with
1224 : the APP handle. On error that field gets cleared. If we already
1225 : know about the public key we will just return. Note that this does
1226 : not mean a key is available; this is solely indicated by the
1227 : presence of the app->app_local->pk[KEYNO].key field.
1228 :
1229 : Note that GnuPG 1.x does not need this and it would be too time
1230 : consuming to send it just for the fun of it. However, given that we
1231 : use the same code in gpg 1.4, we can't use the gcry S-expresion
1232 : here but need to open encode it. */
1233 : #if GNUPG_MAJOR_VERSION > 1
1234 : static gpg_error_t
1235 0 : get_public_key (app_t app, int keyno)
1236 : {
1237 0 : gpg_error_t err = 0;
1238 : unsigned char *buffer;
1239 : const unsigned char *keydata, *m, *e;
1240 : size_t buflen, keydatalen;
1241 0 : size_t mlen = 0;
1242 0 : size_t elen = 0;
1243 0 : unsigned char *mbuf = NULL;
1244 0 : unsigned char *ebuf = NULL;
1245 0 : char *keybuf = NULL;
1246 : gcry_sexp_t s_pkey;
1247 : size_t len;
1248 :
1249 0 : if (keyno < 0 || keyno > 2)
1250 0 : return gpg_error (GPG_ERR_INV_ID);
1251 :
1252 : /* Already cached? */
1253 0 : if (app->app_local->pk[keyno].read_done)
1254 0 : return 0;
1255 :
1256 0 : xfree (app->app_local->pk[keyno].key);
1257 0 : app->app_local->pk[keyno].key = NULL;
1258 0 : app->app_local->pk[keyno].keylen = 0;
1259 :
1260 0 : m = e = NULL; /* (avoid cc warning) */
1261 :
1262 0 : if (app->card_version > 0x0100)
1263 : {
1264 : int exmode, le_value;
1265 :
1266 : /* We may simply read the public key out of these cards. */
1267 0 : if (app->app_local->cardcap.ext_lc_le)
1268 : {
1269 0 : exmode = 1; /* Use extended length. */
1270 0 : le_value = app->app_local->extcap.max_rsp_data;
1271 : }
1272 : else
1273 : {
1274 0 : exmode = 0;
1275 0 : le_value = 256; /* Use legacy value. */
1276 : }
1277 :
1278 0 : err = iso7816_read_public_key
1279 : (app->slot, exmode,
1280 : (const unsigned char*)(keyno == 0? "\xB6" :
1281 : keyno == 1? "\xB8" : "\xA4"), 2,
1282 : le_value,
1283 : &buffer, &buflen);
1284 0 : if (err)
1285 : {
1286 0 : log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1287 0 : goto leave;
1288 : }
1289 :
1290 0 : keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1291 0 : if (!keydata)
1292 : {
1293 0 : err = gpg_error (GPG_ERR_CARD);
1294 0 : log_error (_("response does not contain the public key data\n"));
1295 0 : goto leave;
1296 : }
1297 :
1298 0 : if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
1299 : {
1300 0 : m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1301 0 : if (!m)
1302 : {
1303 0 : err = gpg_error (GPG_ERR_CARD);
1304 0 : log_error (_("response does not contain the RSA modulus\n"));
1305 0 : goto leave;
1306 : }
1307 :
1308 0 : e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1309 0 : if (!e)
1310 : {
1311 0 : err = gpg_error (GPG_ERR_CARD);
1312 0 : log_error (_("response does not contain the RSA public exponent\n"));
1313 0 : goto leave;
1314 : }
1315 : }
1316 : else
1317 : {
1318 0 : m = find_tlv (keydata, keydatalen, 0x0086, &mlen);
1319 0 : if (!m)
1320 : {
1321 0 : err = gpg_error (GPG_ERR_CARD);
1322 0 : log_error (_("response does not contain the EC public point\n"));
1323 0 : goto leave;
1324 : }
1325 : }
1326 : }
1327 : else
1328 : {
1329 : /* Due to a design problem in v1.0 cards we can't get the public
1330 : key out of these cards without doing a verify on CHV3.
1331 : Clearly that is not an option and thus we try to locate the
1332 : key using an external helper.
1333 :
1334 : The helper we use here is gpg itself, which should know about
1335 : the key in any case. */
1336 :
1337 : char fpr[41];
1338 : char *hexkeyid;
1339 0 : char *command = NULL;
1340 : FILE *fp;
1341 : int ret;
1342 :
1343 0 : buffer = NULL; /* We don't need buffer. */
1344 :
1345 0 : err = retrieve_fpr_from_card (app, keyno, fpr);
1346 0 : if (err)
1347 : {
1348 0 : log_error ("error while retrieving fpr from card: %s\n",
1349 : gpg_strerror (err));
1350 0 : goto leave;
1351 : }
1352 0 : hexkeyid = fpr + 24;
1353 :
1354 0 : ret = gpgrt_asprintf
1355 : (&command, "gpg --list-keys --with-colons --with-key-data '%s'", fpr);
1356 0 : if (ret < 0)
1357 : {
1358 0 : err = gpg_error_from_syserror ();
1359 0 : goto leave;
1360 : }
1361 :
1362 0 : fp = popen (command, "r");
1363 0 : xfree (command);
1364 0 : if (!fp)
1365 : {
1366 0 : err = gpg_error_from_syserror ();
1367 0 : log_error ("running gpg failed: %s\n", gpg_strerror (err));
1368 0 : goto leave;
1369 : }
1370 :
1371 0 : err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1372 0 : pclose (fp);
1373 0 : if (err)
1374 : {
1375 0 : log_error ("error while retrieving key material through pipe: %s\n",
1376 : gpg_strerror (err));
1377 0 : goto leave;
1378 : }
1379 : }
1380 :
1381 0 : mbuf = xtrymalloc (mlen + 1);
1382 0 : if (!mbuf)
1383 : {
1384 0 : err = gpg_error_from_syserror ();
1385 0 : goto leave;
1386 : }
1387 :
1388 0 : if ((app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA
1389 0 : || (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC
1390 0 : && !app->app_local->keyattr[keyno].ecc.flags))
1391 0 : && mlen && (*m & 0x80))
1392 : { /* Prepend numbers with a 0 if needed for MPI. */
1393 0 : *mbuf = 0;
1394 0 : memcpy (mbuf+1, m, mlen);
1395 0 : mlen++;
1396 : }
1397 0 : else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC
1398 0 : && app->app_local->keyattr[keyno].ecc.flags)
1399 : { /* Prepend 0x40 prefix. */
1400 0 : *mbuf = 0x40;
1401 0 : memcpy (mbuf+1, m, mlen);
1402 0 : mlen++;
1403 : }
1404 : else
1405 0 : memcpy (mbuf, m, mlen);
1406 :
1407 0 : if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
1408 : {
1409 0 : ebuf = xtrymalloc (elen + 1);
1410 0 : if (!ebuf)
1411 : {
1412 0 : err = gpg_error_from_syserror ();
1413 0 : goto leave;
1414 : }
1415 : /* Prepend numbers with a 0 if needed. */
1416 0 : if (elen && (*e & 0x80))
1417 : {
1418 0 : *ebuf = 0;
1419 0 : memcpy (ebuf+1, e, elen);
1420 0 : elen++;
1421 : }
1422 : else
1423 0 : memcpy (ebuf, e, elen);
1424 :
1425 0 : err = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%b)(e%b)))",
1426 : (int)mlen, mbuf, (int)elen, ebuf);
1427 : }
1428 0 : else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
1429 : {
1430 : char *format;
1431 :
1432 0 : if (!app->app_local->keyattr[keyno].ecc.flags)
1433 0 : format = "(public-key(ecc(curve%s)(q%b)))";
1434 0 : else if (keyno == 1)
1435 0 : format = "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))";
1436 : else
1437 0 : format = "(public-key(ecc(curve%s)(flags eddsa)(q%b)))";
1438 :
1439 0 : err = gcry_sexp_build (&s_pkey, NULL, format,
1440 0 : openpgp_oid_to_curve (app->app_local->keyattr[keyno].ecc.oid, 1),
1441 : (int)mlen, mbuf);
1442 : }
1443 : else
1444 0 : err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1445 :
1446 0 : if (err)
1447 0 : goto leave;
1448 :
1449 0 : len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1450 :
1451 0 : keybuf = xtrymalloc (len);
1452 0 : if (!keybuf)
1453 : {
1454 0 : gcry_sexp_release (s_pkey);
1455 0 : err = gpg_error_from_syserror ();
1456 0 : goto leave;
1457 : }
1458 0 : gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1459 0 : gcry_sexp_release (s_pkey);
1460 :
1461 0 : app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1462 0 : app->app_local->pk[keyno].keylen = len - 1; /* Decrement for trailing '\0' */
1463 :
1464 : leave:
1465 : /* Set a flag to indicate that we tried to read the key. */
1466 0 : app->app_local->pk[keyno].read_done = 1;
1467 :
1468 0 : xfree (buffer);
1469 0 : xfree (mbuf);
1470 0 : xfree (ebuf);
1471 0 : return err;
1472 : }
1473 : #endif /* GNUPG_MAJOR_VERSION > 1 */
1474 :
1475 :
1476 :
1477 : /* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
1478 : This is used by the LEARN command. */
1479 : static gpg_error_t
1480 0 : send_keypair_info (app_t app, ctrl_t ctrl, int key)
1481 : {
1482 0 : int keyno = key - 1;
1483 0 : gpg_error_t err = 0;
1484 : /* Note that GnuPG 1.x does not need this and it would be too time
1485 : consuming to send it just for the fun of it. */
1486 : #if GNUPG_MAJOR_VERSION > 1
1487 : unsigned char grip[20];
1488 : char gripstr[41];
1489 : char idbuf[50];
1490 :
1491 0 : err = get_public_key (app, keyno);
1492 0 : if (err)
1493 0 : goto leave;
1494 :
1495 0 : assert (keyno >= 0 && keyno <= 2);
1496 0 : if (!app->app_local->pk[keyno].key)
1497 0 : goto leave; /* No such key - ignore. */
1498 :
1499 0 : err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
1500 0 : app->app_local->pk[keyno].keylen,
1501 : grip);
1502 0 : if (err)
1503 0 : goto leave;
1504 :
1505 0 : bin2hex (grip, 20, gripstr);
1506 :
1507 0 : sprintf (idbuf, "OPENPGP.%d", keyno+1);
1508 0 : send_status_info (ctrl, "KEYPAIRINFO",
1509 : gripstr, 40,
1510 : idbuf, strlen (idbuf),
1511 : NULL, (size_t)0);
1512 :
1513 : leave:
1514 : #endif /* GNUPG_MAJOR_VERSION > 1 */
1515 :
1516 0 : return err;
1517 : }
1518 :
1519 :
1520 : /* Handle the LEARN command for OpenPGP. */
1521 : static gpg_error_t
1522 0 : do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1523 : {
1524 : (void)flags;
1525 :
1526 0 : do_getattr (app, ctrl, "EXTCAP");
1527 0 : do_getattr (app, ctrl, "DISP-NAME");
1528 0 : do_getattr (app, ctrl, "DISP-LANG");
1529 0 : do_getattr (app, ctrl, "DISP-SEX");
1530 0 : do_getattr (app, ctrl, "PUBKEY-URL");
1531 0 : do_getattr (app, ctrl, "LOGIN-DATA");
1532 0 : do_getattr (app, ctrl, "KEY-FPR");
1533 0 : if (app->card_version > 0x0100)
1534 0 : do_getattr (app, ctrl, "KEY-TIME");
1535 0 : do_getattr (app, ctrl, "CA-FPR");
1536 0 : do_getattr (app, ctrl, "CHV-STATUS");
1537 0 : do_getattr (app, ctrl, "SIG-COUNTER");
1538 0 : if (app->app_local->extcap.private_dos)
1539 : {
1540 0 : do_getattr (app, ctrl, "PRIVATE-DO-1");
1541 0 : do_getattr (app, ctrl, "PRIVATE-DO-2");
1542 0 : if (app->did_chv2)
1543 0 : do_getattr (app, ctrl, "PRIVATE-DO-3");
1544 0 : if (app->did_chv3)
1545 0 : do_getattr (app, ctrl, "PRIVATE-DO-4");
1546 : }
1547 0 : send_keypair_info (app, ctrl, 1);
1548 0 : send_keypair_info (app, ctrl, 2);
1549 0 : send_keypair_info (app, ctrl, 3);
1550 : /* Note: We do not send the Cardholder Certificate, because that is
1551 : relatively long and for OpenPGP applications not really needed. */
1552 0 : return 0;
1553 : }
1554 :
1555 :
1556 : /* Handle the READKEY command for OpenPGP. On success a canonical
1557 : encoded S-expression with the public key will get stored at PK and
1558 : its length (for assertions) at PKLEN; the caller must release that
1559 : buffer. On error PK and PKLEN are not changed and an error code is
1560 : returned. */
1561 : static gpg_error_t
1562 0 : do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1563 : {
1564 : #if GNUPG_MAJOR_VERSION > 1
1565 : gpg_error_t err;
1566 : int keyno;
1567 : unsigned char *buf;
1568 :
1569 0 : if (!strcmp (keyid, "OPENPGP.1"))
1570 0 : keyno = 0;
1571 0 : else if (!strcmp (keyid, "OPENPGP.2"))
1572 0 : keyno = 1;
1573 0 : else if (!strcmp (keyid, "OPENPGP.3"))
1574 0 : keyno = 2;
1575 : else
1576 0 : return gpg_error (GPG_ERR_INV_ID);
1577 :
1578 0 : err = get_public_key (app, keyno);
1579 0 : if (err)
1580 0 : return err;
1581 :
1582 0 : buf = app->app_local->pk[keyno].key;
1583 0 : if (!buf)
1584 0 : return gpg_error (GPG_ERR_NO_PUBKEY);
1585 0 : *pklen = app->app_local->pk[keyno].keylen;;
1586 0 : *pk = xtrymalloc (*pklen);
1587 0 : if (!*pk)
1588 : {
1589 0 : err = gpg_error_from_syserror ();
1590 0 : *pklen = 0;
1591 0 : return err;
1592 : }
1593 0 : memcpy (*pk, buf, *pklen);
1594 0 : return 0;
1595 : #else
1596 : return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1597 : #endif
1598 : }
1599 :
1600 : /* Read the standard certificate of an OpenPGP v2 card. It is
1601 : returned in a freshly allocated buffer with that address stored at
1602 : CERT and the length of the certificate stored at CERTLEN. CERTID
1603 : needs to be set to "OPENPGP.3". */
1604 : static gpg_error_t
1605 0 : do_readcert (app_t app, const char *certid,
1606 : unsigned char **cert, size_t *certlen)
1607 : {
1608 : #if GNUPG_MAJOR_VERSION > 1
1609 : gpg_error_t err;
1610 : unsigned char *buffer;
1611 : size_t buflen;
1612 : void *relptr;
1613 :
1614 0 : *cert = NULL;
1615 0 : *certlen = 0;
1616 0 : if (strcmp (certid, "OPENPGP.3"))
1617 0 : return gpg_error (GPG_ERR_INV_ID);
1618 0 : if (!app->app_local->extcap.is_v2)
1619 0 : return gpg_error (GPG_ERR_NOT_FOUND);
1620 :
1621 0 : relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1622 0 : if (!relptr)
1623 0 : return gpg_error (GPG_ERR_NOT_FOUND);
1624 :
1625 0 : if (!buflen)
1626 0 : err = gpg_error (GPG_ERR_NOT_FOUND);
1627 0 : else if (!(*cert = xtrymalloc (buflen)))
1628 0 : err = gpg_error_from_syserror ();
1629 : else
1630 : {
1631 0 : memcpy (*cert, buffer, buflen);
1632 0 : *certlen = buflen;
1633 0 : err = 0;
1634 : }
1635 0 : xfree (relptr);
1636 0 : return err;
1637 : #else
1638 : return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1639 : #endif
1640 : }
1641 :
1642 :
1643 : /* Decide if we use the pinpad of the reader for PIN input according
1644 : to the user preference on the card, and the capability of the
1645 : reader. This routine is only called when the reader has pinpad.
1646 : Returns 0 if we use pinpad, 1 otherwise. */
1647 : static int
1648 0 : check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1649 : {
1650 0 : if (app->app_local->pinpad.specified == 0) /* No preference on card. */
1651 : {
1652 0 : if (pininfo->fixedlen == 0) /* Reader has varlen capability. */
1653 0 : return 0; /* Then, use pinpad. */
1654 : else
1655 : /*
1656 : * Reader has limited capability, and it may not match PIN of
1657 : * the card.
1658 : */
1659 0 : return 1;
1660 : }
1661 :
1662 0 : if (admin_pin)
1663 0 : pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1664 : else
1665 0 : pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
1666 :
1667 0 : if (pininfo->fixedlen == 0 /* User requests disable pinpad. */
1668 0 : || pininfo->fixedlen < pininfo->minlen
1669 0 : || pininfo->fixedlen > pininfo->maxlen
1670 : /* Reader doesn't have the capability to input a PIN which
1671 : * length is FIXEDLEN. */)
1672 0 : return 1;
1673 :
1674 0 : return 0;
1675 : }
1676 :
1677 :
1678 : /* Verify a CHV either using using the pinentry or if possible by
1679 : using a pinpad. PINCB and PINCB_ARG describe the usual callback
1680 : for the pinentry. CHVNO must be either 1 or 2. SIGCOUNT is only
1681 : used with CHV1. PINVALUE is the address of a pointer which will
1682 : receive a newly allocated block with the actual PIN (this is useful
1683 : in case that PIN shall be used for another verify operation). The
1684 : caller needs to free this value. If the function returns with
1685 : success and NULL is stored at PINVALUE, the caller should take this
1686 : as an indication that the pinpad has been used.
1687 : */
1688 : static gpg_error_t
1689 0 : verify_a_chv (app_t app,
1690 : gpg_error_t (*pincb)(void*, const char *, char **),
1691 : void *pincb_arg,
1692 : int chvno, unsigned long sigcount, char **pinvalue)
1693 : {
1694 0 : int rc = 0;
1695 0 : char *prompt_buffer = NULL;
1696 : const char *prompt;
1697 : pininfo_t pininfo;
1698 0 : int minlen = 6;
1699 :
1700 0 : assert (chvno == 1 || chvno == 2);
1701 :
1702 0 : *pinvalue = NULL;
1703 :
1704 0 : if (chvno == 2 && app->app_local->flags.def_chv2)
1705 : {
1706 : /* Special case for def_chv2 mechanism. */
1707 0 : if (opt.verbose)
1708 0 : log_info (_("using default PIN as %s\n"), "CHV2");
1709 0 : rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1710 0 : if (rc)
1711 : {
1712 : /* Verification of CHV2 with the default PIN failed,
1713 : although the card pretends to have the default PIN set as
1714 : CHV2. We better disable the def_chv2 flag now. */
1715 0 : log_info (_("failed to use default PIN as %s: %s"
1716 : " - disabling further default use\n"),
1717 : "CHV2", gpg_strerror (rc));
1718 0 : app->app_local->flags.def_chv2 = 0;
1719 : }
1720 0 : return rc;
1721 : }
1722 :
1723 0 : memset (&pininfo, 0, sizeof pininfo);
1724 0 : pininfo.fixedlen = -1;
1725 0 : pininfo.minlen = minlen;
1726 :
1727 :
1728 0 : if (chvno == 1)
1729 : {
1730 : #define PROMPTSTRING _("||Please enter the PIN%%0A[sigs done: %lu]")
1731 0 : size_t promptsize = strlen (PROMPTSTRING) + 50;
1732 :
1733 0 : prompt_buffer = xtrymalloc (promptsize);
1734 0 : if (!prompt_buffer)
1735 0 : return gpg_error_from_syserror ();
1736 0 : snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1737 0 : prompt = prompt_buffer;
1738 : #undef PROMPTSTRING
1739 : }
1740 : else
1741 0 : prompt = _("||Please enter the PIN");
1742 :
1743 :
1744 0 : if (!opt.disable_pinpad
1745 0 : && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1746 0 : && !check_pinpad_request (app, &pininfo, 0))
1747 : {
1748 : /* The reader supports the verify command through the pinpad.
1749 : Note that the pincb appends a text to the prompt telling the
1750 : user to use the pinpad. */
1751 0 : rc = pincb (pincb_arg, prompt, NULL);
1752 0 : prompt = NULL;
1753 0 : xfree (prompt_buffer);
1754 0 : prompt_buffer = NULL;
1755 0 : if (rc)
1756 : {
1757 0 : log_info (_("PIN callback returned error: %s\n"),
1758 : gpg_strerror (rc));
1759 0 : return rc;
1760 : }
1761 0 : rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
1762 : /* Dismiss the prompt. */
1763 0 : pincb (pincb_arg, NULL, NULL);
1764 :
1765 0 : assert (!*pinvalue);
1766 : }
1767 : else
1768 : {
1769 : /* The reader has no pinpad or we don't want to use it. */
1770 0 : rc = pincb (pincb_arg, prompt, pinvalue);
1771 0 : prompt = NULL;
1772 0 : xfree (prompt_buffer);
1773 0 : prompt_buffer = NULL;
1774 0 : if (rc)
1775 : {
1776 0 : log_info (_("PIN callback returned error: %s\n"),
1777 : gpg_strerror (rc));
1778 0 : return rc;
1779 : }
1780 :
1781 0 : if (strlen (*pinvalue) < minlen)
1782 : {
1783 0 : log_error (_("PIN for CHV%d is too short;"
1784 : " minimum length is %d\n"), chvno, minlen);
1785 0 : xfree (*pinvalue);
1786 0 : *pinvalue = NULL;
1787 0 : return gpg_error (GPG_ERR_BAD_PIN);
1788 : }
1789 :
1790 0 : rc = iso7816_verify (app->slot, 0x80+chvno,
1791 : *pinvalue, strlen (*pinvalue));
1792 : }
1793 :
1794 0 : if (rc)
1795 : {
1796 0 : log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1797 0 : xfree (*pinvalue);
1798 0 : *pinvalue = NULL;
1799 0 : flush_cache_after_error (app);
1800 : }
1801 :
1802 0 : return rc;
1803 : }
1804 :
1805 :
1806 : /* Verify CHV2 if required. Depending on the configuration of the
1807 : card CHV1 will also be verified. */
1808 : static gpg_error_t
1809 0 : verify_chv2 (app_t app,
1810 : gpg_error_t (*pincb)(void*, const char *, char **),
1811 : void *pincb_arg)
1812 : {
1813 : int rc;
1814 : char *pinvalue;
1815 :
1816 0 : if (app->did_chv2)
1817 0 : return 0; /* We already verified CHV2. */
1818 :
1819 0 : rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1820 0 : if (rc)
1821 0 : return rc;
1822 0 : app->did_chv2 = 1;
1823 :
1824 0 : if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1825 : {
1826 : /* For convenience we verify CHV1 here too. We do this only if
1827 : the card is not configured to require a verification before
1828 : each CHV1 controlled operation (force_chv1) and if we are not
1829 : using the pinpad (PINVALUE == NULL). */
1830 0 : rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1831 0 : if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1832 0 : rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1833 0 : if (rc)
1834 : {
1835 0 : log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1836 0 : flush_cache_after_error (app);
1837 : }
1838 : else
1839 0 : app->did_chv1 = 1;
1840 : }
1841 :
1842 0 : xfree (pinvalue);
1843 :
1844 0 : return rc;
1845 : }
1846 :
1847 :
1848 : /* Build the prompt to enter the Admin PIN. The prompt depends on the
1849 : current sdtate of the card. */
1850 : static gpg_error_t
1851 0 : build_enter_admin_pin_prompt (app_t app, char **r_prompt)
1852 : {
1853 : void *relptr;
1854 : unsigned char *value;
1855 : size_t valuelen;
1856 : int remaining;
1857 : char *prompt;
1858 :
1859 0 : *r_prompt = NULL;
1860 :
1861 0 : relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1862 0 : if (!relptr || valuelen < 7)
1863 : {
1864 0 : log_error (_("error retrieving CHV status from card\n"));
1865 0 : xfree (relptr);
1866 0 : return gpg_error (GPG_ERR_CARD);
1867 : }
1868 0 : if (value[6] == 0)
1869 : {
1870 0 : log_info (_("card is permanently locked!\n"));
1871 0 : xfree (relptr);
1872 0 : return gpg_error (GPG_ERR_BAD_PIN);
1873 : }
1874 0 : remaining = value[6];
1875 0 : xfree (relptr);
1876 :
1877 0 : log_info (ngettext("%d Admin PIN attempt remaining before card"
1878 : " is permanently locked\n",
1879 : "%d Admin PIN attempts remaining before card"
1880 : " is permanently locked\n",
1881 : remaining), remaining);
1882 :
1883 0 : if (remaining < 3)
1884 : {
1885 : /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
1886 : the start of the string. Use %%0A to force a linefeed. */
1887 0 : prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
1888 : "[remaining attempts: %d]"), remaining);
1889 : }
1890 : else
1891 0 : prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
1892 :
1893 0 : if (!prompt)
1894 0 : return gpg_error_from_syserror ();
1895 :
1896 0 : *r_prompt = prompt;
1897 0 : return 0;
1898 : }
1899 :
1900 :
1901 : /* Verify CHV3 if required. */
1902 : static gpg_error_t
1903 0 : verify_chv3 (app_t app,
1904 : gpg_error_t (*pincb)(void*, const char *, char **),
1905 : void *pincb_arg)
1906 : {
1907 0 : int rc = 0;
1908 :
1909 : #if GNUPG_MAJOR_VERSION != 1
1910 0 : if (!opt.allow_admin)
1911 : {
1912 0 : log_info (_("access to admin commands is not configured\n"));
1913 0 : return gpg_error (GPG_ERR_EACCES);
1914 : }
1915 : #endif
1916 :
1917 0 : if (!app->did_chv3)
1918 : {
1919 : pininfo_t pininfo;
1920 0 : int minlen = 8;
1921 : char *prompt;
1922 :
1923 0 : memset (&pininfo, 0, sizeof pininfo);
1924 0 : pininfo.fixedlen = -1;
1925 0 : pininfo.minlen = minlen;
1926 :
1927 0 : rc = build_enter_admin_pin_prompt (app, &prompt);
1928 0 : if (rc)
1929 0 : return rc;
1930 :
1931 0 : if (!opt.disable_pinpad
1932 0 : && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1933 0 : && !check_pinpad_request (app, &pininfo, 1))
1934 : {
1935 : /* The reader supports the verify command through the pinpad. */
1936 0 : rc = pincb (pincb_arg, prompt, NULL);
1937 0 : xfree (prompt);
1938 0 : prompt = NULL;
1939 0 : if (rc)
1940 : {
1941 0 : log_info (_("PIN callback returned error: %s\n"),
1942 : gpg_strerror (rc));
1943 0 : return rc;
1944 : }
1945 0 : rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
1946 : /* Dismiss the prompt. */
1947 0 : pincb (pincb_arg, NULL, NULL);
1948 : }
1949 : else
1950 : {
1951 : char *pinvalue;
1952 :
1953 0 : rc = pincb (pincb_arg, prompt, &pinvalue);
1954 0 : xfree (prompt);
1955 0 : prompt = NULL;
1956 0 : if (rc)
1957 : {
1958 0 : log_info (_("PIN callback returned error: %s\n"),
1959 : gpg_strerror (rc));
1960 0 : return rc;
1961 : }
1962 :
1963 0 : if (strlen (pinvalue) < minlen)
1964 : {
1965 0 : log_error (_("PIN for CHV%d is too short;"
1966 : " minimum length is %d\n"), 3, minlen);
1967 0 : xfree (pinvalue);
1968 0 : return gpg_error (GPG_ERR_BAD_PIN);
1969 : }
1970 :
1971 0 : rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1972 0 : xfree (pinvalue);
1973 : }
1974 :
1975 0 : if (rc)
1976 : {
1977 0 : log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1978 0 : flush_cache_after_error (app);
1979 0 : return rc;
1980 : }
1981 0 : app->did_chv3 = 1;
1982 : }
1983 0 : return rc;
1984 : }
1985 :
1986 :
1987 : /* Handle the SETATTR operation. All arguments are already basically
1988 : checked. */
1989 : static gpg_error_t
1990 0 : do_setattr (app_t app, const char *name,
1991 : gpg_error_t (*pincb)(void*, const char *, char **),
1992 : void *pincb_arg,
1993 : const unsigned char *value, size_t valuelen)
1994 : {
1995 : gpg_error_t rc;
1996 : int idx;
1997 : static struct {
1998 : const char *name;
1999 : int tag;
2000 : int need_chv;
2001 : int special;
2002 : unsigned int need_v2:1;
2003 : } table[] = {
2004 : { "DISP-NAME", 0x005B, 3 },
2005 : { "LOGIN-DATA", 0x005E, 3, 2 },
2006 : { "DISP-LANG", 0x5F2D, 3 },
2007 : { "DISP-SEX", 0x5F35, 3 },
2008 : { "PUBKEY-URL", 0x5F50, 3 },
2009 : { "CHV-STATUS-1", 0x00C4, 3, 1 },
2010 : { "CA-FPR-1", 0x00CA, 3 },
2011 : { "CA-FPR-2", 0x00CB, 3 },
2012 : { "CA-FPR-3", 0x00CC, 3 },
2013 : { "PRIVATE-DO-1", 0x0101, 2 },
2014 : { "PRIVATE-DO-2", 0x0102, 3 },
2015 : { "PRIVATE-DO-3", 0x0103, 2 },
2016 : { "PRIVATE-DO-4", 0x0104, 3 },
2017 : { "CERT-3", 0x7F21, 3, 0, 1 },
2018 : { "SM-KEY-ENC", 0x00D1, 3, 0, 1 },
2019 : { "SM-KEY-MAC", 0x00D2, 3, 0, 1 },
2020 : { "KEY-ATTR", 0, 0, 3, 1 },
2021 : { "AESKEY", 0x00D5, 3, 0, 1 },
2022 : { NULL, 0 }
2023 : };
2024 : int exmode;
2025 :
2026 0 : for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2027 : ;
2028 0 : if (!table[idx].name)
2029 0 : return gpg_error (GPG_ERR_INV_NAME);
2030 0 : if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2031 0 : return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported. */
2032 :
2033 0 : if (table[idx].special == 3)
2034 0 : return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2035 :
2036 0 : switch (table[idx].need_chv)
2037 : {
2038 : case 2:
2039 0 : rc = verify_chv2 (app, pincb, pincb_arg);
2040 0 : break;
2041 : case 3:
2042 0 : rc = verify_chv3 (app, pincb, pincb_arg);
2043 0 : break;
2044 : default:
2045 0 : rc = 0;
2046 : }
2047 0 : if (rc)
2048 0 : return rc;
2049 :
2050 : /* Flush the cache before writing it, so that the next get operation
2051 : will reread the data from the card and thus get synced in case of
2052 : errors (e.g. data truncated by the card). */
2053 0 : flush_cache_item (app, table[idx].tag);
2054 :
2055 0 : if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2056 0 : exmode = 1; /* Use extended length w/o a limit. */
2057 0 : else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2058 0 : exmode = -254; /* Command chaining with max. 254 bytes. */
2059 : else
2060 0 : exmode = 0;
2061 0 : rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
2062 0 : if (rc)
2063 0 : log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2064 :
2065 0 : if (table[idx].special == 1)
2066 0 : app->force_chv1 = (valuelen && *value == 0);
2067 0 : else if (table[idx].special == 2)
2068 0 : parse_login_data (app);
2069 :
2070 0 : return rc;
2071 : }
2072 :
2073 :
2074 : /* Handle the WRITECERT command for OpenPGP. This rites the standard
2075 : certifciate to the card; CERTID needs to be set to "OPENPGP.3".
2076 : PINCB and PINCB_ARG are the usual arguments for the pinentry
2077 : callback. */
2078 : static gpg_error_t
2079 0 : do_writecert (app_t app, ctrl_t ctrl,
2080 : const char *certidstr,
2081 : gpg_error_t (*pincb)(void*, const char *, char **),
2082 : void *pincb_arg,
2083 : const unsigned char *certdata, size_t certdatalen)
2084 : {
2085 : (void)ctrl;
2086 : #if GNUPG_MAJOR_VERSION > 1
2087 0 : if (strcmp (certidstr, "OPENPGP.3"))
2088 0 : return gpg_error (GPG_ERR_INV_ID);
2089 0 : if (!certdata || !certdatalen)
2090 0 : return gpg_error (GPG_ERR_INV_ARG);
2091 0 : if (!app->app_local->extcap.is_v2)
2092 0 : return gpg_error (GPG_ERR_NOT_SUPPORTED);
2093 0 : if (certdatalen > app->app_local->extcap.max_certlen_3)
2094 0 : return gpg_error (GPG_ERR_TOO_LARGE);
2095 0 : return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2096 : #else
2097 : return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2098 : #endif
2099 : }
2100 :
2101 :
2102 :
2103 : /* Handle the PASSWD command. The following combinations are
2104 : possible:
2105 :
2106 : Flags CHVNO Vers. Description
2107 : RESET 1 1 Verify CHV3 and set a new CHV1 and CHV2
2108 : RESET 1 2 Verify PW3 and set a new PW1.
2109 : RESET 2 1 Verify CHV3 and set a new CHV1 and CHV2.
2110 : RESET 2 2 Verify PW3 and set a new Reset Code.
2111 : RESET 3 any Returns GPG_ERR_INV_ID.
2112 : - 1 1 Verify CHV2 and set a new CHV1 and CHV2.
2113 : - 1 2 Verify PW1 and set a new PW1.
2114 : - 2 1 Verify CHV2 and set a new CHV1 and CHV2.
2115 : - 2 2 Verify Reset Code and set a new PW1.
2116 : - 3 any Verify CHV3/PW3 and set a new CHV3/PW3.
2117 : */
2118 : static gpg_error_t
2119 0 : do_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr,
2120 : unsigned int flags,
2121 : gpg_error_t (*pincb)(void*, const char *, char **),
2122 : void *pincb_arg)
2123 : {
2124 0 : int rc = 0;
2125 0 : int chvno = atoi (chvnostr);
2126 0 : char *resetcode = NULL;
2127 0 : char *oldpinvalue = NULL;
2128 0 : char *pinvalue = NULL;
2129 0 : int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2130 0 : int set_resetcode = 0;
2131 : pininfo_t pininfo;
2132 0 : int use_pinpad = 0;
2133 0 : int minlen = 6;
2134 :
2135 : (void)ctrl;
2136 0 : memset (&pininfo, 0, sizeof pininfo);
2137 0 : pininfo.fixedlen = -1;
2138 0 : pininfo.minlen = minlen;
2139 :
2140 0 : if (reset_mode && chvno == 3)
2141 : {
2142 0 : rc = gpg_error (GPG_ERR_INV_ID);
2143 0 : goto leave;
2144 : }
2145 :
2146 0 : if (!app->app_local->extcap.is_v2)
2147 : {
2148 : /* Version 1 cards. */
2149 :
2150 0 : if (reset_mode || chvno == 3)
2151 : {
2152 : /* We always require that the PIN is entered. */
2153 0 : app->did_chv3 = 0;
2154 0 : rc = verify_chv3 (app, pincb, pincb_arg);
2155 0 : if (rc)
2156 0 : goto leave;
2157 : }
2158 0 : else if (chvno == 1 || chvno == 2)
2159 0 : {
2160 : /* On a v1.x card CHV1 and CVH2 should always have the same
2161 : value, thus we enforce it here. */
2162 0 : int save_force = app->force_chv1;
2163 :
2164 0 : app->force_chv1 = 0;
2165 0 : app->did_chv1 = 0;
2166 0 : app->did_chv2 = 0;
2167 0 : rc = verify_chv2 (app, pincb, pincb_arg);
2168 0 : app->force_chv1 = save_force;
2169 0 : if (rc)
2170 0 : goto leave;
2171 : }
2172 : else
2173 : {
2174 0 : rc = gpg_error (GPG_ERR_INV_ID);
2175 0 : goto leave;
2176 : }
2177 : }
2178 : else
2179 : {
2180 : /* Version 2 cards. */
2181 :
2182 0 : if (!opt.disable_pinpad
2183 0 : && !iso7816_check_pinpad (app->slot,
2184 : ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2185 0 : && !check_pinpad_request (app, &pininfo, chvno == 3))
2186 0 : use_pinpad = 1;
2187 :
2188 0 : if (reset_mode)
2189 : {
2190 : /* To reset a PIN the Admin PIN is required. */
2191 0 : use_pinpad = 0;
2192 0 : app->did_chv3 = 0;
2193 0 : rc = verify_chv3 (app, pincb, pincb_arg);
2194 0 : if (rc)
2195 0 : goto leave;
2196 :
2197 0 : if (chvno == 2)
2198 0 : set_resetcode = 1;
2199 : }
2200 0 : else if (chvno == 1 || chvno == 3)
2201 : {
2202 0 : if (!use_pinpad)
2203 : {
2204 0 : char *promptbuf = NULL;
2205 : const char *prompt;
2206 :
2207 0 : if (chvno == 3)
2208 : {
2209 0 : minlen = 8;
2210 0 : rc = build_enter_admin_pin_prompt (app, &promptbuf);
2211 0 : if (rc)
2212 0 : goto leave;
2213 0 : prompt = promptbuf;
2214 : }
2215 : else
2216 0 : prompt = _("||Please enter the PIN");
2217 0 : rc = pincb (pincb_arg, prompt, &oldpinvalue);
2218 0 : xfree (promptbuf);
2219 0 : promptbuf = NULL;
2220 0 : if (rc)
2221 : {
2222 0 : log_info (_("PIN callback returned error: %s\n"),
2223 : gpg_strerror (rc));
2224 0 : goto leave;
2225 : }
2226 :
2227 0 : if (strlen (oldpinvalue) < minlen)
2228 : {
2229 0 : log_info (_("PIN for CHV%d is too short;"
2230 : " minimum length is %d\n"), chvno, minlen);
2231 0 : rc = gpg_error (GPG_ERR_BAD_PIN);
2232 0 : goto leave;
2233 : }
2234 : }
2235 : }
2236 0 : else if (chvno == 2)
2237 : {
2238 : /* There is no PW2 for v2 cards. We use this condition to
2239 : allow a PW reset using the Reset Code. */
2240 : void *relptr;
2241 : unsigned char *value;
2242 : size_t valuelen;
2243 : int remaining;
2244 :
2245 0 : use_pinpad = 0;
2246 0 : minlen = 8;
2247 0 : relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2248 0 : if (!relptr || valuelen < 7)
2249 : {
2250 0 : log_error (_("error retrieving CHV status from card\n"));
2251 0 : xfree (relptr);
2252 0 : rc = gpg_error (GPG_ERR_CARD);
2253 0 : goto leave;
2254 : }
2255 0 : remaining = value[5];
2256 0 : xfree (relptr);
2257 0 : if (!remaining)
2258 : {
2259 0 : log_error (_("Reset Code not or not anymore available\n"));
2260 0 : rc = gpg_error (GPG_ERR_BAD_PIN);
2261 0 : goto leave;
2262 : }
2263 :
2264 0 : rc = pincb (pincb_arg,
2265 0 : _("||Please enter the Reset Code for the card"),
2266 : &resetcode);
2267 0 : if (rc)
2268 : {
2269 0 : log_info (_("PIN callback returned error: %s\n"),
2270 : gpg_strerror (rc));
2271 0 : goto leave;
2272 : }
2273 0 : if (strlen (resetcode) < minlen)
2274 : {
2275 0 : log_info (_("Reset Code is too short; minimum length is %d\n"),
2276 : minlen);
2277 0 : rc = gpg_error (GPG_ERR_BAD_PIN);
2278 0 : goto leave;
2279 : }
2280 : }
2281 : else
2282 : {
2283 0 : rc = gpg_error (GPG_ERR_INV_ID);
2284 0 : goto leave;
2285 : }
2286 : }
2287 :
2288 0 : if (chvno == 3)
2289 0 : app->did_chv3 = 0;
2290 : else
2291 0 : app->did_chv1 = app->did_chv2 = 0;
2292 :
2293 0 : if (!use_pinpad)
2294 : {
2295 : /* TRANSLATORS: Do not translate the "|*|" prefixes but
2296 : keep it at the start of the string. We need this elsewhere
2297 : to get some infos on the string. */
2298 0 : rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2299 : chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2300 : &pinvalue);
2301 0 : if (rc)
2302 : {
2303 0 : log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2304 0 : goto leave;
2305 : }
2306 : }
2307 :
2308 :
2309 0 : if (resetcode)
2310 : {
2311 : char *buffer;
2312 :
2313 0 : buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2314 0 : if (!buffer)
2315 0 : rc = gpg_error_from_syserror ();
2316 : else
2317 : {
2318 0 : strcpy (stpcpy (buffer, resetcode), pinvalue);
2319 0 : rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2320 : buffer, strlen (buffer));
2321 0 : wipememory (buffer, strlen (buffer));
2322 0 : xfree (buffer);
2323 : }
2324 : }
2325 0 : else if (set_resetcode)
2326 : {
2327 0 : if (strlen (pinvalue) < 8)
2328 : {
2329 0 : log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2330 0 : rc = gpg_error (GPG_ERR_BAD_PIN);
2331 : }
2332 : else
2333 0 : rc = iso7816_put_data (app->slot, 0, 0xD3,
2334 : pinvalue, strlen (pinvalue));
2335 : }
2336 0 : else if (reset_mode)
2337 : {
2338 0 : rc = iso7816_reset_retry_counter (app->slot, 0x81,
2339 : pinvalue, strlen (pinvalue));
2340 0 : if (!rc && !app->app_local->extcap.is_v2)
2341 0 : rc = iso7816_reset_retry_counter (app->slot, 0x82,
2342 : pinvalue, strlen (pinvalue));
2343 : }
2344 0 : else if (!app->app_local->extcap.is_v2)
2345 : {
2346 : /* Version 1 cards. */
2347 0 : if (chvno == 1 || chvno == 2)
2348 : {
2349 0 : rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2350 : pinvalue, strlen (pinvalue));
2351 0 : if (!rc)
2352 0 : rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2353 : pinvalue, strlen (pinvalue));
2354 : }
2355 : else /* CHVNO == 3 */
2356 : {
2357 0 : rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2358 : pinvalue, strlen (pinvalue));
2359 : }
2360 : }
2361 : else
2362 : {
2363 : /* Version 2 cards. */
2364 0 : assert (chvno == 1 || chvno == 3);
2365 :
2366 0 : if (use_pinpad)
2367 : {
2368 0 : rc = pincb (pincb_arg,
2369 : chvno == 3 ?
2370 : _("||Please enter the Admin PIN and New Admin PIN") :
2371 : _("||Please enter the PIN and New PIN"), NULL);
2372 0 : if (rc)
2373 : {
2374 0 : log_info (_("PIN callback returned error: %s\n"),
2375 : gpg_strerror (rc));
2376 0 : goto leave;
2377 : }
2378 0 : rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2379 : &pininfo);
2380 0 : pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2381 : }
2382 : else
2383 0 : rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2384 : oldpinvalue, strlen (oldpinvalue),
2385 : pinvalue, strlen (pinvalue));
2386 : }
2387 :
2388 0 : if (pinvalue)
2389 : {
2390 0 : wipememory (pinvalue, strlen (pinvalue));
2391 0 : xfree (pinvalue);
2392 : }
2393 0 : if (rc)
2394 0 : flush_cache_after_error (app);
2395 :
2396 : leave:
2397 0 : if (resetcode)
2398 : {
2399 0 : wipememory (resetcode, strlen (resetcode));
2400 0 : xfree (resetcode);
2401 : }
2402 0 : if (oldpinvalue)
2403 : {
2404 0 : wipememory (oldpinvalue, strlen (oldpinvalue));
2405 0 : xfree (oldpinvalue);
2406 : }
2407 0 : return rc;
2408 : }
2409 :
2410 :
2411 : /* Check whether a key already exists. KEYIDX is the index of the key
2412 : (0..2). If FORCE is TRUE a diagnositic will be printed but no
2413 : error returned if the key already exists. The flag GENERATING is
2414 : only used to print correct messages. */
2415 : static gpg_error_t
2416 0 : does_key_exist (app_t app, int keyidx, int generating, int force)
2417 : {
2418 : const unsigned char *fpr;
2419 : unsigned char *buffer;
2420 : size_t buflen, n;
2421 : int i;
2422 :
2423 0 : assert (keyidx >=0 && keyidx <= 2);
2424 :
2425 0 : if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2426 : {
2427 0 : log_error (_("error reading application data\n"));
2428 0 : return gpg_error (GPG_ERR_GENERAL);
2429 : }
2430 0 : fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2431 0 : if (!fpr || n < 60)
2432 : {
2433 0 : log_error (_("error reading fingerprint DO\n"));
2434 0 : xfree (buffer);
2435 0 : return gpg_error (GPG_ERR_GENERAL);
2436 : }
2437 0 : fpr += 20*keyidx;
2438 0 : for (i=0; i < 20 && !fpr[i]; i++)
2439 : ;
2440 0 : xfree (buffer);
2441 0 : if (i!=20 && !force)
2442 : {
2443 0 : log_error (_("key already exists\n"));
2444 0 : return gpg_error (GPG_ERR_EEXIST);
2445 : }
2446 0 : else if (i!=20)
2447 0 : log_info (_("existing key will be replaced\n"));
2448 0 : else if (generating)
2449 0 : log_info (_("generating new key\n"));
2450 : else
2451 0 : log_info (_("writing new key\n"));
2452 0 : return 0;
2453 : }
2454 :
2455 :
2456 : /* Create a TLV tag and value and store it at BUFFER. Return the length
2457 : of tag and length. A LENGTH greater than 65535 is truncated. */
2458 : static size_t
2459 0 : add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2460 : {
2461 0 : unsigned char *p = buffer;
2462 :
2463 0 : assert (tag <= 0xffff);
2464 0 : if ( tag > 0xff )
2465 0 : *p++ = tag >> 8;
2466 0 : *p++ = tag;
2467 0 : if (length < 128)
2468 0 : *p++ = length;
2469 0 : else if (length < 256)
2470 : {
2471 0 : *p++ = 0x81;
2472 0 : *p++ = length;
2473 : }
2474 : else
2475 : {
2476 0 : if (length > 0xffff)
2477 0 : length = 0xffff;
2478 0 : *p++ = 0x82;
2479 0 : *p++ = length >> 8;
2480 0 : *p++ = length;
2481 : }
2482 :
2483 0 : return p - buffer;
2484 : }
2485 :
2486 :
2487 : static gpg_error_t
2488 0 : build_privkey_template (app_t app, int keyno,
2489 : const unsigned char *rsa_n, size_t rsa_n_len,
2490 : const unsigned char *rsa_e, size_t rsa_e_len,
2491 : const unsigned char *rsa_p, size_t rsa_p_len,
2492 : const unsigned char *rsa_q, size_t rsa_q_len,
2493 : const unsigned char *rsa_u, size_t rsa_u_len,
2494 : const unsigned char *rsa_dp, size_t rsa_dp_len,
2495 : const unsigned char *rsa_dq, size_t rsa_dq_len,
2496 : unsigned char **result, size_t *resultlen)
2497 : {
2498 : size_t rsa_e_reqlen;
2499 : unsigned char privkey[7*(1+3+3)];
2500 : size_t privkey_len;
2501 : unsigned char exthdr[2+2+3];
2502 : size_t exthdr_len;
2503 : unsigned char suffix[2+3];
2504 : size_t suffix_len;
2505 : unsigned char *tp;
2506 : size_t datalen;
2507 : unsigned char *template;
2508 : size_t template_size;
2509 :
2510 0 : *result = NULL;
2511 0 : *resultlen = 0;
2512 :
2513 0 : switch (app->app_local->keyattr[keyno].rsa.format)
2514 : {
2515 : case RSA_STD:
2516 : case RSA_STD_N:
2517 : case RSA_CRT:
2518 : case RSA_CRT_N:
2519 0 : break;
2520 :
2521 : default:
2522 0 : return gpg_error (GPG_ERR_INV_VALUE);
2523 : }
2524 :
2525 : /* Get the required length for E. Rounded up to the nearest byte */
2526 0 : rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
2527 0 : assert (rsa_e_len <= rsa_e_reqlen);
2528 :
2529 : /* Build the 7f48 cardholder private key template. */
2530 0 : datalen = 0;
2531 0 : tp = privkey;
2532 :
2533 0 : tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2534 0 : datalen += rsa_e_reqlen;
2535 :
2536 0 : tp += add_tlv (tp, 0x92, rsa_p_len);
2537 0 : datalen += rsa_p_len;
2538 :
2539 0 : tp += add_tlv (tp, 0x93, rsa_q_len);
2540 0 : datalen += rsa_q_len;
2541 :
2542 0 : if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
2543 0 : || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2544 : {
2545 0 : tp += add_tlv (tp, 0x94, rsa_u_len);
2546 0 : datalen += rsa_u_len;
2547 0 : tp += add_tlv (tp, 0x95, rsa_dp_len);
2548 0 : datalen += rsa_dp_len;
2549 0 : tp += add_tlv (tp, 0x96, rsa_dq_len);
2550 0 : datalen += rsa_dq_len;
2551 : }
2552 :
2553 0 : if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
2554 0 : || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2555 : {
2556 0 : tp += add_tlv (tp, 0x97, rsa_n_len);
2557 0 : datalen += rsa_n_len;
2558 : }
2559 0 : privkey_len = tp - privkey;
2560 :
2561 : /* Build the extended header list without the private key template. */
2562 0 : tp = exthdr;
2563 0 : *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2564 0 : *tp++ = 0;
2565 0 : tp += add_tlv (tp, 0x7f48, privkey_len);
2566 0 : exthdr_len = tp - exthdr;
2567 :
2568 : /* Build the 5f48 suffix of the data. */
2569 0 : tp = suffix;
2570 0 : tp += add_tlv (tp, 0x5f48, datalen);
2571 0 : suffix_len = tp - suffix;
2572 :
2573 : /* Now concatenate everything. */
2574 0 : template_size = (1 + 3 /* 0x4d and len. */
2575 : + exthdr_len
2576 0 : + privkey_len
2577 0 : + suffix_len
2578 0 : + datalen);
2579 0 : tp = template = xtrymalloc_secure (template_size);
2580 0 : if (!template)
2581 0 : return gpg_error_from_syserror ();
2582 :
2583 0 : tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2584 0 : memcpy (tp, exthdr, exthdr_len);
2585 0 : tp += exthdr_len;
2586 0 : memcpy (tp, privkey, privkey_len);
2587 0 : tp += privkey_len;
2588 0 : memcpy (tp, suffix, suffix_len);
2589 0 : tp += suffix_len;
2590 :
2591 0 : memcpy (tp, rsa_e, rsa_e_len);
2592 0 : if (rsa_e_len < rsa_e_reqlen)
2593 : {
2594 : /* Right justify E. */
2595 0 : memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2596 0 : memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2597 : }
2598 0 : tp += rsa_e_reqlen;
2599 :
2600 0 : memcpy (tp, rsa_p, rsa_p_len);
2601 0 : tp += rsa_p_len;
2602 :
2603 0 : memcpy (tp, rsa_q, rsa_q_len);
2604 0 : tp += rsa_q_len;
2605 :
2606 0 : if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
2607 0 : || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2608 : {
2609 0 : memcpy (tp, rsa_u, rsa_u_len);
2610 0 : tp += rsa_u_len;
2611 0 : memcpy (tp, rsa_dp, rsa_dp_len);
2612 0 : tp += rsa_dp_len;
2613 0 : memcpy (tp, rsa_dq, rsa_dq_len);
2614 0 : tp += rsa_dq_len;
2615 : }
2616 :
2617 0 : if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
2618 0 : || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2619 : {
2620 0 : memcpy (tp, rsa_n, rsa_n_len);
2621 0 : tp += rsa_n_len;
2622 : }
2623 :
2624 : /* Sanity check. We don't know the exact length because we
2625 : allocated 3 bytes for the first length header. */
2626 0 : assert (tp - template <= template_size);
2627 :
2628 0 : *result = template;
2629 0 : *resultlen = tp - template;
2630 0 : return 0;
2631 : }
2632 :
2633 : static gpg_error_t
2634 0 : build_ecc_privkey_template (app_t app, int keyno,
2635 : const unsigned char *ecc_d, size_t ecc_d_len,
2636 : unsigned char **result, size_t *resultlen)
2637 : {
2638 : unsigned char privkey[2];
2639 : size_t privkey_len;
2640 : unsigned char exthdr[2+2+1];
2641 : size_t exthdr_len;
2642 : unsigned char suffix[2+1];
2643 : size_t suffix_len;
2644 : unsigned char *tp;
2645 : size_t datalen;
2646 : unsigned char *template;
2647 : size_t template_size;
2648 :
2649 : (void)app;
2650 :
2651 0 : *result = NULL;
2652 0 : *resultlen = 0;
2653 :
2654 : /* Build the 7f48 cardholder private key template. */
2655 0 : datalen = 0;
2656 0 : tp = privkey;
2657 :
2658 0 : tp += add_tlv (tp, 0x92, ecc_d_len);
2659 0 : datalen += ecc_d_len;
2660 :
2661 0 : privkey_len = tp - privkey;
2662 :
2663 : /* Build the extended header list without the private key template. */
2664 0 : tp = exthdr;
2665 0 : *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2666 0 : *tp++ = 0;
2667 0 : tp += add_tlv (tp, 0x7f48, privkey_len);
2668 0 : exthdr_len = tp - exthdr;
2669 :
2670 : /* Build the 5f48 suffix of the data. */
2671 0 : tp = suffix;
2672 0 : tp += add_tlv (tp, 0x5f48, datalen);
2673 0 : suffix_len = tp - suffix;
2674 :
2675 : /* Now concatenate everything. */
2676 0 : template_size = (1 + 1 /* 0x4d and len. */
2677 : + exthdr_len
2678 0 : + privkey_len
2679 0 : + suffix_len
2680 0 : + datalen);
2681 0 : tp = template = xtrymalloc_secure (template_size);
2682 0 : if (!template)
2683 0 : return gpg_error_from_syserror ();
2684 :
2685 0 : tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2686 0 : memcpy (tp, exthdr, exthdr_len);
2687 0 : tp += exthdr_len;
2688 0 : memcpy (tp, privkey, privkey_len);
2689 0 : tp += privkey_len;
2690 0 : memcpy (tp, suffix, suffix_len);
2691 0 : tp += suffix_len;
2692 :
2693 0 : memcpy (tp, ecc_d, ecc_d_len);
2694 0 : tp += ecc_d_len;
2695 :
2696 0 : assert (tp - template == template_size);
2697 :
2698 0 : *result = template;
2699 0 : *resultlen = tp - template;
2700 0 : return 0;
2701 : }
2702 :
2703 :
2704 : /* Helper for do_writekley to change the size of a key. Not ethat
2705 : this deletes the entire key without asking. */
2706 : static gpg_error_t
2707 0 : change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
2708 : gpg_error_t (*pincb)(void*, const char *, char **),
2709 : void *pincb_arg)
2710 : {
2711 : gpg_error_t err;
2712 :
2713 0 : assert (keyno >=0 && keyno <= 2);
2714 :
2715 : /* Prepare for storing the key. */
2716 0 : err = verify_chv3 (app, pincb, pincb_arg);
2717 0 : if (err)
2718 0 : return err;
2719 :
2720 : /* Change the attribute. */
2721 0 : err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
2722 0 : if (err)
2723 0 : log_error ("error changing key attribute (key=%d)\n", keyno+1);
2724 : else
2725 0 : log_info ("key attribute changed (key=%d)\n", keyno+1);
2726 0 : flush_cache (app);
2727 0 : parse_algorithm_attribute (app, keyno);
2728 0 : app->did_chv1 = 0;
2729 0 : app->did_chv2 = 0;
2730 0 : app->did_chv3 = 0;
2731 0 : return err;
2732 : }
2733 :
2734 :
2735 : static gpg_error_t
2736 0 : change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
2737 : gpg_error_t (*pincb)(void*, const char *, char **),
2738 : void *pincb_arg)
2739 : {
2740 0 : gpg_error_t err = 0;
2741 : unsigned char *buf;
2742 : size_t buflen;
2743 : void *relptr;
2744 :
2745 : /* Read the current attributes into a buffer. */
2746 0 : relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
2747 0 : if (!relptr)
2748 0 : err = gpg_error (GPG_ERR_CARD);
2749 0 : else if (buflen < 6 || buf[0] != PUBKEY_ALGO_RSA)
2750 : {
2751 : /* Attriutes too short or not an RSA key. */
2752 0 : xfree (relptr);
2753 0 : err = gpg_error (GPG_ERR_CARD);
2754 : }
2755 : else
2756 : {
2757 : /* We only change n_bits and don't touch anything else. Before we
2758 : do so, we round up NBITS to a sensible way in the same way as
2759 : gpg's key generation does it. This may help to sort out problems
2760 : with a few bits too short keys. */
2761 0 : nbits = ((nbits + 31) / 32) * 32;
2762 0 : buf[1] = (nbits >> 8);
2763 0 : buf[2] = nbits;
2764 0 : err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
2765 0 : xfree (relptr);
2766 : }
2767 :
2768 0 : return err;
2769 : }
2770 :
2771 :
2772 : /* Helper to process an setattr command for name KEY-ATTR.
2773 : In (VALUE,VALUELEN), it expects following string:
2774 : RSA: "--force <key> <algo> rsa<nbits>"
2775 : ECC: "--force <key> <algo> <curvename>"
2776 : */
2777 : static gpg_error_t
2778 0 : change_keyattr_from_string (app_t app,
2779 : gpg_error_t (*pincb)(void*, const char *, char **),
2780 : void *pincb_arg,
2781 : const void *value, size_t valuelen)
2782 : {
2783 0 : gpg_error_t err = 0;
2784 : char *string;
2785 : int key, keyno, algo;
2786 0 : int n = 0;
2787 :
2788 : /* VALUE is expected to be a string but not guaranteed to be
2789 : terminated. Thus copy it to an allocated buffer first. */
2790 0 : string = xtrymalloc (valuelen+1);
2791 0 : if (!string)
2792 0 : return gpg_error_from_syserror ();
2793 0 : memcpy (string, value, valuelen);
2794 0 : string[valuelen] = 0;
2795 :
2796 : /* Because this function deletes the key we require the string
2797 : "--force" in the data to make clear that something serious might
2798 : happen. */
2799 0 : sscanf (string, "--force %d %d %n", &key, &algo, &n);
2800 0 : if (n < 12)
2801 : {
2802 0 : err = gpg_error (GPG_ERR_INV_DATA);
2803 0 : goto leave;
2804 : }
2805 :
2806 0 : keyno = key - 1;
2807 0 : if (keyno < 0 || keyno > 2)
2808 0 : err = gpg_error (GPG_ERR_INV_ID);
2809 0 : else if (algo == PUBKEY_ALGO_RSA)
2810 : {
2811 : unsigned int nbits;
2812 :
2813 0 : errno = 0;
2814 0 : nbits = strtoul (string+n+3, NULL, 10);
2815 0 : if (errno)
2816 0 : err = gpg_error (GPG_ERR_INV_DATA);
2817 0 : else if (nbits < 1024)
2818 0 : err = gpg_error (GPG_ERR_TOO_SHORT);
2819 0 : else if (nbits > 4096)
2820 0 : err = gpg_error (GPG_ERR_TOO_LARGE);
2821 : else
2822 0 : err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
2823 : }
2824 0 : else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
2825 0 : || algo == PUBKEY_ALGO_EDDSA)
2826 0 : {
2827 : const char *oidstr;
2828 : gcry_mpi_t oid;
2829 : const unsigned char *oidbuf;
2830 : size_t oid_len;
2831 :
2832 0 : oidstr = openpgp_curve_to_oid (string+n, NULL);
2833 0 : if (!oidstr)
2834 : {
2835 0 : err = gpg_error (GPG_ERR_INV_DATA);
2836 0 : goto leave;
2837 : }
2838 :
2839 0 : err = openpgp_oid_from_str (oidstr, &oid);
2840 0 : if (err)
2841 0 : goto leave;
2842 :
2843 0 : oidbuf = gcry_mpi_get_opaque (oid, &n);
2844 0 : oid_len = (n+7)/8;
2845 :
2846 : /* We have enough room at STRING. */
2847 0 : string[0] = algo;
2848 0 : memcpy (string+1, oidbuf+1, oid_len-1);
2849 0 : err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
2850 0 : gcry_mpi_release (oid);
2851 : }
2852 : else
2853 0 : err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2854 :
2855 : leave:
2856 0 : xfree (string);
2857 0 : return err;
2858 : }
2859 :
2860 :
2861 : static gpg_error_t
2862 0 : rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
2863 : void *pincb_arg, int keyno,
2864 : const unsigned char *buf, size_t buflen, int depth)
2865 : {
2866 : gpg_error_t err;
2867 : const unsigned char *tok;
2868 : size_t toklen;
2869 : int last_depth1, last_depth2;
2870 0 : const unsigned char *rsa_n = NULL;
2871 0 : const unsigned char *rsa_e = NULL;
2872 0 : const unsigned char *rsa_p = NULL;
2873 0 : const unsigned char *rsa_q = NULL;
2874 : size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2875 : unsigned int nbits;
2876 : unsigned int maxbits;
2877 0 : unsigned char *template = NULL;
2878 : unsigned char *tp;
2879 : size_t template_len;
2880 : unsigned char fprbuf[20];
2881 0 : u32 created_at = 0;
2882 :
2883 0 : if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
2884 : {
2885 0 : log_error (_("unsupported algorithm: %s"), "RSA");
2886 0 : err = gpg_error (GPG_ERR_INV_VALUE);
2887 0 : goto leave;
2888 : }
2889 :
2890 0 : last_depth1 = depth;
2891 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2892 0 : && depth && depth >= last_depth1)
2893 : {
2894 0 : if (tok)
2895 : {
2896 0 : err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2897 0 : goto leave;
2898 : }
2899 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2900 0 : goto leave;
2901 0 : if (tok && toklen == 1)
2902 : {
2903 : const unsigned char **mpi;
2904 : size_t *mpi_len;
2905 :
2906 0 : switch (*tok)
2907 : {
2908 0 : case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
2909 0 : case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
2910 0 : case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
2911 0 : case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
2912 0 : default: mpi = NULL; mpi_len = NULL; break;
2913 : }
2914 0 : if (mpi && *mpi)
2915 : {
2916 0 : err = gpg_error (GPG_ERR_DUP_VALUE);
2917 0 : goto leave;
2918 : }
2919 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2920 0 : goto leave;
2921 0 : if (tok && mpi)
2922 : {
2923 : /* Strip off leading zero bytes and save. */
2924 0 : for (;toklen && !*tok; toklen--, tok++)
2925 : ;
2926 0 : *mpi = tok;
2927 0 : *mpi_len = toklen;
2928 : }
2929 : }
2930 : /* Skip until end of list. */
2931 0 : last_depth2 = depth;
2932 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2933 0 : && depth && depth >= last_depth2)
2934 : ;
2935 0 : if (err)
2936 0 : goto leave;
2937 : }
2938 : /* Parse other attributes. */
2939 0 : last_depth1 = depth;
2940 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2941 0 : && depth && depth >= last_depth1)
2942 : {
2943 0 : if (tok)
2944 : {
2945 0 : err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2946 0 : goto leave;
2947 : }
2948 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2949 0 : goto leave;
2950 0 : if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2951 : {
2952 0 : if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2953 0 : goto leave;
2954 0 : if (tok)
2955 : {
2956 0 : for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2957 0 : tok++, toklen--)
2958 0 : created_at = created_at*10 + (*tok - '0');
2959 : }
2960 : }
2961 : /* Skip until end of list. */
2962 0 : last_depth2 = depth;
2963 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2964 0 : && depth && depth >= last_depth2)
2965 : ;
2966 0 : if (err)
2967 0 : goto leave;
2968 : }
2969 :
2970 :
2971 : /* Check that we have all parameters and that they match the card
2972 : description. */
2973 0 : if (!created_at)
2974 : {
2975 0 : log_error (_("creation timestamp missing\n"));
2976 0 : err = gpg_error (GPG_ERR_INV_VALUE);
2977 0 : goto leave;
2978 : }
2979 :
2980 0 : maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
2981 0 : nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2982 0 : if (opt.verbose)
2983 0 : log_info ("RSA modulus size is %u bits (%u bytes)\n",
2984 : nbits, (unsigned int)rsa_n_len);
2985 0 : if (nbits && nbits != maxbits
2986 0 : && app->app_local->extcap.algo_attr_change)
2987 : {
2988 : /* Try to switch the key to a new length. */
2989 0 : err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
2990 0 : if (!err)
2991 0 : maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
2992 : }
2993 0 : if (nbits != maxbits)
2994 : {
2995 0 : log_error (_("RSA modulus missing or not of size %d bits\n"),
2996 : (int)maxbits);
2997 0 : err = gpg_error (GPG_ERR_BAD_SECKEY);
2998 0 : goto leave;
2999 : }
3000 :
3001 0 : maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3002 0 : if (maxbits > 32 && !app->app_local->extcap.is_v2)
3003 0 : maxbits = 32; /* Our code for v1 does only support 32 bits. */
3004 0 : nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3005 0 : if (nbits < 2 || nbits > maxbits)
3006 : {
3007 0 : log_error (_("RSA public exponent missing or larger than %d bits\n"),
3008 : (int)maxbits);
3009 0 : err = gpg_error (GPG_ERR_BAD_SECKEY);
3010 0 : goto leave;
3011 : }
3012 :
3013 0 : maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3014 0 : nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3015 0 : if (nbits != maxbits)
3016 : {
3017 0 : log_error (_("RSA prime %s missing or not of size %d bits\n"),
3018 : "P", (int)maxbits);
3019 0 : err = gpg_error (GPG_ERR_BAD_SECKEY);
3020 0 : goto leave;
3021 : }
3022 0 : nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3023 0 : if (nbits != maxbits)
3024 : {
3025 0 : log_error (_("RSA prime %s missing or not of size %d bits\n"),
3026 : "Q", (int)maxbits);
3027 0 : err = gpg_error (GPG_ERR_BAD_SECKEY);
3028 0 : goto leave;
3029 : }
3030 :
3031 : /* We need to remove the cached public key. */
3032 0 : xfree (app->app_local->pk[keyno].key);
3033 0 : app->app_local->pk[keyno].key = NULL;
3034 0 : app->app_local->pk[keyno].keylen = 0;
3035 0 : app->app_local->pk[keyno].read_done = 0;
3036 :
3037 :
3038 0 : if (app->app_local->extcap.is_v2)
3039 : {
3040 : unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3041 : size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3042 : gcry_mpi_t mpi_e, mpi_p, mpi_q;
3043 0 : gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3044 0 : gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3045 0 : gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3046 0 : gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3047 : int exmode;
3048 :
3049 : /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3050 0 : gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3051 0 : gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3052 0 : gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3053 :
3054 0 : gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3055 0 : gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3056 0 : gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3057 0 : gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3058 0 : gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3059 :
3060 0 : gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3061 0 : gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3062 0 : gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3063 :
3064 0 : gcry_mpi_release (mpi_e);
3065 0 : gcry_mpi_release (mpi_p);
3066 0 : gcry_mpi_release (mpi_q);
3067 0 : gcry_mpi_release (mpi_u);
3068 0 : gcry_mpi_release (mpi_dp);
3069 0 : gcry_mpi_release (mpi_dq);
3070 0 : gcry_mpi_release (mpi_tmp);
3071 :
3072 : /* Build the private key template as described in section 4.3.3.7 of
3073 : the OpenPGP card specs version 2.0. */
3074 0 : err = build_privkey_template (app, keyno,
3075 : rsa_n, rsa_n_len,
3076 : rsa_e, rsa_e_len,
3077 : rsa_p, rsa_p_len,
3078 : rsa_q, rsa_q_len,
3079 : rsa_u, rsa_u_len,
3080 : rsa_dp, rsa_dp_len,
3081 : rsa_dq, rsa_dq_len,
3082 : &template, &template_len);
3083 0 : xfree(rsa_u);
3084 0 : xfree(rsa_dp);
3085 0 : xfree(rsa_dq);
3086 :
3087 0 : if (err)
3088 0 : goto leave;
3089 :
3090 : /* Prepare for storing the key. */
3091 0 : err = verify_chv3 (app, pincb, pincb_arg);
3092 0 : if (err)
3093 0 : goto leave;
3094 :
3095 : /* Store the key. */
3096 0 : if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3097 0 : exmode = 1; /* Use extended length w/o a limit. */
3098 0 : else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3099 0 : exmode = -254;
3100 : else
3101 0 : exmode = 0;
3102 0 : err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3103 : template, template_len);
3104 : }
3105 : else
3106 : {
3107 : /* Build the private key template as described in section 4.3.3.6 of
3108 : the OpenPGP card specs version 1.1:
3109 : 0xC0 <length> public exponent
3110 : 0xC1 <length> prime p
3111 : 0xC2 <length> prime q
3112 : */
3113 0 : assert (rsa_e_len <= 4);
3114 0 : template_len = (1 + 1 + 4
3115 : + 1 + 1 + rsa_p_len
3116 0 : + 1 + 1 + rsa_q_len);
3117 0 : template = tp = xtrymalloc_secure (template_len);
3118 0 : if (!template)
3119 : {
3120 0 : err = gpg_error_from_syserror ();
3121 0 : goto leave;
3122 : }
3123 0 : *tp++ = 0xC0;
3124 0 : *tp++ = 4;
3125 0 : memcpy (tp, rsa_e, rsa_e_len);
3126 0 : if (rsa_e_len < 4)
3127 : {
3128 : /* Right justify E. */
3129 0 : memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3130 0 : memset (tp, 0, 4-rsa_e_len);
3131 : }
3132 0 : tp += 4;
3133 :
3134 0 : *tp++ = 0xC1;
3135 0 : *tp++ = rsa_p_len;
3136 0 : memcpy (tp, rsa_p, rsa_p_len);
3137 0 : tp += rsa_p_len;
3138 :
3139 0 : *tp++ = 0xC2;
3140 0 : *tp++ = rsa_q_len;
3141 0 : memcpy (tp, rsa_q, rsa_q_len);
3142 0 : tp += rsa_q_len;
3143 :
3144 0 : assert (tp - template == template_len);
3145 :
3146 : /* Prepare for storing the key. */
3147 0 : err = verify_chv3 (app, pincb, pincb_arg);
3148 0 : if (err)
3149 0 : goto leave;
3150 :
3151 : /* Store the key. */
3152 0 : err = iso7816_put_data (app->slot, 0,
3153 0 : (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
3154 : template, template_len);
3155 : }
3156 0 : if (err)
3157 : {
3158 0 : log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3159 0 : goto leave;
3160 : }
3161 :
3162 0 : err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
3163 : rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3164 0 : if (err)
3165 0 : goto leave;
3166 :
3167 :
3168 : leave:
3169 0 : xfree (template);
3170 0 : return err;
3171 : }
3172 :
3173 :
3174 : static gpg_error_t
3175 0 : ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3176 : void *pincb_arg, int keyno,
3177 : const unsigned char *buf, size_t buflen, int depth)
3178 : {
3179 : gpg_error_t err;
3180 : const unsigned char *tok;
3181 : size_t toklen;
3182 : int last_depth1, last_depth2;
3183 0 : const unsigned char *ecc_q = NULL;
3184 0 : const unsigned char *ecc_d = NULL;
3185 : size_t ecc_q_len, ecc_d_len;
3186 0 : u32 created_at = 0;
3187 0 : const char *oidstr = NULL;
3188 0 : int flag_djb_tweak = 0;
3189 : int algo;
3190 : gcry_mpi_t oid;
3191 0 : const unsigned char *oidbuf = NULL;
3192 : unsigned int n;
3193 : size_t oid_len;
3194 : unsigned char fprbuf[20];
3195 :
3196 : /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3197 : curve = "NIST P-256" */
3198 : /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3199 : curve = "secp256k1" */
3200 : /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3201 : curve = "Ed25519" */
3202 0 : last_depth1 = depth;
3203 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3204 0 : && depth && depth >= last_depth1)
3205 : {
3206 0 : if (tok)
3207 : {
3208 0 : err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3209 0 : goto leave;
3210 : }
3211 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3212 0 : goto leave;
3213 :
3214 0 : if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3215 0 : {
3216 : unsigned char *curve;
3217 :
3218 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3219 0 : goto leave;
3220 :
3221 0 : curve = xtrymalloc (toklen+1);
3222 0 : if (!curve)
3223 : {
3224 0 : err = gpg_error_from_syserror ();
3225 0 : goto leave;
3226 : }
3227 :
3228 0 : memcpy (curve, tok, toklen);
3229 0 : curve[toklen] = 0;
3230 0 : oidstr = openpgp_curve_to_oid (curve, NULL);
3231 0 : xfree (curve);
3232 : }
3233 0 : else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
3234 : {
3235 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3236 0 : goto leave;
3237 :
3238 0 : if (tok)
3239 : {
3240 0 : if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
3241 0 : || (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
3242 0 : flag_djb_tweak = 1;
3243 : }
3244 : }
3245 0 : else if (tok && toklen == 1)
3246 : {
3247 : const unsigned char **buf2;
3248 : size_t *buf2len;
3249 0 : int native = flag_djb_tweak;
3250 :
3251 0 : switch (*tok)
3252 : {
3253 0 : case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3254 0 : case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
3255 0 : default: buf2 = NULL; buf2len = NULL; break;
3256 : }
3257 0 : if (buf2 && *buf2)
3258 : {
3259 0 : err = gpg_error (GPG_ERR_DUP_VALUE);
3260 0 : goto leave;
3261 : }
3262 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3263 0 : goto leave;
3264 0 : if (tok && buf2)
3265 : {
3266 0 : if (!native)
3267 : /* Strip off leading zero bytes and save. */
3268 0 : for (;toklen && !*tok; toklen--, tok++)
3269 : ;
3270 :
3271 0 : *buf2 = tok;
3272 0 : *buf2len = toklen;
3273 : }
3274 : }
3275 : /* Skip until end of list. */
3276 0 : last_depth2 = depth;
3277 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3278 0 : && depth && depth >= last_depth2)
3279 : ;
3280 0 : if (err)
3281 0 : goto leave;
3282 : }
3283 : /* Parse other attributes. */
3284 0 : last_depth1 = depth;
3285 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3286 0 : && depth && depth >= last_depth1)
3287 : {
3288 0 : if (tok)
3289 : {
3290 0 : err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3291 0 : goto leave;
3292 : }
3293 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3294 0 : goto leave;
3295 0 : if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3296 : {
3297 0 : if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3298 0 : goto leave;
3299 0 : if (tok)
3300 : {
3301 0 : for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3302 0 : tok++, toklen--)
3303 0 : created_at = created_at*10 + (*tok - '0');
3304 : }
3305 : }
3306 : /* Skip until end of list. */
3307 0 : last_depth2 = depth;
3308 0 : while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3309 0 : && depth && depth >= last_depth2)
3310 : ;
3311 0 : if (err)
3312 0 : goto leave;
3313 : }
3314 :
3315 :
3316 : /* Check that we have all parameters and that they match the card
3317 : description. */
3318 0 : if (!oidstr)
3319 : {
3320 0 : log_error (_("unsupported curve\n"));
3321 0 : err = gpg_error (GPG_ERR_INV_VALUE);
3322 0 : goto leave;
3323 : }
3324 0 : if (!created_at)
3325 : {
3326 0 : log_error (_("creation timestamp missing\n"));
3327 0 : err = gpg_error (GPG_ERR_INV_VALUE);
3328 0 : goto leave;
3329 : }
3330 0 : if (flag_djb_tweak && keyno != 1)
3331 0 : algo = PUBKEY_ALGO_EDDSA;
3332 0 : else if (keyno == 1)
3333 0 : algo = PUBKEY_ALGO_ECDH;
3334 : else
3335 0 : algo = PUBKEY_ALGO_ECDSA;
3336 :
3337 0 : err = openpgp_oid_from_str (oidstr, &oid);
3338 0 : if (err)
3339 0 : goto leave;
3340 0 : oidbuf = gcry_mpi_get_opaque (oid, &n);
3341 0 : oid_len = (n+7)/8;
3342 0 : if (!oidbuf)
3343 : {
3344 0 : err = gpg_error_from_syserror ();
3345 0 : gcry_mpi_release (oid);
3346 0 : goto leave;
3347 : }
3348 :
3349 0 : if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_ECC
3350 0 : || app->app_local->keyattr[keyno].ecc.oid != oidstr
3351 0 : || app->app_local->keyattr[keyno].ecc.flags != flag_djb_tweak)
3352 : {
3353 0 : if (app->app_local->extcap.algo_attr_change)
3354 : {
3355 0 : unsigned char keyattr[oid_len];
3356 :
3357 0 : keyattr[0] = algo;
3358 0 : memcpy (keyattr+1, oidbuf+1, oid_len-1);
3359 0 : err = change_keyattr (app, keyno, keyattr, oid_len, pincb, pincb_arg);
3360 0 : if (err)
3361 0 : goto leave;
3362 : }
3363 : else
3364 : {
3365 0 : log_error ("key attribute on card doesn't match\n");
3366 0 : err = gpg_error (GPG_ERR_INV_VALUE);
3367 0 : goto leave;
3368 : }
3369 : }
3370 :
3371 0 : if (opt.verbose)
3372 0 : log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
3373 :
3374 : /* We need to remove the cached public key. */
3375 0 : xfree (app->app_local->pk[keyno].key);
3376 0 : app->app_local->pk[keyno].key = NULL;
3377 0 : app->app_local->pk[keyno].keylen = 0;
3378 0 : app->app_local->pk[keyno].read_done = 0;
3379 :
3380 0 : if (app->app_local->extcap.is_v2)
3381 : {
3382 : /* Build the private key template as described in section 4.3.3.7 of
3383 : the OpenPGP card specs version 2.0. */
3384 : unsigned char *template;
3385 : size_t template_len;
3386 : int exmode;
3387 :
3388 0 : err = build_ecc_privkey_template (app, keyno,
3389 : ecc_d, ecc_d_len,
3390 : &template, &template_len);
3391 0 : if (err)
3392 0 : goto leave;
3393 :
3394 : /* Prepare for storing the key. */
3395 0 : err = verify_chv3 (app, pincb, pincb_arg);
3396 0 : if (err)
3397 : {
3398 0 : xfree (template);
3399 0 : goto leave;
3400 : }
3401 :
3402 : /* Store the key. */
3403 0 : if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3404 0 : exmode = 1; /* Use extended length w/o a limit. */
3405 0 : else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3406 0 : exmode = -254;
3407 : else
3408 0 : exmode = 0;
3409 0 : err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3410 : template, template_len);
3411 0 : xfree (template);
3412 : }
3413 : else
3414 0 : err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3415 :
3416 0 : if (err)
3417 : {
3418 0 : log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3419 0 : goto leave;
3420 : }
3421 :
3422 0 : err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
3423 : ecc_q, ecc_q_len, "\x03\x01\x08\x07", (size_t)4);
3424 :
3425 : leave:
3426 0 : if (oidbuf)
3427 0 : gcry_mpi_release (oid);
3428 0 : return err;
3429 : }
3430 :
3431 : /* Handle the WRITEKEY command for OpenPGP. This function expects a
3432 : canonical encoded S-expression with the secret key in KEYDATA and
3433 : its length (for assertions) in KEYDATALEN. KEYID needs to be the
3434 : usual keyid which for OpenPGP is the string "OPENPGP.n" with
3435 : n=1,2,3. Bit 0 of FLAGS indicates whether an existing key shall
3436 : get overwritten. PINCB and PINCB_ARG are the usual arguments for
3437 : the pinentry callback. */
3438 : static gpg_error_t
3439 0 : do_writekey (app_t app, ctrl_t ctrl,
3440 : const char *keyid, unsigned int flags,
3441 : gpg_error_t (*pincb)(void*, const char *, char **),
3442 : void *pincb_arg,
3443 : const unsigned char *keydata, size_t keydatalen)
3444 : {
3445 : gpg_error_t err;
3446 0 : int force = (flags & 1);
3447 : int keyno;
3448 : const unsigned char *buf, *tok;
3449 : size_t buflen, toklen;
3450 : int depth;
3451 :
3452 : (void)ctrl;
3453 :
3454 0 : if (!strcmp (keyid, "OPENPGP.1"))
3455 0 : keyno = 0;
3456 0 : else if (!strcmp (keyid, "OPENPGP.2"))
3457 0 : keyno = 1;
3458 0 : else if (!strcmp (keyid, "OPENPGP.3"))
3459 0 : keyno = 2;
3460 : else
3461 0 : return gpg_error (GPG_ERR_INV_ID);
3462 :
3463 0 : err = does_key_exist (app, keyno, 0, force);
3464 0 : if (err)
3465 0 : return err;
3466 :
3467 :
3468 : /*
3469 : Parse the S-expression
3470 : */
3471 0 : buf = keydata;
3472 0 : buflen = keydatalen;
3473 0 : depth = 0;
3474 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3475 0 : goto leave;
3476 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3477 0 : goto leave;
3478 0 : if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
3479 : {
3480 0 : if (!tok)
3481 : ;
3482 0 : else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
3483 0 : log_info ("protected-private-key passed to writekey\n");
3484 0 : else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
3485 0 : log_info ("shadowed-private-key passed to writekey\n");
3486 0 : err = gpg_error (GPG_ERR_BAD_SECKEY);
3487 0 : goto leave;
3488 : }
3489 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3490 0 : goto leave;
3491 0 : if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3492 0 : goto leave;
3493 0 : if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
3494 0 : err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
3495 0 : else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
3496 0 : err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
3497 : else
3498 : {
3499 0 : err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
3500 0 : goto leave;
3501 : }
3502 :
3503 : leave:
3504 0 : return err;
3505 : }
3506 :
3507 :
3508 :
3509 : /* Handle the GENKEY command. */
3510 : static gpg_error_t
3511 0 : do_genkey (app_t app, ctrl_t ctrl, const char *keynostr, unsigned int flags,
3512 : time_t createtime,
3513 : gpg_error_t (*pincb)(void*, const char *, char **),
3514 : void *pincb_arg)
3515 : {
3516 : int rc;
3517 : char numbuf[30];
3518 : unsigned char fprbuf[20];
3519 : const unsigned char *keydata, *m, *e;
3520 0 : unsigned char *buffer = NULL;
3521 : size_t buflen, keydatalen, mlen, elen;
3522 : time_t created_at;
3523 0 : int keyno = atoi (keynostr) - 1;
3524 0 : int force = (flags & 1);
3525 : time_t start_at;
3526 : int exmode;
3527 : int le_value;
3528 : unsigned int keybits;
3529 :
3530 0 : if (keyno < 0 || keyno > 2)
3531 0 : return gpg_error (GPG_ERR_INV_ID);
3532 :
3533 : /* We flush the cache to increase the traffic before a key
3534 : generation. This _might_ help a card to gather more entropy. */
3535 0 : flush_cache (app);
3536 :
3537 : /* Obviously we need to remove the cached public key. */
3538 0 : xfree (app->app_local->pk[keyno].key);
3539 0 : app->app_local->pk[keyno].key = NULL;
3540 0 : app->app_local->pk[keyno].keylen = 0;
3541 0 : app->app_local->pk[keyno].read_done = 0;
3542 :
3543 : /* Check whether a key already exists. */
3544 0 : rc = does_key_exist (app, keyno, 1, force);
3545 0 : if (rc)
3546 0 : return rc;
3547 :
3548 : /* Because we send the key parameter back via status lines we need
3549 : to put a limit on the max. allowed keysize. 2048 bit will
3550 : already lead to a 527 byte long status line and thus a 4096 bit
3551 : key would exceed the Assuan line length limit. */
3552 0 : keybits = app->app_local->keyattr[keyno].rsa.n_bits;
3553 0 : if (keybits > 4096)
3554 0 : return gpg_error (GPG_ERR_TOO_LARGE);
3555 :
3556 : /* Prepare for key generation by verifying the Admin PIN. */
3557 0 : rc = verify_chv3 (app, pincb, pincb_arg);
3558 0 : if (rc)
3559 0 : goto leave;
3560 :
3561 : /* Test whether we will need extended length mode. (1900 is an
3562 : arbitrary length which for sure fits into a short apdu.) */
3563 0 : if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
3564 : {
3565 0 : exmode = 1; /* Use extended length w/o a limit. */
3566 0 : le_value = app->app_local->extcap.max_rsp_data;
3567 : /* No need to check le_value because it comes from a 16 bit
3568 : value and thus can't create an overflow on a 32 bit
3569 : system. */
3570 : }
3571 : else
3572 : {
3573 0 : exmode = 0;
3574 0 : le_value = 256; /* Use legacy value. */
3575 : }
3576 :
3577 0 : log_info (_("please wait while key is being generated ...\n"));
3578 0 : start_at = time (NULL);
3579 0 : rc = iso7816_generate_keypair
3580 : /* # warning key generation temporary replaced by reading an existing key. */
3581 : /* rc = iso7816_read_public_key */
3582 : (app->slot, exmode,
3583 : (const unsigned char*)(keyno == 0? "\xB6" :
3584 : keyno == 1? "\xB8" : "\xA4"), 2,
3585 : le_value,
3586 : &buffer, &buflen);
3587 0 : if (rc)
3588 : {
3589 0 : rc = gpg_error (GPG_ERR_CARD);
3590 0 : log_error (_("generating key failed\n"));
3591 0 : goto leave;
3592 : }
3593 :
3594 : {
3595 0 : int nsecs = (int)(time (NULL) - start_at);
3596 0 : log_info (ngettext("key generation completed (%d second)\n",
3597 : "key generation completed (%d seconds)\n",
3598 : nsecs), nsecs);
3599 : }
3600 :
3601 0 : keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
3602 0 : if (!keydata)
3603 : {
3604 0 : rc = gpg_error (GPG_ERR_CARD);
3605 0 : log_error (_("response does not contain the public key data\n"));
3606 0 : goto leave;
3607 : }
3608 :
3609 0 : m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
3610 0 : if (!m)
3611 : {
3612 0 : rc = gpg_error (GPG_ERR_CARD);
3613 0 : log_error (_("response does not contain the RSA modulus\n"));
3614 0 : goto leave;
3615 : }
3616 : /* log_printhex ("RSA n:", m, mlen); */
3617 0 : send_key_data (ctrl, "n", m, mlen);
3618 :
3619 0 : e = find_tlv (keydata, keydatalen, 0x0082, &elen);
3620 0 : if (!e)
3621 : {
3622 0 : rc = gpg_error (GPG_ERR_CARD);
3623 0 : log_error (_("response does not contain the RSA public exponent\n"));
3624 0 : goto leave;
3625 : }
3626 : /* log_printhex ("RSA e:", e, elen); */
3627 0 : send_key_data (ctrl, "e", e, elen);
3628 :
3629 0 : created_at = createtime? createtime : gnupg_get_time ();
3630 0 : sprintf (numbuf, "%lu", (unsigned long)created_at);
3631 0 : send_status_info (ctrl, "KEY-CREATED-AT",
3632 : numbuf, (size_t)strlen(numbuf), NULL, 0);
3633 :
3634 0 : for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
3635 : ;
3636 0 : for (; elen && !*e; elen--, e++) /* strip leading zeroes */
3637 : ;
3638 :
3639 0 : rc = store_fpr (app, keyno, (u32)created_at, fprbuf, PUBKEY_ALGO_RSA,
3640 : m, mlen, e, elen);
3641 0 : if (rc)
3642 0 : goto leave;
3643 0 : send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
3644 :
3645 :
3646 : leave:
3647 0 : xfree (buffer);
3648 0 : return rc;
3649 : }
3650 :
3651 :
3652 : static unsigned long
3653 0 : convert_sig_counter_value (const unsigned char *value, size_t valuelen)
3654 : {
3655 : unsigned long ul;
3656 :
3657 0 : if (valuelen == 3 )
3658 0 : ul = (value[0] << 16) | (value[1] << 8) | value[2];
3659 : else
3660 : {
3661 0 : log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
3662 0 : ul = 0;
3663 : }
3664 0 : return ul;
3665 : }
3666 :
3667 : static unsigned long
3668 0 : get_sig_counter (app_t app)
3669 : {
3670 : void *relptr;
3671 : unsigned char *value;
3672 : size_t valuelen;
3673 : unsigned long ul;
3674 :
3675 0 : relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
3676 0 : if (!relptr)
3677 0 : return 0;
3678 0 : ul = convert_sig_counter_value (value, valuelen);
3679 0 : xfree (relptr);
3680 0 : return ul;
3681 : }
3682 :
3683 : static gpg_error_t
3684 0 : compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
3685 : {
3686 : const unsigned char *fpr;
3687 : unsigned char *buffer;
3688 : size_t buflen, n;
3689 : int rc, i;
3690 :
3691 0 : assert (keyno >= 0 && keyno <= 2);
3692 :
3693 0 : rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3694 0 : if (rc)
3695 : {
3696 0 : log_error (_("error reading application data\n"));
3697 0 : return gpg_error (GPG_ERR_GENERAL);
3698 : }
3699 0 : fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3700 0 : if (!fpr || n != 60)
3701 : {
3702 0 : xfree (buffer);
3703 0 : log_error (_("error reading fingerprint DO\n"));
3704 0 : return gpg_error (GPG_ERR_GENERAL);
3705 : }
3706 0 : fpr += keyno*20;
3707 0 : for (i=0; i < 20; i++)
3708 0 : if (sha1fpr[i] != fpr[i])
3709 : {
3710 0 : xfree (buffer);
3711 0 : log_info (_("fingerprint on card does not match requested one\n"));
3712 0 : return gpg_error (GPG_ERR_WRONG_SECKEY);
3713 : }
3714 0 : xfree (buffer);
3715 0 : return 0;
3716 : }
3717 :
3718 :
3719 : /* If a fingerprint has been specified check it against the one on the
3720 : card. This allows for a meaningful error message in case the key
3721 : on the card has been replaced but the shadow information known to
3722 : gpg has not been updated. If there is no fingerprint we assume
3723 : that this is okay. */
3724 : static gpg_error_t
3725 0 : check_against_given_fingerprint (app_t app, const char *fpr, int key)
3726 : {
3727 : unsigned char tmp[20];
3728 : const char *s;
3729 : int n;
3730 :
3731 0 : for (s=fpr, n=0; hexdigitp (s); s++, n++)
3732 : ;
3733 0 : if (n != 40)
3734 0 : return gpg_error (GPG_ERR_INV_ID);
3735 0 : else if (!*s)
3736 : ; /* okay */
3737 : else
3738 0 : return gpg_error (GPG_ERR_INV_ID);
3739 :
3740 0 : for (s=fpr, n=0; n < 20; s += 2, n++)
3741 0 : tmp[n] = xtoi_2 (s);
3742 0 : return compare_fingerprint (app, key-1, tmp);
3743 : }
3744 :
3745 :
3746 :
3747 : /* Compute a digital signature on INDATA which is expected to be the
3748 : raw message digest. For this application the KEYIDSTR consists of
3749 : the serialnumber and the fingerprint delimited by a slash.
3750 :
3751 : Note that this function may return the error code
3752 : GPG_ERR_WRONG_CARD to indicate that the card currently present does
3753 : not match the one required for the requested action (e.g. the
3754 : serial number does not match).
3755 :
3756 : As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3757 : operation to the auth command.
3758 : */
3759 : static gpg_error_t
3760 0 : do_sign (app_t app, const char *keyidstr, int hashalgo,
3761 : gpg_error_t (*pincb)(void*, const char *, char **),
3762 : void *pincb_arg,
3763 : const void *indata, size_t indatalen,
3764 : unsigned char **outdata, size_t *outdatalen )
3765 : {
3766 : static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3767 : { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3768 : 0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
3769 : static unsigned char sha1_prefix[15] = /* (1.3.14.3.2.26) */
3770 : { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3771 : 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
3772 : static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3773 : { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3774 : 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3775 : 0x1C };
3776 : static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3777 : { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3778 : 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3779 : 0x00, 0x04, 0x20 };
3780 : static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3781 : { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3782 : 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3783 : 0x00, 0x04, 0x30 };
3784 : static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3785 : { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3786 : 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3787 : 0x00, 0x04, 0x40 };
3788 : int rc;
3789 : unsigned char data[19+64];
3790 : size_t datalen;
3791 : unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3792 : const char *s;
3793 : int n;
3794 0 : const char *fpr = NULL;
3795 : unsigned long sigcount;
3796 0 : int use_auth = 0;
3797 : int exmode, le_value;
3798 :
3799 0 : if (!keyidstr || !*keyidstr)
3800 0 : return gpg_error (GPG_ERR_INV_VALUE);
3801 :
3802 : /* Strip off known prefixes. */
3803 : #define X(a,b,c,d) \
3804 : if (hashalgo == GCRY_MD_ ## a \
3805 : && (d) \
3806 : && indatalen == sizeof b ## _prefix + (c) \
3807 : && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3808 : { \
3809 : indata = (const char*)indata + sizeof b ## _prefix; \
3810 : indatalen -= sizeof b ## _prefix; \
3811 : }
3812 :
3813 0 : if (indatalen == 20)
3814 : ; /* Assume a plain SHA-1 or RMD160 digest has been given. */
3815 0 : else X(SHA1, sha1, 20, 1)
3816 0 : else X(RMD160, rmd160, 20, 1)
3817 0 : else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3818 0 : else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3819 0 : else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3820 0 : else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3821 0 : else if ((indatalen == 28 || indatalen == 32
3822 0 : || indatalen == 48 || indatalen ==64)
3823 0 : && app->app_local->extcap.is_v2)
3824 : ; /* Assume a plain SHA-3 digest has been given. */
3825 : else
3826 : {
3827 0 : log_error (_("card does not support digest algorithm %s\n"),
3828 : gcry_md_algo_name (hashalgo));
3829 : /* Or the supplied digest length does not match an algorithm. */
3830 0 : return gpg_error (GPG_ERR_INV_VALUE);
3831 : }
3832 : #undef X
3833 :
3834 : /* Check whether an OpenPGP card of any version has been requested. */
3835 0 : if (!strcmp (keyidstr, "OPENPGP.1"))
3836 : ;
3837 0 : else if (!strcmp (keyidstr, "OPENPGP.3"))
3838 0 : use_auth = 1;
3839 0 : else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3840 0 : return gpg_error (GPG_ERR_INV_ID);
3841 : else
3842 : {
3843 0 : for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3844 : ;
3845 0 : if (n != 32)
3846 0 : return gpg_error (GPG_ERR_INV_ID);
3847 0 : else if (!*s)
3848 : ; /* no fingerprint given: we allow this for now. */
3849 0 : else if (*s == '/')
3850 0 : fpr = s + 1;
3851 : else
3852 0 : return gpg_error (GPG_ERR_INV_ID);
3853 :
3854 0 : for (s=keyidstr, n=0; n < 16; s += 2, n++)
3855 0 : tmp_sn[n] = xtoi_2 (s);
3856 :
3857 0 : if (app->serialnolen != 16)
3858 0 : return gpg_error (GPG_ERR_INV_CARD);
3859 0 : if (memcmp (app->serialno, tmp_sn, 16))
3860 0 : return gpg_error (GPG_ERR_WRONG_CARD);
3861 : }
3862 :
3863 : /* If a fingerprint has been specified check it against the one on
3864 : the card. This is allows for a meaningful error message in case
3865 : the key on the card has been replaced but the shadow information
3866 : known to gpg was not updated. If there is no fingerprint, gpg
3867 : will detect a bogus signature anyway due to the
3868 : verify-after-signing feature. */
3869 0 : rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3870 0 : if (rc)
3871 0 : return rc;
3872 :
3873 : /* Concatenate prefix and digest. */
3874 : #define X(a,b,d) \
3875 : if (hashalgo == GCRY_MD_ ## a && (d) ) \
3876 : { \
3877 : datalen = sizeof b ## _prefix + indatalen; \
3878 : assert (datalen <= sizeof data); \
3879 : memcpy (data, b ## _prefix, sizeof b ## _prefix); \
3880 : memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3881 : }
3882 :
3883 0 : if (use_auth
3884 0 : || app->app_local->keyattr[use_auth? 2: 0].key_type == KEY_TYPE_RSA)
3885 : {
3886 0 : X(SHA1, sha1, 1)
3887 0 : else X(RMD160, rmd160, 1)
3888 0 : else X(SHA224, sha224, app->app_local->extcap.is_v2)
3889 0 : else X(SHA256, sha256, app->app_local->extcap.is_v2)
3890 0 : else X(SHA384, sha384, app->app_local->extcap.is_v2)
3891 0 : else X(SHA512, sha512, app->app_local->extcap.is_v2)
3892 : else
3893 0 : return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3894 : }
3895 : else
3896 : {
3897 0 : datalen = indatalen;
3898 0 : memcpy (data, indata, indatalen);
3899 : }
3900 : #undef X
3901 :
3902 : /* Redirect to the AUTH command if asked to. */
3903 0 : if (use_auth)
3904 : {
3905 0 : return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3906 : data, datalen,
3907 : outdata, outdatalen);
3908 : }
3909 :
3910 : /* Show the number of signature done using this key. */
3911 0 : sigcount = get_sig_counter (app);
3912 0 : log_info (_("signatures created so far: %lu\n"), sigcount);
3913 :
3914 : /* Check CHV if needed. */
3915 0 : if (!app->did_chv1 || app->force_chv1 )
3916 : {
3917 : char *pinvalue;
3918 :
3919 0 : rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3920 0 : if (rc)
3921 0 : return rc;
3922 :
3923 0 : app->did_chv1 = 1;
3924 :
3925 : /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3926 : sync, thus we verify CHV2 here using the given PIN. Cards
3927 : with version2 to not have the need for a separate CHV2 and
3928 : internally use just one. Obviously we can't do that if the
3929 : pinpad has been used. */
3930 0 : if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3931 : {
3932 0 : rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3933 0 : if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3934 0 : rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3935 0 : if (rc)
3936 : {
3937 0 : log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3938 0 : xfree (pinvalue);
3939 0 : flush_cache_after_error (app);
3940 0 : return rc;
3941 : }
3942 0 : app->did_chv2 = 1;
3943 : }
3944 0 : xfree (pinvalue);
3945 : }
3946 :
3947 :
3948 0 : if (app->app_local->cardcap.ext_lc_le)
3949 : {
3950 0 : exmode = 1; /* Use extended length. */
3951 0 : le_value = app->app_local->extcap.max_rsp_data;
3952 : }
3953 : else
3954 : {
3955 0 : exmode = 0;
3956 0 : le_value = 0;
3957 : }
3958 0 : rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
3959 : outdata, outdatalen);
3960 0 : return rc;
3961 : }
3962 :
3963 : /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3964 : on INDATA which is expected to be the raw message digest. For this
3965 : application the KEYIDSTR consists of the serialnumber and the
3966 : fingerprint delimited by a slash. Optionally the id OPENPGP.3 may
3967 : be given.
3968 :
3969 : Note that this function may return the error code
3970 : GPG_ERR_WRONG_CARD to indicate that the card currently present does
3971 : not match the one required for the requested action (e.g. the
3972 : serial number does not match). */
3973 : static gpg_error_t
3974 0 : do_auth (app_t app, const char *keyidstr,
3975 : gpg_error_t (*pincb)(void*, const char *, char **),
3976 : void *pincb_arg,
3977 : const void *indata, size_t indatalen,
3978 : unsigned char **outdata, size_t *outdatalen )
3979 : {
3980 : int rc;
3981 : unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3982 : const char *s;
3983 : int n;
3984 0 : const char *fpr = NULL;
3985 :
3986 0 : if (!keyidstr || !*keyidstr)
3987 0 : return gpg_error (GPG_ERR_INV_VALUE);
3988 0 : if (app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
3989 0 : && indatalen > 101) /* For a 2048 bit key. */
3990 0 : return gpg_error (GPG_ERR_INV_VALUE);
3991 :
3992 0 : if (app->app_local->keyattr[2].key_type == KEY_TYPE_ECC)
3993 : {
3994 0 : if (!app->app_local->keyattr[2].ecc.flags
3995 0 : && (indatalen == 51 || indatalen == 67 || indatalen == 83))
3996 0 : {
3997 0 : const char *p = (const char *)indata + 19;
3998 0 : indata = p;
3999 0 : indatalen -= 19;
4000 : }
4001 : else
4002 : {
4003 0 : const char *p = (const char *)indata + 15;
4004 0 : indata = p;
4005 0 : indatalen -= 15;
4006 : }
4007 : }
4008 :
4009 : /* Check whether an OpenPGP card of any version has been requested. */
4010 0 : if (!strcmp (keyidstr, "OPENPGP.3"))
4011 : ;
4012 0 : else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
4013 0 : return gpg_error (GPG_ERR_INV_ID);
4014 : else
4015 : {
4016 0 : for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4017 : ;
4018 0 : if (n != 32)
4019 0 : return gpg_error (GPG_ERR_INV_ID);
4020 0 : else if (!*s)
4021 : ; /* no fingerprint given: we allow this for now. */
4022 0 : else if (*s == '/')
4023 0 : fpr = s + 1;
4024 : else
4025 0 : return gpg_error (GPG_ERR_INV_ID);
4026 :
4027 0 : for (s=keyidstr, n=0; n < 16; s += 2, n++)
4028 0 : tmp_sn[n] = xtoi_2 (s);
4029 :
4030 0 : if (app->serialnolen != 16)
4031 0 : return gpg_error (GPG_ERR_INV_CARD);
4032 0 : if (memcmp (app->serialno, tmp_sn, 16))
4033 0 : return gpg_error (GPG_ERR_WRONG_CARD);
4034 : }
4035 :
4036 : /* If a fingerprint has been specified check it against the one on
4037 : the card. This is allows for a meaningful error message in case
4038 : the key on the card has been replaced but the shadow information
4039 : known to gpg was not updated. If there is no fingerprint, gpg
4040 : will detect a bogus signature anyway due to the
4041 : verify-after-signing feature. */
4042 0 : rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
4043 0 : if (rc)
4044 0 : return rc;
4045 :
4046 0 : rc = verify_chv2 (app, pincb, pincb_arg);
4047 0 : if (!rc)
4048 : {
4049 : int exmode, le_value;
4050 :
4051 0 : if (app->app_local->cardcap.ext_lc_le)
4052 : {
4053 0 : exmode = 1; /* Use extended length. */
4054 0 : le_value = app->app_local->extcap.max_rsp_data;
4055 : }
4056 : else
4057 : {
4058 0 : exmode = 0;
4059 0 : le_value = 0;
4060 : }
4061 0 : rc = iso7816_internal_authenticate (app->slot, exmode,
4062 : indata, indatalen, le_value,
4063 : outdata, outdatalen);
4064 : }
4065 0 : return rc;
4066 : }
4067 :
4068 :
4069 : static gpg_error_t
4070 0 : do_decipher (app_t app, const char *keyidstr,
4071 : gpg_error_t (*pincb)(void*, const char *, char **),
4072 : void *pincb_arg,
4073 : const void *indata, size_t indatalen,
4074 : unsigned char **outdata, size_t *outdatalen,
4075 : unsigned int *r_info)
4076 : {
4077 : int rc;
4078 : unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
4079 : const char *s;
4080 : int n;
4081 0 : const char *fpr = NULL;
4082 : int exmode, le_value;
4083 0 : unsigned char *fixbuf = NULL;
4084 0 : int padind = 0;
4085 0 : int fixuplen = 0;
4086 :
4087 0 : if (!keyidstr || !*keyidstr || !indatalen)
4088 0 : return gpg_error (GPG_ERR_INV_VALUE);
4089 :
4090 : /* Check whether an OpenPGP card of any version has been requested. */
4091 0 : if (!strcmp (keyidstr, "OPENPGP.2"))
4092 : ;
4093 0 : else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
4094 0 : return gpg_error (GPG_ERR_INV_ID);
4095 : else
4096 : {
4097 0 : for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4098 : ;
4099 0 : if (n != 32)
4100 0 : return gpg_error (GPG_ERR_INV_ID);
4101 0 : else if (!*s)
4102 : ; /* no fingerprint given: we allow this for now. */
4103 0 : else if (*s == '/')
4104 0 : fpr = s + 1;
4105 : else
4106 0 : return gpg_error (GPG_ERR_INV_ID);
4107 :
4108 0 : for (s=keyidstr, n=0; n < 16; s += 2, n++)
4109 0 : tmp_sn[n] = xtoi_2 (s);
4110 :
4111 0 : if (app->serialnolen != 16)
4112 0 : return gpg_error (GPG_ERR_INV_CARD);
4113 0 : if (memcmp (app->serialno, tmp_sn, 16))
4114 0 : return gpg_error (GPG_ERR_WRONG_CARD);
4115 : }
4116 :
4117 : /* If a fingerprint has been specified check it against the one on
4118 : the card. This is allows for a meaningful error message in case
4119 : the key on the card has been replaced but the shadow information
4120 : known to gpg was not updated. If there is no fingerprint, the
4121 : decryption won't produce the right plaintext anyway. */
4122 0 : rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
4123 0 : if (rc)
4124 0 : return rc;
4125 :
4126 0 : rc = verify_chv2 (app, pincb, pincb_arg);
4127 0 : if (rc)
4128 0 : return rc;
4129 :
4130 0 : if ((indatalen == 16 + 1 || indatalen == 32 + 1)
4131 0 : && ((char *)indata)[0] == 0x02)
4132 : {
4133 : /* PSO:DECIPHER with symmetric key. */
4134 0 : padind = -1;
4135 : }
4136 0 : else if (app->app_local->keyattr[1].key_type == KEY_TYPE_RSA)
4137 : {
4138 : /* We might encounter a couple of leading zeroes in the
4139 : cryptogram. Due to internal use of MPIs these leading zeroes
4140 : are stripped. However the OpenPGP card expects exactly 128
4141 : bytes for the cryptogram (for a 1k key). Thus we need to fix
4142 : it up. We do this for up to 16 leading zero bytes; a
4143 : cryptogram with more than this is with a very high
4144 : probability anyway broken. If a signed conversion was used
4145 : we may also encounter one leading zero followed by the correct
4146 : length. We fix that as well. */
4147 0 : if (indatalen >= (128-16) && indatalen < 128) /* 1024 bit key. */
4148 0 : fixuplen = 128 - indatalen;
4149 0 : else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key. */
4150 0 : fixuplen = 192 - indatalen;
4151 0 : else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key. */
4152 0 : fixuplen = 256 - indatalen;
4153 0 : else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key. */
4154 0 : fixuplen = 384 - indatalen;
4155 0 : else if (indatalen >= (512-16) && indatalen < 512) /* 4096 bit key. */
4156 0 : fixuplen = 512 - indatalen;
4157 0 : else if (!*(const char *)indata && (indatalen == 129
4158 0 : || indatalen == 193
4159 0 : || indatalen == 257
4160 0 : || indatalen == 385
4161 0 : || indatalen == 513))
4162 0 : fixuplen = -1;
4163 : else
4164 0 : fixuplen = 0;
4165 :
4166 0 : if (fixuplen > 0)
4167 : {
4168 : /* While we have to prepend stuff anyway, we can also
4169 : include the padding byte here so that iso1816_decipher
4170 : does not need to do another data mangling. */
4171 0 : fixuplen++;
4172 :
4173 0 : fixbuf = xtrymalloc (fixuplen + indatalen);
4174 0 : if (!fixbuf)
4175 0 : return gpg_error_from_syserror ();
4176 :
4177 0 : memset (fixbuf, 0, fixuplen);
4178 0 : memcpy (fixbuf+fixuplen, indata, indatalen);
4179 0 : indata = fixbuf;
4180 0 : indatalen = fixuplen + indatalen;
4181 0 : padind = -1; /* Already padded. */
4182 : }
4183 0 : else if (fixuplen < 0)
4184 : {
4185 : /* We use the extra leading zero as the padding byte. */
4186 0 : padind = -1;
4187 : }
4188 : }
4189 0 : else if (app->app_local->keyattr[1].key_type == KEY_TYPE_ECC)
4190 : {
4191 0 : int old_format_len = 0;
4192 :
4193 0 : if (app->app_local->keyattr[1].ecc.flags)
4194 : {
4195 0 : if (indatalen > 32 && (indatalen % 2))
4196 : { /*
4197 : * Skip the prefix. It may be 0x40 (in new format), or MPI
4198 : * head of 0x00 (in old format).
4199 : */
4200 0 : indata = (const char *)indata + 1;
4201 0 : indatalen--;
4202 : }
4203 0 : else if (indatalen < 32)
4204 : { /*
4205 : * Old format trancated by MPI handling.
4206 : */
4207 0 : old_format_len = indatalen;
4208 0 : indatalen = 32;
4209 : }
4210 : }
4211 :
4212 0 : fixuplen = 7;
4213 0 : fixbuf = xtrymalloc (fixuplen + indatalen);
4214 0 : if (!fixbuf)
4215 0 : return gpg_error_from_syserror ();
4216 :
4217 : /* Build 'Cipher DO' */
4218 0 : fixbuf[0] = '\xa6';
4219 0 : fixbuf[1] = (char)(indatalen+5);
4220 0 : fixbuf[2] = '\x7f';
4221 0 : fixbuf[3] = '\x49';
4222 0 : fixbuf[4] = (char)(indatalen+2);
4223 0 : fixbuf[5] = '\x86';
4224 0 : fixbuf[6] = (char)indatalen;
4225 0 : if (old_format_len)
4226 : {
4227 0 : memset (fixbuf+fixuplen, 0, 32 - old_format_len);
4228 0 : memcpy (fixbuf+fixuplen + 32 - old_format_len,
4229 : indata, old_format_len);
4230 : }
4231 : else
4232 : {
4233 0 : memcpy (fixbuf+fixuplen, indata, indatalen);
4234 : }
4235 0 : indata = fixbuf;
4236 0 : indatalen = fixuplen + indatalen;
4237 :
4238 0 : padind = -1;
4239 : }
4240 : else
4241 0 : return gpg_error (GPG_ERR_INV_VALUE);
4242 :
4243 0 : if (app->app_local->cardcap.ext_lc_le && indatalen > 254 )
4244 : {
4245 0 : exmode = 1; /* Extended length w/o a limit. */
4246 0 : le_value = app->app_local->extcap.max_rsp_data;
4247 : }
4248 0 : else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
4249 : {
4250 0 : exmode = -254; /* Command chaining with max. 254 bytes. */
4251 0 : le_value = 0;
4252 : }
4253 : else
4254 0 : exmode = le_value = 0;
4255 :
4256 0 : rc = iso7816_decipher (app->slot, exmode,
4257 : indata, indatalen, le_value, padind,
4258 : outdata, outdatalen);
4259 0 : xfree (fixbuf);
4260 0 : if (app->app_local->keyattr[1].key_type == KEY_TYPE_ECC
4261 0 : && app->app_local->keyattr[1].ecc.flags)
4262 : { /* Add the prefix 0x40 */
4263 0 : fixbuf = xtrymalloc (*outdatalen + 1);
4264 0 : if (!fixbuf)
4265 : {
4266 0 : xfree (*outdata);
4267 0 : return gpg_error_from_syserror ();
4268 : }
4269 0 : fixbuf[0] = 0x40;
4270 0 : memcpy (fixbuf+1, *outdata, *outdatalen);
4271 0 : xfree (*outdata);
4272 0 : *outdata = fixbuf;
4273 0 : *outdatalen = *outdatalen + 1;
4274 : }
4275 :
4276 0 : if (gpg_err_code (rc) == GPG_ERR_CARD /* actual SW is 0x640a */
4277 0 : && app->app_local->manufacturer == 5
4278 0 : && app->card_version == 0x0200)
4279 0 : log_info ("NOTE: Cards with manufacturer id 5 and s/n <= 346 (0x15a)"
4280 : " do not work with encryption keys > 2048 bits\n");
4281 :
4282 0 : *r_info |= APP_DECIPHER_INFO_NOPAD;
4283 :
4284 0 : return rc;
4285 : }
4286 :
4287 :
4288 : /* Perform a simple verify operation for CHV1 and CHV2, so that
4289 : further operations won't ask for CHV2 and it is possible to do a
4290 : cheap check on the PIN: If there is something wrong with the PIN
4291 : entry system, only the regular CHV will get blocked and not the
4292 : dangerous CHV3. KEYIDSTR is the usual card's serial number; an
4293 : optional fingerprint part will be ignored.
4294 :
4295 : There is a special mode if the keyidstr is "<serialno>[CHV3]" with
4296 : the "[CHV3]" being a literal string: The Admin Pin is checked if
4297 : and only if the retry counter is still at 3. */
4298 : static gpg_error_t
4299 0 : do_check_pin (app_t app, const char *keyidstr,
4300 : gpg_error_t (*pincb)(void*, const char *, char **),
4301 : void *pincb_arg)
4302 : {
4303 : unsigned char tmp_sn[20];
4304 : const char *s;
4305 : int n;
4306 0 : int admin_pin = 0;
4307 :
4308 0 : if (!keyidstr || !*keyidstr)
4309 0 : return gpg_error (GPG_ERR_INV_VALUE);
4310 :
4311 : /* Check whether an OpenPGP card of any version has been requested. */
4312 0 : if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
4313 0 : return gpg_error (GPG_ERR_INV_ID);
4314 :
4315 0 : for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4316 : ;
4317 0 : if (n != 32)
4318 0 : return gpg_error (GPG_ERR_INV_ID);
4319 0 : else if (!*s)
4320 : ; /* No fingerprint given: we allow this for now. */
4321 0 : else if (*s == '/')
4322 : ; /* We ignore a fingerprint. */
4323 0 : else if (!strcmp (s, "[CHV3]") )
4324 0 : admin_pin = 1;
4325 : else
4326 0 : return gpg_error (GPG_ERR_INV_ID);
4327 :
4328 0 : for (s=keyidstr, n=0; n < 16; s += 2, n++)
4329 0 : tmp_sn[n] = xtoi_2 (s);
4330 :
4331 0 : if (app->serialnolen != 16)
4332 0 : return gpg_error (GPG_ERR_INV_CARD);
4333 0 : if (memcmp (app->serialno, tmp_sn, 16))
4334 0 : return gpg_error (GPG_ERR_WRONG_CARD);
4335 :
4336 : /* Yes, there is a race conditions: The user might pull the card
4337 : right here and we won't notice that. However this is not a
4338 : problem and the check above is merely for a graceful failure
4339 : between operations. */
4340 :
4341 0 : if (admin_pin)
4342 : {
4343 : void *relptr;
4344 : unsigned char *value;
4345 : size_t valuelen;
4346 : int count;
4347 :
4348 0 : relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
4349 0 : if (!relptr || valuelen < 7)
4350 : {
4351 0 : log_error (_("error retrieving CHV status from card\n"));
4352 0 : xfree (relptr);
4353 0 : return gpg_error (GPG_ERR_CARD);
4354 : }
4355 0 : count = value[6];
4356 0 : xfree (relptr);
4357 :
4358 0 : if (!count)
4359 : {
4360 0 : log_info (_("card is permanently locked!\n"));
4361 0 : return gpg_error (GPG_ERR_BAD_PIN);
4362 : }
4363 0 : else if (count < 3)
4364 : {
4365 0 : log_info (_("verification of Admin PIN is currently prohibited "
4366 : "through this command\n"));
4367 0 : return gpg_error (GPG_ERR_GENERAL);
4368 : }
4369 :
4370 0 : app->did_chv3 = 0; /* Force verification. */
4371 0 : return verify_chv3 (app, pincb, pincb_arg);
4372 : }
4373 : else
4374 0 : return verify_chv2 (app, pincb, pincb_arg);
4375 : }
4376 :
4377 :
4378 : /* Show information about card capabilities. */
4379 : static void
4380 0 : show_caps (struct app_local_s *s)
4381 : {
4382 0 : log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
4383 0 : log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
4384 0 : if (s->extcap.get_challenge)
4385 0 : log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
4386 0 : log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
4387 0 : log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
4388 0 : log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
4389 0 : log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
4390 0 : log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
4391 0 : if (s->extcap.sm_supported)
4392 0 : log_printf (" (%s)", s->extcap.sm_algo==2? "3DES":
4393 0 : (s->extcap.sm_algo==2? "AES-128" : "AES-256"));
4394 0 : log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
4395 0 : log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
4396 0 : log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
4397 0 : log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
4398 0 : log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
4399 0 : log_info ("Status Indicator: %02X\n", s->status_indicator);
4400 0 : log_info ("Symmetric crypto: %s\n", s->extcap.has_decrypt? "yes":"no");
4401 0 : log_info ("Button..........: %s\n", s->extcap.has_button? "yes":"no");
4402 :
4403 0 : log_info ("GnuPG-No-Sync ..: %s\n", s->flags.no_sync? "yes":"no");
4404 0 : log_info ("GnuPG-Def-PW2 ..: %s\n", s->flags.def_chv2? "yes":"no");
4405 0 : }
4406 :
4407 :
4408 : /* Parse the historical bytes in BUFFER of BUFLEN and store them in
4409 : APPLOC. */
4410 : static void
4411 0 : parse_historical (struct app_local_s *apploc,
4412 : const unsigned char * buffer, size_t buflen)
4413 : {
4414 : /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00 */
4415 0 : if (buflen < 4)
4416 : {
4417 0 : log_error ("warning: historical bytes are too short\n");
4418 0 : return; /* Too short. */
4419 : }
4420 0 : if (*buffer)
4421 : {
4422 0 : log_error ("warning: bad category indicator in historical bytes\n");
4423 0 : return;
4424 : }
4425 :
4426 : /* Skip category indicator. */
4427 0 : buffer++;
4428 0 : buflen--;
4429 :
4430 : /* Get the status indicator. */
4431 0 : apploc->status_indicator = buffer[buflen-3];
4432 0 : buflen -= 3;
4433 :
4434 : /* Parse the compact TLV. */
4435 0 : while (buflen)
4436 : {
4437 0 : unsigned int tag = (*buffer & 0xf0) >> 4;
4438 0 : unsigned int len = (*buffer & 0x0f);
4439 0 : if (len+1 > buflen)
4440 : {
4441 0 : log_error ("warning: bad Compact-TLV in historical bytes\n");
4442 0 : return; /* Error. */
4443 : }
4444 0 : buffer++;
4445 0 : buflen--;
4446 0 : if (tag == 7 && len == 3)
4447 : {
4448 : /* Card capabilities. */
4449 0 : apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
4450 0 : apploc->cardcap.ext_lc_le = !!(buffer[2] & 0x40);
4451 : }
4452 0 : buffer += len;
4453 0 : buflen -= len;
4454 : }
4455 : }
4456 :
4457 :
4458 : /*
4459 : * Check if the OID in an DER encoding is available by GnuPG/libgcrypt,
4460 : * and return the constant string in dotted decimal form.
4461 : * Return NULL if not available.
4462 : * The constant string is not allocated dynamically, never free it.
4463 : */
4464 : static const char *
4465 0 : ecc_oid (unsigned char *buf, size_t buflen)
4466 : {
4467 : gcry_mpi_t oid;
4468 : char *oidstr;
4469 : const char *result;
4470 : unsigned char *oidbuf;
4471 :
4472 0 : oidbuf = xtrymalloc (buflen + 1);
4473 0 : if (!oidbuf)
4474 0 : return NULL;
4475 :
4476 0 : memcpy (oidbuf+1, buf, buflen);
4477 0 : oidbuf[0] = buflen;
4478 0 : oid = gcry_mpi_set_opaque (NULL, oidbuf, (buflen+1) * 8);
4479 0 : if (!oid)
4480 : {
4481 0 : xfree (oidbuf);
4482 0 : return NULL;
4483 : }
4484 :
4485 0 : oidstr = openpgp_oid_to_str (oid);
4486 0 : gcry_mpi_release (oid);
4487 0 : if (!oidstr)
4488 0 : return NULL;
4489 :
4490 0 : result = openpgp_curve_to_oid (oidstr, NULL);
4491 0 : xfree (oidstr);
4492 0 : return result;
4493 : }
4494 :
4495 :
4496 : /* Parse and optionally show the algorithm attributes for KEYNO.
4497 : KEYNO must be in the range 0..2. */
4498 : static void
4499 0 : parse_algorithm_attribute (app_t app, int keyno)
4500 : {
4501 : unsigned char *buffer;
4502 : size_t buflen;
4503 : void *relptr;
4504 0 : const char desc[3][5] = {"sign", "encr", "auth"};
4505 :
4506 0 : assert (keyno >=0 && keyno <= 2);
4507 :
4508 0 : app->app_local->keyattr[keyno].key_type = KEY_TYPE_RSA;
4509 0 : app->app_local->keyattr[keyno].rsa.n_bits = 0;
4510 :
4511 0 : relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
4512 0 : if (!relptr)
4513 : {
4514 0 : log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
4515 0 : return;
4516 : }
4517 0 : if (buflen < 1)
4518 : {
4519 0 : log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
4520 0 : xfree (relptr);
4521 0 : return;
4522 : }
4523 :
4524 0 : if (opt.verbose)
4525 0 : log_info ("Key-Attr-%s ..: ", desc[keyno]);
4526 0 : if (*buffer == PUBKEY_ALGO_RSA && (buflen == 5 || buflen == 6))
4527 : {
4528 0 : app->app_local->keyattr[keyno].rsa.n_bits = (buffer[1]<<8 | buffer[2]);
4529 0 : app->app_local->keyattr[keyno].rsa.e_bits = (buffer[3]<<8 | buffer[4]);
4530 0 : app->app_local->keyattr[keyno].rsa.format = 0;
4531 0 : if (buflen < 6)
4532 0 : app->app_local->keyattr[keyno].rsa.format = RSA_STD;
4533 : else
4534 0 : app->app_local->keyattr[keyno].rsa.format = (buffer[5] == 0? RSA_STD :
4535 0 : buffer[5] == 1? RSA_STD_N :
4536 0 : buffer[5] == 2? RSA_CRT :
4537 0 : buffer[5] == 3? RSA_CRT_N :
4538 : RSA_UNKNOWN_FMT);
4539 :
4540 0 : if (opt.verbose)
4541 0 : log_printf
4542 : ("RSA, n=%u, e=%u, fmt=%s\n",
4543 0 : app->app_local->keyattr[keyno].rsa.n_bits,
4544 0 : app->app_local->keyattr[keyno].rsa.e_bits,
4545 0 : app->app_local->keyattr[keyno].rsa.format == RSA_STD? "std" :
4546 0 : app->app_local->keyattr[keyno].rsa.format == RSA_STD_N?"std+n":
4547 0 : app->app_local->keyattr[keyno].rsa.format == RSA_CRT? "crt" :
4548 0 : app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N?"crt+n":"?");
4549 : }
4550 0 : else if (*buffer == PUBKEY_ALGO_ECDH || *buffer == PUBKEY_ALGO_ECDSA
4551 0 : || *buffer == PUBKEY_ALGO_EDDSA)
4552 0 : {
4553 0 : const char *oid = ecc_oid (buffer + 1, buflen - 1);
4554 :
4555 0 : if (!oid)
4556 0 : log_printhex ("Curve with OID not supported: ", buffer+1, buflen-1);
4557 : else
4558 : {
4559 0 : app->app_local->keyattr[keyno].key_type = KEY_TYPE_ECC;
4560 0 : app->app_local->keyattr[keyno].ecc.oid = oid;
4561 0 : if (*buffer == PUBKEY_ALGO_EDDSA
4562 0 : || (*buffer == PUBKEY_ALGO_ECDH
4563 0 : && !strcmp (app->app_local->keyattr[keyno].ecc.oid,
4564 : "1.3.6.1.4.1.3029.1.5.1")))
4565 0 : app->app_local->keyattr[keyno].ecc.flags = ECC_FLAG_DJB_TWEAK;
4566 : else
4567 0 : app->app_local->keyattr[keyno].ecc.flags = 0;
4568 0 : if (opt.verbose)
4569 0 : log_printf
4570 0 : ("ECC, curve=%s%s\n", app->app_local->keyattr[keyno].ecc.oid,
4571 0 : !app->app_local->keyattr[keyno].ecc.flags ? "":
4572 0 : keyno==1? " (djb-tweak)": " (eddsa)");
4573 : }
4574 : }
4575 0 : else if (opt.verbose)
4576 0 : log_printhex ("", buffer, buflen);
4577 :
4578 0 : xfree (relptr);
4579 : }
4580 :
4581 : /* Select the OpenPGP application on the card in SLOT. This function
4582 : must be used before any other OpenPGP application functions. */
4583 : gpg_error_t
4584 0 : app_select_openpgp (app_t app)
4585 : {
4586 : static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
4587 0 : int slot = app->slot;
4588 : int rc;
4589 : unsigned char *buffer;
4590 : size_t buflen;
4591 : void *relptr;
4592 :
4593 : /* Note that the card can't cope with P2=0xCO, thus we need to pass a
4594 : special flag value. */
4595 0 : rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
4596 0 : if (!rc)
4597 : {
4598 : unsigned int manufacturer;
4599 :
4600 0 : app->apptype = "OPENPGP";
4601 :
4602 0 : app->did_chv1 = 0;
4603 0 : app->did_chv2 = 0;
4604 0 : app->did_chv3 = 0;
4605 0 : app->app_local = NULL;
4606 :
4607 : /* The OpenPGP card returns the serial number as part of the
4608 : AID; because we prefer to use OpenPGP serial numbers, we
4609 : replace a possibly already set one from a EF.GDO with this
4610 : one. Note, that for current OpenPGP cards, no EF.GDO exists
4611 : and thus it won't matter at all. */
4612 0 : rc = iso7816_get_data (slot, 0, 0x004F, &buffer, &buflen);
4613 0 : if (rc)
4614 0 : goto leave;
4615 0 : if (opt.verbose)
4616 : {
4617 0 : log_info ("AID: ");
4618 0 : log_printhex ("", buffer, buflen);
4619 : }
4620 :
4621 0 : app->card_version = buffer[6] << 8;
4622 0 : app->card_version |= buffer[7];
4623 0 : manufacturer = (buffer[8]<<8 | buffer[9]);
4624 :
4625 0 : xfree (app->serialno);
4626 0 : app->serialno = buffer;
4627 0 : app->serialnolen = buflen;
4628 0 : buffer = NULL;
4629 0 : app->app_local = xtrycalloc (1, sizeof *app->app_local);
4630 0 : if (!app->app_local)
4631 : {
4632 0 : rc = gpg_error (gpg_err_code_from_errno (errno));
4633 0 : goto leave;
4634 : }
4635 :
4636 0 : app->app_local->manufacturer = manufacturer;
4637 :
4638 0 : if (app->card_version >= 0x0200)
4639 0 : app->app_local->extcap.is_v2 = 1;
4640 :
4641 :
4642 : /* Read the historical bytes. */
4643 0 : relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
4644 0 : if (relptr)
4645 : {
4646 0 : if (opt.verbose)
4647 : {
4648 0 : log_info ("Historical Bytes: ");
4649 0 : log_printhex ("", buffer, buflen);
4650 : }
4651 0 : parse_historical (app->app_local, buffer, buflen);
4652 0 : xfree (relptr);
4653 : }
4654 :
4655 : /* Read the force-chv1 flag. */
4656 0 : relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
4657 0 : if (!relptr)
4658 : {
4659 0 : log_error (_("can't access %s - invalid OpenPGP card?\n"),
4660 : "CHV Status Bytes");
4661 0 : goto leave;
4662 : }
4663 0 : app->force_chv1 = (buflen && *buffer == 0);
4664 0 : xfree (relptr);
4665 :
4666 : /* Read the extended capabilities. */
4667 0 : relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
4668 0 : if (!relptr)
4669 : {
4670 0 : log_error (_("can't access %s - invalid OpenPGP card?\n"),
4671 : "Extended Capability Flags" );
4672 0 : goto leave;
4673 : }
4674 0 : if (buflen)
4675 : {
4676 0 : app->app_local->extcap.sm_supported = !!(*buffer & 0x80);
4677 0 : app->app_local->extcap.get_challenge = !!(*buffer & 0x40);
4678 0 : app->app_local->extcap.key_import = !!(*buffer & 0x20);
4679 0 : app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
4680 0 : app->app_local->extcap.private_dos = !!(*buffer & 0x08);
4681 0 : app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
4682 0 : app->app_local->extcap.has_decrypt = !!(*buffer & 0x02);
4683 : }
4684 0 : if (buflen >= 10)
4685 : {
4686 : /* Available with v2 cards. */
4687 0 : app->app_local->extcap.sm_algo = buffer[1];
4688 0 : app->app_local->extcap.max_get_challenge
4689 0 : = (buffer[2] << 8 | buffer[3]);
4690 0 : app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
4691 0 : app->app_local->extcap.max_cmd_data = (buffer[6] << 8 | buffer[7]);
4692 0 : app->app_local->extcap.max_rsp_data = (buffer[8] << 8 | buffer[9]);
4693 : }
4694 0 : xfree (relptr);
4695 :
4696 : /* Some of the first cards accidentally don't set the
4697 : CHANGE_FORCE_CHV bit but allow it anyway. */
4698 0 : if (app->card_version <= 0x0100 && manufacturer == 1)
4699 0 : app->app_local->extcap.change_force_chv = 1;
4700 :
4701 : /* Check optional DO of "General Feature Management" for button. */
4702 0 : relptr = get_one_do (app, 0x7f74, &buffer, &buflen, NULL);
4703 0 : if (relptr)
4704 : /* It must be: 03 81 01 20 */
4705 0 : app->app_local->extcap.has_button = 1;
4706 :
4707 0 : parse_login_data (app);
4708 :
4709 0 : if (opt.verbose)
4710 0 : show_caps (app->app_local);
4711 :
4712 0 : parse_algorithm_attribute (app, 0);
4713 0 : parse_algorithm_attribute (app, 1);
4714 0 : parse_algorithm_attribute (app, 2);
4715 :
4716 0 : if (opt.verbose > 1)
4717 0 : dump_all_do (slot);
4718 :
4719 0 : app->fnc.deinit = do_deinit;
4720 0 : app->fnc.learn_status = do_learn_status;
4721 0 : app->fnc.readcert = do_readcert;
4722 0 : app->fnc.readkey = do_readkey;
4723 0 : app->fnc.getattr = do_getattr;
4724 0 : app->fnc.setattr = do_setattr;
4725 0 : app->fnc.writecert = do_writecert;
4726 0 : app->fnc.writekey = do_writekey;
4727 0 : app->fnc.genkey = do_genkey;
4728 0 : app->fnc.sign = do_sign;
4729 0 : app->fnc.auth = do_auth;
4730 0 : app->fnc.decipher = do_decipher;
4731 0 : app->fnc.change_pin = do_change_pin;
4732 0 : app->fnc.check_pin = do_check_pin;
4733 : }
4734 :
4735 : leave:
4736 0 : if (rc)
4737 0 : do_deinit (app);
4738 0 : return rc;
4739 : }
|
