Remove hacks which are not anymore needed since we now require Libgcrypt 1.4
[gnupg.git] / agent / divert-scd.c
1 /* divert-scd.c - divert operations to the scdaemon 
2  *      Copyright (C) 2002, 2003 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 <http://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 "sexp-parse.h"
32 #include "i18n.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   const unsigned char *s;
40   size_t n;
41   char *serialno;
42   int no_card = 0;
43   char *desc;
44   char *want_sn, *want_kid;
45   int want_sn_displen;
46
47   *r_kid = NULL;
48   s = shadow_info;
49   if (*s != '(')
50     return gpg_error (GPG_ERR_INV_SEXP);
51   s++;
52   n = snext (&s);
53   if (!n)
54     return gpg_error (GPG_ERR_INV_SEXP);
55   want_sn = xtrymalloc (n*2+1);
56   if (!want_sn)
57     return out_of_core ();
58   for (i=0; i < n; i++)
59     sprintf (want_sn+2*i, "%02X", s[i]);
60   s += n;
61   /* We assume that a 20 byte serial number is a standard one which
62      seems to have the property to have a zero in the last nibble.  We
63      don't display this '0' because it may confuse the user */
64   want_sn_displen = strlen (want_sn);
65   if (want_sn_displen == 20 && want_sn[19] == '0')
66     want_sn_displen--;
67
68   n = snext (&s);
69   if (!n)
70     return gpg_error (GPG_ERR_INV_SEXP);
71   want_kid = xtrymalloc (n+1);
72   if (!want_kid)
73     {
74       gpg_error_t tmperr = out_of_core ();
75       xfree (want_sn);
76       return tmperr;
77     }
78   memcpy (want_kid, s, n);
79   want_kid[n] = 0;
80
81   for (;;)
82     {
83       rc = agent_card_serialno (ctrl, &serialno);
84       if (!rc)
85         {
86           log_debug ("detected card with S/N %s\n", serialno);
87           i = strcmp (serialno, want_sn);
88           xfree (serialno);
89           serialno = NULL;
90           if (!i)
91             {
92               xfree (want_sn);
93               *r_kid = want_kid;
94               return 0; /* yes, we have the correct card */
95             }
96         }
97       else if (gpg_err_code (rc) == GPG_ERR_CARD_NOT_PRESENT)
98         {
99           log_debug ("no card present\n");
100           rc = 0;
101           no_card = 1;
102         }
103       else
104         {
105           log_error ("error accesing card: %s\n", gpg_strerror (rc));
106         }
107
108       if (!rc)
109         {
110           if (asprintf (&desc,
111                     "%s:%%0A%%0A"
112                     "  \"%.*s\"",
113                     no_card? "Please insert the card with serial number" 
114                     : "Please remove the current card and "
115                     "insert the one with serial number",
116                     want_sn_displen, want_sn) < 0)
117             {
118               rc = out_of_core ();
119             }
120           else
121             {
122               rc = agent_get_confirmation (ctrl, desc, NULL, NULL);
123               xfree (desc);
124             }
125         }
126       if (rc)
127         {
128           xfree (want_sn);
129           xfree (want_kid);
130           return rc;
131         }
132     }
133 }
134
135
136 /* Put the DIGEST into an DER encoded container and return it in R_VAL. */
137 static int
138 encode_md_for_card (const unsigned char *digest, size_t digestlen, int algo,
139                     unsigned char **r_val, size_t *r_len)
140 {
141   unsigned char *frame;
142   unsigned char asn[100];
143   size_t asnlen;
144
145   *r_val = NULL;
146   *r_len = 0;
147
148   asnlen = DIM(asn);
149   if (!algo || gcry_md_test_algo (algo))
150     return gpg_error (GPG_ERR_DIGEST_ALGO);
151   if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
152     {
153       log_error ("no object identifier for algo %d\n", algo);
154       return gpg_error (GPG_ERR_INTERNAL);
155     }
156
157   frame = xtrymalloc (asnlen + digestlen);
158   if (!frame)
159     return out_of_core ();
160   memcpy (frame, asn, asnlen);
161   memcpy (frame+asnlen, digest, digestlen);
162   if (DBG_CRYPTO)
163     log_printhex ("encoded hash:", frame, asnlen+digestlen);
164       
165   *r_val = frame;
166   *r_len = asnlen+digestlen;
167   return 0;
168 }
169
170
171 /* Callback used to ask for the PIN which should be set into BUF.  The
172    buf has been allocated by the caller and is of size MAXBUF which
173    includes the terminating null.  The function should return an UTF-8
174    string with the passphrase, the buffer may optionally be padded
175    with arbitrary characters.
176
177    INFO gets displayed as part of a generic string.  However if the
178    first character of INFO is a vertical bar all up to the next
179    verical bar are considered flags and only everything after the
180    second vertical bar gets displayed as the full prompt.
181
182    Flags:
183
184       'N' = New PIN, this requests a second prompt to repeat the the
185             PIN.  If the PIN is not correctly repeated it starts from
186             all over.
187       'A' = The PIN is an Admin PIN, SO-PIN, PUK or alike.
188       'R' = The PIN is a Reset Code.
189
190    Example:
191
192      "|AN|Please enter the new security officer's PIN"
193      
194    The text "Please ..." will get displayed and the flags 'A' and 'N'
195    are considered.
196  */
197 static int 
198 getpin_cb (void *opaque, const char *info, char *buf, size_t maxbuf)
199 {
200   struct pin_entry_info_s *pi;
201   int rc;
202   ctrl_t ctrl = opaque;
203   const char *ends, *s;
204   int any_flags = 0;
205   int newpin = 0;
206   int resetcode = 0;
207   const char *again_text = NULL;
208   const char *prompt = "PIN";
209
210   if (buf && maxbuf < 2)
211     return gpg_error (GPG_ERR_INV_VALUE);
212
213   /* Parse the flags. */
214   if (info && *info =='|' && (ends=strchr (info+1, '|')))
215     {
216       for (s=info+1; s < ends; s++)
217         {
218           if (*s == 'A')
219             prompt = _("Admin PIN");
220           else if (*s == 'N')
221             newpin = 1;
222           else if (*s == 'R')
223             {
224               prompt = _("Reset Code");
225               resetcode = 1;
226             }
227         }
228       info = ends+1;
229       any_flags = 1;
230     }
231   else if (info && *info == '|')
232     log_debug ("pin_cb called without proper PIN info hack\n");
233
234   /* If BUF has been passed as NULL, we are in keypad mode: The
235      callback opens the popup and immediatley returns. */
236   if (!buf)
237     {
238       if (maxbuf == 0) /* Close the pinentry. */
239         {
240           agent_popup_message_stop (ctrl);
241           rc = 0;
242         }
243       else if (maxbuf == 1)  /* Open the pinentry. */
244         {
245           rc = agent_popup_message_start (ctrl, info, NULL);
246         }
247       else
248         rc = gpg_error (GPG_ERR_INV_VALUE);
249       return rc;
250     }
251
252   /* FIXME: keep PI and TRIES in OPAQUE.  Frankly this is a whole
253      mess because we should call the card's verify function from the
254      pinentry check pin CB. */
255  again:
256   pi = gcry_calloc_secure (1, sizeof (*pi) + maxbuf + 10);
257   if (!pi)
258     return gpg_error_from_syserror ();
259   pi->max_length = maxbuf-1;
260   pi->min_digits = 0;  /* we want a real passphrase */
261   pi->max_digits = 8;
262   pi->max_tries = 3;
263
264   if (any_flags)
265     {
266       rc = agent_askpin (ctrl, info, prompt, again_text, pi);
267       again_text = NULL;
268       if (!rc && newpin)
269         {
270           struct pin_entry_info_s *pi2;
271           pi2 = gcry_calloc_secure (1, sizeof (*pi) + maxbuf + 10);
272           if (!pi2)
273             {
274               rc = gpg_error_from_syserror ();
275               xfree (pi);
276               return rc;
277             }
278           pi2->max_length = maxbuf-1;
279           pi2->min_digits = 0;
280           pi2->max_digits = 8;
281           pi2->max_tries = 1;
282           rc = agent_askpin (ctrl,
283                              (resetcode?
284                               _("Repeat this Reset Code"):
285                               _("Repeat this PIN")),
286                              prompt, NULL, pi2);
287           if (!rc && strcmp (pi->pin, pi2->pin))
288             {
289               again_text = (resetcode? 
290                             N_("Reset Code not correctly repeated; try again"):
291                             N_("PIN not correctly repeated; try again"));
292               xfree (pi2);
293               xfree (pi);
294               goto again;
295             }
296           xfree (pi2);
297         }
298     }
299   else
300     {
301       char *desc;
302       if ( asprintf (&desc,
303                      _("Please enter the PIN%s%s%s to unlock the card"), 
304                      info? " (`":"",
305                      info? info:"",
306                      info? "')":"") < 0)
307         desc = NULL;
308       rc = agent_askpin (ctrl, desc?desc:info, prompt, NULL, pi);
309       xfree (desc);
310     }
311
312   if (!rc)
313     {
314       strncpy (buf, pi->pin, maxbuf-1);
315       buf[maxbuf-1] = 0;
316     }
317   xfree (pi);
318   return rc;
319 }
320
321
322
323
324 int
325 divert_pksign (ctrl_t ctrl, 
326                const unsigned char *digest, size_t digestlen, int algo,
327                const unsigned char *shadow_info, unsigned char **r_sig)
328 {
329   int rc;
330   char *kid;
331   size_t siglen;
332   unsigned char *sigval = NULL;
333
334   rc = ask_for_card (ctrl, shadow_info, &kid);
335   if (rc)
336     return rc;
337
338   if (algo == MD_USER_TLS_MD5SHA1)
339     {
340       int save = ctrl->use_auth_call;
341       ctrl->use_auth_call = 1;
342       rc = agent_card_pksign (ctrl, kid, getpin_cb, ctrl,
343                               digest, digestlen, &sigval, &siglen);
344       ctrl->use_auth_call = save;
345     }
346   else
347     {
348       unsigned char *data;
349       size_t ndata;
350
351       rc = encode_md_for_card (digest, digestlen, algo, &data, &ndata);
352       if (!rc)
353         {
354           rc = agent_card_pksign (ctrl, kid, getpin_cb, ctrl,
355                                   data, ndata, &sigval, &siglen);
356           xfree (data);
357         }
358     }
359
360   if (!rc)
361     *r_sig = sigval;
362
363   xfree (kid);
364
365   return rc;
366 }
367
368
369 /* Decrypt the the value given asn an S-expression in CIPHER using the
370    key identified by SHADOW_INFO and return the plaintext in an
371    allocated buffer in R_BUF.  */
372 int  
373 divert_pkdecrypt (ctrl_t ctrl,
374                   const unsigned char *cipher,
375                   const unsigned char *shadow_info,
376                   char **r_buf, size_t *r_len)
377 {
378   int rc;
379   char *kid;
380   const unsigned char *s;
381   size_t n;
382   const unsigned char *ciphertext;
383   size_t ciphertextlen;
384   char *plaintext;
385   size_t plaintextlen;
386
387   s = cipher;
388   if (*s != '(')
389     return gpg_error (GPG_ERR_INV_SEXP);
390   s++;
391   n = snext (&s);
392   if (!n)
393     return gpg_error (GPG_ERR_INV_SEXP); 
394   if (!smatch (&s, n, "enc-val"))
395     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
396   if (*s != '(')
397     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
398   s++;
399   n = snext (&s);
400   if (!n)
401     return gpg_error (GPG_ERR_INV_SEXP); 
402   if (!smatch (&s, n, "rsa"))
403     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM); 
404   if (*s != '(')
405     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
406   s++;
407   n = snext (&s);
408   if (!n)
409     return gpg_error (GPG_ERR_INV_SEXP); 
410   if (!smatch (&s, n, "a"))
411     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
412   n = snext (&s);
413   if (!n)
414     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
415   ciphertext = s;
416   ciphertextlen = n;
417
418   rc = ask_for_card (ctrl, shadow_info, &kid);
419   if (rc)
420     return rc;
421
422   rc = agent_card_pkdecrypt (ctrl, kid, getpin_cb, ctrl,
423                              ciphertext, ciphertextlen,
424                              &plaintext, &plaintextlen);
425   if (!rc)
426     {
427       *r_buf = plaintext;
428       *r_len = plaintextlen;
429     }
430   xfree (kid);
431   return rc;
432 }
433
434
435 int  
436 divert_generic_cmd (ctrl_t ctrl, const char *cmdline, void *assuan_context)
437 {
438   return agent_card_scd (ctrl, cmdline, getpin_cb, ctrl, assuan_context);
439 }
440
441
442
443
444