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