fix up 6562de7475b21cd03c7b1a83a591fa563c589f5b
[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 3 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, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <npth.h>
26
27 #include "scdaemon.h"
28 #include "../common/exechelp.h"
29 #include "app-common.h"
30 #include "iso7816.h"
31 #include "apdu.h"
32 #include "../common/tlv.h"
33
34 static npth_mutex_t app_list_lock;
35 static app_t app_top;
36
37
38 /* The list of application names and there select function.  Of no
39  * specfic application is selected the first available application on
40  * a card is selected.  */
41 struct app_priority_list_s
42 {
43   char const *name;
44   gpg_error_t (*select_func)(app_t);
45 };
46
47 static struct app_priority_list_s app_priority_list[] =
48   {{ "openpgp",   app_select_openpgp   },
49    { "piv",       app_select_piv       },
50    { "nks",       app_select_nks       },
51    { "p15",       app_select_p15       },
52    { "geldkarte", app_select_geldkarte },
53    { "dinsig",    app_select_dinsig    },
54    { "sc-hsm",    app_select_sc_hsm    },
55    { NULL,        NULL                 }
56   };
57
58
59
60
61 \f
62 /* Initialization function to change the default app_priority_list.
63  * LIST is a list of comma or space separated strings with application
64  * names.  Unknown names will only result in warning message.
65  * Application not mentioned in LIST are used in their original order
66  * after the given once.  */
67 void
68 app_update_priority_list (const char *arg)
69 {
70   struct app_priority_list_s save;
71   char **names;
72   int i, j, idx;
73
74   names = strtokenize (arg, ", ");
75   if (!names)
76     log_fatal ("strtokenize failed: %s\n",
77                gpg_strerror (gpg_error_from_syserror ()));
78
79   idx = 0;
80   for (i=0; names[i]; i++)
81     {
82       ascii_strlwr (names[i]);
83       for (j=0; j < i; j++)
84         if (!strcmp (names[j], names[i]))
85           break;
86       if (j < i)
87         {
88           log_info ("warning: duplicate application '%s' in priority list\n",
89                     names[i]);
90           continue;
91         }
92
93       for (j=idx; app_priority_list[j].name; j++)
94         if (!strcmp (names[i], app_priority_list[j].name))
95           break;
96       if (!app_priority_list[j].name)
97         {
98           log_info ("warning: unknown application '%s' in priority list\n",
99                     names[i]);
100           continue;
101         }
102       save = app_priority_list[idx];
103       app_priority_list[idx] = app_priority_list[j];
104       app_priority_list[j] = save;
105       idx++;
106     }
107   log_assert (idx < DIM (app_priority_list));
108
109   xfree (names);
110   for (i=0; app_priority_list[i].name; i++)
111     log_info ("app priority %d: %s\n", i, app_priority_list[i].name);
112 }
113
114
115 static void
116 print_progress_line (void *opaque, const char *what, int pc, int cur, int tot)
117 {
118   ctrl_t ctrl = opaque;
119   char line[100];
120
121   if (ctrl)
122     {
123       snprintf (line, sizeof line, "%s %c %d %d", what, pc, cur, tot);
124       send_status_direct (ctrl, "PROGRESS", line);
125     }
126 }
127
128
129 /* Lock the reader SLOT.  This function shall be used right before
130    calling any of the actual application functions to serialize access
131    to the reader.  We do this always even if the reader is not
132    actually used.  This allows an actual connection to assume that it
133    never shares a reader (while performing one command).  Returns 0 on
134    success; only then the unlock_reader function must be called after
135    returning from the handler. */
136 static gpg_error_t
137 lock_app (app_t app, ctrl_t ctrl)
138 {
139   if (npth_mutex_lock (&app->lock))
140     {
141       gpg_error_t err = gpg_error_from_syserror ();
142       log_error ("failed to acquire APP lock for %p: %s\n",
143                  app, gpg_strerror (err));
144       return err;
145     }
146
147   apdu_set_progress_cb (app->slot, print_progress_line, ctrl);
148   apdu_set_prompt_cb (app->slot, popup_prompt, ctrl);
149
150   return 0;
151 }
152
153 /* Release a lock on the reader.  See lock_reader(). */
154 static void
155 unlock_app (app_t app)
156 {
157   apdu_set_progress_cb (app->slot, NULL, NULL);
158   apdu_set_prompt_cb (app->slot, NULL, NULL);
159
160   if (npth_mutex_unlock (&app->lock))
161     {
162       gpg_error_t err = gpg_error_from_syserror ();
163       log_error ("failed to release APP lock for %p: %s\n",
164                  app, gpg_strerror (err));
165     }
166 }
167
168
169 /* This function may be called to print information pertaining to the
170    current state of this module to the log. */
171 void
172 app_dump_state (void)
173 {
174   app_t a;
175
176   npth_mutex_lock (&app_list_lock);
177   for (a = app_top; a; a = a->next)
178     log_info ("app_dump_state: app=%p type='%s'\n", a, a->apptype);
179   npth_mutex_unlock (&app_list_lock);
180 }
181
182 /* Check whether the application NAME is allowed.  This does not mean
183    we have support for it though.  */
184 static int
185 is_app_allowed (const char *name)
186 {
187   strlist_t l;
188
189   for (l=opt.disabled_applications; l; l = l->next)
190     if (!strcmp (l->d, name))
191       return 0; /* no */
192   return 1; /* yes */
193 }
194
195
196 static gpg_error_t
197 check_conflict (app_t app, const char *name)
198 {
199   if (!app || !name || (app->apptype && !ascii_strcasecmp (app->apptype, name)))
200     return 0;
201
202   if (app->apptype && !strcmp (app->apptype, "UNDEFINED"))
203     return 0;
204
205   log_info ("application '%s' in use - can't switch\n",
206             app->apptype? app->apptype : "<null>");
207
208   return gpg_error (GPG_ERR_CONFLICT);
209 }
210
211 /* This function is used by the serialno command to check for an
212    application conflict which may appear if the serialno command is
213    used to request a specific application and the connection has
214    already done a select_application. */
215 gpg_error_t
216 check_application_conflict (const char *name, app_t app)
217 {
218   return check_conflict (app, name);
219 }
220
221
222 gpg_error_t
223 app_reset (app_t app, ctrl_t ctrl, int send_reset)
224 {
225   gpg_error_t err = 0;
226
227   if (send_reset)
228     {
229       int sw;
230
231       lock_app (app, ctrl);
232       sw = apdu_reset (app->slot);
233       if (sw)
234         err = gpg_error (GPG_ERR_CARD_RESET);
235
236       app->reset_requested = 1;
237       unlock_app (app);
238
239       scd_kick_the_loop ();
240       gnupg_sleep (1);
241     }
242   else
243     {
244       ctrl->app_ctx = NULL;
245       release_application (app, 0);
246     }
247
248   return err;
249 }
250
251 static gpg_error_t
252 app_new_register (int slot, ctrl_t ctrl, const char *name,
253                   int periodical_check_needed)
254 {
255   gpg_error_t err = 0;
256   app_t app = NULL;
257   unsigned char *result = NULL;
258   size_t resultlen;
259   int want_undefined;
260   int i;
261
262   /* Need to allocate a new one.  */
263   app = xtrycalloc (1, sizeof *app);
264   if (!app)
265     {
266       err = gpg_error_from_syserror ();
267       log_info ("error allocating context: %s\n", gpg_strerror (err));
268       return err;
269     }
270
271   app->slot = slot;
272   app->card_status = (unsigned int)-1;
273
274   if (npth_mutex_init (&app->lock, NULL))
275     {
276       err = gpg_error_from_syserror ();
277       log_error ("error initializing mutex: %s\n", gpg_strerror (err));
278       xfree (app);
279       return err;
280     }
281
282   err = lock_app (app, ctrl);
283   if (err)
284     {
285       xfree (app);
286       return err;
287     }
288
289   want_undefined = (name && !strcmp (name, "undefined"));
290
291   /* Try to read the GDO file first to get a default serial number.
292      We skip this if the undefined application has been requested. */
293   if (!want_undefined)
294     {
295       err = iso7816_select_file (slot, 0x3F00, 1);
296       if (gpg_err_code (err) == GPG_ERR_CARD)
297         {
298           /* Might be SW==0x7D00.  Let's test whether it is a Yubikey
299            * by selecting its manager application and then reading the
300            * config.  */
301           static char const yk_aid[] =
302             { 0xA0, 0x00, 0x00, 0x05, 0x27, 0x47, 0x11, 0x17 }; /*MGR*/
303           static char const otp_aid[] =
304             { 0xA0, 0x00, 0x00, 0x05, 0x27, 0x20, 0x01 }; /*OTP*/
305           unsigned char *buf;
306           size_t buflen;
307           const unsigned char *s0;
308           unsigned char formfactor;
309           size_t n;
310
311           if (!iso7816_select_application (slot, yk_aid, sizeof yk_aid,
312                                            0x0001)
313               && !iso7816_apdu_direct (slot, "\x00\x1d\x00\x00\x00", 5, 0,
314                                        NULL, &buf, &buflen))
315             {
316               app->cardtype = "yubikey";
317               if (opt.verbose)
318                 {
319                   log_info ("Yubico: config=");
320                   log_printhex (buf, buflen, "");
321                 }
322
323               /* We skip the first byte which seems to be the total
324                * length of the config data.  */
325               if (buflen > 1)
326                 {
327                   s0 = find_tlv (buf+1, buflen-1, 0x04, &n);  /* Form factor */
328                   formfactor = (s0 && n == 1)? *s0 : 0;
329
330                   s0 = find_tlv (buf+1, buflen-1, 0x02, &n);  /* Serial */
331                   if (s0 && n >= 4)
332                     {
333                       app->serialno = xtrymalloc (3 + 1 + n);
334                       if (app->serialno)
335                         {
336                           app->serialnolen = 3 + 1 + n;
337                           app->serialno[0] = 0xff;
338                           app->serialno[1] = 0x02;
339                           app->serialno[2] = 0x0;
340                           app->serialno[3] = formfactor;
341                           memcpy (app->serialno + 4, s0, n);
342                           /* Note that we do not clear the error
343                            * so that no further serial number
344                            * testing is done.  After all we just
345                            * set the serial number.  */
346                         }
347                     }
348
349                   s0 = find_tlv (buf+1, buflen-1, 0x05, &n);  /* version */
350                   if (s0 && n == 3)
351                     app->cardversion = ((s0[0]<<16)|(s0[1]<<8)|s0[2]);
352                   else if (!s0)
353                     {
354                       /* No version - this is not a Yubikey 5.  We now
355                        * switch to the OTP app and take the first
356                        * three bytes of the reponse as version
357                        * number.  */
358                       xfree (buf);
359                       buf = NULL;
360                       if (!iso7816_select_application_ext (slot,
361                                                        otp_aid, sizeof otp_aid,
362                                                        1, &buf, &buflen)
363                           && buflen > 3)
364                         app->cardversion = ((buf[0]<<16)|(buf[1]<<8)|buf[2]);
365                     }
366                 }
367               xfree (buf);
368             }
369         }
370
371       if (!err)
372         err = iso7816_select_file (slot, 0x2F02, 0);
373       if (!err)
374         err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
375       if (!err)
376         {
377           size_t n;
378           const unsigned char *p;
379
380           p = find_tlv_unchecked (result, resultlen, 0x5A, &n);
381           if (p)
382             resultlen -= (p-result);
383           if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
384             {
385               /* The object it does not fit into the buffer.  This is an
386                  invalid encoding (or the buffer is too short.  However, I
387                  have some test cards with such an invalid encoding and
388                  therefore I use this ugly workaround to return something
389                  I can further experiment with. */
390               log_info ("enabling BMI testcard workaround\n");
391               n--;
392             }
393
394           if (p && n <= resultlen)
395             {
396               /* The GDO file is pretty short, thus we simply reuse it for
397                  storing the serial number. */
398               memmove (result, p, n);
399               app->serialno = result;
400               app->serialnolen = n;
401               err = app_munge_serialno (app);
402               if (err)
403                 goto leave;
404             }
405           else
406             xfree (result);
407           result = NULL;
408         }
409     }
410
411   /* Figure out the application to use.  */
412   if (want_undefined)
413     {
414       /* We switch to the "undefined" application only if explicitly
415          requested.  */
416       app->apptype = "UNDEFINED";
417       /* Clear the error so that we don't run through the application
418        * selection chain.  */
419       err = 0;
420     }
421   else
422     {
423       /* For certain error codes, there is no need to try more.  */
424       if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT
425           || gpg_err_code (err) == GPG_ERR_ENODEV)
426         goto leave;
427
428       /* Set a default error so that we run through the application
429        * selection chain.  */
430       err = gpg_error (GPG_ERR_NOT_FOUND);
431     }
432
433   /* Find the first available app if NAME is NULL or the one matching
434    * NAME but only if that application is also enabled.  */
435   for (i=0; err && app_priority_list[i].name; i++)
436     {
437       if (is_app_allowed (app_priority_list[i].name)
438           && (!name || !strcmp (name, app_priority_list[i].name)))
439         err = app_priority_list[i].select_func (app);
440     }
441   if (err && name && gpg_err_code (err) != GPG_ERR_OBJ_TERM_STATE)
442     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
443
444  leave:
445   if (err)
446     {
447       if (name)
448         log_info ("can't select application '%s': %s\n",
449                   name, gpg_strerror (err));
450       else
451         log_info ("no supported card application found: %s\n",
452                   gpg_strerror (err));
453       unlock_app (app);
454       xfree (app);
455       return err;
456     }
457
458   app->periodical_check_needed = periodical_check_needed;
459   app->next = app_top;
460   app_top = app;
461   unlock_app (app);
462   return 0;
463 }
464
465 /* If called with NAME as NULL, select the best fitting application
466    and return a context; otherwise select the application with NAME
467    and return a context.  Returns an error code and stores NULL at
468    R_APP if no application was found or no card is present. */
469 gpg_error_t
470 select_application (ctrl_t ctrl, const char *name, app_t *r_app,
471                     int scan, const unsigned char *serialno_bin,
472                     size_t serialno_bin_len)
473 {
474   gpg_error_t err = 0;
475   app_t a, a_prev = NULL;
476
477   *r_app = NULL;
478
479   npth_mutex_lock (&app_list_lock);
480
481   if (scan || !app_top)
482     {
483       struct dev_list *l;
484       int new_app = 0;
485
486       /* Scan the devices to find new device(s).  */
487       err = apdu_dev_list_start (opt.reader_port, &l);
488       if (err)
489         {
490           npth_mutex_unlock (&app_list_lock);
491           return err;
492         }
493
494       while (1)
495         {
496           int slot;
497           int periodical_check_needed_this;
498
499           slot = apdu_open_reader (l, !app_top);
500           if (slot < 0)
501             break;
502
503           periodical_check_needed_this = apdu_connect (slot);
504           if (periodical_check_needed_this < 0)
505             {
506               /* We close a reader with no card.  */
507               err = gpg_error (GPG_ERR_ENODEV);
508             }
509           else
510             {
511               err = app_new_register (slot, ctrl, name,
512                                       periodical_check_needed_this);
513               new_app++;
514             }
515
516           if (err)
517             apdu_close_reader (slot);
518         }
519
520       apdu_dev_list_finish (l);
521
522       /* If new device(s), kick the scdaemon loop.  */
523       if (new_app)
524         scd_kick_the_loop ();
525     }
526
527   for (a = app_top; a; a = a->next)
528     {
529       lock_app (a, ctrl);
530       if (serialno_bin == NULL)
531         break;
532       if (a->serialnolen == serialno_bin_len
533           && !memcmp (a->serialno, serialno_bin, a->serialnolen))
534         break;
535       unlock_app (a);
536       a_prev = a;
537     }
538
539   if (a)
540     {
541       err = check_conflict (a, name);
542       if (!err)
543         {
544           a->ref_count++;
545           *r_app = a;
546           if (a_prev)
547             {
548               a_prev->next = a->next;
549               a->next = app_top;
550               app_top = a;
551             }
552       }
553       unlock_app (a);
554     }
555   else
556     err = gpg_error (GPG_ERR_ENODEV);
557
558   npth_mutex_unlock (&app_list_lock);
559
560   return err;
561 }
562
563
564 char *
565 get_supported_applications (void)
566 {
567   int idx;
568   size_t nbytes;
569   char *buffer, *p;
570   const char *s;
571
572   for (nbytes=1, idx=0; (s=app_priority_list[idx].name); idx++)
573     nbytes += strlen (s) + 1 + 1;
574
575   buffer = xtrymalloc (nbytes);
576   if (!buffer)
577     return NULL;
578
579   for (p=buffer, idx=0; (s=app_priority_list[idx].name); idx++)
580     if (is_app_allowed (s))
581       p = stpcpy (stpcpy (p, s), ":\n");
582   *p = 0;
583
584   return buffer;
585 }
586
587
588 /* Deallocate the application.  */
589 static void
590 deallocate_app (app_t app)
591 {
592   app_t a, a_prev = NULL;
593
594   for (a = app_top; a; a = a->next)
595     if (a == app)
596       {
597         if (a_prev == NULL)
598           app_top = a->next;
599         else
600           a_prev->next = a->next;
601         break;
602       }
603     else
604       a_prev = a;
605
606   if (app->ref_count)
607     log_error ("trying to release context used yet (%d)\n", app->ref_count);
608
609   if (app->fnc.deinit)
610     {
611       app->fnc.deinit (app);
612       app->fnc.deinit = NULL;
613     }
614
615   xfree (app->serialno);
616
617   unlock_app (app);
618   xfree (app);
619 }
620
621 /* Free the resources associated with the application APP.  APP is
622    allowed to be NULL in which case this is a no-op.  Note that we are
623    using reference counting to track the users of the application and
624    actually deferring the deallocation to allow for a later reuse by
625    a new connection. */
626 void
627 release_application (app_t app, int locked_already)
628 {
629   if (!app)
630     return;
631
632   /* We don't deallocate app here.  Instead, we keep it.  This is
633      useful so that a card does not get reset even if only one session
634      is using the card - this way the PIN cache and other cached data
635      are preserved.  */
636
637   if (!locked_already)
638     lock_app (app, NULL);
639
640   if (!app->ref_count)
641     log_bug ("trying to release an already released context\n");
642
643   --app->ref_count;
644   if (!locked_already)
645     unlock_app (app);
646 }
647
648
649
650 /* The serial number may need some cosmetics.  Do it here.  This
651    function shall only be called once after a new serial number has
652    been put into APP->serialno.
653
654    Prefixes we use:
655
656      FF 00 00 = For serial numbers starting with an FF
657      FF 01 00 = Some german p15 cards return an empty serial number so the
658                 serial number from the EF(TokenInfo) is used instead.
659      FF 02 00 = Serial number from Yubikey config
660      FF 7F 00 = No serialno.
661
662      All other serial number not starting with FF are used as they are.
663 */
664 gpg_error_t
665 app_munge_serialno (app_t app)
666 {
667   if (app->serialnolen && app->serialno[0] == 0xff)
668     {
669       /* The serial number starts with our special prefix.  This
670          requires that we put our default prefix "FF0000" in front. */
671       unsigned char *p = xtrymalloc (app->serialnolen + 3);
672       if (!p)
673         return gpg_error_from_syserror ();
674       memcpy (p, "\xff\0", 3);
675       memcpy (p+3, app->serialno, app->serialnolen);
676       app->serialnolen += 3;
677       xfree (app->serialno);
678       app->serialno = p;
679     }
680   else if (!app->serialnolen)
681     {
682       unsigned char *p = xtrymalloc (3);
683       if (!p)
684         return gpg_error_from_syserror ();
685       memcpy (p, "\xff\x7f", 3);
686       app->serialnolen = 3;
687       xfree (app->serialno);
688       app->serialno = p;
689     }
690   return 0;
691 }
692
693
694
695 /* Retrieve the serial number of the card.  The serial number is
696    returned as a malloced string (hex encoded) in SERIAL.  Caller must
697    free SERIAL unless the function returns an error.  */
698 char *
699 app_get_serialno (app_t app)
700 {
701   char *serial;
702
703   if (!app)
704     return NULL;
705
706   if (!app->serialnolen)
707     serial = xtrystrdup ("FF7F00");
708   else
709     serial = bin2hex (app->serialno, app->serialnolen, NULL);
710
711   return serial;
712 }
713
714
715 /* Write out the application specific status lines for the LEARN
716    command. */
717 gpg_error_t
718 app_write_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
719 {
720   gpg_error_t err;
721
722   if (!app)
723     return gpg_error (GPG_ERR_INV_VALUE);
724   if (!app->fnc.learn_status)
725     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
726
727   /* We do not send CARD and APPTYPE if only keypairinfo is requested.  */
728   if (!(flags &1))
729     {
730       if (app->cardtype)
731         send_status_direct (ctrl, "CARDTYPE", app->cardtype);
732       if (app->cardversion)
733         send_status_printf (ctrl, "CARDVERSION", "%X", app->cardversion);
734       if (app->apptype)
735         send_status_direct (ctrl, "APPTYPE", app->apptype);
736       if (app->appversion)
737         send_status_printf (ctrl, "APPVERSION", "%X", app->appversion);
738     }
739
740   err = lock_app (app, ctrl);
741   if (err)
742     return err;
743   err = app->fnc.learn_status (app, ctrl, flags);
744   unlock_app (app);
745   return err;
746 }
747
748
749 /* Read the certificate with id CERTID (as returned by learn_status in
750    the CERTINFO status lines) and return it in the freshly allocated
751    buffer put into CERT and the length of the certificate put into
752    CERTLEN. */
753 gpg_error_t
754 app_readcert (app_t app, ctrl_t ctrl, const char *certid,
755               unsigned char **cert, size_t *certlen)
756 {
757   gpg_error_t err;
758
759   if (!app)
760     return gpg_error (GPG_ERR_INV_VALUE);
761   if (!app->ref_count)
762     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
763   if (!app->fnc.readcert)
764     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
765   err = lock_app (app, ctrl);
766   if (err)
767     return err;
768   err = app->fnc.readcert (app, certid, cert, certlen);
769   unlock_app (app);
770   return err;
771 }
772
773
774 /* Read the key with ID KEYID.  On success a canonical encoded
775  * S-expression with the public key will get stored at PK and its
776  * length (for assertions) at PKLEN; the caller must release that
777  * buffer. On error NULL will be stored at PK and PKLEN and an error
778  * code returned.  If the key is not required NULL may be passed for
779  * PK; this makse send if the APP_READKEY_FLAG_INFO has also been set.
780  *
781  * This function might not be supported by all applications.  */
782 gpg_error_t
783 app_readkey (app_t app, ctrl_t ctrl, const char *keyid, unsigned int flags,
784              unsigned char **pk, size_t *pklen)
785 {
786   gpg_error_t err;
787
788   if (pk)
789     *pk = NULL;
790   if (pklen)
791     *pklen = 0;
792
793   if (!app || !keyid)
794     return gpg_error (GPG_ERR_INV_VALUE);
795   if (!app->ref_count)
796     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
797   if (!app->fnc.readkey)
798     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
799   err = lock_app (app, ctrl);
800   if (err)
801     return err;
802   err= app->fnc.readkey (app, ctrl, keyid, flags, pk, pklen);
803   unlock_app (app);
804   return err;
805 }
806
807
808 /* Perform a GETATTR operation.  */
809 gpg_error_t
810 app_getattr (app_t app, ctrl_t ctrl, const char *name)
811 {
812   gpg_error_t err;
813
814   if (!app || !name || !*name)
815     return gpg_error (GPG_ERR_INV_VALUE);
816   if (!app->ref_count)
817     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
818
819   if (app->cardtype && name && !strcmp (name, "CARDTYPE"))
820     {
821       send_status_direct (ctrl, "CARDTYPE", app->cardtype);
822       return 0;
823     }
824   if (app->apptype && name && !strcmp (name, "APPTYPE"))
825     {
826       send_status_direct (ctrl, "APPTYPE", app->apptype);
827       return 0;
828     }
829   if (name && !strcmp (name, "SERIALNO"))
830     {
831       char *serial;
832
833       serial = app_get_serialno (app);
834       if (!serial)
835         return gpg_error (GPG_ERR_INV_VALUE);
836
837       send_status_direct (ctrl, "SERIALNO", serial);
838       xfree (serial);
839       return 0;
840     }
841
842   if (!app->fnc.getattr)
843     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
844   err = lock_app (app, ctrl);
845   if (err)
846     return err;
847   err = app->fnc.getattr (app, ctrl, name);
848   unlock_app (app);
849   return err;
850 }
851
852 /* Perform a SETATTR operation.  */
853 gpg_error_t
854 app_setattr (app_t app, ctrl_t ctrl, const char *name,
855              gpg_error_t (*pincb)(void*, const char *, char **),
856              void *pincb_arg,
857              const unsigned char *value, size_t valuelen)
858 {
859   gpg_error_t err;
860
861   if (!app || !name || !*name || !value)
862     return gpg_error (GPG_ERR_INV_VALUE);
863   if (!app->ref_count)
864     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
865   if (!app->fnc.setattr)
866     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
867   err = lock_app (app, ctrl);
868   if (err)
869     return err;
870   err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
871   unlock_app (app);
872   return err;
873 }
874
875 /* Create the signature and return the allocated result in OUTDATA.
876    If a PIN is required the PINCB will be used to ask for the PIN; it
877    should return the PIN in an allocated buffer and put it into PIN.  */
878 gpg_error_t
879 app_sign (app_t app, ctrl_t ctrl, const char *keyidstr, int hashalgo,
880           gpg_error_t (*pincb)(void*, const char *, char **),
881           void *pincb_arg,
882           const void *indata, size_t indatalen,
883           unsigned char **outdata, size_t *outdatalen )
884 {
885   gpg_error_t err;
886
887   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
888     return gpg_error (GPG_ERR_INV_VALUE);
889   if (!app->ref_count)
890     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
891   if (!app->fnc.sign)
892     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
893   err = lock_app (app, ctrl);
894   if (err)
895     return err;
896   err = app->fnc.sign (app, keyidstr, hashalgo,
897                        pincb, pincb_arg,
898                        indata, indatalen,
899                        outdata, outdatalen);
900   unlock_app (app);
901   if (opt.verbose)
902     log_info ("operation sign result: %s\n", gpg_strerror (err));
903   return err;
904 }
905
906 /* Create the signature using the INTERNAL AUTHENTICATE command and
907    return the allocated result in OUTDATA.  If a PIN is required the
908    PINCB will be used to ask for the PIN; it should return the PIN in
909    an allocated buffer and put it into PIN.  */
910 gpg_error_t
911 app_auth (app_t app, ctrl_t ctrl, const char *keyidstr,
912           gpg_error_t (*pincb)(void*, const char *, char **),
913           void *pincb_arg,
914           const void *indata, size_t indatalen,
915           unsigned char **outdata, size_t *outdatalen )
916 {
917   gpg_error_t err;
918
919   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
920     return gpg_error (GPG_ERR_INV_VALUE);
921   if (!app->ref_count)
922     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
923   if (!app->fnc.auth)
924     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
925   err = lock_app (app, ctrl);
926   if (err)
927     return err;
928   err = app->fnc.auth (app, keyidstr,
929                        pincb, pincb_arg,
930                        indata, indatalen,
931                        outdata, outdatalen);
932   unlock_app (app);
933   if (opt.verbose)
934     log_info ("operation auth result: %s\n", gpg_strerror (err));
935   return err;
936 }
937
938
939 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
940    If a PIN is required the PINCB will be used to ask for the PIN; it
941    should return the PIN in an allocated buffer and put it into PIN.  */
942 gpg_error_t
943 app_decipher (app_t app, ctrl_t ctrl, const char *keyidstr,
944               gpg_error_t (*pincb)(void*, const char *, char **),
945               void *pincb_arg,
946               const void *indata, size_t indatalen,
947               unsigned char **outdata, size_t *outdatalen,
948               unsigned int *r_info)
949 {
950   gpg_error_t err;
951
952   *r_info = 0;
953
954   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
955     return gpg_error (GPG_ERR_INV_VALUE);
956   if (!app->ref_count)
957     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
958   if (!app->fnc.decipher)
959     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
960   err = lock_app (app, ctrl);
961   if (err)
962     return err;
963   err = app->fnc.decipher (app, keyidstr,
964                            pincb, pincb_arg,
965                            indata, indatalen,
966                            outdata, outdatalen,
967                            r_info);
968   unlock_app (app);
969   if (opt.verbose)
970     log_info ("operation decipher result: %s\n", gpg_strerror (err));
971   return err;
972 }
973
974
975 /* Perform the WRITECERT operation.  */
976 gpg_error_t
977 app_writecert (app_t app, ctrl_t ctrl,
978               const char *certidstr,
979               gpg_error_t (*pincb)(void*, const char *, char **),
980               void *pincb_arg,
981               const unsigned char *data, size_t datalen)
982 {
983   gpg_error_t err;
984
985   if (!app || !certidstr || !*certidstr || !pincb)
986     return gpg_error (GPG_ERR_INV_VALUE);
987   if (!app->ref_count)
988     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
989   if (!app->fnc.writecert)
990     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
991   err = lock_app (app, ctrl);
992   if (err)
993     return err;
994   err = app->fnc.writecert (app, ctrl, certidstr,
995                             pincb, pincb_arg, data, datalen);
996   unlock_app (app);
997   if (opt.verbose)
998     log_info ("operation writecert result: %s\n", gpg_strerror (err));
999   return err;
1000 }
1001
1002
1003 /* Perform the WRITEKEY operation.  */
1004 gpg_error_t
1005 app_writekey (app_t app, ctrl_t ctrl,
1006               const char *keyidstr, unsigned int flags,
1007               gpg_error_t (*pincb)(void*, const char *, char **),
1008               void *pincb_arg,
1009               const unsigned char *keydata, size_t keydatalen)
1010 {
1011   gpg_error_t err;
1012
1013   if (!app || !keyidstr || !*keyidstr || !pincb)
1014     return gpg_error (GPG_ERR_INV_VALUE);
1015   if (!app->ref_count)
1016     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
1017   if (!app->fnc.writekey)
1018     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1019   err = lock_app (app, ctrl);
1020   if (err)
1021     return err;
1022   err = app->fnc.writekey (app, ctrl, keyidstr, flags,
1023                            pincb, pincb_arg, keydata, keydatalen);
1024   unlock_app (app);
1025   if (opt.verbose)
1026     log_info ("operation writekey result: %s\n", gpg_strerror (err));
1027   return err;
1028 }
1029
1030
1031 /* Perform a SETATTR operation.  */
1032 gpg_error_t
1033 app_genkey (app_t app, ctrl_t ctrl, const char *keynostr,
1034             const char *keytype, unsigned int flags, time_t createtime,
1035             gpg_error_t (*pincb)(void*, const char *, char **),
1036             void *pincb_arg)
1037 {
1038   gpg_error_t err;
1039
1040   if (!app || !keynostr || !*keynostr || !pincb)
1041     return gpg_error (GPG_ERR_INV_VALUE);
1042   if (!app->ref_count)
1043     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
1044   if (!app->fnc.genkey)
1045     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1046   err = lock_app (app, ctrl);
1047   if (err)
1048     return err;
1049   err = app->fnc.genkey (app, ctrl, keynostr, keytype, flags,
1050                          createtime, pincb, pincb_arg);
1051   unlock_app (app);
1052   if (opt.verbose)
1053     log_info ("operation genkey result: %s\n", gpg_strerror (err));
1054   return err;
1055 }
1056
1057
1058 /* Perform a GET CHALLENGE operation.  This function is special as it
1059    directly accesses the card without any application specific
1060    wrapper. */
1061 gpg_error_t
1062 app_get_challenge (app_t app, ctrl_t ctrl, size_t nbytes, unsigned char *buffer)
1063 {
1064   gpg_error_t err;
1065
1066   if (!app || !nbytes || !buffer)
1067     return gpg_error (GPG_ERR_INV_VALUE);
1068   if (!app->ref_count)
1069     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
1070   err = lock_app (app, ctrl);
1071   if (err)
1072     return err;
1073   err = iso7816_get_challenge (app->slot, nbytes, buffer);
1074   unlock_app (app);
1075   return err;
1076 }
1077
1078
1079
1080 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
1081 gpg_error_t
1082 app_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr,
1083                 unsigned int flags,
1084                 gpg_error_t (*pincb)(void*, const char *, char **),
1085                 void *pincb_arg)
1086 {
1087   gpg_error_t err;
1088
1089   if (!app || !chvnostr || !*chvnostr || !pincb)
1090     return gpg_error (GPG_ERR_INV_VALUE);
1091   if (!app->ref_count)
1092     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
1093   if (!app->fnc.change_pin)
1094     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1095   err = lock_app (app, ctrl);
1096   if (err)
1097     return err;
1098   err = app->fnc.change_pin (app, ctrl, chvnostr, flags, pincb, pincb_arg);
1099   unlock_app (app);
1100   if (opt.verbose)
1101     log_info ("operation change_pin result: %s\n", gpg_strerror (err));
1102   return err;
1103 }
1104
1105
1106 /* Perform a VERIFY operation without doing anything else.  This may
1107    be used to initialize a the PIN cache for long lasting other
1108    operations.  Its use is highly application dependent. */
1109 gpg_error_t
1110 app_check_pin (app_t app, ctrl_t ctrl, const char *keyidstr,
1111                gpg_error_t (*pincb)(void*, const char *, char **),
1112                void *pincb_arg)
1113 {
1114   gpg_error_t err;
1115
1116   if (!app || !keyidstr || !*keyidstr || !pincb)
1117     return gpg_error (GPG_ERR_INV_VALUE);
1118   if (!app->ref_count)
1119     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
1120   if (!app->fnc.check_pin)
1121     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1122   err = lock_app (app, ctrl);
1123   if (err)
1124     return err;
1125   err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
1126   unlock_app (app);
1127   if (opt.verbose)
1128     log_info ("operation check_pin result: %s\n", gpg_strerror (err));
1129   return err;
1130 }
1131
1132 static void
1133 report_change (int slot, int old_status, int cur_status)
1134 {
1135   char *homestr, *envstr;
1136   char *fname;
1137   char templ[50];
1138   FILE *fp;
1139
1140   snprintf (templ, sizeof templ, "reader_%d.status", slot);
1141   fname = make_filename (gnupg_homedir (), templ, NULL );
1142   fp = fopen (fname, "w");
1143   if (fp)
1144     {
1145       fprintf (fp, "%s\n",
1146                (cur_status & 1)? "USABLE":
1147                (cur_status & 4)? "ACTIVE":
1148                (cur_status & 2)? "PRESENT": "NOCARD");
1149       fclose (fp);
1150     }
1151   xfree (fname);
1152
1153   homestr = make_filename (gnupg_homedir (), NULL);
1154   if (gpgrt_asprintf (&envstr, "GNUPGHOME=%s", homestr) < 0)
1155     log_error ("out of core while building environment\n");
1156   else
1157     {
1158       gpg_error_t err;
1159       const char *args[9], *envs[2];
1160       char numbuf1[30], numbuf2[30], numbuf3[30];
1161
1162       envs[0] = envstr;
1163       envs[1] = NULL;
1164
1165       sprintf (numbuf1, "%d", slot);
1166       sprintf (numbuf2, "0x%04X", old_status);
1167       sprintf (numbuf3, "0x%04X", cur_status);
1168       args[0] = "--reader-port";
1169       args[1] = numbuf1;
1170       args[2] = "--old-code";
1171       args[3] = numbuf2;
1172       args[4] = "--new-code";
1173       args[5] = numbuf3;
1174       args[6] = "--status";
1175       args[7] = ((cur_status & 1)? "USABLE":
1176                  (cur_status & 4)? "ACTIVE":
1177                  (cur_status & 2)? "PRESENT": "NOCARD");
1178       args[8] = NULL;
1179
1180       fname = make_filename (gnupg_homedir (), "scd-event", NULL);
1181       err = gnupg_spawn_process_detached (fname, args, envs);
1182       if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
1183         log_error ("failed to run event handler '%s': %s\n",
1184                    fname, gpg_strerror (err));
1185       xfree (fname);
1186       xfree (envstr);
1187     }
1188   xfree (homestr);
1189 }
1190
1191 int
1192 scd_update_reader_status_file (void)
1193 {
1194   app_t a, app_next;
1195   int periodical_check_needed = 0;
1196
1197   npth_mutex_lock (&app_list_lock);
1198   for (a = app_top; a; a = app_next)
1199     {
1200       int sw;
1201       unsigned int status;
1202
1203       lock_app (a, NULL);
1204       app_next = a->next;
1205
1206       if (a->reset_requested)
1207         status = 0;
1208       else
1209         {
1210           sw = apdu_get_status (a->slot, 0, &status);
1211           if (sw == SW_HOST_NO_READER)
1212             {
1213               /* Most likely the _reader_ has been unplugged.  */
1214               status = 0;
1215             }
1216           else if (sw)
1217             {
1218               /* Get status failed.  Ignore that.  */
1219               if (a->periodical_check_needed)
1220                 periodical_check_needed = 1;
1221               unlock_app (a);
1222               continue;
1223             }
1224         }
1225
1226       if (a->card_status != status)
1227         {
1228           report_change (a->slot, a->card_status, status);
1229           send_client_notifications (a, status == 0);
1230
1231           if (status == 0)
1232             {
1233               log_debug ("Removal of a card: %d\n", a->slot);
1234               apdu_close_reader (a->slot);
1235               deallocate_app (a);
1236             }
1237           else
1238             {
1239               a->card_status = status;
1240               if (a->periodical_check_needed)
1241                 periodical_check_needed = 1;
1242               unlock_app (a);
1243             }
1244         }
1245       else
1246         {
1247           if (a->periodical_check_needed)
1248             periodical_check_needed = 1;
1249           unlock_app (a);
1250         }
1251     }
1252   npth_mutex_unlock (&app_list_lock);
1253
1254   return periodical_check_needed;
1255 }
1256
1257 /* This function must be called once to initialize this module.  This
1258    has to be done before a second thread is spawned.  We can't do the
1259    static initialization because Pth emulation code might not be able
1260    to do a static init; in particular, it is not possible for W32. */
1261 gpg_error_t
1262 initialize_module_command (void)
1263 {
1264   gpg_error_t err;
1265
1266   if (npth_mutex_init (&app_list_lock, NULL))
1267     {
1268       err = gpg_error_from_syserror ();
1269       log_error ("app: error initializing mutex: %s\n", gpg_strerror (err));
1270       return err;
1271     }
1272
1273   return apdu_init ();
1274 }
1275
1276 void
1277 app_send_card_list (ctrl_t ctrl)
1278 {
1279   app_t a;
1280   char buf[65];
1281
1282   npth_mutex_lock (&app_list_lock);
1283   for (a = app_top; a; a = a->next)
1284     {
1285       if (DIM (buf) < 2 * a->serialnolen + 1)
1286         continue;
1287
1288       bin2hex (a->serialno, a->serialnolen, buf);
1289       send_status_direct (ctrl, "SERIALNO", buf);
1290     }
1291   npth_mutex_unlock (&app_list_lock);
1292 }
1293
1294 /* Execute an action for each app.  ACTION can be one of:
1295      KEYGRIP_ACTION_SEND_DATA: send data if KEYGRIP_STR matches
1296      KEYGRIP_ACTION_WRITE_STATUS: write status if KEYGRIP_STR matches
1297      KEYGRIP_ACTION_LOOKUP: Return matching APP
1298  */
1299 app_t
1300 app_do_with_keygrip (ctrl_t ctrl, int action, const char *keygrip_str)
1301 {
1302   app_t a;
1303
1304   npth_mutex_lock (&app_list_lock);
1305
1306   for (a = app_top; a; a = a->next)
1307     if (a->fnc.with_keygrip
1308         && !a->fnc.with_keygrip (a, ctrl, action, keygrip_str))
1309       break;
1310
1311   npth_mutex_unlock (&app_list_lock);
1312   return a;
1313 }