* protect-tool.c: New option --canonical.
[gnupg.git] / scd / app.c
1 /* app.c - Application selection.
2  *      Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 # include <pth.h>
27
28 #include "scdaemon.h"
29 #include "app-common.h"
30 #include "apdu.h"
31 #include "iso7816.h"
32 #include "tlv.h"
33
34 /* This table is used to keep track of locks on a per reader base.
35    The index into the table is the slot number of the reader.  The
36    mutex will be initialized on demand (one of the advantages of a
37    userland threading system). */
38 static struct
39 {
40   int initialized;
41   pth_mutex_t lock;
42 } lock_table[10];
43
44
45 /* Lock the reader associated with the APP context.  This function
46    shall be used right before calling any of the actual application
47    functions to serialize access to the reader.  We do this always
48    even if the reader is not actually used.  This allows an actual
49    application to assume that it never shares a reader (while
50    performing one command).  Returns 0 on success; only then the
51    unlock_reader function must be called after returning from the
52    handler. */
53 static gpg_error_t 
54 lock_reader (app_t app)
55 {
56   gpg_error_t err;
57   int slot = app->slot;
58
59   if (slot < 0 || slot >= DIM (lock_table))
60     return gpg_error (app->slot<0? GPG_ERR_INV_VALUE : GPG_ERR_RESOURCE_LIMIT);
61
62   if (!lock_table[slot].initialized)
63     {
64       if (!pth_mutex_init (&lock_table[slot].lock))
65         {
66           err = gpg_error_from_errno (errno);
67           log_error ("error initializing mutex: %s\n", strerror (errno));
68           return err;
69         }
70       lock_table[slot].initialized = 1;
71     }
72   
73   if (!pth_mutex_acquire (&lock_table[slot].lock, 0, NULL))
74     {
75       err = gpg_error_from_errno (errno);
76       log_error ("failed to acquire APP lock for slot %d: %s\n",
77                  slot, strerror (errno));
78       return err;
79     }
80
81   return 0;
82 }
83
84 /* Release a lock on the reader.  See lock_reader(). */
85 static void
86 unlock_reader (app_t app)
87 {
88   int slot = app->slot;
89
90   if (slot < 0 || slot >= DIM (lock_table)
91       || !lock_table[slot].initialized)
92     log_bug ("unlock_reader called for invalid slot %d\n", slot);
93
94   if (!pth_mutex_release (&lock_table[slot].lock))
95     log_error ("failed to release APP lock for slot %d: %s\n",
96                slot, strerror (errno));
97
98 }
99  
100 /* Check wether the application NAME is allowed.  This does not mean
101    we have support for it though.  */
102 static int
103 is_app_allowed (const char *name)
104 {
105   strlist_t l;
106
107   for (l=opt.disabled_applications; l; l = l->next)
108     if (!strcmp (l->d, name))
109       return 0; /* no */
110   return 1; /* yes */
111 }
112
113
114 /* If called with NAME as NULL, select the best fitting application
115    and return a context; otherwise select the application with NAME
116    and return a context.  SLOT identifies the reader device. Returns
117    an error code and stores NULL at R_APP if no application was found
118    or no card is present. */
119 gpg_error_t
120 select_application (ctrl_t ctrl, int slot, const char *name, app_t *r_app)
121 {
122   gpg_error_t err;
123   app_t app;
124   unsigned char *result = NULL;
125   size_t resultlen;
126
127   *r_app = NULL;
128   app = xtrycalloc (1, sizeof *app);
129   if (!app)
130     {
131       err = gpg_error_from_errno (errno);
132       log_info ("error allocating context: %s\n", gpg_strerror (err));
133       return err;
134     }
135   app->slot = slot;
136
137   err = lock_reader (app);
138   if (err)
139     return err;
140
141   /* Fixme: We should now first check whether a card is at all
142      present. */
143
144   /* Try to read the GDO file first to get a default serial number. */
145   err = iso7816_select_file (slot, 0x3F00, 1, NULL, NULL);
146   if (!err)
147     err = iso7816_select_file (slot, 0x2F02, 0, NULL, NULL);
148   if (!err)
149      err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
150   if (!err)
151     {
152       size_t n;
153       const unsigned char *p;
154
155       p = find_tlv_unchecked (result, resultlen, 0x5A, &n);
156       if (p)
157         resultlen -= (p-result);
158       if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
159         {
160           /* The object it does not fit into the buffer.  This is an
161              invalid encoding (or the buffer is too short.  However, I
162              have some test cards with such an invalid encoding and
163              therefore I use this ugly workaround to return something
164              I can further experiment with. */
165           log_debug ("enabling BMI testcard workaround\n");
166           n--;
167         }
168
169       if (p && n <= resultlen)
170         {
171           /* The GDO file is pretty short, thus we simply reuse it for
172              storing the serial number. */
173           memmove (result, p, n);
174           app->serialno = result;
175           app->serialnolen = n;
176           err = app_munge_serialno (app);
177           if (err)
178             goto leave;
179         }
180       else
181         xfree (result);
182       result = NULL;
183     }
184
185   /* For certain error codes, there is no need to try more.  */
186   if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT)
187     goto leave;
188   
189
190   /* Figure out the application to use.  */
191   err = gpg_error (GPG_ERR_NOT_FOUND);
192
193   if (err && is_app_allowed ("openpgp")
194           && (!name || !strcmp (name, "openpgp")))
195     err = app_select_openpgp (app);
196   if (err && is_app_allowed ("nks") && (!name || !strcmp (name, "nks")))
197     err = app_select_nks (app);
198   if (err && is_app_allowed ("p15") && (!name || !strcmp (name, "p15")))
199     err = app_select_p15 (app);
200   if (err && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
201     err = app_select_dinsig (app);
202   if (err && name)
203     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
204
205  leave:
206   if (err)
207     {
208       if (name)
209         log_info ("can't select application `%s': %s\n",
210                   name, gpg_strerror (err));
211       else
212         log_info ("no supported card application found: %s\n",
213                   gpg_strerror (err));
214       xfree (app);
215       return err;
216     }
217
218   app->initialized = 1;
219   unlock_reader (app);
220   *r_app = app;
221   return 0;
222 }
223
224
225 void
226 release_application (app_t app)
227 {
228   if (!app)
229     return;
230
231   if (app->fnc.deinit)
232     {
233       app->fnc.deinit (app);
234       app->fnc.deinit = NULL;
235     }
236
237   xfree (app->serialno);
238   xfree (app);
239 }
240
241
242
243 /* The serial number may need some cosmetics.  Do it here.  This
244    function shall only be called once after a new serial number has
245    been put into APP->serialno. 
246
247    Prefixes we use:
248    
249      FF 00 00 = For serial numbers starting with an FF
250      FF 01 00 = Some german p15 cards return an empty serial number so the
251                 serial number from the EF(TokenInfo) is used instead.
252      
253      All other serial number not starting with FF are used as they are.
254 */
255 gpg_error_t
256 app_munge_serialno (app_t app)
257 {
258   if (app->serialnolen && app->serialno[0] == 0xff)
259     { 
260       /* The serial number starts with our special prefix.  This
261          requires that we put our default prefix "FF0000" in front. */
262       unsigned char *p = xtrymalloc (app->serialnolen + 3);
263       if (!p)
264         return gpg_error (gpg_err_code_from_errno (errno));
265       memcpy (p, "\xff\0", 3);
266       memcpy (p+3, app->serialno, app->serialnolen);
267       app->serialnolen += 3;
268       xfree (app->serialno);
269       app->serialno = p;
270     }
271   return 0;
272 }
273
274
275
276 /* Retrieve the serial number and the time of the last update of the
277    card.  The serial number is returned as a malloced string (hex
278    encoded) in SERIAL and the time of update is returned in STAMP.  If
279    no update time is available the returned value is 0.  Caller must
280    free SERIAL unless the function returns an error.  If STAMP is not
281    of interest, NULL may be passed. */
282 gpg_error_t 
283 app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
284 {
285   unsigned char *buf, *p;
286   int i;
287
288   if (!app || !serial)
289     return gpg_error (GPG_ERR_INV_VALUE);
290
291   *serial = NULL;
292   if (stamp)
293     *stamp = 0; /* not available */
294
295   buf = xtrymalloc (app->serialnolen * 2 + 1);
296   if (!buf)
297     return gpg_error_from_errno (errno);
298   for (p=buf, i=0; i < app->serialnolen; p +=2, i++)
299     sprintf (p, "%02X", app->serialno[i]);
300   *p = 0;
301   *serial = buf;
302   return 0;
303 }
304
305
306 /* Write out the application specifig status lines for the LEARN
307    command. */
308 gpg_error_t
309 app_write_learn_status (app_t app, CTRL ctrl)
310 {
311   gpg_error_t err;
312
313   if (!app)
314     return gpg_error (GPG_ERR_INV_VALUE);
315   if (!app->initialized)
316     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
317   if (!app->fnc.learn_status)
318     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
319
320   if (app->apptype)
321     send_status_info (ctrl, "APPTYPE",
322                       app->apptype, strlen (app->apptype), NULL, 0);
323   err = lock_reader (app);
324   if (err)
325     return err;
326   err = app->fnc.learn_status (app, ctrl);
327   unlock_reader (app);
328   return err;
329 }
330
331
332 /* Read the certificate with id CERTID (as returned by learn_status in
333    the CERTINFO status lines) and return it in the freshly allocated
334    buffer put into CERT and the length of the certificate put into
335    CERTLEN. */
336 gpg_error_t
337 app_readcert (app_t app, const char *certid,
338               unsigned char **cert, size_t *certlen)
339 {
340   gpg_error_t err;
341
342   if (!app)
343     return gpg_error (GPG_ERR_INV_VALUE);
344   if (!app->initialized)
345     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
346   if (!app->fnc.readcert)
347     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
348   err = lock_reader (app);
349   if (err)
350     return err;
351   err = app->fnc.readcert (app, certid, cert, certlen);
352   unlock_reader (app);
353   return err;
354 }
355
356
357 /* Read the key with ID KEYID.  On success a canonical encoded
358    S-expression with the public key will get stored at PK and its
359    length (for assertions) at PKLEN; the caller must release that
360    buffer. On error NULL will be stored at PK and PKLEN and an error
361    code returned.
362
363    This function might not be supported by all applications.  */
364 gpg_error_t
365 app_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
366 {
367   gpg_error_t err;
368
369   if (pk)
370     *pk = NULL;
371   if (pklen)
372     *pklen = 0;
373
374   if (!app || !keyid || !pk || !pklen)
375     return gpg_error (GPG_ERR_INV_VALUE);
376   if (!app->initialized)
377     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
378   if (!app->fnc.readkey)
379     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
380   err = lock_reader (app);
381   if (err)
382     return err;
383   err= app->fnc.readkey (app, keyid, pk, pklen);
384   unlock_reader (app);
385   return err;
386 }
387
388
389 /* Perform a GETATTR operation.  */
390 gpg_error_t 
391 app_getattr (app_t app, CTRL ctrl, const char *name)
392 {
393   gpg_error_t err;
394
395   if (!app || !name || !*name)
396     return gpg_error (GPG_ERR_INV_VALUE);
397   if (!app->initialized)
398     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
399
400   if (app->apptype && name && !strcmp (name, "APPTYPE"))
401     {
402       send_status_info (ctrl, "APPTYPE",
403                         app->apptype, strlen (app->apptype), NULL, 0);
404       return 0;
405     }
406   if (name && !strcmp (name, "SERIALNO"))
407     {
408       char *serial;
409       time_t stamp;
410       int rc;
411       
412       rc = app_get_serial_and_stamp (app, &serial, &stamp);
413       if (rc)
414         return rc;
415       send_status_info (ctrl, "SERIALNO", serial, strlen (serial), NULL, 0);
416       xfree (serial);
417       return 0;
418     }
419
420   if (!app->fnc.getattr)
421     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
422   err = lock_reader (app);
423   if (err)
424     return err;
425   err =  app->fnc.getattr (app, ctrl, name);
426   unlock_reader (app);
427   return err;
428 }
429
430 /* Perform a SETATTR operation.  */
431 gpg_error_t 
432 app_setattr (app_t app, const char *name,
433              gpg_error_t (*pincb)(void*, const char *, char **),
434              void *pincb_arg,
435              const unsigned char *value, size_t valuelen)
436 {
437   gpg_error_t err;
438
439   if (!app || !name || !*name || !value)
440     return gpg_error (GPG_ERR_INV_VALUE);
441   if (!app->initialized)
442     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
443   if (!app->fnc.setattr)
444     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
445   err = lock_reader (app);
446   if (err)
447     return err;
448   err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
449   unlock_reader (app);
450   return err;
451 }
452
453 /* Create the signature and return the allocated result in OUTDATA.
454    If a PIN is required the PINCB will be used to ask for the PIN; it
455    should return the PIN in an allocated buffer and put it into PIN.  */
456 gpg_error_t 
457 app_sign (app_t app, const char *keyidstr, int hashalgo,
458           gpg_error_t (*pincb)(void*, const char *, char **),
459           void *pincb_arg,
460           const void *indata, size_t indatalen,
461           unsigned char **outdata, size_t *outdatalen )
462 {
463   gpg_error_t err;
464
465   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
466     return gpg_error (GPG_ERR_INV_VALUE);
467   if (!app->initialized)
468     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
469   if (!app->fnc.sign)
470     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
471   err = lock_reader (app);
472   if (err)
473     return err;
474   err = app->fnc.sign (app, keyidstr, hashalgo,
475                        pincb, pincb_arg,
476                        indata, indatalen,
477                        outdata, outdatalen);
478   unlock_reader (app);
479   if (opt.verbose)
480     log_info ("operation sign result: %s\n", gpg_strerror (err));
481   return err;
482 }
483
484 /* Create the signature using the INTERNAL AUTHENTICATE command and
485    return the allocated result in OUTDATA.  If a PIN is required the
486    PINCB will be used to ask for the PIN; it should return the PIN in
487    an allocated buffer and put it into PIN.  */
488 gpg_error_t 
489 app_auth (app_t app, const char *keyidstr,
490           gpg_error_t (*pincb)(void*, const char *, char **),
491           void *pincb_arg,
492           const void *indata, size_t indatalen,
493           unsigned char **outdata, size_t *outdatalen )
494 {
495   gpg_error_t err;
496
497   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
498     return gpg_error (GPG_ERR_INV_VALUE);
499   if (!app->initialized)
500     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
501   if (!app->fnc.auth)
502     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
503   err = lock_reader (app);
504   if (err)
505     return err;
506   err = app->fnc.auth (app, keyidstr,
507                        pincb, pincb_arg,
508                        indata, indatalen,
509                        outdata, outdatalen);
510   unlock_reader (app);
511   if (opt.verbose)
512     log_info ("operation auth result: %s\n", gpg_strerror (err));
513   return err;
514 }
515
516
517 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
518    If a PIN is required the PINCB will be used to ask for the PIN; it
519    should return the PIN in an allocated buffer and put it into PIN.  */
520 gpg_error_t 
521 app_decipher (app_t app, const char *keyidstr,
522               gpg_error_t (*pincb)(void*, const char *, char **),
523               void *pincb_arg,
524               const void *indata, size_t indatalen,
525               unsigned char **outdata, size_t *outdatalen )
526 {
527   gpg_error_t err;
528
529   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
530     return gpg_error (GPG_ERR_INV_VALUE);
531   if (!app->initialized)
532     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
533   if (!app->fnc.decipher)
534     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
535   err = lock_reader (app);
536   if (err)
537     return err;
538   err = app->fnc.decipher (app, keyidstr,
539                            pincb, pincb_arg,
540                            indata, indatalen,
541                            outdata, outdatalen);
542   unlock_reader (app);
543   if (opt.verbose)
544     log_info ("operation decipher result: %s\n", gpg_strerror (err));
545   return err;
546 }
547
548
549 /* Perform the WRITEKEY operation.  */
550 gpg_error_t
551 app_writekey (app_t app, ctrl_t ctrl,
552               const char *keyidstr, unsigned int flags,
553               gpg_error_t (*pincb)(void*, const char *, char **),
554               void *pincb_arg,
555               const unsigned char *keydata, size_t keydatalen)
556 {
557   gpg_error_t err;
558
559   if (!app || !keyidstr || !*keyidstr || !pincb)
560     return gpg_error (GPG_ERR_INV_VALUE);
561   if (!app->initialized)
562     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
563   if (!app->fnc.writekey)
564     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
565   err = lock_reader (app);
566   if (err)
567     return err;
568   err = app->fnc.writekey (app, ctrl, keyidstr, flags,
569                            pincb, pincb_arg, keydata, keydatalen);
570   unlock_reader (app);
571   if (opt.verbose)
572     log_info ("operation writekey result: %s\n", gpg_strerror (err));
573   return err;
574
575 }
576
577
578 /* Perform a SETATTR operation.  */
579 gpg_error_t 
580 app_genkey (app_t app, CTRL ctrl, const char *keynostr, unsigned int flags,
581             gpg_error_t (*pincb)(void*, const char *, char **),
582             void *pincb_arg)
583 {
584   gpg_error_t err;
585
586   if (!app || !keynostr || !*keynostr || !pincb)
587     return gpg_error (GPG_ERR_INV_VALUE);
588   if (!app->initialized)
589     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
590   if (!app->fnc.genkey)
591     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
592   err = lock_reader (app);
593   if (err)
594     return err;
595   err = app->fnc.genkey (app, ctrl, keynostr, flags, pincb, pincb_arg);
596   unlock_reader (app);
597   if (opt.verbose)
598     log_info ("operation genkey result: %s\n", gpg_strerror (err));
599   return err;
600 }
601
602
603 /* Perform a GET CHALLENGE operation.  This fucntion is special as it
604    directly accesses the card without any application specific
605    wrapper. */
606 gpg_error_t
607 app_get_challenge (app_t app, size_t nbytes, unsigned char *buffer)
608 {
609   gpg_error_t err;
610
611   if (!app || !nbytes || !buffer)
612     return gpg_error (GPG_ERR_INV_VALUE);
613   if (!app->initialized)
614     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
615   err = lock_reader (app);
616   if (err)
617     return err;
618   err = iso7816_get_challenge (app->slot, nbytes, buffer);
619   unlock_reader (app);
620   return err;
621 }
622
623
624
625 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
626 gpg_error_t 
627 app_change_pin (app_t app, CTRL ctrl, const char *chvnostr, int reset_mode,
628                 gpg_error_t (*pincb)(void*, const char *, char **),
629                 void *pincb_arg)
630 {
631   gpg_error_t err;
632
633   if (!app || !chvnostr || !*chvnostr || !pincb)
634     return gpg_error (GPG_ERR_INV_VALUE);
635   if (!app->initialized)
636     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
637   if (!app->fnc.change_pin)
638     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
639   err = lock_reader (app);
640   if (err)
641     return err;
642   err = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode,
643                              pincb, pincb_arg);
644   unlock_reader (app);
645   if (opt.verbose)
646     log_info ("operation change_pin result: %s\n", gpg_strerror (err));
647   return err;
648 }
649
650
651 /* Perform a VERIFY operation without doing anything lese.  This may
652    be used to initialze a the PIN cache for long lasting other
653    operations.  Its use is highly application dependent. */
654 gpg_error_t 
655 app_check_pin (app_t app, const char *keyidstr,
656                gpg_error_t (*pincb)(void*, const char *, char **),
657                void *pincb_arg)
658 {
659   gpg_error_t err;
660
661   if (!app || !keyidstr || !*keyidstr || !pincb)
662     return gpg_error (GPG_ERR_INV_VALUE);
663   if (!app->initialized)
664     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
665   if (!app->fnc.check_pin)
666     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
667   err = lock_reader (app);
668   if (err)
669     return err;
670   err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
671   unlock_reader (app);
672   if (opt.verbose)
673     log_info ("operation check_pin result: %s\n", gpg_strerror (err));
674   return err;
675 }
676