agent: Fix segv running in --server mode
[gnupg.git] / agent / command.c
1 /* command.c - gpg-agent command handler
2  * Copyright (C) 2001-2011 Free Software Foundation, Inc.
3  * Copyright (C) 2001-2013 Werner Koch
4  * Copyright (C) 2015 g10 Code GmbH.
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  */
21
22 /* FIXME: we should not use the default assuan buffering but setup
23    some buffering in secure mempory to protect session keys etc. */
24
25 #include <config.h>
26
27 #include <errno.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <ctype.h>
32 #include <unistd.h>
33 #include <assert.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <dirent.h>
37
38 #include "agent.h"
39 #include <assuan.h>
40 #include "../common/i18n.h"
41 #include "cvt-openpgp.h"
42 #include "../common/ssh-utils.h"
43 #include "../common/asshelp.h"
44 #include "../common/server-help.h"
45
46
47 /* Maximum allowed size of the inquired ciphertext.  */
48 #define MAXLEN_CIPHERTEXT 4096
49 /* Maximum allowed size of the key parameters.  */
50 #define MAXLEN_KEYPARAM 1024
51 /* Maximum allowed size of key data as used in inquiries (bytes). */
52 #define MAXLEN_KEYDATA 8192
53 /* The size of the import/export KEK key (in bytes).  */
54 #define KEYWRAP_KEYSIZE (128/8)
55
56 /* A shortcut to call assuan_set_error using an gpg_err_code_t and a
57    text string.  */
58 #define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
59
60 /* Check that the maximum digest length we support has at least the
61    length of the keygrip.  */
62 #if MAX_DIGEST_LEN < 20
63 #error MAX_DIGEST_LEN shorter than keygrip
64 #endif
65
66 /* Data used to associate an Assuan context with local server data.
67    This is this modules local part of the server_control_s struct.  */
68 struct server_local_s
69 {
70   /* Our Assuan context.  */
71   assuan_context_t assuan_ctx;
72
73   /* If this flag is true, the passphrase cache is used for signing
74      operations.  It defaults to true but may be set on a per
75      connection base.  The global option opt.ignore_cache_for_signing
76      takes precedence over this flag.  */
77   unsigned int use_cache_for_signing : 1;
78
79   /* Flag to suppress I/O logging during a command.  */
80   unsigned int pause_io_logging : 1;
81
82   /* Flag indicating that the connection is from ourselves.  */
83   unsigned int connect_from_self : 1;
84
85   /* Helper flag for io_monitor to allow suppressing of our own
86    * greeting in some cases.  See io_monitor for details.  */
87   unsigned int greeting_seen : 1;
88
89   /* If this flag is set to true the agent will be terminated after
90      the end of the current session.  */
91   unsigned int stopme : 1;
92
93   /* Flag indicating whether pinentry notifications shall be done. */
94   unsigned int allow_pinentry_notify : 1;
95
96   /* An allocated description for the next key operation.  This is
97      used if a pinnetry needs to be popped up.  */
98   char *keydesc;
99
100   /* Malloced KEK (Key-Encryption-Key) for the import_key command.  */
101   void *import_key;
102
103   /* Malloced KEK for the export_key command.  */
104   void *export_key;
105
106   /* Client is aware of the error code GPG_ERR_FULLY_CANCELED.  */
107   int allow_fully_canceled;
108
109   /* Last CACHE_NONCE sent as status (malloced).  */
110   char *last_cache_nonce;
111
112   /* Last PASSWD_NONCE sent as status (malloced). */
113   char *last_passwd_nonce;
114 };
115
116
117 /* An entry for the getval/putval commands. */
118 struct putval_item_s
119 {
120   struct putval_item_s *next;
121   size_t off;  /* Offset to the value into DATA.  */
122   size_t len;  /* Length of the value.  */
123   char d[1];   /* Key | Nul | value.  */
124 };
125
126
127 /* A list of key value pairs fpr the getval/putval commands.  */
128 static struct putval_item_s *putval_list;
129
130
131 \f
132 /* To help polling clients, we keep track of the number of certain
133    events.  This structure keeps those counters.  The counters are
134    integers and there should be no problem if they are overflowing as
135    callers need to check only whether a counter changed.  The actual
136    values are not meaningful. */
137 struct
138 {
139   /* Incremented if any of the other counters below changed. */
140   unsigned int any;
141
142   /* Incremented if a key is added or removed from the internal privat
143      key database. */
144   unsigned int key;
145
146   /* Incremented if a change of the card readers stati has been
147      detected. */
148   unsigned int card;
149
150 } eventcounter;
151
152
153 \f
154 /*  Local prototypes.  */
155 static int command_has_option (const char *cmd, const char *cmdopt);
156
157
158
159 \f
160 /* Release the memory buffer MB but first wipe out the used memory. */
161 static void
162 clear_outbuf (membuf_t *mb)
163 {
164   void *p;
165   size_t n;
166
167   p = get_membuf (mb, &n);
168   if (p)
169     {
170       wipememory (p, n);
171       xfree (p);
172     }
173 }
174
175
176 /* Write the content of memory buffer MB as assuan data to CTX and
177    wipe the buffer out afterwards. */
178 static gpg_error_t
179 write_and_clear_outbuf (assuan_context_t ctx, membuf_t *mb)
180 {
181   gpg_error_t ae;
182   void *p;
183   size_t n;
184
185   p = get_membuf (mb, &n);
186   if (!p)
187     return out_of_core ();
188   ae = assuan_send_data (ctx, p, n);
189   memset (p, 0, n);
190   xfree (p);
191   return ae;
192 }
193
194
195 /* Clear the nonces used to enable the passphrase cache for certain
196    multi-command command sequences.  */
197 static void
198 clear_nonce_cache (ctrl_t ctrl)
199 {
200   if (ctrl->server_local->last_cache_nonce)
201     {
202       agent_put_cache (ctrl, ctrl->server_local->last_cache_nonce,
203                        CACHE_MODE_NONCE, NULL, 0);
204       xfree (ctrl->server_local->last_cache_nonce);
205       ctrl->server_local->last_cache_nonce = NULL;
206     }
207   if (ctrl->server_local->last_passwd_nonce)
208     {
209       agent_put_cache (ctrl, ctrl->server_local->last_passwd_nonce,
210                        CACHE_MODE_NONCE, NULL, 0);
211       xfree (ctrl->server_local->last_passwd_nonce);
212       ctrl->server_local->last_passwd_nonce = NULL;
213     }
214 }
215
216
217 /* This function is called by Libassuan whenever the client sends a
218    reset.  It has been registered similar to the other Assuan
219    commands.  */
220 static gpg_error_t
221 reset_notify (assuan_context_t ctx, char *line)
222 {
223   ctrl_t ctrl = assuan_get_pointer (ctx);
224
225   (void) line;
226
227   memset (ctrl->keygrip, 0, 20);
228   ctrl->have_keygrip = 0;
229   ctrl->digest.valuelen = 0;
230
231   xfree (ctrl->server_local->keydesc);
232   ctrl->server_local->keydesc = NULL;
233
234   clear_nonce_cache (ctrl);
235
236   return 0;
237 }
238
239
240 /* Replace all '+' by a blank in the string S. */
241 static void
242 plus_to_blank (char *s)
243 {
244   for (; *s; s++)
245     {
246       if (*s == '+')
247         *s = ' ';
248     }
249 }
250
251
252 /* Parse a hex string.  Return an Assuan error code or 0 on success and the
253    length of the parsed string in LEN. */
254 static int
255 parse_hexstring (assuan_context_t ctx, const char *string, size_t *len)
256 {
257   const char *p;
258   size_t n;
259
260   /* parse the hash value */
261   for (p=string, n=0; hexdigitp (p); p++, n++)
262     ;
263   if (*p != ' ' && *p != '\t' && *p)
264     return set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
265   if ((n&1))
266     return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
267   *len = n;
268   return 0;
269 }
270
271
272 /* Parse the keygrip in STRING into the provided buffer BUF.  BUF must
273    provide space for 20 bytes.  BUF is not changed if the function
274    returns an error. */
275 static int
276 parse_keygrip (assuan_context_t ctx, const char *string, unsigned char *buf)
277 {
278   int rc;
279   size_t n = 0;
280
281   rc = parse_hexstring (ctx, string, &n);
282   if (rc)
283     return rc;
284   n /= 2;
285   if (n != 20)
286     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of keygrip");
287
288   if (hex2bin (string, buf, 20) < 0)
289     return set_error (GPG_ERR_BUG, "hex2bin");
290
291   return 0;
292 }
293
294
295 /* Write an Assuan status line.  KEYWORD is the first item on the
296  * status line.  The following arguments are all separated by a space
297  * in the output.  The last argument must be a NULL.  Linefeeds and
298  * carriage returns characters (which are not allowed in an Assuan
299  * status line) are silently quoted in C-style.  */
300 gpg_error_t
301 agent_write_status (ctrl_t ctrl, const char *keyword, ...)
302 {
303   gpg_error_t err;
304   va_list arg_ptr;
305   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
306
307   va_start (arg_ptr, keyword);
308   err = vprint_assuan_status_strings (ctx, keyword, arg_ptr);
309   va_end (arg_ptr);
310   return err;
311 }
312
313
314 /* This function is similar to print_assuan_status but takes a CTRL
315    arg instead of an assuan context as first argument.  */
316 gpg_error_t
317 agent_print_status (ctrl_t ctrl, const char *keyword, const char *format, ...)
318 {
319   gpg_error_t err;
320   va_list arg_ptr;
321   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
322
323   va_start (arg_ptr, format);
324   err = vprint_assuan_status (ctx, keyword, format, arg_ptr);
325   va_end (arg_ptr);
326   return err;
327 }
328
329
330 /* Helper to notify the client about a launched Pinentry.  Because
331    that might disturb some older clients, this is only done if enabled
332    via an option.  Returns an gpg error code. */
333 gpg_error_t
334 agent_inq_pinentry_launched (ctrl_t ctrl, unsigned long pid, const char *extra)
335 {
336   char line[256];
337
338   if (!ctrl || !ctrl->server_local
339       || !ctrl->server_local->allow_pinentry_notify)
340     return 0;
341   snprintf (line, DIM(line), "PINENTRY_LAUNCHED %lu%s%s",
342             pid, extra?" ":"", extra? extra:"");
343   return assuan_inquire (ctrl->server_local->assuan_ctx, line, NULL, NULL, 0);
344 }
345
346
347 /* An agent progress callback for Libgcrypt.  This has been registered
348  * to be called via the progress dispatcher mechanism from
349  * gpg-agent.c  */
350 static void
351 progress_cb (ctrl_t ctrl, const char *what, int printchar,
352              int current, int total)
353 {
354   if (!ctrl || !ctrl->server_local || !ctrl->server_local->assuan_ctx)
355     ;
356   else if (printchar == '\n' && what && !strcmp (what, "primegen"))
357     agent_print_status (ctrl, "PROGRESS", "%.20s X 100 100", what);
358   else
359     agent_print_status (ctrl, "PROGRESS", "%.20s %c %d %d",
360                         what, printchar=='\n'?'X':printchar, current, total);
361 }
362
363
364 /* Helper to print a message while leaving a command.  Note that this
365  * function does not call assuan_set_error; the caller may do this
366  * prior to calling us.  */
367 static gpg_error_t
368 leave_cmd (assuan_context_t ctx, gpg_error_t err)
369 {
370   if (err)
371     {
372       const char *name = assuan_get_command_name (ctx);
373       if (!name)
374         name = "?";
375
376       /* Not all users of gpg-agent know about the fully canceled
377          error code; map it back if needed.  */
378       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
379         {
380           ctrl_t ctrl = assuan_get_pointer (ctx);
381
382           if (!ctrl->server_local->allow_fully_canceled)
383             err = gpg_err_make (gpg_err_source (err), GPG_ERR_CANCELED);
384         }
385
386       /* Most code from common/ does not know the error source, thus
387          we fix this here.  */
388       if (gpg_err_source (err) == GPG_ERR_SOURCE_UNKNOWN)
389         err = gpg_err_make (GPG_ERR_SOURCE_DEFAULT, gpg_err_code (err));
390
391       if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
392         log_error ("command '%s' failed: %s\n", name,
393                    gpg_strerror (err));
394       else
395         log_error ("command '%s' failed: %s <%s>\n", name,
396                    gpg_strerror (err), gpg_strsource (err));
397     }
398   return err;
399 }
400
401
402 \f
403 static const char hlp_geteventcounter[] =
404   "GETEVENTCOUNTER\n"
405   "\n"
406   "Return a status line named EVENTCOUNTER with the current values\n"
407   "of all event counters.  The values are decimal numbers in the range\n"
408   "0 to UINT_MAX and wrapping around to 0.  The actual values should\n"
409   "not be relied upon, they shall only be used to detect a change.\n"
410   "\n"
411   "The currently defined counters are:\n"
412   "\n"
413   "ANY  - Incremented with any change of any of the other counters.\n"
414   "KEY  - Incremented for added or removed private keys.\n"
415   "CARD - Incremented for changes of the card readers stati.";
416 static gpg_error_t
417 cmd_geteventcounter (assuan_context_t ctx, char *line)
418 {
419   ctrl_t ctrl = assuan_get_pointer (ctx);
420
421   (void)line;
422
423   if (ctrl->restricted)
424     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
425
426   return agent_print_status (ctrl, "EVENTCOUNTER", "%u %u %u",
427                              eventcounter.any,
428                              eventcounter.key,
429                              eventcounter.card);
430 }
431
432
433 /* This function should be called once for all key removals or
434    additions.  This function is assured not to do any context
435    switches. */
436 void
437 bump_key_eventcounter (void)
438 {
439   eventcounter.key++;
440   eventcounter.any++;
441 }
442
443
444 /* This function should be called for all card reader status
445    changes.  This function is assured not to do any context
446    switches. */
447 void
448 bump_card_eventcounter (void)
449 {
450   eventcounter.card++;
451   eventcounter.any++;
452 }
453
454
455
456 \f
457 static const char hlp_istrusted[] =
458   "ISTRUSTED <hexstring_with_fingerprint>\n"
459   "\n"
460   "Return OK when we have an entry with this fingerprint in our\n"
461   "trustlist";
462 static gpg_error_t
463 cmd_istrusted (assuan_context_t ctx, char *line)
464 {
465   ctrl_t ctrl = assuan_get_pointer (ctx);
466   int rc, n, i;
467   char *p;
468   char fpr[41];
469
470   /* Parse the fingerprint value. */
471   for (p=line,n=0; hexdigitp (p); p++, n++)
472     ;
473   if (*p || !(n == 40 || n == 32))
474     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
475   i = 0;
476   if (n==32)
477     {
478       strcpy (fpr, "00000000");
479       i += 8;
480     }
481   for (p=line; i < 40; p++, i++)
482     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
483   fpr[i] = 0;
484   rc = agent_istrusted (ctrl, fpr, NULL);
485   if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
486     return rc;
487   else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF )
488     return gpg_error (GPG_ERR_NOT_TRUSTED);
489   else
490     return leave_cmd (ctx, rc);
491 }
492
493
494 static const char hlp_listtrusted[] =
495   "LISTTRUSTED\n"
496   "\n"
497   "List all entries from the trustlist.";
498 static gpg_error_t
499 cmd_listtrusted (assuan_context_t ctx, char *line)
500 {
501   ctrl_t ctrl = assuan_get_pointer (ctx);
502   int rc;
503
504   (void)line;
505
506   if (ctrl->restricted)
507     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
508
509   rc = agent_listtrusted (ctx);
510   return leave_cmd (ctx, rc);
511 }
512
513
514 static const char hlp_martrusted[] =
515   "MARKTRUSTED <hexstring_with_fingerprint> <flag> <display_name>\n"
516   "\n"
517   "Store a new key in into the trustlist.";
518 static gpg_error_t
519 cmd_marktrusted (assuan_context_t ctx, char *line)
520 {
521   ctrl_t ctrl = assuan_get_pointer (ctx);
522   int rc, n, i;
523   char *p;
524   char fpr[41];
525   int flag;
526
527   if (ctrl->restricted)
528     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
529
530   /* parse the fingerprint value */
531   for (p=line,n=0; hexdigitp (p); p++, n++)
532     ;
533   if (!spacep (p) || !(n == 40 || n == 32))
534     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
535   i = 0;
536   if (n==32)
537     {
538       strcpy (fpr, "00000000");
539       i += 8;
540     }
541   for (p=line; i < 40; p++, i++)
542     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
543   fpr[i] = 0;
544
545   while (spacep (p))
546     p++;
547   flag = *p++;
548   if ( (flag != 'S' && flag != 'P') || !spacep (p) )
549     return set_error (GPG_ERR_ASS_PARAMETER, "invalid flag - must be P or S");
550   while (spacep (p))
551     p++;
552
553   rc = agent_marktrusted (ctrl, p, fpr, flag);
554   return leave_cmd (ctx, rc);
555 }
556
557
558
559 \f
560 static const char hlp_havekey[] =
561   "HAVEKEY <hexstrings_with_keygrips>\n"
562   "\n"
563   "Return success if at least one of the secret keys with the given\n"
564   "keygrips is available.";
565 static gpg_error_t
566 cmd_havekey (assuan_context_t ctx, char *line)
567 {
568   gpg_error_t err;
569   unsigned char buf[20];
570
571   do
572     {
573       err = parse_keygrip (ctx, line, buf);
574       if (err)
575         return err;
576
577       if (!agent_key_available (buf))
578         return 0; /* Found.  */
579
580       while (*line && *line != ' ' && *line != '\t')
581         line++;
582       while (*line == ' ' || *line == '\t')
583         line++;
584     }
585   while (*line);
586
587   /* No leave_cmd() here because errors are expected and would clutter
588      the log.  */
589   return gpg_error (GPG_ERR_NO_SECKEY);
590 }
591
592
593 static const char hlp_sigkey[] =
594   "SIGKEY <hexstring_with_keygrip>\n"
595   "SETKEY <hexstring_with_keygrip>\n"
596   "\n"
597   "Set the  key used for a sign or decrypt operation.";
598 static gpg_error_t
599 cmd_sigkey (assuan_context_t ctx, char *line)
600 {
601   int rc;
602   ctrl_t ctrl = assuan_get_pointer (ctx);
603
604   rc = parse_keygrip (ctx, line, ctrl->keygrip);
605   if (rc)
606     return rc;
607   ctrl->have_keygrip = 1;
608   return 0;
609 }
610
611
612 static const char hlp_setkeydesc[] =
613   "SETKEYDESC plus_percent_escaped_string\n"
614   "\n"
615   "Set a description to be used for the next PKSIGN, PKDECRYPT, IMPORT_KEY\n"
616   "or EXPORT_KEY operation if this operation requires a passphrase.  If\n"
617   "this command is not used a default text will be used.  Note, that\n"
618   "this description implictly selects the label used for the entry\n"
619   "box; if the string contains the string PIN (which in general will\n"
620   "not be translated), \"PIN\" is used, otherwise the translation of\n"
621   "\"passphrase\" is used.  The description string should not contain\n"
622   "blanks unless they are percent or '+' escaped.\n"
623   "\n"
624   "The description is only valid for the next PKSIGN, PKDECRYPT,\n"
625   "IMPORT_KEY, EXPORT_KEY, or DELETE_KEY operation.";
626 static gpg_error_t
627 cmd_setkeydesc (assuan_context_t ctx, char *line)
628 {
629   ctrl_t ctrl = assuan_get_pointer (ctx);
630   char *desc, *p;
631
632   for (p=line; *p == ' '; p++)
633     ;
634   desc = p;
635   p = strchr (desc, ' ');
636   if (p)
637     *p = 0; /* We ignore any garbage; we might late use it for other args. */
638
639   if (!*desc)
640     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
641
642   /* Note, that we only need to replace the + characters and should
643      leave the other escaping in place because the escaped string is
644      send verbatim to the pinentry which does the unescaping (but not
645      the + replacing) */
646   plus_to_blank (desc);
647
648   xfree (ctrl->server_local->keydesc);
649
650   if (ctrl->restricted)
651     {
652       ctrl->server_local->keydesc = strconcat
653         ((ctrl->restricted == 2
654          ? _("Note: Request from the web browser.")
655          : _("Note: Request from a remote site.")  ), "%0A%0A", desc, NULL);
656     }
657   else
658     ctrl->server_local->keydesc = xtrystrdup (desc);
659   if (!ctrl->server_local->keydesc)
660     return out_of_core ();
661   return 0;
662 }
663
664
665 static const char hlp_sethash[] =
666   "SETHASH (--hash=<name>)|(<algonumber>) <hexstring>\n"
667   "\n"
668   "The client can use this command to tell the server about the data\n"
669   "(which usually is a hash) to be signed.";
670 static gpg_error_t
671 cmd_sethash (assuan_context_t ctx, char *line)
672 {
673   int rc;
674   size_t n;
675   char *p;
676   ctrl_t ctrl = assuan_get_pointer (ctx);
677   unsigned char *buf;
678   char *endp;
679   int algo;
680
681   /* Parse the alternative hash options which may be used instead of
682      the algo number.  */
683   if (has_option_name (line, "--hash"))
684     {
685       if (has_option (line, "--hash=sha1"))
686         algo = GCRY_MD_SHA1;
687       else if (has_option (line, "--hash=sha224"))
688         algo = GCRY_MD_SHA224;
689       else if (has_option (line, "--hash=sha256"))
690         algo = GCRY_MD_SHA256;
691       else if (has_option (line, "--hash=sha384"))
692         algo = GCRY_MD_SHA384;
693       else if (has_option (line, "--hash=sha512"))
694         algo = GCRY_MD_SHA512;
695       else if (has_option (line, "--hash=rmd160"))
696         algo = GCRY_MD_RMD160;
697       else if (has_option (line, "--hash=md5"))
698         algo = GCRY_MD_MD5;
699       else if (has_option (line, "--hash=tls-md5sha1"))
700         algo = MD_USER_TLS_MD5SHA1;
701       else
702         return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
703     }
704   else
705     algo = 0;
706
707   line = skip_options (line);
708
709   if (!algo)
710     {
711       /* No hash option has been given: require an algo number instead  */
712       algo = (int)strtoul (line, &endp, 10);
713       for (line = endp; *line == ' ' || *line == '\t'; line++)
714         ;
715       if (!algo || gcry_md_test_algo (algo))
716         return set_error (GPG_ERR_UNSUPPORTED_ALGORITHM, NULL);
717     }
718   ctrl->digest.algo = algo;
719   ctrl->digest.raw_value = 0;
720
721   /* Parse the hash value. */
722   n = 0;
723   rc = parse_hexstring (ctx, line, &n);
724   if (rc)
725     return rc;
726   n /= 2;
727   if (algo == MD_USER_TLS_MD5SHA1 && n == 36)
728     ;
729   else if (n != 16 && n != 20 && n != 24
730            && n != 28 && n != 32 && n != 48 && n != 64)
731     return set_error (GPG_ERR_ASS_PARAMETER, "unsupported length of hash");
732
733   if (n > MAX_DIGEST_LEN)
734     return set_error (GPG_ERR_ASS_PARAMETER, "hash value to long");
735
736   buf = ctrl->digest.value;
737   ctrl->digest.valuelen = n;
738   for (p=line, n=0; n < ctrl->digest.valuelen; p += 2, n++)
739     buf[n] = xtoi_2 (p);
740   for (; n < ctrl->digest.valuelen; n++)
741     buf[n] = 0;
742   return 0;
743 }
744
745
746 static const char hlp_pksign[] =
747   "PKSIGN [<options>] [<cache_nonce>]\n"
748   "\n"
749   "Perform the actual sign operation.  Neither input nor output are\n"
750   "sensitive to eavesdropping.";
751 static gpg_error_t
752 cmd_pksign (assuan_context_t ctx, char *line)
753 {
754   gpg_error_t err;
755   cache_mode_t cache_mode = CACHE_MODE_NORMAL;
756   ctrl_t ctrl = assuan_get_pointer (ctx);
757   membuf_t outbuf;
758   char *cache_nonce = NULL;
759   char *p;
760
761   line = skip_options (line);
762
763   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
764     ;
765   *p = '\0';
766   if (*line)
767     cache_nonce = xtrystrdup (line);
768
769   if (opt.ignore_cache_for_signing)
770     cache_mode = CACHE_MODE_IGNORE;
771   else if (!ctrl->server_local->use_cache_for_signing)
772     cache_mode = CACHE_MODE_IGNORE;
773
774   init_membuf (&outbuf, 512);
775
776   err = agent_pksign (ctrl, cache_nonce, ctrl->server_local->keydesc,
777                       &outbuf, cache_mode);
778   if (err)
779     clear_outbuf (&outbuf);
780   else
781     err = write_and_clear_outbuf (ctx, &outbuf);
782
783   xfree (cache_nonce);
784   xfree (ctrl->server_local->keydesc);
785   ctrl->server_local->keydesc = NULL;
786   return leave_cmd (ctx, err);
787 }
788
789
790 static const char hlp_pkdecrypt[] =
791   "PKDECRYPT [<options>]\n"
792   "\n"
793   "Perform the actual decrypt operation.  Input is not\n"
794   "sensitive to eavesdropping.";
795 static gpg_error_t
796 cmd_pkdecrypt (assuan_context_t ctx, char *line)
797 {
798   int rc;
799   ctrl_t ctrl = assuan_get_pointer (ctx);
800   unsigned char *value;
801   size_t valuelen;
802   membuf_t outbuf;
803   int padding;
804
805   (void)line;
806
807   /* First inquire the data to decrypt */
808   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_CIPHERTEXT);
809   if (!rc)
810     rc = assuan_inquire (ctx, "CIPHERTEXT",
811                         &value, &valuelen, MAXLEN_CIPHERTEXT);
812   if (rc)
813     return rc;
814
815   init_membuf (&outbuf, 512);
816
817   rc = agent_pkdecrypt (ctrl, ctrl->server_local->keydesc,
818                         value, valuelen, &outbuf, &padding);
819   xfree (value);
820   if (rc)
821     clear_outbuf (&outbuf);
822   else
823     {
824       if (padding != -1)
825         rc = print_assuan_status (ctx, "PADDING", "%d", padding);
826       else
827         rc = 0;
828       if (!rc)
829         rc = write_and_clear_outbuf (ctx, &outbuf);
830     }
831   xfree (ctrl->server_local->keydesc);
832   ctrl->server_local->keydesc = NULL;
833   return leave_cmd (ctx, rc);
834 }
835
836
837 static const char hlp_genkey[] =
838   "GENKEY [--no-protection] [--preset] [--inq-passwd]\n"
839   "       [--passwd-nonce=<s>] [<cache_nonce>]\n"
840   "\n"
841   "Generate a new key, store the secret part and return the public\n"
842   "part.  Here is an example transaction:\n"
843   "\n"
844   "  C: GENKEY\n"
845   "  S: INQUIRE KEYPARAM\n"
846   "  C: D (genkey (rsa (nbits 3072)))\n"
847   "  C: END\n"
848   "  S: D (public-key\n"
849   "  S: D   (rsa (n 326487324683264) (e 10001)))\n"
850   "  S: OK key created\n"
851   "\n"
852   "When the --preset option is used the passphrase for the generated\n"
853   "key will be added to the cache.  When --inq-passwd is used an inquire\n"
854   "with the keyword NEWPASSWD is used to request the passphrase for the\n"
855   "new key.  When a --passwd-nonce is used, the corresponding cached\n"
856   "passphrase is used to protect the new key.";
857 static gpg_error_t
858 cmd_genkey (assuan_context_t ctx, char *line)
859 {
860   ctrl_t ctrl = assuan_get_pointer (ctx);
861   int rc;
862   int no_protection;
863   unsigned char *value;
864   size_t valuelen;
865   unsigned char *newpasswd = NULL;
866   membuf_t outbuf;
867   char *cache_nonce = NULL;
868   char *passwd_nonce = NULL;
869   int opt_preset;
870   int opt_inq_passwd;
871   size_t n;
872   char *p, *pend;
873   int c;
874
875   if (ctrl->restricted)
876     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
877
878   no_protection = has_option (line, "--no-protection");
879   opt_preset = has_option (line, "--preset");
880   opt_inq_passwd = has_option (line, "--inq-passwd");
881   passwd_nonce = option_value (line, "--passwd-nonce");
882   if (passwd_nonce)
883     {
884       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
885         ;
886       c = *pend;
887       *pend = '\0';
888       passwd_nonce = xtrystrdup (passwd_nonce);
889       *pend = c;
890       if (!passwd_nonce)
891         {
892           rc = gpg_error_from_syserror ();
893           goto leave;
894         }
895     }
896   line = skip_options (line);
897
898   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
899     ;
900   *p = '\0';
901   if (*line)
902     cache_nonce = xtrystrdup (line);
903
904   /* First inquire the parameters */
905   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_KEYPARAM);
906   if (!rc)
907     rc = assuan_inquire (ctx, "KEYPARAM", &value, &valuelen, MAXLEN_KEYPARAM);
908   if (rc)
909     return rc;
910
911   init_membuf (&outbuf, 512);
912
913   /* If requested, ask for the password to be used for the key.  If
914      this is not used the regular Pinentry mechanism is used.  */
915   if (opt_inq_passwd && !no_protection)
916     {
917       /* (N is used as a dummy) */
918       assuan_begin_confidential (ctx);
919       rc = assuan_inquire (ctx, "NEWPASSWD", &newpasswd, &n, 256);
920       assuan_end_confidential (ctx);
921       if (rc)
922         goto leave;
923       if (!*newpasswd)
924         {
925           /* Empty password given - switch to no-protection mode.  */
926           xfree (newpasswd);
927           newpasswd = NULL;
928           no_protection = 1;
929         }
930
931     }
932   else if (passwd_nonce)
933     newpasswd = agent_get_cache (ctrl, passwd_nonce, CACHE_MODE_NONCE);
934
935   rc = agent_genkey (ctrl, cache_nonce, (char*)value, valuelen, no_protection,
936                      newpasswd, opt_preset, &outbuf);
937
938  leave:
939   if (newpasswd)
940     {
941       /* Assuan_inquire does not allow us to read into secure memory
942          thus we need to wipe it ourself.  */
943       wipememory (newpasswd, strlen (newpasswd));
944       xfree (newpasswd);
945     }
946   xfree (value);
947   if (rc)
948     clear_outbuf (&outbuf);
949   else
950     rc = write_and_clear_outbuf (ctx, &outbuf);
951   xfree (cache_nonce);
952   xfree (passwd_nonce);
953   return leave_cmd (ctx, rc);
954 }
955
956
957
958 \f
959 static const char hlp_readkey[] =
960   "READKEY <hexstring_with_keygrip>\n"
961   "        --card <keyid>\n"
962   "\n"
963   "Return the public key for the given keygrip or keyid.\n"
964   "With --card, private key file with card information will be created.";
965 static gpg_error_t
966 cmd_readkey (assuan_context_t ctx, char *line)
967 {
968   ctrl_t ctrl = assuan_get_pointer (ctx);
969   int rc;
970   unsigned char grip[20];
971   gcry_sexp_t s_pkey = NULL;
972   unsigned char *pkbuf = NULL;
973   char *serialno = NULL;
974   size_t pkbuflen;
975   const char *opt_card;
976
977   if (ctrl->restricted)
978     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
979
980   opt_card = has_option_name (line, "--card");
981   line = skip_options (line);
982
983   if (opt_card)
984     {
985       const char *keyid = opt_card;
986
987       rc = agent_card_getattr (ctrl, "SERIALNO", &serialno);
988       if (rc)
989         {
990           log_error (_("error getting serial number of card: %s\n"),
991                      gpg_strerror (rc));
992           goto leave;
993         }
994
995       rc = agent_card_readkey (ctrl, keyid, &pkbuf);
996       if (rc)
997         goto leave;
998       pkbuflen = gcry_sexp_canon_len (pkbuf, 0, NULL, NULL);
999       rc = gcry_sexp_sscan (&s_pkey, NULL, (char*)pkbuf, pkbuflen);
1000       if (rc)
1001         goto leave;
1002
1003       if (!gcry_pk_get_keygrip (s_pkey, grip))
1004         {
1005           rc = gcry_pk_testkey (s_pkey);
1006           if (rc == 0)
1007             rc = gpg_error (GPG_ERR_INTERNAL);
1008
1009           goto leave;
1010         }
1011
1012       rc = agent_write_shadow_key (grip, serialno, keyid, pkbuf, 0);
1013       if (rc)
1014         goto leave;
1015
1016       rc = assuan_send_data (ctx, pkbuf, pkbuflen);
1017     }
1018   else
1019     {
1020       rc = parse_keygrip (ctx, line, grip);
1021       if (rc)
1022         goto leave;
1023
1024       rc = agent_public_key_from_file (ctrl, grip, &s_pkey);
1025       if (!rc)
1026         {
1027           pkbuflen = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1028           log_assert (pkbuflen);
1029           pkbuf = xtrymalloc (pkbuflen);
1030           if (!pkbuf)
1031             rc = gpg_error_from_syserror ();
1032           else
1033             {
1034               pkbuflen = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON,
1035                                            pkbuf, pkbuflen);
1036               rc = assuan_send_data (ctx, pkbuf, pkbuflen);
1037             }
1038         }
1039     }
1040
1041  leave:
1042   xfree (serialno);
1043   xfree (pkbuf);
1044   gcry_sexp_release (s_pkey);
1045   return leave_cmd (ctx, rc);
1046 }
1047
1048
1049 \f
1050 static const char hlp_keyinfo[] =
1051   "KEYINFO [--[ssh-]list] [--data] [--ssh-fpr] [--with-ssh] <keygrip>\n"
1052   "\n"
1053   "Return information about the key specified by the KEYGRIP.  If the\n"
1054   "key is not available GPG_ERR_NOT_FOUND is returned.  If the option\n"
1055   "--list is given the keygrip is ignored and information about all\n"
1056   "available keys are returned.  If --ssh-list is given information\n"
1057   "about all keys listed in the sshcontrol are returned.  With --with-ssh\n"
1058   "information from sshcontrol is always added to the info. Unless --data\n"
1059   "is given, the information is returned as a status line using the format:\n"
1060   "\n"
1061   "  KEYINFO <keygrip> <type> <serialno> <idstr> <cached> <protection> <fpr>\n"
1062   "\n"
1063   "KEYGRIP is the keygrip.\n"
1064   "\n"
1065   "TYPE is describes the type of the key:\n"
1066   "    'D' - Regular key stored on disk,\n"
1067   "    'T' - Key is stored on a smartcard (token),\n"
1068   "    'X' - Unknown type,\n"
1069   "    '-' - Key is missing.\n"
1070   "\n"
1071   "SERIALNO is an ASCII string with the serial number of the\n"
1072   "         smartcard.  If the serial number is not known a single\n"
1073   "         dash '-' is used instead.\n"
1074   "\n"
1075   "IDSTR is the IDSTR used to distinguish keys on a smartcard.  If it\n"
1076   "      is not known a dash is used instead.\n"
1077   "\n"
1078   "CACHED is 1 if the passphrase for the key was found in the key cache.\n"
1079   "       If not, a '-' is used instead.\n"
1080   "\n"
1081   "PROTECTION describes the key protection type:\n"
1082   "    'P' - The key is protected with a passphrase,\n"
1083   "    'C' - The key is not protected,\n"
1084   "    '-' - Unknown protection.\n"
1085   "\n"
1086   "FPR returns the formatted ssh-style fingerprint of the key.  It is only\n"
1087   "    printed if the option --ssh-fpr has been used.  It defaults to '-'.\n"
1088   "\n"
1089   "TTL is the TTL in seconds for that key or '-' if n/a.\n"
1090   "\n"
1091   "FLAGS is a word consisting of one-letter flags:\n"
1092   "      'D' - The key has been disabled,\n"
1093   "      'S' - The key is listed in sshcontrol (requires --with-ssh),\n"
1094   "      'c' - Use of the key needs to be confirmed,\n"
1095   "      '-' - No flags given.\n"
1096   "\n"
1097   "More information may be added in the future.";
1098 static gpg_error_t
1099 do_one_keyinfo (ctrl_t ctrl, const unsigned char *grip, assuan_context_t ctx,
1100                 int data, int with_ssh_fpr, int in_ssh,
1101                 int ttl, int disabled, int confirm)
1102 {
1103   gpg_error_t err;
1104   char hexgrip[40+1];
1105   char *fpr = NULL;
1106   int keytype;
1107   unsigned char *shadow_info = NULL;
1108   char *serialno = NULL;
1109   char *idstr = NULL;
1110   const char *keytypestr;
1111   const char *cached;
1112   const char *protectionstr;
1113   char *pw;
1114   int missing_key = 0;
1115   char ttlbuf[20];
1116   char flagsbuf[5];
1117
1118   err = agent_key_info_from_file (ctrl, grip, &keytype, &shadow_info);
1119   if (err)
1120     {
1121       if (in_ssh && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1122         missing_key = 1;
1123       else
1124         goto leave;
1125     }
1126
1127   /* Reformat the grip so that we use uppercase as good style. */
1128   bin2hex (grip, 20, hexgrip);
1129
1130   if (ttl > 0)
1131     snprintf (ttlbuf, sizeof ttlbuf, "%d", ttl);
1132   else
1133     strcpy (ttlbuf, "-");
1134
1135   *flagsbuf = 0;
1136   if (disabled)
1137     strcat (flagsbuf, "D");
1138   if (in_ssh)
1139     strcat (flagsbuf, "S");
1140   if (confirm)
1141     strcat (flagsbuf, "c");
1142   if (!*flagsbuf)
1143     strcpy (flagsbuf, "-");
1144
1145
1146   if (missing_key)
1147     {
1148       protectionstr = "-"; keytypestr = "-";
1149     }
1150   else
1151     {
1152       switch (keytype)
1153         {
1154         case PRIVATE_KEY_CLEAR:
1155         case PRIVATE_KEY_OPENPGP_NONE:
1156           protectionstr = "C"; keytypestr = "D";
1157           break;
1158         case PRIVATE_KEY_PROTECTED: protectionstr = "P"; keytypestr = "D";
1159           break;
1160         case PRIVATE_KEY_SHADOWED: protectionstr = "-"; keytypestr = "T";
1161           break;
1162         default: protectionstr = "-"; keytypestr = "X";
1163           break;
1164         }
1165     }
1166
1167   /* Compute the ssh fingerprint if requested.  */
1168   if (with_ssh_fpr)
1169     {
1170       gcry_sexp_t key;
1171
1172       if (!agent_raw_key_from_file (ctrl, grip, &key))
1173         {
1174           ssh_get_fingerprint_string (key, GCRY_MD_MD5, &fpr);
1175           gcry_sexp_release (key);
1176         }
1177     }
1178
1179   /* Here we have a little race by doing the cache check separately
1180      from the retrieval function.  Given that the cache flag is only a
1181      hint, it should not really matter.  */
1182   pw = agent_get_cache (ctrl, hexgrip, CACHE_MODE_NORMAL);
1183   cached = pw ? "1" : "-";
1184   xfree (pw);
1185
1186   if (shadow_info)
1187     {
1188       err = parse_shadow_info (shadow_info, &serialno, &idstr, NULL);
1189       if (err)
1190         goto leave;
1191     }
1192
1193   if (!data)
1194     err = agent_write_status (ctrl, "KEYINFO",
1195                               hexgrip,
1196                               keytypestr,
1197                               serialno? serialno : "-",
1198                               idstr? idstr : "-",
1199                               cached,
1200                               protectionstr,
1201                               fpr? fpr : "-",
1202                               ttlbuf,
1203                               flagsbuf,
1204                               NULL);
1205   else
1206     {
1207       char *string;
1208
1209       string = xtryasprintf ("%s %s %s %s %s %s %s %s %s\n",
1210                              hexgrip, keytypestr,
1211                              serialno? serialno : "-",
1212                              idstr? idstr : "-", cached, protectionstr,
1213                              fpr? fpr : "-",
1214                              ttlbuf,
1215                              flagsbuf);
1216       if (!string)
1217         err = gpg_error_from_syserror ();
1218       else
1219         err = assuan_send_data (ctx, string, strlen(string));
1220       xfree (string);
1221     }
1222
1223  leave:
1224   xfree (fpr);
1225   xfree (shadow_info);
1226   xfree (serialno);
1227   xfree (idstr);
1228   return err;
1229 }
1230
1231
1232 /* Entry int for the command KEYINFO.  This function handles the
1233    command option processing.  For details see hlp_keyinfo above.  */
1234 static gpg_error_t
1235 cmd_keyinfo (assuan_context_t ctx, char *line)
1236 {
1237   ctrl_t ctrl = assuan_get_pointer (ctx);
1238   int err;
1239   unsigned char grip[20];
1240   DIR *dir = NULL;
1241   int list_mode;
1242   int opt_data, opt_ssh_fpr, opt_with_ssh;
1243   ssh_control_file_t cf = NULL;
1244   char hexgrip[41];
1245   int disabled, ttl, confirm, is_ssh;
1246
1247   if (ctrl->restricted)
1248     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1249
1250   if (has_option (line, "--ssh-list"))
1251     list_mode = 2;
1252   else
1253     list_mode = has_option (line, "--list");
1254   opt_data = has_option (line, "--data");
1255   opt_ssh_fpr = has_option (line, "--ssh-fpr");
1256   opt_with_ssh = has_option (line, "--with-ssh");
1257   line = skip_options (line);
1258
1259   if (opt_with_ssh || list_mode == 2)
1260     cf = ssh_open_control_file ();
1261
1262   if (list_mode == 2)
1263     {
1264       if (cf)
1265         {
1266           while (!ssh_read_control_file (cf, hexgrip,
1267                                          &disabled, &ttl, &confirm))
1268             {
1269               if (hex2bin (hexgrip, grip, 20) < 0 )
1270                 continue; /* Bad hex string.  */
1271               err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, 1,
1272                                     ttl, disabled, confirm);
1273               if (err)
1274                 goto leave;
1275             }
1276         }
1277       err = 0;
1278     }
1279   else if (list_mode)
1280     {
1281       char *dirname;
1282       struct dirent *dir_entry;
1283
1284       dirname = make_filename_try (gnupg_homedir (),
1285                                    GNUPG_PRIVATE_KEYS_DIR, NULL);
1286       if (!dirname)
1287         {
1288           err = gpg_error_from_syserror ();
1289           goto leave;
1290         }
1291       dir = opendir (dirname);
1292       if (!dir)
1293         {
1294           err = gpg_error_from_syserror ();
1295           xfree (dirname);
1296           goto leave;
1297         }
1298       xfree (dirname);
1299
1300       while ( (dir_entry = readdir (dir)) )
1301         {
1302           if (strlen (dir_entry->d_name) != 44
1303               || strcmp (dir_entry->d_name + 40, ".key"))
1304             continue;
1305           strncpy (hexgrip, dir_entry->d_name, 40);
1306           hexgrip[40] = 0;
1307
1308           if ( hex2bin (hexgrip, grip, 20) < 0 )
1309             continue; /* Bad hex string.  */
1310
1311           disabled = ttl = confirm = is_ssh = 0;
1312           if (opt_with_ssh)
1313             {
1314               err = ssh_search_control_file (cf, hexgrip,
1315                                              &disabled, &ttl, &confirm);
1316               if (!err)
1317                 is_ssh = 1;
1318               else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1319                 goto leave;
1320             }
1321
1322           err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1323                                 ttl, disabled, confirm);
1324           if (err)
1325             goto leave;
1326         }
1327       err = 0;
1328     }
1329   else
1330     {
1331       err = parse_keygrip (ctx, line, grip);
1332       if (err)
1333         goto leave;
1334       disabled = ttl = confirm = is_ssh = 0;
1335       if (opt_with_ssh)
1336         {
1337           err = ssh_search_control_file (cf, line,
1338                                          &disabled, &ttl, &confirm);
1339           if (!err)
1340             is_ssh = 1;
1341           else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1342             goto leave;
1343         }
1344
1345       err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1346                             ttl, disabled, confirm);
1347     }
1348
1349  leave:
1350   ssh_close_control_file (cf);
1351   if (dir)
1352     closedir (dir);
1353   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1354     leave_cmd (ctx, err);
1355   return err;
1356 }
1357
1358
1359 \f
1360 /* Helper for cmd_get_passphrase.  */
1361 static int
1362 send_back_passphrase (assuan_context_t ctx, int via_data, const char *pw)
1363 {
1364   size_t n;
1365   int rc;
1366
1367   assuan_begin_confidential (ctx);
1368   n = strlen (pw);
1369   if (via_data)
1370     rc = assuan_send_data (ctx, pw, n);
1371   else
1372     {
1373       char *p = xtrymalloc_secure (n*2+1);
1374       if (!p)
1375         rc = gpg_error_from_syserror ();
1376       else
1377         {
1378           bin2hex (pw, n, p);
1379           rc = assuan_set_okay_line (ctx, p);
1380           xfree (p);
1381         }
1382     }
1383   return rc;
1384 }
1385
1386
1387 static const char hlp_get_passphrase[] =
1388   "GET_PASSPHRASE [--data] [--check] [--no-ask] [--repeat[=N]]\n"
1389   "               [--qualitybar] <cache_id>\n"
1390   "               [<error_message> <prompt> <description>]\n"
1391   "\n"
1392   "This function is usually used to ask for a passphrase to be used\n"
1393   "for conventional encryption, but may also be used by programs which\n"
1394   "need specal handling of passphrases.  This command uses a syntax\n"
1395   "which helps clients to use the agent with minimum effort.  The\n"
1396   "agent either returns with an error or with a OK followed by the hex\n"
1397   "encoded passphrase.  Note that the length of the strings is\n"
1398   "implicitly limited by the maximum length of a command.\n"
1399   "\n"
1400   "If the option \"--data\" is used the passphrase is returned by usual\n"
1401   "data lines and not on the okay line.\n"
1402   "\n"
1403   "If the option \"--check\" is used the passphrase constraints checks as\n"
1404   "implemented by gpg-agent are applied.  A check is not done if the\n"
1405   "passphrase has been found in the cache.\n"
1406   "\n"
1407   "If the option \"--no-ask\" is used and the passphrase is not in the\n"
1408   "cache the user will not be asked to enter a passphrase but the error\n"
1409   "code GPG_ERR_NO_DATA is returned.  \n"
1410   "\n"
1411   "If the option \"--qualitybar\" is used a visual indication of the\n"
1412   "entered passphrase quality is shown.  (Unless no minimum passphrase\n"
1413   "length has been configured.)";
1414 static gpg_error_t
1415 cmd_get_passphrase (assuan_context_t ctx, char *line)
1416 {
1417   ctrl_t ctrl = assuan_get_pointer (ctx);
1418   int rc;
1419   char *pw;
1420   char *response;
1421   char *cacheid = NULL, *desc = NULL, *prompt = NULL, *errtext = NULL;
1422   const char *desc2 = _("Please re-enter this passphrase");
1423   char *p;
1424   int opt_data, opt_check, opt_no_ask, opt_qualbar;
1425   int opt_repeat = 0;
1426   char *entry_errtext = NULL;
1427
1428   if (ctrl->restricted)
1429     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1430
1431   opt_data = has_option (line, "--data");
1432   opt_check = has_option (line, "--check");
1433   opt_no_ask = has_option (line, "--no-ask");
1434   if (has_option_name (line, "--repeat"))
1435     {
1436       p = option_value (line, "--repeat");
1437       if (p)
1438         opt_repeat = atoi (p);
1439       else
1440         opt_repeat = 1;
1441     }
1442   opt_qualbar = has_option (line, "--qualitybar");
1443   line = skip_options (line);
1444
1445   cacheid = line;
1446   p = strchr (cacheid, ' ');
1447   if (p)
1448     {
1449       *p++ = 0;
1450       while (*p == ' ')
1451         p++;
1452       errtext = p;
1453       p = strchr (errtext, ' ');
1454       if (p)
1455         {
1456           *p++ = 0;
1457           while (*p == ' ')
1458             p++;
1459           prompt = p;
1460           p = strchr (prompt, ' ');
1461           if (p)
1462             {
1463               *p++ = 0;
1464               while (*p == ' ')
1465                 p++;
1466               desc = p;
1467               p = strchr (desc, ' ');
1468               if (p)
1469                 *p = 0; /* Ignore trailing garbage. */
1470             }
1471         }
1472     }
1473   if (!*cacheid || strlen (cacheid) > 50)
1474     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1475   if (!desc)
1476     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1477
1478   if (!strcmp (cacheid, "X"))
1479     cacheid = NULL;
1480   if (!strcmp (errtext, "X"))
1481     errtext = NULL;
1482   if (!strcmp (prompt, "X"))
1483     prompt = NULL;
1484   if (!strcmp (desc, "X"))
1485     desc = NULL;
1486
1487   pw = cacheid ? agent_get_cache (ctrl, cacheid, CACHE_MODE_USER) : NULL;
1488   if (pw)
1489     {
1490       rc = send_back_passphrase (ctx, opt_data, pw);
1491       xfree (pw);
1492     }
1493   else if (opt_no_ask)
1494     rc = gpg_error (GPG_ERR_NO_DATA);
1495   else
1496     {
1497       /* Note, that we only need to replace the + characters and
1498          should leave the other escaping in place because the escaped
1499          string is send verbatim to the pinentry which does the
1500          unescaping (but not the + replacing) */
1501       if (errtext)
1502         plus_to_blank (errtext);
1503       if (prompt)
1504         plus_to_blank (prompt);
1505       if (desc)
1506         plus_to_blank (desc);
1507
1508     next_try:
1509       rc = agent_get_passphrase (ctrl, &response, desc, prompt,
1510                                  entry_errtext? entry_errtext:errtext,
1511                                  opt_qualbar, cacheid, CACHE_MODE_USER);
1512       xfree (entry_errtext);
1513       entry_errtext = NULL;
1514       if (!rc)
1515         {
1516           int i;
1517
1518           if (opt_check
1519               && check_passphrase_constraints (ctrl, response, &entry_errtext))
1520             {
1521               xfree (response);
1522               goto next_try;
1523             }
1524           for (i = 0; i < opt_repeat; i++)
1525             {
1526               char *response2;
1527
1528               if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
1529                 break;
1530
1531               rc = agent_get_passphrase (ctrl, &response2, desc2, prompt,
1532                                          errtext, 0,
1533                                          cacheid, CACHE_MODE_USER);
1534               if (rc)
1535                 break;
1536               if (strcmp (response2, response))
1537                 {
1538                   xfree (response2);
1539                   xfree (response);
1540                   entry_errtext = try_percent_escape
1541                     (_("does not match - try again"), NULL);
1542                   if (!entry_errtext)
1543                     {
1544                       rc = gpg_error_from_syserror ();
1545                       break;
1546                     }
1547                   goto next_try;
1548                 }
1549               xfree (response2);
1550             }
1551           if (!rc)
1552             {
1553               if (cacheid)
1554                 agent_put_cache (ctrl, cacheid, CACHE_MODE_USER, response, 0);
1555               rc = send_back_passphrase (ctx, opt_data, response);
1556             }
1557           xfree (response);
1558         }
1559     }
1560
1561   return leave_cmd (ctx, rc);
1562 }
1563
1564
1565 static const char hlp_clear_passphrase[] =
1566   "CLEAR_PASSPHRASE [--mode=normal] <cache_id>\n"
1567   "\n"
1568   "may be used to invalidate the cache entry for a passphrase.  The\n"
1569   "function returns with OK even when there is no cached passphrase.\n"
1570   "The --mode=normal option is used to clear an entry for a cacheid\n"
1571   "added by the agent.\n";
1572 static gpg_error_t
1573 cmd_clear_passphrase (assuan_context_t ctx, char *line)
1574 {
1575   ctrl_t ctrl = assuan_get_pointer (ctx);
1576   char *cacheid = NULL;
1577   char *p;
1578   int opt_normal;
1579
1580   if (ctrl->restricted)
1581     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1582
1583   opt_normal = has_option (line, "--mode=normal");
1584   line = skip_options (line);
1585
1586   /* parse the stuff */
1587   for (p=line; *p == ' '; p++)
1588     ;
1589   cacheid = p;
1590   p = strchr (cacheid, ' ');
1591   if (p)
1592     *p = 0; /* ignore garbage */
1593   if (!*cacheid || strlen (cacheid) > 50)
1594     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1595
1596   agent_put_cache (ctrl, cacheid,
1597                    opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER,
1598                    NULL, 0);
1599
1600   agent_clear_passphrase (ctrl, cacheid,
1601                           opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER);
1602
1603   return 0;
1604 }
1605
1606
1607 static const char hlp_get_confirmation[] =
1608   "GET_CONFIRMATION <description>\n"
1609   "\n"
1610   "This command may be used to ask for a simple confirmation.\n"
1611   "DESCRIPTION is displayed along with a Okay and Cancel button.  This\n"
1612   "command uses a syntax which helps clients to use the agent with\n"
1613   "minimum effort.  The agent either returns with an error or with a\n"
1614   "OK.  Note, that the length of DESCRIPTION is implicitly limited by\n"
1615   "the maximum length of a command. DESCRIPTION should not contain\n"
1616   "any spaces, those must be encoded either percent escaped or simply\n"
1617   "as '+'.";
1618 static gpg_error_t
1619 cmd_get_confirmation (assuan_context_t ctx, char *line)
1620 {
1621   ctrl_t ctrl = assuan_get_pointer (ctx);
1622   int rc;
1623   char *desc = NULL;
1624   char *p;
1625
1626   if (ctrl->restricted)
1627     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1628
1629   /* parse the stuff */
1630   for (p=line; *p == ' '; p++)
1631     ;
1632   desc = p;
1633   p = strchr (desc, ' ');
1634   if (p)
1635     *p = 0; /* We ignore any garbage -may be later used for other args. */
1636
1637   if (!*desc)
1638     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1639
1640   if (!strcmp (desc, "X"))
1641     desc = NULL;
1642
1643   /* Note, that we only need to replace the + characters and should
1644      leave the other escaping in place because the escaped string is
1645      send verbatim to the pinentry which does the unescaping (but not
1646      the + replacing) */
1647   if (desc)
1648     plus_to_blank (desc);
1649
1650   rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
1651   return leave_cmd (ctx, rc);
1652 }
1653
1654
1655 \f
1656 static const char hlp_learn[] =
1657   "LEARN [--send] [--sendinfo] [--force]\n"
1658   "\n"
1659   "Learn something about the currently inserted smartcard.  With\n"
1660   "--sendinfo information about the card is returned; with --send\n"
1661   "the available certificates are returned as D lines; with --force\n"
1662   "private key storage will be updated by the result.";
1663 static gpg_error_t
1664 cmd_learn (assuan_context_t ctx, char *line)
1665 {
1666   ctrl_t ctrl = assuan_get_pointer (ctx);
1667   gpg_error_t err;
1668   int send, sendinfo, force;
1669
1670   send = has_option (line, "--send");
1671   sendinfo = send? 1 : has_option (line, "--sendinfo");
1672   force = has_option (line, "--force");
1673
1674   if (ctrl->restricted)
1675     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1676
1677   err = agent_handle_learn (ctrl, send, sendinfo? ctx : NULL, force);
1678   return leave_cmd (ctx, err);
1679 }
1680
1681
1682 \f
1683 static const char hlp_passwd[] =
1684   "PASSWD [--cache-nonce=<c>] [--passwd-nonce=<s>] [--preset]\n"
1685   "       [--verify] <hexkeygrip>\n"
1686   "\n"
1687   "Change the passphrase/PIN for the key identified by keygrip in LINE.  If\n"
1688   "--preset is used then the new passphrase will be added to the cache.\n"
1689   "If --verify is used the command asks for the passphrase and verifies\n"
1690   "that the passphrase valid.\n";
1691 static gpg_error_t
1692 cmd_passwd (assuan_context_t ctx, char *line)
1693 {
1694   ctrl_t ctrl = assuan_get_pointer (ctx);
1695   gpg_error_t err;
1696   int c;
1697   char *cache_nonce = NULL;
1698   char *passwd_nonce = NULL;
1699   unsigned char grip[20];
1700   gcry_sexp_t s_skey = NULL;
1701   unsigned char *shadow_info = NULL;
1702   char *passphrase = NULL;
1703   char *pend;
1704   int opt_preset, opt_verify;
1705
1706   if (ctrl->restricted)
1707     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1708
1709   opt_preset = has_option (line, "--preset");
1710   cache_nonce = option_value (line, "--cache-nonce");
1711   opt_verify = has_option (line, "--verify");
1712   if (cache_nonce)
1713     {
1714       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
1715         ;
1716       c = *pend;
1717       *pend = '\0';
1718       cache_nonce = xtrystrdup (cache_nonce);
1719       *pend = c;
1720       if (!cache_nonce)
1721         {
1722           err = gpg_error_from_syserror ();
1723           goto leave;
1724         }
1725     }
1726
1727   passwd_nonce = option_value (line, "--passwd-nonce");
1728   if (passwd_nonce)
1729     {
1730       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
1731         ;
1732       c = *pend;
1733       *pend = '\0';
1734       passwd_nonce = xtrystrdup (passwd_nonce);
1735       *pend = c;
1736       if (!passwd_nonce)
1737         {
1738           err = gpg_error_from_syserror ();
1739           goto leave;
1740         }
1741     }
1742
1743   line = skip_options (line);
1744
1745   err = parse_keygrip (ctx, line, grip);
1746   if (err)
1747     goto leave;
1748
1749   ctrl->in_passwd++;
1750   err = agent_key_from_file (ctrl,
1751                              opt_verify? NULL : cache_nonce,
1752                              ctrl->server_local->keydesc,
1753                              grip, &shadow_info, CACHE_MODE_IGNORE, NULL,
1754                              &s_skey, &passphrase);
1755   if (err)
1756     ;
1757   else if (shadow_info)
1758     {
1759       log_error ("changing a smartcard PIN is not yet supported\n");
1760       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1761     }
1762   else if (opt_verify)
1763     {
1764       /* All done.  */
1765       if (passphrase)
1766         {
1767           if (!passwd_nonce)
1768             {
1769               char buf[12];
1770               gcry_create_nonce (buf, 12);
1771               passwd_nonce = bin2hex (buf, 12, NULL);
1772             }
1773           if (passwd_nonce
1774               && !agent_put_cache (ctrl, passwd_nonce, CACHE_MODE_NONCE,
1775                                    passphrase, CACHE_TTL_NONCE))
1776             {
1777               assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1778               xfree (ctrl->server_local->last_passwd_nonce);
1779               ctrl->server_local->last_passwd_nonce = passwd_nonce;
1780               passwd_nonce = NULL;
1781             }
1782         }
1783     }
1784   else
1785     {
1786       char *newpass = NULL;
1787
1788       if (passwd_nonce)
1789         newpass = agent_get_cache (ctrl, passwd_nonce, CACHE_MODE_NONCE);
1790       err = agent_protect_and_store (ctrl, s_skey, &newpass);
1791       if (!err && passphrase)
1792         {
1793           /* A passphrase existed on the old key and the change was
1794              successful.  Return a nonce for that old passphrase to
1795              let the caller try to unprotect the other subkeys with
1796              the same key.  */
1797           if (!cache_nonce)
1798             {
1799               char buf[12];
1800               gcry_create_nonce (buf, 12);
1801               cache_nonce = bin2hex (buf, 12, NULL);
1802             }
1803           if (cache_nonce
1804               && !agent_put_cache (ctrl, cache_nonce, CACHE_MODE_NONCE,
1805                                    passphrase, CACHE_TTL_NONCE))
1806             {
1807               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
1808               xfree (ctrl->server_local->last_cache_nonce);
1809               ctrl->server_local->last_cache_nonce = cache_nonce;
1810               cache_nonce = NULL;
1811             }
1812           if (newpass)
1813             {
1814               /* If we have a new passphrase (which might be empty) we
1815                  store it under a passwd nonce so that the caller may
1816                  send that nonce again to use it for another key. */
1817               if (!passwd_nonce)
1818                 {
1819                   char buf[12];
1820                   gcry_create_nonce (buf, 12);
1821                   passwd_nonce = bin2hex (buf, 12, NULL);
1822                 }
1823               if (passwd_nonce
1824                   && !agent_put_cache (ctrl, passwd_nonce, CACHE_MODE_NONCE,
1825                                        newpass, CACHE_TTL_NONCE))
1826                 {
1827                   assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1828                   xfree (ctrl->server_local->last_passwd_nonce);
1829                   ctrl->server_local->last_passwd_nonce = passwd_nonce;
1830                   passwd_nonce = NULL;
1831                 }
1832             }
1833         }
1834       if (!err && opt_preset)
1835         {
1836           char hexgrip[40+1];
1837           bin2hex(grip, 20, hexgrip);
1838           err = agent_put_cache (ctrl, hexgrip, CACHE_MODE_ANY, newpass,
1839                                  ctrl->cache_ttl_opt_preset);
1840         }
1841       xfree (newpass);
1842     }
1843   ctrl->in_passwd--;
1844
1845   xfree (ctrl->server_local->keydesc);
1846   ctrl->server_local->keydesc = NULL;
1847
1848  leave:
1849   xfree (passphrase);
1850   gcry_sexp_release (s_skey);
1851   xfree (shadow_info);
1852   xfree (cache_nonce);
1853   xfree (passwd_nonce);
1854   return leave_cmd (ctx, err);
1855 }
1856
1857
1858 static const char hlp_preset_passphrase[] =
1859   "PRESET_PASSPHRASE [--inquire] <string_or_keygrip> <timeout> [<hexstring>]\n"
1860   "\n"
1861   "Set the cached passphrase/PIN for the key identified by the keygrip\n"
1862   "to passwd for the given time, where -1 means infinite and 0 means\n"
1863   "the default (currently only a timeout of -1 is allowed, which means\n"
1864   "to never expire it).  If passwd is not provided, ask for it via the\n"
1865   "pinentry module unless --inquire is passed in which case the passphrase\n"
1866   "is retrieved from the client via a server inquire.\n";
1867 static gpg_error_t
1868 cmd_preset_passphrase (assuan_context_t ctx, char *line)
1869 {
1870   ctrl_t ctrl = assuan_get_pointer (ctx);
1871   int rc;
1872   char *grip_clear = NULL;
1873   unsigned char *passphrase = NULL;
1874   int ttl;
1875   size_t len;
1876   int opt_inquire;
1877
1878   if (ctrl->restricted)
1879     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1880
1881   if (!opt.allow_preset_passphrase)
1882     return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
1883
1884   opt_inquire = has_option (line, "--inquire");
1885   line = skip_options (line);
1886   grip_clear = line;
1887   while (*line && (*line != ' ' && *line != '\t'))
1888     line++;
1889   if (!*line)
1890     return gpg_error (GPG_ERR_MISSING_VALUE);
1891   *line = '\0';
1892   line++;
1893   while (*line && (*line == ' ' || *line == '\t'))
1894     line++;
1895
1896   /* Currently, only infinite timeouts are allowed.  */
1897   ttl = -1;
1898   if (line[0] != '-' || line[1] != '1')
1899     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1900   line++;
1901   line++;
1902   while (!(*line != ' ' && *line != '\t'))
1903     line++;
1904
1905   /* Syntax check the hexstring.  */
1906   len = 0;
1907   rc = parse_hexstring (ctx, line, &len);
1908   if (rc)
1909     return rc;
1910   line[len] = '\0';
1911
1912   /* If there is a passphrase, use it.  Currently, a passphrase is
1913      required.  */
1914   if (*line)
1915     {
1916       if (opt_inquire)
1917         {
1918           rc = set_error (GPG_ERR_ASS_PARAMETER,
1919                           "both --inquire and passphrase specified");
1920           goto leave;
1921         }
1922
1923       /* Do in-place conversion.  */
1924       passphrase = line;
1925       if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
1926         rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
1927     }
1928   else if (opt_inquire)
1929     {
1930       /* Note that the passphrase will be truncated at any null byte and the
1931        * limit is 480 characters. */
1932       size_t maxlen = 480;
1933
1934       rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", maxlen);
1935       if (!rc)
1936         rc = assuan_inquire (ctx, "PASSPHRASE", &passphrase, &len, maxlen);
1937     }
1938   else
1939     rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
1940
1941   if (!rc)
1942     {
1943       rc = agent_put_cache (ctrl, grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1944       if (opt_inquire)
1945         xfree (passphrase);
1946     }
1947
1948 leave:
1949   return leave_cmd (ctx, rc);
1950 }
1951
1952
1953 \f
1954 static const char hlp_scd[] =
1955   "SCD <commands to pass to the scdaemon>\n"
1956   " \n"
1957   "This is a general quote command to redirect everything to the\n"
1958   "SCdaemon.";
1959 static gpg_error_t
1960 cmd_scd (assuan_context_t ctx, char *line)
1961 {
1962   int rc;
1963 #ifdef BUILD_WITH_SCDAEMON
1964   ctrl_t ctrl = assuan_get_pointer (ctx);
1965   if (ctrl->restricted)
1966     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1967
1968   rc = divert_generic_cmd (ctrl, line, ctx);
1969 #else
1970   (void)ctx; (void)line;
1971   rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
1972 #endif
1973   return rc;
1974 }
1975
1976
1977 \f
1978 static const char hlp_keywrap_key[] =
1979   "KEYWRAP_KEY [--clear] <mode>\n"
1980   "\n"
1981   "Return a key to wrap another key.  For now the key is returned\n"
1982   "verbatim and thus makes not much sense because an eavesdropper on\n"
1983   "the gpg-agent connection will see the key as well as the wrapped key.\n"
1984   "However, this function may either be equipped with a public key\n"
1985   "mechanism or not used at all if the key is a pre-shared key.  In any\n"
1986   "case wrapping the import and export of keys is a requirement for\n"
1987   "certain cryptographic validations and thus useful.  The key persists\n"
1988   "until a RESET command but may be cleared using the option --clear.\n"
1989   "\n"
1990   "Supported modes are:\n"
1991   "  --import  - Return a key to import a key into gpg-agent\n"
1992   "  --export  - Return a key to export a key from gpg-agent";
1993 static gpg_error_t
1994 cmd_keywrap_key (assuan_context_t ctx, char *line)
1995 {
1996   ctrl_t ctrl = assuan_get_pointer (ctx);
1997   gpg_error_t err = 0;
1998   int clearopt = has_option (line, "--clear");
1999
2000   if (ctrl->restricted)
2001     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2002
2003   assuan_begin_confidential (ctx);
2004   if (has_option (line, "--import"))
2005     {
2006       xfree (ctrl->server_local->import_key);
2007       if (clearopt)
2008         ctrl->server_local->import_key = NULL;
2009       else if (!(ctrl->server_local->import_key =
2010                  gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
2011         err = gpg_error_from_syserror ();
2012       else
2013         err = assuan_send_data (ctx, ctrl->server_local->import_key,
2014                                 KEYWRAP_KEYSIZE);
2015     }
2016   else if (has_option (line, "--export"))
2017     {
2018       xfree (ctrl->server_local->export_key);
2019       if (clearopt)
2020         ctrl->server_local->export_key = NULL;
2021       else if (!(ctrl->server_local->export_key =
2022             gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
2023         err = gpg_error_from_syserror ();
2024       else
2025         err = assuan_send_data (ctx, ctrl->server_local->export_key,
2026                                 KEYWRAP_KEYSIZE);
2027     }
2028   else
2029     err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for MODE");
2030   assuan_end_confidential (ctx);
2031
2032   return leave_cmd (ctx, err);
2033 }
2034
2035
2036 \f
2037 static const char hlp_import_key[] =
2038   "IMPORT_KEY [--unattended] [--force] [<cache_nonce>]\n"
2039   "\n"
2040   "Import a secret key into the key store.  The key is expected to be\n"
2041   "encrypted using the current session's key wrapping key (cf. command\n"
2042   "KEYWRAP_KEY) using the AESWRAP-128 algorithm.  This function takes\n"
2043   "no arguments but uses the inquiry \"KEYDATA\" to ask for the actual\n"
2044   "key data.  The unwrapped key must be a canonical S-expression.  The\n"
2045   "option --unattended tries to import the key as-is without any\n"
2046   "re-encryption.  Existing key can be overwritten with --force.";
2047 static gpg_error_t
2048 cmd_import_key (assuan_context_t ctx, char *line)
2049 {
2050   ctrl_t ctrl = assuan_get_pointer (ctx);
2051   gpg_error_t err;
2052   int opt_unattended;
2053   int force;
2054   unsigned char *wrappedkey = NULL;
2055   size_t wrappedkeylen;
2056   gcry_cipher_hd_t cipherhd = NULL;
2057   unsigned char *key = NULL;
2058   size_t keylen, realkeylen;
2059   char *passphrase = NULL;
2060   unsigned char *finalkey = NULL;
2061   size_t finalkeylen;
2062   unsigned char grip[20];
2063   gcry_sexp_t openpgp_sexp = NULL;
2064   char *cache_nonce = NULL;
2065   char *p;
2066
2067   if (ctrl->restricted)
2068     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2069
2070   if (!ctrl->server_local->import_key)
2071     {
2072       err = gpg_error (GPG_ERR_MISSING_KEY);
2073       goto leave;
2074     }
2075
2076   opt_unattended = has_option (line, "--unattended");
2077   force = has_option (line, "--force");
2078   line = skip_options (line);
2079
2080   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
2081     ;
2082   *p = '\0';
2083   if (*line)
2084     cache_nonce = xtrystrdup (line);
2085
2086   assuan_begin_confidential (ctx);
2087   err = assuan_inquire (ctx, "KEYDATA",
2088                         &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
2089   assuan_end_confidential (ctx);
2090   if (err)
2091     goto leave;
2092   if (wrappedkeylen < 24)
2093     {
2094       err = gpg_error (GPG_ERR_INV_LENGTH);
2095       goto leave;
2096     }
2097   keylen = wrappedkeylen - 8;
2098   key = xtrymalloc_secure (keylen);
2099   if (!key)
2100     {
2101       err = gpg_error_from_syserror ();
2102       goto leave;
2103     }
2104
2105   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2106                           GCRY_CIPHER_MODE_AESWRAP, 0);
2107   if (err)
2108     goto leave;
2109   err = gcry_cipher_setkey (cipherhd,
2110                             ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
2111   if (err)
2112     goto leave;
2113   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
2114   if (err)
2115     goto leave;
2116   gcry_cipher_close (cipherhd);
2117   cipherhd = NULL;
2118   xfree (wrappedkey);
2119   wrappedkey = NULL;
2120
2121   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
2122   if (!realkeylen)
2123     goto leave; /* Invalid canonical encoded S-expression.  */
2124
2125   err = keygrip_from_canon_sexp (key, realkeylen, grip);
2126   if (err)
2127     {
2128       /* This might be due to an unsupported S-expression format.
2129          Check whether this is openpgp-private-key and trigger that
2130          import code.  */
2131       if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
2132         {
2133           const char *tag;
2134           size_t taglen;
2135
2136           tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
2137           if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
2138             ;
2139           else
2140             {
2141               gcry_sexp_release (openpgp_sexp);
2142               openpgp_sexp = NULL;
2143             }
2144         }
2145       if (!openpgp_sexp)
2146         goto leave; /* Note that ERR is still set.  */
2147     }
2148
2149
2150   if (openpgp_sexp)
2151     {
2152       /* In most cases the key is encrypted and thus the conversion
2153          function from the OpenPGP format to our internal format will
2154          ask for a passphrase.  That passphrase will be returned and
2155          used to protect the key using the same code as for regular
2156          key import. */
2157
2158       xfree (key);
2159       key = NULL;
2160       err = convert_from_openpgp (ctrl, openpgp_sexp, force, grip,
2161                                   ctrl->server_local->keydesc, cache_nonce,
2162                                   &key, opt_unattended? NULL : &passphrase);
2163       if (err)
2164         goto leave;
2165       realkeylen = gcry_sexp_canon_len (key, 0, NULL, &err);
2166       if (!realkeylen)
2167         goto leave; /* Invalid canonical encoded S-expression.  */
2168       if (passphrase)
2169         {
2170           assert (!opt_unattended);
2171           if (!cache_nonce)
2172             {
2173               char buf[12];
2174               gcry_create_nonce (buf, 12);
2175               cache_nonce = bin2hex (buf, 12, NULL);
2176             }
2177           if (cache_nonce
2178               && !agent_put_cache (ctrl, cache_nonce, CACHE_MODE_NONCE,
2179                                    passphrase, CACHE_TTL_NONCE))
2180             assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2181         }
2182     }
2183   else if (opt_unattended)
2184     {
2185       err = set_error (GPG_ERR_ASS_PARAMETER,
2186                        "\"--unattended\" may only be used with OpenPGP keys");
2187       goto leave;
2188     }
2189   else
2190     {
2191       if (!force && !agent_key_available (grip))
2192         err = gpg_error (GPG_ERR_EEXIST);
2193       else
2194         {
2195           char *prompt = xtryasprintf
2196             (_("Please enter the passphrase to protect the "
2197                "imported object within the %s system."), GNUPG_NAME);
2198           if (!prompt)
2199             err = gpg_error_from_syserror ();
2200           else
2201             err = agent_ask_new_passphrase (ctrl, prompt, &passphrase);
2202           xfree (prompt);
2203         }
2204       if (err)
2205         goto leave;
2206     }
2207
2208   if (passphrase)
2209     {
2210       err = agent_protect (key, passphrase, &finalkey, &finalkeylen,
2211                            ctrl->s2k_count, -1);
2212       if (!err)
2213         err = agent_write_private_key (grip, finalkey, finalkeylen, force);
2214     }
2215   else
2216     err = agent_write_private_key (grip, key, realkeylen, force);
2217
2218  leave:
2219   gcry_sexp_release (openpgp_sexp);
2220   xfree (finalkey);
2221   xfree (passphrase);
2222   xfree (key);
2223   gcry_cipher_close (cipherhd);
2224   xfree (wrappedkey);
2225   xfree (cache_nonce);
2226   xfree (ctrl->server_local->keydesc);
2227   ctrl->server_local->keydesc = NULL;
2228   return leave_cmd (ctx, err);
2229 }
2230
2231
2232 \f
2233 static const char hlp_export_key[] =
2234   "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
2235   "\n"
2236   "Export a secret key from the key store.  The key will be encrypted\n"
2237   "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
2238   "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
2239   "prior to using this command.  The function takes the keygrip as argument.\n"
2240   "\n"
2241   "If --openpgp is used, the secret key material will be exported in RFC 4880\n"
2242   "compatible passphrase-protected form.  Without --openpgp, the secret key\n"
2243   "material will be exported in the clear (after prompting the user to unlock\n"
2244   "it, if needed).\n";
2245 static gpg_error_t
2246 cmd_export_key (assuan_context_t ctx, char *line)
2247 {
2248   ctrl_t ctrl = assuan_get_pointer (ctx);
2249   gpg_error_t err;
2250   unsigned char grip[20];
2251   gcry_sexp_t s_skey = NULL;
2252   unsigned char *key = NULL;
2253   size_t keylen;
2254   gcry_cipher_hd_t cipherhd = NULL;
2255   unsigned char *wrappedkey = NULL;
2256   size_t wrappedkeylen;
2257   int openpgp;
2258   char *cache_nonce;
2259   char *passphrase = NULL;
2260   unsigned char *shadow_info = NULL;
2261   char *pend;
2262   int c;
2263
2264   if (ctrl->restricted)
2265     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2266
2267   openpgp = has_option (line, "--openpgp");
2268   cache_nonce = option_value (line, "--cache-nonce");
2269   if (cache_nonce)
2270     {
2271       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
2272         ;
2273       c = *pend;
2274       *pend = '\0';
2275       cache_nonce = xtrystrdup (cache_nonce);
2276       *pend = c;
2277       if (!cache_nonce)
2278         {
2279           err = gpg_error_from_syserror ();
2280           goto leave;
2281         }
2282     }
2283   line = skip_options (line);
2284
2285   if (!ctrl->server_local->export_key)
2286     {
2287       err = set_error (GPG_ERR_MISSING_KEY, "did you run KEYWRAP_KEY ?");
2288       goto leave;
2289     }
2290
2291   err = parse_keygrip (ctx, line, grip);
2292   if (err)
2293     goto leave;
2294
2295   if (agent_key_available (grip))
2296     {
2297       err = gpg_error (GPG_ERR_NO_SECKEY);
2298       goto leave;
2299     }
2300
2301   /* Get the key from the file.  With the openpgp flag we also ask for
2302      the passphrase so that we can use it to re-encrypt it.  */
2303   err = agent_key_from_file (ctrl, cache_nonce,
2304                              ctrl->server_local->keydesc, grip,
2305                              &shadow_info, CACHE_MODE_IGNORE, NULL, &s_skey,
2306                              openpgp ? &passphrase : NULL);
2307   if (err)
2308     goto leave;
2309   if (shadow_info)
2310     {
2311       /* Key is on a smartcard.  */
2312       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2313       goto leave;
2314     }
2315
2316   if (openpgp)
2317     {
2318       /* The openpgp option changes the key format into the OpenPGP
2319          key transfer format.  The result is already a padded
2320          canonical S-expression.  */
2321       if (!passphrase)
2322         {
2323           err = agent_ask_new_passphrase
2324             (ctrl, _("This key (or subkey) is not protected with a passphrase."
2325                      "  Please enter a new passphrase to export it."),
2326              &passphrase);
2327           if (err)
2328             goto leave;
2329         }
2330       err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
2331       if (!err && passphrase)
2332         {
2333           if (!cache_nonce)
2334             {
2335               char buf[12];
2336               gcry_create_nonce (buf, 12);
2337               cache_nonce = bin2hex (buf, 12, NULL);
2338             }
2339           if (cache_nonce
2340               && !agent_put_cache (ctrl, cache_nonce, CACHE_MODE_NONCE,
2341                                    passphrase, CACHE_TTL_NONCE))
2342             {
2343               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2344               xfree (ctrl->server_local->last_cache_nonce);
2345               ctrl->server_local->last_cache_nonce = cache_nonce;
2346               cache_nonce = NULL;
2347             }
2348         }
2349     }
2350   else
2351     {
2352       /* Convert into a canonical S-expression and wrap that.  */
2353       err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
2354     }
2355   if (err)
2356     goto leave;
2357   gcry_sexp_release (s_skey);
2358   s_skey = NULL;
2359
2360   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2361                           GCRY_CIPHER_MODE_AESWRAP, 0);
2362   if (err)
2363     goto leave;
2364   err = gcry_cipher_setkey (cipherhd,
2365                             ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
2366   if (err)
2367     goto leave;
2368
2369   wrappedkeylen = keylen + 8;
2370   wrappedkey = xtrymalloc (wrappedkeylen);
2371   if (!wrappedkey)
2372     {
2373       err = gpg_error_from_syserror ();
2374       goto leave;
2375     }
2376
2377   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
2378   if (err)
2379     goto leave;
2380   xfree (key);
2381   key = NULL;
2382   gcry_cipher_close (cipherhd);
2383   cipherhd = NULL;
2384
2385   assuan_begin_confidential (ctx);
2386   err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
2387   assuan_end_confidential (ctx);
2388
2389
2390  leave:
2391   xfree (cache_nonce);
2392   xfree (passphrase);
2393   xfree (wrappedkey);
2394   gcry_cipher_close (cipherhd);
2395   xfree (key);
2396   gcry_sexp_release (s_skey);
2397   xfree (ctrl->server_local->keydesc);
2398   ctrl->server_local->keydesc = NULL;
2399   xfree (shadow_info);
2400
2401   return leave_cmd (ctx, err);
2402 }
2403
2404
2405 \f
2406 static const char hlp_delete_key[] =
2407   "DELETE_KEY [--force|--stub-only] <hexstring_with_keygrip>\n"
2408   "\n"
2409   "Delete a secret key from the key store.  If --force is used\n"
2410   "and a loopback pinentry is allowed, the agent will not ask\n"
2411   "the user for confirmation.  If --stub-only is used the key will\n"
2412   "only be deleted if it is a reference to a token.";
2413 static gpg_error_t
2414 cmd_delete_key (assuan_context_t ctx, char *line)
2415 {
2416   ctrl_t ctrl = assuan_get_pointer (ctx);
2417   gpg_error_t err;
2418   int force, stub_only;
2419   unsigned char grip[20];
2420
2421   if (ctrl->restricted)
2422     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2423
2424   force = has_option (line, "--force");
2425   stub_only = has_option (line, "--stub-only");
2426   line = skip_options (line);
2427
2428   /* If the use of a loopback pinentry has been disabled, we assume
2429    * that a silent deletion of keys shall also not be allowed.  */
2430   if (!opt.allow_loopback_pinentry)
2431     force = 0;
2432
2433   err = parse_keygrip (ctx, line, grip);
2434   if (err)
2435     goto leave;
2436
2437   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip,
2438                           force, stub_only);
2439   if (err)
2440     goto leave;
2441
2442  leave:
2443   xfree (ctrl->server_local->keydesc);
2444   ctrl->server_local->keydesc = NULL;
2445
2446   return leave_cmd (ctx, err);
2447 }
2448
2449
2450 \f
2451 #if SIZEOF_TIME_T > SIZEOF_UNSIGNED_LONG
2452 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010llu))"
2453 #else
2454 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010lu))"
2455 #endif
2456
2457 static const char hlp_keytocard[] =
2458   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2459   "\n";
2460 static gpg_error_t
2461 cmd_keytocard (assuan_context_t ctx, char *line)
2462 {
2463   ctrl_t ctrl = assuan_get_pointer (ctx);
2464   int force;
2465   gpg_error_t err = 0;
2466   unsigned char grip[20];
2467   gcry_sexp_t s_skey = NULL;
2468   unsigned char *keydata;
2469   size_t keydatalen;
2470   const char *serialno, *timestamp_str, *id;
2471   unsigned char *shadow_info = NULL;
2472   time_t timestamp;
2473
2474   if (ctrl->restricted)
2475     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2476
2477   force = has_option (line, "--force");
2478   line = skip_options (line);
2479
2480   err = parse_keygrip (ctx, line, grip);
2481   if (err)
2482     goto leave;
2483
2484   if (agent_key_available (grip))
2485     {
2486       err =gpg_error (GPG_ERR_NO_SECKEY);
2487       goto leave;
2488     }
2489
2490   /* Fixme: Replace the parsing code by split_fields().  */
2491   line += 40;
2492   while (*line && (*line == ' ' || *line == '\t'))
2493     line++;
2494   serialno = line;
2495   while (*line && (*line != ' ' && *line != '\t'))
2496     line++;
2497   if (!*line)
2498     {
2499       err = gpg_error (GPG_ERR_MISSING_VALUE);
2500       goto leave;
2501     }
2502   *line = '\0';
2503   line++;
2504   while (*line && (*line == ' ' || *line == '\t'))
2505     line++;
2506   id = line;
2507   while (*line && (*line != ' ' && *line != '\t'))
2508     line++;
2509   if (!*line)
2510     {
2511       err = gpg_error (GPG_ERR_MISSING_VALUE);
2512       goto leave;
2513     }
2514   *line = '\0';
2515   line++;
2516   while (*line && (*line == ' ' || *line == '\t'))
2517     line++;
2518   timestamp_str = line;
2519   while (*line && (*line != ' ' && *line != '\t'))
2520     line++;
2521   if (*line)
2522     *line = '\0';
2523
2524   if ((timestamp = isotime2epoch (timestamp_str)) == (time_t)(-1))
2525     {
2526       err = gpg_error (GPG_ERR_INV_TIME);
2527       goto leave;
2528     }
2529
2530   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2531                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2532                              &s_skey, NULL);
2533   if (err)
2534     {
2535       xfree (shadow_info);
2536       goto leave;
2537     }
2538   if (shadow_info)
2539     {
2540       /* Key is on a smartcard already.  */
2541       xfree (shadow_info);
2542       gcry_sexp_release (s_skey);
2543       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2544       goto leave;
2545     }
2546
2547   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2548   keydata = xtrymalloc_secure (keydatalen + 30);
2549   if (keydata == NULL)
2550     {
2551       err = gpg_error_from_syserror ();
2552       gcry_sexp_release (s_skey);
2553       goto leave;
2554     }
2555
2556   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2557   gcry_sexp_release (s_skey);
2558   keydatalen--;                 /* Decrement for last '\0'.  */
2559   /* Add timestamp "created-at" in the private key */
2560   snprintf (keydata+keydatalen-1, 30, KEYTOCARD_TIMESTAMP_FORMAT, timestamp);
2561   keydatalen += 10 + 19 - 1;
2562   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2563   xfree (keydata);
2564
2565  leave:
2566   return leave_cmd (ctx, err);
2567 }
2568
2569
2570 \f
2571 static const char hlp_getval[] =
2572   "GETVAL <key>\n"
2573   "\n"
2574   "Return the value for KEY from the special environment as created by\n"
2575   "PUTVAL.";
2576 static gpg_error_t
2577 cmd_getval (assuan_context_t ctx, char *line)
2578 {
2579   ctrl_t ctrl = assuan_get_pointer (ctx);
2580   int rc = 0;
2581   char *key = NULL;
2582   char *p;
2583   struct putval_item_s *vl;
2584
2585   if (ctrl->restricted)
2586     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2587
2588   for (p=line; *p == ' '; p++)
2589     ;
2590   key = p;
2591   p = strchr (key, ' ');
2592   if (p)
2593     {
2594       *p++ = 0;
2595       for (; *p == ' '; p++)
2596         ;
2597       if (*p)
2598         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2599     }
2600   if (!*key)
2601     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2602
2603
2604   for (vl=putval_list; vl; vl = vl->next)
2605     if ( !strcmp (vl->d, key) )
2606       break;
2607
2608   if (vl) /* Got an entry. */
2609     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2610   else
2611     return gpg_error (GPG_ERR_NO_DATA);
2612
2613   return leave_cmd (ctx, rc);
2614 }
2615
2616
2617 static const char hlp_putval[] =
2618   "PUTVAL <key> [<percent_escaped_value>]\n"
2619   "\n"
2620   "The gpg-agent maintains a kind of environment which may be used to\n"
2621   "store key/value pairs in it, so that they can be retrieved later.\n"
2622   "This may be used by helper daemons to daemonize themself on\n"
2623   "invocation and register them with gpg-agent.  Callers of the\n"
2624   "daemon's service may now first try connect to get the information\n"
2625   "for that service from gpg-agent through the GETVAL command and then\n"
2626   "try to connect to that daemon.  Only if that fails they may start\n"
2627   "an own instance of the service daemon. \n"
2628   "\n"
2629   "KEY is an arbitrary symbol with the same syntax rules as keys\n"
2630   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2631   "corresponding value; they should be similar to the values of\n"
2632   "envronment variables but gpg-agent does not enforce any\n"
2633   "restrictions.  If that value is not given any value under that KEY\n"
2634   "is removed from this special environment.";
2635 static gpg_error_t
2636 cmd_putval (assuan_context_t ctx, char *line)
2637 {
2638   ctrl_t ctrl = assuan_get_pointer (ctx);
2639   int rc = 0;
2640   char *key = NULL;
2641   char *value = NULL;
2642   size_t valuelen = 0;
2643   char *p;
2644   struct putval_item_s *vl, *vlprev;
2645
2646   if (ctrl->restricted)
2647     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2648
2649   for (p=line; *p == ' '; p++)
2650     ;
2651   key = p;
2652   p = strchr (key, ' ');
2653   if (p)
2654     {
2655       *p++ = 0;
2656       for (; *p == ' '; p++)
2657         ;
2658       if (*p)
2659         {
2660           value = p;
2661           p = strchr (value, ' ');
2662           if (p)
2663             *p = 0;
2664           valuelen = percent_plus_unescape_inplace (value, 0);
2665         }
2666     }
2667   if (!*key)
2668     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2669
2670
2671   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2672     if ( !strcmp (vl->d, key) )
2673       break;
2674
2675   if (vl) /* Delete old entry. */
2676     {
2677       if (vlprev)
2678         vlprev->next = vl->next;
2679       else
2680         putval_list = vl->next;
2681       xfree (vl);
2682     }
2683
2684   if (valuelen) /* Add entry. */
2685     {
2686       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2687       if (!vl)
2688         rc = gpg_error_from_syserror ();
2689       else
2690         {
2691           vl->len = valuelen;
2692           vl->off = strlen (key) + 1;
2693           strcpy (vl->d, key);
2694           memcpy (vl->d + vl->off, value, valuelen);
2695           vl->next = putval_list;
2696           putval_list = vl;
2697         }
2698     }
2699
2700   return leave_cmd (ctx, rc);
2701 }
2702
2703
2704
2705 \f
2706 static const char hlp_updatestartuptty[] =
2707   "UPDATESTARTUPTTY\n"
2708   "\n"
2709   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2710   "session.  This command is useful to pull future pinentries to\n"
2711   "another screen.  It is only required because there is no way in the\n"
2712   "ssh-agent protocol to convey this information.";
2713 static gpg_error_t
2714 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2715 {
2716   ctrl_t ctrl = assuan_get_pointer (ctx);
2717   gpg_error_t err = 0;
2718   session_env_t se;
2719   char *lc_ctype = NULL;
2720   char *lc_messages = NULL;
2721   int iterator;
2722   const char *name;
2723
2724   (void)line;
2725
2726   if (ctrl->restricted)
2727     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2728
2729   se = session_env_new ();
2730   if (!se)
2731     err = gpg_error_from_syserror ();
2732
2733   iterator = 0;
2734   while (!err && (name = session_env_list_stdenvnames (&iterator, NULL)))
2735     {
2736       const char *value = session_env_getenv (ctrl->session_env, name);
2737       if (value)
2738         err = session_env_setenv (se, name, value);
2739     }
2740
2741   if (!err && ctrl->lc_ctype)
2742     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2743       err = gpg_error_from_syserror ();
2744
2745   if (!err && ctrl->lc_messages)
2746     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2747       err = gpg_error_from_syserror ();
2748
2749   if (err)
2750     {
2751       session_env_release (se);
2752       xfree (lc_ctype);
2753       xfree (lc_messages);
2754     }
2755   else
2756     {
2757       session_env_release (opt.startup_env);
2758       opt.startup_env = se;
2759       xfree (opt.startup_lc_ctype);
2760       opt.startup_lc_ctype = lc_ctype;
2761       xfree (opt.startup_lc_messages);
2762       opt.startup_lc_messages = lc_messages;
2763     }
2764
2765   return err;
2766 }
2767
2768
2769 \f
2770 static const char hlp_killagent[] =
2771   "KILLAGENT\n"
2772   "\n"
2773   "Stop the agent.";
2774 static gpg_error_t
2775 cmd_killagent (assuan_context_t ctx, char *line)
2776 {
2777   ctrl_t ctrl = assuan_get_pointer (ctx);
2778
2779   (void)line;
2780
2781   if (ctrl->restricted)
2782     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2783
2784   ctrl->server_local->stopme = 1;
2785   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2786   return 0;
2787 }
2788
2789
2790 static const char hlp_reloadagent[] =
2791   "RELOADAGENT\n"
2792   "\n"
2793   "This command is an alternative to SIGHUP\n"
2794   "to reload the configuration.";
2795 static gpg_error_t
2796 cmd_reloadagent (assuan_context_t ctx, char *line)
2797 {
2798   ctrl_t ctrl = assuan_get_pointer (ctx);
2799
2800   (void)line;
2801
2802   if (ctrl->restricted)
2803     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2804
2805   agent_sighup_action ();
2806   return 0;
2807 }
2808
2809
2810 \f
2811 static const char hlp_getinfo[] =
2812   "GETINFO <what>\n"
2813   "\n"
2814   "Multipurpose function to return a variety of information.\n"
2815   "Supported values for WHAT are:\n"
2816   "\n"
2817   "  version         - Return the version of the program.\n"
2818   "  pid             - Return the process id of the server.\n"
2819   "  socket_name     - Return the name of the socket.\n"
2820   "  ssh_socket_name - Return the name of the ssh socket.\n"
2821   "  scd_running     - Return OK if the SCdaemon is already running.\n"
2822   "  s2k_time        - Return the time in milliseconds required for S2K.\n"
2823   "  s2k_count       - Return the standard S2K count.\n"
2824   "  s2k_count_cal   - Return the calibrated S2K count.\n"
2825   "  std_env_names   - List the names of the standard environment.\n"
2826   "  std_session_env - List the standard session environment.\n"
2827   "  std_startup_env - List the standard startup environment.\n"
2828   "  getenv NAME     - Return value of envvar NAME.\n"
2829   "  connections     - Return number of active connections.\n"
2830   "  jent_active     - Returns OK if Libgcrypt's JENT is active.\n"
2831   "  restricted      - Returns OK if the connection is in restricted mode.\n"
2832   "  cmd_has_option CMD OPT\n"
2833   "                  - Returns OK if command CMD has option OPT.\n";
2834 static gpg_error_t
2835 cmd_getinfo (assuan_context_t ctx, char *line)
2836 {
2837   ctrl_t ctrl = assuan_get_pointer (ctx);
2838   int rc = 0;
2839
2840   if (!strcmp (line, "version"))
2841     {
2842       const char *s = VERSION;
2843       rc = assuan_send_data (ctx, s, strlen (s));
2844     }
2845   else if (!strncmp (line, "cmd_has_option", 14)
2846            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2847     {
2848       char *cmd, *cmdopt;
2849       line += 14;
2850       while (*line == ' ' || *line == '\t')
2851         line++;
2852       if (!*line)
2853         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2854       else
2855         {
2856           cmd = line;
2857           while (*line && (*line != ' ' && *line != '\t'))
2858             line++;
2859           if (!*line)
2860             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2861           else
2862             {
2863               *line++ = 0;
2864               while (*line == ' ' || *line == '\t')
2865                 line++;
2866               if (!*line)
2867                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2868               else
2869                 {
2870                   cmdopt = line;
2871                   if (!command_has_option (cmd, cmdopt))
2872                     rc = gpg_error (GPG_ERR_GENERAL);
2873                 }
2874             }
2875         }
2876     }
2877   else if (!strcmp (line, "s2k_count"))
2878     {
2879       char numbuf[50];
2880
2881       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2882       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2883     }
2884   else if (!strcmp (line, "restricted"))
2885     {
2886       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2887     }
2888   else if (ctrl->restricted)
2889     {
2890       rc = gpg_error (GPG_ERR_FORBIDDEN);
2891     }
2892   /* All sub-commands below are not allowed in restricted mode.  */
2893   else if (!strcmp (line, "pid"))
2894     {
2895       char numbuf[50];
2896
2897       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2898       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2899     }
2900   else if (!strcmp (line, "socket_name"))
2901     {
2902       const char *s = get_agent_socket_name ();
2903
2904       if (s)
2905         rc = assuan_send_data (ctx, s, strlen (s));
2906       else
2907         rc = gpg_error (GPG_ERR_NO_DATA);
2908     }
2909   else if (!strcmp (line, "ssh_socket_name"))
2910     {
2911       const char *s = get_agent_ssh_socket_name ();
2912
2913       if (s)
2914         rc = assuan_send_data (ctx, s, strlen (s));
2915       else
2916         rc = gpg_error (GPG_ERR_NO_DATA);
2917     }
2918   else if (!strcmp (line, "scd_running"))
2919     {
2920       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2921     }
2922   else if (!strcmp (line, "std_env_names"))
2923     {
2924       int iterator;
2925       const char *name;
2926
2927       iterator = 0;
2928       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2929         {
2930           rc = assuan_send_data (ctx, name, strlen (name)+1);
2931           if (!rc)
2932             rc = assuan_send_data (ctx, NULL, 0);
2933           if (rc)
2934             break;
2935         }
2936     }
2937   else if (!strcmp (line, "std_session_env")
2938            || !strcmp (line, "std_startup_env"))
2939     {
2940       int iterator;
2941       const char *name, *value;
2942       char *string;
2943
2944       iterator = 0;
2945       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2946         {
2947           value = session_env_getenv_or_default
2948             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2949           if (value)
2950             {
2951               string = xtryasprintf ("%s=%s", name, value);
2952               if (!string)
2953                 rc = gpg_error_from_syserror ();
2954               else
2955                 {
2956                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2957                   if (!rc)
2958                     rc = assuan_send_data (ctx, NULL, 0);
2959                 }
2960               if (rc)
2961                 break;
2962             }
2963         }
2964     }
2965   else if (!strncmp (line, "getenv", 6)
2966            && (line[6] == ' ' || line[6] == '\t' || !line[6]))
2967     {
2968       line += 6;
2969       while (*line == ' ' || *line == '\t')
2970         line++;
2971       if (!*line)
2972         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2973       else
2974         {
2975           const char *s = getenv (line);
2976           if (!s)
2977             rc = set_error (GPG_ERR_NOT_FOUND, "No such envvar");
2978           else
2979             rc = assuan_send_data (ctx, s, strlen (s));
2980         }
2981     }
2982   else if (!strcmp (line, "connections"))
2983     {
2984       char numbuf[20];
2985
2986       snprintf (numbuf, sizeof numbuf, "%d",
2987                 get_agent_active_connection_count ());
2988       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2989     }
2990   else if (!strcmp (line, "jent_active"))
2991     {
2992 #if GCRYPT_VERSION_NUMBER >= 0x010800
2993       char *buf;
2994       char *fields[5];
2995
2996       buf = gcry_get_config (0, "rng-type");
2997       if (buf
2998           && split_fields_colon (buf, fields, DIM (fields)) >= 5
2999           && atoi (fields[4]) > 0)
3000         rc = 0;
3001       else
3002         rc = gpg_error (GPG_ERR_FALSE);
3003       gcry_free (buf);
3004 #else
3005       rc = gpg_error (GPG_ERR_FALSE);
3006 #endif
3007     }
3008   else if (!strcmp (line, "s2k_count_cal"))
3009     {
3010       char numbuf[50];
3011
3012       snprintf (numbuf, sizeof numbuf, "%lu", get_calibrated_s2k_count ());
3013       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
3014     }
3015   else if (!strcmp (line, "s2k_time"))
3016     {
3017       char numbuf[50];
3018
3019       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_time ());
3020       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
3021     }
3022   else
3023     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
3024   return rc;
3025 }
3026
3027
3028 \f
3029 /* This function is called by Libassuan to parse the OPTION command.
3030    It has been registered similar to the other Assuan commands.  */
3031 static gpg_error_t
3032 option_handler (assuan_context_t ctx, const char *key, const char *value)
3033 {
3034   ctrl_t ctrl = assuan_get_pointer (ctx);
3035   gpg_error_t err = 0;
3036
3037   if (!strcmp (key, "agent-awareness"))
3038     {
3039       /* The value is a version string telling us of which agent
3040          version the caller is aware of.  */
3041       ctrl->server_local->allow_fully_canceled =
3042         gnupg_compare_version (value, "2.1.0");
3043     }
3044   else if (ctrl->restricted)
3045     {
3046       err = gpg_error (GPG_ERR_FORBIDDEN);
3047     }
3048   /* All options below are not allowed in restricted mode.  */
3049   else if (!strcmp (key, "putenv"))
3050     {
3051       /* Change the session's environment to be used for the
3052          Pinentry.  Valid values are:
3053           <NAME>            Delete envvar NAME
3054           <KEY>=            Set envvar NAME to the empty string
3055           <KEY>=<VALUE>     Set envvar NAME to VALUE
3056       */
3057       err = session_env_putenv (ctrl->session_env, value);
3058     }
3059   else if (!strcmp (key, "display"))
3060     {
3061       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
3062     }
3063   else if (!strcmp (key, "ttyname"))
3064     {
3065       if (!opt.keep_tty)
3066         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
3067     }
3068   else if (!strcmp (key, "ttytype"))
3069     {
3070       if (!opt.keep_tty)
3071         err = session_env_setenv (ctrl->session_env, "TERM", value);
3072     }
3073   else if (!strcmp (key, "lc-ctype"))
3074     {
3075       if (ctrl->lc_ctype)
3076         xfree (ctrl->lc_ctype);
3077       ctrl->lc_ctype = xtrystrdup (value);
3078       if (!ctrl->lc_ctype)
3079         return out_of_core ();
3080     }
3081   else if (!strcmp (key, "lc-messages"))
3082     {
3083       if (ctrl->lc_messages)
3084         xfree (ctrl->lc_messages);
3085       ctrl->lc_messages = xtrystrdup (value);
3086       if (!ctrl->lc_messages)
3087         return out_of_core ();
3088     }
3089   else if (!strcmp (key, "xauthority"))
3090     {
3091       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
3092     }
3093   else if (!strcmp (key, "pinentry-user-data"))
3094     {
3095       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
3096     }
3097   else if (!strcmp (key, "use-cache-for-signing"))
3098     ctrl->server_local->use_cache_for_signing = *value? !!atoi (value) : 0;
3099   else if (!strcmp (key, "allow-pinentry-notify"))
3100     ctrl->server_local->allow_pinentry_notify = 1;
3101   else if (!strcmp (key, "pinentry-mode"))
3102     {
3103       int tmp = parse_pinentry_mode (value);
3104       if (tmp == -1)
3105         err = gpg_error (GPG_ERR_INV_VALUE);
3106       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
3107         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3108       else
3109         ctrl->pinentry_mode = tmp;
3110     }
3111   else if (!strcmp (key, "cache-ttl-opt-preset"))
3112     {
3113       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
3114     }
3115   else if (!strcmp (key, "s2k-count"))
3116     {
3117       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
3118       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
3119         {
3120           ctrl->s2k_count = 0;
3121         }
3122     }
3123   else if (!strcmp (key, "pretend-request-origin"))
3124     {
3125       log_assert (!ctrl->restricted);
3126       switch (parse_request_origin (value))
3127         {
3128         case REQUEST_ORIGIN_LOCAL:   ctrl->restricted = 0; break;
3129         case REQUEST_ORIGIN_REMOTE:  ctrl->restricted = 1; break;
3130         case REQUEST_ORIGIN_BROWSER: ctrl->restricted = 2; break;
3131         default:
3132           err = gpg_error (GPG_ERR_INV_VALUE);
3133           /* Better pretend to be remote in case of a bad value.  */
3134           ctrl->restricted = 1;
3135           break;
3136         }
3137     }
3138   else
3139     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
3140
3141   return err;
3142 }
3143
3144
3145
3146 \f
3147 /* Called by libassuan after all commands. ERR is the error from the
3148    last assuan operation and not the one returned from the command. */
3149 static void
3150 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
3151 {
3152   ctrl_t ctrl = assuan_get_pointer (ctx);
3153
3154   (void)err;
3155
3156   /* Switch off any I/O monitor controlled logging pausing. */
3157   ctrl->server_local->pause_io_logging = 0;
3158 }
3159
3160
3161 /* This function is called by libassuan for all I/O.  We use it here
3162    to disable logging for the GETEVENTCOUNTER commands.  This is so
3163    that the debug output won't get cluttered by this primitive
3164    command.  */
3165 static unsigned int
3166 io_monitor (assuan_context_t ctx, void *hook, int direction,
3167             const char *line, size_t linelen)
3168 {
3169   ctrl_t ctrl = assuan_get_pointer (ctx);
3170
3171   (void) hook;
3172
3173   /* We want to suppress all Assuan log messages for connections from
3174    * self.  However, assuan_get_pid works only after
3175    * assuan_accept. Now, assuan_accept already logs a line ending with
3176    * the process id.  We use this hack here to get the peers pid so
3177    * that we can compare it to our pid.  We should add an assuan
3178    * function to return the pid for a file descriptor and use that to
3179    * detect connections to self.  */
3180   if (ctx && !ctrl->server_local->greeting_seen
3181       && direction == ASSUAN_IO_TO_PEER)
3182     {
3183       ctrl->server_local->greeting_seen = 1;
3184       if (linelen > 32
3185           && !strncmp (line, "OK Pleased to meet you, process ", 32)
3186           && strtoul (line+32, NULL, 10) == getpid ())
3187         return ASSUAN_IO_MONITOR_NOLOG;
3188     }
3189
3190
3191   /* Do not log self-connections.  This makes the log cleaner because
3192    * we won't see the check-our-own-socket calls.  */
3193   if (ctx && ctrl->server_local->connect_from_self)
3194     return ASSUAN_IO_MONITOR_NOLOG;
3195
3196   /* Note that we only check for the uppercase name.  This allows the user to
3197      see the logging for debugging if using a non-upercase command
3198      name. */
3199   if (ctx && direction == ASSUAN_IO_FROM_PEER
3200       && linelen >= 15
3201       && !strncmp (line, "GETEVENTCOUNTER", 15)
3202       && (linelen == 15 || spacep (line+15)))
3203     {
3204       ctrl->server_local->pause_io_logging = 1;
3205     }
3206
3207   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3208 }
3209
3210
3211 /* Return true if the command CMD implements the option OPT.  */
3212 static int
3213 command_has_option (const char *cmd, const char *cmdopt)
3214 {
3215   if (!strcmp (cmd, "GET_PASSPHRASE"))
3216     {
3217       if (!strcmp (cmdopt, "repeat"))
3218           return 1;
3219     }
3220
3221   return 0;
3222 }
3223
3224
3225 /* Tell Libassuan about our commands.  Also register the other Assuan
3226    handlers. */
3227 static int
3228 register_commands (assuan_context_t ctx)
3229 {
3230   static struct {
3231     const char *name;
3232     assuan_handler_t handler;
3233     const char * const help;
3234   } table[] = {
3235     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3236     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3237     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3238     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3239     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3240     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3241     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3242     { "SETHASH",        cmd_sethash,   hlp_sethash },
3243     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3244     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3245     { "GENKEY",         cmd_genkey,    hlp_genkey },
3246     { "READKEY",        cmd_readkey,   hlp_readkey },
3247     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3248     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3249     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3250     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3251     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3252     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3253     { "LEARN",          cmd_learn,     hlp_learn },
3254     { "PASSWD",         cmd_passwd,    hlp_passwd },
3255     { "INPUT",          NULL },
3256     { "OUTPUT",         NULL },
3257     { "SCD",            cmd_scd,       hlp_scd },
3258     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3259     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3260     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3261     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3262     { "GETVAL",         cmd_getval,    hlp_getval },
3263     { "PUTVAL",         cmd_putval,    hlp_putval },
3264     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3265     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3266     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3267     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3268     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3269     { NULL }
3270   };
3271   int i, rc;
3272
3273   for (i=0; table[i].name; i++)
3274     {
3275       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3276                                     table[i].help);
3277       if (rc)
3278         return rc;
3279     }
3280   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3281   assuan_register_reset_notify (ctx, reset_notify);
3282   assuan_register_option_handler (ctx, option_handler);
3283   return 0;
3284 }
3285
3286
3287 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3288    simple piper server, otherwise it is a regular server.  CTRL is the
3289    control structure for this connection; it has only the basic
3290    initialization. */
3291 void
3292 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3293 {
3294   int rc;
3295   assuan_context_t ctx = NULL;
3296
3297   if (ctrl->restricted)
3298     {
3299       if (agent_copy_startup_env (ctrl))
3300         return;
3301     }
3302
3303   rc = assuan_new (&ctx);
3304   if (rc)
3305     {
3306       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3307       agent_exit (2);
3308     }
3309
3310   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3311     {
3312       assuan_fd_t filedes[2];
3313
3314       filedes[0] = assuan_fdopen (0);
3315       filedes[1] = assuan_fdopen (1);
3316       rc = assuan_init_pipe_server (ctx, filedes);
3317     }
3318   else if (listen_fd != GNUPG_INVALID_FD)
3319     {
3320       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3321       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3322          this branch is currently not used.  */
3323     }
3324   else
3325     {
3326       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3327     }
3328   if (rc)
3329     {
3330       log_error ("failed to initialize the server: %s\n",
3331                  gpg_strerror(rc));
3332       agent_exit (2);
3333     }
3334   rc = register_commands (ctx);
3335   if (rc)
3336     {
3337       log_error ("failed to register commands with Assuan: %s\n",
3338                  gpg_strerror(rc));
3339       agent_exit (2);
3340     }
3341
3342   assuan_set_pointer (ctx, ctrl);
3343   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3344   ctrl->server_local->assuan_ctx = ctx;
3345   ctrl->server_local->use_cache_for_signing = 1;
3346
3347   ctrl->digest.raw_value = 0;
3348
3349   assuan_set_io_monitor (ctx, io_monitor, NULL);
3350   agent_set_progress_cb (progress_cb, ctrl);
3351
3352   for (;;)
3353     {
3354       assuan_peercred_t client_creds; /* Note: Points into CTX.  */
3355       pid_t pid;
3356
3357       rc = assuan_accept (ctx);
3358       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3359         {
3360           break;
3361         }
3362       else if (rc)
3363         {
3364           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3365           break;
3366         }
3367
3368       rc = assuan_get_peercred (ctx, &client_creds);
3369       if (rc)
3370         {
3371
3372           if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3373             ;
3374           else
3375             log_info ("Assuan get_peercred failed: %s\n", gpg_strerror (rc));
3376           pid = assuan_get_pid (ctx);
3377           ctrl->client_uid = -1;
3378         }
3379       else
3380         {
3381           pid = client_creds->pid;
3382           ctrl->client_uid = client_creds->uid;
3383         }
3384       ctrl->client_pid = (pid == ASSUAN_INVALID_PID)? 0 : (unsigned long)pid;
3385       ctrl->server_local->connect_from_self = (pid == getpid ());
3386
3387       rc = assuan_process (ctx);
3388       if (rc)
3389         {
3390           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3391           continue;
3392         }
3393     }
3394
3395   /* Reset the nonce caches.  */
3396   clear_nonce_cache (ctrl);
3397
3398   /* Reset the SCD if needed. */
3399   agent_reset_scd (ctrl);
3400
3401   /* Reset the pinentry (in case of popup messages). */
3402   agent_reset_query (ctrl);
3403
3404   /* Cleanup.  */
3405   assuan_release (ctx);
3406   xfree (ctrl->server_local->keydesc);
3407   xfree (ctrl->server_local->import_key);
3408   xfree (ctrl->server_local->export_key);
3409   if (ctrl->server_local->stopme)
3410     agent_exit (0);
3411   xfree (ctrl->server_local);
3412   ctrl->server_local = NULL;
3413 }
3414
3415
3416 /* Helper for the pinentry loopback mode.  It merely passes the
3417    parameters on to the client.  */
3418 gpg_error_t
3419 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3420                   unsigned char **buffer, size_t *size,
3421                   size_t max_length)
3422 {
3423   gpg_error_t rc;
3424   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3425
3426   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3427   if (rc)
3428     return rc;
3429
3430   assuan_begin_confidential (ctx);
3431   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3432   assuan_end_confidential (ctx);
3433   return rc;
3434 }