* command.c (cmd_pksign, cmd_pkdecrypt): Use a copy of the key ID.
[gnupg.git] / scd / command.c
1 /* command.c - SCdaemon command handler
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 <unistd.h>
28 #include <ksba.h>
29
30 #include "scdaemon.h"
31 #include "../assuan/assuan.h"
32
33 /* maximum length aloowed as a PIN; used for INQUIRE NEEDPIN */
34 #define MAXLEN_PIN 100
35
36 #define set_error(e,t) assuan_set_error (ctx, ASSUAN_ ## e, (t))
37
38 /* Data used to associate an Assuan context with local server data */
39 struct server_local_s {
40   ASSUAN_CONTEXT assuan_ctx;
41 };
42
43
44 /* Check whether the option NAME appears in LINE */
45 static int
46 has_option (const char *line, const char *name)
47 {
48   const char *s;
49   int n = strlen (name);
50
51   s = strstr (line, name);
52   return (s && (s == line || spacep (s-1)) && (!s[n] || spacep (s+n)));
53 }
54
55
56
57 \f
58 /* Note, that this reset_notify is also used for cleanup purposes. */
59 static void
60 reset_notify (ASSUAN_CONTEXT ctx)
61 {
62   CTRL ctrl = assuan_get_pointer (ctx); 
63
64   if (ctrl->card_ctx)
65     {
66       card_close (ctrl->card_ctx);
67       ctrl->card_ctx = NULL;
68       xfree (ctrl->in_data.value);
69       ctrl->in_data.value = NULL;
70     }
71 }
72
73
74 static int
75 option_handler (ASSUAN_CONTEXT ctx, const char *key, const char *value)
76 {
77   return 0;
78 }
79
80
81 /* If the card has not yet been opened, do it.  Note that this
82    function returns an Assuan error, so don't map the error a second
83    time */
84 static AssuanError
85 open_card (CTRL ctrl)
86 {
87   if (!ctrl->card_ctx)
88     {
89       int rc = card_open (&ctrl->card_ctx);
90       if (rc)
91         return map_to_assuan_status (rc);
92     }
93   return 0;
94 }
95
96
97 /* SERIALNO 
98
99    Return the serial number of the card using a status reponse.  This
100    functon should be used to check for the presence of a card.
101
102    This function is special in that it can be used to reset the card.
103    Most other functions will return an error when a card change has
104    been detected and the use of this function is therefore required.
105
106    Background: We want to keep the client clear of handling card
107    changes between operations; i.e. the client can assume that all
108    operations are doneon the same card unless he call this function.
109  */
110 static int
111 cmd_serialno (ASSUAN_CONTEXT ctx, char *line)
112 {
113   CTRL ctrl = assuan_get_pointer (ctx);
114   int rc = 0;
115   char *serial_and_stamp;
116   char *serial;
117   time_t stamp;
118
119   if ((rc = open_card (ctrl)))
120     return rc;
121
122   rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
123   if (rc)
124     return map_to_assuan_status (rc);
125   rc = asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
126   xfree (serial);
127   if (rc < 0)
128     return ASSUAN_Out_Of_Core;
129   rc = 0;
130   assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
131   free (serial_and_stamp);
132   return 0;
133 }
134
135
136
137
138 /* LEARN [--force]
139
140    Learn all useful information of the currently inserted card.  When
141    used without the force options, the command might do an INQUIRE
142    like this:
143
144       INQUIRE KNOWNCARDP <hexstring_with_serialNumber> <timestamp>
145
146    The client should just send an "END" if the processing should go on
147    or a "CANCEL" to force the function to terminate with a Cancel
148    error message.  The response of this command is a list of status
149    lines formatted as this:
150
151      S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>
152
153    If there is no certificate yet stored on the card a single "X" is
154    returned as the keygrip.
155
156 */
157 static int
158 cmd_learn (ASSUAN_CONTEXT ctx, char *line)
159 {
160   CTRL ctrl = assuan_get_pointer (ctx);
161   int rc = 0;
162   int idx;
163
164   if ((rc = open_card (ctrl)))
165     return rc;
166
167   /* Unless the force option is used we try a shortcut by identifying
168      the card using a serial number and inquiring the client with
169      that. The client may choose to cancel the operation if he already
170      knows about this card */
171   {
172     char *serial_and_stamp;
173     char *serial;
174     time_t stamp;
175    
176     rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
177     if (rc)
178       return map_to_assuan_status (rc);
179     rc = asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
180     xfree (serial);
181     if (rc < 0)
182       return ASSUAN_Out_Of_Core;
183     rc = 0;
184     assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
185
186     if (!has_option (line, "--force"))
187       {
188         char *command;
189
190         rc = asprintf (&command, "KNOWNCARDP %s", serial_and_stamp);
191         if (rc < 0)
192           {
193             free (serial_and_stamp);
194             return ASSUAN_Out_Of_Core;
195           }
196         rc = 0;
197         rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
198         free (command);  /* (must use standard free here) */
199         if (rc)
200           {
201             if (rc != ASSUAN_Canceled)
202               log_error ("inquire KNOWNCARDP failed: %s\n",
203                          assuan_strerror (rc));
204             free (serial_and_stamp);
205             return rc; 
206           }
207         /* not canceled, so we have to proceeed */
208       }
209     free (serial_and_stamp);
210   }
211
212   for (idx=0; !rc; idx++)
213     {
214       unsigned char keygrip[20];
215       char *keyid;
216       int no_cert = 0;
217
218       rc = card_enum_keypairs (ctrl->card_ctx, idx, keygrip, &keyid);
219       if (rc == GNUPG_Missing_Certificate && keyid)
220         {
221           /* this does happen with an incomplete personalized
222              card; i.e. during the time we have stored the key on the
223              card but not stored the certificate; probably becuase it
224              has not yet been received back from the CA.  Note that we
225              must release KEYID in this case. */
226           rc = 0; 
227           no_cert = 1;
228         }
229       if (!rc)
230         {
231           char *buf, *p;
232
233           buf = p = xtrymalloc (40 + 1 + strlen (keyid) + 1);
234           if (!buf)
235             rc = GNUPG_Out_Of_Core;
236           else
237             {
238               int i;
239               
240               if (no_cert)
241                 *p++ = 'X';
242               else
243                 {
244                   for (i=0; i < 20; i++, p += 2)
245                     sprintf (p, "%02X", keygrip[i]);
246                 }
247               *p++ = ' ';
248               strcpy (p, keyid);
249               assuan_write_status (ctx, "KEYPAIRINFO", buf);
250               xfree (buf);
251             }
252         }
253       xfree (keyid);
254     }
255   if (rc == -1)
256     rc = 0;
257
258
259   return map_to_assuan_status (rc);
260 }
261
262
263 \f
264 /* READCERT <hexified_certid>
265
266  */
267 static int
268 cmd_readcert (ASSUAN_CONTEXT ctx, char *line)
269 {
270   CTRL ctrl = assuan_get_pointer (ctx);
271   int rc;
272   unsigned char *cert;
273   size_t ncert;
274
275   if ((rc = open_card (ctrl)))
276     return rc;
277
278   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
279   if (rc)
280     {
281       log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
282     }
283   if (!rc)
284     {
285       rc = assuan_send_data (ctx, cert, ncert);
286       xfree (cert);
287       if (rc)
288         return rc;
289     }
290
291   return map_to_assuan_status (rc);
292 }
293
294
295 /* READKEY <hexified_certid>
296
297    Return the public key for the given cert or key ID as an standard
298    S-Expression.  */
299 static int
300 cmd_readkey (ASSUAN_CONTEXT ctx, char *line)
301 {
302   CTRL ctrl = assuan_get_pointer (ctx);
303   int rc;
304   unsigned char *cert = NULL;
305   size_t ncert, n;
306   KsbaCert kc = NULL;
307   KsbaSexp p;
308
309   if ((rc = open_card (ctrl)))
310     return rc;
311
312   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
313   if (rc)
314     {
315       log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
316       goto leave;
317     }
318       
319   kc = ksba_cert_new ();
320   if (!kc)
321     {
322       xfree (cert);
323       rc = GNUPG_Out_Of_Core;
324       goto leave;
325     }
326   rc = ksba_cert_init_from_mem (kc, cert, ncert);
327   if (rc)
328     {
329       log_error ("failed to parse the certificate: %s\n", ksba_strerror (rc));
330       rc = map_ksba_err (rc);
331       goto leave;
332     }
333
334   p = ksba_cert_get_public_key (kc);
335   if (!p)
336     {
337       rc = GNUPG_No_Public_Key;
338       goto leave;
339     }
340
341   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
342   rc = assuan_send_data (ctx, p, n);
343   rc = map_assuan_err (rc);
344   xfree (p);
345
346
347  leave:
348   ksba_cert_release (kc);
349   xfree (cert);
350   return map_to_assuan_status (rc);
351 }
352
353
354 \f
355
356 /* SETDATA <hexstring> 
357
358    The client should use this command to tell us the data he want to
359    sign.  */
360 static int
361 cmd_setdata (ASSUAN_CONTEXT ctx, char *line)
362 {
363   CTRL ctrl = assuan_get_pointer (ctx);
364   int n;
365   char *p;
366   unsigned char *buf;
367
368   /* parse the hexstring */
369   for (p=line,n=0; hexdigitp (p); p++, n++)
370     ;
371   if (*p)
372     return set_error (Parameter_Error, "invalid hexstring");
373   if ((n&1))
374     return set_error (Parameter_Error, "odd number of digits");
375   n /= 2;
376   buf = xtrymalloc (n);
377   if (!buf)
378     return ASSUAN_Out_Of_Core;
379
380   ctrl->in_data.value = buf;
381   ctrl->in_data.valuelen = n;
382   for (p=line, n=0; n < ctrl->in_data.valuelen; p += 2, n++)
383     buf[n] = xtoi_2 (p);
384   return 0;
385 }
386
387
388
389 static int 
390 pin_cb (void *opaque, const char *info, char **retstr)
391 {
392   ASSUAN_CONTEXT ctx = opaque;
393   char *command;
394   int rc;
395   char *value;
396   size_t valuelen;
397
398   *retstr = NULL;
399   log_debug ("asking for PIN '%s'\n", info);
400
401   rc = asprintf (&command, "NEEDPIN %s", info);
402   if (rc < 0)
403     return GNUPG_Out_Of_Core;
404
405   /* FIXME: Write an inquire function which returns the result in
406      secure memory */
407   rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN); 
408   free (command);  
409   if (rc)
410     return map_assuan_err (rc);
411
412   if (!valuelen || value[valuelen-1])
413     {
414       /* We require that the returned value is an UTF-8 string */
415       xfree (value);
416       return GNUPG_Invalid_Response;
417     }
418   *retstr = value;
419   return 0;
420 }
421
422
423 /* PKSIGN <hexified_id>
424
425  */
426 static int
427 cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
428 {
429   CTRL ctrl = assuan_get_pointer (ctx);
430   int rc;
431   void *outdata;
432   size_t outdatalen;
433   char *keyidstr;
434
435   if ((rc = open_card (ctrl)))
436     return rc;
437
438   /* We have to use a copy of the key ID because the function may use
439      the pin_cb which in turn uses the assuan line buffer and thus
440      overwriting the original line with the keyid */
441   keyidstr = xtrystrdup (line);
442   if (!keyidstr)
443     return ASSUAN_Out_Of_Core;
444   rc = card_sign (ctrl->card_ctx,
445                   keyidstr, GCRY_MD_SHA1,
446                   pin_cb, ctx,
447                   ctrl->in_data.value, ctrl->in_data.valuelen,
448                   &outdata, &outdatalen);
449   xfree (keyidstr);
450   if (rc)
451     {
452       log_error ("card_sign failed: %s\n", gnupg_strerror (rc));
453     }
454   else
455     {
456       rc = assuan_send_data (ctx, outdata, outdatalen);
457       xfree (outdata);
458       if (rc)
459         return rc; /* that is already an assuan error code */
460     }
461
462   return map_to_assuan_status (rc);
463 }
464
465 /* PKDECRYPT <hexified_id>
466
467  */
468 static int
469 cmd_pkdecrypt (ASSUAN_CONTEXT ctx, char *line)
470 {
471   CTRL ctrl = assuan_get_pointer (ctx);
472   int rc;
473   void *outdata;
474   size_t outdatalen;
475   char *keyidstr;
476
477   if ((rc = open_card (ctrl)))
478     return rc;
479
480   keyidstr = xtrystrdup (line);
481   if (!keyidstr)
482     return ASSUAN_Out_Of_Core;
483   rc = card_decipher (ctrl->card_ctx,
484                       keyidstr, 
485                       pin_cb, ctx,
486                       ctrl->in_data.value, ctrl->in_data.valuelen,
487                       &outdata, &outdatalen);
488   xfree (keyidstr);
489   if (rc)
490     {
491       log_error ("card_create_signature failed: %s\n", gnupg_strerror (rc));
492     }
493   else
494     {
495       rc = assuan_send_data (ctx, outdata, outdatalen);
496       xfree (outdata);
497       if (rc)
498         return rc; /* that is already an assuan error code */
499     }
500
501   return map_to_assuan_status (rc);
502 }
503
504
505
506 \f
507 /* Tell the assuan library about our commands */
508 static int
509 register_commands (ASSUAN_CONTEXT ctx)
510 {
511   static struct {
512     const char *name;
513     int cmd_id;
514     int (*handler)(ASSUAN_CONTEXT, char *line);
515   } table[] = {
516     { "SERIALNO", 0, cmd_serialno },
517     { "LEARN", 0, cmd_learn },
518     { "READCERT", 0, cmd_readcert },
519     { "READKEY", 0,  cmd_readkey },
520     { "SETDATA", 0,  cmd_setdata },
521     { "PKSIGN", 0,   cmd_pksign },
522     { "PKDECRYPT", 0,cmd_pkdecrypt },
523     { "",     ASSUAN_CMD_INPUT, NULL }, 
524     { "",     ASSUAN_CMD_OUTPUT, NULL }, 
525     { NULL }
526   };
527   int i, j, rc;
528
529   for (i=j=0; table[i].name; i++)
530     {
531       rc = assuan_register_command (ctx,
532                                     table[i].cmd_id? table[i].cmd_id
533                                                    : (ASSUAN_CMD_USER + j++),
534                                     table[i].name, table[i].handler);
535       if (rc)
536         return rc;
537     } 
538   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
539
540   assuan_register_reset_notify (ctx, reset_notify);
541   assuan_register_option_handler (ctx, option_handler);
542   return 0;
543 }
544
545
546 /* Startup the server.  If LISTEN_FD is given as -1, this is simple
547    piper server, otherwise it is a regular server */
548 void
549 scd_command_handler (int listen_fd)
550 {
551   int rc;
552   ASSUAN_CONTEXT ctx;
553   struct server_control_s ctrl;
554
555   memset (&ctrl, 0, sizeof ctrl);
556   scd_init_default_ctrl (&ctrl);
557   
558   if (listen_fd == -1)
559     {
560       int filedes[2];
561
562       filedes[0] = 0;
563       filedes[1] = 1;
564       rc = assuan_init_pipe_server (&ctx, filedes);
565     }
566   else
567     {
568       rc = assuan_init_socket_server (&ctx, listen_fd);
569     }
570   if (rc)
571     {
572       log_error ("failed to initialize the server: %s\n",
573                  assuan_strerror(rc));
574       scd_exit (2);
575     }
576   rc = register_commands (ctx);
577   if (rc)
578     {
579       log_error ("failed to register commands with Assuan: %s\n",
580                  assuan_strerror(rc));
581       scd_exit (2);
582     }
583   assuan_set_pointer (ctx, &ctrl);
584   ctrl.server_local = xcalloc (1, sizeof *ctrl.server_local);
585   ctrl.server_local->assuan_ctx = ctx;
586
587   if (DBG_ASSUAN)
588     assuan_set_log_stream (ctx, log_get_stream ());
589
590   for (;;)
591     {
592       rc = assuan_accept (ctx);
593       if (rc == -1)
594         {
595           break;
596         }
597       else if (rc)
598         {
599           log_info ("Assuan accept problem: %s\n", assuan_strerror (rc));
600           break;
601         }
602       
603       rc = assuan_process (ctx);
604       if (rc)
605         {
606           log_info ("Assuan processing failed: %s\n", assuan_strerror (rc));
607           continue;
608         }
609     }
610   reset_notify (ctx); /* used for cleanup */
611
612   assuan_deinit_server (ctx);
613 }