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