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