* agent.h (server_control_s): Add connection_fd field.
[gnupg.git] / agent / call-scd.c
1 /* call-scd.c - fork of the scdaemon to do SC operations
2  *      Copyright (C) 2001, 2002 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 /* Fixme: For now we have serialized all access to the scdaemon which
22    make sense becuase the scdaemon can't handle concurrent connections
23    right now.  We should however keep a list of connections and lock
24    just that connection - it migth make sense to implemtn parts of
25    this in Assuan.*/
26
27 #include <config.h>
28 #include <errno.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <assert.h>
34 #include <unistd.h>
35 #include <sys/stat.h>
36 #ifdef USE_GNU_PTH
37 # include <pth.h>
38 #endif
39
40 #include "agent.h"
41 #include <assuan.h>
42
43 #ifdef _POSIX_OPEN_MAX
44 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
45 #else
46 #define MAX_OPEN_FDS 20
47 #endif
48
49 static ASSUAN_CONTEXT scd_ctx = NULL;
50 #ifdef USE_GNU_PTH
51 static pth_mutex_t scd_lock = PTH_MUTEX_INIT;
52 #endif
53 /* We need to keep track of the connection currently using the SCD.
54    For a pipe server this is all a NOP becuase the connection will
55    always have the conenction indicator -1.  agent_reset_scd releases
56    the active connection; i.e. sets it back to -1, so that a new
57    connection can start using the SCD.  If we eventually allow
58    multiple SCD session we will either make scdaemon multi-threaded or
59    fork of a new scdaemon and let it see how it can get access to a
60    reader. 
61 */
62 static int active_connection_fd = -1;
63 static int active_connection = 0;
64
65 /* callback parameter for learn card */
66 struct learn_parm_s {
67   void (*kpinfo_cb)(void*, const char *);
68   void *kpinfo_cb_arg;
69   void (*certinfo_cb)(void*, const char *);
70   void *certinfo_cb_arg;
71   void (*sinfo_cb)(void*, const char *, size_t, const char *);
72   void *sinfo_cb_arg;
73 };
74
75 struct inq_needpin_s {
76   ASSUAN_CONTEXT ctx;
77   int (*getpin_cb)(void *, const char *, char*, size_t);
78   void *getpin_cb_arg;
79 };
80
81 struct membuf {
82   size_t len;
83   size_t size;
84   char *buf;
85   int out_of_core;
86 };
87
88
89 \f
90 /* A simple implementation of a dynamic buffer.  Use init_membuf() to
91    create a buffer, put_membuf to append bytes and get_membuf to
92    release and return the buffer.  Allocation errors are detected but
93    only returned at the final get_membuf(), this helps not to clutter
94    the code with out of core checks.  */
95
96 static void
97 init_membuf (struct membuf *mb, int initiallen)
98 {
99   mb->len = 0;
100   mb->size = initiallen;
101   mb->out_of_core = 0;
102   mb->buf = xtrymalloc (initiallen);
103   if (!mb->buf)
104       mb->out_of_core = 1;
105 }
106
107 static void
108 put_membuf (struct membuf *mb, const void *buf, size_t len)
109 {
110   if (mb->out_of_core)
111     return;
112
113   if (mb->len + len >= mb->size)
114     {
115       char *p;
116       
117       mb->size += len + 1024;
118       p = xtryrealloc (mb->buf, mb->size);
119       if (!p)
120         {
121           mb->out_of_core = 1;
122           return;
123         }
124       mb->buf = p;
125     }
126   memcpy (mb->buf + mb->len, buf, len);
127   mb->len += len;
128 }
129
130 static void *
131 get_membuf (struct membuf *mb, size_t *len)
132 {
133   char *p;
134
135   if (mb->out_of_core)
136     {
137       xfree (mb->buf);
138       mb->buf = NULL;
139       return NULL;
140     }
141
142   p = mb->buf;
143   *len = mb->len;
144   mb->buf = NULL;
145   mb->out_of_core = 1; /* don't allow a reuse */
146   return p;
147 }
148
149
150
151 \f
152 static int 
153 unlock_scd (int rc)
154 {
155 #ifdef USE_GNU_PTH
156   if (!pth_mutex_release (&scd_lock))
157     {
158       log_error ("failed to release the SCD lock\n");
159       if (!rc)
160         rc = gpg_error (GPG_ERR_INTERNAL);
161     }
162 #endif
163   return rc;
164 }
165
166 /* To make sure we leave no secrets in our image after forking of the
167    scdaemon, we use this callback. */
168 static void
169 atfork_cb (void *opaque, int where)
170 {
171   if (!where)
172     gcry_control (GCRYCTL_TERM_SECMEM);
173 }
174
175
176 /* Fork off the SCdaemon if this has not already been done.  Note that
177    this fucntion alos locks the daemon.  */
178 static int
179 start_scd (ctrl_t ctrl)
180 {
181   int rc;
182   const char *pgmname;
183   ASSUAN_CONTEXT ctx;
184   const char *argv[3];
185   int no_close_list[3];
186   int i;
187
188 #ifdef USE_GNU_PTH
189   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
190     {
191       log_error ("failed to acquire the SCD lock\n");
192       return gpg_error (GPG_ERR_INTERNAL);
193     }
194 #endif
195
196   if (scd_ctx)
197     {
198       /* If we are not the connection currently using the SCD, return
199          an error. */
200       if (!active_connection)
201         {
202           active_connection_fd = ctrl->connection_fd;
203           active_connection = 1;
204         }
205       else if (ctrl->connection_fd != active_connection_fd)
206         return unlock_scd (gpg_error (GPG_ERR_CONFLICT));
207       
208       /* Okay, we scdaemon already started and used by us. */
209       return 0; 
210     }
211
212   if (opt.verbose)
213     log_info ("no running SCdaemon - starting it\n");
214       
215   if (fflush (NULL))
216     {
217       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
218       log_error ("error flushing pending output: %s\n", strerror (errno));
219       return unlock_scd (tmperr);
220     }
221
222   if (!opt.scdaemon_program || !*opt.scdaemon_program)
223     opt.scdaemon_program = GNUPG_DEFAULT_SCDAEMON;
224   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
225     pgmname = opt.scdaemon_program;
226   else
227     pgmname++;
228
229   argv[0] = pgmname;
230   argv[1] = "--server";
231   argv[2] = NULL;
232
233   i=0;
234   if (!opt.running_detached)
235     {
236       if (log_get_fd () != -1)
237         no_close_list[i++] = log_get_fd ();
238       no_close_list[i++] = fileno (stderr);
239     }
240   no_close_list[i] = -1;
241
242   /* Connect to the pinentry and perform initial handshaking */
243   rc = assuan_pipe_connect2 (&ctx, opt.scdaemon_program, (char**)argv,
244                              no_close_list, atfork_cb, NULL);
245   if (rc)
246     {
247       log_error ("can't connect to the SCdaemon: %s\n",
248                  assuan_strerror (rc));
249       return unlock_scd (gpg_error (GPG_ERR_NO_SCDAEMON));
250     }
251   scd_ctx = ctx;
252   active_connection_fd = ctrl->connection_fd;
253   active_connection = 1;
254
255   if (DBG_ASSUAN)
256     log_debug ("connection to SCdaemon established\n");
257
258   return 0;
259 }
260
261
262
263 /* Reset the SCD if it has been used. */
264 int
265 agent_reset_scd (ctrl_t ctrl)
266 {
267   int rc = 0;
268
269 #ifdef USE_GNU_PTH
270   if (!pth_mutex_acquire (&scd_lock, 0, NULL))
271     {
272       log_error ("failed to acquire the SCD lock for reset\n");
273       return gpg_error (GPG_ERR_INTERNAL);
274     }
275 #endif
276   if (active_connection && active_connection_fd == ctrl->connection_fd)
277     {
278       if (scd_ctx)
279         rc = assuan_transact (scd_ctx, "RESET", NULL, NULL,
280                               NULL, NULL, NULL, NULL);
281       active_connection_fd = -1;
282       active_connection = 0;
283     }
284
285   return unlock_scd (map_assuan_err (rc));
286 }
287
288
289
290
291 \f
292 static AssuanError
293 learn_status_cb (void *opaque, const char *line)
294 {
295   struct learn_parm_s *parm = opaque;
296   const char *keyword = line;
297   int keywordlen;
298
299   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
300     ;
301   while (spacep (line))
302     line++;
303   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
304     {
305       parm->certinfo_cb (parm->certinfo_cb_arg, line);
306     }
307   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
308     {
309       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
310     }
311   else if (keywordlen && *line)
312     {
313       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
314     }
315   
316   return 0;
317 }
318
319 /* Perform the learn command and return a list of all private keys
320    stored on the card. */
321 int
322 agent_card_learn (ctrl_t ctrl,
323                   void (*kpinfo_cb)(void*, const char *),
324                   void *kpinfo_cb_arg,
325                   void (*certinfo_cb)(void*, const char *),
326                   void *certinfo_cb_arg,
327                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
328                   void *sinfo_cb_arg)
329 {
330   int rc;
331   struct learn_parm_s parm;
332
333   rc = start_scd (ctrl);
334   if (rc)
335     return rc;
336
337   memset (&parm, 0, sizeof parm);
338   parm.kpinfo_cb = kpinfo_cb;
339   parm.kpinfo_cb_arg = kpinfo_cb_arg;
340   parm.certinfo_cb = certinfo_cb;
341   parm.certinfo_cb_arg = certinfo_cb_arg;
342   parm.sinfo_cb = sinfo_cb;
343   parm.sinfo_cb_arg = sinfo_cb_arg;
344   rc = assuan_transact (scd_ctx, "LEARN --force",
345                         NULL, NULL, NULL, NULL,
346                         learn_status_cb, &parm);
347   if (rc)
348     return unlock_scd (map_assuan_err (rc));
349
350   return unlock_scd (0);
351 }
352
353
354 \f
355 static AssuanError
356 get_serialno_cb (void *opaque, const char *line)
357 {
358   char **serialno = opaque;
359   const char *keyword = line;
360   const char *s;
361   int keywordlen, n;
362
363   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
364     ;
365   while (spacep (line))
366     line++;
367
368   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
369     {
370       if (*serialno)
371         return ASSUAN_Unexpected_Status;
372       for (n=0,s=line; hexdigitp (s); s++, n++)
373         ;
374       if (!n || (n&1)|| !(spacep (s) || !*s) )
375         return ASSUAN_Invalid_Status;
376       *serialno = xtrymalloc (n+1);
377       if (!*serialno)
378         return ASSUAN_Out_Of_Core;
379       memcpy (*serialno, line, n);
380       (*serialno)[n] = 0;
381     }
382   
383   return 0;
384 }
385
386 /* Return the serial number of the card or an appropriate error.  The
387    serial number is returned as a hexstring. */
388 int
389 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
390 {
391   int rc;
392   char *serialno = NULL;
393
394   rc = start_scd (ctrl);
395   if (rc)
396     return rc;
397
398   /* Hmm, do we really need this reset - scddaemon should do this or
399      we can do this if we for some reason figure out that the
400      operation might have failed due to a missing RESET.  Hmmm, I feel
401      this is really SCdaemon's duty */
402 /*    rc = assuan_transact (scd_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL); */
403 /*    if (rc) */
404 /*      return unlock_scd (map_assuan_err (rc)); */
405
406   rc = assuan_transact (scd_ctx, "SERIALNO",
407                         NULL, NULL, NULL, NULL,
408                         get_serialno_cb, &serialno);
409   if (rc)
410     {
411       xfree (serialno);
412       return unlock_scd (map_assuan_err (rc));
413     }
414   *r_serialno = serialno;
415   return unlock_scd (0);
416 }
417
418 \f
419 static AssuanError
420 membuf_data_cb (void *opaque, const void *buffer, size_t length)
421 {
422   struct membuf *data = opaque;
423
424   if (buffer)
425     put_membuf (data, buffer, length);
426   return 0;
427 }
428   
429 /* Handle the NEEDPIN inquiry. */
430 static AssuanError
431 inq_needpin (void *opaque, const char *line)
432 {
433   struct inq_needpin_s *parm = opaque;
434   char *pin;
435   size_t pinlen;
436   int rc;
437
438   if (!(!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7])))
439     {
440       log_error ("unsupported inquiry `%s'\n", line);
441       return ASSUAN_Inquire_Unknown;
442     }
443   line += 7;
444
445   pinlen = 90;
446   pin = gcry_malloc_secure (pinlen);
447   if (!pin)
448     return ASSUAN_Out_Of_Core;
449
450   rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
451   if (rc)
452     rc = ASSUAN_Canceled;
453   if (!rc)
454     rc = assuan_send_data (parm->ctx, pin, pinlen);
455   xfree (pin);
456
457   return rc;
458 }
459
460
461
462 /* Create a signature using the current card */
463 int
464 agent_card_pksign (ctrl_t ctrl,
465                    const char *keyid,
466                    int (*getpin_cb)(void *, const char *, char*, size_t),
467                    void *getpin_cb_arg,
468                    const unsigned char *indata, size_t indatalen,
469                    char **r_buf, size_t *r_buflen)
470 {
471   int rc, i;
472   char *p, line[ASSUAN_LINELENGTH];
473   struct membuf data;
474   struct inq_needpin_s inqparm;
475   size_t len;
476   unsigned char *sigbuf;
477   size_t sigbuflen;
478
479   *r_buf = NULL;
480   rc = start_scd (ctrl);
481   if (rc)
482     return rc;
483
484   if (indatalen*2 + 50 > DIM(line))
485     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
486
487   sprintf (line, "SETDATA ");
488   p = line + strlen (line);
489   for (i=0; i < indatalen ; i++, p += 2 )
490     sprintf (p, "%02X", indata[i]);
491   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
492   if (rc)
493     return unlock_scd (map_assuan_err (rc));
494
495   init_membuf (&data, 1024);
496   inqparm.ctx = scd_ctx;
497   inqparm.getpin_cb = getpin_cb;
498   inqparm.getpin_cb_arg = getpin_cb_arg;
499   snprintf (line, DIM(line)-1, "PKSIGN %s", keyid);
500   line[DIM(line)-1] = 0;
501   rc = assuan_transact (scd_ctx, line,
502                         membuf_data_cb, &data,
503                         inq_needpin, &inqparm,
504                         NULL, NULL);
505   if (rc)
506     {
507       xfree (get_membuf (&data, &len));
508       return unlock_scd (map_assuan_err (rc));
509     }
510   sigbuf = get_membuf (&data, &sigbuflen);
511
512   /* create an S-expression from it which is formatted like this:
513      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
514   *r_buflen = 21 + 11 + sigbuflen + 4;
515   *r_buf = xtrymalloc (*r_buflen);
516   if (!*r_buf)
517     {
518       gpg_error_t tmperr = out_of_core ();
519       xfree (*r_buf);
520       return unlock_scd (tmperr);
521     }
522   p = stpcpy (*r_buf, "(7:sig-val(3:rsa(1:s" );
523   sprintf (p, "%u:", (unsigned int)sigbuflen);
524   p += strlen (p);
525   memcpy (p, sigbuf, sigbuflen);
526   p += sigbuflen;
527   strcpy (p, ")))");
528   xfree (sigbuf);
529
530   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
531   return unlock_scd (0);
532 }
533
534 /* Decipher INDATA using the current card. Note that the returned value is */
535 int
536 agent_card_pkdecrypt (ctrl_t ctrl,
537                       const char *keyid,
538                       int (*getpin_cb)(void *, const char *, char*, size_t),
539                       void *getpin_cb_arg,
540                       const unsigned char *indata, size_t indatalen,
541                       char **r_buf, size_t *r_buflen)
542 {
543   int rc, i;
544   char *p, line[ASSUAN_LINELENGTH];
545   struct membuf data;
546   struct inq_needpin_s inqparm;
547   size_t len;
548
549   *r_buf = NULL;
550   rc = start_scd (ctrl);
551   if (rc)
552     return rc;
553
554   /* FIXME: use secure memory where appropriate */
555   if (indatalen*2 + 50 > DIM(line))
556     return unlock_scd (gpg_error (GPG_ERR_GENERAL));
557
558   sprintf (line, "SETDATA ");
559   p = line + strlen (line);
560   for (i=0; i < indatalen ; i++, p += 2 )
561     sprintf (p, "%02X", indata[i]);
562   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
563   if (rc)
564     return unlock_scd (map_assuan_err (rc));
565
566   init_membuf (&data, 1024);
567   inqparm.ctx = scd_ctx;
568   inqparm.getpin_cb = getpin_cb;
569   inqparm.getpin_cb_arg = getpin_cb_arg;
570   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
571   line[DIM(line)-1] = 0;
572   rc = assuan_transact (scd_ctx, line,
573                         membuf_data_cb, &data,
574                         inq_needpin, &inqparm,
575                         NULL, NULL);
576   if (rc)
577     {
578       xfree (get_membuf (&data, &len));
579       return unlock_scd (map_assuan_err (rc));
580     }
581   *r_buf = get_membuf (&data, r_buflen);
582   if (!*r_buf)
583     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
584
585   return unlock_scd (0);
586 }
587
588
589 \f
590 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
591 int
592 agent_card_readcert (ctrl_t ctrl,
593                      const char *id, char **r_buf, size_t *r_buflen)
594 {
595   int rc;
596   char line[ASSUAN_LINELENGTH];
597   struct membuf data;
598   size_t len;
599
600   *r_buf = NULL;
601   rc = start_scd (ctrl);
602   if (rc)
603     return rc;
604
605   init_membuf (&data, 1024);
606   snprintf (line, DIM(line)-1, "READCERT %s", id);
607   line[DIM(line)-1] = 0;
608   rc = assuan_transact (scd_ctx, line,
609                         membuf_data_cb, &data,
610                         NULL, NULL,
611                         NULL, NULL);
612   if (rc)
613     {
614       xfree (get_membuf (&data, &len));
615       return unlock_scd (map_assuan_err (rc));
616     }
617   *r_buf = get_membuf (&data, r_buflen);
618   if (!*r_buf)
619     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
620
621   return unlock_scd (0);
622 }
623
624
625 \f
626 /* Read a key with ID and return it in an allocate buffer pointed to
627    by r_BUF as a valid S-expression. */
628 int
629 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
630 {
631   int rc;
632   char line[ASSUAN_LINELENGTH];
633   struct membuf data;
634   size_t len, buflen;
635
636   *r_buf = NULL;
637   rc = start_scd (ctrl);
638   if (rc)
639     return rc;
640
641   init_membuf (&data, 1024);
642   snprintf (line, DIM(line)-1, "READKEY %s", id);
643   line[DIM(line)-1] = 0;
644   rc = assuan_transact (scd_ctx, line,
645                         membuf_data_cb, &data,
646                         NULL, NULL,
647                         NULL, NULL);
648   if (rc)
649     {
650       xfree (get_membuf (&data, &len));
651       return unlock_scd (map_assuan_err (rc));
652     }
653   *r_buf = get_membuf (&data, &buflen);
654   if (!*r_buf)
655     return unlock_scd (gpg_error (GPG_ERR_ENOMEM));
656
657   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
658     {
659       xfree (*r_buf); *r_buf = NULL;
660       return unlock_scd (gpg_error (GPG_ERR_INV_VALUE));
661     }
662
663   return unlock_scd (0);
664 }
665
666
667
668 \f
669 static AssuanError
670 pass_status_thru (void *opaque, const char *line)
671 {
672   ASSUAN_CONTEXT ctx = opaque;
673   char keyword[200];
674   int i;
675
676   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
677     keyword[i] = *line;
678   keyword[i] = 0;
679   /* truncate any remaining keyword stuff. */
680   for (; *line && !spacep (line); line++)
681     ;
682   while (spacep (line))
683     line++;
684
685   assuan_write_status (ctx, keyword, line);
686   return 0;
687 }
688
689 static AssuanError
690 pass_data_thru (void *opaque, const void *buffer, size_t length)
691 {
692   ASSUAN_CONTEXT ctx = opaque;
693
694   assuan_send_data (ctx, buffer, length);
695   return 0;
696 }
697
698
699 /* Send the line CMDLINE with command for the SCDdaemon to it and send
700    all status messages back.  This command is used as a general quoting
701    mechanism to pass everything verbatim to SCDAEMOPN.  The PIN
702    inquirey is handled inside gpg-agent. */
703 int
704 agent_card_scd (ctrl_t ctrl, const char *cmdline,
705                 int (*getpin_cb)(void *, const char *, char*, size_t),
706                 void *getpin_cb_arg, void *assuan_context)
707 {
708   int rc;
709   struct inq_needpin_s inqparm;
710
711   rc = start_scd (ctrl);
712   if (rc)
713     return rc;
714
715   inqparm.ctx = scd_ctx;
716   inqparm.getpin_cb = getpin_cb;
717   inqparm.getpin_cb_arg = getpin_cb_arg;
718   rc = assuan_transact (scd_ctx, cmdline,
719                         pass_data_thru, assuan_context,
720                         inq_needpin, &inqparm,
721                         pass_status_thru, assuan_context);
722   if (rc)
723     {
724       return unlock_scd (map_assuan_err (rc));
725     }
726
727   return unlock_scd (0);
728 }
729
730