2004-06-20 Moritz Schulte <moritz@g10code.com>
[gnupg.git] / agent / learncard.c
1 /* learncard.c - Handle the LEARN command
2  *      Copyright (C) 2002, 2003 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.h>
33
34 struct keypair_info_s {
35   struct keypair_info_s *next;
36   int no_cert;
37   char *id;  /* points into grip */
38   char hexgrip[1];
39 };
40 typedef struct keypair_info_s *KEYPAIR_INFO;
41
42 struct kpinfo_cb_parm_s {
43   int error;
44   KEYPAIR_INFO info;
45 };
46
47
48 struct certinfo_s {
49   struct certinfo_s *next;
50   int type;  
51   int done;
52   char id[1];
53 };
54 typedef struct certinfo_s *CERTINFO;
55
56 struct certinfo_cb_parm_s {
57   int error;
58   CERTINFO info;
59 };
60
61
62 struct sinfo_s {
63   struct sinfo_s *next;
64   char *data;       /* Points into keyword. */
65   char keyword[1];  
66 };
67 typedef struct sinfo_s *SINFO;  
68
69 struct sinfo_cb_parm_s {
70   int error;;
71   SINFO info;
72 };
73
74
75
76 static void
77 release_keypair_info (KEYPAIR_INFO info)
78 {
79   while (info)
80     {
81       KEYPAIR_INFO tmp = info->next;
82       xfree (info);
83       info = tmp;
84     }
85 }
86
87 static void
88 release_certinfo (CERTINFO info)
89 {
90   while (info)
91     {
92       CERTINFO tmp = info->next;
93       xfree (info);
94       info = tmp;
95     }
96 }
97
98 static void
99 release_sinfo (SINFO info)
100 {
101   while (info)
102     {
103       SINFO tmp = info->next;
104       xfree (info);
105       info = tmp;
106     }
107 }
108
109
110
111 /* This callback is used by agent_card_learn and passed the content of
112    all KEYPAIRINFO lines.  It merely stores this data away */
113 static void
114 kpinfo_cb (void *opaque, const char *line)
115 {
116   struct kpinfo_cb_parm_s *parm = opaque;
117   KEYPAIR_INFO item;
118   char *p;
119
120   if (parm->error)
121     return; /* no need to gather data after an error coccured */
122   item = xtrycalloc (1, sizeof *item + strlen (line));
123   if (!item)
124     {
125       parm->error = out_of_core ();
126       return;
127     }
128   strcpy (item->hexgrip, line);
129   for (p = item->hexgrip; hexdigitp (p); p++)
130     ;
131   if (p == item->hexgrip && *p == 'X' && spacep (p+1))
132     {
133       item->no_cert = 1;
134       p++;
135     }
136   else if ((p - item->hexgrip) != 40 || !spacep (p))
137     { /* not a 20 byte hex keygrip or not followed by a space */
138       parm->error = gpg_error (GPG_ERR_INV_RESPONSE);
139       xfree (item);
140       return;
141     }
142   *p++ = 0;
143   while (spacep (p))
144     p++;
145   item->id = p;
146   while (*p && !spacep (p))
147     p++;
148   if (p == item->id)
149     { /* invalid ID string */
150       parm->error = gpg_error (GPG_ERR_INV_RESPONSE);
151       xfree (item);
152       return;
153     }
154   *p = 0; /* ignore trailing stuff */
155   
156   /* store it */
157   item->next = parm->info;
158   parm->info = item;
159 }
160
161
162 /* This callback is used by agent_card_learn and passed the content of
163    all CERTINFO lines.  It merely stores this data away */
164 static void
165 certinfo_cb (void *opaque, const char *line)
166 {
167   struct certinfo_cb_parm_s *parm = opaque;
168   CERTINFO item;
169   int type;
170   char *p, *pend;
171
172   if (parm->error)
173     return; /* no need to gather data after an error coccured */
174
175   type = strtol (line, &p, 10);
176   while (spacep (p))
177     p++;
178   for (pend = p; *pend && !spacep (pend); pend++)
179     ;
180   if (p == pend || !*p)
181     { 
182       parm->error = gpg_error (GPG_ERR_INV_RESPONSE);
183       return;
184     }
185   *pend = 0; /* ignore trailing stuff */
186
187   item = xtrycalloc (1, sizeof *item + strlen (p));
188   if (!item)
189     {
190       parm->error = out_of_core ();
191       return;
192     }
193   item->type = type;
194   strcpy (item->id, p);
195   /* store it */
196   item->next = parm->info;
197   parm->info = item;
198 }
199
200
201 /* This callback is used by agent_card_learn and passed the content of
202    all SINFO lines.  It merely stores this data away */
203 static void
204 sinfo_cb (void *opaque, const char *keyword, size_t keywordlen,
205           const char *data)
206 {
207   struct sinfo_cb_parm_s *sparm = opaque;
208   SINFO item;
209
210   if (sparm->error)
211     return; /* no need to gather data after an error coccured */
212
213   item = xtrycalloc (1, sizeof *item + keywordlen + 1 + strlen (data));
214   if (!item)
215     {
216       sparm->error = out_of_core ();
217       return;
218     }
219   memcpy (item->keyword, keyword, keywordlen);
220   item->data = item->keyword + keywordlen;
221   *item->data = 0;
222   item->data++;
223   strcpy (item->data, data);
224   /* store it */
225   item->next = sparm->info;
226   sparm->info = item;
227 }
228
229
230 /* Create an S-expression with the shadow info.  */
231 static unsigned char *
232 make_shadow_info (const char *serialno, const char *idstring)
233 {
234   const char *s;
235   unsigned char *info, *p;
236   char numbuf[21];
237   int n;
238
239   for (s=serialno, n=0; *s && s[1]; s += 2)
240     n++;
241
242   info = p = xtrymalloc (1 + 21 + n
243                            + 21 + strlen (idstring) + 1 + 1);
244   *p++ = '(';
245   sprintf (numbuf, "%d:", n);
246   p = stpcpy (p, numbuf);
247   for (s=serialno; *s && s[1]; s += 2)
248     *p++ = xtoi_2 (s);
249   sprintf (numbuf, "%d:", strlen (idstring));
250   p = stpcpy (p, numbuf);
251   p = stpcpy (p, idstring);
252   *p++ = ')';
253   *p = 0;
254   return info;
255 }
256
257 static int
258 send_cert_back (ctrl_t ctrl, const char *id, void *assuan_context)
259 {
260   int rc;
261   char *derbuf;
262   size_t derbuflen;
263   
264   rc = agent_card_readcert (ctrl, id, &derbuf, &derbuflen);
265   if (rc)
266     {
267       log_error ("error reading certificate: %s\n",
268                  gpg_strerror (rc));
269       return rc;
270     }
271
272   rc = assuan_send_data (assuan_context, derbuf, derbuflen);
273   xfree (derbuf);
274   if (!rc)
275     rc = assuan_send_data (assuan_context, NULL, 0);
276   if (!rc)
277     rc = assuan_write_line (assuan_context, "END");
278   if (rc)
279     {
280       log_error ("sending certificate failed: %s\n",
281                  assuan_strerror (rc));
282       return map_assuan_err (rc);
283     }
284   return 0;
285 }
286
287 /* Perform the learn operation.  If ASSUAN_CONTEXT is not NULL all new
288    certificates are send via Assuan */
289 int
290 agent_handle_learn (ctrl_t ctrl, void *assuan_context)
291 {
292   int rc;
293   struct kpinfo_cb_parm_s parm;
294   struct certinfo_cb_parm_s cparm;
295   struct sinfo_cb_parm_s sparm;
296   char *serialno = NULL;
297   KEYPAIR_INFO item;
298   SINFO sitem;
299   unsigned char grip[20];
300   char *p;
301   int i;
302   static int certtype_list[] = { 
303     101, /* trusted */
304     102, /* useful */
305     100, /* regular */
306     /* We don't include 110 here because gpgsm can't handle it. */
307     -1 /* end of list */
308   };
309
310
311   memset (&parm, 0, sizeof parm);
312   memset (&cparm, 0, sizeof cparm);
313   memset (&sparm, 0, sizeof sparm);
314
315   /* Check whether a card is present and get the serial number */
316   rc = agent_card_serialno (ctrl, &serialno);
317   if (rc)
318     goto leave;
319
320   /* now gather all the available info */
321   rc = agent_card_learn (ctrl, kpinfo_cb, &parm, certinfo_cb, &cparm,
322                          sinfo_cb, &sparm);
323   if (!rc && (parm.error || cparm.error || sparm.error))
324     rc = parm.error? parm.error : cparm.error? cparm.error : sparm.error;
325   if (rc)
326     {
327       log_debug ("agent_card_learn failed: %s\n", gpg_strerror (rc));
328       goto leave;
329     }
330   
331   log_info ("card has S/N: %s\n", serialno);
332
333   /* Pass on all the collected status information. */
334   if (assuan_context)
335     {
336       for (sitem = sparm.info; sitem; sitem = sitem->next)
337         {
338           assuan_write_status (assuan_context, sitem->keyword, sitem->data);
339         }
340     }
341
342   /* Write out the certificates in a standard order. */
343   for (i=0; certtype_list[i] != -1; i++)
344     {
345       CERTINFO citem;
346       for (citem = cparm.info; citem; citem = citem->next)
347         {
348           if (certtype_list[i] != citem->type)
349             continue;
350
351           if (opt.verbose)
352             log_info ("          id: %s    (type=%d)\n",
353                       citem->id, citem->type);
354           
355           if (assuan_context)
356             {
357               rc = send_cert_back (ctrl, citem->id, assuan_context);
358               if (rc)
359                 goto leave;
360               citem->done = 1;
361             }
362         }
363     }
364   
365   for (item = parm.info; item; item = item->next)
366     {
367       unsigned char *pubkey, *shdkey;
368       size_t n;
369
370       if (opt.verbose)
371         log_info ("          id: %s    (grip=%s)\n", item->id, item->hexgrip);
372
373       if (item->no_cert)
374         continue; /* no public key yet available */
375
376       for (p=item->hexgrip, i=0; i < 20; p += 2, i++)
377         grip[i] = xtoi_2 (p);
378       
379       if (!agent_key_available (grip))
380         continue;
381       
382       /* unknown - store it */
383       rc = agent_card_readkey (ctrl, item->id, &pubkey);
384       if (rc)
385         {
386           log_debug ("agent_card_readkey failed: %s\n", gpg_strerror (rc));
387           goto leave;
388         }
389
390       {
391         unsigned char *shadow_info = make_shadow_info (serialno, item->id);
392         if (!shadow_info)
393           {
394             rc = gpg_error (GPG_ERR_ENOMEM);
395             xfree (pubkey);
396             goto leave;
397           }
398         rc = agent_shadow_key (pubkey, shadow_info, &shdkey);
399         xfree (shadow_info);
400       }
401       xfree (pubkey);
402       if (rc)
403         {
404           log_error ("shadowing the key failed: %s\n", gpg_strerror (rc));
405           goto leave;
406         }
407       n = gcry_sexp_canon_len (shdkey, 0, NULL, NULL);
408       assert (n);
409
410       rc = agent_write_private_key (grip, shdkey, n, 0);
411       xfree (shdkey);
412       if (rc)
413         {
414           log_error ("error writing key: %s\n", gpg_strerror (rc));
415           goto leave;
416         }
417
418       if (opt.verbose)
419         log_info ("stored\n");
420       
421       if (assuan_context)
422         {
423           CERTINFO citem;
424           
425           /* only send the certificate if we have not done so before */
426           for (citem = cparm.info; citem; citem = citem->next)
427             {
428               if (!strcmp (citem->id, item->id))
429                 break;
430             }
431           if (!citem)
432             {
433               rc = send_cert_back (ctrl, item->id, assuan_context);
434               if (rc)
435                 goto leave;
436             }
437         }
438     }
439
440   
441  leave:
442   xfree (serialno);
443   release_keypair_info (parm.info);
444   release_certinfo (cparm.info);
445   release_sinfo (sparm.info);
446   return rc;
447 }
448
449