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