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