* gpg-agent.c (handle_connections): Need to check for events if
[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   if (!app->fnc.getattr)
309     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
310   return app->fnc.getattr (app, ctrl, name);
311 }
312
313 /* Perform a SETATTR operation.  */
314 int 
315 app_setattr (APP app, const char *name,
316              int (*pincb)(void*, const char *, char **),
317              void *pincb_arg,
318              const unsigned char *value, size_t valuelen)
319 {
320   if (!app || !name || !*name || !value)
321     return gpg_error (GPG_ERR_INV_VALUE);
322   if (!app->initialized)
323     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
324   if (!app->fnc.setattr)
325     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
326   return app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
327 }
328
329 /* Create the signature and return the allocated result in OUTDATA.
330    If a PIN is required the PINCB will be used to ask for the PIN; it
331    should return the PIN in an allocated buffer and put it into PIN.  */
332 int 
333 app_sign (APP app, const char *keyidstr, int hashalgo,
334           int (pincb)(void*, const char *, char **),
335           void *pincb_arg,
336           const void *indata, size_t indatalen,
337           unsigned char **outdata, size_t *outdatalen )
338 {
339   int rc;
340
341   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
342     return gpg_error (GPG_ERR_INV_VALUE);
343   if (!app->initialized)
344     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
345   if (!app->fnc.sign)
346     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
347   rc = app->fnc.sign (app, keyidstr, hashalgo,
348                       pincb, pincb_arg,
349                       indata, indatalen,
350                       outdata, outdatalen);
351   if (opt.verbose)
352     log_info ("operation sign result: %s\n", gpg_strerror (rc));
353   return rc;
354 }
355
356 /* Create the signature using the INTERNAL AUTHENTICATE command and
357    return the allocated result in OUTDATA.  If a PIN is required the
358    PINCB will be used to ask for the PIN; it should return the PIN in
359    an allocated buffer and put it into PIN.  */
360 int 
361 app_auth (APP app, const char *keyidstr,
362           int (pincb)(void*, const char *, char **),
363           void *pincb_arg,
364           const void *indata, size_t indatalen,
365           unsigned char **outdata, size_t *outdatalen )
366 {
367   int rc;
368
369   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
370     return gpg_error (GPG_ERR_INV_VALUE);
371   if (!app->initialized)
372     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
373   if (!app->fnc.auth)
374     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
375   rc = app->fnc.auth (app, keyidstr,
376                       pincb, pincb_arg,
377                       indata, indatalen,
378                       outdata, outdatalen);
379   if (opt.verbose)
380     log_info ("operation auth result: %s\n", gpg_strerror (rc));
381   return rc;
382 }
383
384
385 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
386    If a PIN is required the PINCB will be used to ask for the PIN; it
387    should return the PIN in an allocated buffer and put it into PIN.  */
388 int 
389 app_decipher (APP app, const char *keyidstr,
390               int (pincb)(void*, const char *, char **),
391               void *pincb_arg,
392               const void *indata, size_t indatalen,
393               unsigned char **outdata, size_t *outdatalen )
394 {
395   int rc;
396
397   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
398     return gpg_error (GPG_ERR_INV_VALUE);
399   if (!app->initialized)
400     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
401   if (!app->fnc.decipher)
402     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
403   rc = app->fnc.decipher (app, keyidstr,
404                           pincb, pincb_arg,
405                           indata, indatalen,
406                           outdata, outdatalen);
407   if (opt.verbose)
408     log_info ("operation decipher result: %s\n", gpg_strerror (rc));
409   return rc;
410 }
411
412
413 /* Perform a SETATTR operation.  */
414 int 
415 app_genkey (APP app, CTRL ctrl, const char *keynostr, unsigned int flags,
416             int (*pincb)(void*, const char *, char **),
417             void *pincb_arg)
418 {
419   int rc;
420
421   if (!app || !keynostr || !*keynostr || !pincb)
422     return gpg_error (GPG_ERR_INV_VALUE);
423   if (!app->initialized)
424     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
425   if (!app->fnc.genkey)
426     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
427   rc = app->fnc.genkey (app, ctrl, keynostr, flags, pincb, pincb_arg);
428   if (opt.verbose)
429     log_info ("operation genkey result: %s\n", gpg_strerror (rc));
430   return rc;
431 }
432
433
434 /* Perform a GET CHALLENGE operation.  This fucntion is special as it
435    directly accesses the card without any application specific
436    wrapper. */
437 int
438 app_get_challenge (APP app, size_t nbytes, unsigned char *buffer)
439 {
440   if (!app || !nbytes || !buffer)
441     return gpg_error (GPG_ERR_INV_VALUE);
442   if (!app->initialized)
443     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
444   return iso7816_get_challenge (app->slot, nbytes, buffer);
445 }
446
447
448
449 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
450 int 
451 app_change_pin (APP app, CTRL ctrl, const char *chvnostr, int reset_mode,
452                 int (*pincb)(void*, const char *, char **),
453                 void *pincb_arg)
454 {
455   int rc;
456
457   if (!app || !chvnostr || !*chvnostr || !pincb)
458     return gpg_error (GPG_ERR_INV_VALUE);
459   if (!app->initialized)
460     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
461   if (!app->fnc.change_pin)
462     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
463   rc = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode, pincb, pincb_arg);
464   if (opt.verbose)
465     log_info ("operation change_pin result: %s\n", gpg_strerror (rc));
466   return rc;
467 }
468
469
470 /* Perform a VERIFY operation without doing anything lese.  This may
471    be used to initialze a the PION cache for long lasting other
472    operations.  Its use is highly application dependent. */
473 int 
474 app_check_pin (APP app, const char *keyidstr,
475                int (*pincb)(void*, const char *, char **),
476                void *pincb_arg)
477 {
478   int rc;
479
480   if (!app || !keyidstr || !*keyidstr || !pincb)
481     return gpg_error (GPG_ERR_INV_VALUE);
482   if (!app->initialized)
483     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
484   if (!app->fnc.check_pin)
485     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
486   rc = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
487   if (opt.verbose)
488     log_info ("operation check_pin result: %s\n", gpg_strerror (rc));
489   return rc;
490 }
491