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