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