55fb5861ebd6835beaf154f64f4b3046437ce414
[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 /* Perform a GETATTR operation.  */
267 int 
268 app_getattr (APP app, CTRL ctrl, const char *name)
269 {
270   if (!app || !name || !*name)
271     return gpg_error (GPG_ERR_INV_VALUE);
272   if (!app->initialized)
273     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
274   if (!app->fnc.getattr)
275     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
276   return app->fnc.getattr (app, ctrl, name);
277 }
278
279 /* Perform a SETATTR operation.  */
280 int 
281 app_setattr (APP app, const char *name,
282              int (*pincb)(void*, const char *, char **),
283              void *pincb_arg,
284              const unsigned char *value, size_t valuelen)
285 {
286   if (!app || !name || !*name || !value)
287     return gpg_error (GPG_ERR_INV_VALUE);
288   if (!app->initialized)
289     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
290   if (!app->fnc.setattr)
291     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
292   return app->fnc.setattr (app, name, pincb, pincb_arg, value, valuelen);
293 }
294
295 /* Create the signature and return the allocated result in OUTDATA.
296    If a PIN is required the PINCB will be used to ask for the PIN; it
297    should return the PIN in an allocated buffer and put it into PIN.  */
298 int 
299 app_sign (APP app, const char *keyidstr, int hashalgo,
300           int (pincb)(void*, const char *, char **),
301           void *pincb_arg,
302           const void *indata, size_t indatalen,
303           unsigned char **outdata, size_t *outdatalen )
304 {
305   int rc;
306
307   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
308     return gpg_error (GPG_ERR_INV_VALUE);
309   if (!app->initialized)
310     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
311   if (!app->fnc.sign)
312     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
313   rc = app->fnc.sign (app, keyidstr, hashalgo,
314                       pincb, pincb_arg,
315                       indata, indatalen,
316                       outdata, outdatalen);
317   if (opt.verbose)
318     log_info ("operation sign result: %s\n", gpg_strerror (rc));
319   return rc;
320 }
321
322 /* Create the signature using the INTERNAL AUTHENTICATE command and
323    return the allocated result in OUTDATA.  If a PIN is required the
324    PINCB will be used to ask for the PIN; it should return the PIN in
325    an allocated buffer and put it into PIN.  */
326 int 
327 app_auth (APP app, const char *keyidstr,
328           int (pincb)(void*, const char *, char **),
329           void *pincb_arg,
330           const void *indata, size_t indatalen,
331           unsigned char **outdata, size_t *outdatalen )
332 {
333   int rc;
334
335   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
336     return gpg_error (GPG_ERR_INV_VALUE);
337   if (!app->initialized)
338     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
339   if (!app->fnc.auth)
340     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
341   rc = app->fnc.auth (app, keyidstr,
342                       pincb, pincb_arg,
343                       indata, indatalen,
344                       outdata, outdatalen);
345   if (opt.verbose)
346     log_info ("operation auth result: %s\n", gpg_strerror (rc));
347   return rc;
348 }
349
350
351 /* Decrypt the data in INDATA and return the allocated result in OUTDATA.
352    If a PIN is required the PINCB will be used to ask for the PIN; it
353    should return the PIN in an allocated buffer and put it into PIN.  */
354 int 
355 app_decipher (APP app, const char *keyidstr,
356               int (pincb)(void*, const char *, char **),
357               void *pincb_arg,
358               const void *indata, size_t indatalen,
359               unsigned char **outdata, size_t *outdatalen )
360 {
361   int rc;
362
363   if (!app || !indata || !indatalen || !outdata || !outdatalen || !pincb)
364     return gpg_error (GPG_ERR_INV_VALUE);
365   if (!app->initialized)
366     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
367   if (!app->fnc.decipher)
368     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
369   rc = app->fnc.decipher (app, keyidstr,
370                           pincb, pincb_arg,
371                           indata, indatalen,
372                           outdata, outdatalen);
373   if (opt.verbose)
374     log_info ("operation decipher result: %s\n", gpg_strerror (rc));
375   return rc;
376 }
377
378
379 /* Perform a SETATTR operation.  */
380 int 
381 app_genkey (APP app, CTRL ctrl, const char *keynostr, unsigned int flags,
382             int (*pincb)(void*, const char *, char **),
383             void *pincb_arg)
384 {
385   int rc;
386
387   if (!app || !keynostr || !*keynostr || !pincb)
388     return gpg_error (GPG_ERR_INV_VALUE);
389   if (!app->initialized)
390     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
391   if (!app->fnc.genkey)
392     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
393   rc = app->fnc.genkey (app, ctrl, keynostr, flags, pincb, pincb_arg);
394   if (opt.verbose)
395     log_info ("operation genkey result: %s\n", gpg_strerror (rc));
396   return rc;
397 }
398
399
400 /* Perform a GET CHALLENGE operation.  This fucntion is special as it
401    directly accesses the card without any application specific
402    wrapper. */
403 int
404 app_get_challenge (APP app, size_t nbytes, unsigned char *buffer)
405 {
406   if (!app || !nbytes || !buffer)
407     return gpg_error (GPG_ERR_INV_VALUE);
408   if (!app->initialized)
409     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
410   return iso7816_get_challenge (app->slot, nbytes, buffer);
411 }
412
413
414
415 /* Perform a CHANGE REFERENCE DATA or RESET RETRY COUNTER operation.  */
416 int 
417 app_change_pin (APP app, CTRL ctrl, const char *chvnostr, int reset_mode,
418                 int (*pincb)(void*, const char *, char **),
419                 void *pincb_arg)
420 {
421   int rc;
422
423   if (!app || !chvnostr || !*chvnostr || !pincb)
424     return gpg_error (GPG_ERR_INV_VALUE);
425   if (!app->initialized)
426     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
427   if (!app->fnc.change_pin)
428     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
429   rc = app->fnc.change_pin (app, ctrl, chvnostr, reset_mode, pincb, pincb_arg);
430   if (opt.verbose)
431     log_info ("operation change_pin result: %s\n", gpg_strerror (rc));
432   return rc;
433 }
434
435
436 /* Perform a VERIFY operation without doing anything lese.  This may
437    be used to initialze a the PION cache for long lasting other
438    operations.  Its use is highly application dependent. */
439 int 
440 app_check_pin (APP app, const char *keyidstr,
441                int (*pincb)(void*, const char *, char **),
442                void *pincb_arg)
443 {
444   int rc;
445
446   if (!app || !keyidstr || !*keyidstr || !pincb)
447     return gpg_error (GPG_ERR_INV_VALUE);
448   if (!app->initialized)
449     return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
450   if (!app->fnc.check_pin)
451     return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
452   rc = app->fnc.check_pin (app, keyidstr, pincb, pincb_arg);
453   if (opt.verbose)
454     log_info ("operation check_pin result: %s\n", gpg_strerror (rc));
455   return rc;
456 }
457