4fe969b34130a33d6596015644fdec8aa7f02673
[scute.git] / src / agent.c
1 /* agent.c - Talking to gpg-agent.
2    Copyright (C) 2006, 2007, 2008, 2015 g10 Code GmbH
3
4    This file is part of Scute.
5
6    Scute is free software; you can redistribute it and/or modify it
7    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    Scute is distributed in the hope that it will be useful, but
12    WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with Scute; if not, write to the Free Software Foundation,
18    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19
20    In addition, as a special exception, g10 Code GmbH gives permission
21    to link this library: with the Mozilla Foundation's code for
22    Mozilla (or with modified versions of it that use the same license
23    as the "Mozilla" code), and distribute the linked executables.  You
24    must obey the GNU General Public License in all respects for all of
25    the code used other than "Mozilla".  If you modify this file, you
26    may extend this exception to your version of the file, but you are
27    not obligated to do so.  If you do not wish to do so, delete this
28    exception statement from your version.  */
29
30 #if HAVE_CONFIG_H
31 #include <config.h>
32 #endif
33
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <locale.h>
37 #include <errno.h>
38 #include <string.h>
39 #include <stdarg.h>
40
41 #ifdef HAVE_W32_SYSTEM
42 #define PATHSEP_C ';'
43 #define WINVER 0x0500  /* Required for AllowSetForegroundWindow.  */
44 #include <windows.h>
45 #else
46 #define PATHSEP_C ':'
47 #endif
48
49 #include <assuan.h>
50 #include <gpg-error.h>
51
52 #include "debug.h"
53 #include "support.h"
54 #include "sexp-parse.h"
55 #include "cert.h"
56 #include "agent.h"
57
58 \f
59 /* The global agent context.  */
60 static assuan_context_t agent_ctx = NULL;
61
62 /* The version number of the agent.  */
63 static int agent_version_major;
64 static int agent_version_minor;
65
66
67 \f
68 /* Hack required for Windows.  */
69 void
70 gnupg_allow_set_foregound_window (pid_t pid)
71 {
72   if (!pid || pid == (pid_t)(-1))
73     return;
74 #ifdef HAVE_W32_SYSTEM
75   else if (!AllowSetForegroundWindow (pid))
76     DEBUG (DBG_CRIT, "AllowSetForegroundWindow(%lu) failed: %i\n",
77            (unsigned long)pid, GetLastError ());
78 #endif
79 }
80
81
82 \f
83 /* Establish a connection to a running GPG agent.  */
84 static gpg_error_t
85 agent_connect (assuan_context_t *ctx_r)
86 {
87   gpg_error_t err = 0;
88   assuan_context_t ctx = NULL;
89   char buffer[255];
90   FILE *p;
91
92   /* Use gpg-connect-agent to obtain the socket name
93    * directly from the agent itself. */
94   snprintf (buffer, sizeof buffer, "%s 'GETINFO socket_name' /bye",
95             get_gpg_connect_agent_path ());
96 #ifdef HAVE_W32_SYSTEM
97   p = _popen (buffer, "r");
98 #else
99   p = popen (buffer, "r");
100 #endif
101   if (p)
102     {
103       int ret;
104
105       ret = fscanf (p, "D %254s\nOK\n", buffer);
106       if (ret == EOF)       /* I/O error? */
107         err = gpg_error_from_errno (errno);
108       else if (ret != 1)    /* Unexpected reply */
109         err = gpg_error (GPG_ERR_NO_AGENT);
110
111       pclose (p);
112     }
113   else
114     err = gpg_error_from_errno (errno);
115
116   /* Then connect to the socket we got. */
117   if (!err)
118     {
119       err = assuan_new (&ctx);
120       if (!err)
121         {
122           err = assuan_socket_connect (ctx, buffer, 0, 0);
123           if (!err)
124             {
125               *ctx_r = ctx;
126               if (_scute_debug_flags & DBG_ASSUAN)
127                 assuan_set_log_stream (*ctx_r, _scute_debug_stream);
128             }
129           else
130             assuan_release (ctx);
131         }
132     }
133
134   /* We do not try any harder. If gpg-connect-agent somehow failed
135    * to give us a suitable socket, we probably cannot do better. */
136   if (err)
137     DEBUG (DBG_CRIT, "cannot connect to GPG agent: %s", gpg_strerror (err));
138
139   return err;
140 }
141
142
143 /* This is the default inquiry callback.  It mainly handles the
144    Pinentry notifications.  */
145 static gpg_error_t
146 default_inq_cb (void *opaque, const char *line)
147 {
148   (void)opaque;
149
150   if (!strncmp (line, "PINENTRY_LAUNCHED", 17) && (line[17]==' '||!line[17]))
151     {
152       gnupg_allow_set_foregound_window ((pid_t)strtoul (line+17, NULL, 10));
153       /* We do not pass errors to avoid breaking other code.  */
154     }
155   else
156     DEBUG (DBG_CRIT, "ignoring gpg-agent inquiry `%s'\n", line);
157
158   return 0;
159 }
160
161
162 /* Send a simple command to the agent.  */
163 static gpg_error_t
164 agent_simple_cmd (assuan_context_t ctx, const char *fmt, ...)
165 {
166   gpg_error_t err;
167   char *optstr;
168   va_list arg;
169   int res;
170
171   va_start (arg, fmt);
172   res = vasprintf (&optstr, fmt, arg);
173   va_end (arg);
174
175   if (res < 0)
176     return gpg_error_from_errno (errno);
177
178   err = assuan_transact (ctx, optstr, NULL, NULL, default_inq_cb,
179                          NULL, NULL, NULL);
180   if (err)
181     DEBUG (DBG_CRIT, "gpg-agent command '%s' failed: %s", optstr,
182            gpg_strerror (err));
183   free (optstr);
184
185   return err;
186 }
187
188
189 /* Read and stroe the agent's version number.  */
190 static gpg_error_t
191 read_version_cb (void *opaque, const void *buffer, size_t length)
192 {
193   char version[20];
194   const char *s;
195
196   (void) opaque;
197
198   if (length > sizeof (version) -1)
199     length = sizeof (version) - 1;
200   strncpy (version, buffer, length);
201   version[length] = 0;
202
203   agent_version_major = atoi (version);
204   s = strchr (version, '.');
205   agent_version_minor = s? atoi (s+1) : 0;
206
207   return 0;
208 }
209
210
211 /* Configure the GPG agent at connection CTX.  */
212 static gpg_error_t
213 agent_configure (assuan_context_t ctx)
214 {
215   gpg_error_t err = 0;
216   char *dft_display = NULL;
217   char *dft_ttyname = NULL;
218   char *dft_ttytype = NULL;
219 #if defined(HAVE_SETLOCALE) && (defined(LC_CTYPE) || defined(LC_MESSAGES))
220   char *old_lc = NULL;
221   char *dft_lc = NULL;
222 #endif
223   char *dft_xauthority = NULL;
224   char *dft_pinentry_user_data = NULL;
225
226   err = agent_simple_cmd (ctx, "RESET");
227   if (err)
228     return err;
229
230   /* Set up display, terminal and locale options.  */
231   dft_display = getenv ("DISPLAY");
232   if (dft_display)
233     err = agent_simple_cmd (ctx, "OPTION display=%s", dft_display);
234   if (err)
235     return err;
236
237   dft_ttyname = getenv ("GPG_TTY");
238   if ((!dft_ttyname || !*dft_ttyname) && ttyname (0))
239     dft_ttyname = ttyname (0);
240   if (dft_ttyname)
241     {
242       err = agent_simple_cmd (ctx, "OPTION ttyname=%s", dft_ttyname);
243       if (err)
244         return err;
245     }
246
247   dft_ttytype = getenv ("TERM");
248   if (dft_ttytype)
249     err = agent_simple_cmd (ctx, "OPTION ttytype=%s", dft_ttytype);
250   if (err)
251     return err;
252
253 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
254   old_lc = setlocale (LC_CTYPE, NULL);
255   if (old_lc)
256     {
257       old_lc = strdup (old_lc);
258       if (!old_lc)
259         return gpg_error_from_errno (errno);
260     }
261   dft_lc = setlocale (LC_CTYPE, "");
262   if (dft_lc)
263     err = agent_simple_cmd ("OPTION lc-ctype=%s", dft_lc);
264   if (old_lc)
265     {
266       setlocale (LC_CTYPE, old_lc);
267       free (old_lc);
268     }
269 #endif
270   if (err)
271     return err;
272
273 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
274   old_lc = setlocale (LC_MESSAGES, NULL);
275   if (old_lc)
276     {
277       old_lc = strdup (old_lc);
278       if (!old_lc)
279         err = gpg_error_from_errno (errno);
280     }
281   dft_lc = setlocale (LC_MESSAGES, "");
282   if (dft_lc)
283     err = agent_simple_cmd ("OPTION lc-messages=%s", dft_lc);
284   if (old_lc)
285     {
286       setlocale (LC_MESSAGES, old_lc);
287       free (old_lc);
288     }
289 #endif
290
291   dft_xauthority = getenv ("XAUTHORITY");
292   if (dft_xauthority)
293     err = agent_simple_cmd (ctx, "OPTION xauthority=%s", dft_xauthority);
294   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
295     err = 0;
296   else if (err)
297     return err;
298
299   dft_pinentry_user_data = getenv ("PINENTRY_USER_DATA");
300   if (dft_pinentry_user_data)
301     err = agent_simple_cmd (ctx, "OPTION pinentry_user_data=%s",
302                             dft_pinentry_user_data);
303   if (err && gpg_err_code (err) != GPG_ERR_UNKNOWN_OPTION)
304     return err;
305
306   err = agent_simple_cmd (ctx, "OPTION allow-pinentry-notify");
307   if (err && gpg_err_code (err) != GPG_ERR_UNKNOWN_OPTION)
308     return err;
309
310   err = assuan_transact (ctx, "GETINFO version",
311                          read_version_cb, NULL,
312                          NULL, NULL, NULL, NULL);
313   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
314     err = 0;
315   else if (err)
316     return err;
317
318
319   return err;
320 }
321
322
323 /* Try to connect to the agent via socket.  Handle the server's
324    initial greeting.  */
325 gpg_error_t
326 scute_agent_initialize (void)
327 {
328   gpg_error_t err = 0;
329
330   if (agent_ctx)
331     {
332       DEBUG (DBG_CRIT, "GPG Agent connection already established");
333       return 0;
334     }
335
336   DEBUG (DBG_INFO, "Establishing connection to gpg-agent");
337   err = agent_connect (&agent_ctx);
338   if (err)
339     return err;
340
341   err = agent_configure (agent_ctx);
342   if (err)
343     scute_agent_finalize ();
344
345   return err;
346 }
347
348
349 int
350 scute_agent_get_agent_version (int *minor)
351 {
352   *minor = agent_version_minor;
353   return agent_version_major;
354 }
355
356
357 \f
358 /* Return a new malloced string by unescaping the string S.  Escaping
359    is percent escaping and '+'/space mapping.  A binary nul will
360    silently be replaced by a 0xFF.  Function returns NULL to indicate
361    an out of memory status.  */
362 static char *
363 unescape_status_string (const unsigned char *src)
364 {
365   char *buffer;
366   char *dst;
367
368   buffer = malloc (strlen (src) + 1);
369   if (!buffer)
370     return NULL;
371
372   dst = buffer;
373   while (*src)
374     {
375       if (*src == '%' && src[1] && src[2])
376         {
377           src++;
378           *dst = xtoi_2 (src);
379           if (*dst == '\0')
380             *dst = '\xff';
381           dst++;
382           src += 2;
383         }
384       else if (*src == '+')
385         {
386           *(dst++) = ' ';
387           src++;
388         }
389       else
390         *(dst++) = *(src++);
391     }
392   *dst = 0;
393
394   return buffer;
395 }
396
397
398 /* Take a 20 byte hexencoded string and put it into the provided
399    20 byte buffer FPR in binary format.  Returns true if successful,
400    and false otherwise.  */
401 static int
402 unhexify_fpr (const char *hexstr, unsigned char *fpr)
403 {
404   const char *src;
405   int cnt;
406
407   /* Check for invalid or wrong length.  */
408   for (src = hexstr, cnt = 0; hexdigitp (src); src++, cnt++)
409     ;
410   if ((*src && !spacep (src)) || (cnt != 40))
411     return 0;
412
413   for (src = hexstr, cnt = 0; *src && !spacep (src); src += 2, cnt++)
414     fpr[cnt] = xtoi_2 (src);
415
416   return 1;
417 }
418
419 /* Return true if HEXSTR is a valid keygrip.  */
420 static unsigned int
421 hexgrip_valid_p (const char *hexstr)
422 {
423   const char *s;
424   int n;
425
426   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
427     ;
428   if ((*s && *s != ' ') || n != 40)
429     return 0; /* Bad keygrip */
430   else
431     return 1; /* Valid.  */
432 }
433
434
435 /* Take the serial number from LINE and return it verbatim in a newly
436    allocated string.  We make sure that only hex characters are
437    returned.  */
438 static char *
439 store_serialno (const char *line)
440 {
441   const char *src;
442   char *ptr;
443
444   for (src = line; hexdigitp (src); src++)
445     ;
446   ptr = malloc (src + 1 - line);
447
448   if (ptr)
449     {
450       memcpy (ptr, line, src - line);
451       ptr[src - line] = 0;
452     }
453
454   return ptr;
455 }
456
457 \f
458 /* Release the card info structure INFO.  */
459 void
460 scute_agent_release_card_info (struct agent_card_info_s *info)
461 {
462   if (!info)
463     return;
464
465   free (info->serialno);
466   free (info->cardtype);
467   free (info->disp_name);
468   free (info->disp_lang);
469   free (info->pubkey_url);
470   free (info->login_data);
471   while (info->kinfo)
472     {
473       key_info_t ki = info->kinfo->next;
474       free (info->kinfo);
475       info->kinfo = ki;
476     }
477
478   memset (info, 0, sizeof (*info));
479 }
480
481
482 /* Return the key info object for the key KEYREF.  If it is not found
483  * NULL is returned.  */
484 key_info_t
485 scute_find_kinfo (agent_card_info_t info, const char *keyref)
486 {
487   key_info_t kinfo;
488
489   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
490     if (!strcmp (kinfo->keyref, keyref))
491       return kinfo;
492   return NULL;
493 }
494
495
496 /* Create a new key info object with KEYREF.  All fields but the
497  * keyref are zeroed out.  The created object is appended to the list
498  * at INFO. */
499 static key_info_t
500 create_kinfo (agent_card_info_t info, const char *keyref)
501 {
502   key_info_t kinfo, ki;
503
504   kinfo = calloc (1, sizeof *kinfo + strlen (keyref));
505   if (!kinfo)
506     return NULL;
507   strcpy (kinfo->keyref, keyref);
508
509   if (!info->kinfo)
510     info->kinfo = kinfo;
511   else
512     {
513       for (ki=info->kinfo; ki->next; ki = ki->next)
514         ;
515       ki->next = kinfo;
516     }
517   return kinfo;
518 }
519
520
521 /* FIXME: We are not returning out of memory errors.  */
522 static gpg_error_t
523 learn_status_cb (void *opaque, const char *line)
524 {
525   agent_card_info_t parm = opaque;
526   const char *keyword = line;
527   int keywordlen;
528   key_info_t kinfo;
529   const char *keyref;
530   int i;
531
532   for (keywordlen = 0; *line && !spacep (line); line++, keywordlen++)
533     ;
534   while (spacep (line))
535     line++;
536
537   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
538     {
539       free (parm->serialno);
540       parm->serialno = store_serialno (line);
541     }
542   else if (keywordlen == 7 && !memcmp (keyword, "APPTYPE", keywordlen))
543     {
544       parm->is_piv = !strcmp (line, "PIV");
545     }
546   else if (keywordlen == 8 && !memcmp (keyword, "CARDTYPE", keywordlen))
547     {
548       free (parm->cardtype);
549       parm->cardtype = unescape_status_string (line);
550     }
551   else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
552     {
553       if (parm->disp_name)
554         free (parm->disp_name);
555       parm->disp_name = unescape_status_string (line);
556     }
557   else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
558     {
559       if (parm->disp_lang)
560         free (parm->disp_lang);
561       parm->disp_lang = unescape_status_string (line);
562     }
563   else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
564     {
565       parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
566     }
567   else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
568     {
569       if (parm->pubkey_url)
570         free (parm->pubkey_url);
571       parm->pubkey_url = unescape_status_string (line);
572     }
573   else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
574     {
575       if (parm->login_data)
576         free (parm->login_data);
577       parm->login_data = unescape_status_string (line);
578     }
579   else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
580     {
581       parm->sig_counter = strtoul (line, NULL, 0);
582     }
583   else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
584     {
585       char *p, *buf;
586
587       buf = p = unescape_status_string (line);
588       if (buf)
589         {
590           while (spacep (p))
591             p++;
592           parm->chv1_cached = atoi (p);
593           while (*p && !spacep (p))
594             p++;
595           while (spacep (p))
596             p++;
597           for (i = 0; *p && i < 3; i++)
598             {
599               parm->chvmaxlen[i] = atoi (p);
600               while (*p && !spacep (p))
601                 p++;
602               while (spacep (p))
603                 p++;
604             }
605           for (i=0; *p && i < 3; i++)
606             {
607               parm->chvretry[i] = atoi (p);
608               while (*p && !spacep (p))
609                 p++;
610               while (spacep (p))
611                 p++;
612             }
613           free (buf);
614         }
615     }
616   else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
617     {
618       int no = atoi (line);
619       while (*line && !spacep (line))
620         line++;
621       while (spacep (line))
622         line++;
623       if (no == 1)
624         parm->fpr1valid = unhexify_fpr (line, parm->fpr1);
625       else if (no == 2)
626         parm->fpr2valid = unhexify_fpr (line, parm->fpr2);
627       else if (no == 3)
628         parm->fpr3valid = unhexify_fpr (line, parm->fpr3);
629     }
630   else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
631     {
632       int no = atoi (line);
633       while (*line && !spacep (line))
634         line++;
635       while (spacep (line))
636         line++;
637       if (no == 1)
638         parm->cafpr1valid = unhexify_fpr (line, parm->cafpr1);
639       else if (no == 2)
640         parm->cafpr2valid = unhexify_fpr (line, parm->cafpr2);
641       else if (no == 3)
642         parm->cafpr3valid = unhexify_fpr (line, parm->cafpr3);
643     }
644   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
645     {
646       /* The format of such a line is:
647        *   KEYPARINFO <hexgrip> <keyref>
648        */
649       const char *hexgrip = line;
650
651       while (*line && !spacep (line))
652         line++;
653       while (spacep (line))
654         line++;
655       keyref = line;
656
657       if (hexgrip_valid_p (hexgrip))
658         {
659           /* Check whether we already have an item for the keyref.  */
660           kinfo = scute_find_kinfo (parm, keyref);
661           if (!kinfo)  /* New entry.  */
662             {
663               kinfo = create_kinfo (parm, keyref);
664               if (!kinfo)
665                 goto no_core;
666             }
667           else /* Existing entry - clear the grip.  */
668             *kinfo->grip = 0;
669
670           strncpy (kinfo->grip, hexgrip, sizeof kinfo->grip);
671           kinfo->grip[sizeof kinfo->grip -1] = 0;
672         }
673     }
674   else if (keywordlen == 6 && !memcmp (keyword, "EXTCAP", keywordlen))
675     {
676       char *p, *p2, *buf;
677       int abool;
678
679       buf = p = unescape_status_string (line);
680       if (buf)
681         {
682           for (p = strtok (buf, " "); p; p = strtok (NULL, " "))
683             {
684               p2 = strchr (p, '=');
685               if (p2)
686                 {
687                   *p2++ = 0;
688                   abool = (*p2 == '1');
689                   if (!strcmp (p, "gc"))
690                     parm->rng_available = abool;
691                   /* We're currently not interested in the
692                    * other capabilities. */
693                 }
694             }
695           free (buf);
696         }
697     }
698   return 0;
699
700  no_core:
701   return gpg_error_from_syserror ();
702 }
703
704
705 /* Call the agent to learn about a smartcard.  */
706 gpg_error_t
707 scute_agent_learn (struct agent_card_info_s *info)
708 {
709   gpg_error_t err;
710
711   memset (info, 0, sizeof (*info));
712   err = assuan_transact (agent_ctx, "LEARN --sendinfo",
713                          NULL, NULL, default_inq_cb,
714                          NULL, learn_status_cb, info);
715
716   return err;
717 }
718
719
720
721 static gpg_error_t
722 geteventcounter_status_cb (void *opaque, const char *line)
723 {
724   int *result = opaque;
725   const char *keyword = line;
726   int keywordlen;
727
728   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
729     ;
730   while (spacep (line))
731     line++;
732
733   if (keywordlen == 12 && !memcmp (keyword, "EVENTCOUNTER", keywordlen))
734     {
735       static int any_count;
736       static unsigned int last_count;
737       unsigned int count;
738
739       if (sscanf (line, "%*u %*u %u ", &count) == 1)
740         {
741           if (any_count && last_count != count)
742             *result = 1;
743           any_count = 1;
744           last_count = count;
745         }
746     }
747
748   return 0;
749 }
750
751
752 static gpg_error_t
753 read_status_cb (void *opaque, const void *buffer, size_t length)
754 {
755   char *flag = opaque;
756
757   if (length == 0)
758     *flag = 'r';
759   else
760     *flag = *((char *) buffer);
761
762   return 0;
763 }
764
765
766 /* Check the agent status.  This returns 0 if a token is present,
767    GPG_ERR_CARD_REMOVED if no token is present, and an error code
768    otherwise.  */
769 gpg_error_t
770 scute_agent_check_status (void)
771 {
772   static char last_flag;
773   gpg_error_t err;
774   int any = 0;
775   char flag = '-';
776
777   /* First we look at the eventcounter to see if anything happened at
778      all.  This is a low overhead function which won't even clutter a
779      gpg-agent log file.  There is no need for error checking here. */
780   if (last_flag)
781     assuan_transact (agent_ctx, "GETEVENTCOUNTER",
782                      NULL, NULL,
783                      NULL, NULL,
784                      geteventcounter_status_cb, &any);
785
786   if (any || !last_flag)
787     {
788       err = assuan_transact (agent_ctx, "SCD GETINFO status",
789                              read_status_cb, &flag,
790                              default_inq_cb, NULL,
791                              NULL, NULL);
792       if (err)
793         return err;
794       last_flag = flag;
795     }
796   else
797     flag = last_flag;
798
799
800   if (flag == 'r')
801     return gpg_error (GPG_ERR_CARD_REMOVED);
802
803   return 0;
804 }
805
806 \f
807 /* We only support RSA signatures up to 4096 bits.  */
808 #define MAX_SIGNATURE_BITS 4096
809
810 /* Enough space to hold a 4096 bit RSA signature in an S-expression.  */
811 #define MAX_SIGNATURE_LEN 640   /* FIXME: magic value */
812
813 struct signature
814 {
815   unsigned char data[MAX_SIGNATURE_LEN];
816   int len;
817 };
818
819 static gpg_error_t
820 pksign_cb (void *opaque, const void *buffer, size_t length)
821 {
822   struct signature *sig = opaque;
823
824   if (sig->len + length > MAX_SIGNATURE_LEN)
825     {
826       DEBUG (DBG_INFO, "maximum signature length exceeded");
827       return gpg_error (GPG_ERR_BAD_DATA);
828     }
829
830   memcpy (&sig->data[sig->len], buffer, length);
831   sig->len += length;
832
833   return 0;
834 }
835
836 /* Parse the result of an pksign operation which is a s-expression in
837    canonical form that looks like (7:sig-val(3:rsa(1:s<LENGTH>:<DATA>))).
838    The raw result is stored in RESULT of size *LEN, and *LEN is
839    adjusted to the actual size.  */
840 static gpg_error_t
841 pksign_parse_result (const struct signature *sig,
842                      unsigned char *result, unsigned int *len)
843 {
844   gpg_error_t err;
845   const unsigned char *s = sig->data;
846   size_t n;
847   int depth;
848
849   if (*s++ != '(')
850     gpg_error (GPG_ERR_INV_SEXP);
851
852   n = snext (&s);
853   if (! n)
854     return gpg_error (GPG_ERR_INV_SEXP);
855   if (! smatch (&s, n, "sig-val"))
856     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
857
858   if (*s++ != '(')
859     gpg_error (GPG_ERR_UNKNOWN_SEXP);
860
861   n = snext (&s);
862   if (! n)
863     return gpg_error (GPG_ERR_INV_SEXP);
864   if (! smatch (&s, n, "rsa"))
865     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
866
867   if (*s++ != '(')
868     gpg_error (GPG_ERR_UNKNOWN_SEXP);
869
870   n = snext (&s);
871   if (! n)
872     return gpg_error (GPG_ERR_INV_SEXP);
873   if (! smatch (&s, n, "s"))
874     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
875
876   n = snext (&s);
877   if (! n)
878     return gpg_error (GPG_ERR_INV_SEXP);
879
880   /* Remove a possible prepended zero byte. */
881   if (!*s && n > 1)
882     {
883       n -= 1;
884       s += 1;
885     }
886
887   if (*len < (unsigned int) n)
888     return gpg_error (GPG_ERR_INV_LENGTH);
889
890   *len = (unsigned int) n;
891   memcpy (result, s, n);
892   s += n;
893
894   depth = 3;
895   err = sskip (&s, &depth);
896   if (err)
897     return err;
898   if (s - sig->data != sig->len || depth != 0)
899     return gpg_error (GPG_ERR_INV_SEXP);
900
901   return 0;
902 }
903
904 /* Decodes the hash DATA of size LEN (if necessary).  Returns a
905    pointer to the raw hash data in R_DATA, the size in R_LEN, and the
906    name of the hash function in R_HASH.
907
908    Prior to TLSv1.2, the hash function was the concatenation of MD5
909    and SHA1 applied to the data respectively, and no encoding was
910    applied.  From TLSv1.2 on, the hash value is prefixed with an hash
911    identifier and encoded using ASN1.
912
913    FIXME: Reference.  */
914 static gpg_error_t
915 decode_hash (const unsigned char *data, int len,
916              const unsigned char **r_data, size_t *r_len,
917              const char **r_hash)
918 {
919   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
920     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
921       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
922   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
923     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
924       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
925   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
926     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
927       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
928       0x1C  };
929   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
930     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
931       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
932       0x00, 0x04, 0x20  };
933   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
934     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
935       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
936       0x00, 0x04, 0x30  };
937   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
938     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
939       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
940       0x00, 0x04, 0x40  };
941
942 #define HANDLE(hash,hashlen)                                            \
943   if (len == sizeof hash ## _prefix + (hashlen)                         \
944       && !memcmp (data, hash ## _prefix, sizeof hash ## _prefix))       \
945     {                                                                   \
946       *r_data = data + sizeof hash ## _prefix;                          \
947       *r_len = hashlen;                                                 \
948       *r_hash = #hash;                                                  \
949     }
950
951   if (len == 36)
952     {
953       /* Prior to TLSv1.2, a combination of MD5 and SHA1 was used.  */
954       *r_data = data;
955       *r_len = 36;
956       *r_hash = "tls-md5sha1";
957     }
958       /* TLSv1.2 encodes the hash value using ASN1.  */
959   else HANDLE (sha1,   20)
960   else HANDLE (rmd160, 20)
961   else HANDLE (sha224, 28)
962   else HANDLE (sha256, 32)
963   else HANDLE (sha384, 48)
964   else HANDLE (sha512, 64)
965     else
966       return gpg_error (GPG_ERR_INV_ARG);
967
968 #undef HANDLE
969
970   return 0;
971 }
972
973
974 /* Call the agent to sign (DATA,LEN) using the key described by
975  * HEXGRIP.  Stores the signature in SIG_RESULT and its lengtn at
976  * SIG_LEN; SIGLEN must initially point to the allocated size of
977  * SIG_RESULT.  */
978 gpg_error_t
979 scute_agent_sign (const char *hexgrip, unsigned char *data, int len,
980                   unsigned char *sig_result, unsigned int *sig_len)
981 {
982   char cmd[150];
983   gpg_error_t err;
984   const char *hash;
985   const unsigned char *raw_data;
986   size_t raw_len;
987 #define MAX_DATA_LEN    64      /* Size of an SHA512 sum.  */
988   unsigned char pretty_data[2 * MAX_DATA_LEN + 1];
989   int i;
990   struct signature sig;
991
992   sig.len = 0;
993
994   if (sig_len == NULL)
995     return gpg_error (GPG_ERR_INV_ARG);
996
997   err = decode_hash (data, len, &raw_data, &raw_len, &hash);
998   if (err)
999     return err;
1000
1001   if (sig_result == NULL)
1002     {
1003       *sig_len = raw_len;
1004       return 0;
1005     }
1006
1007   if (!hexgrip || !sig_result)
1008     return gpg_error (GPG_ERR_INV_ARG);
1009
1010   snprintf (cmd, sizeof (cmd), "SIGKEY %s", hexgrip);
1011
1012   err = assuan_transact (agent_ctx, cmd, NULL, NULL, default_inq_cb,
1013                          NULL, NULL, NULL);
1014   if (err)
1015     return err;
1016
1017   for (i = 0; i < raw_len; i++)
1018     snprintf (&pretty_data[2 * i], 3, "%02X", raw_data[i]);
1019   pretty_data[2 * raw_len] = '\0';
1020
1021   snprintf (cmd, sizeof (cmd), "SETHASH --hash=%s %s", hash, pretty_data);
1022   err = assuan_transact (agent_ctx, cmd, NULL, NULL, default_inq_cb,
1023                          NULL, NULL, NULL);
1024   if (err)
1025     return err;
1026
1027   err = assuan_transact (agent_ctx, "PKSIGN",
1028                          pksign_cb, &sig, default_inq_cb, NULL, NULL, NULL);
1029   if (err)
1030     return err;
1031
1032   err = pksign_parse_result (&sig, sig_result, sig_len);
1033   return err;
1034 }
1035
1036
1037 /* Determine if FPR is trusted.  */
1038 gpg_error_t
1039 scute_agent_is_trusted (char *fpr, bool *is_trusted)
1040 {
1041   gpg_error_t err;
1042   bool trusted = false;
1043   char cmd[150];
1044
1045   snprintf (cmd, sizeof (cmd), "ISTRUSTED %s", fpr);
1046   err = assuan_transact (agent_ctx, cmd, NULL, NULL, default_inq_cb,
1047                          NULL, NULL, NULL);
1048   if (err && gpg_err_code (err) != GPG_ERR_NOT_TRUSTED)
1049     return err;
1050   else if (!err)
1051     trusted = true;
1052
1053   *is_trusted = trusted;
1054   return 0;
1055 }
1056
1057 \f
1058 #define GET_CERT_INIT_SIZE 2048
1059
1060 struct get_cert_s
1061 {
1062   unsigned char *cert_der;
1063   int cert_der_len;
1064   int cert_der_size;
1065 };
1066
1067
1068 gpg_error_t
1069 get_cert_data_cb (void *opaque, const void *data, size_t data_len)
1070 {
1071   struct get_cert_s *cert_s = opaque;
1072   int needed_size;
1073
1074   needed_size = cert_s->cert_der_len + data_len;
1075   if (needed_size > cert_s->cert_der_size)
1076     {
1077       unsigned char *new_cert_der;
1078       int new_cert_der_size = cert_s->cert_der_size;
1079
1080       if (new_cert_der_size == 0)
1081         new_cert_der_size = GET_CERT_INIT_SIZE;
1082       while (new_cert_der_size < needed_size)
1083         new_cert_der_size *= 2;
1084
1085       if (cert_s->cert_der == NULL)
1086         new_cert_der = malloc (new_cert_der_size);
1087       else
1088         new_cert_der = realloc (cert_s->cert_der, new_cert_der_size);
1089
1090       if (new_cert_der == NULL)
1091         return gpg_error_from_syserror ();
1092
1093       cert_s->cert_der = new_cert_der;
1094       cert_s->cert_der_size = new_cert_der_size;
1095     }
1096
1097   memcpy (cert_s->cert_der + cert_s->cert_der_len, data, data_len);
1098   cert_s->cert_der_len += data_len;
1099
1100   return 0;
1101 }
1102
1103
1104 /* Try to get certificate for CERTREF.  */
1105 gpg_error_t
1106 scute_agent_get_cert (const char *certref, struct cert *cert)
1107 {
1108   gpg_error_t err;
1109   char cmd[150];
1110   struct get_cert_s cert_s;
1111
1112   cert_s.cert_der = NULL;
1113   cert_s.cert_der_len = 0;
1114   cert_s.cert_der_size = 0;
1115
1116   snprintf (cmd, sizeof (cmd), "SCD READCERT %s", certref);
1117   err = assuan_transact (agent_ctx, cmd, get_cert_data_cb, &cert_s,
1118                          NULL, NULL, NULL, NULL);
1119   /* Just to be safe... */
1120   if (!err && (cert_s.cert_der_len <= 16 || cert_s.cert_der[0] != 0x30))
1121     {
1122       DEBUG (DBG_INFO, "bad card certificate rejected");
1123       err = gpg_error (GPG_ERR_BAD_CERT);
1124     }
1125   if (err)
1126     {
1127       if (cert_s.cert_der)
1128         free (cert_s.cert_der);
1129       return err;
1130     }
1131
1132   DEBUG (DBG_INFO, "got certificate from card with length %i",
1133          cert_s.cert_der_len);
1134
1135   cert->cert_der = cert_s.cert_der;
1136   cert->cert_der_len = cert_s.cert_der_len;
1137   strncpy (cert->certref, certref, sizeof cert->certref -1);
1138   cert->certref[sizeof cert->certref - 1] = 0;
1139
1140   return 0;
1141 }
1142
1143 struct random_request
1144 {
1145     unsigned char *buffer;
1146     size_t len;
1147 };
1148
1149 gpg_error_t
1150 get_challenge_data_cb (void *opaque, const void *line, size_t len)
1151 {
1152   struct random_request *request = opaque;
1153
1154   if (len != request->len)
1155     return gpg_error (GPG_ERR_INV_LENGTH);
1156
1157   memcpy (request->buffer, line, len);
1158
1159   return 0;
1160 }
1161
1162 gpg_error_t
1163 scute_agent_get_random (unsigned char *data, size_t len)
1164 {
1165     char command[16];
1166     gpg_error_t err;
1167     struct random_request request;
1168
1169     snprintf (command, sizeof(command), "SCD RANDOM %zu", len);
1170
1171     request.buffer = data;
1172     request.len = len;
1173     err = assuan_transact (agent_ctx, command, get_challenge_data_cb,
1174                            &request, NULL, NULL, NULL, NULL);
1175
1176     return err;
1177 }
1178
1179 \f
1180 void
1181 scute_agent_finalize (void)
1182 {
1183   if (!agent_ctx)
1184     {
1185       DEBUG (DBG_CRIT, "no GPG Agent connection established");
1186       return;
1187     }
1188
1189   DEBUG (DBG_INFO, "releasing agent context");
1190   assuan_release (agent_ctx);
1191   agent_ctx = NULL;
1192 }