mirror of
git://git.gnupg.org/gnupg.git
synced 2024-09-07 12:56:21 +02:00
![Werner Koch](/assets/img/avatar_default.png)
* tools/gpg-wks-client.c (read_confirmation_request): Print trust letter. -- The trust letter gives a hint on what's wrong with the key. Signed-off-by: Werner Koch <wk@gnupg.org>
1597 lines
44 KiB
C
1597 lines
44 KiB
C
/* gpg-wks-client.c - A client for the Web Key Service protocols.
|
||
* Copyright (C) 2016 Werner Koch
|
||
* Copyright (C) 2016 Bundesamt für Sicherheit in der Informationstechnik
|
||
*
|
||
* This file is part of GnuPG.
|
||
*
|
||
* This file is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU Lesser General Public License as
|
||
* published by the Free Software Foundation; either version 2.1 of
|
||
* the License, or (at your option) any later version.
|
||
*
|
||
* This file is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public License
|
||
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
||
* SPDX-License-Identifier: LGPL-2.1-or-later
|
||
*/
|
||
|
||
#include <config.h>
|
||
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
|
||
#define INCLUDED_BY_MAIN_MODULE 1
|
||
#include "../common/util.h"
|
||
#include "../common/status.h"
|
||
#include "../common/i18n.h"
|
||
#include "../common/sysutils.h"
|
||
#include "../common/init.h"
|
||
#include "../common/asshelp.h"
|
||
#include "../common/userids.h"
|
||
#include "../common/ccparray.h"
|
||
#include "../common/exectool.h"
|
||
#include "../common/mbox-util.h"
|
||
#include "../common/name-value.h"
|
||
#include "call-dirmngr.h"
|
||
#include "mime-maker.h"
|
||
#include "send-mail.h"
|
||
#include "gpg-wks.h"
|
||
|
||
|
||
/* Constants to identify the commands and options. */
|
||
enum cmd_and_opt_values
|
||
{
|
||
aNull = 0,
|
||
|
||
oQuiet = 'q',
|
||
oVerbose = 'v',
|
||
oOutput = 'o',
|
||
oDirectory = 'C',
|
||
|
||
oDebug = 500,
|
||
|
||
aSupported,
|
||
aCheck,
|
||
aCreate,
|
||
aReceive,
|
||
aRead,
|
||
aInstallKey,
|
||
aRemoveKey,
|
||
aPrintWKDHash,
|
||
aPrintWKDURL,
|
||
|
||
oGpgProgram,
|
||
oSend,
|
||
oFakeSubmissionAddr,
|
||
oStatusFD,
|
||
oWithColons,
|
||
|
||
oDummy
|
||
};
|
||
|
||
|
||
/* The list of commands and options. */
|
||
static gpgrt_opt_t opts[] = {
|
||
ARGPARSE_group (300, ("@Commands:\n ")),
|
||
|
||
ARGPARSE_c (aSupported, "supported",
|
||
("check whether provider supports WKS")),
|
||
ARGPARSE_c (aCheck, "check",
|
||
("check whether a key is available")),
|
||
ARGPARSE_c (aCreate, "create",
|
||
("create a publication request")),
|
||
ARGPARSE_c (aReceive, "receive",
|
||
("receive a MIME confirmation request")),
|
||
ARGPARSE_c (aRead, "read",
|
||
("receive a plain text confirmation request")),
|
||
ARGPARSE_c (aInstallKey, "install-key",
|
||
"install a key into a directory"),
|
||
ARGPARSE_c (aRemoveKey, "remove-key",
|
||
"remove a key from a directory"),
|
||
ARGPARSE_c (aPrintWKDHash, "print-wkd-hash",
|
||
"Print the WKD identifier for the given user ids"),
|
||
ARGPARSE_c (aPrintWKDURL, "print-wkd-url",
|
||
"Print the WKD URL for the given user id"),
|
||
|
||
ARGPARSE_group (301, ("@\nOptions:\n ")),
|
||
|
||
ARGPARSE_s_n (oVerbose, "verbose", ("verbose")),
|
||
ARGPARSE_s_n (oQuiet, "quiet", ("be somewhat more quiet")),
|
||
ARGPARSE_s_s (oDebug, "debug", "@"),
|
||
ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
|
||
ARGPARSE_s_n (oSend, "send", "send the mail using sendmail"),
|
||
ARGPARSE_s_s (oOutput, "output", "|FILE|write the mail to FILE"),
|
||
ARGPARSE_s_i (oStatusFD, "status-fd", N_("|FD|write status info to this FD")),
|
||
ARGPARSE_s_n (oWithColons, "with-colons", "@"),
|
||
ARGPARSE_s_s (oDirectory, "directory", "@"),
|
||
|
||
ARGPARSE_s_s (oFakeSubmissionAddr, "fake-submission-addr", "@"),
|
||
|
||
ARGPARSE_end ()
|
||
};
|
||
|
||
|
||
/* The list of supported debug flags. */
|
||
static struct debug_flags_s debug_flags [] =
|
||
{
|
||
{ DBG_MIME_VALUE , "mime" },
|
||
{ DBG_PARSER_VALUE , "parser" },
|
||
{ DBG_CRYPTO_VALUE , "crypto" },
|
||
{ DBG_MEMORY_VALUE , "memory" },
|
||
{ DBG_MEMSTAT_VALUE, "memstat" },
|
||
{ DBG_IPC_VALUE , "ipc" },
|
||
{ DBG_EXTPROG_VALUE, "extprog" },
|
||
{ 0, NULL }
|
||
};
|
||
|
||
|
||
|
||
/* Value of the option --fake-submission-addr. */
|
||
const char *fake_submission_addr;
|
||
|
||
|
||
static void wrong_args (const char *text) GPGRT_ATTR_NORETURN;
|
||
static gpg_error_t proc_userid_from_stdin (gpg_error_t (*func)(const char *),
|
||
const char *text);
|
||
static gpg_error_t command_supported (char *userid);
|
||
static gpg_error_t command_check (char *userid);
|
||
static gpg_error_t command_send (const char *fingerprint, const char *userid);
|
||
static gpg_error_t encrypt_response (estream_t *r_output, estream_t input,
|
||
const char *addrspec,
|
||
const char *fingerprint);
|
||
static gpg_error_t read_confirmation_request (estream_t msg);
|
||
static gpg_error_t command_receive_cb (void *opaque,
|
||
const char *mediatype, estream_t fp,
|
||
unsigned int flags);
|
||
|
||
|
||
|
||
/* Print usage information and provide strings for help. */
|
||
static const char *
|
||
my_strusage( int level )
|
||
{
|
||
const char *p;
|
||
|
||
switch (level)
|
||
{
|
||
case 9: p = "LGPL-2.1-or-later"; break;
|
||
case 11: p = "gpg-wks-client"; break;
|
||
case 12: p = "@GNUPG@"; break;
|
||
case 13: p = VERSION; break;
|
||
case 14: p = GNUPG_DEF_COPYRIGHT_LINE; break;
|
||
case 17: p = PRINTABLE_OS_NAME; break;
|
||
case 19: p = ("Please report bugs to <@EMAIL@>.\n"); break;
|
||
|
||
case 1:
|
||
case 40:
|
||
p = ("Usage: gpg-wks-client [command] [options] [args] (-h for help)");
|
||
break;
|
||
case 41:
|
||
p = ("Syntax: gpg-wks-client [command] [options] [args]\n"
|
||
"Client for the Web Key Service\n");
|
||
break;
|
||
|
||
default: p = NULL; break;
|
||
}
|
||
return p;
|
||
}
|
||
|
||
|
||
static void
|
||
wrong_args (const char *text)
|
||
{
|
||
es_fprintf (es_stderr, _("usage: %s [options] %s\n"),
|
||
gpgrt_strusage (11), text);
|
||
exit (2);
|
||
}
|
||
|
||
|
||
|
||
/* Command line parsing. */
|
||
static enum cmd_and_opt_values
|
||
parse_arguments (gpgrt_argparse_t *pargs, gpgrt_opt_t *popts)
|
||
{
|
||
enum cmd_and_opt_values cmd = 0;
|
||
int no_more_options = 0;
|
||
|
||
while (!no_more_options && gpgrt_argparse (NULL, pargs, popts))
|
||
{
|
||
switch (pargs->r_opt)
|
||
{
|
||
case oQuiet: opt.quiet = 1; break;
|
||
case oVerbose: opt.verbose++; break;
|
||
case oDebug:
|
||
if (parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags))
|
||
{
|
||
pargs->r_opt = ARGPARSE_INVALID_ARG;
|
||
pargs->err = ARGPARSE_PRINT_ERROR;
|
||
}
|
||
break;
|
||
|
||
case oGpgProgram:
|
||
opt.gpg_program = pargs->r.ret_str;
|
||
break;
|
||
case oDirectory:
|
||
opt.directory = pargs->r.ret_str;
|
||
break;
|
||
case oSend:
|
||
opt.use_sendmail = 1;
|
||
break;
|
||
case oOutput:
|
||
opt.output = pargs->r.ret_str;
|
||
break;
|
||
case oFakeSubmissionAddr:
|
||
fake_submission_addr = pargs->r.ret_str;
|
||
break;
|
||
case oStatusFD:
|
||
wks_set_status_fd (translate_sys2libc_fd_int (pargs->r.ret_int, 1));
|
||
break;
|
||
case oWithColons:
|
||
opt.with_colons = 1;
|
||
break;
|
||
|
||
case aSupported:
|
||
case aCreate:
|
||
case aReceive:
|
||
case aRead:
|
||
case aCheck:
|
||
case aInstallKey:
|
||
case aRemoveKey:
|
||
case aPrintWKDHash:
|
||
case aPrintWKDURL:
|
||
cmd = pargs->r_opt;
|
||
break;
|
||
|
||
default: pargs->err = ARGPARSE_PRINT_ERROR; break;
|
||
}
|
||
}
|
||
|
||
return cmd;
|
||
}
|
||
|
||
|
||
|
||
/* gpg-wks-client main. */
|
||
int
|
||
main (int argc, char **argv)
|
||
{
|
||
gpg_error_t err, delayed_err;
|
||
gpgrt_argparse_t pargs;
|
||
enum cmd_and_opt_values cmd;
|
||
|
||
gnupg_reopen_std ("gpg-wks-client");
|
||
gpgrt_set_strusage (my_strusage);
|
||
log_set_prefix ("gpg-wks-client", GPGRT_LOG_WITH_PREFIX);
|
||
|
||
/* Make sure that our subsystems are ready. */
|
||
i18n_init();
|
||
init_common_subsystems (&argc, &argv);
|
||
|
||
assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
|
||
setup_libassuan_logging (&opt.debug, NULL);
|
||
|
||
/* Parse the command line. */
|
||
pargs.argc = &argc;
|
||
pargs.argv = &argv;
|
||
pargs.flags = ARGPARSE_FLAG_KEEP;
|
||
cmd = parse_arguments (&pargs, opts);
|
||
gpgrt_argparse (NULL, &pargs, NULL);
|
||
|
||
if (log_get_errorcount (0))
|
||
exit (2);
|
||
|
||
/* Print a warning if an argument looks like an option. */
|
||
if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
|
||
{
|
||
int i;
|
||
|
||
for (i=0; i < argc; i++)
|
||
if (argv[i][0] == '-' && argv[i][1] == '-')
|
||
log_info (("NOTE: '%s' is not considered an option\n"), argv[i]);
|
||
}
|
||
|
||
/* Set defaults for non given options. */
|
||
if (!opt.gpg_program)
|
||
opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
|
||
|
||
if (!opt.directory)
|
||
opt.directory = "openpgpkey";
|
||
|
||
/* Tell call-dirmngr what options we want. */
|
||
set_dirmngr_options (opt.verbose, (opt.debug & DBG_IPC_VALUE), 1);
|
||
|
||
|
||
/* Check that the top directory exists. */
|
||
if (cmd == aInstallKey || cmd == aRemoveKey)
|
||
{
|
||
struct stat sb;
|
||
|
||
if (gnupg_stat (opt.directory, &sb))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
log_error ("error accessing directory '%s': %s\n",
|
||
opt.directory, gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
if (!S_ISDIR(sb.st_mode))
|
||
{
|
||
log_error ("error accessing directory '%s': %s\n",
|
||
opt.directory, "not a directory");
|
||
err = gpg_error (GPG_ERR_ENOENT);
|
||
goto leave;
|
||
}
|
||
}
|
||
|
||
/* Run the selected command. */
|
||
switch (cmd)
|
||
{
|
||
case aSupported:
|
||
if (opt.with_colons)
|
||
{
|
||
for (; argc; argc--, argv++)
|
||
command_supported (*argv);
|
||
err = 0;
|
||
}
|
||
else
|
||
{
|
||
if (argc != 1)
|
||
wrong_args ("--supported DOMAIN");
|
||
err = command_supported (argv[0]);
|
||
if (err && gpg_err_code (err) != GPG_ERR_FALSE)
|
||
log_error ("checking support failed: %s\n", gpg_strerror (err));
|
||
}
|
||
break;
|
||
|
||
case aCreate:
|
||
if (argc != 2)
|
||
wrong_args ("--create FINGERPRINT USER-ID");
|
||
err = command_send (argv[0], argv[1]);
|
||
if (err)
|
||
log_error ("creating request failed: %s\n", gpg_strerror (err));
|
||
break;
|
||
|
||
case aReceive:
|
||
if (argc)
|
||
wrong_args ("--receive < MIME-DATA");
|
||
err = wks_receive (es_stdin, command_receive_cb, NULL);
|
||
if (err)
|
||
log_error ("processing mail failed: %s\n", gpg_strerror (err));
|
||
break;
|
||
|
||
case aRead:
|
||
if (argc)
|
||
wrong_args ("--read < WKS-DATA");
|
||
err = read_confirmation_request (es_stdin);
|
||
if (err)
|
||
log_error ("processing mail failed: %s\n", gpg_strerror (err));
|
||
break;
|
||
|
||
case aCheck:
|
||
if (argc != 1)
|
||
wrong_args ("--check USER-ID");
|
||
err = command_check (argv[0]);
|
||
break;
|
||
|
||
case aInstallKey:
|
||
if (!argc)
|
||
err = wks_cmd_install_key (NULL, NULL);
|
||
else if (argc == 2)
|
||
err = wks_cmd_install_key (*argv, argv[1]);
|
||
else
|
||
wrong_args ("--install-key [FILE|FINGERPRINT USER-ID]");
|
||
break;
|
||
|
||
case aRemoveKey:
|
||
if (argc != 1)
|
||
wrong_args ("--remove-key USER-ID");
|
||
err = wks_cmd_remove_key (*argv);
|
||
break;
|
||
|
||
case aPrintWKDHash:
|
||
case aPrintWKDURL:
|
||
if (!argc)
|
||
{
|
||
if (cmd == aPrintWKDHash)
|
||
err = proc_userid_from_stdin (wks_cmd_print_wkd_hash,
|
||
"printing WKD hash");
|
||
else
|
||
err = proc_userid_from_stdin (wks_cmd_print_wkd_url,
|
||
"printing WKD URL");
|
||
}
|
||
else
|
||
{
|
||
for (err = delayed_err = 0; !err && argc; argc--, argv++)
|
||
{
|
||
if (cmd == aPrintWKDHash)
|
||
err = wks_cmd_print_wkd_hash (*argv);
|
||
else
|
||
err = wks_cmd_print_wkd_url (*argv);
|
||
if (gpg_err_code (err) == GPG_ERR_INV_USER_ID)
|
||
{
|
||
/* Diagnostic already printed. */
|
||
delayed_err = err;
|
||
err = 0;
|
||
}
|
||
else if (err)
|
||
log_error ("printing hash failed: %s\n", gpg_strerror (err));
|
||
}
|
||
if (!err)
|
||
err = delayed_err;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
gpgrt_usage (1);
|
||
err = 0;
|
||
break;
|
||
}
|
||
|
||
leave:
|
||
if (err)
|
||
wks_write_status (STATUS_FAILURE, "- %u", err);
|
||
else if (log_get_errorcount (0))
|
||
wks_write_status (STATUS_FAILURE, "- %u", GPG_ERR_GENERAL);
|
||
else
|
||
wks_write_status (STATUS_SUCCESS, NULL);
|
||
return (err || log_get_errorcount (0))? 1:0;
|
||
}
|
||
|
||
|
||
/* Read user ids from stdin and call FUNC for each user id. TEXT is
|
||
* used for error messages. */
|
||
static gpg_error_t
|
||
proc_userid_from_stdin (gpg_error_t (*func)(const char *), const char *text)
|
||
{
|
||
gpg_error_t err = 0;
|
||
gpg_error_t delayed_err = 0;
|
||
char line[2048];
|
||
size_t n = 0;
|
||
|
||
/* If we are on a terminal disable buffering to get direct response. */
|
||
if (gnupg_isatty (es_fileno (es_stdin))
|
||
&& gnupg_isatty (es_fileno (es_stdout)))
|
||
{
|
||
es_setvbuf (es_stdin, NULL, _IONBF, 0);
|
||
es_setvbuf (es_stdout, NULL, _IOLBF, 0);
|
||
}
|
||
|
||
while (es_fgets (line, sizeof line - 1, es_stdin))
|
||
{
|
||
n = strlen (line);
|
||
if (!n || line[n-1] != '\n')
|
||
{
|
||
err = gpg_error (*line? GPG_ERR_LINE_TOO_LONG
|
||
: GPG_ERR_INCOMPLETE_LINE);
|
||
log_error ("error reading stdin: %s\n", gpg_strerror (err));
|
||
break;
|
||
}
|
||
trim_spaces (line);
|
||
err = func (line);
|
||
if (gpg_err_code (err) == GPG_ERR_INV_USER_ID)
|
||
{
|
||
delayed_err = err;
|
||
err = 0;
|
||
}
|
||
else if (err)
|
||
log_error ("%s failed: %s\n", text, gpg_strerror (err));
|
||
}
|
||
if (es_ferror (es_stdin))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
log_error ("error reading stdin: %s\n", gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
|
||
leave:
|
||
if (!err)
|
||
err = delayed_err;
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
|
||
/* Add the user id UID to the key identified by FINGERPRINT. */
|
||
static gpg_error_t
|
||
add_user_id (const char *fingerprint, const char *uid)
|
||
{
|
||
gpg_error_t err;
|
||
ccparray_t ccp;
|
||
const char **argv = NULL;
|
||
|
||
ccparray_init (&ccp, 0);
|
||
|
||
ccparray_put (&ccp, "--no-options");
|
||
if (!opt.verbose)
|
||
ccparray_put (&ccp, "--quiet");
|
||
else if (opt.verbose > 1)
|
||
ccparray_put (&ccp, "--verbose");
|
||
ccparray_put (&ccp, "--batch");
|
||
ccparray_put (&ccp, "--always-trust");
|
||
ccparray_put (&ccp, "--quick-add-uid");
|
||
ccparray_put (&ccp, fingerprint);
|
||
ccparray_put (&ccp, uid);
|
||
|
||
ccparray_put (&ccp, NULL);
|
||
argv = ccparray_get (&ccp, NULL);
|
||
if (!argv)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
goto leave;
|
||
}
|
||
err = gnupg_exec_tool_stream (opt.gpg_program, argv, NULL,
|
||
NULL, NULL,
|
||
NULL, NULL);
|
||
if (err)
|
||
{
|
||
log_error ("adding user id failed: %s\n", gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
|
||
leave:
|
||
xfree (argv);
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
struct decrypt_stream_parm_s
|
||
{
|
||
char *fpr;
|
||
char *mainfpr;
|
||
int otrust;
|
||
};
|
||
|
||
static void
|
||
decrypt_stream_status_cb (void *opaque, const char *keyword, char *args)
|
||
{
|
||
struct decrypt_stream_parm_s *decinfo = opaque;
|
||
|
||
if (DBG_CRYPTO)
|
||
log_debug ("gpg status: %s %s\n", keyword, args);
|
||
if (!strcmp (keyword, "DECRYPTION_KEY") && !decinfo->fpr)
|
||
{
|
||
const char *fields[3];
|
||
|
||
if (split_fields (args, fields, DIM (fields)) >= 3)
|
||
{
|
||
decinfo->fpr = xstrdup (fields[0]);
|
||
decinfo->mainfpr = xstrdup (fields[1]);
|
||
decinfo->otrust = *fields[2];
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Decrypt the INPUT stream to a new stream which is stored at success
|
||
* at R_OUTPUT. */
|
||
static gpg_error_t
|
||
decrypt_stream (estream_t *r_output, struct decrypt_stream_parm_s *decinfo,
|
||
estream_t input)
|
||
{
|
||
gpg_error_t err;
|
||
ccparray_t ccp;
|
||
const char **argv;
|
||
estream_t output;
|
||
|
||
*r_output = NULL;
|
||
memset (decinfo, 0, sizeof *decinfo);
|
||
|
||
output = es_fopenmem (0, "w+b");
|
||
if (!output)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
|
||
return err;
|
||
}
|
||
|
||
ccparray_init (&ccp, 0);
|
||
|
||
ccparray_put (&ccp, "--no-options");
|
||
/* We limit the output to 64 KiB to avoid DoS using compression
|
||
* tricks. A regular client will anyway only send a minimal key;
|
||
* that is one w/o key signatures and attribute packets. */
|
||
ccparray_put (&ccp, "--max-output=0x10000");
|
||
if (!opt.verbose)
|
||
ccparray_put (&ccp, "--quiet");
|
||
else if (opt.verbose > 1)
|
||
ccparray_put (&ccp, "--verbose");
|
||
ccparray_put (&ccp, "--batch");
|
||
ccparray_put (&ccp, "--status-fd=2");
|
||
ccparray_put (&ccp, "--decrypt");
|
||
ccparray_put (&ccp, "--");
|
||
|
||
ccparray_put (&ccp, NULL);
|
||
argv = ccparray_get (&ccp, NULL);
|
||
if (!argv)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
goto leave;
|
||
}
|
||
err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
|
||
NULL, output,
|
||
decrypt_stream_status_cb, decinfo);
|
||
if (!err && (!decinfo->fpr || !decinfo->mainfpr || !decinfo->otrust))
|
||
err = gpg_error (GPG_ERR_INV_ENGINE);
|
||
if (err)
|
||
{
|
||
log_error ("decryption failed: %s\n", gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
else if (opt.verbose)
|
||
log_info ("decryption succeeded\n");
|
||
|
||
es_rewind (output);
|
||
*r_output = output;
|
||
output = NULL;
|
||
|
||
leave:
|
||
if (err)
|
||
{
|
||
xfree (decinfo->fpr);
|
||
xfree (decinfo->mainfpr);
|
||
memset (decinfo, 0, sizeof *decinfo);
|
||
}
|
||
es_fclose (output);
|
||
xfree (argv);
|
||
return err;
|
||
}
|
||
|
||
|
||
/* Return the submission address for the address or just the domain in
|
||
* ADDRSPEC. The submission address is stored as a malloced string at
|
||
* R_SUBMISSION_ADDRESS. At R_POLICY the policy flags of the domain
|
||
* are stored. The caller needs to free them with wks_free_policy.
|
||
* The function returns an error code on failure to find a submission
|
||
* address or policy file. Note: The function may store NULL at
|
||
* R_SUBMISSION_ADDRESS but return success to indicate that the web
|
||
* key directory is supported but not the web key service. As per WKD
|
||
* specs a policy file is always required and will thus be return on
|
||
* success. */
|
||
static gpg_error_t
|
||
get_policy_and_sa (const char *addrspec, int silent,
|
||
policy_flags_t *r_policy, char **r_submission_address)
|
||
{
|
||
gpg_error_t err;
|
||
estream_t mbuf = NULL;
|
||
const char *domain;
|
||
const char *s;
|
||
policy_flags_t policy = NULL;
|
||
char *submission_to = NULL;
|
||
|
||
*r_submission_address = NULL;
|
||
*r_policy = NULL;
|
||
|
||
domain = strchr (addrspec, '@');
|
||
if (domain)
|
||
domain++;
|
||
|
||
if (opt.with_colons)
|
||
{
|
||
s = domain? domain : addrspec;
|
||
es_write_sanitized (es_stdout, s, strlen (s), ":", NULL);
|
||
es_putc (':', es_stdout);
|
||
}
|
||
|
||
/* We first try to get the submission address from the policy file
|
||
* (this is the new method). If both are available we check that
|
||
* they match and print a warning if not. In the latter case we
|
||
* keep on using the one from the submission-address file. */
|
||
err = wkd_get_policy_flags (addrspec, &mbuf);
|
||
if (err && gpg_err_code (err) != GPG_ERR_NO_DATA
|
||
&& gpg_err_code (err) != GPG_ERR_NO_NAME)
|
||
{
|
||
if (!opt.with_colons)
|
||
log_error ("error reading policy flags for '%s': %s\n",
|
||
domain, gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
if (!mbuf)
|
||
{
|
||
if (!opt.with_colons)
|
||
log_error ("provider for '%s' does NOT support the Web Key Directory\n",
|
||
addrspec);
|
||
err = gpg_error (GPG_ERR_FALSE);
|
||
goto leave;
|
||
}
|
||
|
||
policy = xtrycalloc (1, sizeof *policy);
|
||
if (!policy)
|
||
err = gpg_error_from_syserror ();
|
||
else
|
||
err = wks_parse_policy (policy, mbuf, 1);
|
||
es_fclose (mbuf);
|
||
mbuf = NULL;
|
||
if (err)
|
||
goto leave;
|
||
|
||
err = wkd_get_submission_address (addrspec, &submission_to);
|
||
if (err && !policy->submission_address)
|
||
{
|
||
if (!silent && !opt.with_colons)
|
||
log_error (_("error looking up submission address for domain '%s'"
|
||
": %s\n"), domain, gpg_strerror (err));
|
||
if (!silent && gpg_err_code (err) == GPG_ERR_NO_DATA && !opt.with_colons)
|
||
log_error (_("this domain probably doesn't support WKS.\n"));
|
||
goto leave;
|
||
}
|
||
|
||
if (submission_to && policy->submission_address
|
||
&& ascii_strcasecmp (submission_to, policy->submission_address))
|
||
log_info ("Warning: different submission addresses (sa=%s, po=%s)\n",
|
||
submission_to, policy->submission_address);
|
||
|
||
if (!submission_to && policy->submission_address)
|
||
{
|
||
submission_to = xtrystrdup (policy->submission_address);
|
||
if (!submission_to)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
goto leave;
|
||
}
|
||
}
|
||
|
||
leave:
|
||
*r_submission_address = submission_to;
|
||
submission_to = NULL;
|
||
*r_policy = policy;
|
||
policy = NULL;
|
||
|
||
if (opt.with_colons)
|
||
{
|
||
if (*r_policy && !*r_submission_address)
|
||
es_fprintf (es_stdout, "1:0::");
|
||
else if (*r_policy && *r_submission_address)
|
||
es_fprintf (es_stdout, "1:1::");
|
||
else if (err && !(gpg_err_code (err) == GPG_ERR_FALSE
|
||
|| gpg_err_code (err) == GPG_ERR_NO_DATA
|
||
|| gpg_err_code (err) == GPG_ERR_UNKNOWN_HOST))
|
||
es_fprintf (es_stdout, "0:0:%d:", err);
|
||
else
|
||
es_fprintf (es_stdout, "0:0::");
|
||
if (*r_policy)
|
||
{
|
||
es_fprintf (es_stdout, "%u:%u:%u:",
|
||
(*r_policy)->protocol_version,
|
||
(*r_policy)->auth_submit,
|
||
(*r_policy)->mailbox_only);
|
||
}
|
||
es_putc ('\n', es_stdout);
|
||
}
|
||
|
||
xfree (submission_to);
|
||
wks_free_policy (policy);
|
||
xfree (policy);
|
||
es_fclose (mbuf);
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
/* Check whether the provider supports the WKS protocol. */
|
||
static gpg_error_t
|
||
command_supported (char *userid)
|
||
{
|
||
gpg_error_t err;
|
||
char *addrspec = NULL;
|
||
char *submission_to = NULL;
|
||
policy_flags_t policy = NULL;
|
||
|
||
if (!strchr (userid, '@'))
|
||
{
|
||
char *tmp = xstrconcat ("foo@", userid, NULL);
|
||
addrspec = mailbox_from_userid (tmp, 0);
|
||
xfree (tmp);
|
||
}
|
||
else
|
||
addrspec = mailbox_from_userid (userid, 0);
|
||
if (!addrspec)
|
||
{
|
||
log_error (_("\"%s\" is not a proper mail address\n"), userid);
|
||
err = gpg_error (GPG_ERR_INV_USER_ID);
|
||
goto leave;
|
||
}
|
||
|
||
/* Get the submission address. */
|
||
err = get_policy_and_sa (addrspec, 1, &policy, &submission_to);
|
||
if (err || !submission_to)
|
||
{
|
||
if (!submission_to
|
||
|| gpg_err_code (err) == GPG_ERR_FALSE
|
||
|| gpg_err_code (err) == GPG_ERR_NO_DATA
|
||
|| gpg_err_code (err) == GPG_ERR_UNKNOWN_HOST
|
||
)
|
||
{
|
||
/* FALSE is returned if we already figured out that even the
|
||
* Web Key Directory is not supported and thus printed an
|
||
* error message. */
|
||
if (opt.verbose && gpg_err_code (err) != GPG_ERR_FALSE
|
||
&& !opt.with_colons)
|
||
{
|
||
if (gpg_err_code (err) == GPG_ERR_NO_DATA)
|
||
log_info ("provider for '%s' does NOT support WKS\n",
|
||
addrspec);
|
||
else
|
||
log_info ("provider for '%s' does NOT support WKS (%s)\n",
|
||
addrspec, gpg_strerror (err));
|
||
}
|
||
err = gpg_error (GPG_ERR_FALSE);
|
||
if (!opt.with_colons)
|
||
log_inc_errorcount ();
|
||
}
|
||
goto leave;
|
||
}
|
||
|
||
if (opt.verbose && !opt.with_colons)
|
||
log_info ("provider for '%s' supports WKS\n", addrspec);
|
||
|
||
leave:
|
||
wks_free_policy (policy);
|
||
xfree (policy);
|
||
xfree (submission_to);
|
||
xfree (addrspec);
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
/* Check whether the key for USERID is available in the WKD. */
|
||
static gpg_error_t
|
||
command_check (char *userid)
|
||
{
|
||
gpg_error_t err;
|
||
char *addrspec = NULL;
|
||
estream_t key = NULL;
|
||
char *fpr = NULL;
|
||
uidinfo_list_t mboxes = NULL;
|
||
uidinfo_list_t sl;
|
||
int found = 0;
|
||
|
||
addrspec = mailbox_from_userid (userid, 0);
|
||
if (!addrspec)
|
||
{
|
||
log_error (_("\"%s\" is not a proper mail address\n"), userid);
|
||
err = gpg_error (GPG_ERR_INV_USER_ID);
|
||
goto leave;
|
||
}
|
||
|
||
/* Get the submission address. */
|
||
err = wkd_get_key (addrspec, &key);
|
||
switch (gpg_err_code (err))
|
||
{
|
||
case 0:
|
||
if (opt.verbose)
|
||
log_info ("public key for '%s' found via WKD\n", addrspec);
|
||
/* Fixme: Check that the key contains the user id. */
|
||
break;
|
||
|
||
case GPG_ERR_NO_DATA: /* No such key. */
|
||
if (opt.verbose)
|
||
log_info ("public key for '%s' NOT found via WKD\n", addrspec);
|
||
err = gpg_error (GPG_ERR_NO_PUBKEY);
|
||
log_inc_errorcount ();
|
||
break;
|
||
|
||
case GPG_ERR_UNKNOWN_HOST:
|
||
if (opt.verbose)
|
||
log_info ("error looking up '%s' via WKD: %s\n",
|
||
addrspec, gpg_strerror (err));
|
||
err = gpg_error (GPG_ERR_NOT_SUPPORTED);
|
||
break;
|
||
|
||
default:
|
||
log_error ("error looking up '%s' via WKD: %s\n",
|
||
addrspec, gpg_strerror (err));
|
||
break;
|
||
}
|
||
|
||
if (err)
|
||
goto leave;
|
||
|
||
/* Look closer at the key. */
|
||
err = wks_list_key (key, &fpr, &mboxes);
|
||
if (err)
|
||
{
|
||
log_error ("error parsing key: %s\n", gpg_strerror (err));
|
||
err = gpg_error (GPG_ERR_NO_PUBKEY);
|
||
goto leave;
|
||
}
|
||
|
||
if (opt.verbose)
|
||
log_info ("fingerprint: %s\n", fpr);
|
||
|
||
for (sl = mboxes; sl; sl = sl->next)
|
||
{
|
||
if (sl->mbox && !strcmp (sl->mbox, addrspec))
|
||
found = 1;
|
||
if (opt.verbose)
|
||
{
|
||
log_info (" user-id: %s\n", sl->uid);
|
||
log_info (" created: %s\n", asctimestamp (sl->created));
|
||
if (sl->mbox)
|
||
log_info (" addr-spec: %s\n", sl->mbox);
|
||
}
|
||
}
|
||
if (!found)
|
||
{
|
||
log_error ("public key for '%s' has no user id with the mail address\n",
|
||
addrspec);
|
||
err = gpg_error (GPG_ERR_CERT_REVOKED);
|
||
}
|
||
|
||
leave:
|
||
xfree (fpr);
|
||
free_uidinfo_list (mboxes);
|
||
es_fclose (key);
|
||
xfree (addrspec);
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
/* Locate the key by fingerprint and userid and send a publication
|
||
* request. */
|
||
static gpg_error_t
|
||
command_send (const char *fingerprint, const char *userid)
|
||
{
|
||
gpg_error_t err;
|
||
KEYDB_SEARCH_DESC desc;
|
||
char *addrspec = NULL;
|
||
estream_t key = NULL;
|
||
estream_t keyenc = NULL;
|
||
char *submission_to = NULL;
|
||
mime_maker_t mime = NULL;
|
||
policy_flags_t policy = NULL;
|
||
int no_encrypt = 0;
|
||
int posteo_hack = 0;
|
||
const char *domain;
|
||
uidinfo_list_t uidlist = NULL;
|
||
uidinfo_list_t uid, thisuid;
|
||
time_t thistime;
|
||
|
||
if (classify_user_id (fingerprint, &desc, 1)
|
||
|| desc.mode != KEYDB_SEARCH_MODE_FPR)
|
||
{
|
||
log_error (_("\"%s\" is not a fingerprint\n"), fingerprint);
|
||
err = gpg_error (GPG_ERR_INV_NAME);
|
||
goto leave;
|
||
}
|
||
|
||
addrspec = mailbox_from_userid (userid, 0);
|
||
if (!addrspec)
|
||
{
|
||
log_error (_("\"%s\" is not a proper mail address\n"), userid);
|
||
err = gpg_error (GPG_ERR_INV_USER_ID);
|
||
goto leave;
|
||
}
|
||
err = wks_get_key (&key, fingerprint, addrspec, 0);
|
||
if (err)
|
||
goto leave;
|
||
|
||
domain = strchr (addrspec, '@');
|
||
log_assert (domain);
|
||
domain++;
|
||
|
||
/* Get the submission address. */
|
||
if (fake_submission_addr)
|
||
{
|
||
policy = xcalloc (1, sizeof *policy);
|
||
submission_to = xstrdup (fake_submission_addr);
|
||
err = 0;
|
||
}
|
||
else
|
||
{
|
||
err = get_policy_and_sa (addrspec, 0, &policy, &submission_to);
|
||
if (err)
|
||
goto leave;
|
||
if (!submission_to)
|
||
{
|
||
log_error (_("this domain probably doesn't support WKS.\n"));
|
||
err = gpg_error (GPG_ERR_NO_DATA);
|
||
goto leave;
|
||
}
|
||
}
|
||
|
||
log_info ("submitting request to '%s'\n", submission_to);
|
||
|
||
if (policy->auth_submit)
|
||
log_info ("no confirmation required for '%s'\n", addrspec);
|
||
|
||
/* In case the key has several uids with the same addr-spec we will
|
||
* use the newest one. */
|
||
err = wks_list_key (key, NULL, &uidlist);
|
||
if (err)
|
||
{
|
||
log_error ("error parsing key: %s\n",gpg_strerror (err));
|
||
err = gpg_error (GPG_ERR_NO_PUBKEY);
|
||
goto leave;
|
||
}
|
||
thistime = 0;
|
||
thisuid = NULL;
|
||
for (uid = uidlist; uid; uid = uid->next)
|
||
{
|
||
if (!uid->mbox)
|
||
continue; /* Should not happen anyway. */
|
||
if (policy->mailbox_only && ascii_strcasecmp (uid->uid, uid->mbox))
|
||
continue; /* UID has more than just the mailbox. */
|
||
if (uid->created > thistime)
|
||
{
|
||
thistime = uid->created;
|
||
thisuid = uid;
|
||
}
|
||
}
|
||
if (!thisuid)
|
||
thisuid = uidlist; /* This is the case for a missing timestamp. */
|
||
if (opt.verbose)
|
||
log_info ("submitting key with user id '%s'\n", thisuid->uid);
|
||
|
||
/* If we have more than one user id we need to filter the key to
|
||
* include only THISUID. */
|
||
if (uidlist->next)
|
||
{
|
||
estream_t newkey;
|
||
|
||
es_rewind (key);
|
||
err = wks_filter_uid (&newkey, key, thisuid->uid, 0);
|
||
if (err)
|
||
{
|
||
log_error ("error filtering key: %s\n", gpg_strerror (err));
|
||
err = gpg_error (GPG_ERR_NO_PUBKEY);
|
||
goto leave;
|
||
}
|
||
es_fclose (key);
|
||
key = newkey;
|
||
}
|
||
|
||
if (policy->mailbox_only
|
||
&& (!thisuid->mbox || ascii_strcasecmp (thisuid->uid, thisuid->mbox)))
|
||
{
|
||
log_info ("Warning: policy requires 'mailbox-only'"
|
||
" - adding user id '%s'\n", addrspec);
|
||
err = add_user_id (fingerprint, addrspec);
|
||
if (err)
|
||
goto leave;
|
||
|
||
/* Need to get the key again. This time we request filtering
|
||
* for the full user id, so that we do not need check and filter
|
||
* the key again. */
|
||
es_fclose (key);
|
||
key = NULL;
|
||
err = wks_get_key (&key, fingerprint, addrspec, 1);
|
||
if (err)
|
||
goto leave;
|
||
}
|
||
|
||
/* Hack to support posteo but let them disable this by setting the
|
||
* new policy-version flag. */
|
||
if (policy->protocol_version < 3
|
||
&& !ascii_strcasecmp (domain, "posteo.de"))
|
||
{
|
||
log_info ("Warning: Using draft-1 method for domain '%s'\n", domain);
|
||
no_encrypt = 1;
|
||
posteo_hack = 1;
|
||
}
|
||
|
||
/* Encrypt the key part. */
|
||
if (!no_encrypt)
|
||
{
|
||
es_rewind (key);
|
||
err = encrypt_response (&keyenc, key, submission_to, fingerprint);
|
||
if (err)
|
||
goto leave;
|
||
es_fclose (key);
|
||
key = NULL;
|
||
}
|
||
|
||
/* Send the key. */
|
||
err = mime_maker_new (&mime, NULL);
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "From", addrspec);
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "To", submission_to);
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "Subject", "Key publishing request");
|
||
if (err)
|
||
goto leave;
|
||
|
||
/* Tell server which draft we support. */
|
||
err = mime_maker_add_header (mime, "Wks-Draft-Version",
|
||
STR2(WKS_DRAFT_VERSION));
|
||
if (err)
|
||
goto leave;
|
||
|
||
if (no_encrypt)
|
||
{
|
||
void *data;
|
||
size_t datalen, n;
|
||
|
||
if (posteo_hack)
|
||
{
|
||
/* Needs a multipart/mixed with one(!) attachment. It does
|
||
* not grok a non-multipart mail. */
|
||
err = mime_maker_add_header (mime, "Content-Type", "multipart/mixed");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_container (mime);
|
||
if (err)
|
||
goto leave;
|
||
}
|
||
|
||
err = mime_maker_add_header (mime, "Content-type",
|
||
"application/pgp-keys");
|
||
if (err)
|
||
goto leave;
|
||
|
||
if (es_fclose_snatch (key, &data, &datalen))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
goto leave;
|
||
}
|
||
key = NULL;
|
||
/* We need to skip over the first line which has a content-type
|
||
* header not needed here. */
|
||
for (n=0; n < datalen ; n++)
|
||
if (((const char *)data)[n] == '\n')
|
||
{
|
||
n++;
|
||
break;
|
||
}
|
||
|
||
err = mime_maker_add_body_data (mime, (char*)data + n, datalen - n);
|
||
xfree (data);
|
||
if (err)
|
||
goto leave;
|
||
}
|
||
else
|
||
{
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"multipart/encrypted; "
|
||
"protocol=\"application/pgp-encrypted\"");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_container (mime);
|
||
if (err)
|
||
goto leave;
|
||
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"application/pgp-encrypted");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_body (mime, "Version: 1\n");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"application/octet-stream");
|
||
if (err)
|
||
goto leave;
|
||
|
||
err = mime_maker_add_stream (mime, &keyenc);
|
||
if (err)
|
||
goto leave;
|
||
}
|
||
|
||
err = wks_send_mime (mime);
|
||
|
||
leave:
|
||
mime_maker_release (mime);
|
||
xfree (submission_to);
|
||
free_uidinfo_list (uidlist);
|
||
es_fclose (keyenc);
|
||
es_fclose (key);
|
||
wks_free_policy (policy);
|
||
xfree (policy);
|
||
xfree (addrspec);
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
static void
|
||
encrypt_response_status_cb (void *opaque, const char *keyword, char *args)
|
||
{
|
||
gpg_error_t *failure = opaque;
|
||
const char *fields[2];
|
||
|
||
if (DBG_CRYPTO)
|
||
log_debug ("gpg status: %s %s\n", keyword, args);
|
||
|
||
if (!strcmp (keyword, "FAILURE"))
|
||
{
|
||
if (split_fields (args, fields, DIM (fields)) >= 2
|
||
&& !strcmp (fields[0], "encrypt"))
|
||
*failure = strtoul (fields[1], NULL, 10);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/* Encrypt the INPUT stream to a new stream which is stored at success
|
||
* at R_OUTPUT. Encryption is done for ADDRSPEC and for FINGERPRINT
|
||
* (so that the sent message may later be inspected by the user). We
|
||
* currently retrieve that key from the WKD, DANE, or from "local".
|
||
* "local" is last to prefer the latest key version but use a local
|
||
* copy in case we are working offline. It might be useful for the
|
||
* server to send the fingerprint of its encryption key - or even the
|
||
* entire key back. */
|
||
static gpg_error_t
|
||
encrypt_response (estream_t *r_output, estream_t input, const char *addrspec,
|
||
const char *fingerprint)
|
||
{
|
||
gpg_error_t err;
|
||
ccparray_t ccp;
|
||
const char **argv;
|
||
estream_t output;
|
||
gpg_error_t gpg_err = 0;
|
||
|
||
*r_output = NULL;
|
||
|
||
output = es_fopenmem (0, "w+b");
|
||
if (!output)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
|
||
return err;
|
||
}
|
||
|
||
ccparray_init (&ccp, 0);
|
||
|
||
ccparray_put (&ccp, "--no-options");
|
||
if (!opt.verbose)
|
||
ccparray_put (&ccp, "--quiet");
|
||
else if (opt.verbose > 1)
|
||
ccparray_put (&ccp, "--verbose");
|
||
ccparray_put (&ccp, "--batch");
|
||
ccparray_put (&ccp, "--status-fd=2");
|
||
ccparray_put (&ccp, "--always-trust");
|
||
ccparray_put (&ccp, "--armor");
|
||
ccparray_put (&ccp, "-z0"); /* No compression for improved robustness. */
|
||
if (fake_submission_addr)
|
||
ccparray_put (&ccp, "--auto-key-locate=clear,local");
|
||
else
|
||
ccparray_put (&ccp, "--auto-key-locate=clear,wkd,dane,local");
|
||
ccparray_put (&ccp, "--recipient");
|
||
ccparray_put (&ccp, addrspec);
|
||
ccparray_put (&ccp, "--recipient");
|
||
ccparray_put (&ccp, fingerprint);
|
||
ccparray_put (&ccp, "--encrypt");
|
||
ccparray_put (&ccp, "--");
|
||
|
||
ccparray_put (&ccp, NULL);
|
||
argv = ccparray_get (&ccp, NULL);
|
||
if (!argv)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
goto leave;
|
||
}
|
||
err = gnupg_exec_tool_stream (opt.gpg_program, argv, input,
|
||
NULL, output,
|
||
encrypt_response_status_cb, &gpg_err);
|
||
if (err)
|
||
{
|
||
if (gpg_err)
|
||
err = gpg_err;
|
||
log_error ("encryption failed: %s\n", gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
|
||
es_rewind (output);
|
||
*r_output = output;
|
||
output = NULL;
|
||
|
||
leave:
|
||
es_fclose (output);
|
||
xfree (argv);
|
||
return err;
|
||
}
|
||
|
||
|
||
static gpg_error_t
|
||
send_confirmation_response (const char *sender, const char *address,
|
||
const char *nonce, int encrypt,
|
||
const char *fingerprint)
|
||
{
|
||
gpg_error_t err;
|
||
estream_t body = NULL;
|
||
estream_t bodyenc = NULL;
|
||
mime_maker_t mime = NULL;
|
||
|
||
body = es_fopenmem (0, "w+b");
|
||
if (!body)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
log_error ("error allocating memory buffer: %s\n", gpg_strerror (err));
|
||
return err;
|
||
}
|
||
|
||
/* It is fine to use 8 bit encoding because that is encrypted and
|
||
* only our client will see it. */
|
||
if (encrypt)
|
||
{
|
||
es_fputs ("Content-Type: application/vnd.gnupg.wks\n"
|
||
"Content-Transfer-Encoding: 8bit\n"
|
||
"\n",
|
||
body);
|
||
}
|
||
|
||
es_fprintf (body, ("type: confirmation-response\n"
|
||
"sender: %s\n"
|
||
"address: %s\n"
|
||
"nonce: %s\n"),
|
||
sender,
|
||
address,
|
||
nonce);
|
||
|
||
es_rewind (body);
|
||
if (encrypt)
|
||
{
|
||
err = encrypt_response (&bodyenc, body, sender, fingerprint);
|
||
if (err)
|
||
goto leave;
|
||
es_fclose (body);
|
||
body = NULL;
|
||
}
|
||
|
||
err = mime_maker_new (&mime, NULL);
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "From", address);
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "To", sender);
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "Subject", "Key publication confirmation");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "Wks-Draft-Version",
|
||
STR2(WKS_DRAFT_VERSION));
|
||
if (err)
|
||
goto leave;
|
||
|
||
if (encrypt)
|
||
{
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"multipart/encrypted; "
|
||
"protocol=\"application/pgp-encrypted\"");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_container (mime);
|
||
if (err)
|
||
goto leave;
|
||
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"application/pgp-encrypted");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_body (mime, "Version: 1\n");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"application/octet-stream");
|
||
if (err)
|
||
goto leave;
|
||
|
||
err = mime_maker_add_stream (mime, &bodyenc);
|
||
if (err)
|
||
goto leave;
|
||
}
|
||
else
|
||
{
|
||
err = mime_maker_add_header (mime, "Content-Type",
|
||
"application/vnd.gnupg.wks");
|
||
if (err)
|
||
goto leave;
|
||
err = mime_maker_add_stream (mime, &body);
|
||
if (err)
|
||
goto leave;
|
||
}
|
||
|
||
err = wks_send_mime (mime);
|
||
|
||
leave:
|
||
mime_maker_release (mime);
|
||
es_fclose (bodyenc);
|
||
es_fclose (body);
|
||
return err;
|
||
}
|
||
|
||
|
||
/* Reply to a confirmation request. The MSG has already been
|
||
* decrypted and we only need to send the nonce back. MAINFPR is
|
||
* either NULL or the primary key fingerprint of the key used to
|
||
* decrypt the request. */
|
||
static gpg_error_t
|
||
process_confirmation_request (estream_t msg, const char *mainfpr)
|
||
{
|
||
gpg_error_t err;
|
||
nvc_t nvc;
|
||
nve_t item;
|
||
const char *value, *sender, *address, *fingerprint, *nonce;
|
||
|
||
err = nvc_parse (&nvc, NULL, msg);
|
||
if (err)
|
||
{
|
||
log_error ("parsing the WKS message failed: %s\n", gpg_strerror (err));
|
||
goto leave;
|
||
}
|
||
|
||
if (DBG_MIME)
|
||
{
|
||
log_debug ("request follows:\n");
|
||
nvc_write (nvc, log_get_stream ());
|
||
}
|
||
|
||
/* Check that this is a confirmation request. */
|
||
if (!((item = nvc_lookup (nvc, "type:")) && (value = nve_value (item))
|
||
&& !strcmp (value, "confirmation-request")))
|
||
{
|
||
if (item && value)
|
||
log_error ("received unexpected wks message '%s'\n", value);
|
||
else
|
||
log_error ("received invalid wks message: %s\n", "'type' missing");
|
||
err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
|
||
goto leave;
|
||
}
|
||
|
||
/* Get the fingerprint. */
|
||
if (!((item = nvc_lookup (nvc, "fingerprint:"))
|
||
&& (value = nve_value (item))
|
||
&& strlen (value) >= 40))
|
||
{
|
||
log_error ("received invalid wks message: %s\n",
|
||
"'fingerprint' missing or invalid");
|
||
err = gpg_error (GPG_ERR_INV_DATA);
|
||
goto leave;
|
||
}
|
||
fingerprint = value;
|
||
|
||
/* Check that the fingerprint matches the key used to decrypt the
|
||
* message. In --read mode or with the old format we don't have the
|
||
* decryption key; thus we can't bail out. */
|
||
if (!mainfpr || ascii_strcasecmp (mainfpr, fingerprint))
|
||
{
|
||
log_info ("target fingerprint: %s\n", fingerprint);
|
||
log_info ("but decrypted with: %s\n", mainfpr);
|
||
log_error ("confirmation request not decrypted with target key\n");
|
||
if (mainfpr)
|
||
{
|
||
err = gpg_error (GPG_ERR_INV_DATA);
|
||
goto leave;
|
||
}
|
||
}
|
||
|
||
/* Get the address. */
|
||
if (!((item = nvc_lookup (nvc, "address:")) && (value = nve_value (item))
|
||
&& is_valid_mailbox (value)))
|
||
{
|
||
log_error ("received invalid wks message: %s\n",
|
||
"'address' missing or invalid");
|
||
err = gpg_error (GPG_ERR_INV_DATA);
|
||
goto leave;
|
||
}
|
||
address = value;
|
||
/* FIXME: Check that the "address" matches the User ID we want to
|
||
* publish. */
|
||
|
||
/* Get the sender. */
|
||
if (!((item = nvc_lookup (nvc, "sender:")) && (value = nve_value (item))
|
||
&& is_valid_mailbox (value)))
|
||
{
|
||
log_error ("received invalid wks message: %s\n",
|
||
"'sender' missing or invalid");
|
||
err = gpg_error (GPG_ERR_INV_DATA);
|
||
goto leave;
|
||
}
|
||
sender = value;
|
||
/* FIXME: Check that the "sender" matches the From: address. */
|
||
|
||
/* Get the nonce. */
|
||
if (!((item = nvc_lookup (nvc, "nonce:")) && (value = nve_value (item))
|
||
&& strlen (value) > 16))
|
||
{
|
||
log_error ("received invalid wks message: %s\n",
|
||
"'nonce' missing or too short");
|
||
err = gpg_error (GPG_ERR_INV_DATA);
|
||
goto leave;
|
||
}
|
||
nonce = value;
|
||
|
||
/* Send the confirmation. If no key was found, try again without
|
||
* encryption. */
|
||
err = send_confirmation_response (sender, address, nonce, 1, fingerprint);
|
||
if (gpg_err_code (err) == GPG_ERR_NO_PUBKEY)
|
||
{
|
||
log_info ("no encryption key found - sending response in the clear\n");
|
||
err = send_confirmation_response (sender, address, nonce, 0, NULL);
|
||
}
|
||
|
||
leave:
|
||
nvc_release (nvc);
|
||
return err;
|
||
}
|
||
|
||
|
||
/* Read a confirmation request and decrypt it if needed. This
|
||
* function may not be used with a mail or MIME message but only with
|
||
* the actual encrypted or plaintext WKS data. */
|
||
static gpg_error_t
|
||
read_confirmation_request (estream_t msg)
|
||
{
|
||
gpg_error_t err;
|
||
int c;
|
||
estream_t plaintext = NULL;
|
||
|
||
/* We take a really simple approach to check whether MSG is
|
||
* encrypted: We know that an encrypted message is always armored
|
||
* and thus starts with a few dashes. It is even sufficient to
|
||
* check for a single dash, because that can never be a proper first
|
||
* WKS data octet. We need to skip leading spaces, though. */
|
||
while ((c = es_fgetc (msg)) == ' ' || c == '\t' || c == '\r' || c == '\n')
|
||
;
|
||
if (c == EOF)
|
||
{
|
||
log_error ("can't process an empty message\n");
|
||
return gpg_error (GPG_ERR_INV_DATA);
|
||
}
|
||
if (es_ungetc (c, msg) != c)
|
||
{
|
||
log_error ("error ungetting octet from message\n");
|
||
return gpg_error (GPG_ERR_INTERNAL);
|
||
}
|
||
|
||
if (c != '-')
|
||
err = process_confirmation_request (msg, NULL);
|
||
else
|
||
{
|
||
struct decrypt_stream_parm_s decinfo;
|
||
|
||
err = decrypt_stream (&plaintext, &decinfo, msg);
|
||
if (err)
|
||
log_error ("decryption failed: %s\n", gpg_strerror (err));
|
||
else if (decinfo.otrust != 'u')
|
||
{
|
||
err = gpg_error (GPG_ERR_WRONG_SECKEY);
|
||
log_error ("key used to decrypt the confirmation request"
|
||
" was not generated by us (otrust=%c)\n", decinfo.otrust);
|
||
}
|
||
else
|
||
err = process_confirmation_request (plaintext, decinfo.mainfpr);
|
||
xfree (decinfo.fpr);
|
||
xfree (decinfo.mainfpr);
|
||
}
|
||
|
||
es_fclose (plaintext);
|
||
return err;
|
||
}
|
||
|
||
|
||
/* Called from the MIME receiver to process the plain text data in MSG. */
|
||
static gpg_error_t
|
||
command_receive_cb (void *opaque, const char *mediatype,
|
||
estream_t msg, unsigned int flags)
|
||
{
|
||
gpg_error_t err;
|
||
|
||
(void)opaque;
|
||
(void)flags;
|
||
|
||
if (!strcmp (mediatype, "application/vnd.gnupg.wks"))
|
||
err = read_confirmation_request (msg);
|
||
else
|
||
{
|
||
log_info ("ignoring unexpected message of type '%s'\n", mediatype);
|
||
err = gpg_error (GPG_ERR_UNEXPECTED_MSG);
|
||
}
|
||
|
||
return err;
|
||
}
|