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