scd: Clean up internal API for APP.
[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 "app-common.h"
29 #include "iso7816.h"
30 #include "apdu.h"
31 #include "tlv.h"
32
33 /* This table is used to keep track of locks on a per reader base.
34    The index into the table is the slot number of the reader.  The
35    mutex will be initialized on demand (one of the advantages of a
36    userland threading system). */
37 static struct
38 {
39   int initialized;
40   npth_mutex_t lock;
41   app_t app;        /* Application context in use or NULL. */
42 } lock_table[10];
43
44
45
46 static void deallocate_app (app_t app);
47
48
49 \f
50 static void
51 print_progress_line (void *opaque, const char *what, int pc, int cur, int tot)
52 {
53   ctrl_t ctrl = opaque;
54   char line[100];
55
56   if (ctrl)
57     {
58       snprintf (line, sizeof line, "%s %c %d %d", what, pc, cur, tot);
59       send_status_direct (ctrl, "PROGRESS", line);
60     }
61 }
62
63
64 /* Lock the reader SLOT.  This function shall be used right before
65    calling any of the actual application functions to serialize access
66    to the reader.  We do this always even if the reader is not
67    actually used.  This allows an actual connection to assume that it
68    never shares a reader (while performing one command).  Returns 0 on
69    success; only then the unlock_reader function must be called after
70    returning from the handler. */
71 static gpg_error_t
72 lock_reader (int slot, ctrl_t ctrl)
73 {
74   int res;
75
76   if (slot < 0 || slot >= DIM (lock_table))
77     return gpg_error (slot<0? GPG_ERR_INV_VALUE : GPG_ERR_RESOURCE_LIMIT);
78
79   if (!lock_table[slot].initialized)
80     {
81       res = npth_mutex_init (&lock_table[slot].lock, NULL);
82       if (res)
83         {
84           log_error ("error initializing mutex: %s\n", strerror (res));
85           return gpg_error_from_errno (res);
86         }
87       lock_table[slot].initialized = 1;
88       lock_table[slot].app = NULL;
89     }
90
91   res = npth_mutex_lock (&lock_table[slot].lock);
92   if (res)
93     {
94       log_error ("failed to acquire APP lock for slot %d: %s\n",
95                  slot, strerror (res));
96       return gpg_error_from_errno (res);
97     }
98
99   apdu_set_progress_cb (slot, print_progress_line, ctrl);
100
101   return 0;
102 }
103
104 /* Release a lock on the reader.  See lock_reader(). */
105 static void
106 unlock_reader (int slot)
107 {
108   int res;
109
110   if (slot < 0 || slot >= DIM (lock_table)
111       || !lock_table[slot].initialized)
112     log_bug ("unlock_reader called for invalid slot %d\n", slot);
113
114   apdu_set_progress_cb (slot, NULL, NULL);
115
116   res = npth_mutex_unlock (&lock_table[slot].lock);
117   if (res)
118     log_error ("failed to release APP lock for slot %d: %s\n",
119                slot, strerror (res));
120 }
121
122
123 /* This function may be called to print information pertaining to the
124    current state of this module to the log. */
125 void
126 app_dump_state (void)
127 {
128   int slot;
129
130   for (slot=0; slot < DIM (lock_table); slot++)
131     if (lock_table[slot].initialized)
132       {
133         log_info ("app_dump_state: slot=%d", slot);
134         if (lock_table[slot].app)
135           {
136             log_printf (" app=%p", lock_table[slot].app);
137             if (lock_table[slot].app->apptype)
138               log_printf (" type='%s'", lock_table[slot].app->apptype);
139           }
140         log_printf ("\n");
141       }
142 }
143
144 /* Check wether the application NAME is allowed.  This does not mean
145    we have support for it though.  */
146 static int
147 is_app_allowed (const char *name)
148 {
149   strlist_t l;
150
151   for (l=opt.disabled_applications; l; l = l->next)
152     if (!strcmp (l->d, name))
153       return 0; /* no */
154   return 1; /* yes */
155 }
156
157
158 /* This may be called to tell this module about a removed or resetted card. */
159 void
160 application_notify_card_reset (int slot)
161 {
162   if (slot < 0 || slot >= DIM (lock_table))
163     return;
164
165   /* FIXME: We are ignoring any error value here.  */
166   lock_reader (slot, NULL);
167
168   /* Release the APP, as it's not reusable any more.  */
169   if (lock_table[slot].app)
170     {
171       if (lock_table[slot].app->ref_count)
172         log_bug ("trying to release active context\n");
173
174       deallocate_app (lock_table[slot].app);
175       lock_table[slot].app = NULL;
176       log_debug ("application has been released\n");
177     }
178
179   unlock_reader (slot);
180 }
181
182
183 /*
184  * This function is called with lock held.
185  */
186 static gpg_error_t
187 check_conflict (int slot, const char *name)
188 {
189   app_t app = lock_table[slot].app;
190
191   if (!app || !name || (app->apptype && !ascii_strcasecmp (app->apptype, name)))
192     return 0;
193
194   if (!app->ref_count)
195     {
196       lock_table[slot].app = NULL;
197       deallocate_app (app);
198       return 0;
199     }
200   else
201     {
202       log_info ("application '%s' in use by reader %d - can't switch\n",
203                 app->apptype? app->apptype : "<null>", slot);
204       return gpg_error (GPG_ERR_CONFLICT);
205     }
206 }
207
208 /* This function is used by the serialno command to check for an
209    application conflict which may appear if the serialno command is
210    used to request a specific application and the connection has
211    already done a select_application. */
212 gpg_error_t
213 check_application_conflict (ctrl_t ctrl, int slot, const char *name)
214 {
215   gpg_error_t err;
216
217   if (slot < 0 || slot >= DIM (lock_table))
218     return gpg_error (GPG_ERR_INV_VALUE);
219
220   err = lock_reader (slot, ctrl);
221   if (err)
222     return err;
223
224   err = check_conflict (slot, name);
225   unlock_reader (slot);
226   return err;
227 }
228
229
230 /* If called with NAME as NULL, select the best fitting application
231    and return a context; otherwise select the application with NAME
232    and return a context.  SLOT identifies the reader device. Returns
233    an error code and stores NULL at R_APP if no application was found
234    or no card is present. */
235 gpg_error_t
236 select_application (ctrl_t ctrl, int slot, const char *name, app_t *r_app)
237 {
238   gpg_error_t err;
239   app_t app = NULL;
240   unsigned char *result = NULL;
241   size_t resultlen;
242   int want_undefined;
243
244   (void)ctrl;
245
246   *r_app = NULL;
247
248   want_undefined = (name && !strcmp (name, "undefined"));
249
250   err = lock_reader (slot, ctrl);
251   if (err)
252     return err;
253
254   /* First check whether we already have an application to share. */
255   err = check_conflict (slot, name);
256   if (err)
257     {
258       unlock_reader (slot);
259       return err;
260     }
261
262   app = lock_table[slot].app;
263
264   /* If we can reuse an application, bump the reference count and
265      return it.  */
266   if (app)
267     {
268       if (app->slot != slot)
269         log_bug ("slot mismatch %d/%d\n", app->slot, slot);
270       app->slot = slot;
271
272       app->ref_count++;
273       *r_app = app;
274       unlock_reader (slot);
275       return 0; /* Okay: We share that one. */
276     }
277
278   /* Need to allocate a new one.  */
279   app = xtrycalloc (1, sizeof *app);
280   if (!app)
281     {
282       err = gpg_error_from_syserror ();
283       log_info ("error allocating context: %s\n", gpg_strerror (err));
284       unlock_reader (slot);
285       return err;
286     }
287   app->slot = slot;
288
289
290   /* Fixme: We should now first check whether a card is at all
291      present. */
292
293   /* Try to read the GDO file first to get a default serial number.
294      We skip this if the undefined application has been requested. */
295   if (!want_undefined)
296     {
297       err = iso7816_select_file (slot, 0x3F00, 1, NULL, NULL);
298       if (!err)
299         err = iso7816_select_file (slot, 0x2F02, 0, NULL, NULL);
300       if (!err)
301         err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
302       if (!err)
303         {
304           size_t n;
305           const unsigned char *p;
306
307           p = find_tlv_unchecked (result, resultlen, 0x5A, &n);
308           if (p)
309             resultlen -= (p-result);
310           if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
311             {
312               /* The object it does not fit into the buffer.  This is an
313                  invalid encoding (or the buffer is too short.  However, I
314                  have some test cards with such an invalid encoding and
315                  therefore I use this ugly workaround to return something
316                  I can further experiment with. */
317               log_info ("enabling BMI testcard workaround\n");
318               n--;
319             }
320
321           if (p && n <= resultlen)
322             {
323               /* The GDO file is pretty short, thus we simply reuse it for
324                  storing the serial number. */
325               memmove (result, p, n);
326               app->serialno = result;
327               app->serialnolen = n;
328               err = app_munge_serialno (app);
329               if (err)
330                 goto leave;
331             }
332           else
333             xfree (result);
334           result = NULL;
335         }
336     }
337
338   /* For certain error codes, there is no need to try more.  */
339   if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT
340       || gpg_err_code (err) == GPG_ERR_ENODEV)
341     goto leave;
342
343   /* Figure out the application to use.  */
344   if (want_undefined)
345     {
346       /* We switch to the "undefined" application only if explicitly
347          requested.  */
348       app->apptype = "UNDEFINED";
349       err = 0;
350     }
351   else
352     err = gpg_error (GPG_ERR_NOT_FOUND);
353
354   if (err && is_app_allowed ("openpgp")
355           && (!name || !strcmp (name, "openpgp")))
356     err = app_select_openpgp (app);
357   if (err && is_app_allowed ("nks") && (!name || !strcmp (name, "nks")))
358     err = app_select_nks (app);
359   if (err && is_app_allowed ("p15") && (!name || !strcmp (name, "p15")))
360     err = app_select_p15 (app);
361   if (err && is_app_allowed ("geldkarte")
362       && (!name || !strcmp (name, "geldkarte")))
363     err = app_select_geldkarte (app);
364   if (err && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
365     err = app_select_dinsig (app);
366   if (err && is_app_allowed ("sc-hsm") && (!name || !strcmp (name, "sc-hsm")))
367     err = app_select_sc_hsm (app);
368   if (err && name && gpg_err_code (err) != GPG_ERR_OBJ_TERM_STATE)
369     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
370
371  leave:
372   if (err)
373     {
374       if (name)
375         log_info ("can't select application '%s': %s\n",
376                   name, gpg_strerror (err));
377       else
378         log_info ("no supported card application found: %s\n",
379                   gpg_strerror (err));
380       xfree (app);
381       unlock_reader (slot);
382       return err;
383     }
384
385   app->ref_count = 1;
386
387   lock_table[slot].app = app;
388   *r_app = app;
389   unlock_reader (slot);
390   return 0;
391 }
392
393
394 char *
395 get_supported_applications (void)
396 {
397   const char *list[] = {
398     "openpgp",
399     "nks",
400     "p15",
401     "geldkarte",
402     "dinsig",
403     "sc-hsm",
404     /* Note: "undefined" is not listed here because it needs special
405        treatment by the client.  */
406     NULL
407   };
408   int idx;
409   size_t nbytes;
410   char *buffer, *p;
411
412   for (nbytes=1, idx=0; list[idx]; idx++)
413     nbytes += strlen (list[idx]) + 1 + 1;
414
415   buffer = xtrymalloc (nbytes);
416   if (!buffer)
417     return NULL;
418
419   for (p=buffer, idx=0; list[idx]; idx++)
420     if (is_app_allowed (list[idx]))
421       p = stpcpy (stpcpy (p, list[idx]), ":\n");
422   *p = 0;
423
424   return buffer;
425 }
426
427
428 /* Deallocate the application. */
429 static void
430 deallocate_app (app_t app)
431 {
432   if (app->fnc.deinit)
433     {
434       app->fnc.deinit (app);
435       app->fnc.deinit = NULL;
436     }
437
438   xfree (app->serialno);
439   xfree (app);
440 }
441
442 /* Free the resources associated with the application APP.  APP is
443    allowed to be NULL in which case this is a no-op.  Note that we are
444    using reference counting to track the users of the application and
445    actually deferring the deallocation to allow for a later reuse by
446    a new connection. */
447 void
448 release_application (app_t app)
449 {
450   int slot;
451
452   if (!app)
453     return;
454
455   if (!app->ref_count)
456     log_bug ("trying to release an already released context\n");
457   if (--app->ref_count)
458     return;
459
460   /* Move the reference to the application in the lock table. */
461   slot = app->slot;
462   /* FIXME: We are ignoring any error value.  */
463   lock_reader (slot, NULL);
464   if (lock_table[slot].app != app)
465     {
466       unlock_reader (slot);
467       log_bug ("app mismatch %p/%p\n", app, lock_table[slot].app);
468       deallocate_app (app);
469       return;
470     }
471
472   /* We don't deallocate app here.  Instead, we keep it.  This is
473      useful so that a card does not get reset even if only one session
474      is using the card - this way the PIN cache and other cached data
475      are preserved.  */
476   unlock_reader (slot);
477 }
478
479
480
481 /* The serial number may need some cosmetics.  Do it here.  This
482    function shall only be called once after a new serial number has
483    been put into APP->serialno.
484
485    Prefixes we use:
486
487      FF 00 00 = For serial numbers starting with an FF
488      FF 01 00 = Some german p15 cards return an empty serial number so the
489                 serial number from the EF(TokenInfo) is used instead.
490      FF 7F 00 = No serialno.
491
492      All other serial number not starting with FF are used as they are.
493 */
494 gpg_error_t
495 app_munge_serialno (app_t app)
496 {
497   if (app->serialnolen && app->serialno[0] == 0xff)
498     {
499       /* The serial number starts with our special prefix.  This
500          requires that we put our default prefix "FF0000" in front. */
501       unsigned char *p = xtrymalloc (app->serialnolen + 3);
502       if (!p)
503         return gpg_error_from_syserror ();
504       memcpy (p, "\xff\0", 3);
505       memcpy (p+3, app->serialno, app->serialnolen);
506       app->serialnolen += 3;
507       xfree (app->serialno);
508       app->serialno = p;
509     }
510   else if (!app->serialnolen)
511     {
512       unsigned char *p = xtrymalloc (3);
513       if (!p)
514         return gpg_error_from_syserror ();
515       memcpy (p, "\xff\x7f", 3);
516       app->serialnolen = 3;
517       xfree (app->serialno);
518       app->serialno = p;
519     }
520   return 0;
521 }
522
523
524
525 /* Retrieve the serial number and the time of the last update of the
526    card.  The serial number is returned as a malloced string (hex
527    encoded) in SERIAL and the time of update is returned in STAMP.  If
528    no update time is available the returned value is 0.  Caller must
529    free SERIAL unless the function returns an error.  If STAMP is not
530    of interest, NULL may be passed. */
531 gpg_error_t
532 app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
533 {
534   char *buf;
535
536   if (!app || !serial)
537     return gpg_error (GPG_ERR_INV_VALUE);
538
539   *serial = NULL;
540   if (stamp)
541     *stamp = 0; /* not available */
542
543   if (!app->serialnolen)
544     buf = xtrystrdup ("FF7F00");
545   else
546     buf = bin2hex (app->serialno, app->serialnolen, NULL);
547   if (!buf)
548     return gpg_error_from_syserror ();
549
550   *serial = buf;
551   return 0;
552 }
553
554
555 /* Write out the application specifig status lines for the LEARN
556    command. */
557 gpg_error_t
558 app_write_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
559 {
560   gpg_error_t err;
561
562   if (!app)
563     return gpg_error (GPG_ERR_INV_VALUE);
564   if (!app->ref_count)
565     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
566   if (!app->fnc.learn_status)
567     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
568
569   /* We do not send APPTYPE if only keypairinfo is requested.  */
570   if (app->apptype && !(flags & 1))
571     send_status_info (ctrl, "APPTYPE",
572                       app->apptype, strlen (app->apptype), NULL, 0);
573   err = lock_reader (app->slot, ctrl);
574   if (err)
575     return err;
576   err = app->fnc.learn_status (app, ctrl, flags);
577   unlock_reader (app->slot);
578   return err;
579 }
580
581
582 /* Read the certificate with id CERTID (as returned by learn_status in
583    the CERTINFO status lines) and return it in the freshly allocated
584    buffer put into CERT and the length of the certificate put into
585    CERTLEN. */
586 gpg_error_t
587 app_readcert (app_t app, ctrl_t ctrl, const char *certid,
588               unsigned char **cert, size_t *certlen)
589 {
590   gpg_error_t err;
591
592   if (!app)
593     return gpg_error (GPG_ERR_INV_VALUE);
594   if (!app->ref_count)
595     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
596   if (!app->fnc.readcert)
597     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
598   err = lock_reader (app->slot, ctrl);
599   if (err)
600     return err;
601   err = app->fnc.readcert (app, certid, cert, certlen);
602   unlock_reader (app->slot);
603   return err;
604 }
605
606
607 /* Read the key with ID KEYID.  On success a canonical encoded
608    S-expression with the public key will get stored at PK and its
609    length (for assertions) at PKLEN; the caller must release that
610    buffer. On error NULL will be stored at PK and PKLEN and an error
611    code returned.
612
613    This function might not be supported by all applications.  */
614 gpg_error_t
615 app_readkey (app_t app, ctrl_t ctrl, int advanced, const char *keyid,
616              unsigned char **pk, size_t *pklen)
617 {
618   gpg_error_t err;
619
620   if (pk)
621     *pk = NULL;
622   if (pklen)
623     *pklen = 0;
624
625   if (!app || !keyid || !pk || !pklen)
626     return gpg_error (GPG_ERR_INV_VALUE);
627   if (!app->ref_count)
628     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
629   if (!app->fnc.readkey)
630     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
631   err = lock_reader (app->slot, ctrl);
632   if (err)
633     return err;
634   err= app->fnc.readkey (app, advanced, keyid, pk, pklen);
635   unlock_reader (app->slot);
636   return err;
637 }
638
639
640 /* Perform a GETATTR operation.  */
641 gpg_error_t
642 app_getattr (app_t app, ctrl_t ctrl, const char *name)
643 {
644   gpg_error_t err;
645
646   if (!app || !name || !*name)
647     return gpg_error (GPG_ERR_INV_VALUE);
648   if (!app->ref_count)
649     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
650
651   if (app->apptype && name && !strcmp (name, "APPTYPE"))
652     {
653       send_status_info (ctrl, "APPTYPE",
654                         app->apptype, strlen (app->apptype), NULL, 0);
655       return 0;
656     }
657   if (name && !strcmp (name, "SERIALNO"))
658     {
659       char *serial;
660       time_t stamp;
661       int rc;
662
663       rc = app_get_serial_and_stamp (app, &serial, &stamp);
664       if (rc)
665         return rc;
666       send_status_info (ctrl, "SERIALNO", serial, strlen (serial), NULL, 0);
667       xfree (serial);
668       return 0;
669     }
670
671   if (!app->fnc.getattr)
672     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
673   err = lock_reader (app->slot, ctrl);
674   if (err)
675     return err;
676   err =  app->fnc.getattr (app, ctrl, name);
677   unlock_reader (app->slot);
678   return err;
679 }
680
681 /* Perform a SETATTR operation.  */
682 gpg_error_t
683 app_setattr (app_t app, ctrl_t ctrl, const char *name,
684              gpg_error_t (*pincb)(void*, const char *, char **),
685              void *pincb_arg,
686              const unsigned char *value, size_t valuelen)
687 {
688   gpg_error_t err;
689
690   if (!app || !name || !*name || !value)
691     return gpg_error (GPG_ERR_INV_VALUE);
692   if (!app->ref_count)
693     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
694   if (!app->fnc.setattr)
695     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
696   err = lock_reader (app->slot, ctrl);
697   if (err)
698     return err;
699   err = app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
700   unlock_reader (app->slot);
701   return err;
702 }
703
704 /* Create the signature and return the allocated result in OUTDATA.
705    If a PIN is required the PINCB will be used to ask for the PIN; it
706    should return the PIN in an allocated buffer and put it into PIN.  */
707 gpg_error_t
708 app_sign (app_t app, ctrl_t ctrl, const char *keyidstr, int hashalgo,
709           gpg_error_t (*pincb)(void*, const char *, char **),
710           void *pincb_arg,
711           const void *indata, size_t indatalen,
712           unsigned char **outdata, size_t *outdatalen )
713 {
714   gpg_error_t err;
715
716   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
717     return gpg_error (GPG_ERR_INV_VALUE);
718   if (!app->ref_count)
719     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
720   if (!app->fnc.sign)
721     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
722   err = lock_reader (app->slot, ctrl);
723   if (err)
724     return err;
725   err = app->fnc.sign (app, keyidstr, hashalgo,
726                        pincb, pincb_arg,
727                        indata, indatalen,
728                        outdata, outdatalen);
729   unlock_reader (app->slot);
730   if (opt.verbose)
731     log_info ("operation sign result: %s\n", gpg_strerror (err));
732   return err;
733 }
734
735 /* Create the signature using the INTERNAL AUTHENTICATE command and
736    return the allocated result in OUTDATA.  If a PIN is required the
737    PINCB will be used to ask for the PIN; it should return the PIN in
738    an allocated buffer and put it into PIN.  */
739 gpg_error_t
740 app_auth (app_t app, ctrl_t ctrl, const char *keyidstr,
741           gpg_error_t (*pincb)(void*, const char *, char **),
742           void *pincb_arg,
743           const void *indata, size_t indatalen,
744           unsigned char **outdata, size_t *outdatalen )
745 {
746   gpg_error_t err;
747
748   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
749     return gpg_error (GPG_ERR_INV_VALUE);
750   if (!app->ref_count)
751     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
752   if (!app->fnc.auth)
753     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
754   err = lock_reader (app->slot, ctrl);
755   if (err)
756     return err;
757   err = app->fnc.auth (app, keyidstr,
758                        pincb, pincb_arg,
759                        indata, indatalen,
760                        outdata, outdatalen);
761   unlock_reader (app->slot);
762   if (opt.verbose)
763     log_info ("operation auth result: %s\n", gpg_strerror (err));
764   return err;
765 }
766
767
768 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
769    If a PIN is required the PINCB will be used to ask for the PIN; it
770    should return the PIN in an allocated buffer and put it into PIN.  */
771 gpg_error_t
772 app_decipher (app_t app, ctrl_t ctrl, const char *keyidstr,
773               gpg_error_t (*pincb)(void*, const char *, char **),
774               void *pincb_arg,
775               const void *indata, size_t indatalen,
776               unsigned char **outdata, size_t *outdatalen,
777               unsigned int *r_info)
778 {
779   gpg_error_t err;
780
781   *r_info = 0;
782
783   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
784     return gpg_error (GPG_ERR_INV_VALUE);
785   if (!app->ref_count)
786     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
787   if (!app->fnc.decipher)
788     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
789   err = lock_reader (app->slot, ctrl);
790   if (err)
791     return err;
792   err = app->fnc.decipher (app, keyidstr,
793                            pincb, pincb_arg,
794                            indata, indatalen,
795                            outdata, outdatalen,
796                            r_info);
797   unlock_reader (app->slot);
798   if (opt.verbose)
799     log_info ("operation decipher result: %s\n", gpg_strerror (err));
800   return err;
801 }
802
803
804 /* Perform the WRITECERT operation.  */
805 gpg_error_t
806 app_writecert (app_t app, ctrl_t ctrl,
807               const char *certidstr,
808               gpg_error_t (*pincb)(void*, const char *, char **),
809               void *pincb_arg,
810               const unsigned char *data, size_t datalen)
811 {
812   gpg_error_t err;
813
814   if (!app || !certidstr || !*certidstr || !pincb)
815     return gpg_error (GPG_ERR_INV_VALUE);
816   if (!app->ref_count)
817     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
818   if (!app->fnc.writecert)
819     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
820   err = lock_reader (app->slot, ctrl);
821   if (err)
822     return err;
823   err = app->fnc.writecert (app, ctrl, certidstr,
824                             pincb, pincb_arg, data, datalen);
825   unlock_reader (app->slot);
826   if (opt.verbose)
827     log_info ("operation writecert result: %s\n", gpg_strerror (err));
828   return err;
829 }
830
831
832 /* Perform the WRITEKEY operation.  */
833 gpg_error_t
834 app_writekey (app_t app, ctrl_t ctrl,
835               const char *keyidstr, unsigned int flags,
836               gpg_error_t (*pincb)(void*, const char *, char **),
837               void *pincb_arg,
838               const unsigned char *keydata, size_t keydatalen)
839 {
840   gpg_error_t err;
841
842   if (!app || !keyidstr || !*keyidstr || !pincb)
843     return gpg_error (GPG_ERR_INV_VALUE);
844   if (!app->ref_count)
845     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
846   if (!app->fnc.writekey)
847     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
848   err = lock_reader (app->slot, ctrl);
849   if (err)
850     return err;
851   err = app->fnc.writekey (app, ctrl, keyidstr, flags,
852                            pincb, pincb_arg, keydata, keydatalen);
853   unlock_reader (app->slot);
854   if (opt.verbose)
855     log_info ("operation writekey result: %s\n", gpg_strerror (err));
856   return err;
857 }
858
859
860 /* Perform a SETATTR operation.  */
861 gpg_error_t
862 app_genkey (app_t app, ctrl_t ctrl, const char *keynostr, unsigned int flags,
863             time_t createtime,
864             gpg_error_t (*pincb)(void*, const char *, char **),
865             void *pincb_arg)
866 {
867   gpg_error_t err;
868
869   if (!app || !keynostr || !*keynostr || !pincb)
870     return gpg_error (GPG_ERR_INV_VALUE);
871   if (!app->ref_count)
872     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
873   if (!app->fnc.genkey)
874     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
875   err = lock_reader (app->slot, ctrl);
876   if (err)
877     return err;
878   err = app->fnc.genkey (app, ctrl, keynostr, flags,
879                          createtime, pincb, pincb_arg);
880   unlock_reader (app->slot);
881   if (opt.verbose)
882     log_info ("operation genkey result: %s\n", gpg_strerror (err));
883   return err;
884 }
885
886
887 /* Perform a GET CHALLENGE operation.  This function is special as it
888    directly accesses the card without any application specific
889    wrapper. */
890 gpg_error_t
891 app_get_challenge (app_t app, ctrl_t ctrl, size_t nbytes, unsigned char *buffer)
892 {
893   gpg_error_t err;
894
895   if (!app || !nbytes || !buffer)
896     return gpg_error (GPG_ERR_INV_VALUE);
897   if (!app->ref_count)
898     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
899   err = lock_reader (app->slot, ctrl);
900   if (err)
901     return err;
902   err = iso7816_get_challenge (app->slot, nbytes, buffer);
903   unlock_reader (app->slot);
904   return err;
905 }
906
907
908
909 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
910 gpg_error_t
911 app_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr, int reset_mode,
912                 gpg_error_t (*pincb)(void*, const char *, char **),
913                 void *pincb_arg)
914 {
915   gpg_error_t err;
916
917   if (!app || !chvnostr || !*chvnostr || !pincb)
918     return gpg_error (GPG_ERR_INV_VALUE);
919   if (!app->ref_count)
920     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
921   if (!app->fnc.change_pin)
922     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
923   err = lock_reader (app->slot, ctrl);
924   if (err)
925     return err;
926   err = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode,
927                              pincb, pincb_arg);
928   unlock_reader (app->slot);
929   if (opt.verbose)
930     log_info ("operation change_pin result: %s\n", gpg_strerror (err));
931   return err;
932 }
933
934
935 /* Perform a VERIFY operation without doing anything lese.  This may
936    be used to initialze a the PIN cache for long lasting other
937    operations.  Its use is highly application dependent. */
938 gpg_error_t
939 app_check_pin (app_t app, ctrl_t ctrl, const char *keyidstr,
940                gpg_error_t (*pincb)(void*, const char *, char **),
941                void *pincb_arg)
942 {
943   gpg_error_t err;
944
945   if (!app || !keyidstr || !*keyidstr || !pincb)
946     return gpg_error (GPG_ERR_INV_VALUE);
947   if (!app->ref_count)
948     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
949   if (!app->fnc.check_pin)
950     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
951   err = lock_reader (app->slot, ctrl);
952   if (err)
953     return err;
954   err = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
955   unlock_reader (app->slot);
956   if (opt.verbose)
957     log_info ("operation check_pin result: %s\n", gpg_strerror (err));
958   return err;
959 }