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