dfbb83194ce0902f602ebe44ec874e93003879a6
[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 thee 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] [<cache_nonce>]\n"
861   "\n"
862   "Generate a new key, store the secret part and return the public\n"
863   "part.  Here is an example transaction:\n"
864   "\n"
865   "  C: GENKEY\n"
866   "  S: INQUIRE KEYPARAM\n"
867   "  C: D (genkey (rsa (nbits  2048)))\n"
868   "  C: END\n"
869   "  S: D (public-key\n"
870   "  S: D   (rsa (n 326487324683264) (e 10001)))\n"
871   "  S: OK key created\n"
872   "\n"
873   "When the --preset option is used the passphrase for the generated\n"
874   "key will be added to the cache.  When --inq-passwd is used an inquire\n"
875   "with the keyword NEWPASSWD is used to request the passphrase for the\n"
876   "new key.\n";
877 static gpg_error_t
878 cmd_genkey (assuan_context_t ctx, char *line)
879 {
880   ctrl_t ctrl = assuan_get_pointer (ctx);
881   int rc;
882   int no_protection;
883   unsigned char *value;
884   size_t valuelen;
885   unsigned char *newpasswd = NULL;
886   membuf_t outbuf;
887   char *cache_nonce = NULL;
888   int opt_preset;
889   int opt_inq_passwd;
890   size_t n;
891   char *p;
892
893   if (ctrl->restricted)
894     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
895
896   no_protection = has_option (line, "--no-protection");
897   opt_preset = has_option (line, "--preset");
898   opt_inq_passwd = has_option (line, "--inq-passwd");
899   line = skip_options (line);
900
901   p = line;
902   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
903     ;
904   *p = '\0';
905   if (*line)
906     cache_nonce = xtrystrdup (line);
907
908   /* First inquire the parameters */
909   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_KEYPARAM);
910   if (!rc)
911     rc = assuan_inquire (ctx, "KEYPARAM", &value, &valuelen, MAXLEN_KEYPARAM);
912   if (rc)
913     return rc;
914
915   init_membuf (&outbuf, 512);
916
917   /* If requested, ask for the password to be used for the key.  If
918      this is not used the regular Pinentry mechanism is used.  */
919   if (opt_inq_passwd && !no_protection)
920     {
921       /* (N is used as a dummy) */
922       assuan_begin_confidential (ctx);
923       rc = assuan_inquire (ctx, "NEWPASSWD", &newpasswd, &n, 256);
924       assuan_end_confidential (ctx);
925       if (rc)
926         goto leave;
927       if (!*newpasswd)
928         {
929           /* Empty password given - switch to no-protection mode.  */
930           xfree (newpasswd);
931           newpasswd = NULL;
932           no_protection = 1;
933         }
934
935     }
936
937   rc = agent_genkey (ctrl, cache_nonce, (char*)value, valuelen, no_protection,
938                      newpasswd, opt_preset, &outbuf);
939
940  leave:
941   if (newpasswd)
942     {
943       /* Assuan_inquire does not allow us to read into secure memory
944          thus we need to wipe it ourself.  */
945       wipememory (newpasswd, strlen (newpasswd));
946       xfree (newpasswd);
947     }
948   xfree (value);
949   if (rc)
950     clear_outbuf (&outbuf);
951   else
952     rc = write_and_clear_outbuf (ctx, &outbuf);
953   xfree (cache_nonce);
954   return leave_cmd (ctx, rc);
955 }
956
957
958
959 \f
960 static const char hlp_readkey[] =
961   "READKEY <hexstring_with_keygrip>\n"
962   "\n"
963   "Return the public key for the given keygrip.";
964 static gpg_error_t
965 cmd_readkey (assuan_context_t ctx, char *line)
966 {
967   ctrl_t ctrl = assuan_get_pointer (ctx);
968   int rc;
969   unsigned char grip[20];
970   gcry_sexp_t s_pkey = NULL;
971
972   if (ctrl->restricted)
973     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
974
975   rc = parse_keygrip (ctx, line, grip);
976   if (rc)
977     return rc; /* Return immediately as this is already an Assuan error code.*/
978
979   rc = agent_public_key_from_file (ctrl, grip, &s_pkey);
980   if (!rc)
981     {
982       size_t len;
983       unsigned char *buf;
984
985       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
986       assert (len);
987       buf = xtrymalloc (len);
988       if (!buf)
989         rc = gpg_error_from_syserror ();
990       else
991         {
992           len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, buf, len);
993           assert (len);
994           rc = assuan_send_data (ctx, buf, len);
995           xfree (buf);
996         }
997       gcry_sexp_release (s_pkey);
998     }
999
1000   return leave_cmd (ctx, rc);
1001 }
1002
1003
1004 \f
1005 static const char hlp_keyinfo[] =
1006   "KEYINFO [--[ssh-]list] [--data] [--ssh-fpr] [--with-ssh] <keygrip>\n"
1007   "\n"
1008   "Return information about the key specified by the KEYGRIP.  If the\n"
1009   "key is not available GPG_ERR_NOT_FOUND is returned.  If the option\n"
1010   "--list is given the keygrip is ignored and information about all\n"
1011   "available keys are returned.  If --ssh-list is given information\n"
1012   "about all keys listed in the sshcontrol are returned.  With --with-ssh\n"
1013   "information from sshcontrol is always added to the info. Unless --data\n"
1014   "is given, the information is returned as a status line using the format:\n"
1015   "\n"
1016   "  KEYINFO <keygrip> <type> <serialno> <idstr> <cached> <protection> <fpr>\n"
1017   "\n"
1018   "KEYGRIP is the keygrip.\n"
1019   "\n"
1020   "TYPE is describes the type of the key:\n"
1021   "    'D' - Regular key stored on disk,\n"
1022   "    'T' - Key is stored on a smartcard (token),\n"
1023   "    'X' - Unknown type,\n"
1024   "    '-' - Key is missing.\n"
1025   "\n"
1026   "SERIALNO is an ASCII string with the serial number of the\n"
1027   "         smartcard.  If the serial number is not known a single\n"
1028   "         dash '-' is used instead.\n"
1029   "\n"
1030   "IDSTR is the IDSTR used to distinguish keys on a smartcard.  If it\n"
1031   "      is not known a dash is used instead.\n"
1032   "\n"
1033   "CACHED is 1 if the passphrase for the key was found in the key cache.\n"
1034   "       If not, a '-' is used instead.\n"
1035   "\n"
1036   "PROTECTION describes the key protection type:\n"
1037   "    'P' - The key is protected with a passphrase,\n"
1038   "    'C' - The key is not protected,\n"
1039   "    '-' - Unknown protection.\n"
1040   "\n"
1041   "FPR returns the formatted ssh-style fingerprint of the key.  It is only\n"
1042   "    printed if the option --ssh-fpr has been used.  It defaults to '-'.\n"
1043   "\n"
1044   "TTL is the TTL in seconds for that key or '-' if n/a.\n"
1045   "\n"
1046   "FLAGS is a word consisting of one-letter flags:\n"
1047   "      'D' - The key has been disabled,\n"
1048   "      'S' - The key is listed in sshcontrol (requires --with-ssh),\n"
1049   "      'c' - Use of the key needs to be confirmed,\n"
1050   "      '-' - No flags given.\n"
1051   "\n"
1052   "More information may be added in the future.";
1053 static gpg_error_t
1054 do_one_keyinfo (ctrl_t ctrl, const unsigned char *grip, assuan_context_t ctx,
1055                 int data, int with_ssh_fpr, int in_ssh,
1056                 int ttl, int disabled, int confirm)
1057 {
1058   gpg_error_t err;
1059   char hexgrip[40+1];
1060   char *fpr = NULL;
1061   int keytype;
1062   unsigned char *shadow_info = NULL;
1063   char *serialno = NULL;
1064   char *idstr = NULL;
1065   const char *keytypestr;
1066   const char *cached;
1067   const char *protectionstr;
1068   char *pw;
1069   int missing_key = 0;
1070   char ttlbuf[20];
1071   char flagsbuf[5];
1072
1073   err = agent_key_info_from_file (ctrl, grip, &keytype, &shadow_info);
1074   if (err)
1075     {
1076       if (in_ssh && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1077         missing_key = 1;
1078       else
1079         goto leave;
1080     }
1081
1082   /* Reformat the grip so that we use uppercase as good style. */
1083   bin2hex (grip, 20, hexgrip);
1084
1085   if (ttl > 0)
1086     snprintf (ttlbuf, sizeof ttlbuf, "%d", ttl);
1087   else
1088     strcpy (ttlbuf, "-");
1089
1090   *flagsbuf = 0;
1091   if (disabled)
1092     strcat (flagsbuf, "D");
1093   if (in_ssh)
1094     strcat (flagsbuf, "S");
1095   if (confirm)
1096     strcat (flagsbuf, "c");
1097   if (!*flagsbuf)
1098     strcpy (flagsbuf, "-");
1099
1100
1101   if (missing_key)
1102     {
1103       protectionstr = "-"; keytypestr = "-";
1104     }
1105   else
1106     {
1107       switch (keytype)
1108         {
1109         case PRIVATE_KEY_CLEAR:
1110         case PRIVATE_KEY_OPENPGP_NONE:
1111           protectionstr = "C"; keytypestr = "D";
1112           break;
1113         case PRIVATE_KEY_PROTECTED: protectionstr = "P"; keytypestr = "D";
1114           break;
1115         case PRIVATE_KEY_SHADOWED: protectionstr = "-"; keytypestr = "T";
1116           break;
1117         default: protectionstr = "-"; keytypestr = "X";
1118           break;
1119         }
1120     }
1121
1122   /* Compute the ssh fingerprint if requested.  */
1123   if (with_ssh_fpr)
1124     {
1125       gcry_sexp_t key;
1126
1127       if (!agent_raw_key_from_file (ctrl, grip, &key))
1128         {
1129           ssh_get_fingerprint_string (key, &fpr);
1130           gcry_sexp_release (key);
1131         }
1132     }
1133
1134   /* Here we have a little race by doing the cache check separately
1135      from the retrieval function.  Given that the cache flag is only a
1136      hint, it should not really matter.  */
1137   pw = agent_get_cache (hexgrip, CACHE_MODE_NORMAL);
1138   cached = pw ? "1" : "-";
1139   xfree (pw);
1140
1141   if (shadow_info)
1142     {
1143       err = parse_shadow_info (shadow_info, &serialno, &idstr, NULL);
1144       if (err)
1145         goto leave;
1146     }
1147
1148   if (!data)
1149     err = agent_write_status (ctrl, "KEYINFO",
1150                               hexgrip,
1151                               keytypestr,
1152                               serialno? serialno : "-",
1153                               idstr? idstr : "-",
1154                               cached,
1155                               protectionstr,
1156                               fpr? fpr : "-",
1157                               ttlbuf,
1158                               flagsbuf,
1159                               NULL);
1160   else
1161     {
1162       char *string;
1163
1164       string = xtryasprintf ("%s %s %s %s %s %s %s %s %s\n",
1165                              hexgrip, keytypestr,
1166                              serialno? serialno : "-",
1167                              idstr? idstr : "-", cached, protectionstr,
1168                              fpr? fpr : "-",
1169                              ttlbuf,
1170                              flagsbuf);
1171       if (!string)
1172         err = gpg_error_from_syserror ();
1173       else
1174         err = assuan_send_data (ctx, string, strlen(string));
1175       xfree (string);
1176     }
1177
1178  leave:
1179   xfree (fpr);
1180   xfree (shadow_info);
1181   xfree (serialno);
1182   xfree (idstr);
1183   return err;
1184 }
1185
1186
1187 /* Entry int for the command KEYINFO.  This function handles the
1188    command option processing.  For details see hlp_keyinfo above.  */
1189 static gpg_error_t
1190 cmd_keyinfo (assuan_context_t ctx, char *line)
1191 {
1192   ctrl_t ctrl = assuan_get_pointer (ctx);
1193   int err;
1194   unsigned char grip[20];
1195   DIR *dir = NULL;
1196   int list_mode;
1197   int opt_data, opt_ssh_fpr, opt_with_ssh;
1198   ssh_control_file_t cf = NULL;
1199   char hexgrip[41];
1200   int disabled, ttl, confirm, is_ssh;
1201
1202   if (ctrl->restricted)
1203     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1204
1205   if (has_option (line, "--ssh-list"))
1206     list_mode = 2;
1207   else
1208     list_mode = has_option (line, "--list");
1209   opt_data = has_option (line, "--data");
1210   opt_ssh_fpr = has_option (line, "--ssh-fpr");
1211   opt_with_ssh = has_option (line, "--with-ssh");
1212   line = skip_options (line);
1213
1214   if (opt_with_ssh || list_mode == 2)
1215     cf = ssh_open_control_file ();
1216
1217   if (list_mode == 2)
1218     {
1219       if (cf)
1220         {
1221           while (!ssh_read_control_file (cf, hexgrip,
1222                                          &disabled, &ttl, &confirm))
1223             {
1224               if (hex2bin (hexgrip, grip, 20) < 0 )
1225                 continue; /* Bad hex string.  */
1226               err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, 1,
1227                                     ttl, disabled, confirm);
1228               if (err)
1229                 goto leave;
1230             }
1231         }
1232       err = 0;
1233     }
1234   else if (list_mode)
1235     {
1236       char *dirname;
1237       struct dirent *dir_entry;
1238
1239       dirname = make_filename_try (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
1240       if (!dirname)
1241         {
1242           err = gpg_error_from_syserror ();
1243           goto leave;
1244         }
1245       dir = opendir (dirname);
1246       if (!dir)
1247         {
1248           err = gpg_error_from_syserror ();
1249           xfree (dirname);
1250           goto leave;
1251         }
1252       xfree (dirname);
1253
1254       while ( (dir_entry = readdir (dir)) )
1255         {
1256           if (strlen (dir_entry->d_name) != 44
1257               || strcmp (dir_entry->d_name + 40, ".key"))
1258             continue;
1259           strncpy (hexgrip, dir_entry->d_name, 40);
1260           hexgrip[40] = 0;
1261
1262           if ( hex2bin (hexgrip, grip, 20) < 0 )
1263             continue; /* Bad hex string.  */
1264
1265           disabled = ttl = confirm = is_ssh = 0;
1266           if (opt_with_ssh)
1267             {
1268               err = ssh_search_control_file (cf, hexgrip,
1269                                              &disabled, &ttl, &confirm);
1270               if (!err)
1271                 is_ssh = 1;
1272               else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1273                 goto leave;
1274             }
1275
1276           err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1277                                 ttl, disabled, confirm);
1278           if (err)
1279             goto leave;
1280         }
1281       err = 0;
1282     }
1283   else
1284     {
1285       err = parse_keygrip (ctx, line, grip);
1286       if (err)
1287         goto leave;
1288       disabled = ttl = confirm = is_ssh = 0;
1289       if (opt_with_ssh)
1290         {
1291           err = ssh_search_control_file (cf, line,
1292                                          &disabled, &ttl, &confirm);
1293           if (!err)
1294             is_ssh = 1;
1295           else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1296             goto leave;
1297         }
1298
1299       err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1300                             ttl, disabled, confirm);
1301     }
1302
1303  leave:
1304   ssh_close_control_file (cf);
1305   if (dir)
1306     closedir (dir);
1307   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1308     leave_cmd (ctx, err);
1309   return err;
1310 }
1311
1312
1313 \f
1314 /* Helper for cmd_get_passphrase.  */
1315 static int
1316 send_back_passphrase (assuan_context_t ctx, int via_data, const char *pw)
1317 {
1318   size_t n;
1319   int rc;
1320
1321   assuan_begin_confidential (ctx);
1322   n = strlen (pw);
1323   if (via_data)
1324     rc = assuan_send_data (ctx, pw, n);
1325   else
1326     {
1327       char *p = xtrymalloc_secure (n*2+1);
1328       if (!p)
1329         rc = gpg_error_from_syserror ();
1330       else
1331         {
1332           bin2hex (pw, n, p);
1333           rc = assuan_set_okay_line (ctx, p);
1334           xfree (p);
1335         }
1336     }
1337   return rc;
1338 }
1339
1340
1341 static const char hlp_get_passphrase[] =
1342   "GET_PASSPHRASE [--data] [--check] [--no-ask] [--repeat[=N]]\n"
1343   "               [--qualitybar] <cache_id>\n"
1344   "               [<error_message> <prompt> <description>]\n"
1345   "\n"
1346   "This function is usually used to ask for a passphrase to be used\n"
1347   "for conventional encryption, but may also be used by programs which\n"
1348   "need specal handling of passphrases.  This command uses a syntax\n"
1349   "which helps clients to use the agent with minimum effort.  The\n"
1350   "agent either returns with an error or with a OK followed by the hex\n"
1351   "encoded passphrase.  Note that the length of the strings is\n"
1352   "implicitly limited by the maximum length of a command.\n"
1353   "\n"
1354   "If the option \"--data\" is used the passphrase is returned by usual\n"
1355   "data lines and not on the okay line.\n"
1356   "\n"
1357   "If the option \"--check\" is used the passphrase constraints checks as\n"
1358   "implemented by gpg-agent are applied.  A check is not done if the\n"
1359   "passphrase has been found in the cache.\n"
1360   "\n"
1361   "If the option \"--no-ask\" is used and the passphrase is not in the\n"
1362   "cache the user will not be asked to enter a passphrase but the error\n"
1363   "code GPG_ERR_NO_DATA is returned.  \n"
1364   "\n"
1365   "If the option \"--qualitybar\" is used a visual indication of the\n"
1366   "entered passphrase quality is shown.  (Unless no minimum passphrase\n"
1367   "length has been configured.)";
1368 static gpg_error_t
1369 cmd_get_passphrase (assuan_context_t ctx, char *line)
1370 {
1371   ctrl_t ctrl = assuan_get_pointer (ctx);
1372   int rc;
1373   char *pw;
1374   char *response;
1375   char *cacheid = NULL, *desc = NULL, *prompt = NULL, *errtext = NULL;
1376   const char *desc2 = _("Please re-enter this passphrase");
1377   char *p;
1378   int opt_data, opt_check, opt_no_ask, opt_qualbar;
1379   int opt_repeat = 0;
1380   char *entry_errtext = NULL;
1381
1382   if (ctrl->restricted)
1383     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1384
1385   opt_data = has_option (line, "--data");
1386   opt_check = has_option (line, "--check");
1387   opt_no_ask = has_option (line, "--no-ask");
1388   if (has_option_name (line, "--repeat"))
1389     {
1390       p = option_value (line, "--repeat");
1391       if (p)
1392         opt_repeat = atoi (p);
1393       else
1394         opt_repeat = 1;
1395     }
1396   opt_qualbar = has_option (line, "--qualitybar");
1397   line = skip_options (line);
1398
1399   cacheid = line;
1400   p = strchr (cacheid, ' ');
1401   if (p)
1402     {
1403       *p++ = 0;
1404       while (*p == ' ')
1405         p++;
1406       errtext = p;
1407       p = strchr (errtext, ' ');
1408       if (p)
1409         {
1410           *p++ = 0;
1411           while (*p == ' ')
1412             p++;
1413           prompt = p;
1414           p = strchr (prompt, ' ');
1415           if (p)
1416             {
1417               *p++ = 0;
1418               while (*p == ' ')
1419                 p++;
1420               desc = p;
1421               p = strchr (desc, ' ');
1422               if (p)
1423                 *p = 0; /* Ignore trailing garbage. */
1424             }
1425         }
1426     }
1427   if (!*cacheid || strlen (cacheid) > 50)
1428     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1429   if (!desc)
1430     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1431
1432   if (!strcmp (cacheid, "X"))
1433     cacheid = NULL;
1434   if (!strcmp (errtext, "X"))
1435     errtext = NULL;
1436   if (!strcmp (prompt, "X"))
1437     prompt = NULL;
1438   if (!strcmp (desc, "X"))
1439     desc = NULL;
1440
1441   pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_USER) : NULL;
1442   if (pw)
1443     {
1444       rc = send_back_passphrase (ctx, opt_data, pw);
1445       xfree (pw);
1446     }
1447   else if (opt_no_ask)
1448     rc = gpg_error (GPG_ERR_NO_DATA);
1449   else
1450     {
1451       /* Note, that we only need to replace the + characters and
1452          should leave the other escaping in place because the escaped
1453          string is send verbatim to the pinentry which does the
1454          unescaping (but not the + replacing) */
1455       if (errtext)
1456         plus_to_blank (errtext);
1457       if (prompt)
1458         plus_to_blank (prompt);
1459       if (desc)
1460         plus_to_blank (desc);
1461
1462     next_try:
1463       rc = agent_get_passphrase (ctrl, &response, desc, prompt,
1464                                  entry_errtext? entry_errtext:errtext,
1465                                  opt_qualbar, cacheid, CACHE_MODE_USER);
1466       xfree (entry_errtext);
1467       entry_errtext = NULL;
1468       if (!rc)
1469         {
1470           int i;
1471
1472           if (opt_check
1473               && check_passphrase_constraints (ctrl, response, &entry_errtext))
1474             {
1475               xfree (response);
1476               goto next_try;
1477             }
1478           for (i = 0; i < opt_repeat; i++)
1479             {
1480               char *response2;
1481
1482               if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
1483                 break;
1484
1485               rc = agent_get_passphrase (ctrl, &response2, desc2, prompt,
1486                                          errtext, 0,
1487                                          cacheid, CACHE_MODE_USER);
1488               if (rc)
1489                 break;
1490               if (strcmp (response2, response))
1491                 {
1492                   xfree (response2);
1493                   xfree (response);
1494                   entry_errtext = try_percent_escape
1495                     (_("does not match - try again"), NULL);
1496                   if (!entry_errtext)
1497                     {
1498                       rc = gpg_error_from_syserror ();
1499                       break;
1500                     }
1501                   goto next_try;
1502                 }
1503               xfree (response2);
1504             }
1505           if (!rc)
1506             {
1507               if (cacheid)
1508                 agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
1509               rc = send_back_passphrase (ctx, opt_data, response);
1510             }
1511           xfree (response);
1512         }
1513     }
1514
1515   return leave_cmd (ctx, rc);
1516 }
1517
1518
1519 static const char hlp_clear_passphrase[] =
1520   "CLEAR_PASSPHRASE [--mode=normal] <cache_id>\n"
1521   "\n"
1522   "may be used to invalidate the cache entry for a passphrase.  The\n"
1523   "function returns with OK even when there is no cached passphrase.\n"
1524   "The --mode=normal option is used to clear an entry for a cacheid\n"
1525   "added by the agent.\n";
1526 static gpg_error_t
1527 cmd_clear_passphrase (assuan_context_t ctx, char *line)
1528 {
1529   ctrl_t ctrl = assuan_get_pointer (ctx);
1530   char *cacheid = NULL;
1531   char *p;
1532   int opt_normal;
1533
1534   if (ctrl->restricted)
1535     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1536
1537   opt_normal = has_option (line, "--mode=normal");
1538   line = skip_options (line);
1539
1540   /* parse the stuff */
1541   for (p=line; *p == ' '; p++)
1542     ;
1543   cacheid = p;
1544   p = strchr (cacheid, ' ');
1545   if (p)
1546     *p = 0; /* ignore garbage */
1547   if (!*cacheid || strlen (cacheid) > 50)
1548     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1549
1550   agent_put_cache (cacheid, opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER,
1551                    NULL, 0);
1552
1553   agent_clear_passphrase (ctrl, cacheid,
1554                           opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER);
1555
1556   return 0;
1557 }
1558
1559
1560 static const char hlp_get_confirmation[] =
1561   "GET_CONFIRMATION <description>\n"
1562   "\n"
1563   "This command may be used to ask for a simple confirmation.\n"
1564   "DESCRIPTION is displayed along with a Okay and Cancel button.  This\n"
1565   "command uses a syntax which helps clients to use the agent with\n"
1566   "minimum effort.  The agent either returns with an error or with a\n"
1567   "OK.  Note, that the length of DESCRIPTION is implicitly limited by\n"
1568   "the maximum length of a command. DESCRIPTION should not contain\n"
1569   "any spaces, those must be encoded either percent escaped or simply\n"
1570   "as '+'.";
1571 static gpg_error_t
1572 cmd_get_confirmation (assuan_context_t ctx, char *line)
1573 {
1574   ctrl_t ctrl = assuan_get_pointer (ctx);
1575   int rc;
1576   char *desc = NULL;
1577   char *p;
1578
1579   if (ctrl->restricted)
1580     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1581
1582   /* parse the stuff */
1583   for (p=line; *p == ' '; p++)
1584     ;
1585   desc = p;
1586   p = strchr (desc, ' ');
1587   if (p)
1588     *p = 0; /* We ignore any garbage -may be later used for other args. */
1589
1590   if (!*desc)
1591     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1592
1593   if (!strcmp (desc, "X"))
1594     desc = NULL;
1595
1596   /* Note, that we only need to replace the + characters and should
1597      leave the other escaping in place because the escaped string is
1598      send verbatim to the pinentry which does the unescaping (but not
1599      the + replacing) */
1600   if (desc)
1601     plus_to_blank (desc);
1602
1603   rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
1604   return leave_cmd (ctx, rc);
1605 }
1606
1607
1608 \f
1609 static const char hlp_learn[] =
1610   "LEARN [--send] [--sendinfo] [--force]\n"
1611   "\n"
1612   "Learn something about the currently inserted smartcard.  With\n"
1613   "--sendinfo information about the card is returned; with --send\n"
1614   "the available certificates are returned as D lines; with --force\n"
1615   "private key storage will be updated by the result.";
1616 static gpg_error_t
1617 cmd_learn (assuan_context_t ctx, char *line)
1618 {
1619   ctrl_t ctrl = assuan_get_pointer (ctx);
1620   gpg_error_t err;
1621   int send, sendinfo, force;
1622
1623   send = has_option (line, "--send");
1624   sendinfo = send? 1 : has_option (line, "--sendinfo");
1625   force = has_option (line, "--force");
1626
1627   if (ctrl->restricted)
1628     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1629
1630   err = agent_handle_learn (ctrl, send, sendinfo? ctx : NULL, force);
1631   return leave_cmd (ctx, err);
1632 }
1633
1634
1635 \f
1636 static const char hlp_passwd[] =
1637   "PASSWD [--cache-nonce=<c>] [--passwd-nonce=<s>] [--preset]\n"
1638   "       [--verify] <hexkeygrip>\n"
1639   "\n"
1640   "Change the passphrase/PIN for the key identified by keygrip in LINE.  If\n"
1641   "--preset is used then the new passphrase will be added to the cache.\n"
1642   "If --verify is used the command asks for the passphrase and verifies\n"
1643   "that the passphrase valid.\n";
1644 static gpg_error_t
1645 cmd_passwd (assuan_context_t ctx, char *line)
1646 {
1647   ctrl_t ctrl = assuan_get_pointer (ctx);
1648   gpg_error_t err;
1649   int c;
1650   char *cache_nonce = NULL;
1651   char *passwd_nonce = NULL;
1652   unsigned char grip[20];
1653   gcry_sexp_t s_skey = NULL;
1654   unsigned char *shadow_info = NULL;
1655   char *passphrase = NULL;
1656   char *pend;
1657   int opt_preset, opt_verify;
1658
1659   if (ctrl->restricted)
1660     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1661
1662   opt_preset = has_option (line, "--preset");
1663   cache_nonce = option_value (line, "--cache-nonce");
1664   opt_verify = has_option (line, "--verify");
1665   if (cache_nonce)
1666     {
1667       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
1668         ;
1669       c = *pend;
1670       *pend = '\0';
1671       cache_nonce = xtrystrdup (cache_nonce);
1672       *pend = c;
1673       if (!cache_nonce)
1674         {
1675           err = gpg_error_from_syserror ();
1676           goto leave;
1677         }
1678     }
1679
1680   passwd_nonce = option_value (line, "--passwd-nonce");
1681   if (passwd_nonce)
1682     {
1683       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
1684         ;
1685       c = *pend;
1686       *pend = '\0';
1687       passwd_nonce = xtrystrdup (passwd_nonce);
1688       *pend = c;
1689       if (!passwd_nonce)
1690         {
1691           err = gpg_error_from_syserror ();
1692           goto leave;
1693         }
1694     }
1695
1696   line = skip_options (line);
1697
1698   err = parse_keygrip (ctx, line, grip);
1699   if (err)
1700     goto leave;
1701
1702   ctrl->in_passwd++;
1703   err = agent_key_from_file (ctrl,
1704                              opt_verify? NULL : cache_nonce,
1705                              ctrl->server_local->keydesc,
1706                              grip, &shadow_info, CACHE_MODE_IGNORE, NULL,
1707                              &s_skey, &passphrase);
1708   if (err)
1709     ;
1710   else if (shadow_info)
1711     {
1712       log_error ("changing a smartcard PIN is not yet supported\n");
1713       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1714     }
1715   else if (opt_verify)
1716     {
1717       /* All done.  */
1718     }
1719   else
1720     {
1721       char *newpass = NULL;
1722
1723       if (passwd_nonce)
1724         newpass = agent_get_cache (passwd_nonce, CACHE_MODE_NONCE);
1725       err = agent_protect_and_store (ctrl, s_skey, &newpass);
1726       if (!err && passphrase)
1727         {
1728           /* A passphrase existed on the old key and the change was
1729              successful.  Return a nonce for that old passphrase to
1730              let the caller try to unprotect the other subkeys with
1731              the same key.  */
1732           if (!cache_nonce)
1733             {
1734               char buf[12];
1735               gcry_create_nonce (buf, 12);
1736               cache_nonce = bin2hex (buf, 12, NULL);
1737             }
1738           if (cache_nonce
1739               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
1740                                    passphrase, CACHE_TTL_NONCE))
1741             {
1742               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
1743               xfree (ctrl->server_local->last_cache_nonce);
1744               ctrl->server_local->last_cache_nonce = cache_nonce;
1745               cache_nonce = NULL;
1746             }
1747           if (newpass)
1748             {
1749               /* If we have a new passphrase (which might be empty) we
1750                  store it under a passwd nonce so that the caller may
1751                  send that nonce again to use it for another key. */
1752               if (!passwd_nonce)
1753                 {
1754                   char buf[12];
1755                   gcry_create_nonce (buf, 12);
1756                   passwd_nonce = bin2hex (buf, 12, NULL);
1757                 }
1758               if (passwd_nonce
1759                   && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
1760                                        newpass, CACHE_TTL_NONCE))
1761                 {
1762                   assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1763                   xfree (ctrl->server_local->last_passwd_nonce);
1764                   ctrl->server_local->last_passwd_nonce = passwd_nonce;
1765                   passwd_nonce = NULL;
1766                 }
1767             }
1768         }
1769       if (!err && opt_preset)
1770         {
1771           char hexgrip[40+1];
1772           bin2hex(grip, 20, hexgrip);
1773           err = agent_put_cache (hexgrip, CACHE_MODE_ANY, newpass,
1774                                  ctrl->cache_ttl_opt_preset);
1775         }
1776       xfree (newpass);
1777     }
1778   ctrl->in_passwd--;
1779
1780   xfree (ctrl->server_local->keydesc);
1781   ctrl->server_local->keydesc = NULL;
1782
1783  leave:
1784   xfree (passphrase);
1785   gcry_sexp_release (s_skey);
1786   xfree (shadow_info);
1787   xfree (cache_nonce);
1788   return leave_cmd (ctx, err);
1789 }
1790
1791
1792 static const char hlp_preset_passphrase[] =
1793   "PRESET_PASSPHRASE [--inquire] <string_or_keygrip> <timeout> [<hexstring>]\n"
1794   "\n"
1795   "Set the cached passphrase/PIN for the key identified by the keygrip\n"
1796   "to passwd for the given time, where -1 means infinite and 0 means\n"
1797   "the default (currently only a timeout of -1 is allowed, which means\n"
1798   "to never expire it).  If passwd is not provided, ask for it via the\n"
1799   "pinentry module unless --inquire is passed in which case the passphrase\n"
1800   "is retrieved from the client via a server inquire.\n";
1801 static gpg_error_t
1802 cmd_preset_passphrase (assuan_context_t ctx, char *line)
1803 {
1804   ctrl_t ctrl = assuan_get_pointer (ctx);
1805   int rc;
1806   char *grip_clear = NULL;
1807   unsigned char *passphrase = NULL;
1808   int ttl;
1809   size_t len;
1810   int opt_inquire;
1811
1812   if (ctrl->restricted)
1813     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1814
1815   if (!opt.allow_preset_passphrase)
1816     return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
1817
1818   opt_inquire = has_option (line, "--inquire");
1819   line = skip_options (line);
1820   grip_clear = line;
1821   while (*line && (*line != ' ' && *line != '\t'))
1822     line++;
1823   if (!*line)
1824     return gpg_error (GPG_ERR_MISSING_VALUE);
1825   *line = '\0';
1826   line++;
1827   while (*line && (*line == ' ' || *line == '\t'))
1828     line++;
1829
1830   /* Currently, only infinite timeouts are allowed.  */
1831   ttl = -1;
1832   if (line[0] != '-' || line[1] != '1')
1833     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1834   line++;
1835   line++;
1836   while (!(*line != ' ' && *line != '\t'))
1837     line++;
1838
1839   /* Syntax check the hexstring.  */
1840   len = 0;
1841   rc = parse_hexstring (ctx, line, &len);
1842   if (rc)
1843     return rc;
1844   line[len] = '\0';
1845
1846   /* If there is a passphrase, use it.  Currently, a passphrase is
1847      required.  */
1848   if (*line)
1849     {
1850       if (opt_inquire)
1851         {
1852           rc = set_error (GPG_ERR_ASS_PARAMETER,
1853                           "both --inquire and passphrase specified");
1854           goto leave;
1855         }
1856
1857       /* Do in-place conversion.  */
1858       passphrase = line;
1859       if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
1860         rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
1861     }
1862   else if (opt_inquire)
1863     {
1864       /* Note that the passphrase will be truncated at any null byte and the
1865        * limit is 480 characters. */
1866       size_t maxlen = 480;
1867
1868       rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", maxlen);
1869       if (!rc)
1870         rc = assuan_inquire (ctx, "PASSPHRASE", &passphrase, &len, maxlen);
1871     }
1872   else
1873     rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
1874
1875   if (!rc)
1876     {
1877       rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1878       if (opt_inquire)
1879         xfree (passphrase);
1880     }
1881
1882 leave:
1883   return leave_cmd (ctx, rc);
1884 }
1885
1886
1887 \f
1888 static const char hlp_scd[] =
1889   "SCD <commands to pass to the scdaemon>\n"
1890   " \n"
1891   "This is a general quote command to redirect everything to the\n"
1892   "SCdaemon.";
1893 static gpg_error_t
1894 cmd_scd (assuan_context_t ctx, char *line)
1895 {
1896   ctrl_t ctrl = assuan_get_pointer (ctx);
1897   int rc;
1898
1899   if (ctrl->restricted)
1900     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1901
1902   rc = divert_generic_cmd (ctrl, line, ctx);
1903
1904   return rc;
1905 }
1906
1907
1908 \f
1909 static const char hlp_keywrap_key[] =
1910   "KEYWRAP_KEY [--clear] <mode>\n"
1911   "\n"
1912   "Return a key to wrap another key.  For now the key is returned\n"
1913   "verbatim and and thus makes not much sense because an eavesdropper on\n"
1914   "the gpg-agent connection will see the key as well as the wrapped key.\n"
1915   "However, this function may either be equipped with a public key\n"
1916   "mechanism or not used at all if the key is a pre-shared key.  In any\n"
1917   "case wrapping the import and export of keys is a requirement for\n"
1918   "certain cryptographic validations and thus useful.  The key persists\n"
1919   "until a RESET command but may be cleared using the option --clear.\n"
1920   "\n"
1921   "Supported modes are:\n"
1922   "  --import  - Return a key to import a key into gpg-agent\n"
1923   "  --export  - Return a key to export a key from gpg-agent";
1924 static gpg_error_t
1925 cmd_keywrap_key (assuan_context_t ctx, char *line)
1926 {
1927   ctrl_t ctrl = assuan_get_pointer (ctx);
1928   gpg_error_t err = 0;
1929   int clearopt = has_option (line, "--clear");
1930
1931   if (ctrl->restricted)
1932     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1933
1934   assuan_begin_confidential (ctx);
1935   if (has_option (line, "--import"))
1936     {
1937       xfree (ctrl->server_local->import_key);
1938       if (clearopt)
1939         ctrl->server_local->import_key = NULL;
1940       else if (!(ctrl->server_local->import_key =
1941                  gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
1942         err = gpg_error_from_syserror ();
1943       else
1944         err = assuan_send_data (ctx, ctrl->server_local->import_key,
1945                                 KEYWRAP_KEYSIZE);
1946     }
1947   else if (has_option (line, "--export"))
1948     {
1949       xfree (ctrl->server_local->export_key);
1950       if (clearopt)
1951         ctrl->server_local->export_key = NULL;
1952       else if (!(ctrl->server_local->export_key =
1953             gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
1954         err = gpg_error_from_syserror ();
1955       else
1956         err = assuan_send_data (ctx, ctrl->server_local->export_key,
1957                                 KEYWRAP_KEYSIZE);
1958     }
1959   else
1960     err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for MODE");
1961   assuan_end_confidential (ctx);
1962
1963   return leave_cmd (ctx, err);
1964 }
1965
1966
1967 \f
1968 static const char hlp_import_key[] =
1969   "IMPORT_KEY [--unattended] [--force] [<cache_nonce>]\n"
1970   "\n"
1971   "Import a secret key into the key store.  The key is expected to be\n"
1972   "encrypted using the current session's key wrapping key (cf. command\n"
1973   "KEYWRAP_KEY) using the AESWRAP-128 algorithm.  This function takes\n"
1974   "no arguments but uses the inquiry \"KEYDATA\" to ask for the actual\n"
1975   "key data.  The unwrapped key must be a canonical S-expression.  The\n"
1976   "option --unattended tries to import the key as-is without any\n"
1977   "re-encryption.  Existing key can be overwritten with --force.";
1978 static gpg_error_t
1979 cmd_import_key (assuan_context_t ctx, char *line)
1980 {
1981   ctrl_t ctrl = assuan_get_pointer (ctx);
1982   gpg_error_t err;
1983   int opt_unattended;
1984   int force;
1985   unsigned char *wrappedkey = NULL;
1986   size_t wrappedkeylen;
1987   gcry_cipher_hd_t cipherhd = NULL;
1988   unsigned char *key = NULL;
1989   size_t keylen, realkeylen;
1990   char *passphrase = NULL;
1991   unsigned char *finalkey = NULL;
1992   size_t finalkeylen;
1993   unsigned char grip[20];
1994   gcry_sexp_t openpgp_sexp = NULL;
1995   char *cache_nonce = NULL;
1996   char *p;
1997
1998   if (ctrl->restricted)
1999     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2000
2001   if (!ctrl->server_local->import_key)
2002     {
2003       err = gpg_error (GPG_ERR_MISSING_KEY);
2004       goto leave;
2005     }
2006
2007   opt_unattended = has_option (line, "--unattended");
2008   force = has_option (line, "--force");
2009   line = skip_options (line);
2010
2011   p = line;
2012   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
2013     ;
2014   *p = '\0';
2015   if (*line)
2016     cache_nonce = xtrystrdup (line);
2017
2018   assuan_begin_confidential (ctx);
2019   err = assuan_inquire (ctx, "KEYDATA",
2020                         &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
2021   assuan_end_confidential (ctx);
2022   if (err)
2023     goto leave;
2024   if (wrappedkeylen < 24)
2025     {
2026       err = gpg_error (GPG_ERR_INV_LENGTH);
2027       goto leave;
2028     }
2029   keylen = wrappedkeylen - 8;
2030   key = xtrymalloc_secure (keylen);
2031   if (!key)
2032     {
2033       err = gpg_error_from_syserror ();
2034       goto leave;
2035     }
2036
2037   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2038                           GCRY_CIPHER_MODE_AESWRAP, 0);
2039   if (err)
2040     goto leave;
2041   err = gcry_cipher_setkey (cipherhd,
2042                             ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
2043   if (err)
2044     goto leave;
2045   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
2046   if (err)
2047     goto leave;
2048   gcry_cipher_close (cipherhd);
2049   cipherhd = NULL;
2050   xfree (wrappedkey);
2051   wrappedkey = NULL;
2052
2053   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
2054   if (!realkeylen)
2055     goto leave; /* Invalid canonical encoded S-expression.  */
2056
2057   err = keygrip_from_canon_sexp (key, realkeylen, grip);
2058   if (err)
2059     {
2060       /* This might be due to an unsupported S-expression format.
2061          Check whether this is openpgp-private-key and trigger that
2062          import code.  */
2063       if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
2064         {
2065           const char *tag;
2066           size_t taglen;
2067
2068           tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
2069           if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
2070             ;
2071           else
2072             {
2073               gcry_sexp_release (openpgp_sexp);
2074               openpgp_sexp = NULL;
2075             }
2076         }
2077       if (!openpgp_sexp)
2078         goto leave; /* Note that ERR is still set.  */
2079     }
2080
2081
2082   if (openpgp_sexp)
2083     {
2084       /* In most cases the key is encrypted and thus the conversion
2085          function from the OpenPGP format to our internal format will
2086          ask for a passphrase.  That passphrase will be returned and
2087          used to protect the key using the same code as for regular
2088          key import. */
2089
2090       xfree (key);
2091       key = NULL;
2092       err = convert_from_openpgp (ctrl, openpgp_sexp, force, grip,
2093                                   ctrl->server_local->keydesc, cache_nonce,
2094                                   &key, opt_unattended? NULL : &passphrase);
2095       if (err)
2096         goto leave;
2097       realkeylen = gcry_sexp_canon_len (key, 0, NULL, &err);
2098       if (!realkeylen)
2099         goto leave; /* Invalid canonical encoded S-expression.  */
2100       if (passphrase)
2101         {
2102           assert (!opt_unattended);
2103           if (!cache_nonce)
2104             {
2105               char buf[12];
2106               gcry_create_nonce (buf, 12);
2107               cache_nonce = bin2hex (buf, 12, NULL);
2108             }
2109           if (cache_nonce
2110               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2111                                    passphrase, CACHE_TTL_NONCE))
2112             assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2113         }
2114     }
2115   else if (opt_unattended)
2116     {
2117       err = set_error (GPG_ERR_ASS_PARAMETER,
2118                        "\"--unattended\" may only be used with OpenPGP keys");
2119       goto leave;
2120     }
2121   else
2122     {
2123       if (!force && !agent_key_available (grip))
2124         err = gpg_error (GPG_ERR_EEXIST);
2125       else
2126         {
2127           char *prompt = xtryasprintf
2128             (_("Please enter the passphrase to protect the "
2129                "imported object within the %s system."), GNUPG_NAME);
2130           if (!prompt)
2131             err = gpg_error_from_syserror ();
2132           else
2133             err = agent_ask_new_passphrase (ctrl, prompt, &passphrase);
2134           xfree (prompt);
2135         }
2136       if (err)
2137         goto leave;
2138     }
2139
2140   if (passphrase)
2141     {
2142       err = agent_protect (key, passphrase, &finalkey, &finalkeylen,
2143                            ctrl->s2k_count, -1);
2144       if (!err)
2145         err = agent_write_private_key (grip, finalkey, finalkeylen, force);
2146     }
2147   else
2148     err = agent_write_private_key (grip, key, realkeylen, force);
2149
2150  leave:
2151   gcry_sexp_release (openpgp_sexp);
2152   xfree (finalkey);
2153   xfree (passphrase);
2154   xfree (key);
2155   gcry_cipher_close (cipherhd);
2156   xfree (wrappedkey);
2157   xfree (cache_nonce);
2158   xfree (ctrl->server_local->keydesc);
2159   ctrl->server_local->keydesc = NULL;
2160   return leave_cmd (ctx, err);
2161 }
2162
2163
2164 \f
2165 static const char hlp_export_key[] =
2166   "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
2167   "\n"
2168   "Export a secret key from the key store.  The key will be encrypted\n"
2169   "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
2170   "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
2171   "prior to using this command.  The function takes the keygrip as argument.\n";
2172 static gpg_error_t
2173 cmd_export_key (assuan_context_t ctx, char *line)
2174 {
2175   ctrl_t ctrl = assuan_get_pointer (ctx);
2176   gpg_error_t err;
2177   unsigned char grip[20];
2178   gcry_sexp_t s_skey = NULL;
2179   unsigned char *key = NULL;
2180   size_t keylen;
2181   gcry_cipher_hd_t cipherhd = NULL;
2182   unsigned char *wrappedkey = NULL;
2183   size_t wrappedkeylen;
2184   int openpgp;
2185   char *cache_nonce;
2186   char *passphrase = NULL;
2187   unsigned char *shadow_info = NULL;
2188   char *pend;
2189   int c;
2190
2191   if (ctrl->restricted)
2192     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2193
2194   openpgp = has_option (line, "--openpgp");
2195   cache_nonce = option_value (line, "--cache-nonce");
2196   if (cache_nonce)
2197     {
2198       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
2199         ;
2200       c = *pend;
2201       *pend = '\0';
2202       cache_nonce = xtrystrdup (cache_nonce);
2203       *pend = c;
2204       if (!cache_nonce)
2205         {
2206           err = gpg_error_from_syserror ();
2207           goto leave;
2208         }
2209     }
2210   line = skip_options (line);
2211
2212   if (!ctrl->server_local->export_key)
2213     {
2214       err = set_error (GPG_ERR_MISSING_KEY, "did you run KEYWRAP_KEY ?");
2215       goto leave;
2216     }
2217
2218   err = parse_keygrip (ctx, line, grip);
2219   if (err)
2220     goto leave;
2221
2222   if (agent_key_available (grip))
2223     {
2224       err = gpg_error (GPG_ERR_NO_SECKEY);
2225       goto leave;
2226     }
2227
2228   /* Get the key from the file.  With the openpgp flag we also ask for
2229      the passphrase so that we can use it to re-encrypt it.  */
2230   err = agent_key_from_file (ctrl, cache_nonce,
2231                              ctrl->server_local->keydesc, grip,
2232                              &shadow_info, CACHE_MODE_IGNORE, NULL, &s_skey,
2233                              openpgp ? &passphrase : NULL);
2234   if (err)
2235     goto leave;
2236   if (shadow_info)
2237     {
2238       /* Key is on a smartcard.  */
2239       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2240       goto leave;
2241     }
2242
2243   if (openpgp)
2244     {
2245       /* The openpgp option changes the key format into the OpenPGP
2246          key transfer format.  The result is already a padded
2247          canonical S-expression.  */
2248       if (!passphrase)
2249         {
2250           err = agent_ask_new_passphrase
2251             (ctrl, _("This key (or subkey) is not protected with a passphrase."
2252                      "  Please enter a new passphrase to export it."),
2253              &passphrase);
2254           if (err)
2255             goto leave;
2256         }
2257       err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
2258       if (!err && passphrase)
2259         {
2260           if (!cache_nonce)
2261             {
2262               char buf[12];
2263               gcry_create_nonce (buf, 12);
2264               cache_nonce = bin2hex (buf, 12, NULL);
2265             }
2266           if (cache_nonce
2267               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2268                                    passphrase, CACHE_TTL_NONCE))
2269             {
2270               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2271               xfree (ctrl->server_local->last_cache_nonce);
2272               ctrl->server_local->last_cache_nonce = cache_nonce;
2273               cache_nonce = NULL;
2274             }
2275         }
2276     }
2277   else
2278     {
2279       /* Convert into a canonical S-expression and wrap that.  */
2280       err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
2281     }
2282   if (err)
2283     goto leave;
2284   gcry_sexp_release (s_skey);
2285   s_skey = NULL;
2286
2287   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2288                           GCRY_CIPHER_MODE_AESWRAP, 0);
2289   if (err)
2290     goto leave;
2291   err = gcry_cipher_setkey (cipherhd,
2292                             ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
2293   if (err)
2294     goto leave;
2295
2296   wrappedkeylen = keylen + 8;
2297   wrappedkey = xtrymalloc (wrappedkeylen);
2298   if (!wrappedkey)
2299     {
2300       err = gpg_error_from_syserror ();
2301       goto leave;
2302     }
2303
2304   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
2305   if (err)
2306     goto leave;
2307   xfree (key);
2308   key = NULL;
2309   gcry_cipher_close (cipherhd);
2310   cipherhd = NULL;
2311
2312   assuan_begin_confidential (ctx);
2313   err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
2314   assuan_end_confidential (ctx);
2315
2316
2317  leave:
2318   xfree (cache_nonce);
2319   xfree (passphrase);
2320   xfree (wrappedkey);
2321   gcry_cipher_close (cipherhd);
2322   xfree (key);
2323   gcry_sexp_release (s_skey);
2324   xfree (ctrl->server_local->keydesc);
2325   ctrl->server_local->keydesc = NULL;
2326   xfree (shadow_info);
2327
2328   return leave_cmd (ctx, err);
2329 }
2330
2331
2332 \f
2333 static const char hlp_delete_key[] =
2334   "DELETE_KEY [--force] <hexstring_with_keygrip>\n"
2335   "\n"
2336   "Delete a secret key from the key store.  If --force is used\n"
2337   "and a loopback pinentry is allowed, the agent will not ask\n"
2338   "the user for confirmation.";
2339 static gpg_error_t
2340 cmd_delete_key (assuan_context_t ctx, char *line)
2341 {
2342   ctrl_t ctrl = assuan_get_pointer (ctx);
2343   gpg_error_t err;
2344   int force;
2345   unsigned char grip[20];
2346
2347   if (ctrl->restricted)
2348     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2349
2350   force = has_option (line, "--force");
2351   line = skip_options (line);
2352
2353   /* If the use of a loopback pinentry has been disabled, we assume
2354    * that a silent deletion of keys shall also not be allowed.  */
2355   if (!opt.allow_loopback_pinentry)
2356     force = 0;
2357
2358   err = parse_keygrip (ctx, line, grip);
2359   if (err)
2360     goto leave;
2361
2362   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip, force );
2363   if (err)
2364     goto leave;
2365
2366  leave:
2367   xfree (ctrl->server_local->keydesc);
2368   ctrl->server_local->keydesc = NULL;
2369
2370   return leave_cmd (ctx, err);
2371 }
2372
2373
2374 \f
2375 static const char hlp_keytocard[] =
2376   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2377   "\n";
2378 static gpg_error_t
2379 cmd_keytocard (assuan_context_t ctx, char *line)
2380 {
2381   ctrl_t ctrl = assuan_get_pointer (ctx);
2382   int force;
2383   gpg_error_t err = 0;
2384   unsigned char grip[20];
2385   gcry_sexp_t s_skey = NULL;
2386   unsigned char *keydata;
2387   size_t keydatalen, timestamplen;
2388   const char *serialno, *timestamp_str, *id;
2389   unsigned char *shadow_info = NULL;
2390   time_t timestamp;
2391
2392   if (ctrl->restricted)
2393     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2394
2395   force = has_option (line, "--force");
2396   line = skip_options (line);
2397
2398   err = parse_keygrip (ctx, line, grip);
2399   if (err)
2400     return err;
2401
2402   if (agent_key_available (grip))
2403     return gpg_error (GPG_ERR_NO_SECKEY);
2404
2405   line += 40;
2406   while (*line && (*line == ' ' || *line == '\t'))
2407     line++;
2408   serialno = line;
2409   while (*line && (*line != ' ' && *line != '\t'))
2410     line++;
2411   if (!*line)
2412     return gpg_error (GPG_ERR_MISSING_VALUE);
2413   *line = '\0';
2414   line++;
2415   while (*line && (*line == ' ' || *line == '\t'))
2416     line++;
2417   id = line;
2418   while (*line && (*line != ' ' && *line != '\t'))
2419     line++;
2420   if (!*line)
2421     return gpg_error (GPG_ERR_MISSING_VALUE);
2422   *line = '\0';
2423   line++;
2424   while (*line && (*line == ' ' || *line == '\t'))
2425     line++;
2426   timestamp_str = line;
2427   while (*line && (*line != ' ' && *line != '\t'))
2428     line++;
2429   if (*line)
2430     *line = '\0';
2431   timestamplen = line - timestamp_str;
2432   if (timestamplen != 15)
2433     return gpg_error (GPG_ERR_INV_VALUE);
2434
2435   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2436                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2437                              &s_skey, NULL);
2438   if (err)
2439     {
2440       xfree (shadow_info);
2441       return err;
2442     }
2443   if (shadow_info)
2444     {
2445       /* Key is on a smartcard already.  */
2446       xfree (shadow_info);
2447       gcry_sexp_release (s_skey);
2448       return gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2449     }
2450
2451   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2452   keydata = xtrymalloc_secure (keydatalen + 30);
2453   if (keydata == NULL)
2454     {
2455       gcry_sexp_release (s_skey);
2456       return gpg_error_from_syserror ();
2457     }
2458
2459   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2460   gcry_sexp_release (s_skey);
2461   keydatalen--;                 /* Decrement for last '\0'.  */
2462   /* Add timestamp "created-at" in the private key */
2463   timestamp = isotime2epoch (timestamp_str);
2464   snprintf (keydata+keydatalen-1, 30, "(10:created-at10:%010lu))", timestamp);
2465   keydatalen += 10 + 19 - 1;
2466   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2467   xfree (keydata);
2468
2469   return leave_cmd (ctx, err);
2470 }
2471
2472
2473 \f
2474 static const char hlp_getval[] =
2475   "GETVAL <key>\n"
2476   "\n"
2477   "Return the value for KEY from the special environment as created by\n"
2478   "PUTVAL.";
2479 static gpg_error_t
2480 cmd_getval (assuan_context_t ctx, char *line)
2481 {
2482   ctrl_t ctrl = assuan_get_pointer (ctx);
2483   int rc = 0;
2484   char *key = NULL;
2485   char *p;
2486   struct putval_item_s *vl;
2487
2488   if (ctrl->restricted)
2489     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2490
2491   for (p=line; *p == ' '; p++)
2492     ;
2493   key = p;
2494   p = strchr (key, ' ');
2495   if (p)
2496     {
2497       *p++ = 0;
2498       for (; *p == ' '; p++)
2499         ;
2500       if (*p)
2501         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2502     }
2503   if (!*key)
2504     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2505
2506
2507   for (vl=putval_list; vl; vl = vl->next)
2508     if ( !strcmp (vl->d, key) )
2509       break;
2510
2511   if (vl) /* Got an entry. */
2512     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2513   else
2514     return gpg_error (GPG_ERR_NO_DATA);
2515
2516   return leave_cmd (ctx, rc);
2517 }
2518
2519
2520 static const char hlp_putval[] =
2521   "PUTVAL <key> [<percent_escaped_value>]\n"
2522   "\n"
2523   "The gpg-agent maintains a kind of environment which may be used to\n"
2524   "store key/value pairs in it, so that they can be retrieved later.\n"
2525   "This may be used by helper daemons to daemonize themself on\n"
2526   "invocation and register them with gpg-agent.  Callers of the\n"
2527   "daemon's service may now first try connect to get the information\n"
2528   "for that service from gpg-agent through the GETVAL command and then\n"
2529   "try to connect to that daemon.  Only if that fails they may start\n"
2530   "an own instance of the service daemon. \n"
2531   "\n"
2532   "KEY is an an arbitrary symbol with the same syntax rules as keys\n"
2533   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2534   "corresponding value; they should be similar to the values of\n"
2535   "envronment variables but gpg-agent does not enforce any\n"
2536   "restrictions.  If that value is not given any value under that KEY\n"
2537   "is removed from this special environment.";
2538 static gpg_error_t
2539 cmd_putval (assuan_context_t ctx, char *line)
2540 {
2541   ctrl_t ctrl = assuan_get_pointer (ctx);
2542   int rc = 0;
2543   char *key = NULL;
2544   char *value = NULL;
2545   size_t valuelen = 0;
2546   char *p;
2547   struct putval_item_s *vl, *vlprev;
2548
2549   if (ctrl->restricted)
2550     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2551
2552   for (p=line; *p == ' '; p++)
2553     ;
2554   key = p;
2555   p = strchr (key, ' ');
2556   if (p)
2557     {
2558       *p++ = 0;
2559       for (; *p == ' '; p++)
2560         ;
2561       if (*p)
2562         {
2563           value = p;
2564           p = strchr (value, ' ');
2565           if (p)
2566             *p = 0;
2567           valuelen = percent_plus_unescape_inplace (value, 0);
2568         }
2569     }
2570   if (!*key)
2571     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2572
2573
2574   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2575     if ( !strcmp (vl->d, key) )
2576       break;
2577
2578   if (vl) /* Delete old entry. */
2579     {
2580       if (vlprev)
2581         vlprev->next = vl->next;
2582       else
2583         putval_list = vl->next;
2584       xfree (vl);
2585     }
2586
2587   if (valuelen) /* Add entry. */
2588     {
2589       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2590       if (!vl)
2591         rc = gpg_error_from_syserror ();
2592       else
2593         {
2594           vl->len = valuelen;
2595           vl->off = strlen (key) + 1;
2596           strcpy (vl->d, key);
2597           memcpy (vl->d + vl->off, value, valuelen);
2598           vl->next = putval_list;
2599           putval_list = vl;
2600         }
2601     }
2602
2603   return leave_cmd (ctx, rc);
2604 }
2605
2606
2607
2608 \f
2609 static const char hlp_updatestartuptty[] =
2610   "UPDATESTARTUPTTY\n"
2611   "\n"
2612   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2613   "session.  This command is useful to pull future pinentries to\n"
2614   "another screen.  It is only required because there is no way in the\n"
2615   "ssh-agent protocol to convey this information.";
2616 static gpg_error_t
2617 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2618 {
2619   static const char *names[] =
2620     { "GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
2621   ctrl_t ctrl = assuan_get_pointer (ctx);
2622   gpg_error_t err = 0;
2623   session_env_t se;
2624   int idx;
2625   char *lc_ctype = NULL;
2626   char *lc_messages = NULL;
2627
2628   (void)line;
2629
2630   if (ctrl->restricted)
2631     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2632
2633   se = session_env_new ();
2634   if (!se)
2635     err = gpg_error_from_syserror ();
2636
2637   for (idx=0; !err && names[idx]; idx++)
2638     {
2639       const char *value = session_env_getenv (ctrl->session_env, names[idx]);
2640       if (value)
2641         err = session_env_setenv (se, names[idx], value);
2642     }
2643
2644   if (!err && ctrl->lc_ctype)
2645     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2646       err = gpg_error_from_syserror ();
2647
2648   if (!err && ctrl->lc_messages)
2649     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2650       err = gpg_error_from_syserror ();
2651
2652   if (err)
2653     {
2654       session_env_release (se);
2655       xfree (lc_ctype);
2656       xfree (lc_messages);
2657     }
2658   else
2659     {
2660       session_env_release (opt.startup_env);
2661       opt.startup_env = se;
2662       xfree (opt.startup_lc_ctype);
2663       opt.startup_lc_ctype = lc_ctype;
2664       xfree (opt.startup_lc_messages);
2665       opt.startup_lc_messages = lc_messages;
2666     }
2667
2668   return err;
2669 }
2670
2671
2672 \f
2673 static const char hlp_killagent[] =
2674   "KILLAGENT\n"
2675   "\n"
2676   "Stop the agent.";
2677 static gpg_error_t
2678 cmd_killagent (assuan_context_t ctx, char *line)
2679 {
2680   ctrl_t ctrl = assuan_get_pointer (ctx);
2681
2682   (void)line;
2683
2684   if (ctrl->restricted)
2685     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2686
2687   ctrl->server_local->stopme = 1;
2688   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2689   return 0;
2690 }
2691
2692
2693 static const char hlp_reloadagent[] =
2694   "RELOADAGENT\n"
2695   "\n"
2696   "This command is an alternative to SIGHUP\n"
2697   "to reload the configuration.";
2698 static gpg_error_t
2699 cmd_reloadagent (assuan_context_t ctx, char *line)
2700 {
2701   ctrl_t ctrl = assuan_get_pointer (ctx);
2702
2703   (void)line;
2704
2705   if (ctrl->restricted)
2706     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2707
2708   agent_sighup_action ();
2709   return 0;
2710 }
2711
2712
2713 \f
2714 static const char hlp_getinfo[] =
2715   "GETINFO <what>\n"
2716   "\n"
2717   "Multipurpose function to return a variety of information.\n"
2718   "Supported values for WHAT are:\n"
2719   "\n"
2720   "  version     - Return the version of the program.\n"
2721   "  pid         - Return the process id of the server.\n"
2722   "  socket_name - Return the name of the socket.\n"
2723   "  ssh_socket_name - Return the name of the ssh socket.\n"
2724   "  scd_running - Return OK if the SCdaemon is already running.\n"
2725   "  s2k_count   - Return the calibrated S2K count.\n"
2726   "  std_env_names   - List the names of the standard environment.\n"
2727   "  std_session_env - List the standard session environment.\n"
2728   "  std_startup_env - List the standard startup environment.\n"
2729   "  cmd_has_option\n"
2730   "              - Returns OK if the command CMD implements the option OPT.\n"
2731   "  restricted  - Returns OK if the connection is in restricted mode.\n";
2732 static gpg_error_t
2733 cmd_getinfo (assuan_context_t ctx, char *line)
2734 {
2735   ctrl_t ctrl = assuan_get_pointer (ctx);
2736   int rc = 0;
2737
2738   if (!strcmp (line, "version"))
2739     {
2740       const char *s = VERSION;
2741       rc = assuan_send_data (ctx, s, strlen (s));
2742     }
2743   else if (!strncmp (line, "cmd_has_option", 14)
2744            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2745     {
2746       char *cmd, *cmdopt;
2747       line += 14;
2748       while (*line == ' ' || *line == '\t')
2749         line++;
2750       if (!*line)
2751         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2752       else
2753         {
2754           cmd = line;
2755           while (*line && (*line != ' ' && *line != '\t'))
2756             line++;
2757           if (!*line)
2758             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2759           else
2760             {
2761               *line++ = 0;
2762               while (*line == ' ' || *line == '\t')
2763                 line++;
2764               if (!*line)
2765                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2766               else
2767                 {
2768                   cmdopt = line;
2769                   if (!command_has_option (cmd, cmdopt))
2770                     rc = gpg_error (GPG_ERR_GENERAL);
2771                 }
2772             }
2773         }
2774     }
2775   else if (!strcmp (line, "s2k_count"))
2776     {
2777       char numbuf[50];
2778
2779       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2780       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2781     }
2782   else if (!strcmp (line, "restricted"))
2783     {
2784       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2785     }
2786   else if (ctrl->restricted)
2787     {
2788       rc = gpg_error (GPG_ERR_FORBIDDEN);
2789     }
2790   /* All sub-commands below are not allowed in restricted mode.  */
2791   else if (!strcmp (line, "pid"))
2792     {
2793       char numbuf[50];
2794
2795       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2796       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2797     }
2798   else if (!strcmp (line, "socket_name"))
2799     {
2800       const char *s = get_agent_socket_name ();
2801
2802       if (s)
2803         rc = assuan_send_data (ctx, s, strlen (s));
2804       else
2805         rc = gpg_error (GPG_ERR_NO_DATA);
2806     }
2807   else if (!strcmp (line, "ssh_socket_name"))
2808     {
2809       const char *s = get_agent_ssh_socket_name ();
2810
2811       if (s)
2812         rc = assuan_send_data (ctx, s, strlen (s));
2813       else
2814         rc = gpg_error (GPG_ERR_NO_DATA);
2815     }
2816   else if (!strcmp (line, "scd_running"))
2817     {
2818       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2819     }
2820   else if (!strcmp (line, "std_env_names"))
2821     {
2822       int iterator;
2823       const char *name;
2824
2825       iterator = 0;
2826       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2827         {
2828           rc = assuan_send_data (ctx, name, strlen (name)+1);
2829           if (!rc)
2830             rc = assuan_send_data (ctx, NULL, 0);
2831           if (rc)
2832             break;
2833         }
2834     }
2835   else if (!strcmp (line, "std_session_env")
2836            || !strcmp (line, "std_startup_env"))
2837     {
2838       int iterator;
2839       const char *name, *value;
2840       char *string;
2841
2842       iterator = 0;
2843       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2844         {
2845           value = session_env_getenv_or_default
2846             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2847           if (value)
2848             {
2849               string = xtryasprintf ("%s=%s", name, value);
2850               if (!string)
2851                 rc = gpg_error_from_syserror ();
2852               else
2853                 {
2854                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2855                   if (!rc)
2856                     rc = assuan_send_data (ctx, NULL, 0);
2857                 }
2858               if (rc)
2859                 break;
2860             }
2861         }
2862     }
2863   else
2864     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
2865   return rc;
2866 }
2867
2868
2869 \f
2870 /* This function is called by Libassuan to parse the OPTION command.
2871    It has been registered similar to the other Assuan commands.  */
2872 static gpg_error_t
2873 option_handler (assuan_context_t ctx, const char *key, const char *value)
2874 {
2875   ctrl_t ctrl = assuan_get_pointer (ctx);
2876   gpg_error_t err = 0;
2877
2878   if (!strcmp (key, "agent-awareness"))
2879     {
2880       /* The value is a version string telling us of which agent
2881          version the caller is aware of.  */
2882       ctrl->server_local->allow_fully_canceled =
2883         gnupg_compare_version (value, "2.1.0");
2884     }
2885   else if (ctrl->restricted)
2886     {
2887       err = gpg_error (GPG_ERR_FORBIDDEN);
2888     }
2889   /* All options below are not allowed in restricted mode.  */
2890   else if (!strcmp (key, "putenv"))
2891     {
2892       /* Change the session's environment to be used for the
2893          Pinentry.  Valid values are:
2894           <NAME>            Delete envvar NAME
2895           <KEY>=            Set envvar NAME to the empty string
2896           <KEY>=<VALUE>     Set envvar NAME to VALUE
2897       */
2898       err = session_env_putenv (ctrl->session_env, value);
2899     }
2900   else if (!strcmp (key, "display"))
2901     {
2902       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
2903     }
2904   else if (!strcmp (key, "ttyname"))
2905     {
2906       if (!opt.keep_tty)
2907         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
2908     }
2909   else if (!strcmp (key, "ttytype"))
2910     {
2911       if (!opt.keep_tty)
2912         err = session_env_setenv (ctrl->session_env, "TERM", value);
2913     }
2914   else if (!strcmp (key, "lc-ctype"))
2915     {
2916       if (ctrl->lc_ctype)
2917         xfree (ctrl->lc_ctype);
2918       ctrl->lc_ctype = xtrystrdup (value);
2919       if (!ctrl->lc_ctype)
2920         return out_of_core ();
2921     }
2922   else if (!strcmp (key, "lc-messages"))
2923     {
2924       if (ctrl->lc_messages)
2925         xfree (ctrl->lc_messages);
2926       ctrl->lc_messages = xtrystrdup (value);
2927       if (!ctrl->lc_messages)
2928         return out_of_core ();
2929     }
2930   else if (!strcmp (key, "xauthority"))
2931     {
2932       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
2933     }
2934   else if (!strcmp (key, "pinentry-user-data"))
2935     {
2936       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
2937     }
2938   else if (!strcmp (key, "use-cache-for-signing"))
2939     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
2940   else if (!strcmp (key, "allow-pinentry-notify"))
2941     ctrl->server_local->allow_pinentry_notify = 1;
2942   else if (!strcmp (key, "pinentry-mode"))
2943     {
2944       int tmp = parse_pinentry_mode (value);
2945       if (tmp == -1)
2946         err = gpg_error (GPG_ERR_INV_VALUE);
2947       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
2948         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2949       else
2950         ctrl->pinentry_mode = tmp;
2951     }
2952   else if (!strcmp (key, "cache-ttl-opt-preset"))
2953     {
2954       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
2955     }
2956   else if (!strcmp (key, "s2k-count"))
2957     {
2958       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
2959       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
2960         {
2961           ctrl->s2k_count = 0;
2962         }
2963     }
2964   else
2965     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
2966
2967   return err;
2968 }
2969
2970
2971
2972 \f
2973 /* Called by libassuan after all commands. ERR is the error from the
2974    last assuan operation and not the one returned from the command. */
2975 static void
2976 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
2977 {
2978   ctrl_t ctrl = assuan_get_pointer (ctx);
2979
2980   (void)err;
2981
2982   /* Switch off any I/O monitor controlled logging pausing. */
2983   ctrl->server_local->pause_io_logging = 0;
2984 }
2985
2986
2987 /* This function is called by libassuan for all I/O.  We use it here
2988    to disable logging for the GETEVENTCOUNTER commands.  This is so
2989    that the debug output won't get cluttered by this primitive
2990    command.  */
2991 static unsigned int
2992 io_monitor (assuan_context_t ctx, void *hook, int direction,
2993             const char *line, size_t linelen)
2994 {
2995   ctrl_t ctrl = assuan_get_pointer (ctx);
2996
2997   (void) hook;
2998
2999   /* Note that we only check for the uppercase name.  This allows to
3000      see the logging for debugging if using a non-upercase command
3001      name. */
3002   if (ctx && direction == ASSUAN_IO_FROM_PEER
3003       && linelen >= 15
3004       && !strncmp (line, "GETEVENTCOUNTER", 15)
3005       && (linelen == 15 || spacep (line+15)))
3006     {
3007       ctrl->server_local->pause_io_logging = 1;
3008     }
3009
3010   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3011 }
3012
3013
3014 /* Return true if the command CMD implements the option OPT.  */
3015 static int
3016 command_has_option (const char *cmd, const char *cmdopt)
3017 {
3018   if (!strcmp (cmd, "GET_PASSPHRASE"))
3019     {
3020       if (!strcmp (cmdopt, "repeat"))
3021           return 1;
3022     }
3023
3024   return 0;
3025 }
3026
3027
3028 /* Tell Libassuan about our commands.  Also register the other Assuan
3029    handlers. */
3030 static int
3031 register_commands (assuan_context_t ctx)
3032 {
3033   static struct {
3034     const char *name;
3035     assuan_handler_t handler;
3036     const char * const help;
3037   } table[] = {
3038     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3039     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3040     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3041     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3042     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3043     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3044     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3045     { "SETHASH",        cmd_sethash,   hlp_sethash },
3046     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3047     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3048     { "GENKEY",         cmd_genkey,    hlp_genkey },
3049     { "READKEY",        cmd_readkey,   hlp_readkey },
3050     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3051     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3052     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3053     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3054     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3055     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3056     { "LEARN",          cmd_learn,     hlp_learn },
3057     { "PASSWD",         cmd_passwd,    hlp_passwd },
3058     { "INPUT",          NULL },
3059     { "OUTPUT",         NULL },
3060     { "SCD",            cmd_scd,       hlp_scd },
3061     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3062     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3063     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3064     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3065     { "GETVAL",         cmd_getval,    hlp_getval },
3066     { "PUTVAL",         cmd_putval,    hlp_putval },
3067     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3068     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3069     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3070     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3071     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3072     { NULL }
3073   };
3074   int i, rc;
3075
3076   for (i=0; table[i].name; i++)
3077     {
3078       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3079                                     table[i].help);
3080       if (rc)
3081         return rc;
3082     }
3083   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3084   assuan_register_reset_notify (ctx, reset_notify);
3085   assuan_register_option_handler (ctx, option_handler);
3086   return 0;
3087 }
3088
3089
3090 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3091    simple piper server, otherwise it is a regular server.  CTRL is the
3092    control structure for this connection; it has only the basic
3093    intialization. */
3094 void
3095 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3096 {
3097   int rc;
3098   assuan_context_t ctx = NULL;
3099
3100   if (ctrl->restricted)
3101     {
3102       if (agent_copy_startup_env (ctrl))
3103         return;
3104     }
3105
3106   rc = assuan_new (&ctx);
3107   if (rc)
3108     {
3109       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3110       agent_exit (2);
3111     }
3112
3113   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3114     {
3115       assuan_fd_t filedes[2];
3116
3117       filedes[0] = assuan_fdopen (0);
3118       filedes[1] = assuan_fdopen (1);
3119       rc = assuan_init_pipe_server (ctx, filedes);
3120     }
3121   else if (listen_fd != GNUPG_INVALID_FD)
3122     {
3123       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3124       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3125          this branch is currently not used.  */
3126     }
3127   else
3128     {
3129       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3130     }
3131   if (rc)
3132     {
3133       log_error ("failed to initialize the server: %s\n",
3134                  gpg_strerror(rc));
3135       agent_exit (2);
3136     }
3137   rc = register_commands (ctx);
3138   if (rc)
3139     {
3140       log_error ("failed to register commands with Assuan: %s\n",
3141                  gpg_strerror(rc));
3142       agent_exit (2);
3143     }
3144
3145   assuan_set_pointer (ctx, ctrl);
3146   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3147   ctrl->server_local->assuan_ctx = ctx;
3148   ctrl->server_local->use_cache_for_signing = 1;
3149   ctrl->digest.raw_value = 0;
3150
3151   assuan_set_io_monitor (ctx, io_monitor, NULL);
3152   agent_set_progress_cb (progress_cb, ctrl);
3153
3154   for (;;)
3155     {
3156       rc = assuan_accept (ctx);
3157       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3158         {
3159           break;
3160         }
3161       else if (rc)
3162         {
3163           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3164           break;
3165         }
3166
3167       rc = assuan_process (ctx);
3168       if (rc)
3169         {
3170           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3171           continue;
3172         }
3173     }
3174
3175   /* Reset the nonce caches.  */
3176   clear_nonce_cache (ctrl);
3177
3178   /* Reset the SCD if needed. */
3179   agent_reset_scd (ctrl);
3180
3181   /* Reset the pinentry (in case of popup messages). */
3182   agent_reset_query (ctrl);
3183
3184   /* Cleanup.  */
3185   assuan_release (ctx);
3186   xfree (ctrl->server_local->keydesc);
3187   xfree (ctrl->server_local->import_key);
3188   xfree (ctrl->server_local->export_key);
3189   if (ctrl->server_local->stopme)
3190     agent_exit (0);
3191   xfree (ctrl->server_local);
3192   ctrl->server_local = NULL;
3193 }
3194
3195
3196 /* Helper for the pinentry loopback mode.  It merely passes the
3197    parameters on to the client.  */
3198 gpg_error_t
3199 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3200                   unsigned char **buffer, size_t *size,
3201                   size_t max_length)
3202 {
3203   gpg_error_t rc;
3204   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3205
3206   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3207   if (rc)
3208     return rc;
3209
3210   assuan_begin_confidential (ctx);
3211   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3212   assuan_end_confidential (ctx);
3213   return rc;
3214 }