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