* configure.ac: Add an --enable-old-tiger, to revert back to the
[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.  In addition to the keypair info, information
155    about all certificates stored on the card is also returned:
156
157      S CERTINFO <certtype> <hexstring_with_id>
158
159    Where CERTINFO is a number indicating the type of certificate:
160       0   := Unknown
161       100 := Regular X.509 cert
162       101 := Trusted X.509 cert
163       102 := Useful X.509 cert
164
165
166 */
167 static int
168 cmd_learn (ASSUAN_CONTEXT ctx, char *line)
169 {
170   CTRL ctrl = assuan_get_pointer (ctx);
171   int rc = 0;
172   int idx;
173
174   if ((rc = open_card (ctrl)))
175     return rc;
176
177   /* Unless the force option is used we try a shortcut by identifying
178      the card using a serial number and inquiring the client with
179      that. The client may choose to cancel the operation if he already
180      knows about this card */
181   {
182     char *serial_and_stamp;
183     char *serial;
184     time_t stamp;
185    
186     rc = card_get_serial_and_stamp (ctrl->card_ctx, &serial, &stamp);
187     if (rc)
188       return map_to_assuan_status (rc);
189     rc = asprintf (&serial_and_stamp, "%s %lu", serial, (unsigned long)stamp);
190     xfree (serial);
191     if (rc < 0)
192       return ASSUAN_Out_Of_Core;
193     rc = 0;
194     assuan_write_status (ctx, "SERIALNO", serial_and_stamp);
195
196     if (!has_option (line, "--force"))
197       {
198         char *command;
199
200         rc = asprintf (&command, "KNOWNCARDP %s", serial_and_stamp);
201         if (rc < 0)
202           {
203             free (serial_and_stamp);
204             return ASSUAN_Out_Of_Core;
205           }
206         rc = 0;
207         rc = assuan_inquire (ctx, command, NULL, NULL, 0); 
208         free (command);  /* (must use standard free here) */
209         if (rc)
210           {
211             if (rc != ASSUAN_Canceled)
212               log_error ("inquire KNOWNCARDP failed: %s\n",
213                          assuan_strerror (rc));
214             free (serial_and_stamp);
215             return rc; 
216           }
217         /* not canceled, so we have to proceeed */
218       }
219     free (serial_and_stamp);
220   }
221
222   /* Return information about the certificates. */
223   for (idx=0; !rc; idx++)
224     {
225       char *certid;
226       int certtype;
227
228       rc = card_enum_certs (ctrl->card_ctx, idx, &certid, &certtype);
229       if (!rc)
230         {
231           char *buf;
232
233           buf = xtrymalloc (40 + 1 + strlen (certid) + 1);
234           if (!buf)
235             rc = GNUPG_Out_Of_Core;
236           else
237             {
238               sprintf (buf, "%d %s", certtype, certid);
239               assuan_write_status (ctx, "CERTINFO", buf);
240               xfree (buf);
241             }
242         }
243       xfree (certid);
244     }
245   if (rc == -1)
246     rc = 0;
247
248
249   /* Return information about the keys. */
250   for (idx=0; !rc; idx++)
251     {
252       unsigned char keygrip[20];
253       char *keyid;
254       int no_cert = 0;
255
256       rc = card_enum_keypairs (ctrl->card_ctx, idx, keygrip, &keyid);
257       if (rc == GNUPG_Missing_Certificate && keyid)
258         {
259           /* this does happen with an incomplete personalized
260              card; i.e. during the time we have stored the key on the
261              card but not stored the certificate; probably becuase it
262              has not yet been received back from the CA.  Note that we
263              must release KEYID in this case. */
264           rc = 0; 
265           no_cert = 1;
266         }
267       if (!rc)
268         {
269           char *buf, *p;
270
271           buf = p = xtrymalloc (40 + 1 + strlen (keyid) + 1);
272           if (!buf)
273             rc = GNUPG_Out_Of_Core;
274           else
275             {
276               int i;
277               
278               if (no_cert)
279                 *p++ = 'X';
280               else
281                 {
282                   for (i=0; i < 20; i++, p += 2)
283                     sprintf (p, "%02X", keygrip[i]);
284                 }
285               *p++ = ' ';
286               strcpy (p, keyid);
287               assuan_write_status (ctx, "KEYPAIRINFO", buf);
288               xfree (buf);
289             }
290         }
291       xfree (keyid);
292     }
293   if (rc == -1)
294     rc = 0;
295
296
297   return map_to_assuan_status (rc);
298 }
299
300
301 \f
302 /* READCERT <hexified_certid>
303
304  */
305 static int
306 cmd_readcert (ASSUAN_CONTEXT ctx, char *line)
307 {
308   CTRL ctrl = assuan_get_pointer (ctx);
309   int rc;
310   unsigned char *cert;
311   size_t ncert;
312
313   if ((rc = open_card (ctrl)))
314     return rc;
315
316   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
317   if (rc)
318     {
319       log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
320     }
321   if (!rc)
322     {
323       rc = assuan_send_data (ctx, cert, ncert);
324       xfree (cert);
325       if (rc)
326         return rc;
327     }
328
329   return map_to_assuan_status (rc);
330 }
331
332
333 /* READKEY <hexified_certid>
334
335    Return the public key for the given cert or key ID as an standard
336    S-Expression.  */
337 static int
338 cmd_readkey (ASSUAN_CONTEXT ctx, char *line)
339 {
340   CTRL ctrl = assuan_get_pointer (ctx);
341   int rc;
342   unsigned char *cert = NULL;
343   size_t ncert, n;
344   KsbaCert kc = NULL;
345   KsbaSexp p;
346
347   if ((rc = open_card (ctrl)))
348     return rc;
349
350   rc = card_read_cert (ctrl->card_ctx, line, &cert, &ncert);
351   if (rc)
352     {
353       log_error ("card_read_cert failed: %s\n", gnupg_strerror (rc));
354       goto leave;
355     }
356       
357   kc = ksba_cert_new ();
358   if (!kc)
359     {
360       xfree (cert);
361       rc = GNUPG_Out_Of_Core;
362       goto leave;
363     }
364   rc = ksba_cert_init_from_mem (kc, cert, ncert);
365   if (rc)
366     {
367       log_error ("failed to parse the certificate: %s\n", ksba_strerror (rc));
368       rc = map_ksba_err (rc);
369       goto leave;
370     }
371
372   p = ksba_cert_get_public_key (kc);
373   if (!p)
374     {
375       rc = GNUPG_No_Public_Key;
376       goto leave;
377     }
378
379   n = gcry_sexp_canon_len (p, 0, NULL, NULL);
380   rc = assuan_send_data (ctx, p, n);
381   rc = map_assuan_err (rc);
382   xfree (p);
383
384
385  leave:
386   ksba_cert_release (kc);
387   xfree (cert);
388   return map_to_assuan_status (rc);
389 }
390
391
392 \f
393
394 /* SETDATA <hexstring> 
395
396    The client should use this command to tell us the data he want to
397    sign.  */
398 static int
399 cmd_setdata (ASSUAN_CONTEXT ctx, char *line)
400 {
401   CTRL ctrl = assuan_get_pointer (ctx);
402   int n;
403   char *p;
404   unsigned char *buf;
405
406   /* parse the hexstring */
407   for (p=line,n=0; hexdigitp (p); p++, n++)
408     ;
409   if (*p)
410     return set_error (Parameter_Error, "invalid hexstring");
411   if ((n&1))
412     return set_error (Parameter_Error, "odd number of digits");
413   n /= 2;
414   buf = xtrymalloc (n);
415   if (!buf)
416     return ASSUAN_Out_Of_Core;
417
418   ctrl->in_data.value = buf;
419   ctrl->in_data.valuelen = n;
420   for (p=line, n=0; n < ctrl->in_data.valuelen; p += 2, n++)
421     buf[n] = xtoi_2 (p);
422   return 0;
423 }
424
425
426
427 static int 
428 pin_cb (void *opaque, const char *info, char **retstr)
429 {
430   ASSUAN_CONTEXT ctx = opaque;
431   char *command;
432   int rc;
433   char *value;
434   size_t valuelen;
435
436   *retstr = NULL;
437   log_debug ("asking for PIN '%s'\n", info);
438
439   rc = asprintf (&command, "NEEDPIN %s", info);
440   if (rc < 0)
441     return GNUPG_Out_Of_Core;
442
443   /* FIXME: Write an inquire function which returns the result in
444      secure memory */
445   rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN); 
446   free (command);  
447   if (rc)
448     return map_assuan_err (rc);
449
450   if (!valuelen || value[valuelen-1])
451     {
452       /* We require that the returned value is an UTF-8 string */
453       xfree (value);
454       return GNUPG_Invalid_Response;
455     }
456   *retstr = value;
457   return 0;
458 }
459
460
461 /* PKSIGN <hexified_id>
462
463  */
464 static int
465 cmd_pksign (ASSUAN_CONTEXT ctx, char *line)
466 {
467   CTRL ctrl = assuan_get_pointer (ctx);
468   int rc;
469   void *outdata;
470   size_t outdatalen;
471   char *keyidstr;
472
473   if ((rc = open_card (ctrl)))
474     return rc;
475
476   /* We have to use a copy of the key ID because the function may use
477      the pin_cb which in turn uses the assuan line buffer and thus
478      overwriting the original line with the keyid */
479   keyidstr = strdup (line);
480   if (!keyidstr)
481     return ASSUAN_Out_Of_Core;
482   rc = card_sign (ctrl->card_ctx,
483                   keyidstr, GCRY_MD_SHA1,
484                   pin_cb, ctx,
485                   ctrl->in_data.value, ctrl->in_data.valuelen,
486                   &outdata, &outdatalen);
487   free (keyidstr);
488   if (rc)
489     {
490       log_error ("card_sign failed: %s\n", gnupg_strerror (rc));
491     }
492   else
493     {
494       rc = assuan_send_data (ctx, outdata, outdatalen);
495       xfree (outdata);
496       if (rc)
497         return rc; /* that is already an assuan error code */
498     }
499
500   return map_to_assuan_status (rc);
501 }
502
503 /* PKDECRYPT <hexified_id>
504
505  */
506 static int
507 cmd_pkdecrypt (ASSUAN_CONTEXT ctx, char *line)
508 {
509   CTRL ctrl = assuan_get_pointer (ctx);
510   int rc;
511   void *outdata;
512   size_t outdatalen;
513   char *keyidstr;
514
515   if ((rc = open_card (ctrl)))
516     return rc;
517
518   keyidstr = strdup (line);
519   if (!keyidstr)
520     return ASSUAN_Out_Of_Core;
521   rc = card_decipher (ctrl->card_ctx,
522                       keyidstr, 
523                       pin_cb, ctx,
524                       ctrl->in_data.value, ctrl->in_data.valuelen,
525                       &outdata, &outdatalen);
526   free (keyidstr);
527   if (rc)
528     {
529       log_error ("card_create_signature failed: %s\n", gnupg_strerror (rc));
530     }
531   else
532     {
533       rc = assuan_send_data (ctx, outdata, outdatalen);
534       xfree (outdata);
535       if (rc)
536         return rc; /* that is already an assuan error code */
537     }
538
539   return map_to_assuan_status (rc);
540 }
541
542
543
544 \f
545 /* Tell the assuan library about our commands */
546 static int
547 register_commands (ASSUAN_CONTEXT ctx)
548 {
549   static struct {
550     const char *name;
551     int cmd_id;
552     int (*handler)(ASSUAN_CONTEXT, char *line);
553   } table[] = {
554     { "SERIALNO", 0, cmd_serialno },
555     { "LEARN", 0, cmd_learn },
556     { "READCERT", 0, cmd_readcert },
557     { "READKEY", 0,  cmd_readkey },
558     { "SETDATA", 0,  cmd_setdata },
559     { "PKSIGN", 0,   cmd_pksign },
560     { "PKDECRYPT", 0,cmd_pkdecrypt },
561     { "",     ASSUAN_CMD_INPUT, NULL }, 
562     { "",     ASSUAN_CMD_OUTPUT, NULL }, 
563     { NULL }
564   };
565   int i, j, rc;
566
567   for (i=j=0; table[i].name; i++)
568     {
569       rc = assuan_register_command (ctx,
570                                     table[i].cmd_id? table[i].cmd_id
571                                                    : (ASSUAN_CMD_USER + j++),
572                                     table[i].name, table[i].handler);
573       if (rc)
574         return rc;
575     } 
576   assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
577
578   assuan_register_reset_notify (ctx, reset_notify);
579   assuan_register_option_handler (ctx, option_handler);
580   return 0;
581 }
582
583
584 /* Startup the server.  If LISTEN_FD is given as -1, this is simple
585    piper server, otherwise it is a regular server */
586 void
587 scd_command_handler (int listen_fd)
588 {
589   int rc;
590   ASSUAN_CONTEXT ctx;
591   struct server_control_s ctrl;
592
593   memset (&ctrl, 0, sizeof ctrl);
594   scd_init_default_ctrl (&ctrl);
595   
596   if (listen_fd == -1)
597     {
598       int filedes[2];
599
600       filedes[0] = 0;
601       filedes[1] = 1;
602       rc = assuan_init_pipe_server (&ctx, filedes);
603     }
604   else
605     {
606       rc = assuan_init_socket_server (&ctx, listen_fd);
607     }
608   if (rc)
609     {
610       log_error ("failed to initialize the server: %s\n",
611                  assuan_strerror(rc));
612       scd_exit (2);
613     }
614   rc = register_commands (ctx);
615   if (rc)
616     {
617       log_error ("failed to register commands with Assuan: %s\n",
618                  assuan_strerror(rc));
619       scd_exit (2);
620     }
621   assuan_set_pointer (ctx, &ctrl);
622   ctrl.server_local = xcalloc (1, sizeof *ctrl.server_local);
623   ctrl.server_local->assuan_ctx = ctx;
624
625   if (DBG_ASSUAN)
626     assuan_set_log_stream (ctx, log_get_stream ());
627
628   for (;;)
629     {
630       rc = assuan_accept (ctx);
631       if (rc == -1)
632         {
633           break;
634         }
635       else if (rc)
636         {
637           log_info ("Assuan accept problem: %s\n", assuan_strerror (rc));
638           break;
639         }
640       
641       rc = assuan_process (ctx);
642       if (rc)
643         {
644           log_info ("Assuan processing failed: %s\n", assuan_strerror (rc));
645           continue;
646         }
647     }
648   reset_notify (ctx); /* used for cleanup */
649
650   assuan_deinit_server (ctx);
651 }