Signing using a PKCS15 smartcard does work. How to create such a card
[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   int lines;
45   size_t size;
46   char *buffer;
47 };
48
49 struct inq_needpin_s {
50   ASSUAN_CONTEXT ctx;
51   int (*getpin_cb)(void *, const char *, char*, size_t);
52   void *getpin_cb_arg;
53 };
54
55 struct membuf {
56   size_t len;
57   size_t size;
58   char *buf;
59   int out_of_core;
60 };
61
62
63 \f
64 /* A simple implemnation of a dynamic buffer.  Use init_membuf() to
65    create a buffer, put_membuf to append bytes and get_membuf to
66    release and return the buffer.  Allocation errors are detected but
67    only returned at the final get_membuf(), this helps not to clutter
68    the code with out of core checks.  */
69
70 static void
71 init_membuf (struct membuf *mb, int initiallen)
72 {
73   mb->len = 0;
74   mb->size = initiallen;
75   mb->out_of_core = 0;
76   mb->buf = xtrymalloc (initiallen);
77   if (!mb->buf)
78       mb->out_of_core = 1;
79 }
80
81 static void
82 put_membuf (struct membuf *mb, const void *buf, size_t len)
83 {
84   if (mb->out_of_core)
85     return;
86
87   if (mb->len + len >= mb->size)
88     {
89       char *p;
90       
91       mb->size += len + 1024;
92       p = xtryrealloc (mb->buf, mb->size);
93       if (!p)
94         {
95           mb->out_of_core = 1;
96           return;
97         }
98       mb->buf = p;
99     }
100   memcpy (mb->buf + mb->len, buf, len);
101   mb->len += len;
102 }
103
104 static void *
105 get_membuf (struct membuf *mb, size_t *len)
106 {
107   char *p;
108
109   if (mb->out_of_core)
110     {
111       xfree (mb->buf);
112       mb->buf = NULL;
113       return NULL;
114     }
115
116   p = mb->buf;
117   *len = mb->len;
118   mb->buf = NULL;
119   mb->out_of_core = 1; /* don't allow a reuse */
120   return p;
121 }
122
123
124
125 \f
126 /* Fork off the SCdaemon if this has not already been done */
127 static int
128 start_scd (void)
129 {
130   int rc;
131   const char *pgmname;
132   ASSUAN_CONTEXT ctx;
133   const char *argv[3];
134
135   if (scd_ctx)
136     return 0; /* No need to serialize things because the agent is
137                  expected to tun as a single-thread (or may be in
138                  future using libpth) */
139
140   log_debug ("no running SCdaemon - starting it\n");
141       
142   if (fflush (NULL))
143     {
144       log_error ("error flushing pending output: %s\n", strerror (errno));
145       return seterr (Write_Error);
146     }
147
148   /* FIXME: change the default location of the program */
149   if (!opt.scdaemon_program || !*opt.scdaemon_program)
150     opt.scdaemon_program = "../scd/scdaemon";
151   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
152     pgmname = opt.scdaemon_program;
153   else
154     pgmname++;
155
156   argv[0] = pgmname;
157   argv[1] = "--server";
158   argv[2] = NULL;
159
160   /* connect to the pinentry and perform initial handshaking */
161   rc = assuan_pipe_connect (&ctx, opt.scdaemon_program, (char**)argv, 0);
162   if (rc)
163     {
164       log_error ("can't connect to the SCdaemon: %s\n",
165                  assuan_strerror (rc));
166       return seterr (No_Scdaemon);
167     }
168   scd_ctx = ctx;
169   
170   log_debug ("connection to SCdaemon established\n");
171   return 0;
172 }
173
174
175 \f
176 static AssuanError
177 learn_status_cb (void *opaque, const char *line)
178 {
179   /*  struct learn_parm_s *parm = opaque;*/
180   const char *keyword = line;
181   int keywordlen;
182
183   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
184     ;
185   while (spacep (line))
186     line++;
187   if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
188     {
189       log_debug ("learn_status_cb: keypair `%s'\n", line);
190     }
191   else if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
192     {
193       log_debug ("learn_status_cb: serialno `%s'\n", line);
194     }
195   else
196     log_debug ("learn_status_cb: ignoring `%.*s'\n", keywordlen, keyword);
197   
198   return 0;
199 }
200
201 /* Perform the learn command and return a list of all private keys
202    stored on the card. */
203 int
204 agent_card_learn (void)
205 {
206   int rc;
207   struct learn_parm_s parm;
208
209   rc = start_scd ();
210   if (rc)
211     return rc;
212
213   rc = assuan_transact (scd_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
214   if (rc)
215     return map_assuan_err (rc);
216
217   memset (&parm, 0, sizeof parm);
218
219   rc = assuan_transact (scd_ctx, "LEARN --force",
220                         NULL, NULL, NULL, NULL,
221                         learn_status_cb, &parm);
222   if (rc)
223     return map_assuan_err (rc);
224
225   return 0;
226 }
227
228
229 \f
230 static AssuanError
231 get_serialno_cb (void *opaque, const char *line)
232 {
233   char **serialno = opaque;
234   const char *keyword = line;
235   const char *s;
236   int keywordlen, n;
237
238   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
239     ;
240   while (spacep (line))
241     line++;
242
243   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
244     {
245       if (*serialno)
246         return ASSUAN_Unexpected_Status;
247       for (n=0,s=line; hexdigitp (s); s++, n++)
248         ;
249       if (!n || (n&1)|| !(spacep (s) || !*s) )
250         return ASSUAN_Invalid_Status;
251       *serialno = xtrymalloc (n+1);
252       if (!*serialno)
253         return ASSUAN_Out_Of_Core;
254       memcpy (*serialno, line, n);
255       (*serialno)[n] = 0;
256     }
257   
258   return 0;
259 }
260
261 /* Return the serial number of the card or an appropriate error.  The
262    serial number is returned as a hext string. */
263 int
264 agent_card_serialno (char **r_serialno)
265 {
266   int rc;
267   char *serialno = NULL;
268
269   rc = start_scd ();
270   if (rc)
271     return rc;
272
273   /* Hmm, do we really need this reset - scddaemon should do this or
274      we can do this if we for some reason figure out that the
275      operation might have failed due to a missing RESET.  Hmmm, I feel
276      this is really SCdaemon's duty */
277   rc = assuan_transact (scd_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
278   if (rc)
279     return map_assuan_err (rc);
280
281   rc = assuan_transact (scd_ctx, "SERIALNO",
282                         NULL, NULL, NULL, NULL,
283                         get_serialno_cb, &serialno);
284   if (rc)
285     {
286       xfree (serialno);
287       return map_assuan_err (rc);
288     }
289   *r_serialno = serialno;
290   return 0;
291 }
292
293 \f
294 static AssuanError
295 membuf_data_cb (void *opaque, const void *buffer, size_t length)
296 {
297   struct membuf *data = opaque;
298
299   put_membuf (data, buffer, length);
300   return 0;
301 }
302   
303 /* Handle the NEEDPIN inquiry. */
304 static AssuanError
305 inq_needpin (void *opaque, const char *line)
306 {
307   struct inq_needpin_s *parm = opaque;
308   char *pin;
309   size_t pinlen;
310   int rc;
311
312   if (!(!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7])))
313     {
314       log_error ("unsupported inquiry `%s'\n", line);
315       return ASSUAN_Inquire_Unknown;
316     }
317   line += 7;
318
319   pinlen = 90;
320   pin = gcry_malloc_secure (pinlen);
321   if (!pin)
322     return ASSUAN_Out_Of_Core;
323
324   rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
325   if (rc)
326     rc = ASSUAN_Canceled;
327   if (!rc)
328     rc = assuan_send_data (parm->ctx, pin, pinlen);
329   xfree (pin);
330
331   return rc;
332 }
333
334
335
336 /* Create a signature using the current card */
337 int
338 agent_card_pksign (const char *keyid,
339                    int (*getpin_cb)(void *, const char *, char*, size_t),
340                    void *getpin_cb_arg,
341                    const unsigned char *indata, size_t indatalen,
342                    char **r_buf, size_t *r_buflen)
343 {
344   int rc, i;
345   char *p, line[ASSUAN_LINELENGTH];
346   struct membuf data;
347   struct inq_needpin_s inqparm;
348   size_t len;
349   unsigned char *sigbuf;
350   size_t sigbuflen;
351
352   *r_buf = NULL;
353   rc = start_scd ();
354   if (rc)
355     return rc;
356
357   if (indatalen*2 + 50 > DIM(line))
358     return seterr (General_Error);
359
360   sprintf (line, "SETDATA ");
361   p = line + strlen (line);
362   for (i=0; i < indatalen ; i++, p += 2 )
363     sprintf (p, "%02X", indata[i]);
364   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
365   if (rc)
366     return map_assuan_err (rc);
367
368   init_membuf (&data, 1024);
369   inqparm.ctx = scd_ctx;
370   inqparm.getpin_cb = getpin_cb;
371   inqparm.getpin_cb_arg = getpin_cb_arg;
372   snprintf (line, DIM(line)-1, "PKSIGN %s", keyid);
373   line[DIM(line)-1] = 0;
374   rc = assuan_transact (scd_ctx, line,
375                         membuf_data_cb, &data,
376                         inq_needpin, &inqparm,
377                         NULL, NULL);
378   if (rc)
379     {
380       xfree (get_membuf (&data, &len));
381       return map_assuan_err (rc);
382     }
383   sigbuf = get_membuf (&data, &sigbuflen);
384
385   /* create an S-expression from it which is formatted like this:
386      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
387   *r_buflen = 21 + 11 + sigbuflen + 4;
388   *r_buf = xtrymalloc (*r_buflen);
389   if (!*r_buf)
390     {
391       xfree (*r_buf);
392       return GNUPG_Out_Of_Core;
393     }
394   p = stpcpy (*r_buf, "(7:sig-val(3:rsa(1:s" );
395   sprintf (p, "%u:", (unsigned int)sigbuflen);
396   p += strlen (p);
397   memcpy (p, sigbuf, sigbuflen);
398   p += sigbuflen;
399   strcpy (p, ")))");
400   xfree (sigbuf);
401
402   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
403   return 0;
404 }
405