agent: When the password cache is cleared, also clear the ext. cache.
[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)
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] [--inq-passwd] [<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  2048)))\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.  When --inq-passwd is used an inquire\n"
932   "with the keyword NEWPASSWD is used to request the passphrase for the\n"
933   "new key.\n";
934 static gpg_error_t
935 cmd_genkey (assuan_context_t ctx, char *line)
936 {
937   ctrl_t ctrl = assuan_get_pointer (ctx);
938   int rc;
939   int no_protection;
940   unsigned char *value;
941   size_t valuelen;
942   unsigned char *newpasswd = NULL;
943   membuf_t outbuf;
944   char *cache_nonce = NULL;
945   int opt_preset;
946   int opt_inq_passwd;
947   size_t n;
948   char *p;
949
950   if (ctrl->restricted)
951     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
952
953   no_protection = has_option (line, "--no-protection");
954   opt_preset = has_option (line, "--preset");
955   opt_inq_passwd = has_option (line, "--inq-passwd");
956   line = skip_options (line);
957
958   p = line;
959   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
960     ;
961   *p = '\0';
962   if (*line)
963     cache_nonce = xtrystrdup (line);
964
965   /* First inquire the parameters */
966   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%u", MAXLEN_KEYPARAM);
967   if (!rc)
968     rc = assuan_inquire (ctx, "KEYPARAM", &value, &valuelen, MAXLEN_KEYPARAM);
969   if (rc)
970     return rc;
971
972   init_membuf (&outbuf, 512);
973
974   /* If requested, ask for the password to be used for the key.  If
975      this is not used the regular Pinentry mechanism is used.  */
976   if (opt_inq_passwd && !no_protection)
977     {
978       /* (N is used as a dummy) */
979       assuan_begin_confidential (ctx);
980       rc = assuan_inquire (ctx, "NEWPASSWD", &newpasswd, &n, 256);
981       assuan_end_confidential (ctx);
982       if (rc)
983         goto leave;
984       if (!*newpasswd)
985         {
986           /* Empty password given - switch to no-protection mode.  */
987           xfree (newpasswd);
988           newpasswd = NULL;
989           no_protection = 1;
990         }
991
992     }
993
994   rc = agent_genkey (ctrl, cache_nonce, (char*)value, valuelen, no_protection,
995                      newpasswd, opt_preset, &outbuf);
996
997  leave:
998   if (newpasswd)
999     {
1000       /* Assuan_inquire does not allow us to read into secure memory
1001          thus we need to wipe it ourself.  */
1002       wipememory (newpasswd, strlen (newpasswd));
1003       xfree (newpasswd);
1004     }
1005   xfree (value);
1006   if (rc)
1007     clear_outbuf (&outbuf);
1008   else
1009     rc = write_and_clear_outbuf (ctx, &outbuf);
1010   xfree (cache_nonce);
1011   return leave_cmd (ctx, rc);
1012 }
1013
1014
1015
1016 \f
1017 static const char hlp_readkey[] =
1018   "READKEY <hexstring_with_keygrip>\n"
1019   "\n"
1020   "Return the public key for the given keygrip.";
1021 static gpg_error_t
1022 cmd_readkey (assuan_context_t ctx, char *line)
1023 {
1024   ctrl_t ctrl = assuan_get_pointer (ctx);
1025   int rc;
1026   unsigned char grip[20];
1027   gcry_sexp_t s_pkey = NULL;
1028
1029   if (ctrl->restricted)
1030     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1031
1032   rc = parse_keygrip (ctx, line, grip);
1033   if (rc)
1034     return rc; /* Return immediately as this is already an Assuan error code.*/
1035
1036   rc = agent_public_key_from_file (ctrl, grip, &s_pkey);
1037   if (!rc)
1038     {
1039       size_t len;
1040       unsigned char *buf;
1041
1042       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1043       assert (len);
1044       buf = xtrymalloc (len);
1045       if (!buf)
1046         rc = gpg_error_from_syserror ();
1047       else
1048         {
1049           len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, buf, len);
1050           assert (len);
1051           rc = assuan_send_data (ctx, buf, len);
1052           xfree (buf);
1053         }
1054       gcry_sexp_release (s_pkey);
1055     }
1056
1057   return leave_cmd (ctx, rc);
1058 }
1059
1060
1061 \f
1062 static const char hlp_keyinfo[] =
1063   "KEYINFO [--[ssh-]list] [--data] [--ssh-fpr] [--with-ssh] <keygrip>\n"
1064   "\n"
1065   "Return information about the key specified by the KEYGRIP.  If the\n"
1066   "key is not available GPG_ERR_NOT_FOUND is returned.  If the option\n"
1067   "--list is given the keygrip is ignored and information about all\n"
1068   "available keys are returned.  If --ssh-list is given information\n"
1069   "about all keys listed in the sshcontrol are returned.  With --with-ssh\n"
1070   "information from sshcontrol is always added to the info. Unless --data\n"
1071   "is given, the information is returned as a status line using the format:\n"
1072   "\n"
1073   "  KEYINFO <keygrip> <type> <serialno> <idstr> <cached> <protection> <fpr>\n"
1074   "\n"
1075   "KEYGRIP is the keygrip.\n"
1076   "\n"
1077   "TYPE is describes the type of the key:\n"
1078   "    'D' - Regular key stored on disk,\n"
1079   "    'T' - Key is stored on a smartcard (token),\n"
1080   "    'X' - Unknown type,\n"
1081   "    '-' - Key is missing.\n"
1082   "\n"
1083   "SERIALNO is an ASCII string with the serial number of the\n"
1084   "         smartcard.  If the serial number is not known a single\n"
1085   "         dash '-' is used instead.\n"
1086   "\n"
1087   "IDSTR is the IDSTR used to distinguish keys on a smartcard.  If it\n"
1088   "      is not known a dash is used instead.\n"
1089   "\n"
1090   "CACHED is 1 if the passphrase for the key was found in the key cache.\n"
1091   "       If not, a '-' is used instead.\n"
1092   "\n"
1093   "PROTECTION describes the key protection type:\n"
1094   "    'P' - The key is protected with a passphrase,\n"
1095   "    'C' - The key is not protected,\n"
1096   "    '-' - Unknown protection.\n"
1097   "\n"
1098   "FPR returns the formatted ssh-style fingerprint of the key.  It is only\n"
1099   "    printed if the option --ssh-fpr has been used.  It defaults to '-'.\n"
1100   "\n"
1101   "TTL is the TTL in seconds for that key or '-' if n/a.\n"
1102   "\n"
1103   "FLAGS is a word consisting of one-letter flags:\n"
1104   "      'D' - The key has been disabled,\n"
1105   "      'S' - The key is listed in sshcontrol (requires --with-ssh),\n"
1106   "      'c' - Use of the key needs to be confirmed,\n"
1107   "      '-' - No flags given.\n"
1108   "\n"
1109   "More information may be added in the future.";
1110 static gpg_error_t
1111 do_one_keyinfo (ctrl_t ctrl, const unsigned char *grip, assuan_context_t ctx,
1112                 int data, int with_ssh_fpr, int in_ssh,
1113                 int ttl, int disabled, int confirm)
1114 {
1115   gpg_error_t err;
1116   char hexgrip[40+1];
1117   char *fpr = NULL;
1118   int keytype;
1119   unsigned char *shadow_info = NULL;
1120   char *serialno = NULL;
1121   char *idstr = NULL;
1122   const char *keytypestr;
1123   const char *cached;
1124   const char *protectionstr;
1125   char *pw;
1126   int missing_key = 0;
1127   char ttlbuf[20];
1128   char flagsbuf[5];
1129
1130   err = agent_key_info_from_file (ctrl, grip, &keytype, &shadow_info);
1131   if (err)
1132     {
1133       if (in_ssh && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1134         missing_key = 1;
1135       else
1136         goto leave;
1137     }
1138
1139   /* Reformat the grip so that we use uppercase as good style. */
1140   bin2hex (grip, 20, hexgrip);
1141
1142   if (ttl > 0)
1143     snprintf (ttlbuf, sizeof ttlbuf, "%d", ttl);
1144   else
1145     strcpy (ttlbuf, "-");
1146
1147   *flagsbuf = 0;
1148   if (disabled)
1149     strcat (flagsbuf, "D");
1150   if (in_ssh)
1151     strcat (flagsbuf, "S");
1152   if (confirm)
1153     strcat (flagsbuf, "c");
1154   if (!*flagsbuf)
1155     strcpy (flagsbuf, "-");
1156
1157
1158   if (missing_key)
1159     {
1160       protectionstr = "-"; keytypestr = "-";
1161     }
1162   else
1163     {
1164       switch (keytype)
1165         {
1166         case PRIVATE_KEY_CLEAR:
1167         case PRIVATE_KEY_OPENPGP_NONE:
1168           protectionstr = "C"; keytypestr = "D";
1169           break;
1170         case PRIVATE_KEY_PROTECTED: protectionstr = "P"; keytypestr = "D";
1171           break;
1172         case PRIVATE_KEY_SHADOWED: protectionstr = "-"; keytypestr = "T";
1173           break;
1174         default: protectionstr = "-"; keytypestr = "X";
1175           break;
1176         }
1177     }
1178
1179   /* Compute the ssh fingerprint if requested.  */
1180   if (with_ssh_fpr)
1181     {
1182       gcry_sexp_t key;
1183
1184       if (!agent_raw_key_from_file (ctrl, grip, &key))
1185         {
1186           ssh_get_fingerprint_string (key, &fpr);
1187           gcry_sexp_release (key);
1188         }
1189     }
1190
1191   /* Here we have a little race by doing the cache check separately
1192      from the retrieval function.  Given that the cache flag is only a
1193      hint, it should not really matter.  */
1194   pw = agent_get_cache (hexgrip, CACHE_MODE_NORMAL);
1195   cached = pw ? "1" : "-";
1196   xfree (pw);
1197
1198   if (shadow_info)
1199     {
1200       err = parse_shadow_info (shadow_info, &serialno, &idstr, NULL);
1201       if (err)
1202         goto leave;
1203     }
1204
1205   if (!data)
1206     err = agent_write_status (ctrl, "KEYINFO",
1207                               hexgrip,
1208                               keytypestr,
1209                               serialno? serialno : "-",
1210                               idstr? idstr : "-",
1211                               cached,
1212                               protectionstr,
1213                               fpr? fpr : "-",
1214                               ttlbuf,
1215                               flagsbuf,
1216                               NULL);
1217   else
1218     {
1219       char *string;
1220
1221       string = xtryasprintf ("%s %s %s %s %s %s %s %s %s\n",
1222                              hexgrip, keytypestr,
1223                              serialno? serialno : "-",
1224                              idstr? idstr : "-", cached, protectionstr,
1225                              fpr? fpr : "-",
1226                              ttlbuf,
1227                              flagsbuf);
1228       if (!string)
1229         err = gpg_error_from_syserror ();
1230       else
1231         err = assuan_send_data (ctx, string, strlen(string));
1232       xfree (string);
1233     }
1234
1235  leave:
1236   xfree (fpr);
1237   xfree (shadow_info);
1238   xfree (serialno);
1239   xfree (idstr);
1240   return err;
1241 }
1242
1243
1244 /* Entry int for the command KEYINFO.  This function handles the
1245    command option processing.  For details see hlp_keyinfo above.  */
1246 static gpg_error_t
1247 cmd_keyinfo (assuan_context_t ctx, char *line)
1248 {
1249   ctrl_t ctrl = assuan_get_pointer (ctx);
1250   int err;
1251   unsigned char grip[20];
1252   DIR *dir = NULL;
1253   int list_mode;
1254   int opt_data, opt_ssh_fpr, opt_with_ssh;
1255   ssh_control_file_t cf = NULL;
1256   char hexgrip[41];
1257   int disabled, ttl, confirm, is_ssh;
1258
1259   if (ctrl->restricted)
1260     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1261
1262   if (has_option (line, "--ssh-list"))
1263     list_mode = 2;
1264   else
1265     list_mode = has_option (line, "--list");
1266   opt_data = has_option (line, "--data");
1267   opt_ssh_fpr = has_option (line, "--ssh-fpr");
1268   opt_with_ssh = has_option (line, "--with-ssh");
1269   line = skip_options (line);
1270
1271   if (opt_with_ssh || list_mode == 2)
1272     cf = ssh_open_control_file ();
1273
1274   if (list_mode == 2)
1275     {
1276       if (cf)
1277         {
1278           while (!ssh_read_control_file (cf, hexgrip,
1279                                          &disabled, &ttl, &confirm))
1280             {
1281               if (hex2bin (hexgrip, grip, 20) < 0 )
1282                 continue; /* Bad hex string.  */
1283               err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, 1,
1284                                     ttl, disabled, confirm);
1285               if (err)
1286                 goto leave;
1287             }
1288         }
1289       err = 0;
1290     }
1291   else if (list_mode)
1292     {
1293       char *dirname;
1294       struct dirent *dir_entry;
1295
1296       dirname = make_filename_try (opt.homedir, GNUPG_PRIVATE_KEYS_DIR, NULL);
1297       if (!dirname)
1298         {
1299           err = gpg_error_from_syserror ();
1300           goto leave;
1301         }
1302       dir = opendir (dirname);
1303       if (!dir)
1304         {
1305           err = gpg_error_from_syserror ();
1306           xfree (dirname);
1307           goto leave;
1308         }
1309       xfree (dirname);
1310
1311       while ( (dir_entry = readdir (dir)) )
1312         {
1313           if (strlen (dir_entry->d_name) != 44
1314               || strcmp (dir_entry->d_name + 40, ".key"))
1315             continue;
1316           strncpy (hexgrip, dir_entry->d_name, 40);
1317           hexgrip[40] = 0;
1318
1319           if ( hex2bin (hexgrip, grip, 20) < 0 )
1320             continue; /* Bad hex string.  */
1321
1322           disabled = ttl = confirm = is_ssh = 0;
1323           if (opt_with_ssh)
1324             {
1325               err = ssh_search_control_file (cf, hexgrip,
1326                                              &disabled, &ttl, &confirm);
1327               if (!err)
1328                 is_ssh = 1;
1329               else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1330                 goto leave;
1331             }
1332
1333           err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1334                                 ttl, disabled, confirm);
1335           if (err)
1336             goto leave;
1337         }
1338       err = 0;
1339     }
1340   else
1341     {
1342       err = parse_keygrip (ctx, line, grip);
1343       if (err)
1344         goto leave;
1345       disabled = ttl = confirm = is_ssh = 0;
1346       if (opt_with_ssh)
1347         {
1348           err = ssh_search_control_file (cf, line,
1349                                          &disabled, &ttl, &confirm);
1350           if (!err)
1351             is_ssh = 1;
1352           else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1353             goto leave;
1354         }
1355
1356       err = do_one_keyinfo (ctrl, grip, ctx, opt_data, opt_ssh_fpr, is_ssh,
1357                             ttl, disabled, confirm);
1358     }
1359
1360  leave:
1361   ssh_close_control_file (cf);
1362   if (dir)
1363     closedir (dir);
1364   if (err && gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1365     leave_cmd (ctx, err);
1366   return err;
1367 }
1368
1369
1370 \f
1371 /* Helper for cmd_get_passphrase.  */
1372 static int
1373 send_back_passphrase (assuan_context_t ctx, int via_data, const char *pw)
1374 {
1375   size_t n;
1376   int rc;
1377
1378   assuan_begin_confidential (ctx);
1379   n = strlen (pw);
1380   if (via_data)
1381     rc = assuan_send_data (ctx, pw, n);
1382   else
1383     {
1384       char *p = xtrymalloc_secure (n*2+1);
1385       if (!p)
1386         rc = gpg_error_from_syserror ();
1387       else
1388         {
1389           bin2hex (pw, n, p);
1390           rc = assuan_set_okay_line (ctx, p);
1391           xfree (p);
1392         }
1393     }
1394   return rc;
1395 }
1396
1397
1398 static const char hlp_get_passphrase[] =
1399   "GET_PASSPHRASE [--data] [--check] [--no-ask] [--repeat[=N]]\n"
1400   "               [--qualitybar] <cache_id>\n"
1401   "               [<error_message> <prompt> <description>]\n"
1402   "\n"
1403   "This function is usually used to ask for a passphrase to be used\n"
1404   "for conventional encryption, but may also be used by programs which\n"
1405   "need specal handling of passphrases.  This command uses a syntax\n"
1406   "which helps clients to use the agent with minimum effort.  The\n"
1407   "agent either returns with an error or with a OK followed by the hex\n"
1408   "encoded passphrase.  Note that the length of the strings is\n"
1409   "implicitly limited by the maximum length of a command.\n"
1410   "\n"
1411   "If the option \"--data\" is used the passphrase is returned by usual\n"
1412   "data lines and not on the okay line.\n"
1413   "\n"
1414   "If the option \"--check\" is used the passphrase constraints checks as\n"
1415   "implemented by gpg-agent are applied.  A check is not done if the\n"
1416   "passphrase has been found in the cache.\n"
1417   "\n"
1418   "If the option \"--no-ask\" is used and the passphrase is not in the\n"
1419   "cache the user will not be asked to enter a passphrase but the error\n"
1420   "code GPG_ERR_NO_DATA is returned.  \n"
1421   "\n"
1422   "If the option \"--qualitybar\" is used a visual indication of the\n"
1423   "entered passphrase quality is shown.  (Unless no minimum passphrase\n"
1424   "length has been configured.)";
1425 static gpg_error_t
1426 cmd_get_passphrase (assuan_context_t ctx, char *line)
1427 {
1428   ctrl_t ctrl = assuan_get_pointer (ctx);
1429   int rc;
1430   char *pw;
1431   char *response;
1432   char *cacheid = NULL, *desc = NULL, *prompt = NULL, *errtext = NULL;
1433   const char *desc2 = _("Please re-enter this passphrase");
1434   char *p;
1435   int opt_data, opt_check, opt_no_ask, opt_qualbar;
1436   int opt_repeat = 0;
1437   char *repeat_errtext = NULL;
1438
1439   if (ctrl->restricted)
1440     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1441
1442   opt_data = has_option (line, "--data");
1443   opt_check = has_option (line, "--check");
1444   opt_no_ask = has_option (line, "--no-ask");
1445   if (has_option_name (line, "--repeat"))
1446     {
1447       p = option_value (line, "--repeat");
1448       if (p)
1449         opt_repeat = atoi (p);
1450       else
1451         opt_repeat = 1;
1452     }
1453   opt_qualbar = has_option (line, "--qualitybar");
1454   line = skip_options (line);
1455
1456   cacheid = line;
1457   p = strchr (cacheid, ' ');
1458   if (p)
1459     {
1460       *p++ = 0;
1461       while (*p == ' ')
1462         p++;
1463       errtext = p;
1464       p = strchr (errtext, ' ');
1465       if (p)
1466         {
1467           *p++ = 0;
1468           while (*p == ' ')
1469             p++;
1470           prompt = p;
1471           p = strchr (prompt, ' ');
1472           if (p)
1473             {
1474               *p++ = 0;
1475               while (*p == ' ')
1476                 p++;
1477               desc = p;
1478               p = strchr (desc, ' ');
1479               if (p)
1480                 *p = 0; /* Ignore trailing garbage. */
1481             }
1482         }
1483     }
1484   if (!*cacheid || strlen (cacheid) > 50)
1485     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1486   if (!desc)
1487     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1488
1489   if (!strcmp (cacheid, "X"))
1490     cacheid = NULL;
1491   if (!strcmp (errtext, "X"))
1492     errtext = NULL;
1493   if (!strcmp (prompt, "X"))
1494     prompt = NULL;
1495   if (!strcmp (desc, "X"))
1496     desc = NULL;
1497
1498   pw = cacheid ? agent_get_cache (cacheid, CACHE_MODE_NORMAL) : NULL;
1499   if (pw)
1500     {
1501       rc = send_back_passphrase (ctx, opt_data, pw);
1502       xfree (pw);
1503     }
1504   else if (opt_no_ask)
1505     rc = gpg_error (GPG_ERR_NO_DATA);
1506   else
1507     {
1508       /* Note, that we only need to replace the + characters and
1509          should leave the other escaping in place because the escaped
1510          string is send verbatim to the pinentry which does the
1511          unescaping (but not the + replacing) */
1512       if (errtext)
1513         plus_to_blank (errtext);
1514       if (prompt)
1515         plus_to_blank (prompt);
1516       if (desc)
1517         plus_to_blank (desc);
1518
1519     next_try:
1520       rc = agent_get_passphrase (ctrl, &response, desc, prompt,
1521                                  repeat_errtext? repeat_errtext:errtext,
1522                                  opt_qualbar, cacheid, CACHE_MODE_USER);
1523       xfree (repeat_errtext);
1524       repeat_errtext = NULL;
1525       if (!rc)
1526         {
1527           int i;
1528
1529           if (opt_check && check_passphrase_constraints (ctrl, response, 0))
1530             {
1531               xfree (response);
1532               goto next_try;
1533             }
1534           for (i = 0; i < opt_repeat; i++)
1535             {
1536               char *response2;
1537
1538               rc = agent_get_passphrase (ctrl, &response2, desc2, prompt,
1539                                          errtext, 0,
1540                                          cacheid, CACHE_MODE_USER);
1541               if (rc)
1542                 break;
1543               if (strcmp (response2, response))
1544                 {
1545                   xfree (response2);
1546                   xfree (response);
1547                   repeat_errtext = try_percent_escape
1548                     (_("does not match - try again"), NULL);
1549                   if (!repeat_errtext)
1550                     {
1551                       rc = gpg_error_from_syserror ();
1552                       break;
1553                     }
1554                   goto next_try;
1555                 }
1556               xfree (response2);
1557             }
1558           if (!rc)
1559             {
1560               if (cacheid)
1561                 agent_put_cache (cacheid, CACHE_MODE_USER, response, 0);
1562               rc = send_back_passphrase (ctx, opt_data, response);
1563             }
1564           xfree (response);
1565         }
1566     }
1567
1568   return leave_cmd (ctx, rc);
1569 }
1570
1571
1572 static const char hlp_clear_passphrase[] =
1573   "CLEAR_PASSPHRASE [--mode=normal] <cache_id>\n"
1574   "\n"
1575   "may be used to invalidate the cache entry for a passphrase.  The\n"
1576   "function returns with OK even when there is no cached passphrase.\n"
1577   "The --mode=normal option is used to clear an entry for a cacheid\n"
1578   "added by the agent.\n";
1579 static gpg_error_t
1580 cmd_clear_passphrase (assuan_context_t ctx, char *line)
1581 {
1582   ctrl_t ctrl = assuan_get_pointer (ctx);
1583   char *cacheid = NULL;
1584   char *p;
1585   int opt_normal;
1586
1587   if (ctrl->restricted)
1588     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1589
1590   opt_normal = has_option (line, "--mode=normal");
1591   line = skip_options (line);
1592
1593   /* parse the stuff */
1594   for (p=line; *p == ' '; p++)
1595     ;
1596   cacheid = p;
1597   p = strchr (cacheid, ' ');
1598   if (p)
1599     *p = 0; /* ignore garbage */
1600   if (!*cacheid || strlen (cacheid) > 50)
1601     return set_error (GPG_ERR_ASS_PARAMETER, "invalid length of cacheID");
1602
1603   agent_put_cache (cacheid, opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER,
1604                    NULL, 0);
1605
1606   agent_clear_passphrase (ctrl, cacheid,
1607                           opt_normal ? CACHE_MODE_NORMAL : CACHE_MODE_USER);
1608
1609   return 0;
1610 }
1611
1612
1613 static const char hlp_get_confirmation[] =
1614   "GET_CONFIRMATION <description>\n"
1615   "\n"
1616   "This command may be used to ask for a simple confirmation.\n"
1617   "DESCRIPTION is displayed along with a Okay and Cancel button.  This\n"
1618   "command uses a syntax which helps clients to use the agent with\n"
1619   "minimum effort.  The agent either returns with an error or with a\n"
1620   "OK.  Note, that the length of DESCRIPTION is implicitly limited by\n"
1621   "the maximum length of a command. DESCRIPTION should not contain\n"
1622   "any spaces, those must be encoded either percent escaped or simply\n"
1623   "as '+'.";
1624 static gpg_error_t
1625 cmd_get_confirmation (assuan_context_t ctx, char *line)
1626 {
1627   ctrl_t ctrl = assuan_get_pointer (ctx);
1628   int rc;
1629   char *desc = NULL;
1630   char *p;
1631
1632   if (ctrl->restricted)
1633     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1634
1635   /* parse the stuff */
1636   for (p=line; *p == ' '; p++)
1637     ;
1638   desc = p;
1639   p = strchr (desc, ' ');
1640   if (p)
1641     *p = 0; /* We ignore any garbage -may be later used for other args. */
1642
1643   if (!*desc)
1644     return set_error (GPG_ERR_ASS_PARAMETER, "no description given");
1645
1646   if (!strcmp (desc, "X"))
1647     desc = NULL;
1648
1649   /* Note, that we only need to replace the + characters and should
1650      leave the other escaping in place because the escaped string is
1651      send verbatim to the pinentry which does the unescaping (but not
1652      the + replacing) */
1653   if (desc)
1654     plus_to_blank (desc);
1655
1656   rc = agent_get_confirmation (ctrl, desc, NULL, NULL, 0);
1657   return leave_cmd (ctx, rc);
1658 }
1659
1660
1661 \f
1662 static const char hlp_learn[] =
1663   "LEARN [--send] [--sendinfo] [--force]\n"
1664   "\n"
1665   "Learn something about the currently inserted smartcard.  With\n"
1666   "--sendinfo information about the card is returned; with --send\n"
1667   "the available certificates are returned as D lines; with --force\n"
1668   "private key storage will be updated by the result.";
1669 static gpg_error_t
1670 cmd_learn (assuan_context_t ctx, char *line)
1671 {
1672   ctrl_t ctrl = assuan_get_pointer (ctx);
1673   gpg_error_t err;
1674   int send, sendinfo, force;
1675
1676   send = has_option (line, "--send");
1677   sendinfo = send? 1 : has_option (line, "--sendinfo");
1678   force = has_option (line, "--force");
1679
1680   if (ctrl->restricted)
1681     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1682
1683   err = agent_handle_learn (ctrl, send, sendinfo? ctx : NULL, force);
1684   return leave_cmd (ctx, err);
1685 }
1686
1687
1688 \f
1689 static const char hlp_passwd[] =
1690   "PASSWD [--cache-nonce=<c>] [--passwd-nonce=<s>] [--preset] <hexkeygrip>\n"
1691   "\n"
1692   "Change the passphrase/PIN for the key identified by keygrip in LINE. When\n"
1693   "--preset is used then the new passphrase will be added to the cache.\n";
1694 static gpg_error_t
1695 cmd_passwd (assuan_context_t ctx, char *line)
1696 {
1697   ctrl_t ctrl = assuan_get_pointer (ctx);
1698   gpg_error_t err;
1699   int c;
1700   char *cache_nonce = NULL;
1701   char *passwd_nonce = NULL;
1702   unsigned char grip[20];
1703   gcry_sexp_t s_skey = NULL;
1704   unsigned char *shadow_info = NULL;
1705   char *passphrase = NULL;
1706   char *pend;
1707   int opt_preset;
1708
1709   if (ctrl->restricted)
1710     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1711
1712   opt_preset = has_option (line, "--preset");
1713   cache_nonce = option_value (line, "--cache-nonce");
1714   if (cache_nonce)
1715     {
1716       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
1717         ;
1718       c = *pend;
1719       *pend = '\0';
1720       cache_nonce = xtrystrdup (cache_nonce);
1721       *pend = c;
1722       if (!cache_nonce)
1723         {
1724           err = gpg_error_from_syserror ();
1725           goto leave;
1726         }
1727     }
1728
1729   passwd_nonce = option_value (line, "--passwd-nonce");
1730   if (passwd_nonce)
1731     {
1732       for (pend = passwd_nonce; *pend && !spacep (pend); pend++)
1733         ;
1734       c = *pend;
1735       *pend = '\0';
1736       passwd_nonce = xtrystrdup (passwd_nonce);
1737       *pend = c;
1738       if (!passwd_nonce)
1739         {
1740           err = gpg_error_from_syserror ();
1741           goto leave;
1742         }
1743     }
1744
1745   line = skip_options (line);
1746
1747   err = parse_keygrip (ctx, line, grip);
1748   if (err)
1749     goto leave;
1750
1751   ctrl->in_passwd++;
1752   err = agent_key_from_file (ctrl, cache_nonce, ctrl->server_local->keydesc,
1753                              grip, &shadow_info, CACHE_MODE_IGNORE, NULL,
1754                              &s_skey, &passphrase);
1755   if (err)
1756     ;
1757   else if (shadow_info)
1758     {
1759       log_error ("changing a smartcard PIN is not yet supported\n");
1760       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1761     }
1762   else
1763     {
1764       char *newpass = NULL;
1765
1766       if (passwd_nonce)
1767         newpass = agent_get_cache (passwd_nonce, CACHE_MODE_NONCE);
1768       err = agent_protect_and_store (ctrl, s_skey, &newpass);
1769       if (!err && passphrase)
1770         {
1771           /* A passphrase existed on the old key and the change was
1772              successful.  Return a nonce for that old passphrase to
1773              let the caller try to unprotect the other subkeys with
1774              the same key.  */
1775           if (!cache_nonce)
1776             {
1777               char buf[12];
1778               gcry_create_nonce (buf, 12);
1779               cache_nonce = bin2hex (buf, 12, NULL);
1780             }
1781           if (cache_nonce
1782               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
1783                                    passphrase, CACHE_TTL_NONCE))
1784             {
1785               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
1786               xfree (ctrl->server_local->last_cache_nonce);
1787               ctrl->server_local->last_cache_nonce = cache_nonce;
1788               cache_nonce = NULL;
1789             }
1790           if (newpass)
1791             {
1792               /* If we have a new passphrase (which might be empty) we
1793                  store it under a passwd nonce so that the caller may
1794                  send that nonce again to use it for another key. */
1795               if (!passwd_nonce)
1796                 {
1797                   char buf[12];
1798                   gcry_create_nonce (buf, 12);
1799                   passwd_nonce = bin2hex (buf, 12, NULL);
1800                 }
1801               if (passwd_nonce
1802                   && !agent_put_cache (passwd_nonce, CACHE_MODE_NONCE,
1803                                        newpass, CACHE_TTL_NONCE))
1804                 {
1805                   assuan_write_status (ctx, "PASSWD_NONCE", passwd_nonce);
1806                   xfree (ctrl->server_local->last_passwd_nonce);
1807                   ctrl->server_local->last_passwd_nonce = passwd_nonce;
1808                   passwd_nonce = NULL;
1809                 }
1810             }
1811         }
1812       if (!err && opt_preset)
1813         {
1814           char hexgrip[40+1];
1815           bin2hex(grip, 20, hexgrip);
1816           err = agent_put_cache (hexgrip, CACHE_MODE_ANY, newpass,
1817                                  ctrl->cache_ttl_opt_preset);
1818         }
1819       xfree (newpass);
1820     }
1821   ctrl->in_passwd--;
1822
1823   xfree (ctrl->server_local->keydesc);
1824   ctrl->server_local->keydesc = NULL;
1825
1826  leave:
1827   xfree (passphrase);
1828   gcry_sexp_release (s_skey);
1829   xfree (shadow_info);
1830   xfree (cache_nonce);
1831   return leave_cmd (ctx, err);
1832 }
1833
1834
1835 static const char hlp_preset_passphrase[] =
1836   "PRESET_PASSPHRASE [--inquire] <string_or_keygrip> <timeout> [<hexstring>]\n"
1837   "\n"
1838   "Set the cached passphrase/PIN for the key identified by the keygrip\n"
1839   "to passwd for the given time, where -1 means infinite and 0 means\n"
1840   "the default (currently only a timeout of -1 is allowed, which means\n"
1841   "to never expire it).  If passwd is not provided, ask for it via the\n"
1842   "pinentry module unless --inquire is passed in which case the passphrase\n"
1843   "is retrieved from the client via a server inquire.\n";
1844 static gpg_error_t
1845 cmd_preset_passphrase (assuan_context_t ctx, char *line)
1846 {
1847   ctrl_t ctrl = assuan_get_pointer (ctx);
1848   int rc;
1849   char *grip_clear = NULL;
1850   unsigned char *passphrase = NULL;
1851   int ttl;
1852   size_t len;
1853   int opt_inquire;
1854
1855   if (ctrl->restricted)
1856     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1857
1858   if (!opt.allow_preset_passphrase)
1859     return set_error (GPG_ERR_NOT_SUPPORTED, "no --allow-preset-passphrase");
1860
1861   opt_inquire = has_option (line, "--inquire");
1862   line = skip_options (line);
1863   grip_clear = line;
1864   while (*line && (*line != ' ' && *line != '\t'))
1865     line++;
1866   if (!*line)
1867     return gpg_error (GPG_ERR_MISSING_VALUE);
1868   *line = '\0';
1869   line++;
1870   while (*line && (*line == ' ' || *line == '\t'))
1871     line++;
1872
1873   /* Currently, only infinite timeouts are allowed.  */
1874   ttl = -1;
1875   if (line[0] != '-' || line[1] != '1')
1876     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1877   line++;
1878   line++;
1879   while (!(*line != ' ' && *line != '\t'))
1880     line++;
1881
1882   /* Syntax check the hexstring.  */
1883   len = 0;
1884   rc = parse_hexstring (ctx, line, &len);
1885   if (rc)
1886     return rc;
1887   line[len] = '\0';
1888
1889   /* If there is a passphrase, use it.  Currently, a passphrase is
1890      required.  */
1891   if (*line)
1892     {
1893       if (opt_inquire)
1894         {
1895           rc = set_error (GPG_ERR_ASS_PARAMETER,
1896                           "both --inquire and passphrase specified");
1897           goto leave;
1898         }
1899
1900       /* Do in-place conversion.  */
1901       passphrase = line;
1902       if (!hex2str (passphrase, passphrase, strlen (passphrase)+1, NULL))
1903         rc = set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
1904     }
1905   else if (opt_inquire)
1906     {
1907       /* Note that the passphrase will be truncated at any null byte and the
1908        * limit is 480 characters. */
1909       size_t maxlen = 480;
1910
1911       rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", maxlen);
1912       if (!rc)
1913         rc = assuan_inquire (ctx, "PASSPHRASE", &passphrase, &len, maxlen);
1914     }
1915   else
1916     rc = set_error (GPG_ERR_NOT_IMPLEMENTED, "passphrase is required");
1917
1918   if (!rc)
1919     {
1920       rc = agent_put_cache (grip_clear, CACHE_MODE_ANY, passphrase, ttl);
1921       if (opt_inquire)
1922         xfree (passphrase);
1923     }
1924
1925 leave:
1926   return leave_cmd (ctx, rc);
1927 }
1928
1929
1930 \f
1931 static const char hlp_scd[] =
1932   "SCD <commands to pass to the scdaemon>\n"
1933   " \n"
1934   "This is a general quote command to redirect everything to the\n"
1935   "SCdaemon.";
1936 static gpg_error_t
1937 cmd_scd (assuan_context_t ctx, char *line)
1938 {
1939   ctrl_t ctrl = assuan_get_pointer (ctx);
1940   int rc;
1941
1942   if (ctrl->restricted)
1943     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1944
1945   rc = divert_generic_cmd (ctrl, line, ctx);
1946
1947   return rc;
1948 }
1949
1950
1951 \f
1952 static const char hlp_keywrap_key[] =
1953   "KEYWRAP_KEY [--clear] <mode>\n"
1954   "\n"
1955   "Return a key to wrap another key.  For now the key is returned\n"
1956   "verbatim and and thus makes not much sense because an eavesdropper on\n"
1957   "the gpg-agent connection will see the key as well as the wrapped key.\n"
1958   "However, this function may either be equipped with a public key\n"
1959   "mechanism or not used at all if the key is a pre-shared key.  In any\n"
1960   "case wrapping the import and export of keys is a requirement for\n"
1961   "certain cryptographic validations and thus useful.  The key persists\n"
1962   "a RESET command but may be cleared using the option --clear.\n"
1963   "\n"
1964   "Supported modes are:\n"
1965   "  --import  - Return a key to import a key into gpg-agent\n"
1966   "  --export  - Return a key to export a key from gpg-agent";
1967 static gpg_error_t
1968 cmd_keywrap_key (assuan_context_t ctx, char *line)
1969 {
1970   ctrl_t ctrl = assuan_get_pointer (ctx);
1971   gpg_error_t err = 0;
1972   int clearopt = has_option (line, "--clear");
1973
1974   if (ctrl->restricted)
1975     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
1976
1977   assuan_begin_confidential (ctx);
1978   if (has_option (line, "--import"))
1979     {
1980       xfree (ctrl->server_local->import_key);
1981       if (clearopt)
1982         ctrl->server_local->import_key = NULL;
1983       else if (!(ctrl->server_local->import_key =
1984                  gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
1985         err = gpg_error_from_syserror ();
1986       else
1987         err = assuan_send_data (ctx, ctrl->server_local->import_key,
1988                                 KEYWRAP_KEYSIZE);
1989     }
1990   else if (has_option (line, "--export"))
1991     {
1992       xfree (ctrl->server_local->export_key);
1993       if (clearopt)
1994         ctrl->server_local->export_key = NULL;
1995       else if (!(ctrl->server_local->export_key =
1996             gcry_random_bytes (KEYWRAP_KEYSIZE, GCRY_STRONG_RANDOM)))
1997         err = gpg_error_from_syserror ();
1998       else
1999         err = assuan_send_data (ctx, ctrl->server_local->export_key,
2000                                 KEYWRAP_KEYSIZE);
2001     }
2002   else
2003     err = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for MODE");
2004   assuan_end_confidential (ctx);
2005
2006   return leave_cmd (ctx, err);
2007 }
2008
2009
2010 \f
2011 static const char hlp_import_key[] =
2012   "IMPORT_KEY [--unattended] [<cache_nonce>]\n"
2013   "\n"
2014   "Import a secret key into the key store.  The key is expected to be\n"
2015   "encrypted using the current session's key wrapping key (cf. command\n"
2016   "KEYWRAP_KEY) using the AESWRAP-128 algorithm.  This function takes\n"
2017   "no arguments but uses the inquiry \"KEYDATA\" to ask for the actual\n"
2018   "key data.  The unwrapped key must be a canonical S-expression.  The\n"
2019   "option --unattended tries to import the key as-is without any\n"
2020   "re-encryption";
2021 static gpg_error_t
2022 cmd_import_key (assuan_context_t ctx, char *line)
2023 {
2024   ctrl_t ctrl = assuan_get_pointer (ctx);
2025   gpg_error_t err;
2026   int opt_unattended;
2027   unsigned char *wrappedkey = NULL;
2028   size_t wrappedkeylen;
2029   gcry_cipher_hd_t cipherhd = NULL;
2030   unsigned char *key = NULL;
2031   size_t keylen, realkeylen;
2032   char *passphrase = NULL;
2033   unsigned char *finalkey = NULL;
2034   size_t finalkeylen;
2035   unsigned char grip[20];
2036   gcry_sexp_t openpgp_sexp = NULL;
2037   char *cache_nonce = NULL;
2038   char *p;
2039
2040   if (ctrl->restricted)
2041     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2042
2043   if (!ctrl->server_local->import_key)
2044     {
2045       err = gpg_error (GPG_ERR_MISSING_KEY);
2046       goto leave;
2047     }
2048
2049   opt_unattended = has_option (line, "--unattended");
2050   line = skip_options (line);
2051
2052   p = line;
2053   for (p=line; *p && *p != ' ' && *p != '\t'; p++)
2054     ;
2055   *p = '\0';
2056   if (*line)
2057     cache_nonce = xtrystrdup (line);
2058
2059   assuan_begin_confidential (ctx);
2060   err = assuan_inquire (ctx, "KEYDATA",
2061                         &wrappedkey, &wrappedkeylen, MAXLEN_KEYDATA);
2062   assuan_end_confidential (ctx);
2063   if (err)
2064     goto leave;
2065   if (wrappedkeylen < 24)
2066     {
2067       err = gpg_error (GPG_ERR_INV_LENGTH);
2068       goto leave;
2069     }
2070   keylen = wrappedkeylen - 8;
2071   key = xtrymalloc_secure (keylen);
2072   if (!key)
2073     {
2074       err = gpg_error_from_syserror ();
2075       goto leave;
2076     }
2077
2078   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2079                           GCRY_CIPHER_MODE_AESWRAP, 0);
2080   if (err)
2081     goto leave;
2082   err = gcry_cipher_setkey (cipherhd,
2083                             ctrl->server_local->import_key, KEYWRAP_KEYSIZE);
2084   if (err)
2085     goto leave;
2086   err = gcry_cipher_decrypt (cipherhd, key, keylen, wrappedkey, wrappedkeylen);
2087   if (err)
2088     goto leave;
2089   gcry_cipher_close (cipherhd);
2090   cipherhd = NULL;
2091   xfree (wrappedkey);
2092   wrappedkey = NULL;
2093
2094   realkeylen = gcry_sexp_canon_len (key, keylen, NULL, &err);
2095   if (!realkeylen)
2096     goto leave; /* Invalid canonical encoded S-expression.  */
2097
2098   err = keygrip_from_canon_sexp (key, realkeylen, grip);
2099   if (err)
2100     {
2101       /* This might be due to an unsupported S-expression format.
2102          Check whether this is openpgp-private-key and trigger that
2103          import code.  */
2104       if (!gcry_sexp_sscan (&openpgp_sexp, NULL, key, realkeylen))
2105         {
2106           const char *tag;
2107           size_t taglen;
2108
2109           tag = gcry_sexp_nth_data (openpgp_sexp, 0, &taglen);
2110           if (tag && taglen == 19 && !memcmp (tag, "openpgp-private-key", 19))
2111             ;
2112           else
2113             {
2114               gcry_sexp_release (openpgp_sexp);
2115               openpgp_sexp = NULL;
2116             }
2117         }
2118       if (!openpgp_sexp)
2119         goto leave; /* Note that ERR is still set.  */
2120     }
2121
2122
2123   if (openpgp_sexp)
2124     {
2125       /* In most cases the key is encrypted and thus the conversion
2126          function from the OpenPGP format to our internal format will
2127          ask for a passphrase.  That passphrase will be returned and
2128          used to protect the key using the same code as for regular
2129          key import. */
2130
2131       xfree (key);
2132       key = NULL;
2133       err = convert_from_openpgp (ctrl, openpgp_sexp, grip,
2134                                   ctrl->server_local->keydesc, cache_nonce,
2135                                   &key, opt_unattended? NULL : &passphrase);
2136       if (err)
2137         goto leave;
2138       realkeylen = gcry_sexp_canon_len (key, 0, NULL, &err);
2139       if (!realkeylen)
2140         goto leave; /* Invalid canonical encoded S-expression.  */
2141       if (passphrase)
2142         {
2143           assert (!opt_unattended);
2144           if (!cache_nonce)
2145             {
2146               char buf[12];
2147               gcry_create_nonce (buf, 12);
2148               cache_nonce = bin2hex (buf, 12, NULL);
2149             }
2150           if (cache_nonce
2151               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2152                                    passphrase, CACHE_TTL_NONCE))
2153             assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2154         }
2155     }
2156   else if (opt_unattended)
2157     {
2158       err = set_error (GPG_ERR_ASS_PARAMETER,
2159                        "\"--unattended\" may only be used with OpenPGP keys");
2160       goto leave;
2161     }
2162   else
2163     {
2164       if (!agent_key_available (grip))
2165         err = gpg_error (GPG_ERR_EEXIST);
2166       else
2167         {
2168           char *prompt = xtryasprintf
2169             (_("Please enter the passphrase to protect the "
2170                "imported object within the %s system."), GNUPG_NAME);
2171           if (!prompt)
2172             err = gpg_error_from_syserror ();
2173           else
2174             err = agent_ask_new_passphrase (ctrl, prompt, &passphrase);
2175           xfree (prompt);
2176         }
2177       if (err)
2178         goto leave;
2179     }
2180
2181   if (passphrase)
2182     {
2183       err = agent_protect (key, passphrase, &finalkey, &finalkeylen,
2184                            ctrl->s2k_count);
2185       if (!err)
2186         err = agent_write_private_key (grip, finalkey, finalkeylen, 0);
2187     }
2188   else
2189     err = agent_write_private_key (grip, key, realkeylen, 0);
2190
2191  leave:
2192   gcry_sexp_release (openpgp_sexp);
2193   xfree (finalkey);
2194   xfree (passphrase);
2195   xfree (key);
2196   gcry_cipher_close (cipherhd);
2197   xfree (wrappedkey);
2198   xfree (cache_nonce);
2199   xfree (ctrl->server_local->keydesc);
2200   ctrl->server_local->keydesc = NULL;
2201   return leave_cmd (ctx, err);
2202 }
2203
2204
2205 \f
2206 static const char hlp_export_key[] =
2207   "EXPORT_KEY [--cache-nonce=<nonce>] [--openpgp] <hexstring_with_keygrip>\n"
2208   "\n"
2209   "Export a secret key from the key store.  The key will be encrypted\n"
2210   "using the current session's key wrapping key (cf. command KEYWRAP_KEY)\n"
2211   "using the AESWRAP-128 algorithm.  The caller needs to retrieve that key\n"
2212   "prior to using this command.  The function takes the keygrip as argument.\n";
2213 static gpg_error_t
2214 cmd_export_key (assuan_context_t ctx, char *line)
2215 {
2216   ctrl_t ctrl = assuan_get_pointer (ctx);
2217   gpg_error_t err;
2218   unsigned char grip[20];
2219   gcry_sexp_t s_skey = NULL;
2220   unsigned char *key = NULL;
2221   size_t keylen;
2222   gcry_cipher_hd_t cipherhd = NULL;
2223   unsigned char *wrappedkey = NULL;
2224   size_t wrappedkeylen;
2225   int openpgp;
2226   char *cache_nonce;
2227   char *passphrase = NULL;
2228   unsigned char *shadow_info = NULL;
2229   char *pend;
2230   int c;
2231
2232   if (ctrl->restricted)
2233     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2234
2235   openpgp = has_option (line, "--openpgp");
2236   cache_nonce = option_value (line, "--cache-nonce");
2237   if (cache_nonce)
2238     {
2239       for (pend = cache_nonce; *pend && !spacep (pend); pend++)
2240         ;
2241       c = *pend;
2242       *pend = '\0';
2243       cache_nonce = xtrystrdup (cache_nonce);
2244       *pend = c;
2245       if (!cache_nonce)
2246         {
2247           err = gpg_error_from_syserror ();
2248           goto leave;
2249         }
2250     }
2251   line = skip_options (line);
2252
2253   if (!ctrl->server_local->export_key)
2254     {
2255       err = set_error (GPG_ERR_MISSING_KEY, "did you run KEYWRAP_KEY ?");
2256       goto leave;
2257     }
2258
2259   err = parse_keygrip (ctx, line, grip);
2260   if (err)
2261     goto leave;
2262
2263   if (agent_key_available (grip))
2264     {
2265       err = gpg_error (GPG_ERR_NO_SECKEY);
2266       goto leave;
2267     }
2268
2269   /* Get the key from the file.  With the openpgp flag we also ask for
2270      the passphrase so that we can use it to re-encrypt it.  */
2271   err = agent_key_from_file (ctrl, cache_nonce,
2272                              ctrl->server_local->keydesc, grip,
2273                              &shadow_info, CACHE_MODE_IGNORE, NULL, &s_skey,
2274                              openpgp ? &passphrase : NULL);
2275   if (err)
2276     goto leave;
2277   if (shadow_info)
2278     {
2279       /* Key is on a smartcard.  */
2280       err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2281       goto leave;
2282     }
2283
2284   if (openpgp)
2285     {
2286       /* The openpgp option changes the key format into the OpenPGP
2287          key transfer format.  The result is already a padded
2288          canonical S-expression.  */
2289       if (!passphrase)
2290         {
2291           err = agent_ask_new_passphrase
2292             (ctrl, _("This key (or subkey) is not protected with a passphrase."
2293                      "  Please enter a new passphrase to export it."),
2294              &passphrase);
2295           if (err)
2296             goto leave;
2297         }
2298       err = convert_to_openpgp (ctrl, s_skey, passphrase, &key, &keylen);
2299       if (!err && passphrase)
2300         {
2301           if (!cache_nonce)
2302             {
2303               char buf[12];
2304               gcry_create_nonce (buf, 12);
2305               cache_nonce = bin2hex (buf, 12, NULL);
2306             }
2307           if (cache_nonce
2308               && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
2309                                    passphrase, CACHE_TTL_NONCE))
2310             {
2311               assuan_write_status (ctx, "CACHE_NONCE", cache_nonce);
2312               xfree (ctrl->server_local->last_cache_nonce);
2313               ctrl->server_local->last_cache_nonce = cache_nonce;
2314               cache_nonce = NULL;
2315             }
2316         }
2317     }
2318   else
2319     {
2320       /* Convert into a canonical S-expression and wrap that.  */
2321       err = make_canon_sexp_pad (s_skey, 1, &key, &keylen);
2322     }
2323   if (err)
2324     goto leave;
2325   gcry_sexp_release (s_skey);
2326   s_skey = NULL;
2327
2328   err = gcry_cipher_open (&cipherhd, GCRY_CIPHER_AES128,
2329                           GCRY_CIPHER_MODE_AESWRAP, 0);
2330   if (err)
2331     goto leave;
2332   err = gcry_cipher_setkey (cipherhd,
2333                             ctrl->server_local->export_key, KEYWRAP_KEYSIZE);
2334   if (err)
2335     goto leave;
2336
2337   wrappedkeylen = keylen + 8;
2338   wrappedkey = xtrymalloc (wrappedkeylen);
2339   if (!wrappedkey)
2340     {
2341       err = gpg_error_from_syserror ();
2342       goto leave;
2343     }
2344
2345   err = gcry_cipher_encrypt (cipherhd, wrappedkey, wrappedkeylen, key, keylen);
2346   if (err)
2347     goto leave;
2348   xfree (key);
2349   key = NULL;
2350   gcry_cipher_close (cipherhd);
2351   cipherhd = NULL;
2352
2353   assuan_begin_confidential (ctx);
2354   err = assuan_send_data (ctx, wrappedkey, wrappedkeylen);
2355   assuan_end_confidential (ctx);
2356
2357
2358  leave:
2359   xfree (cache_nonce);
2360   xfree (passphrase);
2361   xfree (wrappedkey);
2362   gcry_cipher_close (cipherhd);
2363   xfree (key);
2364   gcry_sexp_release (s_skey);
2365   xfree (ctrl->server_local->keydesc);
2366   ctrl->server_local->keydesc = NULL;
2367   xfree (shadow_info);
2368
2369   return leave_cmd (ctx, err);
2370 }
2371
2372
2373 \f
2374 static const char hlp_delete_key[] =
2375   "DELETE_KEY <hexstring_with_keygrip>\n"
2376   "\n"
2377   "Delete a secret key from the key store.\n"
2378   "As safeguard the agent asks the user for confirmation.\n";
2379 static gpg_error_t
2380 cmd_delete_key (assuan_context_t ctx, char *line)
2381 {
2382   ctrl_t ctrl = assuan_get_pointer (ctx);
2383   gpg_error_t err;
2384   unsigned char grip[20];
2385
2386   if (ctrl->restricted)
2387     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2388
2389   line = skip_options (line);
2390
2391   err = parse_keygrip (ctx, line, grip);
2392   if (err)
2393     goto leave;
2394
2395   err = agent_delete_key (ctrl, ctrl->server_local->keydesc, grip);
2396   if (err)
2397     goto leave;
2398
2399  leave:
2400   xfree (ctrl->server_local->keydesc);
2401   ctrl->server_local->keydesc = NULL;
2402
2403   return leave_cmd (ctx, err);
2404 }
2405
2406
2407 \f
2408 static const char hlp_keytocard[] =
2409   "KEYTOCARD [--force] <hexstring_with_keygrip> <serialno> <id> <timestamp>\n"
2410   "\n";
2411 static gpg_error_t
2412 cmd_keytocard (assuan_context_t ctx, char *line)
2413 {
2414   ctrl_t ctrl = assuan_get_pointer (ctx);
2415   int force;
2416   gpg_error_t err = 0;
2417   unsigned char grip[20];
2418   gcry_sexp_t s_skey = NULL;
2419   unsigned char *keydata;
2420   size_t keydatalen, timestamplen;
2421   const char *serialno, *timestamp_str, *id;
2422   unsigned char *shadow_info = NULL;
2423   time_t timestamp;
2424
2425   if (ctrl->restricted)
2426     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2427
2428   force = has_option (line, "--force");
2429   line = skip_options (line);
2430
2431   err = parse_keygrip (ctx, line, grip);
2432   if (err)
2433     return err;
2434
2435   if (agent_key_available (grip))
2436     return gpg_error (GPG_ERR_NO_SECKEY);
2437
2438   line += 40;
2439   while (*line && (*line == ' ' || *line == '\t'))
2440     line++;
2441   serialno = line;
2442   while (*line && (*line != ' ' && *line != '\t'))
2443     line++;
2444   if (!*line)
2445     return gpg_error (GPG_ERR_MISSING_VALUE);
2446   *line = '\0';
2447   line++;
2448   while (*line && (*line == ' ' || *line == '\t'))
2449     line++;
2450   id = line;
2451   while (*line && (*line != ' ' && *line != '\t'))
2452     line++;
2453   if (!*line)
2454     return gpg_error (GPG_ERR_MISSING_VALUE);
2455   *line = '\0';
2456   line++;
2457   while (*line && (*line == ' ' || *line == '\t'))
2458     line++;
2459   timestamp_str = line;
2460   while (*line && (*line != ' ' && *line != '\t'))
2461     line++;
2462   if (*line)
2463     *line = '\0';
2464   timestamplen = line - timestamp_str;
2465   if (timestamplen != 15)
2466     return gpg_error (GPG_ERR_INV_VALUE);
2467
2468   err = agent_key_from_file (ctrl, NULL, ctrl->server_local->keydesc, grip,
2469                              &shadow_info, CACHE_MODE_IGNORE, NULL,
2470                              &s_skey, NULL);
2471   if (err)
2472     {
2473       xfree (shadow_info);
2474       return err;
2475     }
2476   if (shadow_info)
2477     {
2478       /* Key is on a smartcard already.  */
2479       xfree (shadow_info);
2480       gcry_sexp_release (s_skey);
2481       return gpg_error (GPG_ERR_UNUSABLE_SECKEY);
2482     }
2483
2484   keydatalen =  gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, NULL, 0);
2485   keydata = xtrymalloc_secure (keydatalen + 30);
2486   if (keydata == NULL)
2487     {
2488       gcry_sexp_release (s_skey);
2489       return gpg_error_from_syserror ();
2490     }
2491
2492   gcry_sexp_sprint (s_skey, GCRYSEXP_FMT_CANON, keydata, keydatalen);
2493   gcry_sexp_release (s_skey);
2494   keydatalen--;                 /* Decrement for last '\0'.  */
2495   /* Add timestamp "created-at" in the private key */
2496   timestamp = isotime2epoch (timestamp_str);
2497   snprintf (keydata+keydatalen-1, 30, "(10:created-at10:%010lu))", timestamp);
2498   keydatalen += 10 + 19 - 1;
2499   err = divert_writekey (ctrl, force, serialno, id, keydata, keydatalen);
2500   xfree (keydata);
2501
2502   return leave_cmd (ctx, err);
2503 }
2504
2505
2506 \f
2507 static const char hlp_getval[] =
2508   "GETVAL <key>\n"
2509   "\n"
2510   "Return the value for KEY from the special environment as created by\n"
2511   "PUTVAL.";
2512 static gpg_error_t
2513 cmd_getval (assuan_context_t ctx, char *line)
2514 {
2515   ctrl_t ctrl = assuan_get_pointer (ctx);
2516   int rc = 0;
2517   char *key = NULL;
2518   char *p;
2519   struct putval_item_s *vl;
2520
2521   if (ctrl->restricted)
2522     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2523
2524   for (p=line; *p == ' '; p++)
2525     ;
2526   key = p;
2527   p = strchr (key, ' ');
2528   if (p)
2529     {
2530       *p++ = 0;
2531       for (; *p == ' '; p++)
2532         ;
2533       if (*p)
2534         return set_error (GPG_ERR_ASS_PARAMETER, "too many arguments");
2535     }
2536   if (!*key)
2537     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2538
2539
2540   for (vl=putval_list; vl; vl = vl->next)
2541     if ( !strcmp (vl->d, key) )
2542       break;
2543
2544   if (vl) /* Got an entry. */
2545     rc = assuan_send_data (ctx, vl->d+vl->off, vl->len);
2546   else
2547     return gpg_error (GPG_ERR_NO_DATA);
2548
2549   return leave_cmd (ctx, rc);
2550 }
2551
2552
2553 static const char hlp_putval[] =
2554   "PUTVAL <key> [<percent_escaped_value>]\n"
2555   "\n"
2556   "The gpg-agent maintains a kind of environment which may be used to\n"
2557   "store key/value pairs in it, so that they can be retrieved later.\n"
2558   "This may be used by helper daemons to daemonize themself on\n"
2559   "invocation and register them with gpg-agent.  Callers of the\n"
2560   "daemon's service may now first try connect to get the information\n"
2561   "for that service from gpg-agent through the GETVAL command and then\n"
2562   "try to connect to that daemon.  Only if that fails they may start\n"
2563   "an own instance of the service daemon. \n"
2564   "\n"
2565   "KEY is an an arbitrary symbol with the same syntax rules as keys\n"
2566   "for shell environment variables.  PERCENT_ESCAPED_VALUE is the\n"
2567   "corresponsing value; they should be similar to the values of\n"
2568   "envronment variables but gpg-agent does not enforce any\n"
2569   "restrictions.  If that value is not given any value under that KEY\n"
2570   "is removed from this special environment.";
2571 static gpg_error_t
2572 cmd_putval (assuan_context_t ctx, char *line)
2573 {
2574   ctrl_t ctrl = assuan_get_pointer (ctx);
2575   int rc = 0;
2576   char *key = NULL;
2577   char *value = NULL;
2578   size_t valuelen = 0;
2579   char *p;
2580   struct putval_item_s *vl, *vlprev;
2581
2582   if (ctrl->restricted)
2583     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2584
2585   for (p=line; *p == ' '; p++)
2586     ;
2587   key = p;
2588   p = strchr (key, ' ');
2589   if (p)
2590     {
2591       *p++ = 0;
2592       for (; *p == ' '; p++)
2593         ;
2594       if (*p)
2595         {
2596           value = p;
2597           p = strchr (value, ' ');
2598           if (p)
2599             *p = 0;
2600           valuelen = percent_plus_unescape_inplace (value, 0);
2601         }
2602     }
2603   if (!*key)
2604     return set_error (GPG_ERR_ASS_PARAMETER, "no key given");
2605
2606
2607   for (vl=putval_list,vlprev=NULL; vl; vlprev=vl, vl = vl->next)
2608     if ( !strcmp (vl->d, key) )
2609       break;
2610
2611   if (vl) /* Delete old entry. */
2612     {
2613       if (vlprev)
2614         vlprev->next = vl->next;
2615       else
2616         putval_list = vl->next;
2617       xfree (vl);
2618     }
2619
2620   if (valuelen) /* Add entry. */
2621     {
2622       vl = xtrymalloc (sizeof *vl + strlen (key) + valuelen);
2623       if (!vl)
2624         rc = gpg_error_from_syserror ();
2625       else
2626         {
2627           vl->len = valuelen;
2628           vl->off = strlen (key) + 1;
2629           strcpy (vl->d, key);
2630           memcpy (vl->d + vl->off, value, valuelen);
2631           vl->next = putval_list;
2632           putval_list = vl;
2633         }
2634     }
2635
2636   return leave_cmd (ctx, rc);
2637 }
2638
2639
2640
2641 \f
2642 static const char hlp_updatestartuptty[] =
2643   "UPDATESTARTUPTTY\n"
2644   "\n"
2645   "Set startup TTY and X11 DISPLAY variables to the values of this\n"
2646   "session.  This command is useful to pull future pinentries to\n"
2647   "another screen.  It is only required because there is no way in the\n"
2648   "ssh-agent protocol to convey this information.";
2649 static gpg_error_t
2650 cmd_updatestartuptty (assuan_context_t ctx, char *line)
2651 {
2652   static const char *names[] =
2653     { "GPG_TTY", "DISPLAY", "TERM", "XAUTHORITY", "PINENTRY_USER_DATA", NULL };
2654   ctrl_t ctrl = assuan_get_pointer (ctx);
2655   gpg_error_t err = 0;
2656   session_env_t se;
2657   int idx;
2658   char *lc_ctype = NULL;
2659   char *lc_messages = NULL;
2660
2661   (void)line;
2662
2663   if (ctrl->restricted)
2664     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2665
2666   se = session_env_new ();
2667   if (!se)
2668     err = gpg_error_from_syserror ();
2669
2670   for (idx=0; !err && names[idx]; idx++)
2671     {
2672       const char *value = session_env_getenv (ctrl->session_env, names[idx]);
2673       if (value)
2674         err = session_env_setenv (se, names[idx], value);
2675     }
2676
2677   if (!err && ctrl->lc_ctype)
2678     if (!(lc_ctype = xtrystrdup (ctrl->lc_ctype)))
2679       err = gpg_error_from_syserror ();
2680
2681   if (!err && ctrl->lc_messages)
2682     if (!(lc_messages = xtrystrdup (ctrl->lc_messages)))
2683       err = gpg_error_from_syserror ();
2684
2685   if (err)
2686     {
2687       session_env_release (se);
2688       xfree (lc_ctype);
2689       xfree (lc_messages);
2690     }
2691   else
2692     {
2693       session_env_release (opt.startup_env);
2694       opt.startup_env = se;
2695       xfree (opt.startup_lc_ctype);
2696       opt.startup_lc_ctype = lc_ctype;
2697       xfree (opt.startup_lc_messages);
2698       opt.startup_lc_messages = lc_messages;
2699     }
2700
2701   return err;
2702 }
2703
2704
2705 \f
2706 static const char hlp_killagent[] =
2707   "KILLAGENT\n"
2708   "\n"
2709   "Stop the agent.";
2710 static gpg_error_t
2711 cmd_killagent (assuan_context_t ctx, char *line)
2712 {
2713   ctrl_t ctrl = assuan_get_pointer (ctx);
2714
2715   (void)line;
2716
2717   if (ctrl->restricted)
2718     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2719
2720   ctrl->server_local->stopme = 1;
2721   assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
2722   return 0;
2723 }
2724
2725
2726 static const char hlp_reloadagent[] =
2727   "RELOADAGENT\n"
2728   "\n"
2729   "This command is an alternative to SIGHUP\n"
2730   "to reload the configuration.";
2731 static gpg_error_t
2732 cmd_reloadagent (assuan_context_t ctx, char *line)
2733 {
2734   ctrl_t ctrl = assuan_get_pointer (ctx);
2735
2736   (void)line;
2737
2738   if (ctrl->restricted)
2739     return leave_cmd (ctx, gpg_error (GPG_ERR_FORBIDDEN));
2740
2741   agent_sighup_action ();
2742   return 0;
2743 }
2744
2745
2746 \f
2747 static const char hlp_getinfo[] =
2748   "GETINFO <what>\n"
2749   "\n"
2750   "Multipurpose function to return a variety of information.\n"
2751   "Supported values for WHAT are:\n"
2752   "\n"
2753   "  version     - Return the version of the program.\n"
2754   "  pid         - Return the process id of the server.\n"
2755   "  socket_name - Return the name of the socket.\n"
2756   "  ssh_socket_name - Return the name of the ssh socket.\n"
2757   "  scd_running - Return OK if the SCdaemon is already running.\n"
2758   "  s2k_count   - Return the calibrated S2K count.\n"
2759   "  std_session_env - List the standard session environment.\n"
2760   "  std_startup_env - List the standard startup environment.\n"
2761   "  cmd_has_option\n"
2762   "              - Returns OK if the command CMD implements the option OPT.\n"
2763   "  restricted  - Returns OK if the connection is in restricted mode.\n";
2764 static gpg_error_t
2765 cmd_getinfo (assuan_context_t ctx, char *line)
2766 {
2767   ctrl_t ctrl = assuan_get_pointer (ctx);
2768   int rc = 0;
2769
2770   if (!strcmp (line, "version"))
2771     {
2772       const char *s = VERSION;
2773       rc = assuan_send_data (ctx, s, strlen (s));
2774     }
2775   else if (!strncmp (line, "cmd_has_option", 14)
2776            && (line[14] == ' ' || line[14] == '\t' || !line[14]))
2777     {
2778       char *cmd, *cmdopt;
2779       line += 14;
2780       while (*line == ' ' || *line == '\t')
2781         line++;
2782       if (!*line)
2783         rc = gpg_error (GPG_ERR_MISSING_VALUE);
2784       else
2785         {
2786           cmd = line;
2787           while (*line && (*line != ' ' && *line != '\t'))
2788             line++;
2789           if (!*line)
2790             rc = gpg_error (GPG_ERR_MISSING_VALUE);
2791           else
2792             {
2793               *line++ = 0;
2794               while (*line == ' ' || *line == '\t')
2795                 line++;
2796               if (!*line)
2797                 rc = gpg_error (GPG_ERR_MISSING_VALUE);
2798               else
2799                 {
2800                   cmdopt = line;
2801                   if (!command_has_option (cmd, cmdopt))
2802                     rc = gpg_error (GPG_ERR_GENERAL);
2803                 }
2804             }
2805         }
2806     }
2807   else if (!strcmp (line, "s2k_count"))
2808     {
2809       char numbuf[50];
2810
2811       snprintf (numbuf, sizeof numbuf, "%lu", get_standard_s2k_count ());
2812       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2813     }
2814   else if (!strcmp (line, "restricted"))
2815     {
2816       rc = ctrl->restricted? 0 : gpg_error (GPG_ERR_GENERAL);
2817     }
2818   else if (ctrl->restricted)
2819     {
2820       rc = gpg_error (GPG_ERR_FORBIDDEN);
2821     }
2822   /* All sub-commands below are not allowed in restricted mode.  */
2823   else if (!strcmp (line, "pid"))
2824     {
2825       char numbuf[50];
2826
2827       snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
2828       rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
2829     }
2830   else if (!strcmp (line, "socket_name"))
2831     {
2832       const char *s = get_agent_socket_name ();
2833
2834       if (s)
2835         rc = assuan_send_data (ctx, s, strlen (s));
2836       else
2837         rc = gpg_error (GPG_ERR_NO_DATA);
2838     }
2839   else if (!strcmp (line, "ssh_socket_name"))
2840     {
2841       const char *s = get_agent_ssh_socket_name ();
2842
2843       if (s)
2844         rc = assuan_send_data (ctx, s, strlen (s));
2845       else
2846         rc = gpg_error (GPG_ERR_NO_DATA);
2847     }
2848   else if (!strcmp (line, "scd_running"))
2849     {
2850       rc = agent_scd_check_running ()? 0 : gpg_error (GPG_ERR_GENERAL);
2851     }
2852   else if (!strcmp (line, "std_session_env")
2853            || !strcmp (line, "std_startup_env"))
2854     {
2855       int iterator;
2856       const char *name, *value;
2857       char *string;
2858
2859       iterator = 0;
2860       while ((name = session_env_list_stdenvnames (&iterator, NULL)))
2861         {
2862           value = session_env_getenv_or_default
2863             (line[5] == 't'? opt.startup_env:ctrl->session_env, name, NULL);
2864           if (value)
2865             {
2866               string = xtryasprintf ("%s=%s", name, value);
2867               if (!string)
2868                 rc = gpg_error_from_syserror ();
2869               else
2870                 {
2871                   rc = assuan_send_data (ctx, string, strlen (string)+1);
2872                   if (!rc)
2873                     rc = assuan_send_data (ctx, NULL, 0);
2874                 }
2875               if (rc)
2876                 break;
2877             }
2878         }
2879     }
2880   else
2881     rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
2882   return rc;
2883 }
2884
2885
2886 \f
2887 /* This function is called by Libassuan to parse the OPTION command.
2888    It has been registered similar to the other Assuan commands.  */
2889 static gpg_error_t
2890 option_handler (assuan_context_t ctx, const char *key, const char *value)
2891 {
2892   ctrl_t ctrl = assuan_get_pointer (ctx);
2893   gpg_error_t err = 0;
2894
2895   if (!strcmp (key, "agent-awareness"))
2896     {
2897       /* The value is a version string telling us of which agent
2898          version the caller is aware of.  */
2899       ctrl->server_local->allow_fully_canceled =
2900         gnupg_compare_version (value, "2.1.0");
2901     }
2902   else if (ctrl->restricted)
2903     {
2904       err = gpg_error (GPG_ERR_FORBIDDEN);
2905     }
2906   /* All options below are not allowed in restricted mode.  */
2907   else if (!strcmp (key, "putenv"))
2908     {
2909       /* Change the session's environment to be used for the
2910          Pinentry.  Valid values are:
2911           <NAME>            Delete envvar NAME
2912           <KEY>=            Set envvar NAME to the empty string
2913           <KEY>=<VALUE>     Set envvar NAME to VALUE
2914       */
2915       err = session_env_putenv (ctrl->session_env, value);
2916     }
2917   else if (!strcmp (key, "display"))
2918     {
2919       err = session_env_setenv (ctrl->session_env, "DISPLAY", value);
2920     }
2921   else if (!strcmp (key, "ttyname"))
2922     {
2923       if (!opt.keep_tty)
2924         err = session_env_setenv (ctrl->session_env, "GPG_TTY", value);
2925     }
2926   else if (!strcmp (key, "ttytype"))
2927     {
2928       if (!opt.keep_tty)
2929         err = session_env_setenv (ctrl->session_env, "TERM", value);
2930     }
2931   else if (!strcmp (key, "lc-ctype"))
2932     {
2933       if (ctrl->lc_ctype)
2934         xfree (ctrl->lc_ctype);
2935       ctrl->lc_ctype = xtrystrdup (value);
2936       if (!ctrl->lc_ctype)
2937         return out_of_core ();
2938     }
2939   else if (!strcmp (key, "lc-messages"))
2940     {
2941       if (ctrl->lc_messages)
2942         xfree (ctrl->lc_messages);
2943       ctrl->lc_messages = xtrystrdup (value);
2944       if (!ctrl->lc_messages)
2945         return out_of_core ();
2946     }
2947   else if (!strcmp (key, "xauthority"))
2948     {
2949       err = session_env_setenv (ctrl->session_env, "XAUTHORITY", value);
2950     }
2951   else if (!strcmp (key, "pinentry-user-data"))
2952     {
2953       err = session_env_setenv (ctrl->session_env, "PINENTRY_USER_DATA", value);
2954     }
2955   else if (!strcmp (key, "use-cache-for-signing"))
2956     ctrl->server_local->use_cache_for_signing = *value? atoi (value) : 0;
2957   else if (!strcmp (key, "allow-pinentry-notify"))
2958     ctrl->server_local->allow_pinentry_notify = 1;
2959   else if (!strcmp (key, "pinentry-mode"))
2960     {
2961       int tmp = parse_pinentry_mode (value);
2962       if (tmp == -1)
2963         err = gpg_error (GPG_ERR_INV_VALUE);
2964       else if (tmp == PINENTRY_MODE_LOOPBACK && !opt.allow_loopback_pinentry)
2965         err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2966       else
2967         ctrl->pinentry_mode = tmp;
2968     }
2969   else if (!strcmp (key, "cache-ttl-opt-preset"))
2970     {
2971       ctrl->cache_ttl_opt_preset = *value? atoi (value) : 0;
2972     }
2973   else if (!strcmp (key, "s2k-count"))
2974     {
2975       ctrl->s2k_count = *value? strtoul(value, NULL, 10) : 0;
2976       if (ctrl->s2k_count && ctrl->s2k_count < 65536)
2977         {
2978           ctrl->s2k_count = 0;
2979         }
2980     }
2981   else
2982     err = gpg_error (GPG_ERR_UNKNOWN_OPTION);
2983
2984   return err;
2985 }
2986
2987
2988
2989 \f
2990 /* Called by libassuan after all commands. ERR is the error from the
2991    last assuan operation and not the one returned from the command. */
2992 static void
2993 post_cmd_notify (assuan_context_t ctx, gpg_error_t err)
2994 {
2995   ctrl_t ctrl = assuan_get_pointer (ctx);
2996
2997   (void)err;
2998
2999   /* Switch off any I/O monitor controlled logging pausing. */
3000   ctrl->server_local->pause_io_logging = 0;
3001 }
3002
3003
3004 /* This function is called by libassuan for all I/O.  We use it here
3005    to disable logging for the GETEVENTCOUNTER commands.  This is so
3006    that the debug output won't get cluttered by this primitive
3007    command.  */
3008 static unsigned int
3009 io_monitor (assuan_context_t ctx, void *hook, int direction,
3010             const char *line, size_t linelen)
3011 {
3012   ctrl_t ctrl = assuan_get_pointer (ctx);
3013
3014   (void) hook;
3015
3016   /* Note that we only check for the uppercase name.  This allows to
3017      see the logging for debugging if using a non-upercase command
3018      name. */
3019   if (ctx && direction == ASSUAN_IO_FROM_PEER
3020       && linelen >= 15
3021       && !strncmp (line, "GETEVENTCOUNTER", 15)
3022       && (linelen == 15 || spacep (line+15)))
3023     {
3024       ctrl->server_local->pause_io_logging = 1;
3025     }
3026
3027   return ctrl->server_local->pause_io_logging? ASSUAN_IO_MONITOR_NOLOG : 0;
3028 }
3029
3030
3031 /* Return true if the command CMD implements the option OPT.  */
3032 static int
3033 command_has_option (const char *cmd, const char *cmdopt)
3034 {
3035   if (!strcmp (cmd, "GET_PASSPHRASE"))
3036     {
3037       if (!strcmp (cmdopt, "repeat"))
3038           return 1;
3039     }
3040
3041   return 0;
3042 }
3043
3044
3045 /* Tell Libassuan about our commands.  Also register the other Assuan
3046    handlers. */
3047 static int
3048 register_commands (assuan_context_t ctx)
3049 {
3050   static struct {
3051     const char *name;
3052     assuan_handler_t handler;
3053     const char * const help;
3054   } table[] = {
3055     { "GETEVENTCOUNTER",cmd_geteventcounter, hlp_geteventcounter },
3056     { "ISTRUSTED",      cmd_istrusted, hlp_istrusted },
3057     { "HAVEKEY",        cmd_havekey,   hlp_havekey },
3058     { "KEYINFO",        cmd_keyinfo,   hlp_keyinfo },
3059     { "SIGKEY",         cmd_sigkey,    hlp_sigkey },
3060     { "SETKEY",         cmd_sigkey,    hlp_sigkey },
3061     { "SETKEYDESC",     cmd_setkeydesc,hlp_setkeydesc },
3062     { "SETHASH",        cmd_sethash,   hlp_sethash },
3063     { "PKSIGN",         cmd_pksign,    hlp_pksign },
3064     { "PKDECRYPT",      cmd_pkdecrypt, hlp_pkdecrypt },
3065     { "GENKEY",         cmd_genkey,    hlp_genkey },
3066     { "READKEY",        cmd_readkey,   hlp_readkey },
3067     { "GET_PASSPHRASE", cmd_get_passphrase, hlp_get_passphrase },
3068     { "PRESET_PASSPHRASE", cmd_preset_passphrase, hlp_preset_passphrase },
3069     { "CLEAR_PASSPHRASE", cmd_clear_passphrase,   hlp_clear_passphrase },
3070     { "GET_CONFIRMATION", cmd_get_confirmation,   hlp_get_confirmation },
3071     { "LISTTRUSTED",    cmd_listtrusted, hlp_listtrusted },
3072     { "MARKTRUSTED",    cmd_marktrusted, hlp_martrusted },
3073     { "LEARN",          cmd_learn,     hlp_learn },
3074     { "PASSWD",         cmd_passwd,    hlp_passwd },
3075     { "INPUT",          NULL },
3076     { "OUTPUT",         NULL },
3077     { "SCD",            cmd_scd,       hlp_scd },
3078     { "KEYWRAP_KEY",    cmd_keywrap_key, hlp_keywrap_key },
3079     { "IMPORT_KEY",     cmd_import_key, hlp_import_key },
3080     { "EXPORT_KEY",     cmd_export_key, hlp_export_key },
3081     { "DELETE_KEY",     cmd_delete_key, hlp_delete_key },
3082     { "GETVAL",         cmd_getval,    hlp_getval },
3083     { "PUTVAL",         cmd_putval,    hlp_putval },
3084     { "UPDATESTARTUPTTY",  cmd_updatestartuptty, hlp_updatestartuptty },
3085     { "KILLAGENT",      cmd_killagent,  hlp_killagent },
3086     { "RELOADAGENT",    cmd_reloadagent,hlp_reloadagent },
3087     { "GETINFO",        cmd_getinfo,   hlp_getinfo },
3088     { "KEYTOCARD",      cmd_keytocard, hlp_keytocard },
3089     { NULL }
3090   };
3091   int i, rc;
3092
3093   for (i=0; table[i].name; i++)
3094     {
3095       rc = assuan_register_command (ctx, table[i].name, table[i].handler,
3096                                     table[i].help);
3097       if (rc)
3098         return rc;
3099     }
3100   assuan_register_post_cmd_notify (ctx, post_cmd_notify);
3101   assuan_register_reset_notify (ctx, reset_notify);
3102   assuan_register_option_handler (ctx, option_handler);
3103   return 0;
3104 }
3105
3106
3107 /* Startup the server.  If LISTEN_FD and FD is given as -1, this is a
3108    simple piper server, otherwise it is a regular server.  CTRL is the
3109    control structure for this connection; it has only the basic
3110    intialization. */
3111 void
3112 start_command_handler (ctrl_t ctrl, gnupg_fd_t listen_fd, gnupg_fd_t fd)
3113 {
3114   int rc;
3115   assuan_context_t ctx = NULL;
3116
3117   if (ctrl->restricted)
3118     {
3119       if (agent_copy_startup_env (ctrl))
3120         return;
3121     }
3122
3123   rc = assuan_new (&ctx);
3124   if (rc)
3125     {
3126       log_error ("failed to allocate assuan context: %s\n", gpg_strerror (rc));
3127       agent_exit (2);
3128     }
3129
3130   if (listen_fd == GNUPG_INVALID_FD && fd == GNUPG_INVALID_FD)
3131     {
3132       assuan_fd_t filedes[2];
3133
3134       filedes[0] = assuan_fdopen (0);
3135       filedes[1] = assuan_fdopen (1);
3136       rc = assuan_init_pipe_server (ctx, filedes);
3137     }
3138   else if (listen_fd != GNUPG_INVALID_FD)
3139     {
3140       rc = assuan_init_socket_server (ctx, listen_fd, 0);
3141       /* FIXME: Need to call assuan_sock_set_nonce for Windows.  But
3142          this branch is currently not used.  */
3143     }
3144   else
3145     {
3146       rc = assuan_init_socket_server (ctx, fd, ASSUAN_SOCKET_SERVER_ACCEPTED);
3147     }
3148   if (rc)
3149     {
3150       log_error ("failed to initialize the server: %s\n",
3151                  gpg_strerror(rc));
3152       agent_exit (2);
3153     }
3154   rc = register_commands (ctx);
3155   if (rc)
3156     {
3157       log_error ("failed to register commands with Assuan: %s\n",
3158                  gpg_strerror(rc));
3159       agent_exit (2);
3160     }
3161
3162   assuan_set_pointer (ctx, ctrl);
3163   ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
3164   ctrl->server_local->assuan_ctx = ctx;
3165   ctrl->server_local->use_cache_for_signing = 1;
3166   ctrl->digest.raw_value = 0;
3167
3168   assuan_set_io_monitor (ctx, io_monitor, NULL);
3169
3170   for (;;)
3171     {
3172       rc = assuan_accept (ctx);
3173       if (gpg_err_code (rc) == GPG_ERR_EOF || rc == -1)
3174         {
3175           break;
3176         }
3177       else if (rc)
3178         {
3179           log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
3180           break;
3181         }
3182
3183       rc = assuan_process (ctx);
3184       if (rc)
3185         {
3186           log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
3187           continue;
3188         }
3189     }
3190
3191   /* Reset the nonce caches.  */
3192   clear_nonce_cache (ctrl);
3193
3194   /* Reset the SCD if needed. */
3195   agent_reset_scd (ctrl);
3196
3197   /* Reset the pinentry (in case of popup messages). */
3198   agent_reset_query (ctrl);
3199
3200   /* Cleanup.  */
3201   assuan_release (ctx);
3202   xfree (ctrl->server_local->keydesc);
3203   xfree (ctrl->server_local->import_key);
3204   xfree (ctrl->server_local->export_key);
3205   if (ctrl->server_local->stopme)
3206     agent_exit (0);
3207   xfree (ctrl->server_local);
3208   ctrl->server_local = NULL;
3209 }
3210
3211
3212 /* Helper for the pinentry loopback mode.  It merely passes the
3213    parameters on to the client.  */
3214 gpg_error_t
3215 pinentry_loopback(ctrl_t ctrl, const char *keyword,
3216                   unsigned char **buffer, size_t *size,
3217                   size_t max_length)
3218 {
3219   gpg_error_t rc;
3220   assuan_context_t ctx = ctrl->server_local->assuan_ctx;
3221
3222   rc = print_assuan_status (ctx, "INQUIRE_MAXLEN", "%zu", max_length);
3223   if (rc)
3224     return rc;
3225
3226   assuan_begin_confidential (ctx);
3227   rc = assuan_inquire (ctx, keyword, buffer, size, max_length);
3228   assuan_end_confidential (ctx);
3229   return rc;
3230 }