gpg: Fix memory leak in parse_auto_key_locate.
[gnupg.git] / agent / divert-scd.c
1 /* divert-scd.c - divert operations to the scdaemon
2  *      Copyright (C) 2002, 2003, 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 #include <ctype.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #include <sys/stat.h>
29
30 #include "agent.h"
31 #include "../common/i18n.h"
32 #include "../common/sexp-parse.h"
33
34
35 static int
36 ask_for_card (ctrl_t ctrl, const unsigned char *shadow_info, char **r_kid)
37 {
38   int rc, i;
39   char *serialno;
40   int no_card = 0;
41   char *desc;
42   char *want_sn, *want_kid, *want_sn_disp;
43   int len;
44
45   *r_kid = NULL;
46
47   rc = parse_shadow_info (shadow_info, &want_sn, &want_kid, NULL);
48   if (rc)
49     return rc;
50   want_sn_disp = xtrystrdup (want_sn);
51   if (!want_sn_disp)
52     {
53       rc = gpg_error_from_syserror ();
54       xfree (want_sn);
55       xfree (want_kid);
56       return rc;
57     }
58
59   len = strlen (want_sn_disp);
60   if (len == 32 && !strncmp (want_sn_disp, "D27600012401", 12))
61     {
62       /* This is an OpenPGP card - reformat  */
63       memmove (want_sn_disp, want_sn_disp+16, 4);
64       want_sn_disp[4] = ' ';
65       memmove (want_sn_disp+5, want_sn_disp+20, 8);
66       want_sn_disp[13] = 0;
67     }
68   else if (len == 20 && want_sn_disp[19] == '0')
69     {
70       /* We assume that a 20 byte serial number is a standard one
71        * which has the property to have a zero in the last nibble (Due
72        * to BCD representation).  We don't display this '0' because it
73        * may confuse the user.  */
74       want_sn_disp[19] = 0;
75     }
76
77   for (;;)
78     {
79       rc = agent_card_serialno (ctrl, &serialno, want_sn);
80       if (!rc)
81         {
82           log_debug ("detected card with S/N %s\n", serialno);
83           i = strcmp (serialno, want_sn);
84           xfree (serialno);
85           serialno = NULL;
86           if (!i)
87             {
88               xfree (want_sn_disp);
89               xfree (want_sn);
90               *r_kid = want_kid;
91               return 0; /* yes, we have the correct card */
92             }
93         }
94       else if (gpg_err_code (rc) == GPG_ERR_ENODEV)
95         {
96           log_debug ("no device present\n");
97           rc = 0;
98           no_card = 1;
99         }
100       else if (gpg_err_code (rc) == GPG_ERR_CARD_NOT_PRESENT)
101         {
102           log_debug ("no card present\n");
103           rc = 0;
104           no_card = 2;
105         }
106       else
107         {
108           log_error ("error accessing card: %s\n", gpg_strerror (rc));
109         }
110
111       if (!rc)
112         {
113           if (asprintf (&desc,
114                     "%s:%%0A%%0A"
115                     "  %s",
116                         no_card
117                         ? L_("Please insert the card with serial number")
118                         : L_("Please remove the current card and "
119                              "insert the one with serial number"),
120                         want_sn_disp) < 0)
121             {
122               rc = out_of_core ();
123             }
124           else
125             {
126               rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
127               if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK &&
128                   gpg_err_code (rc) == GPG_ERR_NO_PIN_ENTRY)
129                 rc = gpg_error (GPG_ERR_CARD_NOT_PRESENT);
130
131               xfree (desc);
132             }
133         }
134       if (rc)
135         {
136           xfree (want_sn_disp);
137           xfree (want_sn);
138           xfree (want_kid);
139           return rc;
140         }
141     }
142 }
143
144
145 /* Put the DIGEST into an DER encoded container and return it in R_VAL. */
146 static int
147 encode_md_for_card (const unsigned char *digest, size_t digestlen, int algo,
148                     unsigned char **r_val, size_t *r_len)
149 {
150   unsigned char *frame;
151   unsigned char asn[100];
152   size_t asnlen;
153
154   *r_val = NULL;
155   *r_len = 0;
156
157   asnlen = DIM(asn);
158   if (!algo || gcry_md_test_algo (algo))
159     return gpg_error (GPG_ERR_DIGEST_ALGO);
160   if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
161     {
162       log_error ("no object identifier for algo %d\n", algo);
163       return gpg_error (GPG_ERR_INTERNAL);
164     }
165
166   frame = xtrymalloc (asnlen + digestlen);
167   if (!frame)
168     return out_of_core ();
169   memcpy (frame, asn, asnlen);
170   memcpy (frame+asnlen, digest, digestlen);
171   if (DBG_CRYPTO)
172     log_printhex ("encoded hash:", frame, asnlen+digestlen);
173
174   *r_val = frame;
175   *r_len = asnlen+digestlen;
176   return 0;
177 }
178
179
180 /* Return true if STRING ends in "%0A". */
181 static int
182 has_percent0A_suffix (const char *string)
183 {
184   size_t n;
185
186   return (string
187           && (n = strlen (string)) >= 3
188           && !strcmp (string + n - 3, "%0A"));
189 }
190
191
192 /* Callback used to ask for the PIN which should be set into BUF.  The
193    buf has been allocated by the caller and is of size MAXBUF which
194    includes the terminating null.  The function should return an UTF-8
195    string with the passphrase, the buffer may optionally be padded
196    with arbitrary characters.
197
198    If DESC_TEXT is not NULL it can be used as further informtion shown
199    atop of the INFO message.
200
201    INFO gets displayed as part of a generic string.  However if the
202    first character of INFO is a vertical bar all up to the next
203    verical bar are considered flags and only everything after the
204    second vertical bar gets displayed as the full prompt.
205
206    Flags:
207
208       'N' = New PIN, this requests a second prompt to repeat the
209             PIN.  If the PIN is not correctly repeated it starts from
210             all over.
211       'A' = The PIN is an Admin PIN, SO-PIN or alike.
212       'P' = The PIN is a PUK (Personal Unblocking Key).
213       'R' = The PIN is a Reset Code.
214
215    Example:
216
217      "|AN|Please enter the new security officer's PIN"
218
219    The text "Please ..." will get displayed and the flags 'A' and 'N'
220    are considered.
221  */
222 static int
223 getpin_cb (void *opaque, const char *desc_text, const char *info,
224            char *buf, size_t maxbuf)
225 {
226   struct pin_entry_info_s *pi;
227   int rc;
228   ctrl_t ctrl = opaque;
229   const char *ends, *s;
230   int any_flags = 0;
231   int newpin = 0;
232   int resetcode = 0;
233   int is_puk = 0;
234   const char *again_text = NULL;
235   const char *prompt = "PIN";
236
237   if (buf && maxbuf < 2)
238     return gpg_error (GPG_ERR_INV_VALUE);
239
240   /* Parse the flags. */
241   if (info && *info =='|' && (ends=strchr (info+1, '|')))
242     {
243       for (s=info+1; s < ends; s++)
244         {
245           if (*s == 'A')
246             prompt = L_("Admin PIN");
247           else if (*s == 'P')
248             {
249               /* TRANSLATORS: A PUK is the Personal Unblocking Code
250                  used to unblock a PIN. */
251               prompt = L_("PUK");
252               is_puk = 1;
253             }
254           else if (*s == 'N')
255             newpin = 1;
256           else if (*s == 'R')
257             {
258               prompt = L_("Reset Code");
259               resetcode = 1;
260             }
261         }
262       info = ends+1;
263       any_flags = 1;
264     }
265   else if (info && *info == '|')
266     log_debug ("pin_cb called without proper PIN info hack\n");
267
268   /* If BUF has been passed as NULL, we are in pinpad mode: The
269      callback opens the popup and immediately returns. */
270   if (!buf)
271     {
272       if (maxbuf == 0) /* Close the pinentry. */
273         {
274           agent_popup_message_stop (ctrl);
275           rc = 0;
276         }
277       else if (maxbuf == 1)  /* Open the pinentry. */
278         {
279           if (info)
280             {
281               char *desc, *desc2;
282
283               if ( asprintf (&desc,
284                              L_("%s%%0A%%0AUse the reader's pinpad for input."),
285                              info) < 0 )
286                 rc = gpg_error_from_syserror ();
287               else
288                 {
289                   /* Prepend DESC_TEXT to INFO.  */
290                   if (desc_text)
291                     desc2 = strconcat (desc_text,
292                                        has_percent0A_suffix (desc_text)
293                                        ? "%0A" : "%0A%0A",
294                                        desc, NULL);
295                   else
296                     desc2 = NULL;
297                   rc = agent_popup_message_start (ctrl,
298                                                   desc2? desc2:desc, NULL);
299                   xfree (desc2);
300                   xfree (desc);
301                 }
302             }
303           else
304             rc = agent_popup_message_start (ctrl, desc_text, NULL);
305         }
306       else
307         rc = gpg_error (GPG_ERR_INV_VALUE);
308       return rc;
309     }
310
311   /* FIXME: keep PI and TRIES in OPAQUE.  Frankly this is a whole
312      mess because we should call the card's verify function from the
313      pinentry check pin CB. */
314  again:
315   pi = gcry_calloc_secure (1, sizeof (*pi) + maxbuf + 10);
316   if (!pi)
317     return gpg_error_from_syserror ();
318   pi->max_length = maxbuf-1;
319   pi->min_digits = 0;  /* we want a real passphrase */
320   pi->max_digits = 16;
321   pi->max_tries = 3;
322
323   if (any_flags)
324     {
325       {
326         char *desc2;
327
328         if (desc_text)
329           desc2 = strconcat (desc_text,
330                              has_percent0A_suffix (desc_text)
331                              ? "%0A" : "%0A%0A",
332                              info, NULL);
333         else
334           desc2 = NULL;
335         rc = agent_askpin (ctrl, desc2? desc2 : info,
336                            prompt, again_text, pi, NULL, 0);
337         xfree (desc2);
338       }
339       again_text = NULL;
340       if (!rc && newpin)
341         {
342           struct pin_entry_info_s *pi2;
343           pi2 = gcry_calloc_secure (1, sizeof (*pi) + maxbuf + 10);
344           if (!pi2)
345             {
346               rc = gpg_error_from_syserror ();
347               xfree (pi);
348               return rc;
349             }
350           pi2->max_length = maxbuf-1;
351           pi2->min_digits = 0;
352           pi2->max_digits = 16;
353           pi2->max_tries = 1;
354           rc = agent_askpin (ctrl,
355                              (resetcode?
356                               L_("Repeat this Reset Code"):
357                               is_puk?
358                               L_("Repeat this PUK"):
359                               L_("Repeat this PIN")),
360                              prompt, NULL, pi2, NULL, 0);
361           if (!rc && strcmp (pi->pin, pi2->pin))
362             {
363               again_text = (resetcode?
364                             L_("Reset Code not correctly repeated; try again"):
365                             is_puk?
366                             L_("PUK not correctly repeated; try again"):
367                             L_("PIN not correctly repeated; try again"));
368               xfree (pi2);
369               xfree (pi);
370               goto again;
371             }
372           xfree (pi2);
373         }
374     }
375   else
376     {
377       char *desc, *desc2;
378
379       if ( asprintf (&desc,
380                      L_("Please enter the PIN%s%s%s to unlock the card"),
381                      info? " (":"",
382                      info? info:"",
383                      info? ")":"") < 0)
384         desc = NULL;
385       if (desc_text)
386         desc2 = strconcat (desc_text,
387                            has_percent0A_suffix (desc_text)
388                            ? "%0A" : "%0A%0A",
389                            desc, NULL);
390       else
391         desc2 = NULL;
392       rc = agent_askpin (ctrl, desc2? desc2 : desc? desc : info,
393                          prompt, NULL, pi, NULL, 0);
394       xfree (desc2);
395       xfree (desc);
396     }
397
398   if (!rc)
399     {
400       strncpy (buf, pi->pin, maxbuf-1);
401       buf[maxbuf-1] = 0;
402     }
403   xfree (pi);
404   return rc;
405 }
406
407
408
409 /* This function is used when a sign operation has been diverted to a
410  * smartcard.  DESC_TEXT is the original text for a prompt has send by
411  * gpg to gpg-agent.
412  *
413  * FIXME: Explain the other args.  */
414 int
415 divert_pksign (ctrl_t ctrl, const char *desc_text,
416                const unsigned char *digest, size_t digestlen, int algo,
417                const unsigned char *shadow_info, unsigned char **r_sig,
418                size_t *r_siglen)
419 {
420   int rc;
421   char *kid;
422   size_t siglen;
423   unsigned char *sigval = NULL;
424
425   (void)desc_text;
426
427   rc = ask_for_card (ctrl, shadow_info, &kid);
428   if (rc)
429     return rc;
430
431   if (algo == MD_USER_TLS_MD5SHA1)
432     {
433       int save = ctrl->use_auth_call;
434       ctrl->use_auth_call = 1;
435       rc = agent_card_pksign (ctrl, kid, getpin_cb, ctrl, NULL,
436                               algo, digest, digestlen, &sigval, &siglen);
437       ctrl->use_auth_call = save;
438     }
439   else
440     {
441       unsigned char *data;
442       size_t ndata;
443
444       rc = encode_md_for_card (digest, digestlen, algo, &data, &ndata);
445       if (!rc)
446         {
447           rc = agent_card_pksign (ctrl, kid, getpin_cb, ctrl, NULL,
448                                   algo, data, ndata, &sigval, &siglen);
449           xfree (data);
450         }
451     }
452
453   if (!rc)
454     {
455       *r_sig = sigval;
456       *r_siglen = siglen;
457     }
458
459   xfree (kid);
460
461   return rc;
462 }
463
464
465 /* Decrypt the value given asn an S-expression in CIPHER using the
466    key identified by SHADOW_INFO and return the plaintext in an
467    allocated buffer in R_BUF.  The padding information is stored at
468    R_PADDING with -1 for not known.  */
469 int
470 divert_pkdecrypt (ctrl_t ctrl, const char *desc_text,
471                   const unsigned char *cipher,
472                   const unsigned char *shadow_info,
473                   char **r_buf, size_t *r_len, int *r_padding)
474 {
475   int rc;
476   char *kid;
477   const unsigned char *s;
478   size_t n;
479   const unsigned char *ciphertext;
480   size_t ciphertextlen;
481   char *plaintext;
482   size_t plaintextlen;
483
484   (void)desc_text;
485
486   *r_padding = -1;
487
488   s = cipher;
489   if (*s != '(')
490     return gpg_error (GPG_ERR_INV_SEXP);
491   s++;
492   n = snext (&s);
493   if (!n)
494     return gpg_error (GPG_ERR_INV_SEXP);
495   if (!smatch (&s, n, "enc-val"))
496     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
497   if (*s != '(')
498     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
499   s++;
500   n = snext (&s);
501   if (!n)
502     return gpg_error (GPG_ERR_INV_SEXP);
503   if (smatch (&s, n, "rsa"))
504     {
505       if (*s != '(')
506         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
507       s++;
508       n = snext (&s);
509       if (!n)
510         return gpg_error (GPG_ERR_INV_SEXP);
511       if (!smatch (&s, n, "a"))
512         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
513       n = snext (&s);
514     }
515   else if (smatch (&s, n, "ecdh"))
516     {
517       if (*s != '(')
518         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
519       s++;
520       n = snext (&s);
521       if (!n)
522         return gpg_error (GPG_ERR_INV_SEXP);
523       if (smatch (&s, n, "s"))
524         {
525           n = snext (&s);
526           s += n;
527           if (*s++ != ')')
528             return gpg_error (GPG_ERR_INV_SEXP);
529           if (*s++ != '(')
530             return gpg_error (GPG_ERR_UNKNOWN_SEXP);
531           n = snext (&s);
532           if (!n)
533             return gpg_error (GPG_ERR_INV_SEXP);
534         }
535       if (!smatch (&s, n, "e"))
536         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
537       n = snext (&s);
538     }
539   else
540     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
541
542   if (!n)
543     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
544   ciphertext = s;
545   ciphertextlen = n;
546
547   rc = ask_for_card (ctrl, shadow_info, &kid);
548   if (rc)
549     return rc;
550
551   rc = agent_card_pkdecrypt (ctrl, kid, getpin_cb, ctrl, NULL,
552                              ciphertext, ciphertextlen,
553                              &plaintext, &plaintextlen, r_padding);
554   if (!rc)
555     {
556       *r_buf = plaintext;
557       *r_len = plaintextlen;
558     }
559   xfree (kid);
560   return rc;
561 }
562
563 int
564 divert_writekey (ctrl_t ctrl, int force, const char *serialno,
565                  const char *id, const char *keydata, size_t keydatalen)
566 {
567   return agent_card_writekey (ctrl, force, serialno, id, keydata, keydatalen,
568                               getpin_cb, ctrl);
569 }
570
571 int
572 divert_generic_cmd (ctrl_t ctrl, const char *cmdline, void *assuan_context)
573 {
574   return agent_card_scd (ctrl, cmdline, getpin_cb, ctrl, assuan_context);
575 }