Implemented the chain model for X.509 validation.
[gnupg.git] / sm / call-agent.c
1 /* call-agent.c - divert operations to the agent
2  *      Copyright (C) 2001, 2002, 2003, 2005 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 <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <unistd.h> 
26 #include <time.h>
27 #include <assert.h>
28 #ifdef HAVE_LOCALE_H
29 #include <locale.h>
30 #endif
31
32 #include "gpgsm.h"
33 #include <gcrypt.h>
34 #include <assuan.h>
35 #include "i18n.h"
36 #include "asshelp.h"
37 #include "keydb.h" /* fixme: Move this to import.c */
38 #include "membuf.h"
39
40
41 static assuan_context_t agent_ctx = NULL;
42
43
44 struct cipher_parm_s
45 {
46   assuan_context_t ctx;
47   const unsigned char *ciphertext;
48   size_t ciphertextlen;
49 };
50
51 struct genkey_parm_s
52 {
53   assuan_context_t ctx;
54   const unsigned char *sexp;
55   size_t sexplen;
56 };
57
58 struct learn_parm_s
59 {
60   int error;
61   assuan_context_t ctx;
62   membuf_t *data;
63 };
64
65
66 \f
67 /* Try to connect to the agent via socket or fork it off and work by
68    pipes.  Handle the server's initial greeting */
69 static int
70 start_agent (ctrl_t ctrl)
71 {
72   if (agent_ctx)
73     return 0; /* fixme: We need a context for each thread or serialize
74                  the access to the agent (which is suitable given that
75                  the agent is not MT. */
76
77
78   return start_new_gpg_agent (&agent_ctx,
79                               GPG_ERR_SOURCE_DEFAULT,
80                               opt.homedir,
81                               opt.agent_program,
82                               opt.display, opt.ttyname, opt.ttytype,
83                               opt.lc_ctype, opt.lc_messages,
84                               opt.verbose, DBG_ASSUAN,
85                               gpgsm_status2, ctrl);
86
87 }
88
89
90
91 static int
92 membuf_data_cb (void *opaque, const void *buffer, size_t length)
93 {
94   membuf_t *data = opaque;
95
96   if (buffer)
97     put_membuf (data, buffer, length);
98   return 0;
99 }
100   
101
102
103 \f
104 /* Call the agent to do a sign operation using the key identified by
105    the hex string KEYGRIP. */
106 int
107 gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
108                     unsigned char *digest, size_t digestlen, int digestalgo,
109                     unsigned char **r_buf, size_t *r_buflen )
110 {
111   int rc, i;
112   char *p, line[ASSUAN_LINELENGTH];
113   membuf_t data;
114   size_t len;
115
116   *r_buf = NULL;
117   rc = start_agent (ctrl);
118   if (rc)
119     return rc;
120
121   if (digestlen*2 + 50 > DIM(line))
122     return gpg_error (GPG_ERR_GENERAL);
123
124   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
125   if (rc)
126     return rc;
127
128   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
129   line[DIM(line)-1] = 0;
130   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
131   if (rc)
132     return rc;
133
134   if (desc)
135     {
136       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
137       line[DIM(line)-1] = 0;
138       rc = assuan_transact (agent_ctx, line,
139                             NULL, NULL, NULL, NULL, NULL, NULL);
140       if (rc)
141         return rc;
142     }
143
144   sprintf (line, "SETHASH %d ", digestalgo);
145   p = line + strlen (line);
146   for (i=0; i < digestlen ; i++, p += 2 )
147     sprintf (p, "%02X", digest[i]);
148   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
149   if (rc)
150     return rc;
151
152   init_membuf (&data, 1024);
153   rc = assuan_transact (agent_ctx, "PKSIGN",
154                         membuf_data_cb, &data, NULL, NULL, NULL, NULL);
155   if (rc)
156     {
157       xfree (get_membuf (&data, &len));
158       return rc;
159     }
160   *r_buf = get_membuf (&data, r_buflen);
161
162   if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
163     {
164       xfree (*r_buf); *r_buf = NULL;
165       return gpg_error (GPG_ERR_INV_VALUE);
166     }
167
168   return *r_buf? 0 : out_of_core ();
169 }
170
171
172 /* Call the scdaemon to do a sign operation using the key identified by
173    the hex string KEYID. */
174 int
175 gpgsm_scd_pksign (ctrl_t ctrl, const char *keyid, const char *desc,
176                   unsigned char *digest, size_t digestlen, int digestalgo,
177                   unsigned char **r_buf, size_t *r_buflen )
178 {
179   int rc, i;
180   char *p, line[ASSUAN_LINELENGTH];
181   membuf_t data;
182   size_t len;
183   const char *hashopt;
184   unsigned char *sigbuf;
185   size_t sigbuflen;
186
187   *r_buf = NULL;
188
189   switch(digestalgo)
190     {
191     case GCRY_MD_SHA1:  hashopt = "--hash=sha1"; break;
192     case GCRY_MD_RMD160:hashopt = "--hash=rmd160"; break;
193     case GCRY_MD_MD5:   hashopt = "--hash=md5"; break;
194     case GCRY_MD_SHA256:hashopt = "--hash=sha256"; break;
195     default: 
196       return gpg_error (GPG_ERR_DIGEST_ALGO);
197     }
198
199   rc = start_agent (ctrl);
200   if (rc)
201     return rc;
202
203   if (digestlen*2 + 50 > DIM(line))
204     return gpg_error (GPG_ERR_GENERAL);
205
206   p = stpcpy (line, "SCD SETDATA " );
207   for (i=0; i < digestlen ; i++, p += 2 )
208     sprintf (p, "%02X", digest[i]);
209   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
210   if (rc)
211     return rc;
212
213   init_membuf (&data, 1024);
214
215   snprintf (line, DIM(line)-1, "SCD PKSIGN %s %s", hashopt, keyid);
216   line[DIM(line)-1] = 0;
217   rc = assuan_transact (agent_ctx, line,
218                         membuf_data_cb, &data, NULL, NULL, NULL, NULL);
219   if (rc)
220     {
221       xfree (get_membuf (&data, &len));
222       return rc;
223     }
224   sigbuf = get_membuf (&data, &sigbuflen);
225
226   /* Create an S-expression from it which is formatted like this:
227      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" Fixme: If a card ever
228      creates non-RSA keys we need to change things. */
229   *r_buflen = 21 + 11 + sigbuflen + 4;
230   p = xtrymalloc (*r_buflen);
231   *r_buf = (unsigned char*)p;
232   if (!p)
233     {
234       xfree (sigbuf);
235       return 0;
236     }
237   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
238   sprintf (p, "%u:", (unsigned int)sigbuflen);
239   p += strlen (p);
240   memcpy (p, sigbuf, sigbuflen);
241   p += sigbuflen;
242   strcpy (p, ")))");
243   xfree (sigbuf);
244
245   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
246   return  0;
247 }
248
249
250
251 \f
252 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
253    assuan_transact talkes care of flushing and writing the end */
254 static int
255 inq_ciphertext_cb (void *opaque, const char *keyword)
256 {
257   struct cipher_parm_s *parm = opaque; 
258   int rc;
259
260   assuan_begin_confidential (parm->ctx);
261   rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
262   assuan_end_confidential (parm->ctx);
263   return rc; 
264 }
265
266
267 /* Call the agent to do a decrypt operation using the key identified by
268    the hex string KEYGRIP. */
269 int
270 gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
271                        ksba_const_sexp_t ciphertext, 
272                        char **r_buf, size_t *r_buflen )
273 {
274   int rc;
275   char line[ASSUAN_LINELENGTH];
276   membuf_t data;
277   struct cipher_parm_s cipher_parm;
278   size_t n, len;
279   char *p, *buf, *endp;
280   size_t ciphertextlen;
281   
282   if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
283     return gpg_error (GPG_ERR_INV_VALUE);
284   *r_buf = NULL;
285
286   ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
287   if (!ciphertextlen)
288     return gpg_error (GPG_ERR_INV_VALUE);
289
290   rc = start_agent (ctrl);
291   if (rc)
292     return rc;
293
294   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
295   if (rc)
296     return rc;
297
298   assert ( DIM(line) >= 50 );
299   snprintf (line, DIM(line)-1, "SETKEY %s", keygrip);
300   line[DIM(line)-1] = 0;
301   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
302   if (rc)
303     return rc;
304
305   if (desc)
306     {
307       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
308       line[DIM(line)-1] = 0;
309       rc = assuan_transact (agent_ctx, line,
310                             NULL, NULL, NULL, NULL, NULL, NULL);
311       if (rc)
312         return rc;
313     }
314
315   init_membuf (&data, 1024);
316   cipher_parm.ctx = agent_ctx;
317   cipher_parm.ciphertext = ciphertext;
318   cipher_parm.ciphertextlen = ciphertextlen;
319   rc = assuan_transact (agent_ctx, "PKDECRYPT",
320                         membuf_data_cb, &data,
321                         inq_ciphertext_cb, &cipher_parm, NULL, NULL);
322   if (rc)
323     {
324       xfree (get_membuf (&data, &len));
325       return rc;
326     }
327
328   put_membuf (&data, "", 1); /* Make sure it is 0 terminated. */
329   buf = get_membuf (&data, &len);
330   if (!buf)
331     return gpg_error (GPG_ERR_ENOMEM);
332   assert (len); /* (we forced Nul termination.)  */
333
334   if (*buf == '(')
335     {
336       if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
337         return gpg_error (GPG_ERR_INV_SEXP);
338       len -= 11;   /* Count only the data of the second part. */
339       p = buf + 8; /* Skip leading parenthesis and the value tag. */
340     }
341   else
342     {
343       /* For compatibility with older gpg-agents handle the old style
344          incomplete S-exps. */
345       len--;      /* Do not count the Nul. */
346       p = buf;
347     }
348
349   n = strtoul (p, &endp, 10);
350   if (!n || *endp != ':')
351     return gpg_error (GPG_ERR_INV_SEXP);
352   endp++;
353   if (endp-p+n > len)
354     return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
355   
356   memmove (buf, endp, n);
357
358   *r_buflen = n;
359   *r_buf = buf;
360   return 0;
361 }
362
363
364
365
366 \f
367 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
368    assuan_transact takes care of flushing and writing the end */
369 static int
370 inq_genkey_parms (void *opaque, const char *keyword)
371 {
372   struct genkey_parm_s *parm = opaque; 
373   int rc;
374
375   rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);
376   return rc; 
377 }
378
379
380 \f
381 /* Call the agent to generate a newkey */
382 int
383 gpgsm_agent_genkey (ctrl_t ctrl,
384                     ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey)
385 {
386   int rc;
387   struct genkey_parm_s gk_parm;
388   membuf_t data;
389   size_t len;
390   unsigned char *buf;
391
392   *r_pubkey = NULL;
393   rc = start_agent (ctrl);
394   if (rc)
395     return rc;
396
397   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
398   if (rc)
399     return rc;
400
401   init_membuf (&data, 1024);
402   gk_parm.ctx = agent_ctx;
403   gk_parm.sexp = keyparms;
404   gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
405   if (!gk_parm.sexplen)
406     return gpg_error (GPG_ERR_INV_VALUE);
407   rc = assuan_transact (agent_ctx, "GENKEY",
408                         membuf_data_cb, &data, 
409                         inq_genkey_parms, &gk_parm, NULL, NULL);
410   if (rc)
411     {
412       xfree (get_membuf (&data, &len));
413       return rc;
414     }
415   buf = get_membuf (&data, &len);
416   if (!buf)
417     return gpg_error (GPG_ERR_ENOMEM);
418   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
419     {
420       xfree (buf);
421       return gpg_error (GPG_ERR_INV_SEXP);
422     }
423   *r_pubkey = buf;
424   return 0;
425 }
426
427 \f
428 /* Call the agent to read the public key part for a given keygrip.  If
429    FROMCARD is true, the key is directly read from the current
430    smartcard. In this case HEXKEYGRIP should be the keyID
431    (e.g. OPENPGP.3). */
432 int
433 gpgsm_agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
434                      ksba_sexp_t *r_pubkey)
435 {
436   int rc;
437   membuf_t data;
438   size_t len;
439   unsigned char *buf;
440   char line[ASSUAN_LINELENGTH];
441
442   *r_pubkey = NULL;
443   rc = start_agent (ctrl);
444   if (rc)
445     return rc;
446
447   rc = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
448   if (rc)
449     return rc;
450
451   snprintf (line, DIM(line)-1, "%sREADKEY %s",
452             fromcard? "SCD ":"", hexkeygrip);
453   line[DIM(line)-1] = 0;
454
455   init_membuf (&data, 1024);
456   rc = assuan_transact (agent_ctx, line,
457                         membuf_data_cb, &data, 
458                         NULL, NULL, NULL, NULL);
459   if (rc)
460     {
461       xfree (get_membuf (&data, &len));
462       return rc;
463     }
464   buf = get_membuf (&data, &len);
465   if (!buf)
466     return gpg_error (GPG_ERR_ENOMEM);
467   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
468     {
469       xfree (buf);
470       return gpg_error (GPG_ERR_INV_SEXP);
471     }
472   *r_pubkey = buf;
473   return 0;
474 }
475
476 \f
477
478 static int
479 istrusted_status_cb (void *opaque, const char *line)
480 {
481   struct rootca_flags_s *flags = opaque;
482
483   if (!strncmp (line, "TRUSTLISTFLAG", 13) && (line[13]==' ' || !line[13]))
484     {
485       for (line += 13; *line == ' '; line++)
486         ;
487       if (!strncmp (line, "relax", 5) && (line[5] == ' ' || !line[5]))
488         flags->relax = 1;
489       else if (!strncmp (line, "cm", 2) && (line[2] == ' ' || !line[2]))
490         flags->chain_model = 1;
491     }
492   return 0;
493 }
494
495
496
497 /* Ask the agent whether the certificate is in the list of trusted
498    keys.  ROOTCA_FLAGS is guaranteed to be cleared on error. */
499 int
500 gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert,
501                        struct rootca_flags_s *rootca_flags)
502 {
503   int rc;
504   char *fpr;
505   char line[ASSUAN_LINELENGTH];
506
507   memset (rootca_flags, 0, sizeof *rootca_flags);
508
509   rc = start_agent (ctrl);
510   if (rc)
511     return rc;
512
513   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
514   if (!fpr)
515     {
516       log_error ("error getting the fingerprint\n");
517       return gpg_error (GPG_ERR_GENERAL);
518     }
519
520   snprintf (line, DIM(line)-1, "ISTRUSTED %s", fpr);
521   line[DIM(line)-1] = 0;
522   xfree (fpr);
523
524   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
525                         istrusted_status_cb, rootca_flags);
526   if (!rc)
527     rootca_flags->valid = 1;
528   return rc;
529 }
530
531 /* Ask the agent to mark CERT as a trusted Root-CA one */
532 int
533 gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert)
534 {
535   int rc;
536   char *fpr, *dn;
537   char line[ASSUAN_LINELENGTH];
538
539   rc = start_agent (ctrl);
540   if (rc)
541     return rc;
542
543   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
544   if (!fpr)
545     {
546       log_error ("error getting the fingerprint\n");
547       return gpg_error (GPG_ERR_GENERAL);
548     }
549
550   dn = ksba_cert_get_issuer (cert, 0);
551   if (!dn)
552     {
553       xfree (fpr);
554       return gpg_error (GPG_ERR_GENERAL);
555     }
556   snprintf (line, DIM(line)-1, "MARKTRUSTED %s S %s", fpr, dn);
557   line[DIM(line)-1] = 0;
558   ksba_free (dn);
559   xfree (fpr);
560
561   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
562   return rc;
563 }
564
565
566 \f
567 /* Ask the agent whether the a corresponding secret key is available
568    for the given keygrip */
569 int
570 gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip)
571 {
572   int rc;
573   char line[ASSUAN_LINELENGTH];
574
575   rc = start_agent (ctrl);
576   if (rc)
577     return rc;
578
579   if (!hexkeygrip || strlen (hexkeygrip) != 40)
580     return gpg_error (GPG_ERR_INV_VALUE);
581
582   snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
583   line[DIM(line)-1] = 0;
584
585   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
586   return rc;
587 }
588
589 \f
590 static int
591 learn_cb (void *opaque, const void *buffer, size_t length)
592 {
593   struct learn_parm_s *parm = opaque;
594   size_t len;
595   char *buf;
596   ksba_cert_t cert;
597   int rc;
598
599   if (parm->error)
600     return 0;
601
602   if (buffer)
603     {
604       put_membuf (parm->data, buffer, length);
605       return 0;
606     }
607   /* END encountered - process what we have */
608   buf = get_membuf (parm->data, &len);
609   if (!buf)
610     {
611       parm->error = gpg_error (GPG_ERR_ENOMEM);
612       return 0;
613     }
614
615
616   /* FIXME: this should go into import.c */
617   rc = ksba_cert_new (&cert);
618   if (rc)
619     {
620       parm->error = rc;
621       return 0;
622     }
623   rc = ksba_cert_init_from_mem (cert, buf, len);
624   if (rc)
625     {
626       log_error ("failed to parse a certificate: %s\n", gpg_strerror (rc));
627       ksba_cert_release (cert);
628       parm->error = rc;
629       return 0;
630     }
631
632   rc = gpgsm_basic_cert_check (cert);
633   if (gpg_err_code (rc) == GPG_ERR_MISSING_CERT)
634     { /* For later use we store it in the ephemeral database. */
635       log_info ("issuer certificate missing - storing as ephemeral\n");
636       keydb_store_cert (cert, 1, NULL);
637     }
638   else if (rc)
639     log_error ("invalid certificate: %s\n", gpg_strerror (rc));
640   else
641     {
642       int existed;
643
644       if (!keydb_store_cert (cert, 0, &existed))
645         {
646           if (opt.verbose > 1 && existed)
647             log_info ("certificate already in DB\n");
648           else if (opt.verbose && !existed)
649             log_info ("certificate imported\n");
650         }
651     }
652
653   ksba_cert_release (cert);
654   init_membuf (parm->data, 4096);
655   return 0;
656 }
657   
658 /* Call the agent to learn about a smartcard */
659 int
660 gpgsm_agent_learn (ctrl_t ctrl)
661 {
662   int rc;
663   struct learn_parm_s learn_parm;
664   membuf_t data;
665   size_t len;
666
667   rc = start_agent (ctrl);
668   if (rc)
669     return rc;
670
671   init_membuf (&data, 4096);
672   learn_parm.error = 0;
673   learn_parm.ctx = agent_ctx;
674   learn_parm.data = &data;
675   rc = assuan_transact (agent_ctx, "LEARN --send",
676                         learn_cb, &learn_parm, 
677                         NULL, NULL, NULL, NULL);
678   xfree (get_membuf (&data, &len));
679   if (rc)
680     return rc;
681   return learn_parm.error;
682 }
683
684 \f
685 /* Ask the agent to change the passphrase of the key identified by
686    HEXKEYGRIP. If DESC is not NULL, display instead of the default
687    description message. */
688 int
689 gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
690 {
691   int rc;
692   char line[ASSUAN_LINELENGTH];
693
694   rc = start_agent (ctrl);
695   if (rc)
696     return rc;
697
698   if (!hexkeygrip || strlen (hexkeygrip) != 40)
699     return gpg_error (GPG_ERR_INV_VALUE);
700
701   if (desc)
702     {
703       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
704       line[DIM(line)-1] = 0;
705       rc = assuan_transact (agent_ctx, line,
706                             NULL, NULL, NULL, NULL, NULL, NULL);
707       if (rc)
708         return rc;
709     }
710
711   snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
712   line[DIM(line)-1] = 0;
713
714   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
715   return rc;
716 }
717
718
719 \f
720 /* Ask the agent to pop up a confirmation dialog with the text DESC
721    and an okay and cancel button.  */
722 gpg_error_t
723 gpgsm_agent_get_confirmation (ctrl_t ctrl, const char *desc)
724 {
725   int rc;
726   char line[ASSUAN_LINELENGTH];
727
728   rc = start_agent (ctrl);
729   if (rc)
730     return rc;
731
732   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", desc);
733   line[DIM(line)-1] = 0;
734
735   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
736   return rc;
737 }