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