* call-scd.c (unescape_status_string): New. Actual a copy of
[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
27
28 #include "scdaemon.h"
29 #include "app-common.h"
30 #include "apdu.h"
31 #include "iso7816.h"
32 #include "tlv.h"
33
34
35 /* Check wether the application NAME is allowed.  This does not mean
36    we have support for it though.  */
37 static int
38 is_app_allowed (const char *name)
39 {
40   strlist_t l;
41
42   for (l=opt.disabled_applications; l; l = l->next)
43     if (!strcmp (l->d, name))
44       return 0; /* no */
45   return 1; /* yes */
46 }
47
48
49 /* If called with NAME as NULL, select the best fitting application
50    and return a context; otherwise select the application with NAME
51    and return a context.  SLOT identifies the reader device. Returns
52    an error code and stores NULL at R_APP if no application was found
53    or no card is present. */
54 gpg_error_t
55 select_application (ctrl_t ctrl, int slot, const char *name, app_t *r_app)
56 {
57   int rc;
58   app_t app;
59   unsigned char *result = NULL;
60   size_t resultlen;
61
62   *r_app = NULL;
63   app = xtrycalloc (1, sizeof *app);
64   if (!app)
65     {
66       rc = gpg_error_from_errno (errno);
67       log_info ("error allocating context: %s\n", gpg_strerror (rc));
68       return rc;
69     }
70   app->slot = slot;
71
72   /* Fixme: We should now first check whether a card is at all
73      present. */
74
75   /* Try to read the GDO file first to get a default serial number. */
76   rc = iso7816_select_file (slot, 0x3F00, 1, NULL, NULL);
77   if (!rc)
78     rc = iso7816_select_file (slot, 0x2F02, 0, NULL, NULL);
79   if (!rc)
80      rc = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
81   if (!rc)
82     {
83       size_t n;
84       const unsigned char *p;
85
86       p = find_tlv (result, resultlen, 0x5A, &n);
87       if (p)
88         resultlen -= (p-result);
89       if (p && n > resultlen && n == 0x0d && resultlen+1 == n)
90         {
91           /* The object it does not fit into the buffer.  This is an
92              invalid encoding (or the buffer is too short.  However, I
93              have some test cards with such an invalid encoding and
94              therefore I use this ugly workaround to return something
95              I can further experiment with. */
96           log_debug ("enabling BMI testcard workaround\n");
97           n--;
98         }
99
100       if (p && n <= resultlen)
101         {
102           /* The GDO file is pretty short, thus we simply reuse it for
103              storing the serial number. */
104           memmove (result, p, n);
105           app->serialno = result;
106           app->serialnolen = n;
107           rc = app_munge_serialno (app);
108           if (rc)
109             goto leave;
110         }
111       else
112         xfree (result);
113       result = NULL;
114     }
115
116   /* For certain error codes, there is no need to try more.  */
117   if (gpg_err_code (rc) == GPG_ERR_CARD_NOT_PRESENT)
118     goto leave;
119   
120
121   /* Figure out the application to use.  */
122   rc = gpg_error (GPG_ERR_NOT_FOUND);
123
124   if (rc && is_app_allowed ("openpgp") && (!name || !strcmp (name, "openpgp")))
125     rc = app_select_openpgp (app);
126   if (rc && is_app_allowed ("nks") && (!name || !strcmp (name, "nks")))
127     rc = app_select_nks (app);
128 /*   if (rc && is_app_allowed ("p12") && (!name || !strcmp (name, "p12"))) */
129 /*     rc = app_select_p12 (app); */
130   if (rc && is_app_allowed ("dinsig") && (!name || !strcmp (name, "dinsig")))
131     rc = app_select_dinsig (app);
132   if (rc && name)
133     rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
134
135  leave:
136   if (rc)
137     {
138       if (name)
139         log_info ("can't select application `%s': %s\n",
140                   name, gpg_strerror (rc));
141       else
142         log_info ("no supported card application found: %s\n",
143                   gpg_strerror (rc));
144       xfree (app);
145       return rc;
146     }
147
148   app->initialized = 1;
149   *r_app = app;
150   return 0;
151 }
152
153
154 void
155 release_application (app_t app)
156 {
157   if (!app)
158     return;
159
160   if (app->fnc.deinit)
161     {
162       app->fnc.deinit (app);
163       app->fnc.deinit = NULL;
164     }
165
166   xfree (app->serialno);
167   xfree (app);
168 }
169
170
171
172 /* The serial number may need some cosmetics.  Do it here.  This
173    function shall only be called once after a new serial number has
174    been put into APP->serialno. 
175
176    Prefixes we use:
177    
178      FF 00 00 = For serial numbers starting with an FF
179      FF 01 00 = Some german p15 cards return an empty serial number so the
180                 serial number from the EF(TokeInfo is used instead.
181      
182      All other serial number not starting with FF are used as they are.
183 */
184 int
185 app_munge_serialno (app_t app)
186 {
187   if (app->serialnolen && app->serialno[0] == 0xff)
188     { 
189       /* The serial number starts with our special prefix.  This
190          requires that we put our default prefix "FF0000" in front. */
191       unsigned char *p = xtrymalloc (app->serialnolen + 3);
192       if (!p)
193         return gpg_error (gpg_err_code_from_errno (errno));
194       memcpy (p, "\xff\0", 3);
195       memcpy (p+3, app->serialno, app->serialnolen);
196       app->serialnolen += 3;
197       xfree (app->serialno);
198       app->serialno = p;
199     }
200   return 0;
201 }
202
203
204
205 /* Retrieve the serial number and the time of the last update of the
206    card.  The serial number is returned as a malloced string (hex
207    encoded) in SERIAL and the time of update is returned in STAMP.  If
208    no update time is available the returned value is 0.  Caller must
209    free SERIAL unless the function returns an error.  If STAMP is not
210    of interest, NULL may be passed. */
211 int 
212 app_get_serial_and_stamp (app_t app, char **serial, time_t *stamp)
213 {
214   unsigned char *buf, *p;
215   int i;
216
217   if (!app || !serial)
218     return gpg_error (GPG_ERR_INV_VALUE);
219
220   *serial = NULL;
221   if (stamp)
222     *stamp = 0; /* not available */
223
224   buf = xtrymalloc (app->serialnolen * 2 + 1);
225   if (!buf)
226     return gpg_error_from_errno (errno);
227   for (p=buf, i=0; i < app->serialnolen; p +=2, i++)
228     sprintf (p, "%02X", app->serialno[i]);
229   *p = 0;
230   *serial = buf;
231   return 0;
232 }
233
234
235 /* Write out the application specifig status lines for the LEARN
236    command. */
237 int
238 app_write_learn_status (APP app, CTRL ctrl)
239 {
240   if (!app)
241     return gpg_error (GPG_ERR_INV_VALUE);
242   if (!app->initialized)
243     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
244   if (!app->fnc.learn_status)
245     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
246
247   if (app->apptype)
248     send_status_info (ctrl, "APPTYPE",
249                       app->apptype, strlen (app->apptype), NULL, 0);
250
251   return app->fnc.learn_status (app, ctrl);
252 }
253
254
255 /* Read the certificate with id CERTID (as returned by learn_status in
256    the CERTINFO status lines) and return it in the freshly allocated
257    buffer put into CERT and the length of the certificate put into
258    CERTLEN. */
259 int
260 app_readcert (app_t app, const char *certid,
261               unsigned char **cert, size_t *certlen)
262 {
263   if (!app)
264     return gpg_error (GPG_ERR_INV_VALUE);
265   if (!app->initialized)
266     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
267   if (!app->fnc.readcert)
268     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
269
270   return app->fnc.readcert (app, certid, cert, certlen);
271 }
272
273
274 /* Read the key with ID KEYID.  On success a canonical encoded
275    S-expression with the public key will get stored at PK and its
276    length (for assertions) at PKLEN; the caller must release that
277    buffer. On error NULL will be stored at PK and PKLEN and an error
278    code returned.
279
280    This function might not be supported by all applications.  */
281 int
282 app_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
283 {
284   if (pk)
285     *pk = NULL;
286   if (pklen)
287     *pklen = 0;
288
289   if (!app || !keyid || !pk || !pklen)
290     return gpg_error (GPG_ERR_INV_VALUE);
291   if (!app->initialized)
292     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
293   if (!app->fnc.readkey)
294     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
295
296   return app->fnc.readkey (app, keyid, pk, pklen);
297 }
298
299
300 /* Perform a GETATTR operation.  */
301 int 
302 app_getattr (APP app, CTRL ctrl, const char *name)
303 {
304   if (!app || !name || !*name)
305     return gpg_error (GPG_ERR_INV_VALUE);
306   if (!app->initialized)
307     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
308
309   if (app->apptype && name && !strcmp (name, "APPTYPE"))
310     {
311       send_status_info (ctrl, "APPTYPE",
312                         app->apptype, strlen (app->apptype), NULL, 0);
313       return 0;
314     }
315   if (name && !strcmp (name, "SERIALNO"))
316     {
317       char *serial_and_stamp;
318       char *serial;
319       time_t stamp;
320       int rc;
321       
322       rc = app_get_serial_and_stamp (app, &serial, &stamp);
323       if (rc)
324         return rc;
325       rc = asprintf (&serial_and_stamp, "%s %lu",
326                      serial, (unsigned long)stamp);
327       rc = (rc < 0)? gpg_error_from_errno (errno) : 0;
328       xfree (serial);
329       if (rc)
330         return rc;
331       send_status_info (ctrl, "SERIALNO",
332                         serial_and_stamp, strlen (serial_and_stamp), NULL, 0);
333       free (serial_and_stamp);
334       return 0;
335     }
336
337   if (!app->fnc.getattr)
338     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
339   return app->fnc.getattr (app, ctrl, name);
340 }
341
342 /* Perform a SETATTR operation.  */
343 int 
344 app_setattr (APP app, const char *name,
345              int (*pincb)(void*, const char *, char **),
346              void *pincb_arg,
347              const unsigned char *value, size_t valuelen)
348 {
349   if (!app || !name || !*name || !value)
350     return gpg_error (GPG_ERR_INV_VALUE);
351   if (!app->initialized)
352     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
353   if (!app->fnc.setattr)
354     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
355   return app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
356 }
357
358 /* Create the signature and return the allocated result in OUTDATA.
359    If a PIN is required the PINCB will be used to ask for the PIN; it
360    should return the PIN in an allocated buffer and put it into PIN.  */
361 int 
362 app_sign (APP app, const char *keyidstr, int hashalgo,
363           int (pincb)(void*, const char *, char **),
364           void *pincb_arg,
365           const void *indata, size_t indatalen,
366           unsigned char **outdata, size_t *outdatalen )
367 {
368   int rc;
369
370   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
371     return gpg_error (GPG_ERR_INV_VALUE);
372   if (!app->initialized)
373     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
374   if (!app->fnc.sign)
375     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
376   rc = app->fnc.sign (app, keyidstr, hashalgo,
377                       pincb, pincb_arg,
378                       indata, indatalen,
379                       outdata, outdatalen);
380   if (opt.verbose)
381     log_info ("operation sign result: %s\n", gpg_strerror (rc));
382   return rc;
383 }
384
385 /* Create the signature using the INTERNAL AUTHENTICATE command and
386    return the allocated result in OUTDATA.  If a PIN is required the
387    PINCB will be used to ask for the PIN; it should return the PIN in
388    an allocated buffer and put it into PIN.  */
389 int 
390 app_auth (APP app, const char *keyidstr,
391           int (pincb)(void*, const char *, char **),
392           void *pincb_arg,
393           const void *indata, size_t indatalen,
394           unsigned char **outdata, size_t *outdatalen )
395 {
396   int rc;
397
398   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
399     return gpg_error (GPG_ERR_INV_VALUE);
400   if (!app->initialized)
401     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
402   if (!app->fnc.auth)
403     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
404   rc = app->fnc.auth (app, keyidstr,
405                       pincb, pincb_arg,
406                       indata, indatalen,
407                       outdata, outdatalen);
408   if (opt.verbose)
409     log_info ("operation auth result: %s\n", gpg_strerror (rc));
410   return rc;
411 }
412
413
414 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
415    If a PIN is required the PINCB will be used to ask for the PIN; it
416    should return the PIN in an allocated buffer and put it into PIN.  */
417 int 
418 app_decipher (APP app, const char *keyidstr,
419               int (pincb)(void*, const char *, char **),
420               void *pincb_arg,
421               const void *indata, size_t indatalen,
422               unsigned char **outdata, size_t *outdatalen )
423 {
424   int rc;
425
426   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
427     return gpg_error (GPG_ERR_INV_VALUE);
428   if (!app->initialized)
429     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
430   if (!app->fnc.decipher)
431     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
432   rc = app->fnc.decipher (app, keyidstr,
433                           pincb, pincb_arg,
434                           indata, indatalen,
435                           outdata, outdatalen);
436   if (opt.verbose)
437     log_info ("operation decipher result: %s\n", gpg_strerror (rc));
438   return rc;
439 }
440
441
442 /* Perform a SETATTR operation.  */
443 int 
444 app_genkey (APP app, CTRL ctrl, const char *keynostr, unsigned int flags,
445             int (*pincb)(void*, const char *, char **),
446             void *pincb_arg)
447 {
448   int rc;
449
450   if (!app || !keynostr || !*keynostr || !pincb)
451     return gpg_error (GPG_ERR_INV_VALUE);
452   if (!app->initialized)
453     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
454   if (!app->fnc.genkey)
455     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
456   rc = app->fnc.genkey (app, ctrl, keynostr, flags, pincb, pincb_arg);
457   if (opt.verbose)
458     log_info ("operation genkey result: %s\n", gpg_strerror (rc));
459   return rc;
460 }
461
462
463 /* Perform a GET CHALLENGE operation.  This fucntion is special as it
464    directly accesses the card without any application specific
465    wrapper. */
466 int
467 app_get_challenge (APP app, size_t nbytes, unsigned char *buffer)
468 {
469   if (!app || !nbytes || !buffer)
470     return gpg_error (GPG_ERR_INV_VALUE);
471   if (!app->initialized)
472     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
473   return iso7816_get_challenge (app->slot, nbytes, buffer);
474 }
475
476
477
478 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
479 int 
480 app_change_pin (APP app, CTRL ctrl, const char *chvnostr, int reset_mode,
481                 int (*pincb)(void*, const char *, char **),
482                 void *pincb_arg)
483 {
484   int rc;
485
486   if (!app || !chvnostr || !*chvnostr || !pincb)
487     return gpg_error (GPG_ERR_INV_VALUE);
488   if (!app->initialized)
489     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
490   if (!app->fnc.change_pin)
491     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
492   rc = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode, pincb, pincb_arg);
493   if (opt.verbose)
494     log_info ("operation change_pin result: %s\n", gpg_strerror (rc));
495   return rc;
496 }
497
498
499 /* Perform a VERIFY operation without doing anything lese.  This may
500    be used to initialze a the PION cache for long lasting other
501    operations.  Its use is highly application dependent. */
502 int 
503 app_check_pin (APP app, const char *keyidstr,
504                int (*pincb)(void*, const char *, char **),
505                void *pincb_arg)
506 {
507   int rc;
508
509   if (!app || !keyidstr || !*keyidstr || !pincb)
510     return gpg_error (GPG_ERR_INV_VALUE);
511   if (!app->initialized)
512     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
513   if (!app->fnc.check_pin)
514     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
515   rc = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
516   if (opt.verbose)
517     log_info ("operation check_pin result: %s\n", gpg_strerror (rc));
518   return rc;
519 }
520