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