bd184ac261662e2e91dc4b47b0a3308e9e38b769
[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 <https://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 "../common/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, const char *extra)
366 {
367   char line[256];
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%s%s",
373             pid, extra?" ":"", extra? extra:"");
374   return assuan_inquire (ctrl->server_local->assuan_ctx, line, NULL, NULL, 0);
375 }
376
377
378 /* An agent progress callback for Libgcrypt.  This has been registered
379  * to be called via the progress dispatcher mechanism from
380  * gpg-agent.c  */
381 static void
382 progress_cb (ctrl_t ctrl, const char *what, int printchar,
383              int current, int total)
384 {
385   if (!ctrl || !ctrl->server_local || !ctrl->server_local->assuan_ctx)
386     ;
387   else if (printchar == '\n' && what && !strcmp (what, "primegen"))
388     agent_print_status (ctrl, "PROGRESS", "%.20s X 100 100", what);
389   else
390     agent_print_status (ctrl, "PROGRESS", "%.20s %c %d %d",
391                         what, printchar=='\n'?'X':printchar, current, total);
392 }
393
394
395 /* Helper to print a message while leaving a command.  Note that this
396  * function does not call assuan_set_error; the caller may do this
397  * prior to calling us.  */
398 static gpg_error_t
399 leave_cmd (assuan_context_t ctx, gpg_error_t err)
400 {
401   if (err)
402     {
403       const char *name = assuan_get_command_name (ctx);
404       if (!name)
405         name = "?";
406
407       /* Not all users of gpg-agent know about the fully canceled
408          error code; map it back if needed.  */
409       if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
410         {
411           ctrl_t ctrl = assuan_get_pointer (ctx);
412
413           if (!ctrl->server_local->allow_fully_canceled)
414             err = gpg_err_make (gpg_err_source (err), GPG_ERR_CANCELED);
415         }
416
417       /* Most code from common/ does not know the error source, thus
418          we fix this here.  */
419       if (gpg_err_source (err) == GPG_ERR_SOURCE_UNKNOWN)
420         err = gpg_err_make (GPG_ERR_SOURCE_DEFAULT, gpg_err_code (err));
421
422       if (gpg_err_source (err) == GPG_ERR_SOURCE_DEFAULT)
423         log_error ("command '%s' failed: %s\n", name,
424                    gpg_strerror (err));
425       else
426         log_error ("command '%s' failed: %s <%s>\n", name,
427                    gpg_strerror (err), gpg_strsource (err));
428     }
429   return err;
430 }
431
432
433 \f
434 static const char hlp_geteventcounter[] =
435   "GETEVENTCOUNTER\n"
436   "\n"
437   "Return a status line named EVENTCOUNTER with the current values\n"
438   "of all event counters.  The values are decimal numbers in the range\n"
439   "0 to UINT_MAX and wrapping around to 0.  The actual values should\n"
440   "not be relied upon, they shall only be used to detect a change.\n"
441   "\n"
442   "The currently defined counters are:\n"
443   "\n"
444   "ANY  - Incremented with any change of any of the other counters.\n"
445   "KEY  - Incremented for added or removed private keys.\n"
446   "CARD - Incremented for changes of the card readers stati.";
447 static gpg_error_t
448 cmd_geteventcounter (assuan_context_t ctx, char *line)
449 {
450   ctrl_t ctrl = assuan_get_pointer (ctx);
451
452   (void)line;
453
454   if (ctrl->restricted)
455     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
456
457   return agent_print_status (ctrl, "EVENTCOUNTER", "%u %u %u",
458                              eventcounter.any,
459                              eventcounter.key,
460                              eventcounter.card);
461 }
462
463
464 /* This function should be called once for all key removals or
465    additions.  This function is assured not to do any context
466    switches. */
467 void
468 bump_key_eventcounter (void)
469 {
470   eventcounter.key++;
471   eventcounter.any++;
472 }
473
474
475 /* This function should be called for all card reader status
476    changes.  This function is assured not to do any context
477    switches. */
478 void
479 bump_card_eventcounter (void)
480 {
481   eventcounter.card++;
482   eventcounter.any++;
483 }
484
485
486
487 \f
488 static const char hlp_istrusted[] =
489   "ISTRUSTED <hexstring_with_fingerprint>\n"
490   "\n"
491   "Return OK when we have an entry with this fingerprint in our\n"
492   "trustlist";
493 static gpg_error_t
494 cmd_istrusted (assuan_context_t ctx, char *line)
495 {
496   ctrl_t ctrl = assuan_get_pointer (ctx);
497   int rc, n, i;
498   char *p;
499   char fpr[41];
500
501   /* Parse the fingerprint value. */
502   for (p=line,n=0; hexdigitp (p); p++, n++)
503     ;
504   if (*p || !(n == 40 || n == 32))
505     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
506   i = 0;
507   if (n==32)
508     {
509       strcpy (fpr, "00000000");
510       i += 8;
511     }
512   for (p=line; i < 40; p++, i++)
513     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
514   fpr[i] = 0;
515   rc = agent_istrusted (ctrl, fpr, NULL);
516   if (!rc || gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
517     return rc;
518   else if (rc == -1 || gpg_err_code (rc) == GPG_ERR_EOF )
519     return gpg_error (GPG_ERR_NOT_TRUSTED);
520   else
521     return leave_cmd (ctx, rc);
522 }
523
524
525 static const char hlp_listtrusted[] =
526   "LISTTRUSTED\n"
527   "\n"
528   "List all entries from the trustlist.";
529 static gpg_error_t
530 cmd_listtrusted (assuan_context_t ctx, char *line)
531 {
532   ctrl_t ctrl = assuan_get_pointer (ctx);
533   int rc;
534
535   (void)line;
536
537   if (ctrl->restricted)
538     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
539
540   rc = agent_listtrusted (ctx);
541   return leave_cmd (ctx, rc);
542 }
543
544
545 static const char hlp_martrusted[] =
546   "MARKTRUSTED <hexstring_with_fingerprint> <flag> <display_name>\n"
547   "\n"
548   "Store a new key in into the trustlist.";
549 static gpg_error_t
550 cmd_marktrusted (assuan_context_t ctx, char *line)
551 {
552   ctrl_t ctrl = assuan_get_pointer (ctx);
553   int rc, n, i;
554   char *p;
555   char fpr[41];
556   int flag;
557
558   if (ctrl->restricted)
559     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
560
561   /* parse the fingerprint value */
562   for (p=line,n=0; hexdigitp (p); p++, n++)
563     ;
564   if (!spacep (p) || !(n == 40 || n == 32))
565     return set_error (GPG_ERR_ASS_PARAMETER, "invalid fingerprint");
566   i = 0;
567   if (n==32)
568     {
569       strcpy (fpr, "00000000");
570       i += 8;
571     }
572   for (p=line; i < 40; p++, i++)
573     fpr[i] = *p >= 'a'? (*p & 0xdf): *p;
574   fpr[i] = 0;
575
576   while (spacep (p))
577     p++;
578   flag = *p++;
579   if ( (flag != 'S' && flag != 'P') || !spacep (p) )
580     return set_error (GPG_ERR_ASS_PARAMETER, "invalid flag - must be P or S");
581   while (spacep (p))
582     p++;
583
584   rc = agent_marktrusted (ctrl, p, fpr, flag);
585   return leave_cmd (ctx, rc);
586 }
587
588
589
590 \f
591 static const char hlp_havekey[] =
592   "HAVEKEY <hexstrings_with_keygrips>\n"
593   "\n"
594   "Return success if at least one of the secret keys with the given\n"
595   "keygrips is available.";
596 static gpg_error_t
597 cmd_havekey (assuan_context_t ctx, char *line)
598 {
599   gpg_error_t err;
600   unsigned char buf[20];
601
602   do
603     {
604       err = parse_keygrip (ctx, line, buf);
605       if (err)
606         return err;
607
608       if (!agent_key_available (buf))
609         return 0; /* Found.  */
610
611       while (*line && *line != ' ' && *line != '\t')
612         line++;
613       while (*line == ' ' || *line == '\t')
614         line++;
615     }
616   while (*line);
617
618   /* No leave_cmd() here because errors are expected and would clutter
619      the log.  */
620   return gpg_error (GPG_ERR_NO_SECKEY);
621 }
622
623
624 static const char hlp_sigkey[] =
625   "SIGKEY <hexstring_with_keygrip>\n"
626   "SETKEY <hexstring_with_keygrip>\n"
627   "\n"
628   "Set the  key used for a sign or decrypt operation.";
629 static gpg_error_t
630 cmd_sigkey (assuan_context_t ctx, char *line)
631 {
632   int rc;
633   ctrl_t ctrl = assuan_get_pointer (ctx);
634
635   rc = parse_keygrip (ctx, line, ctrl->keygrip);
636   if (rc)
637     return rc;
638   ctrl->have_keygrip = 1;
639   return 0;
640 }
641
642
643 static const char hlp_setkeydesc[] =
644   "SETKEYDESC plus_percent_escaped_string\n"
645   "\n"
646   "Set a description to be used for the next PKSIGN, PKDECRYPT, IMPORT_KEY\n"
647   "or EXPORT_KEY operation if this operation requires a passphrase.  If\n"
648   "this command is not used a default text will be used.  Note, that\n"
649   "this description implictly selects the label used for the entry\n"
650   "box; if the string contains the string PIN (which in general will\n"
651   "not be translated), \"PIN\" is used, otherwise the translation of\n"
652   "\"passphrase\" is used.  The description string should not contain\n"
653   "blanks unless they are percent or '+' escaped.\n"
654   "\n"
655   "The description is only valid for the next PKSIGN, PKDECRYPT,\n"
656   "IMPORT_KEY, EXPORT_KEY, or DELETE_KEY operation.";
657 static gpg_error_t
658 cmd_setkeydesc (assuan_context_t ctx, char *line)
659 {
660   ctrl_t ctrl = assuan_get_pointer (ctx);
661   char *desc, *p;
662
663   for (p=line; *p == ' '; p++)
664     ;
665   desc = p;
666   p = strchr (desc, ' ');
667   if (p)
668     *p = 0; /* We ignore any garbage; we might late use it for other args. */
669
670   if (!*desc)
671     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
672
673   /* Note, that we only need to replace the + characters and should
674      leave the other escaping in place because the escaped string is
675      send verbatim to the pinentry which does the unescaping (but not
676      the + replacing) */
677   plus_to_blank (desc);
678
679   xfree (ctrl->server_local->keydesc);
680
681   if (ctrl->restricted)
682     {
683       ctrl->server_local->keydesc = strconcat
684         ((ctrl->restricted == 2
685          ? _("Note: Request from the web browser.")
686          : _("Note: Request from a remote site.")  ), "%0A%0A", desc, NULL);
687     }
688   else
689     ctrl->server_local->keydesc = xtrystrdup (desc);
690   if (!ctrl->server_local->keydesc)
691     return out_of_core ();
692   return 0;
693 }
694
695
696 static const char hlp_sethash[] =
697   "SETHASH (--hash=<name>)|(<algonumber>) <hexstring>\n"
698   "\n"
699   "The client can use this command to tell the server about the data\n"
700   "(which usually is a hash) to be signed.";
701 static gpg_error_t
702 cmd_sethash (assuan_context_t ctx, char *line)
703 {
704   int rc;
705   size_t n;
706   char *p;
707   ctrl_t ctrl = assuan_get_pointer (ctx);
708   unsigned char *buf;
709   char *endp;
710   int algo;
711
712   /* Parse the alternative hash options which may be used instead of
713      the algo number.  */
714   if (has_option_name (line, "--hash"))
715     {
716       if (has_option (line, "--hash=sha1"))
717         algo = GCRY_MD_SHA1;
718       else if (has_option (line, "--hash=sha224"))
719         algo = GCRY_MD_SHA224;
720       else if (has_option (line, "--hash=sha256"))
721         algo = GCRY_MD_SHA256;
722       else if (has_option (line, "--hash=sha384"))
723         algo = GCRY_MD_SHA384;
724       else if (has_option (line, "--hash=sha512"))
725         algo = GCRY_MD_SHA512;
726       else if (has_option (line, "--hash=rmd160"))
727         algo = GCRY_MD_RMD160;
728       else if (has_option (line, "--hash=md5"))
729         algo = GCRY_MD_MD5;
730       else if (has_option (line, "--hash=tls-md5sha1"))
731         algo = MD_USER_TLS_MD5SHA1;
732       else
733         return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
734     }
735   else
736     algo = 0;
737
738   line = skip_options (line);
739
740   if (!algo)
741     {
742       /* No hash option has been given: require an algo number instead  */
743       algo = (int)strtoul (line, &endp, 10);
744       for (line = endp; *line == ' ' || *line == '\t'; line++)
745         ;
746       if (!algo || gcry_md_test_algo (algo))
747         return set_error (GPG_ERR_UNSUPPORTED_ALGORITHM, NULL);
748     }
749   ctrl->digest.algo = algo;
750   ctrl->digest.raw_value = 0;
751
752   /* Parse the hash value. */
753   n = 0;
754   rc = parse_hexstring (ctx, line, &n);
755   if (rc)
756     return rc;
757   n /= 2;
758   if (algo == MD_USER_TLS_MD5SHA1 && n == 36)
759     ;
760   else if (n != 16 && n != 20 && n != 24
761            && n != 28 && n != 32 && n != 48 && n != 64)
762     return set_error (GPG_ERR_ASS_PARAMETER, "unsupported length of hash");
763
764   if (n > MAX_DIGEST_LEN)
765     return set_error (GPG_ERR_ASS_PARAMETER, "hash value to long");
766
767   buf = ctrl->digest.value;
768   ctrl->digest.valuelen = n;
769   for (p=line, n=0; n < ctrl->digest.valuelen; p += 2, n++)
770     buf[n] = xtoi_2 (p);
771   for (; n < ctrl->digest.valuelen; n++)
772     buf[n] = 0;
773   return 0;
774 }
775
776
777 static const char hlp_pksign[] =
778   "PKSIGN [<options>] [<cache_nonce>]\n"
779   "\n"
780   "Perform the actual sign operation.  Neither input nor output are\n"
781   "sensitive to eavesdropping.";
782 static gpg_error_t
783 cmd_pksign (assuan_context_t ctx, char *line)
784 {
785   int rc;
786   cache_mode_t cache_mode = CACHE_MODE_NORMAL;
787   ctrl_t ctrl = assuan_get_pointer (ctx);
788   membuf_t outbuf;
789   char *cache_nonce = NULL;
790   char *p;
791
792   line = skip_options (line);
793
794   p = line;
795   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
796     ;
797   *p = '\0';
798   if (*line)
799     cache_nonce = xtrystrdup (line);
800
801   if (opt.ignore_cache_for_signing)
802     cache_mode = CACHE_MODE_IGNORE;
803   else if (!ctrl->server_local->use_cache_for_signing)
804     cache_mode = CACHE_MODE_IGNORE;
805
806   init_membuf (&outbuf, 512);
807
808   rc = agent_pksign (ctrl, cache_nonce, ctrl->server_local->keydesc,
809                      &outbuf, cache_mode);
810   if (rc)
811     clear_outbuf (&outbuf);
812   else
813     rc = write_and_clear_outbuf (ctx, &outbuf);
814
815   xfree (cache_nonce);
816   xfree (ctrl->server_local->keydesc);
817   ctrl->server_local->keydesc = NULL;
818   return leave_cmd (ctx, rc);
819 }
820
821
822 static const char hlp_pkdecrypt[] =
823   "PKDECRYPT [<options>]\n"
824   "\n"
825   "Perform the actual decrypt operation.  Input is not\n"
826   "sensitive to eavesdropping.";
827 static gpg_error_t
828 cmd_pkdecrypt (assuan_context_t ctx, char *line)
829 {
830   int rc;
831   ctrl_t ctrl = assuan_get_pointer (ctx);
832   unsigned char *value;
833   size_t valuelen;
834   membuf_t outbuf;
835   int padding;
836
837   (void)line;
838
839   /* First inquire the data to decrypt */
840   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_CIPHERTEXT);
841   if (!rc)
842     rc = assuan_inquire (ctx, "CIPHERTEXT",
843                         &value, &valuelen, MAXLEN_CIPHERTEXT);
844   if (rc)
845     return rc;
846
847   init_membuf (&outbuf, 512);
848
849   rc = agent_pkdecrypt (ctrl, ctrl->server_local->keydesc,
850                         value, valuelen, &outbuf, &padding);
851   xfree (value);
852   if (rc)
853     clear_outbuf (&outbuf);
854   else
855     {
856       if (padding != -1)
857         rc = print_assuan_status (ctx, "PADDING", "%d", padding);
858       else
859         rc = 0;
860       if (!rc)
861         rc = write_and_clear_outbuf (ctx, &outbuf);
862     }
863   xfree (ctrl->server_local->keydesc);
864   ctrl->server_local->keydesc = NULL;
865   return leave_cmd (ctx, rc);
866 }
867
868
869 static const char hlp_genkey[] =
870   "GENKEY [--no-protection] [--preset] [--inq-passwd]\n"
871   "       [--passwd-nonce=<s>] [<cache_nonce>]\n"
872   "\n"
873   "Generate a new key, store the secret part and return the public\n"
874   "part.  Here is an example transaction:\n"
875   "\n"
876   "  C: GENKEY\n"
877   "  S: INQUIRE KEYPARAM\n"
878   "  C: D (genkey (rsa (nbits  2048)))\n"
879   "  C: END\n"
880   "  S: D (public-key\n"
881   "  S: D   (rsa (n 326487324683264) (e 10001)))\n"
882   "  S: OK key created\n"
883   "\n"
884   "When the --preset option is used the passphrase for the generated\n"
885   "key will be added to the cache.  When --inq-passwd is used an inquire\n"
886   "with the keyword NEWPASSWD is used to request the passphrase for the\n"
887   "new key.  When a --passwd-nonce is used, the corresponding cached\n"
888   "passphrase is used to protect the new key.";
889 static gpg_error_t
890 cmd_genkey (assuan_context_t ctx, char *line)
891 {
892   ctrl_t ctrl = assuan_get_pointer (ctx);
893   int rc;
894   int no_protection;
895   unsigned char *value;
896   size_t valuelen;
897   unsigned char *newpasswd = NULL;
898   membuf_t outbuf;
899   char *cache_nonce = NULL;
900   char *passwd_nonce = NULL;
901   int opt_preset;
902   int opt_inq_passwd;
903   size_t n;
904   char *p, *pend;
905   int c;
906
907   if (ctrl->restricted)
908     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
909
910   no_protection = has_option (line, "--no-protection");
911   opt_preset = has_option (line, "--preset");
912   opt_inq_passwd = has_option (line, "--inq-passwd");
913   passwd_nonce = option_value (line, "--passwd-nonce");
914   if (passwd_nonce)
915     {
916       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
917         ;
918       c = *pend;
919       *pend = '\0';
920       passwd_nonce = xtrystrdup (passwd_nonce);
921       *pend = c;
922       if (!passwd_nonce)
923         {
924           rc = gpg_error_from_syserror ();
925           goto leave;
926         }
927     }
928   line = skip_options (line);
929
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 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   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
2108     ;
2109   *p = '\0';
2110   if (*line)
2111     cache_nonce = xtrystrdup (line);
2112
2113   assuan_begin_confidential (ctx);
2114   err = assuan_inquire (ctx, "KEYDATA",
2115                         &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
2116   assuan_end_confidential (ctx);
2117   if (err)
2118     goto leave;
2119   if (wrappedkeylen < 24)
2120     {
2121       err = gpg_error (GPG_ERR_INV_LENGTH);
2122       goto leave;
2123     }
2124   keylen = wrappedkeylen - 8;
2125   key = xtrymalloc_secure (keylen);
2126   if (!key)
2127     {
2128       err = gpg_error_from_syserror ();
2129       goto leave;
2130     }
2131
2132   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2133                           GCRY_CIPHER_MODE_AESWRAP, 0);
2134   if (err)
2135     goto leave;
2136   err = gcry_cipher_setkey (cipherhd,
2137                             ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
2138   if (err)
2139     goto leave;
2140   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
2141   if (err)
2142     goto leave;
2143   gcry_cipher_close (cipherhd);
2144   cipherhd = NULL;
2145   xfree (wrappedkey);
2146   wrappedkey = NULL;
2147
2148   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
2149   if (!realkeylen)
2150     goto leave; /* Invalid canonical encoded S-expression.  */
2151
2152   err = keygrip_from_canon_sexp (key, realkeylen, grip);
2153   if (err)
2154     {
2155       /* This might be due to an unsupported S-expression format.
2156          Check whether this is openpgp-private-key and trigger that
2157          import code.  */
2158       if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
2159         {
2160           const char *tag;
2161           size_t taglen;
2162
2163           tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
2164           if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
2165             ;
2166           else
2167             {
2168               gcry_sexp_release (openpgp_sexp);
2169               openpgp_sexp = NULL;
2170             }
2171         }
2172       if (!openpgp_sexp)
2173         goto leave; /* Note that ERR is still set.  */
2174     }
2175
2176
2177   if (openpgp_sexp)
2178     {
2179       /* In most cases the key is encrypted and thus the conversion
2180          function from the OpenPGP format to our internal format will
2181          ask for a passphrase.  That passphrase will be returned and
2182          used to protect the key using the same code as for regular
2183          key import. */
2184
2185       xfree (key);
2186       key = NULL;
2187       err = convert_from_openpgp (ctrl, openpgp_sexp, force, grip,
2188                                   ctrl->server_local->keydesc, cache_nonce,
2189                                   &key, opt_unattended? NULL : &passphrase);
2190       if (err)
2191         goto leave;
2192       realkeylen = gcry_sexp_canon_len (key, 0, NULL, &err);
2193       if (!realkeylen)
2194         goto leave; /* Invalid canonical encoded S-expression.  */
2195       if (passphrase)
2196         {
2197           assert (!opt_unattended);
2198           if (!cache_nonce)
2199             {
2200               char buf[12];
2201               gcry_create_nonce (buf, 12);
2202               cache_nonce = bin2hex (buf, 12, NULL);
2203             }
2204           if (cache_nonce
2205               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2206                                    passphrase, CACHE_TTL_NONCE))
2207             assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2208         }
2209     }
2210   else if (opt_unattended)
2211     {
2212       err = set_error (GPG_ERR_ASS_PARAMETER,
2213                        "\"--unattended\" may only be used with OpenPGP keys");
2214       goto leave;
2215     }
2216   else
2217     {
2218       if (!force && !agent_key_available (grip))
2219         err = gpg_error (GPG_ERR_EEXIST);
2220       else
2221         {
2222           char *prompt = xtryasprintf
2223             (_("Please enter the passphrase to protect the "
2224                "imported object within the %s system."), GNUPG_NAME);
2225           if (!prompt)
2226             err = gpg_error_from_syserror ();
2227           else
2228             err = agent_ask_new_passphrase (ctrl, prompt, &passphrase);
2229           xfree (prompt);
2230         }
2231       if (err)
2232         goto leave;
2233     }
2234
2235   if (passphrase)
2236     {
2237       err = agent_protect (key, passphrase, &finalkey, &finalkeylen,
2238                            ctrl->s2k_count, -1);
2239       if (!err)
2240         err = agent_write_private_key (grip, finalkey, finalkeylen, force);
2241     }
2242   else
2243     err = agent_write_private_key (grip, key, realkeylen, force);
2244
2245  leave:
2246   gcry_sexp_release (openpgp_sexp);
2247   xfree (finalkey);
2248   xfree (passphrase);
2249   xfree (key);
2250   gcry_cipher_close (cipherhd);
2251   xfree (wrappedkey);
2252   xfree (cache_nonce);
2253   xfree (ctrl->server_local->keydesc);
2254   ctrl->server_local->keydesc = NULL;
2255   return leave_cmd (ctx, err);
2256 }
2257
2258
2259 \f
2260 static const char hlp_export_key[] =
2261   "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
2262   "\n"
2263   "Export a secret key from the key store.  The key will be encrypted\n"
2264   "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
2265   "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
2266   "prior to using this command.  The function takes the keygrip as argument.\n"
2267   "\n"
2268   "If --openpgp is used, the secret key material will be exported in RFC 4880\n"
2269   "compatible passphrase-protected form.  Without --openpgp, the secret key\n"
2270   "material will be exported in the clear (after prompting the user to unlock\n"
2271   "it, if needed).\n";
2272 static gpg_error_t
2273 cmd_export_key (assuan_context_t ctx, char *line)
2274 {
2275   ctrl_t ctrl = assuan_get_pointer (ctx);
2276   gpg_error_t err;
2277   unsigned char grip[20];
2278   gcry_sexp_t s_skey = NULL;
2279   unsigned char *key = NULL;
2280   size_t keylen;
2281   gcry_cipher_hd_t cipherhd = NULL;
2282   unsigned char *wrappedkey = NULL;
2283   size_t wrappedkeylen;
2284   int openpgp;
2285   char *cache_nonce;
2286   char *passphrase = NULL;
2287   unsigned char *shadow_info = NULL;
2288   char *pend;
2289   int c;
2290
2291   if (ctrl->restricted)
2292     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2293
2294   openpgp = has_option (line, "--openpgp");
2295   cache_nonce = option_value (line, "--cache-nonce");
2296   if (cache_nonce)
2297     {
2298       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
2299         ;
2300       c = *pend;
2301       *pend = '\0';
2302       cache_nonce = xtrystrdup (cache_nonce);
2303       *pend = c;
2304       if (!cache_nonce)
2305         {
2306           err = gpg_error_from_syserror ();
2307           goto leave;
2308         }
2309     }
2310   line = skip_options (line);
2311
2312   if (!ctrl->server_local->export_key)
2313     {
2314       err = set_error (GPG_ERR_MISSING_KEY, "did you run KEYWRAP_KEY ?");
2315       goto leave;
2316     }
2317
2318   err = parse_keygrip (ctx, line, grip);
2319   if (err)
2320     goto leave;
2321
2322   if (agent_key_available (grip))
2323     {
2324       err = gpg_error (GPG_ERR_NO_SECKEY);
2325       goto leave;
2326     }
2327
2328   /* Get the key from the file.  With the openpgp flag we also ask for
2329      the passphrase so that we can use it to re-encrypt it.  */
2330   err = agent_key_from_file (ctrl, cache_nonce,
2331                              ctrl->server_local->keydesc, grip,
2332                              &shadow_info, CACHE_MODE_IGNORE, NULL, &s_skey,
2333                              openpgp ? &passphrase : NULL);
2334   if (err)
2335     goto leave;
2336   if (shadow_info)
2337     {
2338       /* Key is on a smartcard.  */
2339       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2340       goto leave;
2341     }
2342
2343   if (openpgp)
2344     {
2345       /* The openpgp option changes the key format into the OpenPGP
2346          key transfer format.  The result is already a padded
2347          canonical S-expression.  */
2348       if (!passphrase)
2349         {
2350           err = agent_ask_new_passphrase
2351             (ctrl, _("This key (or subkey) is not protected with a passphrase."
2352                      "  Please enter a new passphrase to export it."),
2353              &passphrase);
2354           if (err)
2355             goto leave;
2356         }
2357       err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
2358       if (!err && passphrase)
2359         {
2360           if (!cache_nonce)
2361             {
2362               char buf[12];
2363               gcry_create_nonce (buf, 12);
2364               cache_nonce = bin2hex (buf, 12, NULL);
2365             }
2366           if (cache_nonce
2367               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2368                                    passphrase, CACHE_TTL_NONCE))
2369             {
2370               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2371               xfree (ctrl->server_local->last_cache_nonce);
2372               ctrl->server_local->last_cache_nonce = cache_nonce;
2373               cache_nonce = NULL;
2374             }
2375         }
2376     }
2377   else
2378     {
2379       /* Convert into a canonical S-expression and wrap that.  */
2380       err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
2381     }
2382   if (err)
2383     goto leave;
2384   gcry_sexp_release (s_skey);
2385   s_skey = NULL;
2386
2387   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2388                           GCRY_CIPHER_MODE_AESWRAP, 0);
2389   if (err)
2390     goto leave;
2391   err = gcry_cipher_setkey (cipherhd,
2392                             ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
2393   if (err)
2394     goto leave;
2395
2396   wrappedkeylen = keylen + 8;
2397   wrappedkey = xtrymalloc (wrappedkeylen);
2398   if (!wrappedkey)
2399     {
2400       err = gpg_error_from_syserror ();
2401       goto leave;
2402     }
2403
2404   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
2405   if (err)
2406     goto leave;
2407   xfree (key);
2408   key = NULL;
2409   gcry_cipher_close (cipherhd);
2410   cipherhd = NULL;
2411
2412   assuan_begin_confidential (ctx);
2413   err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
2414   assuan_end_confidential (ctx);
2415
2416
2417  leave:
2418   xfree (cache_nonce);
2419   xfree (passphrase);
2420   xfree (wrappedkey);
2421   gcry_cipher_close (cipherhd);
2422   xfree (key);
2423   gcry_sexp_release (s_skey);
2424   xfree (ctrl->server_local->keydesc);
2425   ctrl->server_local->keydesc = NULL;
2426   xfree (shadow_info);
2427
2428   return leave_cmd (ctx, err);
2429 }
2430
2431
2432 \f
2433 static const char hlp_delete_key[] =
2434   "DELETE_KEY [--force|--stub-only] <hexstring_with_keygrip>\n"
2435   "\n"
2436   "Delete a secret key from the key store.  If --force is used\n"
2437   "and a loopback pinentry is allowed, the agent will not ask\n"
2438   "the user for confirmation.  If --stub-only is used the key will\n"
2439   "only be deleted if it is a reference to a token.";
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, stub_only;
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   stub_only = has_option (line, "--stub-only");
2453   line = skip_options (line);
2454
2455   /* If the use of a loopback pinentry has been disabled, we assume
2456    * that a silent deletion of keys shall also not be allowed.  */
2457   if (!opt.allow_loopback_pinentry)
2458     force = 0;
2459
2460   err = parse_keygrip (ctx, line, grip);
2461   if (err)
2462     goto leave;
2463
2464   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip,
2465                           force, stub_only);
2466   if (err)
2467     goto leave;
2468
2469  leave:
2470   xfree (ctrl->server_local->keydesc);
2471   ctrl->server_local->keydesc = NULL;
2472
2473   return leave_cmd (ctx, err);
2474 }
2475
2476
2477 \f
2478 #if SIZEOF_TIME_T > SIZEOF_UNSIGNED_LONG
2479 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010llu))"
2480 #else
2481 #define KEYTOCARD_TIMESTAMP_FORMAT "(10:created-at10:%010lu))"
2482 #endif
2483
2484 static const char hlp_keytocard[] =
2485   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2486   "\n";
2487 static gpg_error_t
2488 cmd_keytocard (assuan_context_t ctx, char *line)
2489 {
2490   ctrl_t ctrl = assuan_get_pointer (ctx);
2491   int force;
2492   gpg_error_t err = 0;
2493   unsigned char grip[20];
2494   gcry_sexp_t s_skey = NULL;
2495   unsigned char *keydata;
2496   size_t keydatalen;
2497   const char *serialno, *timestamp_str, *id;
2498   unsigned char *shadow_info = NULL;
2499   time_t timestamp;
2500
2501   if (ctrl->restricted)
2502     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2503
2504   force = has_option (line, "--force");
2505   line = skip_options (line);
2506
2507   err = parse_keygrip (ctx, line, grip);
2508   if (err)
2509     goto leave;
2510
2511   if (agent_key_available (grip))
2512     {
2513       err =gpg_error (GPG_ERR_NO_SECKEY);
2514       goto leave;
2515     }
2516
2517   /* Fixme: Replace the parsing code by split_fields().  */
2518   line += 40;
2519   while (*line && (*line == ' ' || *line == '\t'))
2520     line++;
2521   serialno = line;
2522   while (*line && (*line != ' ' && *line != '\t'))
2523     line++;
2524   if (!*line)
2525     {
2526       err = gpg_error (GPG_ERR_MISSING_VALUE);
2527       goto leave;
2528     }
2529   *line = '\0';
2530   line++;
2531   while (*line && (*line == ' ' || *line == '\t'))
2532     line++;
2533   id = line;
2534   while (*line && (*line != ' ' && *line != '\t'))
2535     line++;
2536   if (!*line)
2537     {
2538       err = gpg_error (GPG_ERR_MISSING_VALUE);
2539       goto leave;
2540     }
2541   *line = '\0';
2542   line++;
2543   while (*line && (*line == ' ' || *line == '\t'))
2544     line++;
2545   timestamp_str = line;
2546   while (*line && (*line != ' ' && *line != '\t'))
2547     line++;
2548   if (*line)
2549     *line = '\0';
2550
2551   if ((timestamp = isotime2epoch (timestamp_str)) == (time_t)(-1))
2552     {
2553       err = gpg_error (GPG_ERR_INV_TIME);
2554       goto leave;
2555     }
2556
2557   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2558                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2559                              &s_skey, NULL);
2560   if (err)
2561     {
2562       xfree (shadow_info);
2563       goto leave;
2564     }
2565   if (shadow_info)
2566     {
2567       /* Key is on a smartcard already.  */
2568       xfree (shadow_info);
2569       gcry_sexp_release (s_skey);
2570       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2571       goto leave;
2572     }
2573
2574   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2575   keydata = xtrymalloc_secure (keydatalen + 30);
2576   if (keydata == NULL)
2577     {
2578       err = gpg_error_from_syserror ();
2579       gcry_sexp_release (s_skey);
2580       goto leave;
2581     }
2582
2583   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2584   gcry_sexp_release (s_skey);
2585   keydatalen--;                 /* Decrement for last '\0'.  */
2586   /* Add timestamp "created-at" in the private key */
2587   snprintf (keydata+keydatalen-1, 30, KEYTOCARD_TIMESTAMP_FORMAT, timestamp);
2588   keydatalen += 10 + 19 - 1;
2589   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2590   xfree (keydata);
2591
2592  leave:
2593   return leave_cmd (ctx, err);
2594 }
2595
2596
2597 \f
2598 static const char hlp_getval[] =
2599   "GETVAL <key>\n"
2600   "\n"
2601   "Return the value for KEY from the special environment as created by\n"
2602   "PUTVAL.";
2603 static gpg_error_t
2604 cmd_getval (assuan_context_t ctx, char *line)
2605 {
2606   ctrl_t ctrl = assuan_get_pointer (ctx);
2607   int rc = 0;
2608   char *key = NULL;
2609   char *p;
2610   struct putval_item_s *vl;
2611
2612   if (ctrl->restricted)
2613     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2614
2615   for (p=line; *p == ' '; p++)
2616     ;
2617   key = p;
2618   p = strchr (key, ' ');
2619   if (p)
2620     {
2621       *p++ = 0;
2622       for (; *p == ' '; p++)
2623         ;
2624       if (*p)
2625         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2626     }
2627   if (!*key)
2628     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2629
2630
2631   for (vl=putval_list; vl; vl = vl->next)
2632     if ( !strcmp (vl->d, key) )
2633       break;
2634
2635   if (vl) /* Got an entry. */
2636     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2637   else
2638     return gpg_error (GPG_ERR_NO_DATA);
2639
2640   return leave_cmd (ctx, rc);
2641 }
2642
2643
2644 static const char hlp_putval[] =
2645   "PUTVAL <key> [<percent_escaped_value>]\n"
2646   "\n"
2647   "The gpg-agent maintains a kind of environment which may be used to\n"
2648   "store key/value pairs in it, so that they can be retrieved later.\n"
2649   "This may be used by helper daemons to daemonize themself on\n"
2650   "invocation and register them with gpg-agent.  Callers of the\n"
2651   "daemon's service may now first try connect to get the information\n"
2652   "for that service from gpg-agent through the GETVAL command and then\n"
2653   "try to connect to that daemon.  Only if that fails they may start\n"
2654   "an own instance of the service daemon. \n"
2655   "\n"
2656   "KEY is an arbitrary symbol with the same syntax rules as keys\n"
2657   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2658   "corresponding value; they should be similar to the values of\n"
2659   "envronment variables but gpg-agent does not enforce any\n"
2660   "restrictions.  If that value is not given any value under that KEY\n"
2661   "is removed from this special environment.";
2662 static gpg_error_t
2663 cmd_putval (assuan_context_t ctx, char *line)
2664 {
2665   ctrl_t ctrl = assuan_get_pointer (ctx);
2666   int rc = 0;
2667   char *key = NULL;
2668   char *value = NULL;
2669   size_t valuelen = 0;
2670   char *p;
2671   struct putval_item_s *vl, *vlprev;
2672
2673   if (ctrl->restricted)
2674     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2675
2676   for (p=line; *p == ' '; p++)
2677     ;
2678   key = p;
2679   p = strchr (key, ' ');
2680   if (p)
2681     {
2682       *p++ = 0;
2683       for (; *p == ' '; p++)
2684         ;
2685       if (*p)
2686         {
2687           value = p;
2688           p = strchr (value, ' ');
2689           if (p)
2690             *p = 0;
2691           valuelen = percent_plus_unescape_inplace (value, 0);
2692         }
2693     }
2694   if (!*key)
2695     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2696
2697
2698   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2699     if ( !strcmp (vl->d, key) )
2700       break;
2701
2702   if (vl) /* Delete old entry. */
2703     {
2704       if (vlprev)
2705         vlprev->next = vl->next;
2706       else
2707         putval_list = vl->next;
2708       xfree (vl);
2709     }
2710
2711   if (valuelen) /* Add entry. */
2712     {
2713       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2714       if (!vl)
2715         rc = gpg_error_from_syserror ();
2716       else
2717         {
2718           vl->len = valuelen;
2719           vl->off = strlen (key) + 1;
2720           strcpy (vl->d, key);
2721           memcpy (vl->d + vl->off, value, valuelen);
2722           vl->next = putval_list;
2723           putval_list = vl;
2724         }
2725     }
2726
2727   return leave_cmd (ctx, rc);
2728 }
2729
2730
2731
2732 \f
2733 static const char hlp_updatestartuptty[] =
2734   "UPDATESTARTUPTTY\n"
2735   "\n"
2736   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2737   "session.  This command is useful to pull future pinentries to\n"
2738   "another screen.  It is only required because there is no way in the\n"
2739   "ssh-agent protocol to convey this information.";
2740 static gpg_error_t
2741 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2742 {
2743   ctrl_t ctrl = assuan_get_pointer (ctx);
2744   gpg_error_t err = 0;
2745   session_env_t se;
2746   char *lc_ctype = NULL;
2747   char *lc_messages = NULL;
2748   int iterator;
2749   const char *name;
2750
2751   (void)line;
2752
2753   if (ctrl->restricted)
2754     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2755
2756   se = session_env_new ();
2757   if (!se)
2758     err = gpg_error_from_syserror ();
2759
2760   iterator = 0;
2761   while (!err && (name = session_env_list_stdenvnames (&iterator, NULL)))
2762     {
2763       const char *value = session_env_getenv (ctrl->session_env, name);
2764       if (value)
2765         err = session_env_setenv (se, name, value);
2766     }
2767
2768   if (!err && ctrl->lc_ctype)
2769     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2770       err = gpg_error_from_syserror ();
2771
2772   if (!err && ctrl->lc_messages)
2773     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2774       err = gpg_error_from_syserror ();
2775
2776   if (err)
2777     {
2778       session_env_release (se);
2779       xfree (lc_ctype);
2780       xfree (lc_messages);
2781     }
2782   else
2783     {
2784       session_env_release (opt.startup_env);
2785       opt.startup_env = se;
2786       xfree (opt.startup_lc_ctype);
2787       opt.startup_lc_ctype = lc_ctype;
2788       xfree (opt.startup_lc_messages);
2789       opt.startup_lc_messages = lc_messages;
2790     }
2791
2792   return err;
2793 }
2794
2795
2796 \f
2797 static const char hlp_killagent[] =
2798   "KILLAGENT\n"
2799   "\n"
2800   "Stop the agent.";
2801 static gpg_error_t
2802 cmd_killagent (assuan_context_t ctx, char *line)
2803 {
2804   ctrl_t ctrl = assuan_get_pointer (ctx);
2805
2806   (void)line;
2807
2808   if (ctrl->restricted)
2809     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2810
2811   ctrl->server_local->stopme = 1;
2812   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2813   return 0;
2814 }
2815
2816
2817 static const char hlp_reloadagent[] =
2818   "RELOADAGENT\n"
2819   "\n"
2820   "This command is an alternative to SIGHUP\n"
2821   "to reload the configuration.";
2822 static gpg_error_t
2823 cmd_reloadagent (assuan_context_t ctx, char *line)
2824 {
2825   ctrl_t ctrl = assuan_get_pointer (ctx);
2826
2827   (void)line;
2828
2829   if (ctrl->restricted)
2830     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2831
2832   agent_sighup_action ();
2833   return 0;
2834 }
2835
2836
2837 \f
2838 static const char hlp_getinfo[] =
2839   "GETINFO <what>\n"
2840   "\n"
2841   "Multipurpose function to return a variety of information.\n"
2842   "Supported values for WHAT are:\n"
2843   "\n"
2844   "  version     - Return the version of the program.\n"
2845   "  pid         - Return the process id of the server.\n"
2846   "  socket_name - Return the name of the socket.\n"
2847   "  ssh_socket_name - Return the name of the ssh socket.\n"
2848   "  scd_running - Return OK if the SCdaemon is already running.\n"
2849   "  s2k_count   - Return the calibrated S2K count.\n"
2850   "  std_env_names   - List the names of the standard environment.\n"
2851   "  std_session_env - List the standard session environment.\n"
2852   "  std_startup_env - List the standard startup environment.\n"
2853   "  cmd_has_option\n"
2854   "              - Returns OK if the command CMD implements the option OPT.\n"
2855   "  connections - Return number of active connections.\n"
2856   "  restricted  - Returns OK if the connection is in restricted mode.\n";
2857 static gpg_error_t
2858 cmd_getinfo (assuan_context_t ctx, char *line)
2859 {
2860   ctrl_t ctrl = assuan_get_pointer (ctx);
2861   int rc = 0;
2862
2863   if (!strcmp (line, "version"))
2864     {
2865       const char *s = VERSION;
2866       rc = assuan_send_data (ctx, s, strlen (s));
2867     }
2868   else if (!strncmp (line, "cmd_has_option", 14)
2869            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2870     {
2871       char *cmd, *cmdopt;
2872       line += 14;
2873       while (*line == ' ' || *line == '\t')
2874         line++;
2875       if (!*line)
2876         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2877       else
2878         {
2879           cmd = line;
2880           while (*line && (*line != ' ' && *line != '\t'))
2881             line++;
2882           if (!*line)
2883             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2884           else
2885             {
2886               *line++ = 0;
2887               while (*line == ' ' || *line == '\t')
2888                 line++;
2889               if (!*line)
2890                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2891               else
2892                 {
2893                   cmdopt = line;
2894                   if (!command_has_option (cmd, cmdopt))
2895                     rc = gpg_error (GPG_ERR_GENERAL);
2896                 }
2897             }
2898         }
2899     }
2900   else if (!strcmp (line, "s2k_count"))
2901     {
2902       char numbuf[50];
2903
2904       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2905       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2906     }
2907   else if (!strcmp (line, "restricted"))
2908     {
2909       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2910     }
2911   else if (ctrl->restricted)
2912     {
2913       rc = gpg_error (GPG_ERR_FORBIDDEN);
2914     }
2915   /* All sub-commands below are not allowed in restricted mode.  */
2916   else if (!strcmp (line, "pid"))
2917     {
2918       char numbuf[50];
2919
2920       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2921       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2922     }
2923   else if (!strcmp (line, "socket_name"))
2924     {
2925       const char *s = get_agent_socket_name ();
2926
2927       if (s)
2928         rc = assuan_send_data (ctx, s, strlen (s));
2929       else
2930         rc = gpg_error (GPG_ERR_NO_DATA);
2931     }
2932   else if (!strcmp (line, "ssh_socket_name"))
2933     {
2934       const char *s = get_agent_ssh_socket_name ();
2935
2936       if (s)
2937         rc = assuan_send_data (ctx, s, strlen (s));
2938       else
2939         rc = gpg_error (GPG_ERR_NO_DATA);
2940     }
2941   else if (!strcmp (line, "scd_running"))
2942     {
2943       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2944     }
2945   else if (!strcmp (line, "std_env_names"))
2946     {
2947       int iterator;
2948       const char *name;
2949
2950       iterator = 0;
2951       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2952         {
2953           rc = assuan_send_data (ctx, name, strlen (name)+1);
2954           if (!rc)
2955             rc = assuan_send_data (ctx, NULL, 0);
2956           if (rc)
2957             break;
2958         }
2959     }
2960   else if (!strcmp (line, "std_session_env")
2961            || !strcmp (line, "std_startup_env"))
2962     {
2963       int iterator;
2964       const char *name, *value;
2965       char *string;
2966
2967       iterator = 0;
2968       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2969         {
2970           value = session_env_getenv_or_default
2971             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2972           if (value)
2973             {
2974               string = xtryasprintf ("%s=%s", name, value);
2975               if (!string)
2976                 rc = gpg_error_from_syserror ();
2977               else
2978                 {
2979                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2980                   if (!rc)
2981                     rc = assuan_send_data (ctx, NULL, 0);
2982                 }
2983               if (rc)
2984                 break;
2985             }
2986         }
2987     }
2988   else if (!strcmp (line, "connections"))
2989     {
2990       char numbuf[20];
2991
2992       snprintf (numbuf, sizeof numbuf, "%d",
2993                 get_agent_active_connection_count ());
2994       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2995     }
2996   else
2997     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
2998   return rc;
2999 }
3000
3001
3002 \f
3003 /* This function is called by Libassuan to parse the OPTION command.
3004    It has been registered similar to the other Assuan commands.  */
3005 static gpg_error_t
3006 option_handler (assuan_context_t ctx, const char *key, const char *value)
3007 {
3008   ctrl_t ctrl = assuan_get_pointer (ctx);
3009   gpg_error_t err = 0;
3010
3011   if (!strcmp (key, "agent-awareness"))
3012     {
3013       /* The value is a version string telling us of which agent
3014          version the caller is aware of.  */
3015       ctrl->server_local->allow_fully_canceled =
3016         gnupg_compare_version (value, "2.1.0");
3017     }
3018   else if (ctrl->restricted)
3019     {
3020       err = gpg_error (GPG_ERR_FORBIDDEN);
3021     }
3022   /* All options below are not allowed in restricted mode.  */
3023   else if (!strcmp (key, "putenv"))
3024     {
3025       /* Change the session's environment to be used for the
3026          Pinentry.  Valid values are:
3027           <NAME>            Delete envvar NAME
3028           <KEY>=            Set envvar NAME to the empty string
3029           <KEY>=<VALUE>     Set envvar NAME to VALUE
3030       */
3031       err = session_env_putenv (ctrl->session_env, value);
3032     }
3033   else if (!strcmp (key, "display"))
3034     {
3035       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
3036     }
3037   else if (!strcmp (key, "ttyname"))
3038     {
3039       if (!opt.keep_tty)
3040         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
3041     }
3042   else if (!strcmp (key, "ttytype"))
3043     {
3044       if (!opt.keep_tty)
3045         err = session_env_setenv (ctrl->session_env, "TERM", value);
3046     }
3047   else if (!strcmp (key, "lc-ctype"))
3048     {
3049       if (ctrl->lc_ctype)
3050         xfree (ctrl->lc_ctype);
3051       ctrl->lc_ctype = xtrystrdup (value);
3052       if (!ctrl->lc_ctype)
3053         return out_of_core ();
3054     }
3055   else if (!strcmp (key, "lc-messages"))
3056     {
3057       if (ctrl->lc_messages)
3058         xfree (ctrl->lc_messages);
3059       ctrl->lc_messages = xtrystrdup (value);
3060       if (!ctrl->lc_messages)
3061         return out_of_core ();
3062     }
3063   else if (!strcmp (key, "xauthority"))
3064     {
3065       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
3066     }
3067   else if (!strcmp (key, "pinentry-user-data"))
3068     {
3069       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
3070     }
3071   else if (!strcmp (key, "use-cache-for-signing"))
3072     ctrl->server_local->use_cache_for_signing = *value? !!atoi (value) : 0;
3073   else if (!strcmp (key, "allow-pinentry-notify"))
3074     ctrl->server_local->allow_pinentry_notify = 1;
3075   else if (!strcmp (key, "pinentry-mode"))
3076     {
3077       int tmp = parse_pinentry_mode (value);
3078       if (tmp == -1)
3079         err = gpg_error (GPG_ERR_INV_VALUE);
3080       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
3081         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3082       else
3083         ctrl->pinentry_mode = tmp;
3084     }
3085   else if (!strcmp (key, "cache-ttl-opt-preset"))
3086     {
3087       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
3088     }
3089   else if (!strcmp (key, "s2k-count"))
3090     {
3091       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
3092       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
3093         {
3094           ctrl->s2k_count = 0;
3095         }
3096     }
3097   else
3098     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
3099
3100   return err;
3101 }
3102
3103
3104
3105 \f
3106 /* Called by libassuan after all commands. ERR is the error from the
3107    last assuan operation and not the one returned from the command. */
3108 static void
3109 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
3110 {
3111   ctrl_t ctrl = assuan_get_pointer (ctx);
3112
3113   (void)err;
3114
3115   /* Switch off any I/O monitor controlled logging pausing. */
3116   ctrl->server_local->pause_io_logging = 0;
3117 }
3118
3119
3120 /* This function is called by libassuan for all I/O.  We use it here
3121    to disable logging for the GETEVENTCOUNTER commands.  This is so
3122    that the debug output won't get cluttered by this primitive
3123    command.  */
3124 static unsigned int
3125 io_monitor (assuan_context_t ctx, void *hook, int direction,
3126             const char *line, size_t linelen)
3127 {
3128   ctrl_t ctrl = assuan_get_pointer (ctx);
3129
3130   (void) hook;
3131
3132   /* We want to suppress all Assuan log messages for connections from
3133    * self.  However, assuan_get_pid works only after
3134    * assuan_accept. Now, assuan_accept already logs a line ending with
3135    * the process id.  We use this hack here to get the peers pid so
3136    * that we can compare it to our pid.  We should add an assuan
3137    * function to return the pid for a file descriptor and use that to
3138    * detect connections to self.  */
3139   if (ctx && !ctrl->server_local->greeting_seen
3140       && direction == ASSUAN_IO_TO_PEER)
3141     {
3142       ctrl->server_local->greeting_seen = 1;
3143       if (linelen > 32
3144           && !strncmp (line, "OK Pleased to meet you, process ", 32)
3145           && strtoul (line+32, NULL, 10) == getpid ())
3146         return ASSUAN_IO_MONITOR_NOLOG;
3147     }
3148
3149
3150   /* Do not log self-connections.  This makes the log cleaner because
3151    * we won't see the check-our-own-socket calls.  */
3152   if (ctx && ctrl->server_local->connect_from_self)
3153     return ASSUAN_IO_MONITOR_NOLOG;
3154
3155   /* Note that we only check for the uppercase name.  This allows the user to
3156      see the logging for debugging if using a non-upercase command
3157      name. */
3158   if (ctx && direction == ASSUAN_IO_FROM_PEER
3159       && linelen >= 15
3160       && !strncmp (line, "GETEVENTCOUNTER", 15)
3161       && (linelen == 15 || spacep (line+15)))
3162     {
3163       ctrl->server_local->pause_io_logging = 1;
3164     }
3165
3166   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3167 }
3168
3169
3170 /* Return true if the command CMD implements the option OPT.  */
3171 static int
3172 command_has_option (const char *cmd, const char *cmdopt)
3173 {
3174   if (!strcmp (cmd, "GET_PASSPHRASE"))
3175     {
3176       if (!strcmp (cmdopt, "repeat"))
3177           return 1;
3178     }
3179
3180   return 0;
3181 }
3182
3183
3184 /* Tell Libassuan about our commands.  Also register the other Assuan
3185    handlers. */
3186 static int
3187 register_commands (assuan_context_t ctx)
3188 {
3189   static struct {
3190     const char *name;
3191     assuan_handler_t handler;
3192     const char * const help;
3193   } table[] = {
3194     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3195     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3196     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3197     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3198     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3199     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3200     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3201     { "SETHASH",        cmd_sethash,   hlp_sethash },
3202     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3203     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3204     { "GENKEY",         cmd_genkey,    hlp_genkey },
3205     { "READKEY",        cmd_readkey,   hlp_readkey },
3206     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3207     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3208     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3209     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3210     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3211     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3212     { "LEARN",          cmd_learn,     hlp_learn },
3213     { "PASSWD",         cmd_passwd,    hlp_passwd },
3214     { "INPUT",          NULL },
3215     { "OUTPUT",         NULL },
3216     { "SCD",            cmd_scd,       hlp_scd },
3217     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3218     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3219     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3220     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3221     { "GETVAL",         cmd_getval,    hlp_getval },
3222     { "PUTVAL",         cmd_putval,    hlp_putval },
3223     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3224     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3225     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3226     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3227     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3228     { NULL }
3229   };
3230   int i, rc;
3231
3232   for (i=0; table[i].name; i++)
3233     {
3234       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3235                                     table[i].help);
3236       if (rc)
3237         return rc;
3238     }
3239   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3240   assuan_register_reset_notify (ctx, reset_notify);
3241   assuan_register_option_handler (ctx, option_handler);
3242   return 0;
3243 }
3244
3245
3246 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3247    simple piper server, otherwise it is a regular server.  CTRL is the
3248    control structure for this connection; it has only the basic
3249    initialization. */
3250 void
3251 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3252 {
3253   int rc;
3254   assuan_context_t ctx = NULL;
3255
3256   if (ctrl->restricted)
3257     {
3258       if (agent_copy_startup_env (ctrl))
3259         return;
3260     }
3261
3262   rc = assuan_new (&ctx);
3263   if (rc)
3264     {
3265       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3266       agent_exit (2);
3267     }
3268
3269   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3270     {
3271       assuan_fd_t filedes[2];
3272
3273       filedes[0] = assuan_fdopen (0);
3274       filedes[1] = assuan_fdopen (1);
3275       rc = assuan_init_pipe_server (ctx, filedes);
3276     }
3277   else if (listen_fd != GNUPG_INVALID_FD)
3278     {
3279       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3280       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3281          this branch is currently not used.  */
3282     }
3283   else
3284     {
3285       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3286     }
3287   if (rc)
3288     {
3289       log_error ("failed to initialize the server: %s\n",
3290                  gpg_strerror(rc));
3291       agent_exit (2);
3292     }
3293   rc = register_commands (ctx);
3294   if (rc)
3295     {
3296       log_error ("failed to register commands with Assuan: %s\n",
3297                  gpg_strerror(rc));
3298       agent_exit (2);
3299     }
3300
3301   assuan_set_pointer (ctx, ctrl);
3302   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3303   ctrl->server_local->assuan_ctx = ctx;
3304   ctrl->server_local->use_cache_for_signing = 1;
3305
3306   ctrl->digest.raw_value = 0;
3307
3308   assuan_set_io_monitor (ctx, io_monitor, NULL);
3309   agent_set_progress_cb (progress_cb, ctrl);
3310
3311   for (;;)
3312     {
3313       pid_t client_pid;
3314
3315       rc = assuan_accept (ctx);
3316       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3317         {
3318           break;
3319         }
3320       else if (rc)
3321         {
3322           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3323           break;
3324         }
3325
3326       client_pid = assuan_get_pid (ctx);
3327       ctrl->server_local->connect_from_self = (client_pid == getpid ());
3328       if (client_pid != ASSUAN_INVALID_PID)
3329         ctrl->client_pid = (unsigned long)client_pid;
3330       else
3331         ctrl->client_pid = 0;
3332
3333       rc = assuan_process (ctx);
3334       if (rc)
3335         {
3336           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3337           continue;
3338         }
3339     }
3340
3341   /* Reset the nonce caches.  */
3342   clear_nonce_cache (ctrl);
3343
3344   /* Reset the SCD if needed. */
3345   agent_reset_scd (ctrl);
3346
3347   /* Reset the pinentry (in case of popup messages). */
3348   agent_reset_query (ctrl);
3349
3350   /* Cleanup.  */
3351   assuan_release (ctx);
3352   xfree (ctrl->server_local->keydesc);
3353   xfree (ctrl->server_local->import_key);
3354   xfree (ctrl->server_local->export_key);
3355   if (ctrl->server_local->stopme)
3356     agent_exit (0);
3357   xfree (ctrl->server_local);
3358   ctrl->server_local = NULL;
3359 }
3360
3361
3362 /* Helper for the pinentry loopback mode.  It merely passes the
3363    parameters on to the client.  */
3364 gpg_error_t
3365 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3366                   unsigned char **buffer, size_t *size,
3367                   size_t max_length)
3368 {
3369   gpg_error_t rc;
3370   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3371
3372   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3373   if (rc)
3374     return rc;
3375
3376   assuan_begin_confidential (ctx);
3377   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3378   assuan_end_confidential (ctx);
3379   return rc;
3380 }