609 lines
15 KiB
C
609 lines
15 KiB
C
/* genkey.c - Key generation.
|
||
* Copyright (C) 2000 Werner Koch (dd9jn)
|
||
* Copyright (C) 2001, 2002, 2003, 2004, 2016 g10 Code GmbH
|
||
*
|
||
* This file is part of GPGME.
|
||
*
|
||
* GPGME 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.
|
||
*
|
||
* GPGME 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/>.
|
||
*/
|
||
|
||
#if HAVE_CONFIG_H
|
||
#include <config.h>
|
||
#endif
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <errno.h>
|
||
|
||
#include "gpgme.h"
|
||
#include "debug.h"
|
||
#include "context.h"
|
||
#include "ops.h"
|
||
#include "util.h"
|
||
|
||
|
||
typedef struct
|
||
{
|
||
struct _gpgme_op_genkey_result result;
|
||
|
||
/* The error code from a FAILURE status line or 0. */
|
||
gpg_error_t failure_code;
|
||
|
||
/* The error code from certain ERROR status lines or 0. */
|
||
gpg_error_t error_code;
|
||
|
||
/* Flag to indicate that a UID is to be added. */
|
||
gpg_error_t uidmode;
|
||
|
||
/* The key parameters passed to the crypto engine. */
|
||
gpgme_data_t key_parameter;
|
||
} *op_data_t;
|
||
|
||
|
||
static void
|
||
release_op_data (void *hook)
|
||
{
|
||
op_data_t opd = (op_data_t) hook;
|
||
|
||
if (opd->result.fpr)
|
||
free (opd->result.fpr);
|
||
if (opd->key_parameter)
|
||
gpgme_data_release (opd->key_parameter);
|
||
}
|
||
|
||
|
||
gpgme_genkey_result_t
|
||
gpgme_op_genkey_result (gpgme_ctx_t ctx)
|
||
{
|
||
void *hook;
|
||
op_data_t opd;
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG (DEBUG_CTX, "gpgme_op_genkey_result", ctx);
|
||
|
||
err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook, -1, NULL);
|
||
opd = hook;
|
||
if (err || !opd)
|
||
{
|
||
TRACE_SUC0 ("result=(null)");
|
||
return NULL;
|
||
}
|
||
|
||
TRACE_LOG3 ("fpr = %s, %s, %s", opd->result.fpr,
|
||
opd->result.primary ? "primary" : "no primary",
|
||
opd->result.sub ? "sub" : "no sub");
|
||
|
||
TRACE_SUC1 ("result=%p", &opd->result);
|
||
return &opd->result;
|
||
}
|
||
|
||
|
||
|
||
/* Parse an error status line. Return the error location and the
|
||
error code. The function may modify ARGS. */
|
||
static char *
|
||
parse_error (char *args, gpg_error_t *r_err)
|
||
{
|
||
char *where = strchr (args, ' ');
|
||
char *which;
|
||
|
||
if (where)
|
||
{
|
||
*where = '\0';
|
||
which = where + 1;
|
||
|
||
where = strchr (which, ' ');
|
||
if (where)
|
||
*where = '\0';
|
||
|
||
where = args;
|
||
}
|
||
else
|
||
{
|
||
*r_err = trace_gpg_error (GPG_ERR_INV_ENGINE);
|
||
return NULL;
|
||
}
|
||
|
||
*r_err = atoi (which);
|
||
|
||
return where;
|
||
}
|
||
|
||
|
||
static gpgme_error_t
|
||
genkey_status_handler (void *priv, gpgme_status_code_t code, char *args)
|
||
{
|
||
gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
|
||
gpgme_error_t err;
|
||
void *hook;
|
||
op_data_t opd;
|
||
char *loc;
|
||
|
||
/* Pipe the status code through the progress status handler. */
|
||
err = _gpgme_progress_status_handler (ctx, code, args);
|
||
if (err)
|
||
return err;
|
||
|
||
err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook, -1, NULL);
|
||
opd = hook;
|
||
if (err)
|
||
return err;
|
||
|
||
switch (code)
|
||
{
|
||
case GPGME_STATUS_KEY_CREATED:
|
||
if (args && *args)
|
||
{
|
||
if (*args == 'B' || *args == 'P')
|
||
{
|
||
opd->result.primary = 1;
|
||
opd->result.uid = 1;
|
||
}
|
||
if (*args == 'B' || *args == 'S')
|
||
opd->result.sub = 1;
|
||
if (args[1] == ' ')
|
||
{
|
||
if (opd->result.fpr)
|
||
free (opd->result.fpr);
|
||
opd->result.fpr = strdup (&args[2]);
|
||
if (!opd->result.fpr)
|
||
return gpg_error_from_syserror ();
|
||
}
|
||
}
|
||
break;
|
||
|
||
case GPGME_STATUS_ERROR:
|
||
loc = parse_error (args, &err);
|
||
if (!loc)
|
||
return err;
|
||
if (!opd->error_code)
|
||
opd->error_code = err;
|
||
break;
|
||
|
||
case GPGME_STATUS_FAILURE:
|
||
opd->failure_code = _gpgme_parse_failure (args);
|
||
break;
|
||
|
||
case GPGME_STATUS_EOF:
|
||
if (opd->error_code)
|
||
return opd->error_code;
|
||
else if (!opd->uidmode && !opd->result.primary && !opd->result.sub)
|
||
return gpg_error (GPG_ERR_GENERAL);
|
||
else if (opd->failure_code)
|
||
return opd->failure_code;
|
||
else if (opd->uidmode == 1)
|
||
opd->result.uid = 1; /* We have no status line, thus this hack. */
|
||
break;
|
||
|
||
case GPGME_STATUS_INQUIRE_MAXLEN:
|
||
if (ctx->status_cb && !ctx->full_status)
|
||
{
|
||
err = ctx->status_cb (ctx->status_cb_value, "INQUIRE_MAXLEN", args);
|
||
if (err)
|
||
return err;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
static gpgme_error_t
|
||
get_key_parameter (const char *parms, gpgme_data_t *key_parameter)
|
||
{
|
||
const char *content;
|
||
const char *attrib;
|
||
const char *endtag;
|
||
|
||
/* Extract the key parameter from the XML structure. */
|
||
parms = strstr (parms, "<GnupgKeyParms ");
|
||
if (!parms)
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
|
||
content = strchr (parms, '>');
|
||
if (!content)
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
content++;
|
||
|
||
attrib = strstr (parms, "format=\"internal\"");
|
||
if (!attrib || attrib >= content)
|
||
return gpg_error (GPG_ERR_INV_VALUE);
|
||
|
||
endtag = strstr (content, "</GnupgKeyParms>");
|
||
/* FIXME: Check that there are no control statements inside. */
|
||
while (content[0] == '\n'
|
||
|| (content[0] == '\r' && content[1] == '\n'))
|
||
content++;
|
||
|
||
return gpgme_data_new_from_mem (key_parameter, content,
|
||
endtag - content, 1);
|
||
}
|
||
|
||
|
||
static gpgme_error_t
|
||
genkey_start (gpgme_ctx_t ctx, int synchronous, const char *parms,
|
||
gpgme_data_t pubkey, gpgme_data_t seckey)
|
||
{
|
||
gpgme_error_t err;
|
||
void *hook;
|
||
op_data_t opd;
|
||
err = _gpgme_op_reset (ctx, synchronous);
|
||
if (err)
|
||
return err;
|
||
|
||
err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook,
|
||
sizeof (*opd), release_op_data);
|
||
opd = hook;
|
||
if (err)
|
||
return err;
|
||
|
||
err = get_key_parameter (parms, &opd->key_parameter);
|
||
if (err)
|
||
return err;
|
||
|
||
_gpgme_engine_set_status_handler (ctx->engine, genkey_status_handler, ctx);
|
||
|
||
if (ctx->passphrase_cb)
|
||
{
|
||
err = _gpgme_engine_set_command_handler
|
||
(ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);
|
||
if (err)
|
||
return err;
|
||
}
|
||
|
||
return _gpgme_engine_op_genkey (ctx->engine,
|
||
NULL, NULL, 0, 0, NULL, 0,
|
||
opd->key_parameter,
|
||
ctx->use_armor? GENKEY_EXTRAFLAG_ARMOR:0,
|
||
pubkey, seckey);
|
||
}
|
||
|
||
|
||
/* Generate a new keypair and add it to the keyring. PUBKEY and
|
||
SECKEY should be null for now. PARMS specifies what keys should be
|
||
generated. */
|
||
gpgme_error_t
|
||
gpgme_op_genkey_start (gpgme_ctx_t ctx, const char *parms,
|
||
gpgme_data_t pubkey, gpgme_data_t seckey)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG2 (DEBUG_CTX, "gpgme_op_genkey_start", ctx,
|
||
"pubkey=%p, seckey=%p", pubkey, seckey);
|
||
TRACE_LOGBUF (parms, strlen (parms));
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = genkey_start (ctx, 0, parms, pubkey, seckey);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
/* Generate a new keypair and add it to the keyring. PUBKEY and
|
||
SECKEY should be null for now. PARMS specifies what keys should be
|
||
generated. */
|
||
gpgme_error_t
|
||
gpgme_op_genkey (gpgme_ctx_t ctx, const char *parms, gpgme_data_t pubkey,
|
||
gpgme_data_t seckey)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG2 (DEBUG_CTX, "gpgme_op_genkey", ctx,
|
||
"pubkey=%p, seckey=%p", pubkey, seckey);
|
||
TRACE_LOGBUF (parms, strlen (parms));
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = genkey_start (ctx, 1, parms, pubkey, seckey);
|
||
if (!err)
|
||
err = _gpgme_wait_one (ctx);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
|
||
static gpgme_error_t
|
||
createkey_start (gpgme_ctx_t ctx, int synchronous,
|
||
const char *userid, const char *algo,
|
||
unsigned long reserved, unsigned long expires,
|
||
gpgme_key_t anchorkey, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
void *hook;
|
||
op_data_t opd;
|
||
|
||
err = _gpgme_op_reset (ctx, synchronous);
|
||
if (err)
|
||
return err;
|
||
|
||
if (reserved || anchorkey || !userid)
|
||
return gpg_error (GPG_ERR_INV_ARG);
|
||
|
||
err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook,
|
||
sizeof (*opd), release_op_data);
|
||
opd = hook;
|
||
if (err)
|
||
return err;
|
||
|
||
_gpgme_engine_set_status_handler (ctx->engine, genkey_status_handler, ctx);
|
||
|
||
if (ctx->passphrase_cb)
|
||
{
|
||
err = _gpgme_engine_set_command_handler
|
||
(ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);
|
||
if (err)
|
||
return err;
|
||
}
|
||
|
||
return _gpgme_engine_op_genkey (ctx->engine,
|
||
userid, algo, reserved, expires,
|
||
anchorkey, flags,
|
||
NULL,
|
||
ctx->use_armor? GENKEY_EXTRAFLAG_ARMOR:0,
|
||
NULL, NULL);
|
||
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
gpgme_op_createkey_start (gpgme_ctx_t ctx, const char *userid, const char *algo,
|
||
unsigned long reserved, unsigned long expires,
|
||
gpgme_key_t anchorkey, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG3 (DEBUG_CTX, "gpgme_op_createkey_start", ctx,
|
||
"userid='%s', algo='%s' flags=0x%x", userid, algo, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = createkey_start (ctx, 0,
|
||
userid, algo, reserved, expires, anchorkey, flags);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
gpgme_op_createkey (gpgme_ctx_t ctx, const char *userid, const char *algo,
|
||
unsigned long reserved, unsigned long expires,
|
||
gpgme_key_t anchorkey, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG3 (DEBUG_CTX, "gpgme_op_createkey", ctx,
|
||
"userid='%s', algo='%s' flags=0x%x", userid, algo, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = createkey_start (ctx, 1,
|
||
userid, algo, reserved, expires, anchorkey, flags);
|
||
if (!err)
|
||
err = _gpgme_wait_one (ctx);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
|
||
static gpgme_error_t
|
||
createsubkey_start (gpgme_ctx_t ctx, int synchronous,
|
||
gpgme_key_t key,
|
||
const char *algo,
|
||
unsigned long reserved, unsigned long expires,
|
||
unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
void *hook;
|
||
op_data_t opd;
|
||
|
||
if (ctx->protocol != GPGME_PROTOCOL_OPENPGP)
|
||
return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
|
||
|
||
err = _gpgme_op_reset (ctx, synchronous);
|
||
if (err)
|
||
return err;
|
||
|
||
if (reserved || !key)
|
||
return gpg_error (GPG_ERR_INV_ARG);
|
||
|
||
err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook,
|
||
sizeof (*opd), release_op_data);
|
||
opd = hook;
|
||
if (err)
|
||
return err;
|
||
|
||
_gpgme_engine_set_status_handler (ctx->engine, genkey_status_handler, ctx);
|
||
|
||
if (ctx->passphrase_cb)
|
||
{
|
||
err = _gpgme_engine_set_command_handler
|
||
(ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);
|
||
if (err)
|
||
return err;
|
||
}
|
||
|
||
return _gpgme_engine_op_genkey (ctx->engine,
|
||
NULL, algo, reserved, expires,
|
||
key, flags,
|
||
NULL,
|
||
ctx->use_armor? GENKEY_EXTRAFLAG_ARMOR:0,
|
||
NULL, NULL);
|
||
|
||
}
|
||
|
||
|
||
/* Add a subkey to an existing KEY. */
|
||
gpgme_error_t
|
||
gpgme_op_createsubkey_start (gpgme_ctx_t ctx, gpgme_key_t key, const char *algo,
|
||
unsigned long reserved, unsigned long expires,
|
||
unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG3 (DEBUG_CTX, "gpgme_op_createsubkey_start", ctx,
|
||
"key=%p, algo='%s' flags=0x%x", key, algo, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = createsubkey_start (ctx, 0, key, algo, reserved, expires, flags);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
gpgme_op_createsubkey (gpgme_ctx_t ctx, gpgme_key_t key, const char *algo,
|
||
unsigned long reserved, unsigned long expires,
|
||
unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG3 (DEBUG_CTX, "gpgme_op_createsubkey", ctx,
|
||
"key=%p, algo='%s' flags=0x%x", key, algo, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = createsubkey_start (ctx, 1, key, algo, reserved, expires, flags);
|
||
if (!err)
|
||
err = _gpgme_wait_one (ctx);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
|
||
static gpgme_error_t
|
||
addrevuid_start (gpgme_ctx_t ctx, int synchronous, int revoke,
|
||
gpgme_key_t key, const char *userid, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
void *hook;
|
||
op_data_t opd;
|
||
|
||
if (ctx->protocol != GPGME_PROTOCOL_OPENPGP)
|
||
return gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
|
||
|
||
if (!key || !userid)
|
||
return gpg_error (GPG_ERR_INV_ARG);
|
||
|
||
err = _gpgme_op_reset (ctx, synchronous);
|
||
if (err)
|
||
return err;
|
||
|
||
err = _gpgme_op_data_lookup (ctx, OPDATA_GENKEY, &hook,
|
||
sizeof (*opd), release_op_data);
|
||
opd = hook;
|
||
if (err)
|
||
return err;
|
||
|
||
opd->uidmode = revoke? 2 : 1;
|
||
|
||
_gpgme_engine_set_status_handler (ctx->engine, genkey_status_handler, ctx);
|
||
|
||
if (ctx->passphrase_cb)
|
||
{
|
||
err = _gpgme_engine_set_command_handler
|
||
(ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);
|
||
if (err)
|
||
return err;
|
||
}
|
||
|
||
return _gpgme_engine_op_genkey (ctx->engine,
|
||
userid, NULL, 0, 0,
|
||
key, flags,
|
||
NULL,
|
||
revoke? GENKEY_EXTRAFLAG_REVOKE : 0,
|
||
NULL, NULL);
|
||
|
||
}
|
||
|
||
|
||
/* Add USERID to an existing KEY. */
|
||
gpgme_error_t
|
||
gpgme_op_adduid_start (gpgme_ctx_t ctx,
|
||
gpgme_key_t key, const char *userid, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG2 (DEBUG_CTX, "gpgme_op_adduid_start", ctx,
|
||
"uid='%s' flags=0x%x", userid, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = addrevuid_start (ctx, 0, 0, key, userid, flags);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
gpgme_op_adduid (gpgme_ctx_t ctx,
|
||
gpgme_key_t key, const char *userid, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG2 (DEBUG_CTX, "gpgme_op_adduid", ctx,
|
||
"uid='%s' flags=0x%x", userid, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = addrevuid_start (ctx, 1, 0, key, userid, flags);
|
||
if (!err)
|
||
err = _gpgme_wait_one (ctx);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
/* Revoke USERID from KEY. */
|
||
gpgme_error_t
|
||
gpgme_op_revuid_start (gpgme_ctx_t ctx,
|
||
gpgme_key_t key, const char *userid, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG2 (DEBUG_CTX, "gpgme_op_revuid_start", ctx,
|
||
"uid='%s' flags=0x%x", userid, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = addrevuid_start (ctx, 0, 1, key, userid, flags);
|
||
return TRACE_ERR (err);
|
||
}
|
||
|
||
|
||
gpgme_error_t
|
||
gpgme_op_revuid (gpgme_ctx_t ctx,
|
||
gpgme_key_t key, const char *userid, unsigned int flags)
|
||
{
|
||
gpgme_error_t err;
|
||
|
||
TRACE_BEG2 (DEBUG_CTX, "gpgme_op_revuid", ctx,
|
||
"uid='%s' flags=0x%x", userid, flags);
|
||
|
||
if (!ctx)
|
||
return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG));
|
||
|
||
err = addrevuid_start (ctx, 1, 1, key, userid, flags);
|
||
if (!err)
|
||
err = _gpgme_wait_one (ctx);
|
||
return TRACE_ERR (err);
|
||
}
|