agent: New OPTION pretend-request-origin
[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->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->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  2048)))\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 (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 (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 (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 (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 (cacheid, opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER,
1597                    NULL, 0);
1598
1599   agent_clear_passphrase (ctrl, cacheid,
1600                           opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER);
1601
1602   return 0;
1603 }
1604
1605
1606 static const char hlp_get_confirmation[] =
1607   "GET_CONFIRMATION <description>\n"
1608   "\n"
1609   "This command may be used to ask for a simple confirmation.\n"
1610   "DESCRIPTION is displayed along with a Okay and Cancel button.  This\n"
1611   "command uses a syntax which helps clients to use the agent with\n"
1612   "minimum effort.  The agent either returns with an error or with a\n"
1613   "OK.  Note, that the length of DESCRIPTION is implicitly limited by\n"
1614   "the maximum length of a command. DESCRIPTION should not contain\n"
1615   "any spaces, those must be encoded either percent escaped or simply\n"
1616   "as '+'.";
1617 static gpg_error_t
1618 cmd_get_confirmation (assuan_context_t ctx, char *line)
1619 {
1620   ctrl_t ctrl = assuan_get_pointer (ctx);
1621   int rc;
1622   char *desc = NULL;
1623   char *p;
1624
1625   if (ctrl->restricted)
1626     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1627
1628   /* parse the stuff */
1629   for (p=line; *p == ' '; p++)
1630     ;
1631   desc = p;
1632   p = strchr (desc, ' ');
1633   if (p)
1634     *p = 0; /* We ignore any garbage -may be later used for other args. */
1635
1636   if (!*desc)
1637     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1638
1639   if (!strcmp (desc, "X"))
1640     desc = NULL;
1641
1642   /* Note, that we only need to replace the + characters and should
1643      leave the other escaping in place because the escaped string is
1644      send verbatim to the pinentry which does the unescaping (but not
1645      the + replacing) */
1646   if (desc)
1647     plus_to_blank (desc);
1648
1649   rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
1650   return leave_cmd (ctx, rc);
1651 }
1652
1653
1654 \f
1655 static const char hlp_learn[] =
1656   "LEARN [--send] [--sendinfo] [--force]\n"
1657   "\n"
1658   "Learn something about the currently inserted smartcard.  With\n"
1659   "--sendinfo information about the card is returned; with --send\n"
1660   "the available certificates are returned as D lines; with --force\n"
1661   "private key storage will be updated by the result.";
1662 static gpg_error_t
1663 cmd_learn (assuan_context_t ctx, char *line)
1664 {
1665   ctrl_t ctrl = assuan_get_pointer (ctx);
1666   gpg_error_t err;
1667   int send, sendinfo, force;
1668
1669   send = has_option (line, "--send");
1670   sendinfo = send? 1 : has_option (line, "--sendinfo");
1671   force = has_option (line, "--force");
1672
1673   if (ctrl->restricted)
1674     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1675
1676   err = agent_handle_learn (ctrl, send, sendinfo? ctx : NULL, force);
1677   return leave_cmd (ctx, err);
1678 }
1679
1680
1681 \f
1682 static const char hlp_passwd[] =
1683   "PASSWD [--cache-nonce=<c>] [--passwd-nonce=<s>] [--preset]\n"
1684   "       [--verify] <hexkeygrip>\n"
1685   "\n"
1686   "Change the passphrase/PIN for the key identified by keygrip in LINE.  If\n"
1687   "--preset is used then the new passphrase will be added to the cache.\n"
1688   "If --verify is used the command asks for the passphrase and verifies\n"
1689   "that the passphrase valid.\n";
1690 static gpg_error_t
1691 cmd_passwd (assuan_context_t ctx, char *line)
1692 {
1693   ctrl_t ctrl = assuan_get_pointer (ctx);
1694   gpg_error_t err;
1695   int c;
1696   char *cache_nonce = NULL;
1697   char *passwd_nonce = NULL;
1698   unsigned char grip[20];
1699   gcry_sexp_t s_skey = NULL;
1700   unsigned char *shadow_info = NULL;
1701   char *passphrase = NULL;
1702   char *pend;
1703   int opt_preset, opt_verify;
1704
1705   if (ctrl->restricted)
1706     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1707
1708   opt_preset = has_option (line, "--preset");
1709   cache_nonce = option_value (line, "--cache-nonce");
1710   opt_verify = has_option (line, "--verify");
1711   if (cache_nonce)
1712     {
1713       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
1714         ;
1715       c = *pend;
1716       *pend = '\0';
1717       cache_nonce = xtrystrdup (cache_nonce);
1718       *pend = c;
1719       if (!cache_nonce)
1720         {
1721           err = gpg_error_from_syserror ();
1722           goto leave;
1723         }
1724     }
1725
1726   passwd_nonce = option_value (line, "--passwd-nonce");
1727   if (passwd_nonce)
1728     {
1729       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
1730         ;
1731       c = *pend;
1732       *pend = '\0';
1733       passwd_nonce = xtrystrdup (passwd_nonce);
1734       *pend = c;
1735       if (!passwd_nonce)
1736         {
1737           err = gpg_error_from_syserror ();
1738           goto leave;
1739         }
1740     }
1741
1742   line = skip_options (line);
1743
1744   err = parse_keygrip (ctx, line, grip);
1745   if (err)
1746     goto leave;
1747
1748   ctrl->in_passwd++;
1749   err = agent_key_from_file (ctrl,
1750                              opt_verify? NULL : cache_nonce,
1751                              ctrl->server_local->keydesc,
1752                              grip, &shadow_info, CACHE_MODE_IGNORE, NULL,
1753                              &s_skey, &passphrase);
1754   if (err)
1755     ;
1756   else if (shadow_info)
1757     {
1758       log_error ("changing a smartcard PIN is not yet supported\n");
1759       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1760     }
1761   else if (opt_verify)
1762     {
1763       /* All done.  */
1764       if (passphrase)
1765         {
1766           if (!passwd_nonce)
1767             {
1768               char buf[12];
1769               gcry_create_nonce (buf, 12);
1770               passwd_nonce = bin2hex (buf, 12, NULL);
1771             }
1772           if (passwd_nonce
1773               && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
1774                                    passphrase, CACHE_TTL_NONCE))
1775             {
1776               assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1777               xfree (ctrl->server_local->last_passwd_nonce);
1778               ctrl->server_local->last_passwd_nonce = passwd_nonce;
1779               passwd_nonce = NULL;
1780             }
1781         }
1782     }
1783   else
1784     {
1785       char *newpass = NULL;
1786
1787       if (passwd_nonce)
1788         newpass = agent_get_cache (passwd_nonce, CACHE_MODE_NONCE);
1789       err = agent_protect_and_store (ctrl, s_skey, &newpass);
1790       if (!err && passphrase)
1791         {
1792           /* A passphrase existed on the old key and the change was
1793              successful.  Return a nonce for that old passphrase to
1794              let the caller try to unprotect the other subkeys with
1795              the same key.  */
1796           if (!cache_nonce)
1797             {
1798               char buf[12];
1799               gcry_create_nonce (buf, 12);
1800               cache_nonce = bin2hex (buf, 12, NULL);
1801             }
1802           if (cache_nonce
1803               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
1804                                    passphrase, CACHE_TTL_NONCE))
1805             {
1806               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
1807               xfree (ctrl->server_local->last_cache_nonce);
1808               ctrl->server_local->last_cache_nonce = cache_nonce;
1809               cache_nonce = NULL;
1810             }
1811           if (newpass)
1812             {
1813               /* If we have a new passphrase (which might be empty) we
1814                  store it under a passwd nonce so that the caller may
1815                  send that nonce again to use it for another key. */
1816               if (!passwd_nonce)
1817                 {
1818                   char buf[12];
1819                   gcry_create_nonce (buf, 12);
1820                   passwd_nonce = bin2hex (buf, 12, NULL);
1821                 }
1822               if (passwd_nonce
1823                   && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
1824                                        newpass, CACHE_TTL_NONCE))
1825                 {
1826                   assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1827                   xfree (ctrl->server_local->last_passwd_nonce);
1828                   ctrl->server_local->last_passwd_nonce = passwd_nonce;
1829                   passwd_nonce = NULL;
1830                 }
1831             }
1832         }
1833       if (!err && opt_preset)
1834         {
1835           char hexgrip[40+1];
1836           bin2hex(grip, 20, hexgrip);
1837           err = agent_put_cache (hexgrip, CACHE_MODE_ANY, newpass,
1838                                  ctrl->cache_ttl_opt_preset);
1839         }
1840       xfree (newpass);
1841     }
1842   ctrl->in_passwd--;
1843
1844   xfree (ctrl->server_local->keydesc);
1845   ctrl->server_local->keydesc = NULL;
1846
1847  leave:
1848   xfree (passphrase);
1849   gcry_sexp_release (s_skey);
1850   xfree (shadow_info);
1851   xfree (cache_nonce);
1852   xfree (passwd_nonce);
1853   return leave_cmd (ctx, err);
1854 }
1855
1856
1857 static const char hlp_preset_passphrase[] =
1858   "PRESET_PASSPHRASE [--inquire] <string_or_keygrip> <timeout> [<hexstring>]\n"
1859   "\n"
1860   "Set the cached passphrase/PIN for the key identified by the keygrip\n"
1861   "to passwd for the given time, where -1 means infinite and 0 means\n"
1862   "the default (currently only a timeout of -1 is allowed, which means\n"
1863   "to never expire it).  If passwd is not provided, ask for it via the\n"
1864   "pinentry module unless --inquire is passed in which case the passphrase\n"
1865   "is retrieved from the client via a server inquire.\n";
1866 static gpg_error_t
1867 cmd_preset_passphrase (assuan_context_t ctx, char *line)
1868 {
1869   ctrl_t ctrl = assuan_get_pointer (ctx);
1870   int rc;
1871   char *grip_clear = NULL;
1872   unsigned char *passphrase = NULL;
1873   int ttl;
1874   size_t len;
1875   int opt_inquire;
1876
1877   if (ctrl->restricted)
1878     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1879
1880   if (!opt.allow_preset_passphrase)
1881     return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
1882
1883   opt_inquire = has_option (line, "--inquire");
1884   line = skip_options (line);
1885   grip_clear = line;
1886   while (*line && (*line != ' ' && *line != '\t'))
1887     line++;
1888   if (!*line)
1889     return gpg_error (GPG_ERR_MISSING_VALUE);
1890   *line = '\0';
1891   line++;
1892   while (*line && (*line == ' ' || *line == '\t'))
1893     line++;
1894
1895   /* Currently, only infinite timeouts are allowed.  */
1896   ttl = -1;
1897   if (line[0] != '-' || line[1] != '1')
1898     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1899   line++;
1900   line++;
1901   while (!(*line != ' ' && *line != '\t'))
1902     line++;
1903
1904   /* Syntax check the hexstring.  */
1905   len = 0;
1906   rc = parse_hexstring (ctx, line, &len);
1907   if (rc)
1908     return rc;
1909   line[len] = '\0';
1910
1911   /* If there is a passphrase, use it.  Currently, a passphrase is
1912      required.  */
1913   if (*line)
1914     {
1915       if (opt_inquire)
1916         {
1917           rc = set_error (GPG_ERR_ASS_PARAMETER,
1918                           "both --inquire and passphrase specified");
1919           goto leave;
1920         }
1921
1922       /* Do in-place conversion.  */
1923       passphrase = line;
1924       if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
1925         rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
1926     }
1927   else if (opt_inquire)
1928     {
1929       /* Note that the passphrase will be truncated at any null byte and the
1930        * limit is 480 characters. */
1931       size_t maxlen = 480;
1932
1933       rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", maxlen);
1934       if (!rc)
1935         rc = assuan_inquire (ctx, "PASSPHRASE", &passphrase, &len, maxlen);
1936     }
1937   else
1938     rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
1939
1940   if (!rc)
1941     {
1942       rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1943       if (opt_inquire)
1944         xfree (passphrase);
1945     }
1946
1947 leave:
1948   return leave_cmd (ctx, rc);
1949 }
1950
1951
1952 \f
1953 static const char hlp_scd[] =
1954   "SCD <commands to pass to the scdaemon>\n"
1955   " \n"
1956   "This is a general quote command to redirect everything to the\n"
1957   "SCdaemon.";
1958 static gpg_error_t
1959 cmd_scd (assuan_context_t ctx, char *line)
1960 {
1961   int rc;
1962 #ifdef BUILD_WITH_SCDAEMON
1963   ctrl_t ctrl = assuan_get_pointer (ctx);
1964   if (ctrl->restricted)
1965     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1966
1967   rc = divert_generic_cmd (ctrl, line, ctx);
1968 #else
1969   (void)ctx; (void)line;
1970   rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
1971 #endif
1972   return rc;
1973 }
1974
1975
1976 \f
1977 static const char hlp_keywrap_key[] =
1978   "KEYWRAP_KEY [--clear] <mode>\n"
1979   "\n"
1980   "Return a key to wrap another key.  For now the key is returned\n"
1981   "verbatim and thus makes not much sense because an eavesdropper on\n"
1982   "the gpg-agent connection will see the key as well as the wrapped key.\n"
1983   "However, this function may either be equipped with a public key\n"
1984   "mechanism or not used at all if the key is a pre-shared key.  In any\n"
1985   "case wrapping the import and export of keys is a requirement for\n"
1986   "certain cryptographic validations and thus useful.  The key persists\n"
1987   "until a RESET command but may be cleared using the option --clear.\n"
1988   "\n"
1989   "Supported modes are:\n"
1990   "  --import  - Return a key to import a key into gpg-agent\n"
1991   "  --export  - Return a key to export a key from gpg-agent";
1992 static gpg_error_t
1993 cmd_keywrap_key (assuan_context_t ctx, char *line)
1994 {
1995   ctrl_t ctrl = assuan_get_pointer (ctx);
1996   gpg_error_t err = 0;
1997   int clearopt = has_option (line, "--clear");
1998
1999   if (ctrl->restricted)
2000     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2001
2002   assuan_begin_confidential (ctx);
2003   if (has_option (line, "--import"))
2004     {
2005       xfree (ctrl->server_local->import_key);
2006       if (clearopt)
2007         ctrl->server_local->import_key = NULL;
2008       else if (!(ctrl->server_local->import_key =
2009                  gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
2010         err = gpg_error_from_syserror ();
2011       else
2012         err = assuan_send_data (ctx, ctrl->server_local->import_key,
2013                                 KEYWRAP_KEYSIZE);
2014     }
2015   else if (has_option (line, "--export"))
2016     {
2017       xfree (ctrl->server_local->export_key);
2018       if (clearopt)
2019         ctrl->server_local->export_key = NULL;
2020       else if (!(ctrl->server_local->export_key =
2021             gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
2022         err = gpg_error_from_syserror ();
2023       else
2024         err = assuan_send_data (ctx, ctrl->server_local->export_key,
2025                                 KEYWRAP_KEYSIZE);
2026     }
2027   else
2028     err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for MODE");
2029   assuan_end_confidential (ctx);
2030
2031   return leave_cmd (ctx, err);
2032 }
2033
2034
2035 \f
2036 static const char hlp_import_key[] =
2037   "IMPORT_KEY [--unattended] [--force] [<cache_nonce>]\n"
2038   "\n"
2039   "Import a secret key into the key store.  The key is expected to be\n"
2040   "encrypted using the current session's key wrapping key (cf. command\n"
2041   "KEYWRAP_KEY) using the AESWRAP-128 algorithm.  This function takes\n"
2042   "no arguments but uses the inquiry \"KEYDATA\" to ask for the actual\n"
2043   "key data.  The unwrapped key must be a canonical S-expression.  The\n"
2044   "option --unattended tries to import the key as-is without any\n"
2045   "re-encryption.  Existing key can be overwritten with --force.";
2046 static gpg_error_t
2047 cmd_import_key (assuan_context_t ctx, char *line)
2048 {
2049   ctrl_t ctrl = assuan_get_pointer (ctx);
2050   gpg_error_t err;
2051   int opt_unattended;
2052   int force;
2053   unsigned char *wrappedkey = NULL;
2054   size_t wrappedkeylen;
2055   gcry_cipher_hd_t cipherhd = NULL;
2056   unsigned char *key = NULL;
2057   size_t keylen, realkeylen;
2058   char *passphrase = NULL;
2059   unsigned char *finalkey = NULL;
2060   size_t finalkeylen;
2061   unsigned char grip[20];
2062   gcry_sexp_t openpgp_sexp = NULL;
2063   char *cache_nonce = NULL;
2064   char *p;
2065
2066   if (ctrl->restricted)
2067     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2068
2069   if (!ctrl->server_local->import_key)
2070     {
2071       err = gpg_error (GPG_ERR_MISSING_KEY);
2072       goto leave;
2073     }
2074
2075   opt_unattended = has_option (line, "--unattended");
2076   force = has_option (line, "--force");
2077   line = skip_options (line);
2078
2079   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
2080     ;
2081   *p = '\0';
2082   if (*line)
2083     cache_nonce = xtrystrdup (line);
2084
2085   assuan_begin_confidential (ctx);
2086   err = assuan_inquire (ctx, "KEYDATA",
2087                         &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
2088   assuan_end_confidential (ctx);
2089   if (err)
2090     goto leave;
2091   if (wrappedkeylen < 24)
2092     {
2093       err = gpg_error (GPG_ERR_INV_LENGTH);
2094       goto leave;
2095     }
2096   keylen = wrappedkeylen - 8;
2097   key = xtrymalloc_secure (keylen);
2098   if (!key)
2099     {
2100       err = gpg_error_from_syserror ();
2101       goto leave;
2102     }
2103
2104   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2105                           GCRY_CIPHER_MODE_AESWRAP, 0);
2106   if (err)
2107     goto leave;
2108   err = gcry_cipher_setkey (cipherhd,
2109                             ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
2110   if (err)
2111     goto leave;
2112   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
2113   if (err)
2114     goto leave;
2115   gcry_cipher_close (cipherhd);
2116   cipherhd = NULL;
2117   xfree (wrappedkey);
2118   wrappedkey = NULL;
2119
2120   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
2121   if (!realkeylen)
2122     goto leave; /* Invalid canonical encoded S-expression.  */
2123
2124   err = keygrip_from_canon_sexp (key, realkeylen, grip);
2125   if (err)
2126     {
2127       /* This might be due to an unsupported S-expression format.
2128          Check whether this is openpgp-private-key and trigger that
2129          import code.  */
2130       if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
2131         {
2132           const char *tag;
2133           size_t taglen;
2134
2135           tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
2136           if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
2137             ;
2138           else
2139             {
2140               gcry_sexp_release (openpgp_sexp);
2141               openpgp_sexp = NULL;
2142             }
2143         }
2144       if (!openpgp_sexp)
2145         goto leave; /* Note that ERR is still set.  */
2146     }
2147
2148
2149   if (openpgp_sexp)
2150     {
2151       /* In most cases the key is encrypted and thus the conversion
2152          function from the OpenPGP format to our internal format will
2153          ask for a passphrase.  That passphrase will be returned and
2154          used to protect the key using the same code as for regular
2155          key import. */
2156
2157       xfree (key);
2158       key = NULL;
2159       err = convert_from_openpgp (ctrl, openpgp_sexp, force, grip,
2160                                   ctrl->server_local->keydesc, cache_nonce,
2161                                   &key, opt_unattended? NULL : &passphrase);
2162       if (err)
2163         goto leave;
2164       realkeylen = gcry_sexp_canon_len (key, 0, NULL, &err);
2165       if (!realkeylen)
2166         goto leave; /* Invalid canonical encoded S-expression.  */
2167       if (passphrase)
2168         {
2169           assert (!opt_unattended);
2170           if (!cache_nonce)
2171             {
2172               char buf[12];
2173               gcry_create_nonce (buf, 12);
2174               cache_nonce = bin2hex (buf, 12, NULL);
2175             }
2176           if (cache_nonce
2177               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2178                                    passphrase, CACHE_TTL_NONCE))
2179             assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2180         }
2181     }
2182   else if (opt_unattended)
2183     {
2184       err = set_error (GPG_ERR_ASS_PARAMETER,
2185                        "\"--unattended\" may only be used with OpenPGP keys");
2186       goto leave;
2187     }
2188   else
2189     {
2190       if (!force && !agent_key_available (grip))
2191         err = gpg_error (GPG_ERR_EEXIST);
2192       else
2193         {
2194           char *prompt = xtryasprintf
2195             (_("Please enter the passphrase to protect the "
2196                "imported object within the %s system."), GNUPG_NAME);
2197           if (!prompt)
2198             err = gpg_error_from_syserror ();
2199           else
2200             err = agent_ask_new_passphrase (ctrl, prompt, &passphrase);
2201           xfree (prompt);
2202         }
2203       if (err)
2204         goto leave;
2205     }
2206
2207   if (passphrase)
2208     {
2209       err = agent_protect (key, passphrase, &finalkey, &finalkeylen,
2210                            ctrl->s2k_count, -1);
2211       if (!err)
2212         err = agent_write_private_key (grip, finalkey, finalkeylen, force);
2213     }
2214   else
2215     err = agent_write_private_key (grip, key, realkeylen, force);
2216
2217  leave:
2218   gcry_sexp_release (openpgp_sexp);
2219   xfree (finalkey);
2220   xfree (passphrase);
2221   xfree (key);
2222   gcry_cipher_close (cipherhd);
2223   xfree (wrappedkey);
2224   xfree (cache_nonce);
2225   xfree (ctrl->server_local->keydesc);
2226   ctrl->server_local->keydesc = NULL;
2227   return leave_cmd (ctx, err);
2228 }
2229
2230
2231 \f
2232 static const char hlp_export_key[] =
2233   "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
2234   "\n"
2235   "Export a secret key from the key store.  The key will be encrypted\n"
2236   "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
2237   "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
2238   "prior to using this command.  The function takes the keygrip as argument.\n"
2239   "\n"
2240   "If --openpgp is used, the secret key material will be exported in RFC 4880\n"
2241   "compatible passphrase-protected form.  Without --openpgp, the secret key\n"
2242   "material will be exported in the clear (after prompting the user to unlock\n"
2243   "it, if needed).\n";
2244 static gpg_error_t
2245 cmd_export_key (assuan_context_t ctx, char *line)
2246 {
2247   ctrl_t ctrl = assuan_get_pointer (ctx);
2248   gpg_error_t err;
2249   unsigned char grip[20];
2250   gcry_sexp_t s_skey = NULL;
2251   unsigned char *key = NULL;
2252   size_t keylen;
2253   gcry_cipher_hd_t cipherhd = NULL;
2254   unsigned char *wrappedkey = NULL;
2255   size_t wrappedkeylen;
2256   int openpgp;
2257   char *cache_nonce;
2258   char *passphrase = NULL;
2259   unsigned char *shadow_info = NULL;
2260   char *pend;
2261   int c;
2262
2263   if (ctrl->restricted)
2264     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2265
2266   openpgp = has_option (line, "--openpgp");
2267   cache_nonce = option_value (line, "--cache-nonce");
2268   if (cache_nonce)
2269     {
2270       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
2271         ;
2272       c = *pend;
2273       *pend = '\0';
2274       cache_nonce = xtrystrdup (cache_nonce);
2275       *pend = c;
2276       if (!cache_nonce)
2277         {
2278           err = gpg_error_from_syserror ();
2279           goto leave;
2280         }
2281     }
2282   line = skip_options (line);
2283
2284   if (!ctrl->server_local->export_key)
2285     {
2286       err = set_error (GPG_ERR_MISSING_KEY, "did you run KEYWRAP_KEY ?");
2287       goto leave;
2288     }
2289
2290   err = parse_keygrip (ctx, line, grip);
2291   if (err)
2292     goto leave;
2293
2294   if (agent_key_available (grip))
2295     {
2296       err = gpg_error (GPG_ERR_NO_SECKEY);
2297       goto leave;
2298     }
2299
2300   /* Get the key from the file.  With the openpgp flag we also ask for
2301      the passphrase so that we can use it to re-encrypt it.  */
2302   err = agent_key_from_file (ctrl, cache_nonce,
2303                              ctrl->server_local->keydesc, grip,
2304                              &shadow_info, CACHE_MODE_IGNORE, NULL, &s_skey,
2305                              openpgp ? &passphrase : NULL);
2306   if (err)
2307     goto leave;
2308   if (shadow_info)
2309     {
2310       /* Key is on a smartcard.  */
2311       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2312       goto leave;
2313     }
2314
2315   if (openpgp)
2316     {
2317       /* The openpgp option changes the key format into the OpenPGP
2318          key transfer format.  The result is already a padded
2319          canonical S-expression.  */
2320       if (!passphrase)
2321         {
2322           err = agent_ask_new_passphrase
2323             (ctrl, _("This key (or subkey) is not protected with a passphrase."
2324                      "  Please enter a new passphrase to export it."),
2325              &passphrase);
2326           if (err)
2327             goto leave;
2328         }
2329       err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
2330       if (!err && passphrase)
2331         {
2332           if (!cache_nonce)
2333             {
2334               char buf[12];
2335               gcry_create_nonce (buf, 12);
2336               cache_nonce = bin2hex (buf, 12, NULL);
2337             }
2338           if (cache_nonce
2339               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2340                                    passphrase, CACHE_TTL_NONCE))
2341             {
2342               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2343               xfree (ctrl->server_local->last_cache_nonce);
2344               ctrl->server_local->last_cache_nonce = cache_nonce;
2345               cache_nonce = NULL;
2346             }
2347         }
2348     }
2349   else
2350     {
2351       /* Convert into a canonical S-expression and wrap that.  */
2352       err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
2353     }
2354   if (err)
2355     goto leave;
2356   gcry_sexp_release (s_skey);
2357   s_skey = NULL;
2358
2359   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2360                           GCRY_CIPHER_MODE_AESWRAP, 0);
2361   if (err)
2362     goto leave;
2363   err = gcry_cipher_setkey (cipherhd,
2364                             ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
2365   if (err)
2366     goto leave;
2367
2368   wrappedkeylen = keylen + 8;
2369   wrappedkey = xtrymalloc (wrappedkeylen);
2370   if (!wrappedkey)
2371     {
2372       err = gpg_error_from_syserror ();
2373       goto leave;
2374     }
2375
2376   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
2377   if (err)
2378     goto leave;
2379   xfree (key);
2380   key = NULL;
2381   gcry_cipher_close (cipherhd);
2382   cipherhd = NULL;
2383
2384   assuan_begin_confidential (ctx);
2385   err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
2386   assuan_end_confidential (ctx);
2387
2388
2389  leave:
2390   xfree (cache_nonce);
2391   xfree (passphrase);
2392   xfree (wrappedkey);
2393   gcry_cipher_close (cipherhd);
2394   xfree (key);
2395   gcry_sexp_release (s_skey);
2396   xfree (ctrl->server_local->keydesc);
2397   ctrl->server_local->keydesc = NULL;
2398   xfree (shadow_info);
2399
2400   return leave_cmd (ctx, err);
2401 }
2402
2403
2404 \f
2405 static const char hlp_delete_key[] =
2406   "DELETE_KEY [--force|--stub-only] <hexstring_with_keygrip>\n"
2407   "\n"
2408   "Delete a secret key from the key store.  If --force is used\n"
2409   "and a loopback pinentry is allowed, the agent will not ask\n"
2410   "the user for confirmation.  If --stub-only is used the key will\n"
2411   "only be deleted if it is a reference to a token.";
2412 static gpg_error_t
2413 cmd_delete_key (assuan_context_t ctx, char *line)
2414 {
2415   ctrl_t ctrl = assuan_get_pointer (ctx);
2416   gpg_error_t err;
2417   int force, stub_only;
2418   unsigned char grip[20];
2419
2420   if (ctrl->restricted)
2421     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2422
2423   force = has_option (line, "--force");
2424   stub_only = has_option (line, "--stub-only");
2425   line = skip_options (line);
2426
2427   /* If the use of a loopback pinentry has been disabled, we assume
2428    * that a silent deletion of keys shall also not be allowed.  */
2429   if (!opt.allow_loopback_pinentry)
2430     force = 0;
2431
2432   err = parse_keygrip (ctx, line, grip);
2433   if (err)
2434     goto leave;
2435
2436   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip,
2437                           force, stub_only);
2438   if (err)
2439     goto leave;
2440
2441  leave:
2442   xfree (ctrl->server_local->keydesc);
2443   ctrl->server_local->keydesc = NULL;
2444
2445   return leave_cmd (ctx, err);
2446 }
2447
2448
2449 \f
2450 #if SIZEOF_TIME_T > SIZEOF_UNSIGNED_LONG
2451 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010llu))"
2452 #else
2453 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010lu))"
2454 #endif
2455
2456 static const char hlp_keytocard[] =
2457   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2458   "\n";
2459 static gpg_error_t
2460 cmd_keytocard (assuan_context_t ctx, char *line)
2461 {
2462   ctrl_t ctrl = assuan_get_pointer (ctx);
2463   int force;
2464   gpg_error_t err = 0;
2465   unsigned char grip[20];
2466   gcry_sexp_t s_skey = NULL;
2467   unsigned char *keydata;
2468   size_t keydatalen;
2469   const char *serialno, *timestamp_str, *id;
2470   unsigned char *shadow_info = NULL;
2471   time_t timestamp;
2472
2473   if (ctrl->restricted)
2474     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2475
2476   force = has_option (line, "--force");
2477   line = skip_options (line);
2478
2479   err = parse_keygrip (ctx, line, grip);
2480   if (err)
2481     goto leave;
2482
2483   if (agent_key_available (grip))
2484     {
2485       err =gpg_error (GPG_ERR_NO_SECKEY);
2486       goto leave;
2487     }
2488
2489   /* Fixme: Replace the parsing code by split_fields().  */
2490   line += 40;
2491   while (*line && (*line == ' ' || *line == '\t'))
2492     line++;
2493   serialno = line;
2494   while (*line && (*line != ' ' && *line != '\t'))
2495     line++;
2496   if (!*line)
2497     {
2498       err = gpg_error (GPG_ERR_MISSING_VALUE);
2499       goto leave;
2500     }
2501   *line = '\0';
2502   line++;
2503   while (*line && (*line == ' ' || *line == '\t'))
2504     line++;
2505   id = line;
2506   while (*line && (*line != ' ' && *line != '\t'))
2507     line++;
2508   if (!*line)
2509     {
2510       err = gpg_error (GPG_ERR_MISSING_VALUE);
2511       goto leave;
2512     }
2513   *line = '\0';
2514   line++;
2515   while (*line && (*line == ' ' || *line == '\t'))
2516     line++;
2517   timestamp_str = line;
2518   while (*line && (*line != ' ' && *line != '\t'))
2519     line++;
2520   if (*line)
2521     *line = '\0';
2522
2523   if ((timestamp = isotime2epoch (timestamp_str)) == (time_t)(-1))
2524     {
2525       err = gpg_error (GPG_ERR_INV_TIME);
2526       goto leave;
2527     }
2528
2529   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2530                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2531                              &s_skey, NULL);
2532   if (err)
2533     {
2534       xfree (shadow_info);
2535       goto leave;
2536     }
2537   if (shadow_info)
2538     {
2539       /* Key is on a smartcard already.  */
2540       xfree (shadow_info);
2541       gcry_sexp_release (s_skey);
2542       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2543       goto leave;
2544     }
2545
2546   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2547   keydata = xtrymalloc_secure (keydatalen + 30);
2548   if (keydata == NULL)
2549     {
2550       err = gpg_error_from_syserror ();
2551       gcry_sexp_release (s_skey);
2552       goto leave;
2553     }
2554
2555   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2556   gcry_sexp_release (s_skey);
2557   keydatalen--;                 /* Decrement for last '\0'.  */
2558   /* Add timestamp "created-at" in the private key */
2559   snprintf (keydata+keydatalen-1, 30, KEYTOCARD_TIMESTAMP_FORMAT, timestamp);
2560   keydatalen += 10 + 19 - 1;
2561   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2562   xfree (keydata);
2563
2564  leave:
2565   return leave_cmd (ctx, err);
2566 }
2567
2568
2569 \f
2570 static const char hlp_getval[] =
2571   "GETVAL <key>\n"
2572   "\n"
2573   "Return the value for KEY from the special environment as created by\n"
2574   "PUTVAL.";
2575 static gpg_error_t
2576 cmd_getval (assuan_context_t ctx, char *line)
2577 {
2578   ctrl_t ctrl = assuan_get_pointer (ctx);
2579   int rc = 0;
2580   char *key = NULL;
2581   char *p;
2582   struct putval_item_s *vl;
2583
2584   if (ctrl->restricted)
2585     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2586
2587   for (p=line; *p == ' '; p++)
2588     ;
2589   key = p;
2590   p = strchr (key, ' ');
2591   if (p)
2592     {
2593       *p++ = 0;
2594       for (; *p == ' '; p++)
2595         ;
2596       if (*p)
2597         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2598     }
2599   if (!*key)
2600     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2601
2602
2603   for (vl=putval_list; vl; vl = vl->next)
2604     if ( !strcmp (vl->d, key) )
2605       break;
2606
2607   if (vl) /* Got an entry. */
2608     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2609   else
2610     return gpg_error (GPG_ERR_NO_DATA);
2611
2612   return leave_cmd (ctx, rc);
2613 }
2614
2615
2616 static const char hlp_putval[] =
2617   "PUTVAL <key> [<percent_escaped_value>]\n"
2618   "\n"
2619   "The gpg-agent maintains a kind of environment which may be used to\n"
2620   "store key/value pairs in it, so that they can be retrieved later.\n"
2621   "This may be used by helper daemons to daemonize themself on\n"
2622   "invocation and register them with gpg-agent.  Callers of the\n"
2623   "daemon's service may now first try connect to get the information\n"
2624   "for that service from gpg-agent through the GETVAL command and then\n"
2625   "try to connect to that daemon.  Only if that fails they may start\n"
2626   "an own instance of the service daemon. \n"
2627   "\n"
2628   "KEY is an arbitrary symbol with the same syntax rules as keys\n"
2629   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2630   "corresponding value; they should be similar to the values of\n"
2631   "envronment variables but gpg-agent does not enforce any\n"
2632   "restrictions.  If that value is not given any value under that KEY\n"
2633   "is removed from this special environment.";
2634 static gpg_error_t
2635 cmd_putval (assuan_context_t ctx, char *line)
2636 {
2637   ctrl_t ctrl = assuan_get_pointer (ctx);
2638   int rc = 0;
2639   char *key = NULL;
2640   char *value = NULL;
2641   size_t valuelen = 0;
2642   char *p;
2643   struct putval_item_s *vl, *vlprev;
2644
2645   if (ctrl->restricted)
2646     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2647
2648   for (p=line; *p == ' '; p++)
2649     ;
2650   key = p;
2651   p = strchr (key, ' ');
2652   if (p)
2653     {
2654       *p++ = 0;
2655       for (; *p == ' '; p++)
2656         ;
2657       if (*p)
2658         {
2659           value = p;
2660           p = strchr (value, ' ');
2661           if (p)
2662             *p = 0;
2663           valuelen = percent_plus_unescape_inplace (value, 0);
2664         }
2665     }
2666   if (!*key)
2667     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2668
2669
2670   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2671     if ( !strcmp (vl->d, key) )
2672       break;
2673
2674   if (vl) /* Delete old entry. */
2675     {
2676       if (vlprev)
2677         vlprev->next = vl->next;
2678       else
2679         putval_list = vl->next;
2680       xfree (vl);
2681     }
2682
2683   if (valuelen) /* Add entry. */
2684     {
2685       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2686       if (!vl)
2687         rc = gpg_error_from_syserror ();
2688       else
2689         {
2690           vl->len = valuelen;
2691           vl->off = strlen (key) + 1;
2692           strcpy (vl->d, key);
2693           memcpy (vl->d + vl->off, value, valuelen);
2694           vl->next = putval_list;
2695           putval_list = vl;
2696         }
2697     }
2698
2699   return leave_cmd (ctx, rc);
2700 }
2701
2702
2703
2704 \f
2705 static const char hlp_updatestartuptty[] =
2706   "UPDATESTARTUPTTY\n"
2707   "\n"
2708   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2709   "session.  This command is useful to pull future pinentries to\n"
2710   "another screen.  It is only required because there is no way in the\n"
2711   "ssh-agent protocol to convey this information.";
2712 static gpg_error_t
2713 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2714 {
2715   ctrl_t ctrl = assuan_get_pointer (ctx);
2716   gpg_error_t err = 0;
2717   session_env_t se;
2718   char *lc_ctype = NULL;
2719   char *lc_messages = NULL;
2720   int iterator;
2721   const char *name;
2722
2723   (void)line;
2724
2725   if (ctrl->restricted)
2726     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2727
2728   se = session_env_new ();
2729   if (!se)
2730     err = gpg_error_from_syserror ();
2731
2732   iterator = 0;
2733   while (!err && (name = session_env_list_stdenvnames (&iterator, NULL)))
2734     {
2735       const char *value = session_env_getenv (ctrl->session_env, name);
2736       if (value)
2737         err = session_env_setenv (se, name, value);
2738     }
2739
2740   if (!err && ctrl->lc_ctype)
2741     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2742       err = gpg_error_from_syserror ();
2743
2744   if (!err && ctrl->lc_messages)
2745     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2746       err = gpg_error_from_syserror ();
2747
2748   if (err)
2749     {
2750       session_env_release (se);
2751       xfree (lc_ctype);
2752       xfree (lc_messages);
2753     }
2754   else
2755     {
2756       session_env_release (opt.startup_env);
2757       opt.startup_env = se;
2758       xfree (opt.startup_lc_ctype);
2759       opt.startup_lc_ctype = lc_ctype;
2760       xfree (opt.startup_lc_messages);
2761       opt.startup_lc_messages = lc_messages;
2762     }
2763
2764   return err;
2765 }
2766
2767
2768 \f
2769 static const char hlp_killagent[] =
2770   "KILLAGENT\n"
2771   "\n"
2772   "Stop the agent.";
2773 static gpg_error_t
2774 cmd_killagent (assuan_context_t ctx, char *line)
2775 {
2776   ctrl_t ctrl = assuan_get_pointer (ctx);
2777
2778   (void)line;
2779
2780   if (ctrl->restricted)
2781     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2782
2783   ctrl->server_local->stopme = 1;
2784   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2785   return 0;
2786 }
2787
2788
2789 static const char hlp_reloadagent[] =
2790   "RELOADAGENT\n"
2791   "\n"
2792   "This command is an alternative to SIGHUP\n"
2793   "to reload the configuration.";
2794 static gpg_error_t
2795 cmd_reloadagent (assuan_context_t ctx, char *line)
2796 {
2797   ctrl_t ctrl = assuan_get_pointer (ctx);
2798
2799   (void)line;
2800
2801   if (ctrl->restricted)
2802     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2803
2804   agent_sighup_action ();
2805   return 0;
2806 }
2807
2808
2809 \f
2810 static const char hlp_getinfo[] =
2811   "GETINFO <what>\n"
2812   "\n"
2813   "Multipurpose function to return a variety of information.\n"
2814   "Supported values for WHAT are:\n"
2815   "\n"
2816   "  version         - Return the version of the program.\n"
2817   "  pid             - Return the process id of the server.\n"
2818   "  socket_name     - Return the name of the socket.\n"
2819   "  ssh_socket_name - Return the name of the ssh socket.\n"
2820   "  scd_running     - Return OK if the SCdaemon is already running.\n"
2821   "  s2k_time        - Return the time in milliseconds required for S2K.\n"
2822   "  s2k_count       - Return the standard S2K count.\n"
2823   "  s2k_count_cal   - Return the calibrated S2K count.\n"
2824   "  std_env_names   - List the names of the standard environment.\n"
2825   "  std_session_env - List the standard session environment.\n"
2826   "  std_startup_env - List the standard startup environment.\n"
2827   "  connections     - Return number of active connections.\n"
2828   "  jent_active     - Returns OK if Libgcrypt's JENT is active.\n"
2829   "  restricted      - Returns OK if the connection is in restricted mode.\n"
2830   "  cmd_has_option CMD OPT\n"
2831   "                  - Returns OK if command CMD has option OPT.\n";
2832 static gpg_error_t
2833 cmd_getinfo (assuan_context_t ctx, char *line)
2834 {
2835   ctrl_t ctrl = assuan_get_pointer (ctx);
2836   int rc = 0;
2837
2838   if (!strcmp (line, "version"))
2839     {
2840       const char *s = VERSION;
2841       rc = assuan_send_data (ctx, s, strlen (s));
2842     }
2843   else if (!strncmp (line, "cmd_has_option", 14)
2844            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2845     {
2846       char *cmd, *cmdopt;
2847       line += 14;
2848       while (*line == ' ' || *line == '\t')
2849         line++;
2850       if (!*line)
2851         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2852       else
2853         {
2854           cmd = line;
2855           while (*line && (*line != ' ' && *line != '\t'))
2856             line++;
2857           if (!*line)
2858             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2859           else
2860             {
2861               *line++ = 0;
2862               while (*line == ' ' || *line == '\t')
2863                 line++;
2864               if (!*line)
2865                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2866               else
2867                 {
2868                   cmdopt = line;
2869                   if (!command_has_option (cmd, cmdopt))
2870                     rc = gpg_error (GPG_ERR_GENERAL);
2871                 }
2872             }
2873         }
2874     }
2875   else if (!strcmp (line, "s2k_count"))
2876     {
2877       char numbuf[50];
2878
2879       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2880       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2881     }
2882   else if (!strcmp (line, "restricted"))
2883     {
2884       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2885     }
2886   else if (ctrl->restricted)
2887     {
2888       rc = gpg_error (GPG_ERR_FORBIDDEN);
2889     }
2890   /* All sub-commands below are not allowed in restricted mode.  */
2891   else if (!strcmp (line, "pid"))
2892     {
2893       char numbuf[50];
2894
2895       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2896       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2897     }
2898   else if (!strcmp (line, "socket_name"))
2899     {
2900       const char *s = get_agent_socket_name ();
2901
2902       if (s)
2903         rc = assuan_send_data (ctx, s, strlen (s));
2904       else
2905         rc = gpg_error (GPG_ERR_NO_DATA);
2906     }
2907   else if (!strcmp (line, "ssh_socket_name"))
2908     {
2909       const char *s = get_agent_ssh_socket_name ();
2910
2911       if (s)
2912         rc = assuan_send_data (ctx, s, strlen (s));
2913       else
2914         rc = gpg_error (GPG_ERR_NO_DATA);
2915     }
2916   else if (!strcmp (line, "scd_running"))
2917     {
2918       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2919     }
2920   else if (!strcmp (line, "std_env_names"))
2921     {
2922       int iterator;
2923       const char *name;
2924
2925       iterator = 0;
2926       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2927         {
2928           rc = assuan_send_data (ctx, name, strlen (name)+1);
2929           if (!rc)
2930             rc = assuan_send_data (ctx, NULL, 0);
2931           if (rc)
2932             break;
2933         }
2934     }
2935   else if (!strcmp (line, "std_session_env")
2936            || !strcmp (line, "std_startup_env"))
2937     {
2938       int iterator;
2939       const char *name, *value;
2940       char *string;
2941
2942       iterator = 0;
2943       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2944         {
2945           value = session_env_getenv_or_default
2946             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2947           if (value)
2948             {
2949               string = xtryasprintf ("%s=%s", name, value);
2950               if (!string)
2951                 rc = gpg_error_from_syserror ();
2952               else
2953                 {
2954                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2955                   if (!rc)
2956                     rc = assuan_send_data (ctx, NULL, 0);
2957                 }
2958               if (rc)
2959                 break;
2960             }
2961         }
2962     }
2963   else if (!strcmp (line, "connections"))
2964     {
2965       char numbuf[20];
2966
2967       snprintf (numbuf, sizeof numbuf, "%d",
2968                 get_agent_active_connection_count ());
2969       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2970     }
2971   else if (!strcmp (line, "jent_active"))
2972     {
2973 #if GCRYPT_VERSION_NUMBER >= 0x010800
2974       char *buf;
2975       char *fields[5];
2976
2977       buf = gcry_get_config (0, "rng-type");
2978       if (buf
2979           && split_fields_colon (buf, fields, DIM (fields)) >= 5
2980           && atoi (fields[4]) > 0)
2981         rc = 0;
2982       else
2983         rc = gpg_error (GPG_ERR_FALSE);
2984       gcry_free (buf);
2985 #else
2986       rc = gpg_error (GPG_ERR_FALSE);
2987 #endif
2988     }
2989   else if (!strcmp (line, "s2k_count_cal"))
2990     {
2991       char numbuf[50];
2992
2993       snprintf (numbuf, sizeof numbuf, "%lu", get_calibrated_s2k_count ());
2994       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2995     }
2996   else if (!strcmp (line, "s2k_time"))
2997     {
2998       char numbuf[50];
2999
3000       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_time ());
3001       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
3002     }
3003   else
3004     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
3005   return rc;
3006 }
3007
3008
3009 \f
3010 /* This function is called by Libassuan to parse the OPTION command.
3011    It has been registered similar to the other Assuan commands.  */
3012 static gpg_error_t
3013 option_handler (assuan_context_t ctx, const char *key, const char *value)
3014 {
3015   ctrl_t ctrl = assuan_get_pointer (ctx);
3016   gpg_error_t err = 0;
3017
3018   if (!strcmp (key, "agent-awareness"))
3019     {
3020       /* The value is a version string telling us of which agent
3021          version the caller is aware of.  */
3022       ctrl->server_local->allow_fully_canceled =
3023         gnupg_compare_version (value, "2.1.0");
3024     }
3025   else if (ctrl->restricted)
3026     {
3027       err = gpg_error (GPG_ERR_FORBIDDEN);
3028     }
3029   /* All options below are not allowed in restricted mode.  */
3030   else if (!strcmp (key, "putenv"))
3031     {
3032       /* Change the session's environment to be used for the
3033          Pinentry.  Valid values are:
3034           <NAME>            Delete envvar NAME
3035           <KEY>=            Set envvar NAME to the empty string
3036           <KEY>=<VALUE>     Set envvar NAME to VALUE
3037       */
3038       err = session_env_putenv (ctrl->session_env, value);
3039     }
3040   else if (!strcmp (key, "display"))
3041     {
3042       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
3043     }
3044   else if (!strcmp (key, "ttyname"))
3045     {
3046       if (!opt.keep_tty)
3047         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
3048     }
3049   else if (!strcmp (key, "ttytype"))
3050     {
3051       if (!opt.keep_tty)
3052         err = session_env_setenv (ctrl->session_env, "TERM", value);
3053     }
3054   else if (!strcmp (key, "lc-ctype"))
3055     {
3056       if (ctrl->lc_ctype)
3057         xfree (ctrl->lc_ctype);
3058       ctrl->lc_ctype = xtrystrdup (value);
3059       if (!ctrl->lc_ctype)
3060         return out_of_core ();
3061     }
3062   else if (!strcmp (key, "lc-messages"))
3063     {
3064       if (ctrl->lc_messages)
3065         xfree (ctrl->lc_messages);
3066       ctrl->lc_messages = xtrystrdup (value);
3067       if (!ctrl->lc_messages)
3068         return out_of_core ();
3069     }
3070   else if (!strcmp (key, "xauthority"))
3071     {
3072       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
3073     }
3074   else if (!strcmp (key, "pinentry-user-data"))
3075     {
3076       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
3077     }
3078   else if (!strcmp (key, "use-cache-for-signing"))
3079     ctrl->server_local->use_cache_for_signing = *value? !!atoi (value) : 0;
3080   else if (!strcmp (key, "allow-pinentry-notify"))
3081     ctrl->server_local->allow_pinentry_notify = 1;
3082   else if (!strcmp (key, "pinentry-mode"))
3083     {
3084       int tmp = parse_pinentry_mode (value);
3085       if (tmp == -1)
3086         err = gpg_error (GPG_ERR_INV_VALUE);
3087       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
3088         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3089       else
3090         ctrl->pinentry_mode = tmp;
3091     }
3092   else if (!strcmp (key, "cache-ttl-opt-preset"))
3093     {
3094       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
3095     }
3096   else if (!strcmp (key, "s2k-count"))
3097     {
3098       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
3099       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
3100         {
3101           ctrl->s2k_count = 0;
3102         }
3103     }
3104   else if (!strcmp (key, "pretend-request-origin"))
3105     {
3106       log_assert (!ctrl->restricted);
3107       switch (parse_request_origin (value))
3108         {
3109         case REQUEST_ORIGIN_LOCAL:   ctrl->restricted = 0; break;
3110         case REQUEST_ORIGIN_REMOTE:  ctrl->restricted = 1; break;
3111         case REQUEST_ORIGIN_BROWSER: ctrl->restricted = 2; break;
3112         default:
3113           err = gpg_error (GPG_ERR_INV_VALUE);
3114           /* Better pretend to be remote in case of a bad value.  */
3115           ctrl->restricted = 1;
3116           break;
3117         }
3118     }
3119   else
3120     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
3121
3122   return err;
3123 }
3124
3125
3126
3127 \f
3128 /* Called by libassuan after all commands. ERR is the error from the
3129    last assuan operation and not the one returned from the command. */
3130 static void
3131 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
3132 {
3133   ctrl_t ctrl = assuan_get_pointer (ctx);
3134
3135   (void)err;
3136
3137   /* Switch off any I/O monitor controlled logging pausing. */
3138   ctrl->server_local->pause_io_logging = 0;
3139 }
3140
3141
3142 /* This function is called by libassuan for all I/O.  We use it here
3143    to disable logging for the GETEVENTCOUNTER commands.  This is so
3144    that the debug output won't get cluttered by this primitive
3145    command.  */
3146 static unsigned int
3147 io_monitor (assuan_context_t ctx, void *hook, int direction,
3148             const char *line, size_t linelen)
3149 {
3150   ctrl_t ctrl = assuan_get_pointer (ctx);
3151
3152   (void) hook;
3153
3154   /* We want to suppress all Assuan log messages for connections from
3155    * self.  However, assuan_get_pid works only after
3156    * assuan_accept. Now, assuan_accept already logs a line ending with
3157    * the process id.  We use this hack here to get the peers pid so
3158    * that we can compare it to our pid.  We should add an assuan
3159    * function to return the pid for a file descriptor and use that to
3160    * detect connections to self.  */
3161   if (ctx && !ctrl->server_local->greeting_seen
3162       && direction == ASSUAN_IO_TO_PEER)
3163     {
3164       ctrl->server_local->greeting_seen = 1;
3165       if (linelen > 32
3166           && !strncmp (line, "OK Pleased to meet you, process ", 32)
3167           && strtoul (line+32, NULL, 10) == getpid ())
3168         return ASSUAN_IO_MONITOR_NOLOG;
3169     }
3170
3171
3172   /* Do not log self-connections.  This makes the log cleaner because
3173    * we won't see the check-our-own-socket calls.  */
3174   if (ctx && ctrl->server_local->connect_from_self)
3175     return ASSUAN_IO_MONITOR_NOLOG;
3176
3177   /* Note that we only check for the uppercase name.  This allows the user to
3178      see the logging for debugging if using a non-upercase command
3179      name. */
3180   if (ctx && direction == ASSUAN_IO_FROM_PEER
3181       && linelen >= 15
3182       && !strncmp (line, "GETEVENTCOUNTER", 15)
3183       && (linelen == 15 || spacep (line+15)))
3184     {
3185       ctrl->server_local->pause_io_logging = 1;
3186     }
3187
3188   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3189 }
3190
3191
3192 /* Return true if the command CMD implements the option OPT.  */
3193 static int
3194 command_has_option (const char *cmd, const char *cmdopt)
3195 {
3196   if (!strcmp (cmd, "GET_PASSPHRASE"))
3197     {
3198       if (!strcmp (cmdopt, "repeat"))
3199           return 1;
3200     }
3201
3202   return 0;
3203 }
3204
3205
3206 /* Tell Libassuan about our commands.  Also register the other Assuan
3207    handlers. */
3208 static int
3209 register_commands (assuan_context_t ctx)
3210 {
3211   static struct {
3212     const char *name;
3213     assuan_handler_t handler;
3214     const char * const help;
3215   } table[] = {
3216     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3217     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3218     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3219     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3220     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3221     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3222     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3223     { "SETHASH",        cmd_sethash,   hlp_sethash },
3224     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3225     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3226     { "GENKEY",         cmd_genkey,    hlp_genkey },
3227     { "READKEY",        cmd_readkey,   hlp_readkey },
3228     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3229     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3230     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3231     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3232     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3233     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3234     { "LEARN",          cmd_learn,     hlp_learn },
3235     { "PASSWD",         cmd_passwd,    hlp_passwd },
3236     { "INPUT",          NULL },
3237     { "OUTPUT",         NULL },
3238     { "SCD",            cmd_scd,       hlp_scd },
3239     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3240     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3241     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3242     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3243     { "GETVAL",         cmd_getval,    hlp_getval },
3244     { "PUTVAL",         cmd_putval,    hlp_putval },
3245     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3246     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3247     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3248     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3249     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3250     { NULL }
3251   };
3252   int i, rc;
3253
3254   for (i=0; table[i].name; i++)
3255     {
3256       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3257                                     table[i].help);
3258       if (rc)
3259         return rc;
3260     }
3261   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3262   assuan_register_reset_notify (ctx, reset_notify);
3263   assuan_register_option_handler (ctx, option_handler);
3264   return 0;
3265 }
3266
3267
3268 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3269    simple piper server, otherwise it is a regular server.  CTRL is the
3270    control structure for this connection; it has only the basic
3271    initialization. */
3272 void
3273 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3274 {
3275   int rc;
3276   assuan_context_t ctx = NULL;
3277
3278   if (ctrl->restricted)
3279     {
3280       if (agent_copy_startup_env (ctrl))
3281         return;
3282     }
3283
3284   rc = assuan_new (&ctx);
3285   if (rc)
3286     {
3287       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3288       agent_exit (2);
3289     }
3290
3291   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3292     {
3293       assuan_fd_t filedes[2];
3294
3295       filedes[0] = assuan_fdopen (0);
3296       filedes[1] = assuan_fdopen (1);
3297       rc = assuan_init_pipe_server (ctx, filedes);
3298     }
3299   else if (listen_fd != GNUPG_INVALID_FD)
3300     {
3301       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3302       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3303          this branch is currently not used.  */
3304     }
3305   else
3306     {
3307       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3308     }
3309   if (rc)
3310     {
3311       log_error ("failed to initialize the server: %s\n",
3312                  gpg_strerror(rc));
3313       agent_exit (2);
3314     }
3315   rc = register_commands (ctx);
3316   if (rc)
3317     {
3318       log_error ("failed to register commands with Assuan: %s\n",
3319                  gpg_strerror(rc));
3320       agent_exit (2);
3321     }
3322
3323   assuan_set_pointer (ctx, ctrl);
3324   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3325   ctrl->server_local->assuan_ctx = ctx;
3326   ctrl->server_local->use_cache_for_signing = 1;
3327
3328   ctrl->digest.raw_value = 0;
3329
3330   assuan_set_io_monitor (ctx, io_monitor, NULL);
3331   agent_set_progress_cb (progress_cb, ctrl);
3332
3333   for (;;)
3334     {
3335       pid_t client_pid;
3336
3337       rc = assuan_accept (ctx);
3338       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3339         {
3340           break;
3341         }
3342       else if (rc)
3343         {
3344           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3345           break;
3346         }
3347
3348       client_pid = assuan_get_pid (ctx);
3349       ctrl->server_local->connect_from_self = (client_pid == getpid ());
3350       if (client_pid != ASSUAN_INVALID_PID)
3351         ctrl->client_pid = (unsigned long)client_pid;
3352       else
3353         ctrl->client_pid = 0;
3354
3355       rc = assuan_process (ctx);
3356       if (rc)
3357         {
3358           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3359           continue;
3360         }
3361     }
3362
3363   /* Reset the nonce caches.  */
3364   clear_nonce_cache (ctrl);
3365
3366   /* Reset the SCD if needed. */
3367   agent_reset_scd (ctrl);
3368
3369   /* Reset the pinentry (in case of popup messages). */
3370   agent_reset_query (ctrl);
3371
3372   /* Cleanup.  */
3373   assuan_release (ctx);
3374   xfree (ctrl->server_local->keydesc);
3375   xfree (ctrl->server_local->import_key);
3376   xfree (ctrl->server_local->export_key);
3377   if (ctrl->server_local->stopme)
3378     agent_exit (0);
3379   xfree (ctrl->server_local);
3380   ctrl->server_local = NULL;
3381 }
3382
3383
3384 /* Helper for the pinentry loopback mode.  It merely passes the
3385    parameters on to the client.  */
3386 gpg_error_t
3387 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3388                   unsigned char **buffer, size_t *size,
3389                   size_t max_length)
3390 {
3391   gpg_error_t rc;
3392   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3393
3394   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3395   if (rc)
3396     return rc;
3397
3398   assuan_begin_confidential (ctx);
3399   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3400   assuan_end_confidential (ctx);
3401   return rc;
3402 }