tools/gpg-wks-client.c

   1 /* gpg-wks-client.c - A client for the Web Key Service protocols.
   2  * Copyright (C) 2016 Werner Koch
   3  * Copyright (C) 2016 Bundesamt für Sicherheit in der Informationstechnik
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * This file is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU Lesser General Public License as
   9  * published by the Free Software Foundation; either version 2.1 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This file 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 Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "../common/util.h"
  27 #include "../common/status.h"
  28 #include "../common/i18n.h"
  29 #include "../common/sysutils.h"
  30 #include "../common/init.h"
  31 #include "../common/asshelp.h"
  32 #include "../common/userids.h"
  33 #include "../common/ccparray.h"
  34 #include "../common/exectool.h"
  35 #include "../common/mbox-util.h"
  36 #include "../common/name-value.h"
  37 #include "call-dirmngr.h"
  38 #include "mime-maker.h"
  39 #include "send-mail.h"
  40 #include "gpg-wks.h"
  41
  42
  43 /* Constants to identify the commands and options. */
  44 enum cmd_and_opt_values
  45   {
  46     aNull = 0,
  47
  48     oQuiet      = 'q',
  49     oVerbose    = 'v',
  50     oOutput     = 'o',
  51
  52     oDebug      = 500,
  53
  54     aSupported,
  55     aCheck,
  56     aCreate,
  57     aReceive,
  58     aRead,
  59
  60     oGpgProgram,
  61     oSend,
  62     oFakeSubmissionAddr,
  63     oStatusFD,
  64
  65     oDummy
  66   };
  67
  68
  69 /* The list of commands and options. */
  70 static ARGPARSE_OPTS opts[] = {
  71   ARGPARSE_group (300, ("@Commands:\n ")),
  72
  73   ARGPARSE_c (aSupported, "supported",
  74               ("check whether provider supports WKS")),
  75   ARGPARSE_c (aCheck, "check",
  76               ("check whether a key is available")),
  77   ARGPARSE_c (aCreate,   "create",
  78               ("create a publication request")),
  79   ARGPARSE_c (aReceive,   "receive",
  80               ("receive a MIME confirmation request")),
  81   ARGPARSE_c (aRead,      "read",
  82               ("receive a plain text confirmation request")),
  83
  84   ARGPARSE_group (301, ("@\nOptions:\n ")),
  85
  86   ARGPARSE_s_n (oVerbose, "verbose", ("verbose")),
  87   ARGPARSE_s_n (oQuiet, "quiet",  ("be somewhat more quiet")),
  88   ARGPARSE_s_s (oDebug, "debug", "@"),
  89   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
  90   ARGPARSE_s_n (oSend, "send", "send the mail using sendmail"),
  91   ARGPARSE_s_s (oOutput, "output", "|FILE|write the mail to FILE"),
  92   ARGPARSE_s_i (oStatusFD, "status-fd", N_("|FD|write status info to this FD")),
  93
  94   ARGPARSE_s_s (oFakeSubmissionAddr, "fake-submission-addr", "@"),
  95
  96   ARGPARSE_end ()
  97 };
  98
  99
 100 /* The list of supported debug flags.  */
 101 static struct debug_flags_s debug_flags [] =
 102   {
 103     { DBG_MIME_VALUE   , "mime"    },
 104     { DBG_PARSER_VALUE , "parser"  },
 105     { DBG_CRYPTO_VALUE , "crypto"  },
 106     { DBG_MEMORY_VALUE , "memory"  },
 107     { DBG_MEMSTAT_VALUE, "memstat" },
 108     { DBG_IPC_VALUE    , "ipc"     },
 109     { DBG_EXTPROG_VALUE, "extprog" },
 110     { 0, NULL }
 111   };
 112
 113
 114
 115 /* Value of the option --fake-submission-addr.  */
 116 const char *fake_submission_addr;
 117
 118
 119 static void wrong_args (const char *text) GPGRT_ATTR_NORETURN;
 120 static gpg_error_t command_supported (char *userid);
 121 static gpg_error_t command_check (char *userid);
 122 static gpg_error_t command_send (const char *fingerprint, char *userid);
 123 static gpg_error_t encrypt_response (estream_t *r_output, estream_t input,
 124                                      const char *addrspec,
 125                                      const char *fingerprint);
 126 static gpg_error_t read_confirmation_request (estream_t msg);
 127 static gpg_error_t command_receive_cb (void *opaque,
 128                                        const char *mediatype, estream_t fp,
 129                                        unsigned int flags);
 130
 131
 132 \f
 133 /* Print usage information and provide strings for help. */
 134 static const char *
 135 my_strusage( int level )
 136 {
 137   const char *p;
 138
 139   switch (level)
 140     {
 141     case 11: p = "gpg-wks-client"; break;
 142     case 12: p = "@GNUPG@"; break;
 143     case 13: p = VERSION; break;
 144     case 17: p = PRINTABLE_OS_NAME; break;
 145     case 19: p = ("Please report bugs to <@EMAIL@>.\n"); break;
 146
 147     case 1:
 148     case 40:
 149       p = ("Usage: gpg-wks-client [command] [options] [args] (-h for help)");
 150       break;
 151     case 41:
 152       p = ("Syntax: gpg-wks-client [command] [options] [args]\n"
 153            "Client for the Web Key Service\n");
 154       break;
 155
 156     default: p = NULL; break;
 157     }
 158   return p;
 159 }
 160
 161
 162 static void
 163 wrong_args (const char *text)
 164 {
 165   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), strusage (11), text);
 166   exit (2);
 167 }
 168
 169
 170 \f
 171 /* Command line parsing.  */
 172 static enum cmd_and_opt_values
 173 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
 174 {
 175   enum cmd_and_opt_values cmd = 0;
 176   int no_more_options = 0;
 177
 178   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
 179     {
 180       switch (pargs->r_opt)
 181         {
 182         case oQuiet:     opt.quiet = 1; break;
 183         case oVerbose:   opt.verbose++; break;
 184         case oDebug:
 185           if (parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags))
 186             {
 187               pargs->r_opt = ARGPARSE_INVALID_ARG;
 188               pargs->err = ARGPARSE_PRINT_ERROR;
 189             }
 190           break;
 191
 192         case oGpgProgram:
 193           opt.gpg_program = pargs->r.ret_str;
 194           break;
 195         case oSend:
 196           opt.use_sendmail = 1;
 197           break;
 198         case oOutput:
 199           opt.output = pargs->r.ret_str;
 200           break;
 201         case oFakeSubmissionAddr:
 202           fake_submission_addr = pargs->r.ret_str;
 203           break;
 204         case oStatusFD:
 205           wks_set_status_fd (translate_sys2libc_fd_int (pargs->r.ret_int, 1));
 206           break;
 207
 208         case aSupported:
 209         case aCreate:
 210         case aReceive:
 211         case aRead:
 212         case aCheck:
 213           cmd = pargs->r_opt;
 214           break;
 215
 216         default: pargs->err = 2; break;
 217         }
 218     }
 219
 220   return cmd;
 221 }
 222
 223
 224 \f
 225 /* gpg-wks-client main. */
 226 int
 227 main (int argc, char **argv)
 228 {
 229   gpg_error_t err;
 230   ARGPARSE_ARGS pargs;
 231   enum cmd_and_opt_values cmd;
 232
 233   gnupg_reopen_std ("gpg-wks-client");
 234   set_strusage (my_strusage);
 235   log_set_prefix ("gpg-wks-client", GPGRT_LOG_WITH_PREFIX);
 236
 237   /* Make sure that our subsystems are ready.  */
 238   i18n_init();
 239   init_common_subsystems (&argc, &argv);
 240
 241   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
 242   setup_libassuan_logging (&opt.debug, NULL);
 243
 244   /* Parse the command line. */
 245   pargs.argc  = &argc;
 246   pargs.argv  = &argv;
 247   pargs.flags = ARGPARSE_FLAG_KEEP;
 248   cmd = parse_arguments (&pargs, opts);
 249
 250   if (log_get_errorcount (0))
 251     exit (2);
 252
 253   /* Print a warning if an argument looks like an option.  */
 254   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
 255     {
 256       int i;
 257
 258       for (i=0; i < argc; i++)
 259         if (argv[i][0] == '-' && argv[i][1] == '-')
 260           log_info (("NOTE: '%s' is not considered an option\n"), argv[i]);
 261     }
 262
 263   /* Set defaults for non given options.  */
 264   if (!opt.gpg_program)
 265     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
 266
 267   /* Tell call-dirmngr what options we want.  */
 268   set_dirmngr_options (opt.verbose, (opt.debug & DBG_IPC_VALUE), 1);
 269
 270   /* Run the selected command.  */
 271   switch (cmd)
 272     {
 273     case aSupported:
 274       if (argc != 1)
 275         wrong_args ("--supported USER-ID");
 276       err = command_supported (argv[0]);
 277       if (err && gpg_err_code (err) != GPG_ERR_FALSE)
 278         log_error ("checking support failed: %s\n", gpg_strerror (err));
 279       break;
 280
 281     case aCreate:
 282       if (argc != 2)
 283         wrong_args ("--create FINGERPRINT USER-ID");
 284       err = command_send (argv[0], argv[1]);
 285       if (err)
 286         log_error ("creating request failed: %s\n", gpg_strerror (err));
 287       break;
 288
 289     case aReceive:
 290       if (argc)
 291         wrong_args ("--receive < MIME-DATA");
 292       err = wks_receive (es_stdin, command_receive_cb, NULL);
 293       if (err)
 294         log_error ("processing mail failed: %s\n", gpg_strerror (err));
 295       break;
 296
 297     case aRead:
 298       if (argc)
 299         wrong_args ("--read < WKS-DATA");
 300       err = read_confirmation_request (es_stdin);
 301       if (err)
 302         log_error ("processing mail failed: %s\n", gpg_strerror (err));
 303       break;
 304
 305     case aCheck:
 306       if (argc != 1)
 307         wrong_args ("--check USER-ID");
 308       err = command_check (argv[0]);
 309       break;
 310
 311     default:
 312       usage (1);
 313       err = 0;
 314       break;
 315     }
 316
 317   if (err)
 318     wks_write_status (STATUS_FAILURE, "- %u", err);
 319   else if (log_get_errorcount (0))
 320     wks_write_status (STATUS_FAILURE, "- %u", GPG_ERR_GENERAL);
 321   else
 322     wks_write_status (STATUS_SUCCESS, NULL);
 323   return log_get_errorcount (0)? 1:0;
 324 }
 325
 326
 327 \f
 328 struct get_key_status_parm_s
 329 {
 330   const char *fpr;
 331   int found;
 332   int count;
 333 };
 334
 335 static void
 336 get_key_status_cb (void *opaque, const char *keyword, char *args)
 337 {
 338   struct get_key_status_parm_s *parm = opaque;
 339
 340   /*log_debug ("%s: %s\n", keyword, args);*/
 341   if (!strcmp (keyword, "EXPORTED"))
 342     {
 343       parm->count++;
 344       if (!ascii_strcasecmp (args, parm->fpr))
 345         parm->found = 1;
 346     }
 347 }
 348
 349
 350 /* Get a key by fingerprint from gpg's keyring and make sure that the
 351  * mail address ADDRSPEC is included in the key.  The key is returned
 352  * as a new memory stream at R_KEY.  */
 353 static gpg_error_t
 354 get_key (estream_t *r_key, const char *fingerprint, const char *addrspec)
 355 {
 356   gpg_error_t err;
 357   ccparray_t ccp;
 358   const char **argv = NULL;
 359   estream_t key = NULL;
 360   struct get_key_status_parm_s parm;
 361   char *filterexp = NULL;
 362
 363   memset (&parm, 0, sizeof parm);
 364
 365   *r_key = NULL;
 366
 367   key = es_fopenmem (0, "w+b");
 368   if (!key)
 369     {
 370       err = gpg_error_from_syserror ();
 371       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
 372       goto leave;
 373     }
 374
 375   /* Prefix the key with the MIME content type.  */
 376   es_fputs ("Content-Type: application/pgp-keys\n"
 377             "\n", key);
 378
 379   filterexp = es_bsprintf ("keep-uid=mbox = %s", addrspec);
 380   if (!filterexp)
 381     {
 382       err = gpg_error_from_syserror ();
 383       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
 384       goto leave;
 385     }
 386
 387   ccparray_init (&ccp, 0);
 388
 389   ccparray_put (&ccp, "--no-options");
 390   if (!opt.verbose)
 391     ccparray_put (&ccp, "--quiet");
 392   else if (opt.verbose > 1)
 393     ccparray_put (&ccp, "--verbose");
 394   ccparray_put (&ccp, "--batch");
 395   ccparray_put (&ccp, "--status-fd=2");
 396   ccparray_put (&ccp, "--always-trust");
 397   ccparray_put (&ccp, "--armor");
 398   ccparray_put (&ccp, "--export-options=export-minimal");
 399   ccparray_put (&ccp, "--export-filter");
 400   ccparray_put (&ccp, filterexp);
 401   ccparray_put (&ccp, "--export");
 402   ccparray_put (&ccp, "--");
 403   ccparray_put (&ccp, fingerprint);
 404
 405   ccparray_put (&ccp, NULL);
 406   argv = ccparray_get (&ccp, NULL);
 407   if (!argv)
 408     {
 409       err = gpg_error_from_syserror ();
 410       goto leave;
 411     }
 412   parm.fpr = fingerprint;
 413   err = gnupg_exec_tool_stream (opt.gpg_program, argv, NULL,
 414                                 NULL, key,
 415                                 get_key_status_cb, &parm);
 416   if (!err && parm.count > 1)
 417     err = gpg_error (GPG_ERR_TOO_MANY);
 418   else if (!err && !parm.found)
 419     err = gpg_error (GPG_ERR_NOT_FOUND);
 420   if (err)
 421     {
 422       log_error ("export failed: %s\n", gpg_strerror (err));
 423       goto leave;
 424     }
 425
 426   es_rewind (key);
 427   *r_key = key;
 428   key = NULL;
 429
 430  leave:
 431   es_fclose (key);
 432   xfree (argv);
 433   xfree (filterexp);
 434   return err;
 435 }
 436
 437
 438 \f
 439 struct decrypt_stream_parm_s
 440 {
 441   char *fpr;
 442   char *mainfpr;
 443   int  otrust;
 444 };
 445
 446 static void
 447 decrypt_stream_status_cb (void *opaque, const char *keyword, char *args)
 448 {
 449   struct decrypt_stream_parm_s *decinfo = opaque;
 450
 451   if (DBG_CRYPTO)
 452     log_debug ("gpg status: %s %s\n", keyword, args);
 453   if (!strcmp (keyword, "DECRYPTION_KEY") && !decinfo->fpr)
 454     {
 455       char *fields[3];
 456
 457       if (split_fields (args, fields, DIM (fields)) >= 3)
 458         {
 459           decinfo->fpr = xstrdup (fields[0]);
 460           decinfo->mainfpr = xstrdup (fields[1]);
 461           decinfo->otrust = *fields[2];
 462         }
 463     }
 464 }
 465
 466 /* Decrypt the INPUT stream to a new stream which is stored at success
 467  * at R_OUTPUT.  */
 468 static gpg_error_t
 469 decrypt_stream (estream_t *r_output, struct decrypt_stream_parm_s *decinfo,
 470                 estream_t input)
 471 {
 472   gpg_error_t err;
 473   ccparray_t ccp;
 474   const char **argv;
 475   estream_t output;
 476
 477   *r_output = NULL;
 478   memset (decinfo, 0, sizeof *decinfo);
 479
 480   output = es_fopenmem (0, "w+b");
 481   if (!output)
 482     {
 483       err = gpg_error_from_syserror ();
 484       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
 485       return err;
 486     }
 487
 488   ccparray_init (&ccp, 0);
 489
 490   ccparray_put (&ccp, "--no-options");
 491   /* We limit the output to 64 KiB to avoid DoS using compression
 492    * tricks.  A regular client will anyway only send a minimal key;
 493    * that is one w/o key signatures and attribute packets.  */
 494   ccparray_put (&ccp, "--max-output=0x10000");
 495   if (!opt.verbose)
 496     ccparray_put (&ccp, "--quiet");
 497   else if (opt.verbose > 1)
 498     ccparray_put (&ccp, "--verbose");
 499   ccparray_put (&ccp, "--batch");
 500   ccparray_put (&ccp, "--status-fd=2");
 501   ccparray_put (&ccp, "--decrypt");
 502   ccparray_put (&ccp, "--");
 503
 504   ccparray_put (&ccp, NULL);
 505   argv = ccparray_get (&ccp, NULL);
 506   if (!argv)
 507     {
 508       err = gpg_error_from_syserror ();
 509       goto leave;
 510     }
 511   err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
 512                                 NULL, output,
 513                                 decrypt_stream_status_cb, decinfo);
 514   if (!err && (!decinfo->fpr || !decinfo->mainfpr || !decinfo->otrust))
 515     err = gpg_error (GPG_ERR_INV_ENGINE);
 516   if (err)
 517     {
 518       log_error ("decryption failed: %s\n", gpg_strerror (err));
 519       goto leave;
 520     }
 521   else if (opt.verbose)
 522     log_info ("decryption succeeded\n");
 523
 524   es_rewind (output);
 525   *r_output = output;
 526   output = NULL;
 527
 528  leave:
 529   if (err)
 530     {
 531       xfree (decinfo->fpr);
 532       xfree (decinfo->mainfpr);
 533       memset (decinfo, 0, sizeof *decinfo);
 534     }
 535   es_fclose (output);
 536   xfree (argv);
 537   return err;
 538 }
 539
 540
 541
 542 \f
 543 /* Check whether the  provider supports the WKS protocol.  */
 544 static gpg_error_t
 545 command_supported (char *userid)
 546 {
 547   gpg_error_t err;
 548   char *addrspec = NULL;
 549   char *submission_to = NULL;
 550
 551   if (!strchr (userid, '@'))
 552     {
 553       char *tmp = xstrconcat ("foo@", userid, NULL);
 554       addrspec = mailbox_from_userid (tmp);
 555       xfree (tmp);
 556     }
 557   else
 558     addrspec = mailbox_from_userid (userid);
 559   if (!addrspec)
 560     {
 561       log_error (_("\"%s\" is not a proper mail address\n"), userid);
 562       err = gpg_error (GPG_ERR_INV_USER_ID);
 563       goto leave;
 564     }
 565
 566   /* Get the submission address.  */
 567   err = wkd_get_submission_address (addrspec, &submission_to);
 568   if (err)
 569     {
 570       if (gpg_err_code (err) == GPG_ERR_NO_DATA
 571           || gpg_err_code (err) == GPG_ERR_UNKNOWN_HOST)
 572         {
 573           if (opt.verbose)
 574             log_info ("provider for '%s' does NOT support WKS (%s)\n",
 575                       addrspec, gpg_strerror (err));
 576           err = gpg_error (GPG_ERR_FALSE);
 577           log_inc_errorcount ();
 578         }
 579       goto leave;
 580     }
 581   if (opt.verbose)
 582     log_info ("provider for '%s' supports WKS\n", addrspec);
 583
 584  leave:
 585   xfree (submission_to);
 586   xfree (addrspec);
 587   return err;
 588 }
 589
 590
 591 \f
 592 /* Check whether the key for USERID is available in the WKD.  */
 593 static gpg_error_t
 594 command_check (char *userid)
 595 {
 596   gpg_error_t err;
 597   char *addrspec = NULL;
 598   estream_t key = NULL;
 599   char *fpr = NULL;
 600   strlist_t mboxes = NULL;
 601   strlist_t sl;
 602   int found = 0;
 603
 604   addrspec = mailbox_from_userid (userid);
 605   if (!addrspec)
 606     {
 607       log_error (_("\"%s\" is not a proper mail address\n"), userid);
 608       err = gpg_error (GPG_ERR_INV_USER_ID);
 609       goto leave;
 610     }
 611
 612   /* Get the submission address.  */
 613   err = wkd_get_key (addrspec, &key);
 614   switch (gpg_err_code (err))
 615     {
 616     case 0:
 617       if (opt.verbose)
 618         log_info ("public key for '%s' found via WKD\n", addrspec);
 619       /* Fixme: Check that the key contains the user id.  */
 620       break;
 621
 622     case GPG_ERR_NO_DATA: /* No such key.  */
 623       if (opt.verbose)
 624         log_info ("public key for '%s' NOT found via WKD\n", addrspec);
 625       err = gpg_error (GPG_ERR_NO_PUBKEY);
 626       log_inc_errorcount ();
 627       break;
 628
 629     case GPG_ERR_UNKNOWN_HOST:
 630       if (opt.verbose)
 631         log_info ("error looking up '%s' via WKD: %s\n",
 632                   addrspec, gpg_strerror (err));
 633       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
 634       break;
 635
 636     default:
 637       log_error ("error looking up '%s' via WKD: %s\n",
 638                  addrspec, gpg_strerror (err));
 639       break;
 640     }
 641
 642   if (err)
 643     goto leave;
 644
 645   /* Look closer at the key.  */
 646   err = wks_list_key (key, &fpr, &mboxes);
 647   if (err || !fpr)
 648     {
 649       log_error ("error parsing key: %s\n",
 650                  err? gpg_strerror (err) : "no fingerprint found");
 651       err = gpg_error (GPG_ERR_NO_PUBKEY);
 652       goto leave;
 653     }
 654
 655   if (opt.verbose)
 656     log_info ("fingerprint: %s\n", fpr);
 657
 658   for (sl = mboxes; sl; sl = sl->next)
 659     {
 660       if (!strcmp (sl->d, addrspec))
 661         found = 1;
 662       if (opt.verbose)
 663         log_info ("  addr-spec: %s\n", sl->d);
 664     }
 665   if (!found)
 666     {
 667       log_error ("public key for '%s' has no user id with the mail address\n",
 668                  addrspec);
 669       err = gpg_error (GPG_ERR_CERT_REVOKED);
 670     }
 671
 672  leave:
 673   xfree (fpr);
 674   free_strlist (mboxes);
 675   es_fclose (key);
 676   xfree (addrspec);
 677   return err;
 678 }
 679
 680
 681 \f
 682 /* Locate the key by fingerprint and userid and send a publication
 683  * request.  */
 684 static gpg_error_t
 685 command_send (const char *fingerprint, char *userid)
 686 {
 687   gpg_error_t err;
 688   KEYDB_SEARCH_DESC desc;
 689   char *addrspec = NULL;
 690   estream_t key = NULL;
 691   estream_t keyenc = NULL;
 692   char *submission_to = NULL;
 693   mime_maker_t mime = NULL;
 694   struct policy_flags_s policy;
 695   int no_encrypt = 0;
 696   const char *domain;
 697
 698   memset (&policy, 0, sizeof policy);
 699
 700   if (classify_user_id (fingerprint, &desc, 1)
 701       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
 702            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
 703     {
 704       log_error (_("\"%s\" is not a fingerprint\n"), fingerprint);
 705       err = gpg_error (GPG_ERR_INV_NAME);
 706       goto leave;
 707     }
 708   addrspec = mailbox_from_userid (userid);
 709   if (!addrspec)
 710     {
 711       log_error (_("\"%s\" is not a proper mail address\n"), userid);
 712       err = gpg_error (GPG_ERR_INV_USER_ID);
 713       goto leave;
 714     }
 715   err = get_key (&key, fingerprint, addrspec);
 716   if (err)
 717     goto leave;
 718
 719   domain = strchr (addrspec, '@');
 720   log_assert (domain);
 721   domain++;
 722
 723   /* Get the submission address.  */
 724   if (fake_submission_addr)
 725     {
 726       submission_to = xstrdup (fake_submission_addr);
 727       err = 0;
 728     }
 729   else
 730     err = wkd_get_submission_address (addrspec, &submission_to);
 731   if (err)
 732     {
 733       log_error (_("error looking up submission address for domain '%s': %s\n"),
 734                  domain, gpg_strerror (err));
 735       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
 736         log_error (_("this domain probably doesn't support WKS.\n"));
 737       goto leave;
 738     }
 739   log_info ("submitting request to '%s'\n", submission_to);
 740
 741   /* Get the policy flags.  */
 742   if (!fake_submission_addr)
 743     {
 744       estream_t mbuf;
 745
 746       err = wkd_get_policy_flags (addrspec, &mbuf);
 747       if (err && gpg_err_code (err) != GPG_ERR_NO_DATA)
 748         {
 749           log_error ("error reading policy flags for '%s': %s\n",
 750                      submission_to, gpg_strerror (err));
 751           goto leave;
 752         }
 753       if (mbuf)
 754         {
 755           err = wks_parse_policy (&policy, mbuf, 1);
 756           es_fclose (mbuf);
 757           if (err)
 758             goto leave;
 759         }
 760     }
 761
 762   if (policy.auth_submit)
 763     log_info ("no confirmation required for '%s'\n", addrspec);
 764
 765   /* Hack to support old providers.  */
 766   if (policy.auth_submit && !ascii_strcasecmp (domain, "posteo.de"))
 767     {
 768       log_info ("Warning: Using draft-1 method for domain '%s'\n", domain);
 769       no_encrypt = 1;
 770     }
 771
 772   /* Encrypt the key part.  */
 773   if (!no_encrypt)
 774     {
 775       es_rewind (key);
 776       err = encrypt_response (&keyenc, key, submission_to, fingerprint);
 777       if (err)
 778         goto leave;
 779       es_fclose (key);
 780       key = NULL;
 781     }
 782
 783   /* Send the key.  */
 784   err = mime_maker_new (&mime, NULL);
 785   if (err)
 786     goto leave;
 787   err = mime_maker_add_header (mime, "From", addrspec);
 788   if (err)
 789     goto leave;
 790   err = mime_maker_add_header (mime, "To", submission_to);
 791   if (err)
 792     goto leave;
 793   err = mime_maker_add_header (mime, "Subject", "Key publishing request");
 794   if (err)
 795     goto leave;
 796
 797   /* Tell server which draft we support.  */
 798   err = mime_maker_add_header (mime, "Wks-Draft-Version",
 799                                  STR2(WKS_DRAFT_VERSION));
 800   if (err)
 801     goto leave;
 802
 803   if (no_encrypt)
 804     {
 805       void *data;
 806       size_t datalen, n;
 807
 808       err = mime_maker_add_header (mime, "Content-type",
 809                                    "application/pgp-keys");
 810       if (err)
 811         goto leave;
 812
 813       if (es_fclose_snatch (key, &data, &datalen))
 814         {
 815           err = gpg_error_from_syserror ();
 816           goto leave;
 817         }
 818       key = NULL;
 819       /* We need to skip over the first line which has a content-type
 820        * header not needed here.  */
 821       for (n=0; n < datalen ; n++)
 822         if (((const char *)data)[n] == '\n')
 823           {
 824             n++;
 825             break;
 826           }
 827
 828       err = mime_maker_add_body_data (mime, (char*)data + n, datalen - n);
 829       xfree (data);
 830       if (err)
 831         goto leave;
 832     }
 833   else
 834     {
 835       err = mime_maker_add_header (mime, "Content-Type",
 836                                    "multipart/encrypted; "
 837                                    "protocol=\"application/pgp-encrypted\"");
 838       if (err)
 839         goto leave;
 840       err = mime_maker_add_container (mime);
 841       if (err)
 842         goto leave;
 843
 844       err = mime_maker_add_header (mime, "Content-Type",
 845                                    "application/pgp-encrypted");
 846       if (err)
 847         goto leave;
 848       err = mime_maker_add_body (mime, "Version: 1\n");
 849       if (err)
 850         goto leave;
 851       err = mime_maker_add_header (mime, "Content-Type",
 852                                    "application/octet-stream");
 853       if (err)
 854         goto leave;
 855
 856       err = mime_maker_add_stream (mime, &keyenc);
 857       if (err)
 858         goto leave;
 859     }
 860
 861   err = wks_send_mime (mime);
 862
 863  leave:
 864   mime_maker_release (mime);
 865   xfree (submission_to);
 866   es_fclose (keyenc);
 867   es_fclose (key);
 868   xfree (addrspec);
 869   return err;
 870 }
 871
 872
 873 \f
 874 static void
 875 encrypt_response_status_cb (void *opaque, const char *keyword, char *args)
 876 {
 877   gpg_error_t *failure = opaque;
 878   char *fields[2];
 879
 880   if (DBG_CRYPTO)
 881     log_debug ("gpg status: %s %s\n", keyword, args);
 882
 883   if (!strcmp (keyword, "FAILURE"))
 884     {
 885       if (split_fields (args, fields, DIM (fields)) >= 2
 886           && !strcmp (fields[0], "encrypt"))
 887         *failure = strtoul (fields[1], NULL, 10);
 888     }
 889
 890 }
 891
 892
 893 /* Encrypt the INPUT stream to a new stream which is stored at success
 894  * at R_OUTPUT.  Encryption is done for ADDRSPEC and for FINGERPRINT
 895  * (so that the sent message may later be inspected by the user).  We
 896  * currently retrieve that key from the WKD, DANE, or from "local".
 897  * "local" is last to prefer the latest key version but use a local
 898  * copy in case we are working offline.  It might be useful for the
 899  * server to send the fingerprint of its encryption key - or even the
 900  * entire key back.  */
 901 static gpg_error_t
 902 encrypt_response (estream_t *r_output, estream_t input, const char *addrspec,
 903                   const char *fingerprint)
 904 {
 905   gpg_error_t err;
 906   ccparray_t ccp;
 907   const char **argv;
 908   estream_t output;
 909   gpg_error_t gpg_err = 0;
 910
 911   *r_output = NULL;
 912
 913   output = es_fopenmem (0, "w+b");
 914   if (!output)
 915     {
 916       err = gpg_error_from_syserror ();
 917       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
 918       return err;
 919     }
 920
 921   ccparray_init (&ccp, 0);
 922
 923   ccparray_put (&ccp, "--no-options");
 924   if (!opt.verbose)
 925     ccparray_put (&ccp, "--quiet");
 926   else if (opt.verbose > 1)
 927     ccparray_put (&ccp, "--verbose");
 928   ccparray_put (&ccp, "--batch");
 929   ccparray_put (&ccp, "--status-fd=2");
 930   ccparray_put (&ccp, "--always-trust");
 931   ccparray_put (&ccp, "--armor");
 932   if (fake_submission_addr)
 933     ccparray_put (&ccp, "--auto-key-locate=clear,local");
 934   else
 935     ccparray_put (&ccp, "--auto-key-locate=clear,wkd,dane,local");
 936   ccparray_put (&ccp, "--recipient");
 937   ccparray_put (&ccp, addrspec);
 938   ccparray_put (&ccp, "--recipient");
 939   ccparray_put (&ccp, fingerprint);
 940   ccparray_put (&ccp, "--encrypt");
 941   ccparray_put (&ccp, "--");
 942
 943   ccparray_put (&ccp, NULL);
 944   argv = ccparray_get (&ccp, NULL);
 945   if (!argv)
 946     {
 947       err = gpg_error_from_syserror ();
 948       goto leave;
 949     }
 950   err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
 951                                 NULL, output,
 952                                 encrypt_response_status_cb, &gpg_err);
 953   if (err)
 954     {
 955       if (gpg_err)
 956         err = gpg_err;
 957       log_error ("encryption failed: %s\n", gpg_strerror (err));
 958       goto leave;
 959     }
 960
 961   es_rewind (output);
 962   *r_output = output;
 963   output = NULL;
 964
 965  leave:
 966   es_fclose (output);
 967   xfree (argv);
 968   return err;
 969 }
 970
 971
 972 static gpg_error_t
 973 send_confirmation_response (const char *sender, const char *address,
 974                             const char *nonce, int encrypt,
 975                             const char *fingerprint)
 976 {
 977   gpg_error_t err;
 978   estream_t body = NULL;
 979   estream_t bodyenc = NULL;
 980   mime_maker_t mime = NULL;
 981
 982   body = es_fopenmem (0, "w+b");
 983   if (!body)
 984     {
 985       err = gpg_error_from_syserror ();
 986       log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
 987       return err;
 988     }
 989
 990   /* It is fine to use 8 bit encoding because that is encrypted and
 991    * only our client will see it.  */
 992   if (encrypt)
 993     {
 994       es_fputs ("Content-Type: application/vnd.gnupg.wks\n"
 995                 "Content-Transfer-Encoding: 8bit\n"
 996                 "\n",
 997                 body);
 998     }
 999
1000   es_fprintf (body, ("type: confirmation-response\n"
1001                      "sender: %s\n"
1002                      "address: %s\n"
1003                      "nonce: %s\n"),
1004               sender,
1005               address,
1006               nonce);
1007
1008   es_rewind (body);
1009   if (encrypt)
1010     {
1011       err = encrypt_response (&bodyenc, body, sender, fingerprint);
1012       if (err)
1013         goto leave;
1014       es_fclose (body);
1015       body = NULL;
1016     }
1017
1018   err = mime_maker_new (&mime, NULL);
1019   if (err)
1020     goto leave;
1021   err = mime_maker_add_header (mime, "From", address);
1022   if (err)
1023     goto leave;
1024   err = mime_maker_add_header (mime, "To", sender);
1025   if (err)
1026     goto leave;
1027   err = mime_maker_add_header (mime, "Subject", "Key publication confirmation");
1028   if (err)
1029     goto leave;
1030   err = mime_maker_add_header (mime, "Wks-Draft-Version",
1031                                STR2(WKS_DRAFT_VERSION));
1032   if (err)
1033     goto leave;
1034
1035   if (encrypt)
1036     {
1037       err = mime_maker_add_header (mime, "Content-Type",
1038                                    "multipart/encrypted; "
1039                                    "protocol=\"application/pgp-encrypted\"");
1040       if (err)
1041         goto leave;
1042       err = mime_maker_add_container (mime);
1043       if (err)
1044         goto leave;
1045
1046       err = mime_maker_add_header (mime, "Content-Type",
1047                                    "application/pgp-encrypted");
1048       if (err)
1049         goto leave;
1050       err = mime_maker_add_body (mime, "Version: 1\n");
1051       if (err)
1052         goto leave;
1053       err = mime_maker_add_header (mime, "Content-Type",
1054                                    "application/octet-stream");
1055       if (err)
1056         goto leave;
1057
1058       err = mime_maker_add_stream (mime, &bodyenc);
1059       if (err)
1060         goto leave;
1061     }
1062   else
1063     {
1064       err = mime_maker_add_header (mime, "Content-Type",
1065                                    "application/vnd.gnupg.wks");
1066       if (err)
1067         goto leave;
1068       err = mime_maker_add_stream (mime, &body);
1069       if (err)
1070         goto leave;
1071     }
1072
1073   err = wks_send_mime (mime);
1074
1075  leave:
1076   mime_maker_release (mime);
1077   es_fclose (bodyenc);
1078   es_fclose (body);
1079   return err;
1080 }
1081
1082
1083 /* Reply to a confirmation request.  The MSG has already been
1084  * decrypted and we only need to send the nonce back.  MAINFPR is
1085  * either NULL or the primary key fingerprint of the key used to
1086  * decrypt the request.  */
1087 static gpg_error_t
1088 process_confirmation_request (estream_t msg, const char *mainfpr)
1089 {
1090   gpg_error_t err;
1091   nvc_t nvc;
1092   nve_t item;
1093   const char *value, *sender, *address, *fingerprint, *nonce;
1094
1095   err = nvc_parse (&nvc, NULL, msg);
1096   if (err)
1097     {
1098       log_error ("parsing the WKS message failed: %s\n", gpg_strerror (err));
1099       goto leave;
1100     }
1101
1102   if (DBG_MIME)
1103     {
1104       log_debug ("request follows:\n");
1105       nvc_write (nvc, log_get_stream ());
1106     }
1107
1108   /* Check that this is a confirmation request.  */
1109   if (!((item = nvc_lookup (nvc, "type:")) && (value = nve_value (item))
1110         && !strcmp (value, "confirmation-request")))
1111     {
1112       if (item && value)
1113         log_error ("received unexpected wks message '%s'\n", value);
1114       else
1115         log_error ("received invalid wks message: %s\n", "'type' missing");
1116       err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
1117       goto leave;
1118     }
1119
1120   /* Get the fingerprint.  */
1121   if (!((item = nvc_lookup (nvc, "fingerprint:"))
1122         && (value = nve_value (item))
1123         && strlen (value) >= 40))
1124     {
1125       log_error ("received invalid wks message: %s\n",
1126                  "'fingerprint' missing or invalid");
1127       err = gpg_error (GPG_ERR_INV_DATA);
1128       goto leave;
1129     }
1130   fingerprint = value;
1131
1132   /* Check that the fingerprint matches the key used to decrypt the
1133    * message.  In --read mode or with the old format we don't have the
1134    * decryption key; thus we can't bail out.  */
1135   if (!mainfpr || ascii_strcasecmp (mainfpr, fingerprint))
1136     {
1137       log_info ("target fingerprint: %s\n", fingerprint);
1138       log_info ("but decrypted with: %s\n", mainfpr);
1139       log_error ("confirmation request not decrypted with target key\n");
1140       if (mainfpr)
1141         {
1142           err = gpg_error (GPG_ERR_INV_DATA);
1143           goto leave;
1144         }
1145     }
1146
1147   /* Get the address.  */
1148   if (!((item = nvc_lookup (nvc, "address:")) && (value = nve_value (item))
1149         && is_valid_mailbox (value)))
1150     {
1151       log_error ("received invalid wks message: %s\n",
1152                  "'address' missing or invalid");
1153       err = gpg_error (GPG_ERR_INV_DATA);
1154       goto leave;
1155     }
1156   address = value;
1157   /* FIXME: Check that the "address" matches the User ID we want to
1158    * publish.  */
1159
1160   /* Get the sender.  */
1161   if (!((item = nvc_lookup (nvc, "sender:")) && (value = nve_value (item))
1162         && is_valid_mailbox (value)))
1163     {
1164       log_error ("received invalid wks message: %s\n",
1165                  "'sender' missing or invalid");
1166       err = gpg_error (GPG_ERR_INV_DATA);
1167       goto leave;
1168     }
1169   sender = value;
1170   /* FIXME: Check that the "sender" matches the From: address.  */
1171
1172   /* Get the nonce.  */
1173   if (!((item = nvc_lookup (nvc, "nonce:")) && (value = nve_value (item))
1174         && strlen (value) > 16))
1175     {
1176       log_error ("received invalid wks message: %s\n",
1177                  "'nonce' missing or too short");
1178       err = gpg_error (GPG_ERR_INV_DATA);
1179       goto leave;
1180     }
1181   nonce = value;
1182
1183   /* Send the confirmation.  If no key was found, try again without
1184    * encryption.  */
1185   err = send_confirmation_response (sender, address, nonce, 1, fingerprint);
1186   if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
1187     {
1188       log_info ("no encryption key found - sending response in the clear\n");
1189       err = send_confirmation_response (sender, address, nonce, 0, NULL);
1190     }
1191
1192  leave:
1193   nvc_release (nvc);
1194   return err;
1195 }
1196
1197
1198 /* Read a confirmation request and decrypt it if needed.  This
1199  * function may not be used with a mail or MIME message but only with
1200  * the actual encrypted or plaintext WKS data.  */
1201 static gpg_error_t
1202 read_confirmation_request (estream_t msg)
1203 {
1204   gpg_error_t err;
1205   int c;
1206   estream_t plaintext = NULL;
1207
1208   /* We take a really simple approach to check whether MSG is
1209    * encrypted: We know that an encrypted message is always armored
1210    * and thus starts with a few dashes.  It is even sufficient to
1211    * check for a single dash, because that can never be a proper first
1212    * WKS data octet.  We need to skip leading spaces, though. */
1213   while ((c = es_fgetc (msg)) == ' ' || c == '\t' || c == '\r' || c == '\n')
1214     ;
1215   if (c == EOF)
1216     {
1217       log_error ("can't process an empty message\n");
1218       return gpg_error (GPG_ERR_INV_DATA);
1219     }
1220   if (es_ungetc (c, msg) != c)
1221     {
1222       log_error ("error ungetting octet from message\n");
1223       return gpg_error (GPG_ERR_INTERNAL);
1224     }
1225
1226   if (c != '-')
1227     err = process_confirmation_request (msg, NULL);
1228   else
1229     {
1230       struct decrypt_stream_parm_s decinfo;
1231
1232       err = decrypt_stream (&plaintext, &decinfo, msg);
1233       if (err)
1234         log_error ("decryption failed: %s\n", gpg_strerror (err));
1235       else if (decinfo.otrust != 'u')
1236         {
1237           err = gpg_error (GPG_ERR_WRONG_SECKEY);
1238           log_error ("key used to decrypt the confirmation request"
1239                      " was not generated by us\n");
1240         }
1241       else
1242         err = process_confirmation_request (plaintext, decinfo.mainfpr);
1243       xfree (decinfo.fpr);
1244       xfree (decinfo.mainfpr);
1245     }
1246
1247   es_fclose (plaintext);
1248   return err;
1249 }
1250
1251
1252 /* Called from the MIME receiver to process the plain text data in MSG.  */
1253 static gpg_error_t
1254 command_receive_cb (void *opaque, const char *mediatype,
1255                     estream_t msg, unsigned int flags)
1256 {
1257   gpg_error_t err;
1258
1259   (void)opaque;
1260   (void)flags;
1261
1262   if (!strcmp (mediatype, "application/vnd.gnupg.wks"))
1263     err = read_confirmation_request (msg);
1264   else
1265     {
1266       log_info ("ignoring unexpected message of type '%s'\n", mediatype);
1267       err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
1268     }
1269
1270   return err;
1271 }