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