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