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