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