Create a pkcs#10 request directly from a card.
[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 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
41
42 static assuan_context_t agent_ctx = NULL;
43
44
45 struct cipher_parm_s
46 {
47   ctrl_t ctrl;
48   assuan_context_t ctx;
49   const unsigned char *ciphertext;
50   size_t ciphertextlen;
51 };
52
53 struct genkey_parm_s
54 {
55   ctrl_t ctrl;
56   assuan_context_t ctx;
57   const unsigned char *sexp;
58   size_t sexplen;
59 };
60
61 struct learn_parm_s
62 {
63   int error;
64   ctrl_t ctrl;
65   assuan_context_t ctx;
66   membuf_t *data;
67 };
68
69
70 \f
71 /* Try to connect to the agent via socket or fork it off and work by
72    pipes.  Handle the server's initial greeting */
73 static int
74 start_agent (ctrl_t ctrl)
75 {
76   int rc;
77
78   if (agent_ctx)
79     rc = 0;      /* fixme: We need a context for each thread or
80                     serialize the access to the agent (which is
81                     suitable given that the agent is not MT. */
82   else
83     {
84       rc = start_new_gpg_agent (&agent_ctx,
85                                 GPG_ERR_SOURCE_DEFAULT,
86                                 opt.homedir,
87                                 opt.agent_program,
88                                 opt.display, opt.ttyname, opt.ttytype,
89                                 opt.lc_ctype, opt.lc_messages,
90                                 opt.xauthority, opt.pinentry_user_data,
91                                 opt.verbose, DBG_ASSUAN,
92                                 gpgsm_status2, ctrl);
93       
94       if (!rc)
95         {
96           /* Tell the agent that we support Pinentry notifications.  No
97              error checking so that it will work also with older
98              agents.  */
99           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
100                            NULL, NULL, NULL, NULL, NULL, NULL);
101         }
102     }
103
104   if (!ctrl->agent_seen)
105     {
106       ctrl->agent_seen = 1;
107       audit_log_ok (ctrl->audit, AUDIT_AGENT_READY, rc);
108     }
109
110   return rc;
111 }
112
113
114
115 static int
116 membuf_data_cb (void *opaque, const void *buffer, size_t length)
117 {
118   membuf_t *data = opaque;
119
120   if (buffer)
121     put_membuf (data, buffer, length);
122   return 0;
123 }
124   
125
126 /* This is the default inquiry callback.  It mainly handles the
127    Pinentry notifications.  */
128 static int
129 default_inq_cb (void *opaque, const char *line)
130 {
131   gpg_error_t err;
132   ctrl_t ctrl = opaque;
133
134   if (!strncmp (line, "PINENTRY_LAUNCHED", 17) && (line[17]==' '||!line[17]))
135     {
136       err = gpgsm_proxy_pinentry_notify (ctrl, line);
137       if (err)
138         log_error (_("failed to proxy %s inquiry to client\n"), 
139                    "PINENTRY_LAUNCHED");
140       /* We do not pass errors to avoid breaking other code.  */
141     }
142   else
143     log_error ("ignoring gpg-agent inquiry `%s'\n", line);
144
145   return 0;
146 }
147
148
149
150 \f
151 /* Call the agent to do a sign operation using the key identified by
152    the hex string KEYGRIP. */
153 int
154 gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
155                     unsigned char *digest, size_t digestlen, int digestalgo,
156                     unsigned char **r_buf, size_t *r_buflen )
157 {
158   int rc, i;
159   char *p, line[ASSUAN_LINELENGTH];
160   membuf_t data;
161   size_t len;
162
163   *r_buf = NULL;
164   rc = start_agent (ctrl);
165   if (rc)
166     return rc;
167
168   if (digestlen*2 + 50 > DIM(line))
169     return gpg_error (GPG_ERR_GENERAL);
170
171   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
172   if (rc)
173     return rc;
174
175   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
176   line[DIM(line)-1] = 0;
177   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
178   if (rc)
179     return rc;
180
181   if (desc)
182     {
183       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
184       line[DIM(line)-1] = 0;
185       rc = assuan_transact (agent_ctx, line,
186                             NULL, NULL, NULL, NULL, NULL, NULL);
187       if (rc)
188         return rc;
189     }
190
191   sprintf (line, "SETHASH %d ", digestalgo);
192   p = line + strlen (line);
193   for (i=0; i < digestlen ; i++, p += 2 )
194     sprintf (p, "%02X", digest[i]);
195   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
196   if (rc)
197     return rc;
198
199   init_membuf (&data, 1024);
200   rc = assuan_transact (agent_ctx, "PKSIGN",
201                         membuf_data_cb, &data, default_inq_cb, ctrl,
202                         NULL, NULL);
203   if (rc)
204     {
205       xfree (get_membuf (&data, &len));
206       return rc;
207     }
208   *r_buf = get_membuf (&data, r_buflen);
209
210   if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
211     {
212       xfree (*r_buf); *r_buf = NULL;
213       return gpg_error (GPG_ERR_INV_VALUE);
214     }
215
216   return *r_buf? 0 : out_of_core ();
217 }
218
219
220 /* Call the scdaemon to do a sign operation using the key identified by
221    the hex string KEYID. */
222 int
223 gpgsm_scd_pksign (ctrl_t ctrl, const char *keyid, const char *desc,
224                   unsigned char *digest, size_t digestlen, int digestalgo,
225                   unsigned char **r_buf, size_t *r_buflen )
226 {
227   int rc, i;
228   char *p, line[ASSUAN_LINELENGTH];
229   membuf_t data;
230   size_t len;
231   const char *hashopt;
232   unsigned char *sigbuf;
233   size_t sigbuflen;
234
235   (void)desc;
236
237   *r_buf = NULL;
238
239   switch(digestalgo)
240     {
241     case GCRY_MD_SHA1:  hashopt = "--hash=sha1"; break;
242     case GCRY_MD_RMD160:hashopt = "--hash=rmd160"; break;
243     case GCRY_MD_MD5:   hashopt = "--hash=md5"; break;
244     case GCRY_MD_SHA256:hashopt = "--hash=sha256"; break;
245     default: 
246       return gpg_error (GPG_ERR_DIGEST_ALGO);
247     }
248
249   rc = start_agent (ctrl);
250   if (rc)
251     return rc;
252
253   if (digestlen*2 + 50 > DIM(line))
254     return gpg_error (GPG_ERR_GENERAL);
255
256   p = stpcpy (line, "SCD SETDATA " );
257   for (i=0; i < digestlen ; i++, p += 2 )
258     sprintf (p, "%02X", digest[i]);
259   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
260   if (rc)
261     return rc;
262
263   init_membuf (&data, 1024);
264
265   snprintf (line, DIM(line)-1, "SCD PKSIGN %s %s", hashopt, keyid);
266   line[DIM(line)-1] = 0;
267   rc = assuan_transact (agent_ctx, line,
268                         membuf_data_cb, &data, default_inq_cb, ctrl,
269                         NULL, NULL);
270   if (rc)
271     {
272       xfree (get_membuf (&data, &len));
273       return rc;
274     }
275   sigbuf = get_membuf (&data, &sigbuflen);
276
277   /* Create an S-expression from it which is formatted like this:
278      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" Fixme: If a card ever
279      creates non-RSA keys we need to change things. */
280   *r_buflen = 21 + 11 + sigbuflen + 4;
281   p = xtrymalloc (*r_buflen);
282   *r_buf = (unsigned char*)p;
283   if (!p)
284     {
285       xfree (sigbuf);
286       return 0;
287     }
288   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
289   sprintf (p, "%u:", (unsigned int)sigbuflen);
290   p += strlen (p);
291   memcpy (p, sigbuf, sigbuflen);
292   p += sigbuflen;
293   strcpy (p, ")))");
294   xfree (sigbuf);
295
296   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
297   return  0;
298 }
299
300
301
302 \f
303 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
304    assuan_transact talkes care of flushing and writing the end */
305 static int
306 inq_ciphertext_cb (void *opaque, const char *line)
307 {
308   struct cipher_parm_s *parm = opaque; 
309   int rc;
310
311   if (!strncmp (line, "CIPHERTEXT", 10) && (line[10]==' '||!line[10]))
312     {
313       assuan_begin_confidential (parm->ctx);
314       rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
315       assuan_end_confidential (parm->ctx);
316     }
317   else
318     rc = default_inq_cb (parm->ctrl, line);
319
320   return rc; 
321 }
322
323
324 /* Call the agent to do a decrypt operation using the key identified by
325    the hex string KEYGRIP. */
326 int
327 gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
328                        ksba_const_sexp_t ciphertext, 
329                        char **r_buf, size_t *r_buflen )
330 {
331   int rc;
332   char line[ASSUAN_LINELENGTH];
333    membuf_t data;
334   struct cipher_parm_s cipher_parm;
335   size_t n, len;
336   char *p, *buf, *endp;
337   size_t ciphertextlen;
338   
339   if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
340     return gpg_error (GPG_ERR_INV_VALUE);
341   *r_buf = NULL;
342
343   ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
344   if (!ciphertextlen)
345     return gpg_error (GPG_ERR_INV_VALUE);
346
347   rc = start_agent (ctrl);
348   if (rc)
349     return rc;
350
351   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
352   if (rc)
353     return rc;
354
355   assert ( DIM(line) >= 50 );
356   snprintf (line, DIM(line)-1, "SETKEY %s", keygrip);
357   line[DIM(line)-1] = 0;
358   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
359   if (rc)
360     return rc;
361
362   if (desc)
363     {
364       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
365       line[DIM(line)-1] = 0;
366       rc = assuan_transact (agent_ctx, line,
367                             NULL, NULL, NULL, NULL, NULL, NULL);
368       if (rc)
369         return rc;
370     }
371
372   init_membuf (&data, 1024);
373   cipher_parm.ctrl = ctrl;
374   cipher_parm.ctx = agent_ctx;
375   cipher_parm.ciphertext = ciphertext;
376   cipher_parm.ciphertextlen = ciphertextlen;
377   rc = assuan_transact (agent_ctx, "PKDECRYPT",
378                         membuf_data_cb, &data,
379                         inq_ciphertext_cb, &cipher_parm, NULL, NULL);
380   if (rc)
381     {
382       xfree (get_membuf (&data, &len));
383       return rc;
384     }
385
386   put_membuf (&data, "", 1); /* Make sure it is 0 terminated. */
387   buf = get_membuf (&data, &len);
388   if (!buf)
389     return gpg_error (GPG_ERR_ENOMEM);
390   assert (len); /* (we forced Nul termination.)  */
391
392   if (*buf == '(')
393     {
394       if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
395         return gpg_error (GPG_ERR_INV_SEXP);
396       len -= 11;   /* Count only the data of the second part. */
397       p = buf + 8; /* Skip leading parenthesis and the value tag. */
398     }
399   else
400     {
401       /* For compatibility with older gpg-agents handle the old style
402          incomplete S-exps. */
403       len--;      /* Do not count the Nul. */
404       p = buf;
405     }
406
407   n = strtoul (p, &endp, 10);
408   if (!n || *endp != ':')
409     return gpg_error (GPG_ERR_INV_SEXP);
410   endp++;
411   if (endp-p+n > len)
412     return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
413   
414   memmove (buf, endp, n);
415
416   *r_buflen = n;
417   *r_buf = buf;
418   return 0;
419 }
420
421
422
423
424 \f
425 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
426    assuan_transact takes care of flushing and writing the end */
427 static int
428 inq_genkey_parms (void *opaque, const char *line)
429 {
430   struct genkey_parm_s *parm = opaque; 
431   int rc;
432
433   if (!strncmp (line, "KEYPARAM", 8) && (line[8]==' '||!line[8]))
434     {
435       rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);
436     }
437   else
438     rc = default_inq_cb (parm->ctrl, line);
439
440   return rc; 
441 }
442
443
444 \f
445 /* Call the agent to generate a newkey */
446 int
447 gpgsm_agent_genkey (ctrl_t ctrl,
448                     ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey)
449 {
450   int rc;
451   struct genkey_parm_s gk_parm;
452   membuf_t data;
453   size_t len;
454   unsigned char *buf;
455
456   *r_pubkey = NULL;
457   rc = start_agent (ctrl);
458   if (rc)
459     return rc;
460
461   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
462   if (rc)
463     return rc;
464
465   init_membuf (&data, 1024);
466   gk_parm.ctrl = ctrl;
467   gk_parm.ctx = agent_ctx;
468   gk_parm.sexp = keyparms;
469   gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
470   if (!gk_parm.sexplen)
471     return gpg_error (GPG_ERR_INV_VALUE);
472   rc = assuan_transact (agent_ctx, "GENKEY",
473                         membuf_data_cb, &data, 
474                         inq_genkey_parms, &gk_parm, NULL, NULL);
475   if (rc)
476     {
477       xfree (get_membuf (&data, &len));
478       return rc;
479     }
480   buf = get_membuf (&data, &len);
481   if (!buf)
482     return gpg_error (GPG_ERR_ENOMEM);
483   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
484     {
485       xfree (buf);
486       return gpg_error (GPG_ERR_INV_SEXP);
487     }
488   *r_pubkey = buf;
489   return 0;
490 }
491
492 \f
493 /* Call the agent to read the public key part for a given keygrip.  If
494    FROMCARD is true, the key is directly read from the current
495    smartcard. In this case HEXKEYGRIP should be the keyID
496    (e.g. OPENPGP.3). */
497 int
498 gpgsm_agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
499                      ksba_sexp_t *r_pubkey)
500 {
501   int rc;
502   membuf_t data;
503   size_t len;
504   unsigned char *buf;
505   char line[ASSUAN_LINELENGTH];
506
507   *r_pubkey = NULL;
508   rc = start_agent (ctrl);
509   if (rc)
510     return rc;
511
512   rc = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
513   if (rc)
514     return rc;
515
516   snprintf (line, DIM(line)-1, "%sREADKEY %s",
517             fromcard? "SCD ":"", hexkeygrip);
518   line[DIM(line)-1] = 0;
519
520   init_membuf (&data, 1024);
521   rc = assuan_transact (agent_ctx, line,
522                         membuf_data_cb, &data, 
523                         default_inq_cb, ctrl, NULL, NULL);
524   if (rc)
525     {
526       xfree (get_membuf (&data, &len));
527       return rc;
528     }
529   buf = get_membuf (&data, &len);
530   if (!buf)
531     return gpg_error (GPG_ERR_ENOMEM);
532   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
533     {
534       xfree (buf);
535       return gpg_error (GPG_ERR_INV_SEXP);
536     }
537   *r_pubkey = buf;
538   return 0;
539 }
540
541
542 \f
543 /* Take the serial number from LINE and return it verbatim in a newly
544    allocated string.  We make sure that only hex characters are
545    returned. */
546 static char *
547 store_serialno (const char *line)
548 {
549   const char *s;
550   char *p;
551
552   for (s=line; hexdigitp (s); s++)
553     ;
554   p = xtrymalloc (s + 1 - line);
555   if (p)
556     {
557       memcpy (p, line, s-line);
558       p[s-line] = 0;
559     }
560   return p;
561 }
562
563
564 /* Callback for the gpgsm_agent_serialno fucntion.  */
565 static int
566 scd_serialno_status_cb (void *opaque, const char *line)
567 {
568   char **r_serialno = opaque;
569   const char *keyword = line;
570   int keywordlen;
571
572   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
573     ;
574   while (spacep (line))
575     line++;
576
577   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
578     {
579       xfree (*r_serialno);
580       *r_serialno = store_serialno (line);
581     }
582
583   return 0;
584 }
585
586
587 /* Call the agent to read the serial number of the current card.  */
588 int
589 gpgsm_agent_scd_serialno (ctrl_t ctrl, char **r_serialno)
590 {
591   int rc;
592   char *serialno = NULL;
593  
594   *r_serialno = NULL;
595   rc = start_agent (ctrl);
596   if (rc)
597     return rc;
598
599   rc = assuan_transact (agent_ctx, "SCD SERIALNO",
600                         NULL, NULL,
601                         default_inq_cb, ctrl,
602                         scd_serialno_status_cb, &serialno);
603   if (!rc && !serialno)
604     rc = gpg_error (GPG_ERR_INTERNAL);
605   if (rc)
606     {
607       xfree (serialno);
608       return rc;
609     }
610   *r_serialno = serialno;
611   return 0;
612 }
613
614
615 \f
616 /* Callback for the gpgsm_agent_serialno fucntion.  */
617 static int
618 scd_keypairinfo_status_cb (void *opaque, const char *line)
619 {
620   strlist_t *listaddr = opaque;
621   const char *keyword = line;
622   int keywordlen;
623   strlist_t sl;
624   char *p;
625
626   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
627     ;
628   while (spacep (line))
629     line++;
630
631   if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
632     {
633       sl = append_to_strlist (listaddr, line);
634       p = sl->d;
635       /* Make sure that we only have two tokes so that future
636          extensions of the format won't change the format expected by
637          the caller.  */
638       while (*p && !spacep (p))
639         p++;
640       if (*p)
641         {
642           while (spacep (p))
643             p++;
644           while (*p && !spacep (p))
645             p++;
646           *p = 0;
647         }
648     }
649
650   return 0;
651 }
652
653
654 /* Call the agent to read the keypairinfo lines of the current card.
655    The list is returned as a string made up of the keygrip, a space
656    and the keyid.  */
657 int
658 gpgsm_agent_scd_keypairinfo (ctrl_t ctrl, strlist_t *r_list)
659 {
660   int rc;
661   strlist_t list = NULL;
662  
663   *r_list = NULL;
664   rc = start_agent (ctrl);
665   if (rc)
666     return rc;
667
668   rc = assuan_transact (agent_ctx, "SCD LEARN --force",
669                         NULL, NULL,
670                         default_inq_cb, ctrl,
671                         scd_keypairinfo_status_cb, &list);
672   if (!rc && !list)
673     rc = gpg_error (GPG_ERR_NO_DATA);
674   if (rc)
675     {
676       free_strlist (list);
677       return rc;
678     }
679   *r_list = list;
680   return 0;
681 }
682
683
684 \f
685 static int
686 istrusted_status_cb (void *opaque, const char *line)
687 {
688   struct rootca_flags_s *flags = opaque;
689
690   if (!strncmp (line, "TRUSTLISTFLAG", 13) && (line[13]==' ' || !line[13]))
691     {
692       for (line += 13; *line == ' '; line++)
693         ;
694       if (!strncmp (line, "relax", 5) && (line[5] == ' ' || !line[5]))
695         flags->relax = 1;
696       else if (!strncmp (line, "cm", 2) && (line[2] == ' ' || !line[2]))
697         flags->chain_model = 1;
698     }
699   return 0;
700 }
701
702
703
704 /* Ask the agent whether the certificate is in the list of trusted
705    keys.  The certificate is either specified by the CERT object or by
706    the fingerprint HEXFPR.  ROOTCA_FLAGS is guaranteed to be cleared
707    on error. */
708 int
709 gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert, const char *hexfpr,
710                        struct rootca_flags_s *rootca_flags)
711 {
712   int rc;
713   char line[ASSUAN_LINELENGTH];
714
715   memset (rootca_flags, 0, sizeof *rootca_flags);
716
717   if (cert && hexfpr)
718     return gpg_error (GPG_ERR_INV_ARG);
719
720   rc = start_agent (ctrl);
721   if (rc)
722     return rc;
723
724   if (hexfpr)
725     {
726       snprintf (line, DIM(line)-1, "ISTRUSTED %s", hexfpr);
727       line[DIM(line)-1] = 0;
728     }
729   else
730     {
731       char *fpr;
732
733       fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
734       if (!fpr)
735         {
736           log_error ("error getting the fingerprint\n");
737           return gpg_error (GPG_ERR_GENERAL);
738         }
739       
740       snprintf (line, DIM(line)-1, "ISTRUSTED %s", fpr);
741       line[DIM(line)-1] = 0;
742       xfree (fpr);
743     }
744
745   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
746                         istrusted_status_cb, rootca_flags);
747   if (!rc)
748     rootca_flags->valid = 1;
749   return rc;
750 }
751
752 /* Ask the agent to mark CERT as a trusted Root-CA one */
753 int
754 gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert)
755 {
756   int rc;
757   char *fpr, *dn, *dnfmt;
758   char line[ASSUAN_LINELENGTH];
759
760   rc = start_agent (ctrl);
761   if (rc)
762     return rc;
763
764   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
765   if (!fpr)
766     {
767       log_error ("error getting the fingerprint\n");
768       return gpg_error (GPG_ERR_GENERAL);
769     }
770
771   dn = ksba_cert_get_issuer (cert, 0);
772   if (!dn)
773     {
774       xfree (fpr);
775       return gpg_error (GPG_ERR_GENERAL);
776     }
777   dnfmt = gpgsm_format_name2 (dn, 0);
778   xfree (dn);
779   if (!dnfmt)
780     return gpg_error_from_syserror ();
781   snprintf (line, DIM(line)-1, "MARKTRUSTED %s S %s", fpr, dnfmt);
782   line[DIM(line)-1] = 0;
783   ksba_free (dnfmt);
784   xfree (fpr);
785
786   rc = assuan_transact (agent_ctx, line, NULL, NULL,
787                         default_inq_cb, ctrl, NULL, NULL);
788   return rc;
789 }
790
791
792 \f
793 /* Ask the agent whether the a corresponding secret key is available
794    for the given keygrip */
795 int
796 gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip)
797 {
798   int rc;
799   char line[ASSUAN_LINELENGTH];
800
801   rc = start_agent (ctrl);
802   if (rc)
803     return rc;
804
805   if (!hexkeygrip || strlen (hexkeygrip) != 40)
806     return gpg_error (GPG_ERR_INV_VALUE);
807
808   snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
809   line[DIM(line)-1] = 0;
810
811   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
812   return rc;
813 }
814
815 \f
816 static int
817 learn_status_cb (void *opaque, const char *line)
818 {
819   struct learn_parm_s *parm = opaque;
820
821   /* Pass progress data to the caller.  */
822   if (!strncmp (line, "PROGRESS", 8) && (line[8]==' ' || !line[8]))
823     {
824       if (parm->ctrl)
825         {
826           for (line += 8; *line == ' '; line++)
827             ;
828           if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, line))
829             return gpg_error (GPG_ERR_ASS_CANCELED);
830         }
831     }
832   return 0;
833 }
834
835 static int
836 learn_cb (void *opaque, const void *buffer, size_t length)
837 {
838   struct learn_parm_s *parm = opaque;
839   size_t len;
840   char *buf;
841   ksba_cert_t cert;
842   int rc;
843
844   if (parm->error)
845     return 0;
846
847   if (buffer)
848     {
849       put_membuf (parm->data, buffer, length);
850       return 0;
851     }
852   /* END encountered - process what we have */
853   buf = get_membuf (parm->data, &len);
854   if (!buf)
855     {
856       parm->error = gpg_error (GPG_ERR_ENOMEM);
857       return 0;
858     }
859
860   if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, "learncard C 0 0"))
861     return gpg_error (GPG_ERR_ASS_CANCELED);
862
863   /* FIXME: this should go into import.c */
864   rc = ksba_cert_new (&cert);
865   if (rc)
866     {
867       parm->error = rc;
868       return 0;
869     }
870   rc = ksba_cert_init_from_mem (cert, buf, len);
871   if (rc)
872     {
873       log_error ("failed to parse a certificate: %s\n", gpg_strerror (rc));
874       ksba_cert_release (cert);
875       parm->error = rc;
876       return 0;
877     }
878
879   rc = gpgsm_basic_cert_check (parm->ctrl, cert);
880   if (gpg_err_code (rc) == GPG_ERR_MISSING_CERT)
881     { /* For later use we store it in the ephemeral database. */
882       log_info ("issuer certificate missing - storing as ephemeral\n");
883       keydb_store_cert (cert, 1, NULL);
884     }
885   else if (rc)
886     log_error ("invalid certificate: %s\n", gpg_strerror (rc));
887   else
888     {
889       int existed;
890
891       if (!keydb_store_cert (cert, 0, &existed))
892         {
893           if (opt.verbose > 1 && existed)
894             log_info ("certificate already in DB\n");
895           else if (opt.verbose && !existed)
896             log_info ("certificate imported\n");
897         }
898     }
899
900   ksba_cert_release (cert);
901   init_membuf (parm->data, 4096);
902   return 0;
903 }
904   
905 /* Call the agent to learn about a smartcard */
906 int
907 gpgsm_agent_learn (ctrl_t ctrl)
908 {
909   int rc;
910   struct learn_parm_s learn_parm;
911   membuf_t data;
912   size_t len;
913
914   rc = start_agent (ctrl);
915   if (rc)
916     return rc;
917
918   init_membuf (&data, 4096);
919   learn_parm.error = 0;
920   learn_parm.ctrl = ctrl;
921   learn_parm.ctx = agent_ctx;
922   learn_parm.data = &data;
923   rc = assuan_transact (agent_ctx, "LEARN --send",
924                         learn_cb, &learn_parm, 
925                         NULL, NULL, 
926                         learn_status_cb, &learn_parm);
927   xfree (get_membuf (&data, &len));
928   if (rc)
929     return rc;
930   return learn_parm.error;
931 }
932
933 \f
934 /* Ask the agent to change the passphrase of the key identified by
935    HEXKEYGRIP. If DESC is not NULL, display instead of the default
936    description message. */
937 int
938 gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
939 {
940   int rc;
941   char line[ASSUAN_LINELENGTH];
942
943   rc = start_agent (ctrl);
944   if (rc)
945     return rc;
946
947   if (!hexkeygrip || strlen (hexkeygrip) != 40)
948     return gpg_error (GPG_ERR_INV_VALUE);
949
950   if (desc)
951     {
952       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
953       line[DIM(line)-1] = 0;
954       rc = assuan_transact (agent_ctx, line,
955                             NULL, NULL, NULL, NULL, NULL, NULL);
956       if (rc)
957         return rc;
958     }
959
960   snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
961   line[DIM(line)-1] = 0;
962
963   rc = assuan_transact (agent_ctx, line, NULL, NULL,
964                         default_inq_cb, ctrl, NULL, NULL);
965   return rc;
966 }
967
968
969 \f
970 /* Ask the agent to pop up a confirmation dialog with the text DESC
971    and an okay and cancel button.  */
972 gpg_error_t
973 gpgsm_agent_get_confirmation (ctrl_t ctrl, const char *desc)
974 {
975   int rc;
976   char line[ASSUAN_LINELENGTH];
977
978   rc = start_agent (ctrl);
979   if (rc)
980     return rc;
981
982   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", desc);
983   line[DIM(line)-1] = 0;
984
985   rc = assuan_transact (agent_ctx, line, NULL, NULL,
986                         default_inq_cb, ctrl, NULL, NULL);
987   return rc;
988 }
989
990
991 \f
992 /* Return 0 if the agent is alive.  This is useful to make sure that
993    an agent has been started. */
994 gpg_error_t
995 gpgsm_agent_send_nop (ctrl_t ctrl)
996 {
997   int rc;
998
999   rc = start_agent (ctrl);
1000   if (!rc)
1001     rc = assuan_transact (agent_ctx, "NOP",
1002                           NULL, NULL, NULL, NULL, NULL, NULL);
1003   return rc;
1004 }
1005
1006
1007 \f
1008 static int
1009 keyinfo_status_cb (void *opaque, const char *line)
1010 {
1011   char **serialno = opaque;
1012   const char *s, *s2;
1013
1014   if (!strncmp (line, "KEYINFO ", 8) && !*serialno)
1015     {
1016       s = strchr (line+8, ' ');
1017       if (s && s[1] == 'T' && s[2] == ' ' && s[3])
1018         {
1019           s += 3;
1020           s2 = strchr (s, ' ');
1021           if ( s2 > s )
1022             {
1023               *serialno = xtrymalloc ((s2 - s)+1);
1024               if (*serialno)
1025                 {
1026                   memcpy (*serialno, s, s2 - s);
1027                   (*serialno)[s2 - s] = 0;
1028                 }
1029             }
1030         }
1031     }
1032   return 0;
1033 }
1034
1035 /* Return the serial number for a secret key.  If the returned serial
1036    number is NULL, the key is not stored on a smartcard.  Caller needs
1037    to free R_SERIALNO.  */
1038 gpg_error_t
1039 gpgsm_agent_keyinfo (ctrl_t ctrl, const char *hexkeygrip, char **r_serialno)
1040 {
1041   gpg_error_t err;
1042   char line[ASSUAN_LINELENGTH];
1043   char *serialno = NULL;
1044
1045   *r_serialno = NULL;
1046
1047   err = start_agent (ctrl);
1048   if (err)
1049     return err;
1050
1051   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1052     return gpg_error (GPG_ERR_INV_VALUE);
1053
1054   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1055   line[DIM(line)-1] = 0;
1056
1057   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1058                          keyinfo_status_cb, &serialno);
1059   if (!err && serialno)
1060     {
1061       /* Sanity check for bad characters.  */
1062       if (strpbrk (serialno, ":\n\r"))
1063         err = GPG_ERR_INV_VALUE;
1064     }
1065   if (err)
1066     xfree (serialno);
1067   else
1068     *r_serialno = serialno;
1069   return err;
1070 }
1071