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