Show passphrase constraints errors as password prompt errors
[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 <hexstring_with_keygrip>\n"
2392   "\n"
2393   "Delete a secret key from the key store.\n"
2394   "As safeguard 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   unsigned char grip[20];
2401
2402   if (ctrl->restricted)
2403     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2404
2405   line = skip_options (line);
2406
2407   err = parse_keygrip (ctx, line, grip);
2408   if (err)
2409     goto leave;
2410
2411   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip);
2412   if (err)
2413     goto leave;
2414
2415  leave:
2416   xfree (ctrl->server_local->keydesc);
2417   ctrl->server_local->keydesc = NULL;
2418
2419   return leave_cmd (ctx, err);
2420 }
2421
2422
2423 \f
2424 static const char hlp_keytocard[] =
2425   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2426   "\n";
2427 static gpg_error_t
2428 cmd_keytocard (assuan_context_t ctx, char *line)
2429 {
2430   ctrl_t ctrl = assuan_get_pointer (ctx);
2431   int force;
2432   gpg_error_t err = 0;
2433   unsigned char grip[20];
2434   gcry_sexp_t s_skey = NULL;
2435   unsigned char *keydata;
2436   size_t keydatalen, timestamplen;
2437   const char *serialno, *timestamp_str, *id;
2438   unsigned char *shadow_info = NULL;
2439   time_t timestamp;
2440
2441   if (ctrl->restricted)
2442     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2443
2444   force = has_option (line, "--force");
2445   line = skip_options (line);
2446
2447   err = parse_keygrip (ctx, line, grip);
2448   if (err)
2449     return err;
2450
2451   if (agent_key_available (grip))
2452     return gpg_error (GPG_ERR_NO_SECKEY);
2453
2454   line += 40;
2455   while (*line && (*line == ' ' || *line == '\t'))
2456     line++;
2457   serialno = line;
2458   while (*line && (*line != ' ' && *line != '\t'))
2459     line++;
2460   if (!*line)
2461     return gpg_error (GPG_ERR_MISSING_VALUE);
2462   *line = '\0';
2463   line++;
2464   while (*line && (*line == ' ' || *line == '\t'))
2465     line++;
2466   id = line;
2467   while (*line && (*line != ' ' && *line != '\t'))
2468     line++;
2469   if (!*line)
2470     return gpg_error (GPG_ERR_MISSING_VALUE);
2471   *line = '\0';
2472   line++;
2473   while (*line && (*line == ' ' || *line == '\t'))
2474     line++;
2475   timestamp_str = line;
2476   while (*line && (*line != ' ' && *line != '\t'))
2477     line++;
2478   if (*line)
2479     *line = '\0';
2480   timestamplen = line - timestamp_str;
2481   if (timestamplen != 15)
2482     return gpg_error (GPG_ERR_INV_VALUE);
2483
2484   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2485                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2486                              &s_skey, NULL);
2487   if (err)
2488     {
2489       xfree (shadow_info);
2490       return err;
2491     }
2492   if (shadow_info)
2493     {
2494       /* Key is on a smartcard already.  */
2495       xfree (shadow_info);
2496       gcry_sexp_release (s_skey);
2497       return gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2498     }
2499
2500   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2501   keydata = xtrymalloc_secure (keydatalen + 30);
2502   if (keydata == NULL)
2503     {
2504       gcry_sexp_release (s_skey);
2505       return gpg_error_from_syserror ();
2506     }
2507
2508   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2509   gcry_sexp_release (s_skey);
2510   keydatalen--;                 /* Decrement for last '\0'.  */
2511   /* Add timestamp "created-at" in the private key */
2512   timestamp = isotime2epoch (timestamp_str);
2513   snprintf (keydata+keydatalen-1, 30, "(10:created-at10:%010lu))", timestamp);
2514   keydatalen += 10 + 19 - 1;
2515   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2516   xfree (keydata);
2517
2518   return leave_cmd (ctx, err);
2519 }
2520
2521
2522 \f
2523 static const char hlp_getval[] =
2524   "GETVAL <key>\n"
2525   "\n"
2526   "Return the value for KEY from the special environment as created by\n"
2527   "PUTVAL.";
2528 static gpg_error_t
2529 cmd_getval (assuan_context_t ctx, char *line)
2530 {
2531   ctrl_t ctrl = assuan_get_pointer (ctx);
2532   int rc = 0;
2533   char *key = NULL;
2534   char *p;
2535   struct putval_item_s *vl;
2536
2537   if (ctrl->restricted)
2538     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2539
2540   for (p=line; *p == ' '; p++)
2541     ;
2542   key = p;
2543   p = strchr (key, ' ');
2544   if (p)
2545     {
2546       *p++ = 0;
2547       for (; *p == ' '; p++)
2548         ;
2549       if (*p)
2550         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2551     }
2552   if (!*key)
2553     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2554
2555
2556   for (vl=putval_list; vl; vl = vl->next)
2557     if ( !strcmp (vl->d, key) )
2558       break;
2559
2560   if (vl) /* Got an entry. */
2561     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2562   else
2563     return gpg_error (GPG_ERR_NO_DATA);
2564
2565   return leave_cmd (ctx, rc);
2566 }
2567
2568
2569 static const char hlp_putval[] =
2570   "PUTVAL <key> [<percent_escaped_value>]\n"
2571   "\n"
2572   "The gpg-agent maintains a kind of environment which may be used to\n"
2573   "store key/value pairs in it, so that they can be retrieved later.\n"
2574   "This may be used by helper daemons to daemonize themself on\n"
2575   "invocation and register them with gpg-agent.  Callers of the\n"
2576   "daemon's service may now first try connect to get the information\n"
2577   "for that service from gpg-agent through the GETVAL command and then\n"
2578   "try to connect to that daemon.  Only if that fails they may start\n"
2579   "an own instance of the service daemon. \n"
2580   "\n"
2581   "KEY is an an arbitrary symbol with the same syntax rules as keys\n"
2582   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2583   "corresponsing value; they should be similar to the values of\n"
2584   "envronment variables but gpg-agent does not enforce any\n"
2585   "restrictions.  If that value is not given any value under that KEY\n"
2586   "is removed from this special environment.";
2587 static gpg_error_t
2588 cmd_putval (assuan_context_t ctx, char *line)
2589 {
2590   ctrl_t ctrl = assuan_get_pointer (ctx);
2591   int rc = 0;
2592   char *key = NULL;
2593   char *value = NULL;
2594   size_t valuelen = 0;
2595   char *p;
2596   struct putval_item_s *vl, *vlprev;
2597
2598   if (ctrl->restricted)
2599     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2600
2601   for (p=line; *p == ' '; p++)
2602     ;
2603   key = p;
2604   p = strchr (key, ' ');
2605   if (p)
2606     {
2607       *p++ = 0;
2608       for (; *p == ' '; p++)
2609         ;
2610       if (*p)
2611         {
2612           value = p;
2613           p = strchr (value, ' ');
2614           if (p)
2615             *p = 0;
2616           valuelen = percent_plus_unescape_inplace (value, 0);
2617         }
2618     }
2619   if (!*key)
2620     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2621
2622
2623   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2624     if ( !strcmp (vl->d, key) )
2625       break;
2626
2627   if (vl) /* Delete old entry. */
2628     {
2629       if (vlprev)
2630         vlprev->next = vl->next;
2631       else
2632         putval_list = vl->next;
2633       xfree (vl);
2634     }
2635
2636   if (valuelen) /* Add entry. */
2637     {
2638       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2639       if (!vl)
2640         rc = gpg_error_from_syserror ();
2641       else
2642         {
2643           vl->len = valuelen;
2644           vl->off = strlen (key) + 1;
2645           strcpy (vl->d, key);
2646           memcpy (vl->d + vl->off, value, valuelen);
2647           vl->next = putval_list;
2648           putval_list = vl;
2649         }
2650     }
2651
2652   return leave_cmd (ctx, rc);
2653 }
2654
2655
2656
2657 \f
2658 static const char hlp_updatestartuptty[] =
2659   "UPDATESTARTUPTTY\n"
2660   "\n"
2661   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2662   "session.  This command is useful to pull future pinentries to\n"
2663   "another screen.  It is only required because there is no way in the\n"
2664   "ssh-agent protocol to convey this information.";
2665 static gpg_error_t
2666 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2667 {
2668   static const char *names[] =
2669     { "GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
2670   ctrl_t ctrl = assuan_get_pointer (ctx);
2671   gpg_error_t err = 0;
2672   session_env_t se;
2673   int idx;
2674   char *lc_ctype = NULL;
2675   char *lc_messages = NULL;
2676
2677   (void)line;
2678
2679   if (ctrl->restricted)
2680     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2681
2682   se = session_env_new ();
2683   if (!se)
2684     err = gpg_error_from_syserror ();
2685
2686   for (idx=0; !err && names[idx]; idx++)
2687     {
2688       const char *value = session_env_getenv (ctrl->session_env, names[idx]);
2689       if (value)
2690         err = session_env_setenv (se, names[idx], value);
2691     }
2692
2693   if (!err && ctrl->lc_ctype)
2694     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2695       err = gpg_error_from_syserror ();
2696
2697   if (!err && ctrl->lc_messages)
2698     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2699       err = gpg_error_from_syserror ();
2700
2701   if (err)
2702     {
2703       session_env_release (se);
2704       xfree (lc_ctype);
2705       xfree (lc_messages);
2706     }
2707   else
2708     {
2709       session_env_release (opt.startup_env);
2710       opt.startup_env = se;
2711       xfree (opt.startup_lc_ctype);
2712       opt.startup_lc_ctype = lc_ctype;
2713       xfree (opt.startup_lc_messages);
2714       opt.startup_lc_messages = lc_messages;
2715     }
2716
2717   return err;
2718 }
2719
2720
2721 \f
2722 static const char hlp_killagent[] =
2723   "KILLAGENT\n"
2724   "\n"
2725   "Stop the agent.";
2726 static gpg_error_t
2727 cmd_killagent (assuan_context_t ctx, char *line)
2728 {
2729   ctrl_t ctrl = assuan_get_pointer (ctx);
2730
2731   (void)line;
2732
2733   if (ctrl->restricted)
2734     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2735
2736   ctrl->server_local->stopme = 1;
2737   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2738   return 0;
2739 }
2740
2741
2742 static const char hlp_reloadagent[] =
2743   "RELOADAGENT\n"
2744   "\n"
2745   "This command is an alternative to SIGHUP\n"
2746   "to reload the configuration.";
2747 static gpg_error_t
2748 cmd_reloadagent (assuan_context_t ctx, char *line)
2749 {
2750   ctrl_t ctrl = assuan_get_pointer (ctx);
2751
2752   (void)line;
2753
2754   if (ctrl->restricted)
2755     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2756
2757   agent_sighup_action ();
2758   return 0;
2759 }
2760
2761
2762 \f
2763 static const char hlp_getinfo[] =
2764   "GETINFO <what>\n"
2765   "\n"
2766   "Multipurpose function to return a variety of information.\n"
2767   "Supported values for WHAT are:\n"
2768   "\n"
2769   "  version     - Return the version of the program.\n"
2770   "  pid         - Return the process id of the server.\n"
2771   "  socket_name - Return the name of the socket.\n"
2772   "  ssh_socket_name - Return the name of the ssh socket.\n"
2773   "  scd_running - Return OK if the SCdaemon is already running.\n"
2774   "  s2k_count   - Return the calibrated S2K count.\n"
2775   "  std_env_names   - List the names of the standard environment.\n"
2776   "  std_session_env - List the standard session environment.\n"
2777   "  std_startup_env - List the standard startup environment.\n"
2778   "  cmd_has_option\n"
2779   "              - Returns OK if the command CMD implements the option OPT.\n"
2780   "  restricted  - Returns OK if the connection is in restricted mode.\n";
2781 static gpg_error_t
2782 cmd_getinfo (assuan_context_t ctx, char *line)
2783 {
2784   ctrl_t ctrl = assuan_get_pointer (ctx);
2785   int rc = 0;
2786
2787   if (!strcmp (line, "version"))
2788     {
2789       const char *s = VERSION;
2790       rc = assuan_send_data (ctx, s, strlen (s));
2791     }
2792   else if (!strncmp (line, "cmd_has_option", 14)
2793            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2794     {
2795       char *cmd, *cmdopt;
2796       line += 14;
2797       while (*line == ' ' || *line == '\t')
2798         line++;
2799       if (!*line)
2800         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2801       else
2802         {
2803           cmd = line;
2804           while (*line && (*line != ' ' && *line != '\t'))
2805             line++;
2806           if (!*line)
2807             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2808           else
2809             {
2810               *line++ = 0;
2811               while (*line == ' ' || *line == '\t')
2812                 line++;
2813               if (!*line)
2814                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2815               else
2816                 {
2817                   cmdopt = line;
2818                   if (!command_has_option (cmd, cmdopt))
2819                     rc = gpg_error (GPG_ERR_GENERAL);
2820                 }
2821             }
2822         }
2823     }
2824   else if (!strcmp (line, "s2k_count"))
2825     {
2826       char numbuf[50];
2827
2828       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2829       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2830     }
2831   else if (!strcmp (line, "restricted"))
2832     {
2833       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2834     }
2835   else if (ctrl->restricted)
2836     {
2837       rc = gpg_error (GPG_ERR_FORBIDDEN);
2838     }
2839   /* All sub-commands below are not allowed in restricted mode.  */
2840   else if (!strcmp (line, "pid"))
2841     {
2842       char numbuf[50];
2843
2844       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2845       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2846     }
2847   else if (!strcmp (line, "socket_name"))
2848     {
2849       const char *s = get_agent_socket_name ();
2850
2851       if (s)
2852         rc = assuan_send_data (ctx, s, strlen (s));
2853       else
2854         rc = gpg_error (GPG_ERR_NO_DATA);
2855     }
2856   else if (!strcmp (line, "ssh_socket_name"))
2857     {
2858       const char *s = get_agent_ssh_socket_name ();
2859
2860       if (s)
2861         rc = assuan_send_data (ctx, s, strlen (s));
2862       else
2863         rc = gpg_error (GPG_ERR_NO_DATA);
2864     }
2865   else if (!strcmp (line, "scd_running"))
2866     {
2867       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2868     }
2869   else if (!strcmp (line, "std_env_names"))
2870     {
2871       int iterator;
2872       const char *name;
2873
2874       iterator = 0;
2875       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2876         {
2877           rc = assuan_send_data (ctx, name, strlen (name)+1);
2878           if (!rc)
2879             rc = assuan_send_data (ctx, NULL, 0);
2880           if (rc)
2881             break;
2882         }
2883     }
2884   else if (!strcmp (line, "std_session_env")
2885            || !strcmp (line, "std_startup_env"))
2886     {
2887       int iterator;
2888       const char *name, *value;
2889       char *string;
2890
2891       iterator = 0;
2892       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2893         {
2894           value = session_env_getenv_or_default
2895             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2896           if (value)
2897             {
2898               string = xtryasprintf ("%s=%s", name, value);
2899               if (!string)
2900                 rc = gpg_error_from_syserror ();
2901               else
2902                 {
2903                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2904                   if (!rc)
2905                     rc = assuan_send_data (ctx, NULL, 0);
2906                 }
2907               if (rc)
2908                 break;
2909             }
2910         }
2911     }
2912   else
2913     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
2914   return rc;
2915 }
2916
2917
2918 \f
2919 /* This function is called by Libassuan to parse the OPTION command.
2920    It has been registered similar to the other Assuan commands.  */
2921 static gpg_error_t
2922 option_handler (assuan_context_t ctx, const char *key, const char *value)
2923 {
2924   ctrl_t ctrl = assuan_get_pointer (ctx);
2925   gpg_error_t err = 0;
2926
2927   if (!strcmp (key, "agent-awareness"))
2928     {
2929       /* The value is a version string telling us of which agent
2930          version the caller is aware of.  */
2931       ctrl->server_local->allow_fully_canceled =
2932         gnupg_compare_version (value, "2.1.0");
2933     }
2934   else if (ctrl->restricted)
2935     {
2936       err = gpg_error (GPG_ERR_FORBIDDEN);
2937     }
2938   /* All options below are not allowed in restricted mode.  */
2939   else if (!strcmp (key, "putenv"))
2940     {
2941       /* Change the session's environment to be used for the
2942          Pinentry.  Valid values are:
2943           <NAME>            Delete envvar NAME
2944           <KEY>=            Set envvar NAME to the empty string
2945           <KEY>=<VALUE>     Set envvar NAME to VALUE
2946       */
2947       err = session_env_putenv (ctrl->session_env, value);
2948     }
2949   else if (!strcmp (key, "display"))
2950     {
2951       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
2952     }
2953   else if (!strcmp (key, "ttyname"))
2954     {
2955       if (!opt.keep_tty)
2956         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
2957     }
2958   else if (!strcmp (key, "ttytype"))
2959     {
2960       if (!opt.keep_tty)
2961         err = session_env_setenv (ctrl->session_env, "TERM", value);
2962     }
2963   else if (!strcmp (key, "lc-ctype"))
2964     {
2965       if (ctrl->lc_ctype)
2966         xfree (ctrl->lc_ctype);
2967       ctrl->lc_ctype = xtrystrdup (value);
2968       if (!ctrl->lc_ctype)
2969         return out_of_core ();
2970     }
2971   else if (!strcmp (key, "lc-messages"))
2972     {
2973       if (ctrl->lc_messages)
2974         xfree (ctrl->lc_messages);
2975       ctrl->lc_messages = xtrystrdup (value);
2976       if (!ctrl->lc_messages)
2977         return out_of_core ();
2978     }
2979   else if (!strcmp (key, "xauthority"))
2980     {
2981       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
2982     }
2983   else if (!strcmp (key, "pinentry-user-data"))
2984     {
2985       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
2986     }
2987   else if (!strcmp (key, "use-cache-for-signing"))
2988     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
2989   else if (!strcmp (key, "allow-pinentry-notify"))
2990     ctrl->server_local->allow_pinentry_notify = 1;
2991   else if (!strcmp (key, "pinentry-mode"))
2992     {
2993       int tmp = parse_pinentry_mode (value);
2994       if (tmp == -1)
2995         err = gpg_error (GPG_ERR_INV_VALUE);
2996       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
2997         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2998       else
2999         ctrl->pinentry_mode = tmp;
3000     }
3001   else if (!strcmp (key, "cache-ttl-opt-preset"))
3002     {
3003       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
3004     }
3005   else if (!strcmp (key, "s2k-count"))
3006     {
3007       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
3008       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
3009         {
3010           ctrl->s2k_count = 0;
3011         }
3012     }
3013   else
3014     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
3015
3016   return err;
3017 }
3018
3019
3020
3021 \f
3022 /* Called by libassuan after all commands. ERR is the error from the
3023    last assuan operation and not the one returned from the command. */
3024 static void
3025 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
3026 {
3027   ctrl_t ctrl = assuan_get_pointer (ctx);
3028
3029   (void)err;
3030
3031   /* Switch off any I/O monitor controlled logging pausing. */
3032   ctrl->server_local->pause_io_logging = 0;
3033 }
3034
3035
3036 /* This function is called by libassuan for all I/O.  We use it here
3037    to disable logging for the GETEVENTCOUNTER commands.  This is so
3038    that the debug output won't get cluttered by this primitive
3039    command.  */
3040 static unsigned int
3041 io_monitor (assuan_context_t ctx, void *hook, int direction,
3042             const char *line, size_t linelen)
3043 {
3044   ctrl_t ctrl = assuan_get_pointer (ctx);
3045
3046   (void) hook;
3047
3048   /* Note that we only check for the uppercase name.  This allows to
3049      see the logging for debugging if using a non-upercase command
3050      name. */
3051   if (ctx && direction == ASSUAN_IO_FROM_PEER
3052       && linelen >= 15
3053       && !strncmp (line, "GETEVENTCOUNTER", 15)
3054       && (linelen == 15 || spacep (line+15)))
3055     {
3056       ctrl->server_local->pause_io_logging = 1;
3057     }
3058
3059   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3060 }
3061
3062
3063 /* Return true if the command CMD implements the option OPT.  */
3064 static int
3065 command_has_option (const char *cmd, const char *cmdopt)
3066 {
3067   if (!strcmp (cmd, "GET_PASSPHRASE"))
3068     {
3069       if (!strcmp (cmdopt, "repeat"))
3070           return 1;
3071     }
3072
3073   return 0;
3074 }
3075
3076
3077 /* Tell Libassuan about our commands.  Also register the other Assuan
3078    handlers. */
3079 static int
3080 register_commands (assuan_context_t ctx)
3081 {
3082   static struct {
3083     const char *name;
3084     assuan_handler_t handler;
3085     const char * const help;
3086   } table[] = {
3087     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3088     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3089     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3090     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3091     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3092     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3093     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3094     { "SETHASH",        cmd_sethash,   hlp_sethash },
3095     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3096     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3097     { "GENKEY",         cmd_genkey,    hlp_genkey },
3098     { "READKEY",        cmd_readkey,   hlp_readkey },
3099     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3100     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3101     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3102     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3103     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3104     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3105     { "LEARN",          cmd_learn,     hlp_learn },
3106     { "PASSWD",         cmd_passwd,    hlp_passwd },
3107     { "INPUT",          NULL },
3108     { "OUTPUT",         NULL },
3109     { "SCD",            cmd_scd,       hlp_scd },
3110     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3111     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3112     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3113     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3114     { "GETVAL",         cmd_getval,    hlp_getval },
3115     { "PUTVAL",         cmd_putval,    hlp_putval },
3116     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3117     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3118     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3119     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3120     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3121     { NULL }
3122   };
3123   int i, rc;
3124
3125   for (i=0; table[i].name; i++)
3126     {
3127       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3128                                     table[i].help);
3129       if (rc)
3130         return rc;
3131     }
3132   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3133   assuan_register_reset_notify (ctx, reset_notify);
3134   assuan_register_option_handler (ctx, option_handler);
3135   return 0;
3136 }
3137
3138
3139 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3140    simple piper server, otherwise it is a regular server.  CTRL is the
3141    control structure for this connection; it has only the basic
3142    intialization. */
3143 void
3144 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3145 {
3146   int rc;
3147   assuan_context_t ctx = NULL;
3148
3149   if (ctrl->restricted)
3150     {
3151       if (agent_copy_startup_env (ctrl))
3152         return;
3153     }
3154
3155   rc = assuan_new (&ctx);
3156   if (rc)
3157     {
3158       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3159       agent_exit (2);
3160     }
3161
3162   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3163     {
3164       assuan_fd_t filedes[2];
3165
3166       filedes[0] = assuan_fdopen (0);
3167       filedes[1] = assuan_fdopen (1);
3168       rc = assuan_init_pipe_server (ctx, filedes);
3169     }
3170   else if (listen_fd != GNUPG_INVALID_FD)
3171     {
3172       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3173       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3174          this branch is currently not used.  */
3175     }
3176   else
3177     {
3178       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3179     }
3180   if (rc)
3181     {
3182       log_error ("failed to initialize the server: %s\n",
3183                  gpg_strerror(rc));
3184       agent_exit (2);
3185     }
3186   rc = register_commands (ctx);
3187   if (rc)
3188     {
3189       log_error ("failed to register commands with Assuan: %s\n",
3190                  gpg_strerror(rc));
3191       agent_exit (2);
3192     }
3193
3194   assuan_set_pointer (ctx, ctrl);
3195   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3196   ctrl->server_local->assuan_ctx = ctx;
3197   ctrl->server_local->use_cache_for_signing = 1;
3198   ctrl->digest.raw_value = 0;
3199
3200   assuan_set_io_monitor (ctx, io_monitor, NULL);
3201
3202   for (;;)
3203     {
3204       rc = assuan_accept (ctx);
3205       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3206         {
3207           break;
3208         }
3209       else if (rc)
3210         {
3211           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3212           break;
3213         }
3214
3215       rc = assuan_process (ctx);
3216       if (rc)
3217         {
3218           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3219           continue;
3220         }
3221     }
3222
3223   /* Reset the nonce caches.  */
3224   clear_nonce_cache (ctrl);
3225
3226   /* Reset the SCD if needed. */
3227   agent_reset_scd (ctrl);
3228
3229   /* Reset the pinentry (in case of popup messages). */
3230   agent_reset_query (ctrl);
3231
3232   /* Cleanup.  */
3233   assuan_release (ctx);
3234   xfree (ctrl->server_local->keydesc);
3235   xfree (ctrl->server_local->import_key);
3236   xfree (ctrl->server_local->export_key);
3237   if (ctrl->server_local->stopme)
3238     agent_exit (0);
3239   xfree (ctrl->server_local);
3240   ctrl->server_local = NULL;
3241 }
3242
3243
3244 /* Helper for the pinentry loopback mode.  It merely passes the
3245    parameters on to the client.  */
3246 gpg_error_t
3247 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3248                   unsigned char **buffer, size_t *size,
3249                   size_t max_length)
3250 {
3251   gpg_error_t rc;
3252   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3253
3254   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3255   if (rc)
3256     return rc;
3257
3258   assuan_begin_confidential (ctx);
3259   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3260   assuan_end_confidential (ctx);
3261   return rc;
3262 }