Replace use of opt.homedir by accessor functions.
[gnupg.git] / sm / call-agent.c
1 /* call-agent.c - Divert GPGSM operations to the agent
2  * Copyright (C) 2001, 2002, 2003, 2005, 2007,
3  *               2008, 2009, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <time.h>
28 #include <assert.h>
29 #ifdef HAVE_LOCALE_H
30 #include <locale.h>
31 #endif
32
33 #include "gpgsm.h"
34 #include <gcrypt.h>
35 #include <assuan.h>
36 #include "i18n.h"
37 #include "asshelp.h"
38 #include "keydb.h" /* fixme: Move this to import.c */
39 #include "membuf.h"
40 #include "shareddefs.h"
41 #include "passphrase.h"
42
43
44 static assuan_context_t agent_ctx = NULL;
45
46
47 struct cipher_parm_s
48 {
49   ctrl_t ctrl;
50   assuan_context_t ctx;
51   const unsigned char *ciphertext;
52   size_t ciphertextlen;
53 };
54
55 struct genkey_parm_s
56 {
57   ctrl_t ctrl;
58   assuan_context_t ctx;
59   const unsigned char *sexp;
60   size_t sexplen;
61 };
62
63 struct learn_parm_s
64 {
65   int error;
66   ctrl_t ctrl;
67   assuan_context_t ctx;
68   membuf_t *data;
69 };
70
71 struct import_key_parm_s
72 {
73   ctrl_t ctrl;
74   assuan_context_t ctx;
75   const void *key;
76   size_t keylen;
77 };
78
79 struct default_inq_parm_s
80 {
81   ctrl_t ctrl;
82   assuan_context_t ctx;
83 };
84
85 \f
86 /* Print a warning if the server's version number is less than our
87    version number.  Returns an error code on a connection problem.  */
88 static gpg_error_t
89 warn_version_mismatch (ctrl_t ctrl, assuan_context_t ctx,
90                        const char *servername, int mode)
91 {
92   gpg_error_t err;
93   char *serverversion;
94   const char *myversion = strusage (13);
95
96   err = get_assuan_server_version (ctx, mode, &serverversion);
97   if (err)
98     log_error (_("error getting version from '%s': %s\n"),
99                servername, gpg_strerror (err));
100   else if (!compare_version_strings (serverversion, myversion))
101     {
102       char *warn;
103
104       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
105                            servername, serverversion, myversion);
106       if (!warn)
107         err = gpg_error_from_syserror ();
108       else
109         {
110           log_info (_("WARNING: %s\n"), warn);
111           gpgsm_status2 (ctrl, STATUS_WARNING, "server_version_mismatch 0",
112                          warn, NULL);
113           xfree (warn);
114         }
115     }
116   xfree (serverversion);
117   return err;
118 }
119
120
121 /* Try to connect to the agent via socket or fork it off and work by
122    pipes.  Handle the server's initial greeting */
123 static int
124 start_agent (ctrl_t ctrl)
125 {
126   int rc;
127
128   if (agent_ctx)
129     rc = 0;      /* fixme: We need a context for each thread or
130                     serialize the access to the agent (which is
131                     suitable given that the agent is not MT. */
132   else
133     {
134       rc = start_new_gpg_agent (&agent_ctx,
135                                 GPG_ERR_SOURCE_DEFAULT,
136                                 gnupg_homedir (),
137                                 opt.agent_program,
138                                 opt.lc_ctype, opt.lc_messages,
139                                 opt.session_env,
140                                 opt.autostart, opt.verbose, DBG_IPC,
141                                 gpgsm_status2, ctrl);
142
143       if (!opt.autostart && gpg_err_code (rc) == GPG_ERR_NO_AGENT)
144         {
145           static int shown;
146
147           if (!shown)
148             {
149               shown = 1;
150               log_info (_("no gpg-agent running in this session\n"));
151             }
152         }
153       else if (!rc && !(rc = warn_version_mismatch (ctrl, agent_ctx,
154                                                     GPG_AGENT_NAME, 0)))
155         {
156           /* Tell the agent that we support Pinentry notifications.  No
157              error checking so that it will work also with older
158              agents.  */
159           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
160                            NULL, NULL, NULL, NULL, NULL, NULL);
161
162           /* Pass on the pinentry mode.  */
163           if (opt.pinentry_mode)
164             {
165               char *tmp = xasprintf ("OPTION pinentry-mode=%s",
166                                      str_pinentry_mode (opt.pinentry_mode));
167               rc = assuan_transact (agent_ctx, tmp,
168                                NULL, NULL, NULL, NULL, NULL, NULL);
169               xfree (tmp);
170               if (rc)
171                 log_error ("setting pinentry mode '%s' failed: %s\n",
172                            str_pinentry_mode (opt.pinentry_mode),
173                            gpg_strerror (rc));
174             }
175         }
176     }
177
178   if (!ctrl->agent_seen)
179     {
180       ctrl->agent_seen = 1;
181       audit_log_ok (ctrl->audit, AUDIT_AGENT_READY, rc);
182     }
183
184   return rc;
185 }
186
187 /* This is the default inquiry callback.  It mainly handles the
188    Pinentry notifications.  */
189 static gpg_error_t
190 default_inq_cb (void *opaque, const char *line)
191 {
192   gpg_error_t err = 0;
193   struct default_inq_parm_s *parm = opaque;
194   ctrl_t ctrl = parm->ctrl;
195
196   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
197     {
198       err = gpgsm_proxy_pinentry_notify (ctrl, line);
199       if (err)
200         log_error (_("failed to proxy %s inquiry to client\n"),
201                    "PINENTRY_LAUNCHED");
202       /* We do not pass errors to avoid breaking other code.  */
203     }
204   else if ((has_leading_keyword (line, "PASSPHRASE")
205             || has_leading_keyword (line, "NEW_PASSPHRASE"))
206            && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK
207            && have_static_passphrase ())
208     {
209       const char *s = get_static_passphrase ();
210       err = assuan_send_data (parm->ctx, s, strlen (s));
211     }
212   else
213     log_error ("ignoring gpg-agent inquiry '%s'\n", line);
214
215   return err;
216 }
217
218
219
220 \f
221 /* Call the agent to do a sign operation using the key identified by
222    the hex string KEYGRIP. */
223 int
224 gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
225                     unsigned char *digest, size_t digestlen, int digestalgo,
226                     unsigned char **r_buf, size_t *r_buflen )
227 {
228   int rc, i;
229   char *p, line[ASSUAN_LINELENGTH];
230   membuf_t data;
231   size_t len;
232   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
233
234   *r_buf = NULL;
235   rc = start_agent (ctrl);
236   if (rc)
237     return rc;
238
239   if (digestlen*2 + 50 > DIM(line))
240     return gpg_error (GPG_ERR_GENERAL);
241
242   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
243   if (rc)
244     return rc;
245
246   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
247   line[DIM(line)-1] = 0;
248   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
249   if (rc)
250     return rc;
251
252   if (desc)
253     {
254       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
255       line[DIM(line)-1] = 0;
256       rc = assuan_transact (agent_ctx, line,
257                             NULL, NULL, NULL, NULL, NULL, NULL);
258       if (rc)
259         return rc;
260     }
261
262   sprintf (line, "SETHASH %d ", digestalgo);
263   p = line + strlen (line);
264   for (i=0; i < digestlen ; i++, p += 2 )
265     sprintf (p, "%02X", digest[i]);
266   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
267   if (rc)
268     return rc;
269
270   init_membuf (&data, 1024);
271   rc = assuan_transact (agent_ctx, "PKSIGN",
272                         put_membuf_cb, &data, default_inq_cb, &inq_parm,
273                         NULL, NULL);
274   if (rc)
275     {
276       xfree (get_membuf (&data, &len));
277       return rc;
278     }
279   *r_buf = get_membuf (&data, r_buflen);
280
281   if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
282     {
283       xfree (*r_buf); *r_buf = NULL;
284       return gpg_error (GPG_ERR_INV_VALUE);
285     }
286
287   return *r_buf? 0 : out_of_core ();
288 }
289
290
291 /* Call the scdaemon to do a sign operation using the key identified by
292    the hex string KEYID. */
293 int
294 gpgsm_scd_pksign (ctrl_t ctrl, const char *keyid, const char *desc,
295                   unsigned char *digest, size_t digestlen, int digestalgo,
296                   unsigned char **r_buf, size_t *r_buflen )
297 {
298   int rc, i;
299   char *p, line[ASSUAN_LINELENGTH];
300   membuf_t data;
301   size_t len;
302   const char *hashopt;
303   unsigned char *sigbuf;
304   size_t sigbuflen;
305   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
306
307   (void)desc;
308
309   *r_buf = NULL;
310
311   switch(digestalgo)
312     {
313     case GCRY_MD_SHA1:  hashopt = "--hash=sha1"; break;
314     case GCRY_MD_RMD160:hashopt = "--hash=rmd160"; break;
315     case GCRY_MD_MD5:   hashopt = "--hash=md5"; break;
316     case GCRY_MD_SHA256:hashopt = "--hash=sha256"; break;
317     default:
318       return gpg_error (GPG_ERR_DIGEST_ALGO);
319     }
320
321   rc = start_agent (ctrl);
322   if (rc)
323     return rc;
324
325   if (digestlen*2 + 50 > DIM(line))
326     return gpg_error (GPG_ERR_GENERAL);
327
328   p = stpcpy (line, "SCD SETDATA " );
329   for (i=0; i < digestlen ; i++, p += 2 )
330     sprintf (p, "%02X", digest[i]);
331   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
332   if (rc)
333     return rc;
334
335   init_membuf (&data, 1024);
336
337   snprintf (line, DIM(line)-1, "SCD PKSIGN %s %s", hashopt, keyid);
338   line[DIM(line)-1] = 0;
339   rc = assuan_transact (agent_ctx, line,
340                         put_membuf_cb, &data, default_inq_cb, &inq_parm,
341                         NULL, NULL);
342   if (rc)
343     {
344       xfree (get_membuf (&data, &len));
345       return rc;
346     }
347   sigbuf = get_membuf (&data, &sigbuflen);
348
349   /* Create an S-expression from it which is formatted like this:
350      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" Fixme: If a card ever
351      creates non-RSA keys we need to change things. */
352   *r_buflen = 21 + 11 + sigbuflen + 4;
353   p = xtrymalloc (*r_buflen);
354   *r_buf = (unsigned char*)p;
355   if (!p)
356     {
357       xfree (sigbuf);
358       return 0;
359     }
360   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
361   sprintf (p, "%u:", (unsigned int)sigbuflen);
362   p += strlen (p);
363   memcpy (p, sigbuf, sigbuflen);
364   p += sigbuflen;
365   strcpy (p, ")))");
366   xfree (sigbuf);
367
368   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
369   return  0;
370 }
371
372
373
374 \f
375 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
376    assuan_transact takes care of flushing and writing the end */
377 static gpg_error_t
378 inq_ciphertext_cb (void *opaque, const char *line)
379 {
380   struct cipher_parm_s *parm = opaque;
381   int rc;
382
383   if (has_leading_keyword (line, "CIPHERTEXT"))
384     {
385       assuan_begin_confidential (parm->ctx);
386       rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
387       assuan_end_confidential (parm->ctx);
388     }
389   else
390     {
391       struct default_inq_parm_s inq_parm = { parm->ctrl, parm->ctx };
392       rc = default_inq_cb (&inq_parm, line);
393     }
394
395   return rc;
396 }
397
398
399 /* Call the agent to do a decrypt operation using the key identified by
400    the hex string KEYGRIP. */
401 int
402 gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
403                        ksba_const_sexp_t ciphertext,
404                        char **r_buf, size_t *r_buflen )
405 {
406   int rc;
407   char line[ASSUAN_LINELENGTH];
408    membuf_t data;
409   struct cipher_parm_s cipher_parm;
410   size_t n, len;
411   char *p, *buf, *endp;
412   size_t ciphertextlen;
413
414   if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
415     return gpg_error (GPG_ERR_INV_VALUE);
416   *r_buf = NULL;
417
418   ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
419   if (!ciphertextlen)
420     return gpg_error (GPG_ERR_INV_VALUE);
421
422   rc = start_agent (ctrl);
423   if (rc)
424     return rc;
425
426   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
427   if (rc)
428     return rc;
429
430   assert ( DIM(line) >= 50 );
431   snprintf (line, DIM(line)-1, "SETKEY %s", keygrip);
432   line[DIM(line)-1] = 0;
433   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
434   if (rc)
435     return rc;
436
437   if (desc)
438     {
439       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
440       line[DIM(line)-1] = 0;
441       rc = assuan_transact (agent_ctx, line,
442                             NULL, NULL, NULL, NULL, NULL, NULL);
443       if (rc)
444         return rc;
445     }
446
447   init_membuf (&data, 1024);
448   cipher_parm.ctrl = ctrl;
449   cipher_parm.ctx = agent_ctx;
450   cipher_parm.ciphertext = ciphertext;
451   cipher_parm.ciphertextlen = ciphertextlen;
452   rc = assuan_transact (agent_ctx, "PKDECRYPT",
453                         put_membuf_cb, &data,
454                         inq_ciphertext_cb, &cipher_parm, NULL, NULL);
455   if (rc)
456     {
457       xfree (get_membuf (&data, &len));
458       return rc;
459     }
460
461   put_membuf (&data, "", 1); /* Make sure it is 0 terminated. */
462   buf = get_membuf (&data, &len);
463   if (!buf)
464     return gpg_error (GPG_ERR_ENOMEM);
465   assert (len); /* (we forced Nul termination.)  */
466
467   if (*buf == '(')
468     {
469       if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
470         return gpg_error (GPG_ERR_INV_SEXP);
471       len -= 11;   /* Count only the data of the second part. */
472       p = buf + 8; /* Skip leading parenthesis and the value tag. */
473     }
474   else
475     {
476       /* For compatibility with older gpg-agents handle the old style
477          incomplete S-exps. */
478       len--;      /* Do not count the Nul. */
479       p = buf;
480     }
481
482   n = strtoul (p, &endp, 10);
483   if (!n || *endp != ':')
484     return gpg_error (GPG_ERR_INV_SEXP);
485   endp++;
486   if (endp-p+n > len)
487     return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
488
489   memmove (buf, endp, n);
490
491   *r_buflen = n;
492   *r_buf = buf;
493   return 0;
494 }
495
496
497
498
499 \f
500 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
501    assuan_transact takes care of flushing and writing the end */
502 static gpg_error_t
503 inq_genkey_parms (void *opaque, const char *line)
504 {
505   struct genkey_parm_s *parm = opaque;
506   int rc;
507
508   if (has_leading_keyword (line, "KEYPARAM"))
509     {
510       rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);
511     }
512   else
513     {
514       struct default_inq_parm_s inq_parm = { parm->ctrl, parm->ctx };
515       rc = default_inq_cb (&inq_parm, line);
516     }
517
518   return rc;
519 }
520
521
522 \f
523 /* Call the agent to generate a newkey */
524 int
525 gpgsm_agent_genkey (ctrl_t ctrl,
526                     ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey)
527 {
528   int rc;
529   struct genkey_parm_s gk_parm;
530   membuf_t data;
531   size_t len;
532   unsigned char *buf;
533
534   *r_pubkey = NULL;
535   rc = start_agent (ctrl);
536   if (rc)
537     return rc;
538
539   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
540   if (rc)
541     return rc;
542
543   init_membuf (&data, 1024);
544   gk_parm.ctrl = ctrl;
545   gk_parm.ctx = agent_ctx;
546   gk_parm.sexp = keyparms;
547   gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
548   if (!gk_parm.sexplen)
549     return gpg_error (GPG_ERR_INV_VALUE);
550   rc = assuan_transact (agent_ctx, "GENKEY",
551                         put_membuf_cb, &data,
552                         inq_genkey_parms, &gk_parm, NULL, NULL);
553   if (rc)
554     {
555       xfree (get_membuf (&data, &len));
556       return rc;
557     }
558   buf = get_membuf (&data, &len);
559   if (!buf)
560     return gpg_error (GPG_ERR_ENOMEM);
561   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
562     {
563       xfree (buf);
564       return gpg_error (GPG_ERR_INV_SEXP);
565     }
566   *r_pubkey = buf;
567   return 0;
568 }
569
570 \f
571 /* Call the agent to read the public key part for a given keygrip.  If
572    FROMCARD is true, the key is directly read from the current
573    smartcard. In this case HEXKEYGRIP should be the keyID
574    (e.g. OPENPGP.3). */
575 int
576 gpgsm_agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
577                      ksba_sexp_t *r_pubkey)
578 {
579   int rc;
580   membuf_t data;
581   size_t len;
582   unsigned char *buf;
583   char line[ASSUAN_LINELENGTH];
584   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
585
586   *r_pubkey = NULL;
587   rc = start_agent (ctrl);
588   if (rc)
589     return rc;
590
591   rc = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
592   if (rc)
593     return rc;
594
595   snprintf (line, DIM(line)-1, "%sREADKEY %s",
596             fromcard? "SCD ":"", hexkeygrip);
597   line[DIM(line)-1] = 0;
598
599   init_membuf (&data, 1024);
600   rc = assuan_transact (agent_ctx, line,
601                         put_membuf_cb, &data,
602                         default_inq_cb, &inq_parm, NULL, NULL);
603   if (rc)
604     {
605       xfree (get_membuf (&data, &len));
606       return rc;
607     }
608   buf = get_membuf (&data, &len);
609   if (!buf)
610     return gpg_error (GPG_ERR_ENOMEM);
611   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
612     {
613       xfree (buf);
614       return gpg_error (GPG_ERR_INV_SEXP);
615     }
616   *r_pubkey = buf;
617   return 0;
618 }
619
620
621 \f
622 /* Take the serial number from LINE and return it verbatim in a newly
623    allocated string.  We make sure that only hex characters are
624    returned. */
625 static char *
626 store_serialno (const char *line)
627 {
628   const char *s;
629   char *p;
630
631   for (s=line; hexdigitp (s); s++)
632     ;
633   p = xtrymalloc (s + 1 - line);
634   if (p)
635     {
636       memcpy (p, line, s-line);
637       p[s-line] = 0;
638     }
639   return p;
640 }
641
642
643 /* Callback for the gpgsm_agent_serialno function.  */
644 static gpg_error_t
645 scd_serialno_status_cb (void *opaque, const char *line)
646 {
647   char **r_serialno = opaque;
648   const char *keyword = line;
649   int keywordlen;
650
651   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
652     ;
653   while (spacep (line))
654     line++;
655
656   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
657     {
658       xfree (*r_serialno);
659       *r_serialno = store_serialno (line);
660     }
661
662   return 0;
663 }
664
665
666 /* Call the agent to read the serial number of the current card.  */
667 int
668 gpgsm_agent_scd_serialno (ctrl_t ctrl, char **r_serialno)
669 {
670   int rc;
671   char *serialno = NULL;
672   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
673
674   *r_serialno = NULL;
675   rc = start_agent (ctrl);
676   if (rc)
677     return rc;
678
679   rc = assuan_transact (agent_ctx, "SCD SERIALNO",
680                         NULL, NULL,
681                         default_inq_cb, &inq_parm,
682                         scd_serialno_status_cb, &serialno);
683   if (!rc && !serialno)
684     rc = gpg_error (GPG_ERR_INTERNAL);
685   if (rc)
686     {
687       xfree (serialno);
688       return rc;
689     }
690   *r_serialno = serialno;
691   return 0;
692 }
693
694
695 \f
696 /* Callback for the gpgsm_agent_serialno function.  */
697 static gpg_error_t
698 scd_keypairinfo_status_cb (void *opaque, const char *line)
699 {
700   strlist_t *listaddr = opaque;
701   const char *keyword = line;
702   int keywordlen;
703   strlist_t sl;
704   char *p;
705
706   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
707     ;
708   while (spacep (line))
709     line++;
710
711   if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
712     {
713       sl = append_to_strlist (listaddr, line);
714       p = sl->d;
715       /* Make sure that we only have two tokes so that future
716          extensions of the format won't change the format expected by
717          the caller.  */
718       while (*p && !spacep (p))
719         p++;
720       if (*p)
721         {
722           while (spacep (p))
723             p++;
724           while (*p && !spacep (p))
725             p++;
726           *p = 0;
727         }
728     }
729
730   return 0;
731 }
732
733
734 /* Call the agent to read the keypairinfo lines of the current card.
735    The list is returned as a string made up of the keygrip, a space
736    and the keyid.  */
737 int
738 gpgsm_agent_scd_keypairinfo (ctrl_t ctrl, strlist_t *r_list)
739 {
740   int rc;
741   strlist_t list = NULL;
742   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
743
744   *r_list = NULL;
745   rc = start_agent (ctrl);
746   if (rc)
747     return rc;
748
749   rc = assuan_transact (agent_ctx, "SCD LEARN --force",
750                         NULL, NULL,
751                         default_inq_cb, &inq_parm,
752                         scd_keypairinfo_status_cb, &list);
753   if (!rc && !list)
754     rc = gpg_error (GPG_ERR_NO_DATA);
755   if (rc)
756     {
757       free_strlist (list);
758       return rc;
759     }
760   *r_list = list;
761   return 0;
762 }
763
764
765 \f
766 static gpg_error_t
767 istrusted_status_cb (void *opaque, const char *line)
768 {
769   struct rootca_flags_s *flags = opaque;
770   const char *s;
771
772   if ((s = has_leading_keyword (line, "TRUSTLISTFLAG")))
773     {
774       line = s;
775       if (has_leading_keyword (line, "relax"))
776         flags->relax = 1;
777       else if (has_leading_keyword (line, "cm"))
778         flags->chain_model = 1;
779     }
780   return 0;
781 }
782
783
784
785 /* Ask the agent whether the certificate is in the list of trusted
786    keys.  The certificate is either specified by the CERT object or by
787    the fingerprint HEXFPR.  ROOTCA_FLAGS is guaranteed to be cleared
788    on error. */
789 int
790 gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert, const char *hexfpr,
791                        struct rootca_flags_s *rootca_flags)
792 {
793   int rc;
794   char line[ASSUAN_LINELENGTH];
795
796   memset (rootca_flags, 0, sizeof *rootca_flags);
797
798   if (cert && hexfpr)
799     return gpg_error (GPG_ERR_INV_ARG);
800
801   rc = start_agent (ctrl);
802   if (rc)
803     return rc;
804
805   if (hexfpr)
806     {
807       snprintf (line, DIM(line)-1, "ISTRUSTED %s", hexfpr);
808       line[DIM(line)-1] = 0;
809     }
810   else
811     {
812       char *fpr;
813
814       fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
815       if (!fpr)
816         {
817           log_error ("error getting the fingerprint\n");
818           return gpg_error (GPG_ERR_GENERAL);
819         }
820
821       snprintf (line, DIM(line)-1, "ISTRUSTED %s", fpr);
822       line[DIM(line)-1] = 0;
823       xfree (fpr);
824     }
825
826   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
827                         istrusted_status_cb, rootca_flags);
828   if (!rc)
829     rootca_flags->valid = 1;
830   return rc;
831 }
832
833 /* Ask the agent to mark CERT as a trusted Root-CA one */
834 int
835 gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert)
836 {
837   int rc;
838   char *fpr, *dn, *dnfmt;
839   char line[ASSUAN_LINELENGTH];
840   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
841
842   rc = start_agent (ctrl);
843   if (rc)
844     return rc;
845
846   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
847   if (!fpr)
848     {
849       log_error ("error getting the fingerprint\n");
850       return gpg_error (GPG_ERR_GENERAL);
851     }
852
853   dn = ksba_cert_get_issuer (cert, 0);
854   if (!dn)
855     {
856       xfree (fpr);
857       return gpg_error (GPG_ERR_GENERAL);
858     }
859   dnfmt = gpgsm_format_name2 (dn, 0);
860   xfree (dn);
861   if (!dnfmt)
862     return gpg_error_from_syserror ();
863   snprintf (line, DIM(line)-1, "MARKTRUSTED %s S %s", fpr, dnfmt);
864   line[DIM(line)-1] = 0;
865   ksba_free (dnfmt);
866   xfree (fpr);
867
868   rc = assuan_transact (agent_ctx, line, NULL, NULL,
869                         default_inq_cb, &inq_parm, NULL, NULL);
870   return rc;
871 }
872
873
874 \f
875 /* Ask the agent whether the a corresponding secret key is available
876    for the given keygrip */
877 int
878 gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip)
879 {
880   int rc;
881   char line[ASSUAN_LINELENGTH];
882
883   rc = start_agent (ctrl);
884   if (rc)
885     return rc;
886
887   if (!hexkeygrip || strlen (hexkeygrip) != 40)
888     return gpg_error (GPG_ERR_INV_VALUE);
889
890   snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
891   line[DIM(line)-1] = 0;
892
893   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
894   return rc;
895 }
896
897 \f
898 static gpg_error_t
899 learn_status_cb (void *opaque, const char *line)
900 {
901   struct learn_parm_s *parm = opaque;
902   const char *s;
903
904   /* Pass progress data to the caller.  */
905   if ((s = has_leading_keyword (line, "PROGRESS")))
906     {
907       line = s;
908       if (parm->ctrl)
909         {
910           if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, line))
911             return gpg_error (GPG_ERR_ASS_CANCELED);
912         }
913     }
914   return 0;
915 }
916
917 static gpg_error_t
918 learn_cb (void *opaque, const void *buffer, size_t length)
919 {
920   struct learn_parm_s *parm = opaque;
921   size_t len;
922   char *buf;
923   ksba_cert_t cert;
924   int rc;
925
926   if (parm->error)
927     return 0;
928
929   if (buffer)
930     {
931       put_membuf (parm->data, buffer, length);
932       return 0;
933     }
934   /* END encountered - process what we have */
935   buf = get_membuf (parm->data, &len);
936   if (!buf)
937     {
938       parm->error = gpg_error (GPG_ERR_ENOMEM);
939       return 0;
940     }
941
942   if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, "learncard C 0 0"))
943     return gpg_error (GPG_ERR_ASS_CANCELED);
944
945   /* FIXME: this should go into import.c */
946   rc = ksba_cert_new (&cert);
947   if (rc)
948     {
949       parm->error = rc;
950       return 0;
951     }
952   rc = ksba_cert_init_from_mem (cert, buf, len);
953   if (rc)
954     {
955       log_error ("failed to parse a certificate: %s\n", gpg_strerror (rc));
956       ksba_cert_release (cert);
957       parm->error = rc;
958       return 0;
959     }
960
961   /* We do not store a certifciate with missing issuers as ephemeral
962      because we can assume that the --learn-card command has been used
963      on purpose.  */
964   rc = gpgsm_basic_cert_check (parm->ctrl, cert);
965   if (rc && gpg_err_code (rc) != GPG_ERR_MISSING_CERT
966       && gpg_err_code (rc) != GPG_ERR_MISSING_ISSUER_CERT)
967     log_error ("invalid certificate: %s\n", gpg_strerror (rc));
968   else
969     {
970       int existed;
971
972       if (!keydb_store_cert (cert, 0, &existed))
973         {
974           if (opt.verbose > 1 && existed)
975             log_info ("certificate already in DB\n");
976           else if (opt.verbose && !existed)
977             log_info ("certificate imported\n");
978         }
979     }
980
981   ksba_cert_release (cert);
982   init_membuf (parm->data, 4096);
983   return 0;
984 }
985
986 /* Call the agent to learn about a smartcard */
987 int
988 gpgsm_agent_learn (ctrl_t ctrl)
989 {
990   int rc;
991   struct learn_parm_s learn_parm;
992   membuf_t data;
993   size_t len;
994
995   rc = start_agent (ctrl);
996   if (rc)
997     return rc;
998
999   rc = warn_version_mismatch (ctrl, agent_ctx, SCDAEMON_NAME, 2);
1000   if (rc)
1001     return rc;
1002
1003   init_membuf (&data, 4096);
1004   learn_parm.error = 0;
1005   learn_parm.ctrl = ctrl;
1006   learn_parm.ctx = agent_ctx;
1007   learn_parm.data = &data;
1008   rc = assuan_transact (agent_ctx, "LEARN --send",
1009                         learn_cb, &learn_parm,
1010                         NULL, NULL,
1011                         learn_status_cb, &learn_parm);
1012   xfree (get_membuf (&data, &len));
1013   if (rc)
1014     return rc;
1015   return learn_parm.error;
1016 }
1017
1018 \f
1019 /* Ask the agent to change the passphrase of the key identified by
1020    HEXKEYGRIP. If DESC is not NULL, display instead of the default
1021    description message. */
1022 int
1023 gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
1024 {
1025   int rc;
1026   char line[ASSUAN_LINELENGTH];
1027   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1028
1029   rc = start_agent (ctrl);
1030   if (rc)
1031     return rc;
1032
1033   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1034     return gpg_error (GPG_ERR_INV_VALUE);
1035
1036   if (desc)
1037     {
1038       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1039       line[DIM(line)-1] = 0;
1040       rc = assuan_transact (agent_ctx, line,
1041                             NULL, NULL, NULL, NULL, NULL, NULL);
1042       if (rc)
1043         return rc;
1044     }
1045
1046   snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
1047   line[DIM(line)-1] = 0;
1048
1049   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1050                         default_inq_cb, &inq_parm, NULL, NULL);
1051   return rc;
1052 }
1053
1054
1055 \f
1056 /* Ask the agent to pop up a confirmation dialog with the text DESC
1057    and an okay and cancel button.  */
1058 gpg_error_t
1059 gpgsm_agent_get_confirmation (ctrl_t ctrl, const char *desc)
1060 {
1061   int rc;
1062   char line[ASSUAN_LINELENGTH];
1063   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1064
1065   rc = start_agent (ctrl);
1066   if (rc)
1067     return rc;
1068
1069   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", desc);
1070   line[DIM(line)-1] = 0;
1071
1072   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1073                         default_inq_cb, &inq_parm, NULL, NULL);
1074   return rc;
1075 }
1076
1077
1078 \f
1079 /* Return 0 if the agent is alive.  This is useful to make sure that
1080    an agent has been started. */
1081 gpg_error_t
1082 gpgsm_agent_send_nop (ctrl_t ctrl)
1083 {
1084   int rc;
1085
1086   rc = start_agent (ctrl);
1087   if (!rc)
1088     rc = assuan_transact (agent_ctx, "NOP",
1089                           NULL, NULL, NULL, NULL, NULL, NULL);
1090   return rc;
1091 }
1092
1093
1094 \f
1095 static gpg_error_t
1096 keyinfo_status_cb (void *opaque, const char *line)
1097 {
1098   char **serialno = opaque;
1099   const char *s, *s2;
1100
1101   if ((s = has_leading_keyword (line, "KEYINFO")) && !*serialno)
1102     {
1103       s = strchr (s, ' ');
1104       if (s && s[1] == 'T' && s[2] == ' ' && s[3])
1105         {
1106           s += 3;
1107           s2 = strchr (s, ' ');
1108           if ( s2 > s )
1109             {
1110               *serialno = xtrymalloc ((s2 - s)+1);
1111               if (*serialno)
1112                 {
1113                   memcpy (*serialno, s, s2 - s);
1114                   (*serialno)[s2 - s] = 0;
1115                 }
1116             }
1117         }
1118     }
1119   return 0;
1120 }
1121
1122 /* Return the serial number for a secret key.  If the returned serial
1123    number is NULL, the key is not stored on a smartcard.  Caller needs
1124    to free R_SERIALNO.  */
1125 gpg_error_t
1126 gpgsm_agent_keyinfo (ctrl_t ctrl, const char *hexkeygrip, char **r_serialno)
1127 {
1128   gpg_error_t err;
1129   char line[ASSUAN_LINELENGTH];
1130   char *serialno = NULL;
1131
1132   *r_serialno = NULL;
1133
1134   err = start_agent (ctrl);
1135   if (err)
1136     return err;
1137
1138   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1139     return gpg_error (GPG_ERR_INV_VALUE);
1140
1141   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1142   line[DIM(line)-1] = 0;
1143
1144   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1145                          keyinfo_status_cb, &serialno);
1146   if (!err && serialno)
1147     {
1148       /* Sanity check for bad characters.  */
1149       if (strpbrk (serialno, ":\n\r"))
1150         err = GPG_ERR_INV_VALUE;
1151     }
1152   if (err)
1153     xfree (serialno);
1154   else
1155     *r_serialno = serialno;
1156   return err;
1157 }
1158
1159
1160 \f
1161 /* Ask for the passphrase (this is used for pkcs#12 import/export.  On
1162    success the caller needs to free the string stored at R_PASSPHRASE.
1163    On error NULL will be stored at R_PASSPHRASE and an appropriate
1164    error code returned.  If REPEAT is true the agent tries to get a
1165    new passphrase (i.e. asks the user to confirm it).  */
1166 gpg_error_t
1167 gpgsm_agent_ask_passphrase (ctrl_t ctrl, const char *desc_msg, int repeat,
1168                             char **r_passphrase)
1169 {
1170   gpg_error_t err;
1171   char line[ASSUAN_LINELENGTH];
1172   char *arg4 = NULL;
1173   membuf_t data;
1174   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1175
1176   *r_passphrase = NULL;
1177
1178   err = start_agent (ctrl);
1179   if (err)
1180     return err;
1181
1182   if (desc_msg && *desc_msg && !(arg4 = percent_plus_escape (desc_msg)))
1183     return gpg_error_from_syserror ();
1184
1185   snprintf (line, DIM(line)-1, "GET_PASSPHRASE --data%s -- X X X %s",
1186             repeat? " --repeat=1 --check --qualitybar":"",
1187             arg4);
1188   xfree (arg4);
1189
1190   init_membuf_secure (&data, 64);
1191   err = assuan_transact (agent_ctx, line,
1192                          put_membuf_cb, &data,
1193                          default_inq_cb, &inq_parm, NULL, NULL);
1194
1195   if (err)
1196     xfree (get_membuf (&data, NULL));
1197   else
1198     {
1199       put_membuf (&data, "", 1);
1200       *r_passphrase = get_membuf (&data, NULL);
1201       if (!*r_passphrase)
1202         err = gpg_error_from_syserror ();
1203     }
1204   return err;
1205 }
1206
1207
1208 \f
1209 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
1210    the key shall be use for export, with false for import.  On success
1211    the new key is stored at R_KEY and its length at R_KEKLEN.  */
1212 gpg_error_t
1213 gpgsm_agent_keywrap_key (ctrl_t ctrl, int forexport,
1214                          void **r_kek, size_t *r_keklen)
1215 {
1216   gpg_error_t err;
1217   membuf_t data;
1218   size_t len;
1219   unsigned char *buf;
1220   char line[ASSUAN_LINELENGTH];
1221   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1222
1223   *r_kek = NULL;
1224   err = start_agent (ctrl);
1225   if (err)
1226     return err;
1227
1228   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
1229             forexport? "--export":"--import");
1230
1231   init_membuf_secure (&data, 64);
1232   err = assuan_transact (agent_ctx, line,
1233                          put_membuf_cb, &data,
1234                          default_inq_cb, &inq_parm, NULL, NULL);
1235   if (err)
1236     {
1237       xfree (get_membuf (&data, &len));
1238       return err;
1239     }
1240   buf = get_membuf (&data, &len);
1241   if (!buf)
1242     return gpg_error_from_syserror ();
1243   *r_kek = buf;
1244   *r_keklen = len;
1245   return 0;
1246 }
1247
1248
1249
1250 \f
1251 /* Handle the inquiry for an IMPORT_KEY command.  */
1252 static gpg_error_t
1253 inq_import_key_parms (void *opaque, const char *line)
1254 {
1255   struct import_key_parm_s *parm = opaque;
1256   gpg_error_t err;
1257
1258   if (has_leading_keyword (line, "KEYDATA"))
1259     {
1260       assuan_begin_confidential (parm->ctx);
1261       err = assuan_send_data (parm->ctx, parm->key, parm->keylen);
1262       assuan_end_confidential (parm->ctx);
1263     }
1264   else
1265     {
1266       struct default_inq_parm_s inq_parm = { parm->ctrl, parm->ctx };
1267       err = default_inq_cb (&inq_parm, line);
1268     }
1269
1270   return err;
1271 }
1272
1273
1274 /* Call the agent to import a key into the agent.  */
1275 gpg_error_t
1276 gpgsm_agent_import_key (ctrl_t ctrl, const void *key, size_t keylen)
1277 {
1278   gpg_error_t err;
1279   struct import_key_parm_s parm;
1280
1281   err = start_agent (ctrl);
1282   if (err)
1283     return err;
1284
1285   parm.ctrl   = ctrl;
1286   parm.ctx    = agent_ctx;
1287   parm.key    = key;
1288   parm.keylen = keylen;
1289
1290   err = assuan_transact (agent_ctx, "IMPORT_KEY",
1291                          NULL, NULL, inq_import_key_parms, &parm, NULL, NULL);
1292   return err;
1293 }
1294
1295
1296 \f
1297 /* Receive a secret key from the agent.  KEYGRIP is the hexified
1298    keygrip, DESC a prompt to be displayed with the agent's passphrase
1299    question (needs to be plus+percent escaped).  On success the key is
1300    stored as a canonical S-expression at R_RESULT and R_RESULTLEN. */
1301 gpg_error_t
1302 gpgsm_agent_export_key (ctrl_t ctrl, const char *keygrip, const char *desc,
1303                         unsigned char **r_result, size_t *r_resultlen)
1304 {
1305   gpg_error_t err;
1306   membuf_t data;
1307   size_t len;
1308   unsigned char *buf;
1309   char line[ASSUAN_LINELENGTH];
1310   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1311
1312   *r_result = NULL;
1313
1314   err = start_agent (ctrl);
1315   if (err)
1316     return err;
1317
1318   if (desc)
1319     {
1320       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1321       err = assuan_transact (agent_ctx, line,
1322                              NULL, NULL, NULL, NULL, NULL, NULL);
1323       if (err)
1324         return err;
1325     }
1326
1327   snprintf (line, DIM(line)-1, "EXPORT_KEY %s", keygrip);
1328
1329   init_membuf_secure (&data, 1024);
1330   err = assuan_transact (agent_ctx, line,
1331                          put_membuf_cb, &data,
1332                          default_inq_cb, &inq_parm, NULL, NULL);
1333   if (err)
1334     {
1335       xfree (get_membuf (&data, &len));
1336       return err;
1337     }
1338   buf = get_membuf (&data, &len);
1339   if (!buf)
1340     return gpg_error_from_syserror ();
1341   *r_result = buf;
1342   *r_resultlen = len;
1343   return 0;
1344 }