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