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