scd:piv: Allow writecert to only write matching certs.
[gnupg.git] / scd / iso7816.c
1 /* iso7816.c - ISO 7816 commands
2  * Copyright (C) 2003, 2004, 2008, 2009 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
26 #if defined(GNUPG_SCD_MAIN_HEADER)
27 #include GNUPG_SCD_MAIN_HEADER
28 #elif GNUPG_MAJOR_VERSION == 1
29 /* This is used with GnuPG version < 1.9.  The code has been source
30    copied from the current GnuPG >= 1.9  and is maintained over
31    there. */
32 #include "options.h"
33 #include "errors.h"
34 #include "memory.h"
35 #include "../common/util.h"
36 #include "../common/i18n.h"
37 #else /* GNUPG_MAJOR_VERSION != 1 */
38 #include "scdaemon.h"
39 #endif /* GNUPG_MAJOR_VERSION != 1 */
40
41 #include "iso7816.h"
42 #include "apdu.h"
43
44
45 #define CMD_SELECT_FILE 0xA4
46 #define CMD_VERIFY                ISO7816_VERIFY
47 #define CMD_CHANGE_REFERENCE_DATA ISO7816_CHANGE_REFERENCE_DATA
48 #define CMD_RESET_RETRY_COUNTER   ISO7816_RESET_RETRY_COUNTER
49 #define CMD_GET_DATA    0xCA
50 #define CMD_PUT_DATA    0xDA
51 #define CMD_MSE         0x22
52 #define CMD_PSO         0x2A
53 #define CMD_GENERAL_AUTHENTICATE  0x87
54 #define CMD_INTERNAL_AUTHENTICATE 0x88
55 #define CMD_GENERATE_KEYPAIR      0x47
56 #define CMD_GET_CHALLENGE         0x84
57 #define CMD_READ_BINARY 0xB0
58 #define CMD_READ_RECORD 0xB2
59
60 static gpg_error_t
61 map_sw (int sw)
62 {
63   gpg_err_code_t ec;
64
65   switch (sw)
66     {
67     case SW_EEPROM_FAILURE: ec = GPG_ERR_HARDWARE; break;
68     case SW_TERM_STATE:     ec = GPG_ERR_OBJ_TERM_STATE; break;
69     case SW_WRONG_LENGTH:   ec = GPG_ERR_INV_VALUE; break;
70     case SW_ACK_TIMEOUT:    ec = GPG_ERR_TIMEOUT; break;
71     case SW_SM_NOT_SUP:     ec = GPG_ERR_NOT_SUPPORTED; break;
72     case SW_CC_NOT_SUP:     ec = GPG_ERR_NOT_SUPPORTED; break;
73     case SW_CHV_WRONG:      ec = GPG_ERR_BAD_PIN; break;
74     case SW_CHV_BLOCKED:    ec = GPG_ERR_PIN_BLOCKED; break;
75     case SW_USE_CONDITIONS: ec = GPG_ERR_USE_CONDITIONS; break;
76     case SW_NOT_SUPPORTED:  ec = GPG_ERR_NOT_SUPPORTED; break;
77     case SW_BAD_PARAMETER:  ec = GPG_ERR_INV_VALUE; break;
78     case SW_FILE_NOT_FOUND: ec = GPG_ERR_ENOENT; break;
79     case SW_RECORD_NOT_FOUND:ec= GPG_ERR_NOT_FOUND; break;
80     case SW_REF_NOT_FOUND:  ec = GPG_ERR_NO_OBJ; break;
81     case SW_BAD_P0_P1:      ec = GPG_ERR_INV_VALUE; break;
82     case SW_EXACT_LENGTH:   ec = GPG_ERR_INV_VALUE; break;
83     case SW_INS_NOT_SUP:    ec = GPG_ERR_CARD; break;
84     case SW_CLA_NOT_SUP:    ec = GPG_ERR_CARD; break;
85     case SW_SUCCESS:        ec = 0; break;
86
87     case SW_HOST_OUT_OF_CORE: ec = GPG_ERR_ENOMEM; break;
88     case SW_HOST_INV_VALUE:   ec = GPG_ERR_INV_VALUE; break;
89     case SW_HOST_INCOMPLETE_CARD_RESPONSE: ec = GPG_ERR_CARD; break;
90     case SW_HOST_NOT_SUPPORTED: ec = GPG_ERR_NOT_SUPPORTED; break;
91     case SW_HOST_LOCKING_FAILED: ec = GPG_ERR_BUG; break;
92     case SW_HOST_BUSY:           ec = GPG_ERR_EBUSY; break;
93     case SW_HOST_NO_CARD:        ec = GPG_ERR_CARD_NOT_PRESENT; break;
94     case SW_HOST_CARD_INACTIVE:  ec = GPG_ERR_CARD_RESET; break;
95     case SW_HOST_CARD_IO_ERROR:  ec = GPG_ERR_EIO; break;
96     case SW_HOST_GENERAL_ERROR:  ec = GPG_ERR_GENERAL; break;
97     case SW_HOST_NO_READER:      ec = GPG_ERR_ENODEV; break;
98     case SW_HOST_ABORTED:        ec = GPG_ERR_INV_RESPONSE; break;
99     case SW_HOST_NO_PINPAD:      ec = GPG_ERR_NOT_SUPPORTED; break;
100     case SW_HOST_CANCELLED:      ec = GPG_ERR_CANCELED; break;
101
102     default:
103       if ((sw & 0x010000))
104         ec = GPG_ERR_GENERAL; /* Should not happen. */
105       else if ((sw & 0xff00) == SW_MORE_DATA)
106         ec = 0; /* This should actually never been seen here. */
107       else
108         ec = GPG_ERR_CARD;
109     }
110   return gpg_error (ec);
111 }
112
113 /* Map a status word from the APDU layer to a gpg-error code.  */
114 gpg_error_t
115 iso7816_map_sw (int sw)
116 {
117   /* All APDU functions should return 0x9000 on success but for
118      historical reasons of the implementation some return 0 to
119      indicate success.  We allow for that here. */
120   return sw? map_sw (sw) : 0;
121 }
122
123
124 /* This function is specialized version of the SELECT FILE command.
125    SLOT is the card and reader as created for example by
126    apdu_open_reader (), AID is a buffer of size AIDLEN holding the
127    requested application ID.  The function can't be used to enumerate
128    AIDs and won't return the AID on success.  The return value is 0
129    for okay or a GPG error code.  Note that ISO error codes are
130    internally mapped.  Bit 0 of FLAGS should be set if the card does
131    not understand P2=0xC0. */
132 gpg_error_t
133 iso7816_select_application (int slot, const char *aid, size_t aidlen,
134                             unsigned int flags)
135 {
136   int sw;
137   sw = apdu_send_simple (slot, 0, 0x00, CMD_SELECT_FILE, 4,
138                          (flags&1)? 0 :0x0c, aidlen, aid);
139   return map_sw (sw);
140 }
141
142
143 /* This is the same as iso7816_select_application but may return data
144  * at RESULT,RESULTLEN).  */
145 gpg_error_t
146 iso7816_select_application_ext (int slot, const char *aid, size_t aidlen,
147                                 unsigned int flags,
148                                 unsigned char **result, size_t *resultlen)
149 {
150   int sw;
151   sw = apdu_send (slot, 0, 0x00, CMD_SELECT_FILE, 4,
152                   (flags&1)? 0:0x0c, aidlen, aid,
153                   result, resultlen);
154   return map_sw (sw);
155 }
156
157
158 gpg_error_t
159 iso7816_select_file (int slot, int tag, int is_dir)
160 {
161   int sw, p0, p1;
162   unsigned char tagbuf[2];
163
164   tagbuf[0] = (tag >> 8) & 0xff;
165   tagbuf[1] = tag & 0xff;
166
167   p0 = (tag == 0x3F00)? 0: is_dir? 1:2;
168   p1 = 0x0c; /* No FC return. */
169   sw = apdu_send_simple (slot, 0, 0x00, CMD_SELECT_FILE,
170                          p0, p1, 2, (char*)tagbuf );
171   return map_sw (sw);
172 }
173
174
175 /* Do a select file command with a direct path. */
176 gpg_error_t
177 iso7816_select_path (int slot, const unsigned short *path, size_t pathlen)
178 {
179   int sw, p0, p1;
180   unsigned char buffer[100];
181   int buflen;
182
183   if (pathlen/2 >= sizeof buffer)
184     return gpg_error (GPG_ERR_TOO_LARGE);
185
186   for (buflen = 0; pathlen; pathlen--, path++)
187     {
188       buffer[buflen++] = (*path >> 8);
189       buffer[buflen++] = *path;
190     }
191
192   p0 = 0x08;
193   p1 = 0x0c; /* No FC return. */
194   sw = apdu_send_simple (slot, 0, 0x00, CMD_SELECT_FILE,
195                          p0, p1, buflen, (char*)buffer );
196   return map_sw (sw);
197 }
198
199
200 /* This is a private command currently only working for TCOS cards. */
201 gpg_error_t
202 iso7816_list_directory (int slot, int list_dirs,
203                         unsigned char **result, size_t *resultlen)
204 {
205   int sw;
206
207   if (!result || !resultlen)
208     return gpg_error (GPG_ERR_INV_VALUE);
209   *result = NULL;
210   *resultlen = 0;
211
212   sw = apdu_send (slot, 0, 0x80, 0xAA, list_dirs? 1:2, 0, -1, NULL,
213                   result, resultlen);
214   if (sw != SW_SUCCESS)
215     {
216       /* Make sure that pending buffers are released. */
217       xfree (*result);
218       *result = NULL;
219       *resultlen = 0;
220     }
221   return map_sw (sw);
222 }
223
224
225 /* This function sends an already formatted APDU to the card.  With
226    HANDLE_MORE set to true a MORE DATA status will be handled
227    internally.  The return value is a gpg error code (i.e. a mapped
228    status word).  This is basically the same as apdu_send_direct but
229    it maps the status word and does not return it in the result
230    buffer.  However, it R_SW is not NULL the status word is stored
231    R_SW for closer inspection. */
232 gpg_error_t
233 iso7816_apdu_direct (int slot, const void *apdudata, size_t apdudatalen,
234                      int handle_more, unsigned int *r_sw,
235                      unsigned char **result, size_t *resultlen)
236 {
237   int sw, sw2;
238
239   if (result)
240     {
241       *result = NULL;
242       *resultlen = 0;
243     }
244
245   sw = apdu_send_direct (slot, 0, apdudata, apdudatalen, handle_more,
246                          &sw2, result, resultlen);
247   if (!sw)
248     {
249       if (!result)
250         sw = sw2;
251       else if (*resultlen < 2)
252         sw = SW_HOST_GENERAL_ERROR;
253       else
254         {
255           sw = ((*result)[*resultlen-2] << 8) | (*result)[*resultlen-1];
256           (*resultlen)--;
257           (*resultlen)--;
258         }
259     }
260   if (sw != SW_SUCCESS && result)
261     {
262       /* Make sure that pending buffers are released. */
263       xfree (*result);
264       *result = NULL;
265       *resultlen = 0;
266     }
267   if (r_sw)
268     *r_sw = sw;
269   return map_sw (sw);
270 }
271
272
273 /* Check whether the reader supports the ISO command code COMMAND on
274    the pinpad.  Returns 0 on success.  */
275 gpg_error_t
276 iso7816_check_pinpad (int slot, int command, pininfo_t *pininfo)
277 {
278   int sw;
279
280   sw = apdu_check_pinpad (slot, command, pininfo);
281   return iso7816_map_sw (sw);
282 }
283
284
285 /* Perform a VERIFY command on SLOT using the card holder verification
286    vector CHVNO.  With PININFO non-NULL the pinpad of the reader will
287    be used.  Returns 0 on success. */
288 gpg_error_t
289 iso7816_verify_kp (int slot, int chvno, pininfo_t *pininfo)
290 {
291   int sw;
292
293   sw = apdu_pinpad_verify (slot, 0x00, CMD_VERIFY, 0, chvno, pininfo);
294   return map_sw (sw);
295 }
296
297 /* Perform a VERIFY command on SLOT using the card holder verification
298    vector CHVNO with a CHV of length CHVLEN.  Returns 0 on success. */
299 gpg_error_t
300 iso7816_verify (int slot, int chvno, const char *chv, size_t chvlen)
301 {
302   int sw;
303
304   sw = apdu_send_simple (slot, 0, 0x00, CMD_VERIFY, 0, chvno, chvlen, chv);
305   return map_sw (sw);
306 }
307
308 /* Perform a CHANGE_REFERENCE_DATA command on SLOT for the card holder
309    verification vector CHVNO.  With PININFO non-NULL the pinpad of the
310    reader will be used.  If IS_EXCHANGE is 0, a "change reference
311    data" is done, otherwise an "exchange reference data".  */
312 gpg_error_t
313 iso7816_change_reference_data_kp (int slot, int chvno, int is_exchange,
314                                   pininfo_t *pininfo)
315 {
316   int sw;
317
318   sw = apdu_pinpad_modify (slot, 0x00, CMD_CHANGE_REFERENCE_DATA,
319                            is_exchange ? 1 : 0, chvno, pininfo);
320   return map_sw (sw);
321 }
322
323 /* Perform a CHANGE_REFERENCE_DATA command on SLOT for the card holder
324    verification vector CHVNO.  If the OLDCHV is NULL (and OLDCHVLEN
325    0), a "change reference data" is done, otherwise an "exchange
326    reference data".  The new reference data is expected in NEWCHV of
327    length NEWCHVLEN.  */
328 gpg_error_t
329 iso7816_change_reference_data (int slot, int chvno,
330                                const char *oldchv, size_t oldchvlen,
331                                const char *newchv, size_t newchvlen)
332 {
333   int sw;
334   char *buf;
335
336   if ((!oldchv && oldchvlen)
337       || (oldchv && !oldchvlen)
338       || !newchv || !newchvlen )
339     return gpg_error (GPG_ERR_INV_VALUE);
340
341   buf = xtrymalloc (oldchvlen + newchvlen);
342   if (!buf)
343     return gpg_error (gpg_err_code_from_errno (errno));
344   if (oldchvlen)
345     memcpy (buf, oldchv, oldchvlen);
346   memcpy (buf+oldchvlen, newchv, newchvlen);
347
348   sw = apdu_send_simple (slot, 0, 0x00, CMD_CHANGE_REFERENCE_DATA,
349                          oldchvlen? 0 : 1, chvno, oldchvlen+newchvlen, buf);
350   wipememory (buf, oldchvlen+newchvlen);
351   xfree (buf);
352   return map_sw (sw);
353
354 }
355
356
357 gpg_error_t
358 iso7816_reset_retry_counter_with_rc (int slot, int chvno,
359                                      const char *data, size_t datalen)
360 {
361   int sw;
362
363   if (!data || !datalen )
364     return gpg_error (GPG_ERR_INV_VALUE);
365
366   sw = apdu_send_simple (slot, 0, 0x00, CMD_RESET_RETRY_COUNTER,
367                          0, chvno, datalen, data);
368   return map_sw (sw);
369 }
370
371
372 gpg_error_t
373 iso7816_reset_retry_counter (int slot, int chvno,
374                              const char *newchv, size_t newchvlen)
375 {
376   int sw;
377
378   sw = apdu_send_simple (slot, 0, 0x00, CMD_RESET_RETRY_COUNTER,
379                          2, chvno, newchvlen, newchv);
380   return map_sw (sw);
381 }
382
383
384
385 /* Perform a GET DATA command requesting TAG and storing the result in
386    a newly allocated buffer at the address passed by RESULT.  Return
387    the length of this data at the address of RESULTLEN. */
388 gpg_error_t
389 iso7816_get_data (int slot, int extended_mode, int tag,
390                   unsigned char **result, size_t *resultlen)
391 {
392   int sw;
393   int le;
394
395   if (!result || !resultlen)
396     return gpg_error (GPG_ERR_INV_VALUE);
397   *result = NULL;
398   *resultlen = 0;
399
400   if (extended_mode > 0 && extended_mode < 256)
401     le = 65534; /* Not 65535 in case it is used as some special flag.  */
402   else if (extended_mode > 0)
403     le = extended_mode;
404   else
405     le = 256;
406
407   sw = apdu_send_le (slot, extended_mode, 0x00, CMD_GET_DATA,
408                      ((tag >> 8) & 0xff), (tag & 0xff), -1, NULL, le,
409                      result, resultlen);
410   if (sw != SW_SUCCESS)
411     {
412       /* Make sure that pending buffers are released. */
413       xfree (*result);
414       *result = NULL;
415       *resultlen = 0;
416       return map_sw (sw);
417     }
418
419   return 0;
420 }
421
422
423 /* Perform a GET DATA command requesting TAG and storing the result in
424  * a newly allocated buffer at the address passed by RESULT.  Return
425  * the length of this data at the address of RESULTLEN.  This variant
426  * is needed for long (3 octet) tags. */
427 gpg_error_t
428 iso7816_get_data_odd (int slot, int extended_mode, unsigned int tag,
429                       unsigned char **result, size_t *resultlen)
430 {
431   int sw;
432   int le;
433   int datalen;
434   unsigned char data[5];
435
436   if (!result || !resultlen)
437     return gpg_error (GPG_ERR_INV_VALUE);
438   *result = NULL;
439   *resultlen = 0;
440
441   if (extended_mode > 0 && extended_mode < 256)
442     le = 65534; /* Not 65535 in case it is used as some special flag.  */
443   else if (extended_mode > 0)
444     le = extended_mode;
445   else
446     le = 256;
447
448   data[0] = 0x5c;
449   if (tag <= 0xff)
450     {
451       data[1] = 1;
452       data[2] = tag;
453       datalen = 3;
454     }
455   else if (tag <= 0xffff)
456     {
457       data[1] = 2;
458       data[2] = (tag >> 8);
459       data[3] = tag;
460       datalen = 4;
461     }
462   else
463     {
464       data[1] = 3;
465       data[2] = (tag >> 16);
466       data[3] = (tag >> 8);
467       data[4] = tag;
468       datalen = 5;
469     }
470
471   sw = apdu_send_le (slot, extended_mode, 0x00, CMD_GET_DATA + 1,
472                      0x3f, 0xff, datalen, data, le,
473                      result, resultlen);
474   if (sw != SW_SUCCESS)
475     {
476       /* Make sure that pending buffers are released. */
477       xfree (*result);
478       *result = NULL;
479       *resultlen = 0;
480       return map_sw (sw);
481     }
482
483   return 0;
484 }
485
486
487 /* Perform a PUT DATA command on card in SLOT.  Write DATA of length
488    DATALEN to TAG.  EXTENDED_MODE controls whether extended length
489    headers or command chaining is used instead of single length
490    bytes. */
491 gpg_error_t
492 iso7816_put_data (int slot, int extended_mode, int tag,
493                   const void *data, size_t datalen)
494 {
495   int sw;
496
497   sw = apdu_send_simple (slot, extended_mode, 0x00, CMD_PUT_DATA,
498                          ((tag >> 8) & 0xff), (tag & 0xff),
499                          datalen, (const char*)data);
500   return map_sw (sw);
501 }
502
503 /* Same as iso7816_put_data but uses an odd instruction byte.  */
504 gpg_error_t
505 iso7816_put_data_odd (int slot, int extended_mode, int tag,
506                       const void *data, size_t datalen)
507 {
508   int sw;
509
510   sw = apdu_send_simple (slot, extended_mode, 0x00, CMD_PUT_DATA+1,
511                          ((tag >> 8) & 0xff), (tag & 0xff),
512                          datalen, (const char*)data);
513   return map_sw (sw);
514 }
515
516 /* Manage Security Environment.  This is a weird operation and there
517    is no easy abstraction for it.  Furthermore, some card seem to have
518    a different interpretation of 7816-8 and thus we resort to let the
519    caller decide what to do. */
520 gpg_error_t
521 iso7816_manage_security_env (int slot, int p1, int p2,
522                              const unsigned char *data, size_t datalen)
523 {
524   int sw;
525
526   if (p1 < 0 || p1 > 255 || p2 < 0 || p2 > 255 )
527     return gpg_error (GPG_ERR_INV_VALUE);
528
529   sw = apdu_send_simple (slot, 0, 0x00, CMD_MSE, p1, p2,
530                          data? datalen : -1, (const char*)data);
531   return map_sw (sw);
532 }
533
534
535 /* Perform the security operation COMPUTE DIGITAL SIGANTURE.  On
536    success 0 is returned and the data is available in a newly
537    allocated buffer stored at RESULT with its length stored at
538    RESULTLEN.  For LE see do_generate_keypair. */
539 gpg_error_t
540 iso7816_compute_ds (int slot, int extended_mode,
541                     const unsigned char *data, size_t datalen, int le,
542                     unsigned char **result, size_t *resultlen)
543 {
544   int sw;
545
546   if (!data || !datalen || !result || !resultlen)
547     return gpg_error (GPG_ERR_INV_VALUE);
548   *result = NULL;
549   *resultlen = 0;
550
551   if (!extended_mode)
552     le = 256;  /* Ignore provided Le and use what apdu_send uses. */
553   else if (le >= 0 && le < 256)
554     le = 256;
555
556   sw = apdu_send_le (slot, extended_mode,
557                      0x00, CMD_PSO, 0x9E, 0x9A,
558                      datalen, (const char*)data,
559                      le,
560                      result, resultlen);
561   if (sw != SW_SUCCESS)
562     {
563       /* Make sure that pending buffers are released. */
564       xfree (*result);
565       *result = NULL;
566       *resultlen = 0;
567       return map_sw (sw);
568     }
569
570   return 0;
571 }
572
573
574 /* Perform the security operation DECIPHER.  PADIND is the padding
575    indicator to be used.  It should be 0 if no padding is required, a
576    value of -1 suppresses the padding byte.  On success 0 is returned
577    and the plaintext is available in a newly allocated buffer stored
578    at RESULT with its length stored at RESULTLEN.  For LE see
579    do_generate_keypair. */
580 gpg_error_t
581 iso7816_decipher (int slot, int extended_mode,
582                   const unsigned char *data, size_t datalen, int le,
583                   int padind, unsigned char **result, size_t *resultlen)
584 {
585   int sw;
586   unsigned char *buf;
587
588   if (!data || !datalen || !result || !resultlen)
589     return gpg_error (GPG_ERR_INV_VALUE);
590   *result = NULL;
591   *resultlen = 0;
592
593   if (!extended_mode)
594     le = 256;  /* Ignore provided Le and use what apdu_send uses. */
595   else if (le >= 0 && le < 256)
596     le = 256;
597
598   if (padind >= 0)
599     {
600       /* We need to prepend the padding indicator. */
601       buf = xtrymalloc (datalen + 1);
602       if (!buf)
603         return gpg_error (gpg_err_code_from_errno (errno));
604
605       *buf = padind; /* Padding indicator. */
606       memcpy (buf+1, data, datalen);
607       sw = apdu_send_le (slot, extended_mode,
608                          0x00, CMD_PSO, 0x80, 0x86,
609                          datalen+1, (char*)buf, le,
610                          result, resultlen);
611       xfree (buf);
612     }
613   else
614     {
615       sw = apdu_send_le (slot, extended_mode,
616                          0x00, CMD_PSO, 0x80, 0x86,
617                          datalen, (const char *)data, le,
618                          result, resultlen);
619     }
620   if (sw != SW_SUCCESS)
621     {
622       /* Make sure that pending buffers are released. */
623       xfree (*result);
624       *result = NULL;
625       *resultlen = 0;
626       return map_sw (sw);
627     }
628
629   return 0;
630 }
631
632
633 /* For LE see do_generate_keypair.  */
634 gpg_error_t
635 iso7816_internal_authenticate (int slot, int extended_mode,
636                                const unsigned char *data, size_t datalen,
637                                int le,
638                                unsigned char **result, size_t *resultlen)
639 {
640   int sw;
641
642   if (!data || !datalen || !result || !resultlen)
643     return gpg_error (GPG_ERR_INV_VALUE);
644   *result = NULL;
645   *resultlen = 0;
646
647   if (!extended_mode)
648     le = 256;  /* Ignore provided Le and use what apdu_send uses. */
649   else if (le >= 0 && le < 256)
650     le = 256;
651
652   sw = apdu_send_le (slot, extended_mode,
653                      0x00, CMD_INTERNAL_AUTHENTICATE, 0, 0,
654                      datalen, (const char*)data,
655                      le,
656                      result, resultlen);
657   if (sw != SW_SUCCESS)
658     {
659       /* Make sure that pending buffers are released. */
660       xfree (*result);
661       *result = NULL;
662       *resultlen = 0;
663       return map_sw (sw);
664     }
665
666   return 0;
667 }
668
669
670 /* For LE see do_generate_keypair.  */
671 gpg_error_t
672 iso7816_general_authenticate (int slot, int extended_mode,
673                               int algoref, int keyref,
674                               const unsigned char *data, size_t datalen,
675                               int le,
676                               unsigned char **result, size_t *resultlen)
677 {
678   int sw;
679
680   if (!data || !datalen || !result || !resultlen)
681     return gpg_error (GPG_ERR_INV_VALUE);
682   *result = NULL;
683   *resultlen = 0;
684
685   if (!extended_mode)
686     le = 256;  /* Ignore provided Le and use what apdu_send uses. */
687   else if (le >= 0 && le < 256)
688     le = 256;
689
690   sw = apdu_send_le (slot, extended_mode,
691                      0x00, CMD_GENERAL_AUTHENTICATE, algoref, keyref,
692                      datalen, (const char*)data,
693                      le,
694                      result, resultlen);
695   if (sw != SW_SUCCESS)
696     {
697       /* Make sure that pending buffers are released. */
698       xfree (*result);
699       *result = NULL;
700       *resultlen = 0;
701       return map_sw (sw);
702     }
703
704   return 0;
705 }
706
707
708 /* LE is the expected return length.  This is usually 0 except if
709    extended length mode is used and more than 256 byte will be
710    returned.  In that case a value of -1 uses a large default
711    (e.g. 4096 bytes), a value larger 256 used that value.  */
712 static gpg_error_t
713 do_generate_keypair (int slot, int extended_mode, int p1, int p2,
714                      const char *data, size_t datalen, int le,
715                      unsigned char **result, size_t *resultlen)
716 {
717   int sw;
718
719   if (!data || !datalen || !result || !resultlen)
720     return gpg_error (GPG_ERR_INV_VALUE);
721   *result = NULL;
722   *resultlen = 0;
723
724   sw = apdu_send_le (slot, extended_mode,
725                      0x00, CMD_GENERATE_KEYPAIR, p1, p2,
726                      datalen, data,
727                      le >= 0 && le < 256? 256:le,
728                      result, resultlen);
729   if (sw != SW_SUCCESS)
730     {
731       /* Make sure that pending buffers are released. */
732       xfree (*result);
733       *result = NULL;
734       *resultlen = 0;
735       return map_sw (sw);
736     }
737
738   return 0;
739 }
740
741
742 gpg_error_t
743 iso7816_generate_keypair (int slot, int extended_mode, int p1, int p2,
744                           const char *data, size_t datalen,
745                           int le,
746                           unsigned char **result, size_t *resultlen)
747 {
748   return do_generate_keypair (slot, extended_mode, p1, p2,
749                               data, datalen, le, result, resultlen);
750 }
751
752
753 gpg_error_t
754 iso7816_read_public_key (int slot, int extended_mode,
755                          const char *data, size_t datalen,
756                          int le,
757                          unsigned char **result, size_t *resultlen)
758 {
759   return do_generate_keypair (slot, extended_mode, 0x81, 0,
760                               data, datalen, le, result, resultlen);
761 }
762
763
764
765 gpg_error_t
766 iso7816_get_challenge (int slot, int length, unsigned char *buffer)
767 {
768   int sw;
769   unsigned char *result;
770   size_t resultlen, n;
771
772   if (!buffer || length < 1)
773     return gpg_error (GPG_ERR_INV_VALUE);
774
775   do
776     {
777       result = NULL;
778       n = length > 254? 254 : length;
779       sw = apdu_send_le (slot, 0,
780                          0x00, CMD_GET_CHALLENGE, 0, 0, -1, NULL, n,
781                          &result, &resultlen);
782       if (sw != SW_SUCCESS)
783         {
784           /* Make sure that pending buffers are released. */
785           xfree (result);
786           return map_sw (sw);
787         }
788       if (resultlen > n)
789         resultlen = n;
790       memcpy (buffer, result, resultlen);
791       buffer += resultlen;
792       length -= resultlen;
793       xfree (result);
794     }
795   while (length > 0);
796
797   return 0;
798 }
799
800 /* Perform a READ BINARY command requesting a maximum of NMAX bytes
801    from OFFSET.  With NMAX = 0 the entire file is read. The result is
802    stored in a newly allocated buffer at the address passed by RESULT.
803    Returns the length of this data at the address of RESULTLEN. */
804 gpg_error_t
805 iso7816_read_binary (int slot, size_t offset, size_t nmax,
806                      unsigned char **result, size_t *resultlen)
807 {
808   int sw;
809   unsigned char *buffer;
810   size_t bufferlen;
811   int read_all = !nmax;
812   size_t n;
813
814   if (!result || !resultlen)
815     return gpg_error (GPG_ERR_INV_VALUE);
816   *result = NULL;
817   *resultlen = 0;
818
819   /* We can only encode 15 bits in p0,p1 to indicate an offset. Thus
820      we check for this limit. */
821   if (offset > 32767)
822     return gpg_error (GPG_ERR_INV_VALUE);
823
824   do
825     {
826       buffer = NULL;
827       bufferlen = 0;
828       n = read_all? 0 : nmax;
829       sw = apdu_send_le (slot, 0, 0x00, CMD_READ_BINARY,
830                          ((offset>>8) & 0xff), (offset & 0xff) , -1, NULL,
831                          n, &buffer, &bufferlen);
832       if ( SW_EXACT_LENGTH_P(sw) )
833         {
834           n = (sw & 0x00ff);
835           sw = apdu_send_le (slot, 0, 0x00, CMD_READ_BINARY,
836                              ((offset>>8) & 0xff), (offset & 0xff) , -1, NULL,
837                              n, &buffer, &bufferlen);
838         }
839
840       if (*result && sw == SW_BAD_P0_P1)
841         {
842           /* Bad Parameter means that the offset is outside of the
843              EF. When reading all data we take this as an indication
844              for EOF.  */
845           break;
846         }
847
848       if (sw != SW_SUCCESS && sw != SW_EOF_REACHED)
849         {
850           /* Make sure that pending buffers are released. */
851           xfree (buffer);
852           xfree (*result);
853           *result = NULL;
854           *resultlen = 0;
855           return map_sw (sw);
856         }
857       if (*result) /* Need to extend the buffer. */
858         {
859           unsigned char *p = xtryrealloc (*result, *resultlen + bufferlen);
860           if (!p)
861             {
862               gpg_error_t err = gpg_error_from_syserror ();
863               xfree (buffer);
864               xfree (*result);
865               *result = NULL;
866               *resultlen = 0;
867               return err;
868             }
869           *result = p;
870           memcpy (*result + *resultlen, buffer, bufferlen);
871           *resultlen += bufferlen;
872           xfree (buffer);
873           buffer = NULL;
874         }
875       else /* Transfer the buffer into our result. */
876         {
877           *result = buffer;
878           *resultlen = bufferlen;
879         }
880       offset += bufferlen;
881       if (offset > 32767)
882         break; /* We simply truncate the result for too large
883                   files. */
884       if (nmax > bufferlen)
885         nmax -= bufferlen;
886       else
887         nmax = 0;
888     }
889   while ((read_all && sw != SW_EOF_REACHED) || (!read_all && nmax));
890
891   return 0;
892 }
893
894 /* Perform a READ RECORD command. RECNO gives the record number to
895    read with 0 indicating the current record.  RECCOUNT must be 1 (not
896    all cards support reading of more than one record).  SHORT_EF
897    should be 0 to read the current EF or contain a short EF. The
898    result is stored in a newly allocated buffer at the address passed
899    by RESULT.  Returns the length of this data at the address of
900    RESULTLEN. */
901 gpg_error_t
902 iso7816_read_record (int slot, int recno, int reccount, int short_ef,
903                      unsigned char **result, size_t *resultlen)
904 {
905   int sw;
906   unsigned char *buffer;
907   size_t bufferlen;
908
909   if (!result || !resultlen)
910     return gpg_error (GPG_ERR_INV_VALUE);
911   *result = NULL;
912   *resultlen = 0;
913
914   /* We can only encode 15 bits in p0,p1 to indicate an offset. Thus
915      we check for this limit. */
916   if (recno < 0 || recno > 255 || reccount != 1
917       || short_ef < 0 || short_ef > 254 )
918     return gpg_error (GPG_ERR_INV_VALUE);
919
920   buffer = NULL;
921   bufferlen = 0;
922   sw = apdu_send_le (slot, 0, 0x00, CMD_READ_RECORD,
923                      recno,
924                      short_ef? short_ef : 0x04,
925                      -1, NULL,
926                      0, &buffer, &bufferlen);
927
928   if (sw != SW_SUCCESS && sw != SW_EOF_REACHED)
929     {
930       /* Make sure that pending buffers are released. */
931       xfree (buffer);
932       xfree (*result);
933       *result = NULL;
934       *resultlen = 0;
935       return map_sw (sw);
936     }
937   *result = buffer;
938   *resultlen = bufferlen;
939
940   return 0;
941 }