2003-06-05 09:14:21 +02:00
|
|
|
/* sign.c - sign data
|
2007-10-25 11:06:21 +02:00
|
|
|
* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
|
2012-02-01 03:30:05 +01:00
|
|
|
* 2007, 2010, 2012 Free Software Foundation, Inc.
|
2003-06-05 09:14:21 +02:00
|
|
|
*
|
|
|
|
* This file is part of GnuPG.
|
|
|
|
*
|
|
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
2007-07-04 21:49:40 +02:00
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-06-05 09:14:21 +02:00
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* GnuPG 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 General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2016-11-05 12:02:19 +01:00
|
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
2003-06-05 09:14:21 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
#include "gpg.h"
|
2003-06-05 09:14:21 +02:00
|
|
|
#include "options.h"
|
|
|
|
#include "packet.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
#include "../common/status.h"
|
|
|
|
#include "../common/iobuf.h"
|
2003-06-05 09:14:21 +02:00
|
|
|
#include "keydb.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
#include "../common/util.h"
|
2003-06-05 09:14:21 +02:00
|
|
|
#include "main.h"
|
|
|
|
#include "filter.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
#include "../common/ttyio.h"
|
2003-06-05 09:14:21 +02:00
|
|
|
#include "trustdb.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
#include "../common/status.h"
|
|
|
|
#include "../common/i18n.h"
|
2003-06-18 21:56:13 +02:00
|
|
|
#include "pkglue.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
#include "../common/sysutils.h"
|
2003-07-03 20:08:16 +02:00
|
|
|
#include "call-agent.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
#include "../common/mbox-util.h"
|
2017-06-06 16:01:40 +02:00
|
|
|
#include "../common/compliance.h"
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
#ifdef HAVE_DOSISH_SYSTEM
|
|
|
|
#define LF "\r\n"
|
|
|
|
#else
|
|
|
|
#define LF "\n"
|
|
|
|
#endif
|
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
|
|
|
|
/* Hack */
|
2003-06-05 09:14:21 +02:00
|
|
|
static int recipient_digest_algo=0;
|
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/****************
|
2006-04-19 13:26:11 +02:00
|
|
|
* Create notations and other stuff. It is assumed that the stings in
|
|
|
|
* STRLIST are already checked to contain only printable data and have
|
|
|
|
* a valid NAME=VALUE format.
|
2003-06-05 09:14:21 +02:00
|
|
|
*/
|
|
|
|
static void
|
2010-02-02 15:06:19 +01:00
|
|
|
mk_notation_policy_etc (PKT_signature *sig,
|
|
|
|
PKT_public_key *pk, PKT_public_key *pksk)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2016-06-13 09:37:53 +02:00
|
|
|
const char *string;
|
|
|
|
char *p = NULL;
|
|
|
|
strlist_t pu = NULL;
|
|
|
|
struct notation *nd = NULL;
|
|
|
|
struct expando_args args;
|
|
|
|
|
|
|
|
log_assert (sig->version >= 4);
|
|
|
|
|
|
|
|
memset (&args, 0, sizeof(args));
|
|
|
|
args.pk = pk;
|
|
|
|
args.pksk = pksk;
|
|
|
|
|
|
|
|
/* Notation data. */
|
|
|
|
if (IS_SIG(sig) && opt.sig_notations)
|
|
|
|
nd = opt.sig_notations;
|
|
|
|
else if (IS_CERT(sig) && opt.cert_notations)
|
|
|
|
nd = opt.cert_notations;
|
|
|
|
|
|
|
|
if (nd)
|
|
|
|
{
|
|
|
|
struct notation *item;
|
|
|
|
|
|
|
|
for (item = nd; item; item = item->next)
|
|
|
|
{
|
|
|
|
item->altvalue = pct_expando (item->value,&args);
|
|
|
|
if (!item->altvalue)
|
|
|
|
log_error (_("WARNING: unable to %%-expand notation "
|
|
|
|
"(too large). Using unexpanded.\n"));
|
|
|
|
}
|
|
|
|
|
|
|
|
keygen_add_notations (sig, nd);
|
|
|
|
|
|
|
|
for (item = nd; item; item = item->next)
|
|
|
|
{
|
|
|
|
xfree (item->altvalue);
|
|
|
|
item->altvalue = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set policy URL. */
|
|
|
|
if (IS_SIG(sig) && opt.sig_policy_url)
|
|
|
|
pu = opt.sig_policy_url;
|
|
|
|
else if (IS_CERT(sig) && opt.cert_policy_url)
|
|
|
|
pu = opt.cert_policy_url;
|
|
|
|
|
|
|
|
for (; pu; pu = pu->next)
|
|
|
|
{
|
|
|
|
string = pu->d;
|
|
|
|
|
|
|
|
p = pct_expando (string, &args);
|
|
|
|
if (!p)
|
|
|
|
{
|
|
|
|
log_error(_("WARNING: unable to %%-expand policy URL "
|
|
|
|
"(too large). Using unexpanded.\n"));
|
|
|
|
p = xstrdup(string);
|
|
|
|
}
|
|
|
|
|
|
|
|
build_sig_subpkt (sig, (SIGSUBPKT_POLICY
|
|
|
|
| ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0)),
|
|
|
|
p, strlen (p));
|
|
|
|
|
|
|
|
xfree (p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Preferred keyserver URL. */
|
|
|
|
if (IS_SIG(sig) && opt.sig_keyserver_url)
|
|
|
|
pu = opt.sig_keyserver_url;
|
|
|
|
|
|
|
|
for (; pu; pu = pu->next)
|
|
|
|
{
|
|
|
|
string = pu->d;
|
|
|
|
|
|
|
|
p = pct_expando (string, &args);
|
|
|
|
if (!p)
|
|
|
|
{
|
|
|
|
log_error (_("WARNING: unable to %%-expand preferred keyserver URL"
|
|
|
|
" (too large). Using unexpanded.\n"));
|
|
|
|
p = xstrdup (string);
|
|
|
|
}
|
|
|
|
|
|
|
|
build_sig_subpkt (sig, (SIGSUBPKT_PREF_KS
|
|
|
|
| ((pu->flags & 1)?SIGSUBPKT_FLAG_CRITICAL:0)),
|
|
|
|
p, strlen (p));
|
|
|
|
xfree (p);
|
|
|
|
}
|
2016-06-13 11:24:09 +02:00
|
|
|
|
|
|
|
/* Set signer's user id. */
|
|
|
|
if (IS_SIG (sig) && !opt.flags.disable_signer_uid)
|
|
|
|
{
|
|
|
|
char *mbox;
|
|
|
|
|
|
|
|
/* For now we use the uid which was used to locate the key. */
|
|
|
|
if (pksk->user_id && (mbox = mailbox_from_userid (pksk->user_id->name)))
|
|
|
|
{
|
|
|
|
if (DBG_LOOKUP)
|
|
|
|
log_debug ("setting Signer's UID to '%s'\n", mbox);
|
|
|
|
build_sig_subpkt (sig, SIGSUBPKT_SIGNERS_UID, mbox, strlen (mbox));
|
2016-06-30 17:55:06 +02:00
|
|
|
xfree (mbox);
|
2016-06-13 11:24:09 +02:00
|
|
|
}
|
2016-08-18 10:08:34 +02:00
|
|
|
else if (opt.sender_list)
|
|
|
|
{
|
|
|
|
/* If a list of --sender was given we scan that list and use
|
|
|
|
* the first one matching a user id of the current key. */
|
|
|
|
|
|
|
|
/* FIXME: We need to get the list of user ids for the PKSK
|
|
|
|
* packet. That requires either a function to look it up
|
|
|
|
* again or we need to extend the key packet struct to link
|
|
|
|
* to the primary key which in turn could link to the user
|
|
|
|
* ids. Too much of a change right now. Let's take just
|
|
|
|
* one from the supplied list and hope that the caller
|
|
|
|
* passed a matching one. */
|
|
|
|
build_sig_subpkt (sig, SIGSUBPKT_SIGNERS_UID,
|
|
|
|
opt.sender_list->d, strlen (opt.sender_list->d));
|
|
|
|
}
|
2016-06-13 11:24:09 +02:00
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-03-13 13:28:35 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Put the Key Block subpakcet into SIG for key PKSK. Returns an
|
|
|
|
* error code on failure.
|
|
|
|
*/
|
|
|
|
static gpg_error_t
|
|
|
|
mk_sig_subpkt_key_block (ctrl_t ctrl, PKT_signature *sig, PKT_public_key *pksk)
|
|
|
|
{
|
|
|
|
gpg_error_t err;
|
|
|
|
char *mbox;
|
|
|
|
char *filterexp = NULL;
|
|
|
|
int save_opt_armor = opt.armor;
|
|
|
|
int save_opt_verbose = opt.verbose;
|
|
|
|
char hexfpr[2*MAX_FINGERPRINT_LEN + 1];
|
|
|
|
void *data = NULL;
|
|
|
|
size_t datalen;
|
|
|
|
kbnode_t keyblock = NULL;
|
|
|
|
|
|
|
|
push_export_filters ();
|
|
|
|
opt.armor = 0;
|
|
|
|
|
|
|
|
hexfingerprint (pksk, hexfpr, sizeof hexfpr);
|
|
|
|
|
|
|
|
/* Get the user id so that we know which one to insert into the
|
|
|
|
* key. */
|
|
|
|
if (pksk->user_id
|
|
|
|
&& (mbox = mailbox_from_userid (pksk->user_id->name)))
|
|
|
|
{
|
|
|
|
if (DBG_LOOKUP)
|
|
|
|
log_debug ("including key with UID '%s' (specified)\n", mbox);
|
|
|
|
filterexp = xasprintf ("keep-uid= -- mbox = %s", mbox);
|
|
|
|
xfree (mbox);
|
|
|
|
}
|
|
|
|
else if (opt.sender_list)
|
|
|
|
{
|
|
|
|
/* If --sender was given we use the first one from that list. */
|
|
|
|
if (DBG_LOOKUP)
|
|
|
|
log_debug ("including key with UID '%s' (--sender)\n",
|
|
|
|
opt.sender_list->d);
|
|
|
|
filterexp = xasprintf ("keep-uid= -- mbox = %s", opt.sender_list->d);
|
|
|
|
}
|
|
|
|
else /* Use the primary user id. */
|
|
|
|
{
|
|
|
|
if (DBG_LOOKUP)
|
|
|
|
log_debug ("including key with primary UID\n");
|
|
|
|
filterexp = xstrdup ("keep-uid= primary -t");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DBG_LOOKUP)
|
|
|
|
log_debug ("export filter expression: %s\n", filterexp);
|
|
|
|
err = parse_and_set_export_filter (filterexp);
|
|
|
|
if (err)
|
|
|
|
goto leave;
|
|
|
|
xfree (filterexp);
|
|
|
|
filterexp = xasprintf ("drop-subkey= fpr <> %s && usage !~ e", hexfpr);
|
|
|
|
if (DBG_LOOKUP)
|
|
|
|
log_debug ("export filter expression: %s\n", filterexp);
|
|
|
|
err = parse_and_set_export_filter (filterexp);
|
|
|
|
if (err)
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
|
|
opt.verbose = 0;
|
|
|
|
err = export_pubkey_buffer (ctrl, hexfpr, EXPORT_MINIMAL|EXPORT_CLEAN,
|
|
|
|
"", 1, /* Prefix with the reserved byte. */
|
|
|
|
NULL, &keyblock, &data, &datalen);
|
|
|
|
opt.verbose = save_opt_verbose;
|
|
|
|
if (err)
|
|
|
|
{
|
|
|
|
log_error ("failed to get to be included key: %s\n", gpg_strerror (err));
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
build_sig_subpkt (sig, SIGSUBPKT_KEY_BLOCK, data, datalen);
|
|
|
|
|
|
|
|
leave:
|
|
|
|
xfree (data);
|
|
|
|
release_kbnode (keyblock);
|
|
|
|
xfree (filterexp);
|
|
|
|
opt.armor = save_opt_armor;
|
|
|
|
pop_export_filters ();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/*
|
2011-02-03 17:40:43 +01:00
|
|
|
* Helper to hash a user ID packet.
|
2003-06-05 09:14:21 +02:00
|
|
|
*/
|
|
|
|
static void
|
2006-04-19 15:24:36 +02:00
|
|
|
hash_uid (gcry_md_hd_t md, int sigversion, const PKT_user_id *uid)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2014-10-12 20:07:12 +02:00
|
|
|
byte buf[5];
|
|
|
|
|
|
|
|
(void)sigversion;
|
|
|
|
|
|
|
|
if (uid->attrib_data)
|
|
|
|
{
|
|
|
|
buf[0] = 0xd1; /* Indicates an attribute packet. */
|
|
|
|
buf[1] = uid->attrib_len >> 24; /* Always use 4 length bytes. */
|
|
|
|
buf[2] = uid->attrib_len >> 16;
|
|
|
|
buf[3] = uid->attrib_len >> 8;
|
|
|
|
buf[4] = uid->attrib_len;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buf[0] = 0xb4; /* Indicates a userid packet. */
|
|
|
|
buf[1] = uid->len >> 24; /* Always use 4 length bytes. */
|
|
|
|
buf[2] = uid->len >> 16;
|
|
|
|
buf[3] = uid->len >> 8;
|
|
|
|
buf[4] = uid->len;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2014-10-12 20:07:12 +02:00
|
|
|
gcry_md_write( md, buf, 5 );
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
if (uid->attrib_data)
|
|
|
|
gcry_md_write (md, uid->attrib_data, uid->attrib_len );
|
|
|
|
else
|
|
|
|
gcry_md_write (md, uid->name, uid->len );
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper to hash some parts from the signature
|
|
|
|
*/
|
|
|
|
static void
|
2006-04-19 15:24:36 +02:00
|
|
|
hash_sigversion_to_magic (gcry_md_hd_t md, const PKT_signature *sig)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2014-10-12 20:07:12 +02:00
|
|
|
byte buf[6];
|
|
|
|
size_t n;
|
|
|
|
|
|
|
|
gcry_md_putc (md, sig->version);
|
|
|
|
gcry_md_putc (md, sig->sig_class);
|
|
|
|
gcry_md_putc (md, sig->pubkey_algo);
|
|
|
|
gcry_md_putc (md, sig->digest_algo);
|
|
|
|
if (sig->hashed)
|
|
|
|
{
|
|
|
|
n = sig->hashed->len;
|
|
|
|
gcry_md_putc (md, (n >> 8) );
|
|
|
|
gcry_md_putc (md, n );
|
|
|
|
gcry_md_write (md, sig->hashed->data, n );
|
|
|
|
n += 6;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2014-10-12 20:07:12 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
gcry_md_putc (md, 0); /* Always hash the length of the subpacket. */
|
|
|
|
gcry_md_putc (md, 0);
|
|
|
|
n = 6;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2014-10-12 20:07:12 +02:00
|
|
|
/* Add some magic. */
|
|
|
|
buf[0] = sig->version;
|
|
|
|
buf[1] = 0xff;
|
|
|
|
buf[2] = n >> 24; /* (n is only 16 bit, so this is always 0) */
|
|
|
|
buf[3] = n >> 16;
|
|
|
|
buf[4] = n >> 8;
|
|
|
|
buf[5] = n;
|
|
|
|
gcry_md_write (md, buf, 6);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
|
2010-09-01 14:49:05 +02:00
|
|
|
/* Perform the sign operation. If CACHE_NONCE is given the agent is
|
2019-11-11 11:41:00 +01:00
|
|
|
* advised to use that cached passphrase for the key. SIGNHINTS has
|
|
|
|
* hints so that we can do some additional checks. */
|
2003-06-05 09:14:21 +02:00
|
|
|
static int
|
2017-03-31 20:03:52 +02:00
|
|
|
do_sign (ctrl_t ctrl, PKT_public_key *pksk, PKT_signature *sig,
|
2019-11-11 11:41:00 +01:00
|
|
|
gcry_md_hd_t md, int mdalgo,
|
|
|
|
const char *cache_nonce, unsigned int signhints)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2010-04-20 19:57:50 +02:00
|
|
|
gpg_error_t err;
|
|
|
|
byte *dp;
|
2010-10-18 14:59:19 +02:00
|
|
|
char *hexgrip;
|
2010-04-20 19:57:50 +02:00
|
|
|
|
2024-09-26 10:37:32 +02:00
|
|
|
/* An ADSK key commonly has a creation date older than the primary
|
|
|
|
* key. For example because the ADSK is used as an archive key for
|
|
|
|
* a group of users. */
|
|
|
|
if (pksk->timestamp > sig->timestamp && !(signhints & SIGNHINT_ADSK))
|
2010-04-20 19:57:50 +02:00
|
|
|
{
|
|
|
|
ulong d = pksk->timestamp - sig->timestamp;
|
2016-01-18 11:20:15 +01:00
|
|
|
log_info (ngettext("key %s was created %lu second"
|
|
|
|
" in the future (time warp or clock problem)\n",
|
|
|
|
"key %s was created %lu seconds"
|
|
|
|
" in the future (time warp or clock problem)\n",
|
|
|
|
d), keystr_from_pk (pksk), d);
|
2010-04-20 19:57:50 +02:00
|
|
|
if (!opt.ignore_time_conflict)
|
|
|
|
return gpg_error (GPG_ERR_TIME_CONFLICT);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-04-20 19:57:50 +02:00
|
|
|
print_pubkey_algo_note (pksk->pubkey_algo);
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2010-04-20 19:57:50 +02:00
|
|
|
if (!mdalgo)
|
|
|
|
mdalgo = gcry_md_get_algo (md);
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
if ((signhints & SIGNHINT_KEYSIG) && !(signhints & SIGNHINT_SELFSIG)
|
|
|
|
&& mdalgo == GCRY_MD_SHA1
|
|
|
|
&& !opt.flags.allow_weak_key_signatures)
|
|
|
|
{
|
|
|
|
/* We do not allow the creation of third-party key signatures
|
|
|
|
* using SHA-1 because we also reject them when verifying. Note
|
|
|
|
* that this will render dsa1024 keys unsuitable for such
|
|
|
|
* keysigs and in turn the WoT. */
|
|
|
|
print_sha1_keysig_rejected_note ();
|
|
|
|
err = gpg_error (GPG_ERR_DIGEST_ALGO);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2024-01-10 17:18:34 +01:00
|
|
|
/* Check compliance but always allow for key revocations. */
|
|
|
|
if (!IS_KEY_REV (sig)
|
|
|
|
&& ! gnupg_digest_is_allowed (opt.compliance, 1, mdalgo))
|
2017-06-06 16:01:40 +02:00
|
|
|
{
|
2017-07-28 17:46:43 +02:00
|
|
|
log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
|
2017-06-06 16:01:40 +02:00
|
|
|
gcry_md_algo_name (mdalgo),
|
|
|
|
gnupg_compliance_option_string (opt.compliance));
|
|
|
|
err = gpg_error (GPG_ERR_DIGEST_ALGO);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2024-01-10 17:18:34 +01:00
|
|
|
if (!IS_KEY_REV (sig)
|
|
|
|
&& ! gnupg_pk_is_allowed (opt.compliance, PK_USE_SIGNING,
|
|
|
|
pksk->pubkey_algo, 0,
|
|
|
|
pksk->pkey, nbits_from_pk (pksk), NULL))
|
2017-06-06 16:01:40 +02:00
|
|
|
{
|
2017-07-28 17:46:43 +02:00
|
|
|
log_error (_("key %s may not be used for signing in %s mode\n"),
|
2017-06-06 16:01:40 +02:00
|
|
|
keystr_from_pk (pksk),
|
|
|
|
gnupg_compliance_option_string (opt.compliance));
|
|
|
|
err = gpg_error (GPG_ERR_PUBKEY_ALGO);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2017-07-17 15:52:26 +02:00
|
|
|
if (!gnupg_rng_is_compliant (opt.compliance))
|
|
|
|
{
|
|
|
|
err = gpg_error (GPG_ERR_FORBIDDEN);
|
|
|
|
log_error (_("%s is not compliant with %s mode\n"),
|
|
|
|
"RNG",
|
|
|
|
gnupg_compliance_option_string (opt.compliance));
|
|
|
|
write_status_error ("random-compliance", err);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2010-04-20 19:57:50 +02:00
|
|
|
print_digest_algo_note (mdalgo);
|
|
|
|
dp = gcry_md_read (md, mdalgo);
|
|
|
|
sig->digest_algo = mdalgo;
|
|
|
|
sig->digest_start[0] = dp[0];
|
|
|
|
sig->digest_start[1] = dp[1];
|
2016-12-09 13:12:30 +01:00
|
|
|
mpi_release (sig->data[0]);
|
2010-04-20 19:57:50 +02:00
|
|
|
sig->data[0] = NULL;
|
2016-12-09 13:12:30 +01:00
|
|
|
mpi_release (sig->data[1]);
|
2010-04-20 19:57:50 +02:00
|
|
|
sig->data[1] = NULL;
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-10-18 14:59:19 +02:00
|
|
|
err = hexkeygrip_from_pk (pksk, &hexgrip);
|
|
|
|
if (!err)
|
2010-04-20 19:57:50 +02:00
|
|
|
{
|
2010-10-18 14:59:19 +02:00
|
|
|
char *desc;
|
|
|
|
gcry_sexp_t s_sigval;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2017-03-31 20:03:52 +02:00
|
|
|
desc = gpg_format_keydesc (ctrl, pksk, FORMAT_KEYDESC_NORMAL, 1);
|
2011-02-03 17:40:43 +01:00
|
|
|
err = agent_pksign (NULL/*ctrl*/, cache_nonce, hexgrip, desc,
|
2013-02-07 20:37:58 +01:00
|
|
|
pksk->keyid, pksk->main_keyid, pksk->pubkey_algo,
|
2010-10-18 14:59:19 +02:00
|
|
|
dp, gcry_md_get_algo_dlen (mdalgo), mdalgo,
|
|
|
|
&s_sigval);
|
|
|
|
xfree (desc);
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-10-18 14:59:19 +02:00
|
|
|
if (err)
|
|
|
|
;
|
|
|
|
else if (pksk->pubkey_algo == GCRY_PK_RSA
|
|
|
|
|| pksk->pubkey_algo == GCRY_PK_RSA_S)
|
2013-11-15 08:59:45 +01:00
|
|
|
sig->data[0] = get_mpi_from_sexp (s_sigval, "s", GCRYMPI_FMT_USG);
|
|
|
|
else if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
|
|
|
|
{
|
|
|
|
sig->data[0] = get_mpi_from_sexp (s_sigval, "r", GCRYMPI_FMT_OPAQUE);
|
|
|
|
sig->data[1] = get_mpi_from_sexp (s_sigval, "s", GCRYMPI_FMT_OPAQUE);
|
|
|
|
}
|
2010-10-18 14:59:19 +02:00
|
|
|
else
|
|
|
|
{
|
2013-11-15 08:59:45 +01:00
|
|
|
sig->data[0] = get_mpi_from_sexp (s_sigval, "r", GCRYMPI_FMT_USG);
|
|
|
|
sig->data[1] = get_mpi_from_sexp (s_sigval, "s", GCRYMPI_FMT_USG);
|
2010-04-20 19:57:50 +02:00
|
|
|
}
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-10-18 14:59:19 +02:00
|
|
|
gcry_sexp_release (s_sigval);
|
2010-04-20 19:57:50 +02:00
|
|
|
}
|
2010-10-18 14:59:19 +02:00
|
|
|
xfree (hexgrip);
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2017-06-06 16:01:40 +02:00
|
|
|
leave:
|
2010-04-20 19:57:50 +02:00
|
|
|
if (err)
|
2020-11-13 16:05:28 +01:00
|
|
|
{
|
|
|
|
log_error (_("signing failed: %s\n"), gpg_strerror (err));
|
|
|
|
if (gpg_err_source (err) == GPG_ERR_SOURCE_SCD
|
|
|
|
&& gpg_err_code (err) == GPG_ERR_INV_ID)
|
|
|
|
print_further_info ("a reason might be a card with replaced keys");
|
|
|
|
}
|
2011-02-03 17:40:43 +01:00
|
|
|
else
|
2010-04-20 19:57:50 +02:00
|
|
|
{
|
|
|
|
if (opt.verbose)
|
|
|
|
{
|
2017-03-31 20:03:52 +02:00
|
|
|
char *ustr = get_user_id_string_native (ctrl, sig->keyid);
|
2010-04-20 19:57:50 +02:00
|
|
|
log_info (_("%s/%s signature from: \"%s\"\n"),
|
2011-02-03 17:40:43 +01:00
|
|
|
openpgp_pk_algo_name (pksk->pubkey_algo),
|
|
|
|
openpgp_md_algo_name (sig->digest_algo),
|
2010-04-20 19:57:50 +02:00
|
|
|
ustr);
|
|
|
|
xfree (ustr);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2003-06-27 22:53:09 +02:00
|
|
|
}
|
2010-04-20 19:57:50 +02:00
|
|
|
return err;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-04-26 04:39:28 +02:00
|
|
|
static int
|
2017-03-31 20:03:52 +02:00
|
|
|
complete_sig (ctrl_t ctrl,
|
|
|
|
PKT_signature *sig, PKT_public_key *pksk, gcry_md_hd_t md,
|
2019-11-11 11:41:00 +01:00
|
|
|
const char *cache_nonce, unsigned int signhints)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2010-02-02 15:06:19 +01:00
|
|
|
int rc;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2010-04-20 19:57:50 +02:00
|
|
|
/* if (!(rc = check_secret_key (pksk, 0))) */
|
2019-11-11 11:41:00 +01:00
|
|
|
rc = do_sign (ctrl, pksk, sig, md, 0, cache_nonce, signhints);
|
2010-02-02 15:06:19 +01:00
|
|
|
return rc;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
|
2010-10-20 13:33:50 +02:00
|
|
|
/* Return true if the key seems to be on a version 1 OpenPGP card.
|
|
|
|
This works by asking the agent and may fail if the card has not yet
|
|
|
|
been used with the agent. */
|
|
|
|
static int
|
|
|
|
openpgp_card_v1_p (PKT_public_key *pk)
|
|
|
|
{
|
|
|
|
gpg_error_t err;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
/* Shortcut if we are not using RSA: The v1 cards only support RSA
|
|
|
|
thus there is no point in looking any further. */
|
|
|
|
if (!is_RSA (pk->pubkey_algo))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!pk->flags.serialno_valid)
|
|
|
|
{
|
|
|
|
char *hexgrip;
|
|
|
|
|
|
|
|
err = hexkeygrip_from_pk (pk, &hexgrip);
|
|
|
|
if (err)
|
|
|
|
{
|
|
|
|
log_error ("error computing a keygrip: %s\n", gpg_strerror (err));
|
|
|
|
return 0; /* Ooops. */
|
|
|
|
}
|
|
|
|
|
|
|
|
xfree (pk->serialno);
|
2016-06-10 22:15:33 +02:00
|
|
|
agent_get_keyinfo (NULL, hexgrip, &pk->serialno, NULL);
|
2010-10-20 13:33:50 +02:00
|
|
|
xfree (hexgrip);
|
|
|
|
pk->flags.serialno_valid = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pk->serialno)
|
|
|
|
result = 0; /* Error from a past agent_get_keyinfo or no card. */
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* The version number of the card is included in the serialno. */
|
|
|
|
result = !strncmp (pk->serialno, "D2760001240101", 14);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-08-13 11:19:22 +02:00
|
|
|
/* Get a matching hash algorithm for DSA and ECDSA. */
|
2006-04-28 16:31:29 +02:00
|
|
|
static int
|
|
|
|
match_dsa_hash (unsigned int qbytes)
|
|
|
|
{
|
|
|
|
if (qbytes <= 20)
|
|
|
|
return DIGEST_ALGO_SHA1;
|
2007-12-12 11:28:30 +01:00
|
|
|
|
2008-09-29 17:02:55 +02:00
|
|
|
if (qbytes <= 28)
|
2006-04-28 16:31:29 +02:00
|
|
|
return DIGEST_ALGO_SHA224;
|
2007-12-12 11:28:30 +01:00
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
if (qbytes <= 32)
|
|
|
|
return DIGEST_ALGO_SHA256;
|
|
|
|
|
|
|
|
if (qbytes <= 48)
|
|
|
|
return DIGEST_ALGO_SHA384;
|
2007-12-12 11:28:30 +01:00
|
|
|
|
2011-01-06 02:33:17 +01:00
|
|
|
if (qbytes <= 66 ) /* 66 corresponds to 521 (64 to 512) */
|
2006-04-28 16:31:29 +02:00
|
|
|
return DIGEST_ALGO_SHA512;
|
2007-12-12 11:28:30 +01:00
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
return DEFAULT_DIGEST_ALGO;
|
|
|
|
/* DEFAULT_DIGEST_ALGO will certainly fail, but it's the best wrong
|
2007-12-12 11:28:30 +01:00
|
|
|
answer we have if a digest larger than 512 bits is requested. */
|
2006-04-28 16:31:29 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
/*
|
|
|
|
First try --digest-algo. If that isn't set, see if the recipient
|
|
|
|
has a preferred algorithm (which is also filtered through
|
2012-11-16 10:35:33 +01:00
|
|
|
--personal-digest-prefs). If we're making a signature without a
|
2006-04-19 13:26:11 +02:00
|
|
|
particular recipient (i.e. signing, rather than signing+encrypting)
|
2012-11-16 10:35:33 +01:00
|
|
|
then take the first algorithm in --personal-digest-prefs that is
|
|
|
|
usable for the pubkey algorithm. If --personal-digest-prefs isn't
|
2006-04-19 13:26:11 +02:00
|
|
|
set, then take the OpenPGP default (i.e. SHA-1).
|
|
|
|
|
2013-11-15 08:59:45 +01:00
|
|
|
Note that Ed25519+EdDSA takes an input of arbitrary length and thus
|
|
|
|
we don't enforce any particular algorithm like we do for standard
|
|
|
|
ECDSA. However, we use SHA256 as the default algorithm.
|
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
Possible improvement: Use the highest-ranked usable algorithm from
|
|
|
|
the signing key prefs either before or after using the personal
|
|
|
|
list?
|
|
|
|
*/
|
2003-06-05 09:14:21 +02:00
|
|
|
static int
|
2010-02-02 15:06:19 +01:00
|
|
|
hash_for (PKT_public_key *pk)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2010-02-02 15:06:19 +01:00
|
|
|
if (opt.def_digest_algo)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2010-02-02 15:06:19 +01:00
|
|
|
return opt.def_digest_algo;
|
|
|
|
}
|
2020-11-02 13:39:58 +01:00
|
|
|
else if (recipient_digest_algo && !is_weak_digest (recipient_digest_algo))
|
2010-02-02 15:06:19 +01:00
|
|
|
{
|
|
|
|
return recipient_digest_algo;
|
|
|
|
}
|
gpg: Use only OpenPGP public key algo ids and add the EdDSA algo id.
* common/sexputil.c (get_pk_algo_from_canon_sexp): Change to return a
string.
* g10/keygen.c (check_keygrip): Adjust for change.
* sm/certreqgen-ui.c (check_keygrip): Likewise.
* agent/pksign.c (do_encode_dsa): Remove bogus map_pk_openpgp_to_gcry.
* g10/misc.c (map_pk_openpgp_to_gcry): Remove.
(openpgp_pk_test_algo): Change to a wrapper for openpgp_pk_test_algo2.
(openpgp_pk_test_algo2): Rewrite.
(openpgp_pk_algo_usage, pubkey_nbits): Add support for EdDSA.
(openpgp_pk_algo_name): Rewrite to remove need for gcry calls.
(pubkey_get_npkey, pubkey_get_nskey): Ditto.
(pubkey_get_nsig, pubkey_get_nenc): Ditto.
* g10/keygen.c(do_create_from_keygrip): Support EdDSA.
(common_gen, gen_ecc, ask_keysize, generate_keypair): Ditto.
* g10/build-packet.c (do_key): Ditto.
* g10/export.c (transfer_format_to_openpgp): Ditto.
* g10/getkey.c (cache_public_key): Ditto.
* g10/import.c (transfer_secret_keys): Ditto.
* g10/keylist.c (list_keyblock_print, list_keyblock_colon): Ditto.
* g10/mainproc.c (proc_pubkey_enc): Ditto.
* g10/parse-packet.c (parse_key): Ditto,
* g10/sign.c (hash_for, sign_file, make_keysig_packet): Ditto.
* g10/keyserver.c (print_keyrec): Use openpgp_pk_algo_name.
* g10/pkglue.c (pk_verify, pk_encrypt, pk_check_secret_key): Use only
OpenPGP algo ids and support EdDSA.
* g10/pubkey-enc.c (get_it): Use only OpenPGP algo ids.
* g10/seskey.c (encode_md_value): Ditto.
--
This patch separates Libgcrypt and OpenPGP public key algorithms ids
and in most cases completely removes the Libgcrypt ones. This is
useful because for Libgcrypt we specify the algorithm in the
S-expressions and the public key ids are not anymore needed.
This patch also adds some support for PUBKEY_ALGO_EDDSA which will
eventually be used instead of merging EdDSA with ECDSA. As of now an
experimental algorithm id is used but the plan is to write an I-D so
that we can get a new id from the IETF. Note that EdDSA (Ed25519)
does not yet work and that more changes are required.
The ECC support is still broken right now. Needs to be fixed.
Signed-off-by: Werner Koch <wk@gnupg.org>
2014-01-30 18:48:37 +01:00
|
|
|
else if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA
|
2013-11-15 08:59:45 +01:00
|
|
|
&& openpgp_oid_is_ed25519 (pk->pkey[0]))
|
|
|
|
{
|
|
|
|
if (opt.personal_digest_prefs)
|
|
|
|
return opt.personal_digest_prefs[0].value;
|
|
|
|
else
|
|
|
|
return DIGEST_ALGO_SHA256;
|
|
|
|
}
|
2011-01-21 12:00:57 +01:00
|
|
|
else if (pk->pubkey_algo == PUBKEY_ALGO_DSA
|
|
|
|
|| pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
|
2010-02-02 15:06:19 +01:00
|
|
|
{
|
2011-01-06 02:33:17 +01:00
|
|
|
unsigned int qbytes = gcry_mpi_get_nbits (pk->pkey[1]);
|
|
|
|
|
2011-01-21 12:00:57 +01:00
|
|
|
if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
|
|
|
|
qbytes = ecdsa_qbits_from_Q (qbytes);
|
2011-01-06 02:33:17 +01:00
|
|
|
qbytes = qbytes/8;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
/* It's a DSA key, so find a hash that is the same size as q or
|
|
|
|
larger. If q is 160, assume it is an old DSA key and use a
|
|
|
|
160-bit hash unless --enable-dsa2 is set, in which case act
|
|
|
|
like a new DSA key that just happens to have a 160-bit q
|
|
|
|
(i.e. allow truncation). If q is not 160, by definition it
|
2020-08-13 11:19:22 +02:00
|
|
|
must be a new DSA key. We ignore the personal_digest_prefs
|
|
|
|
for ECDSA because they should always macth the curve and
|
|
|
|
truncated hashes are not useful either. Even worse,
|
|
|
|
smartcards may reject non matching hash lengths for curves
|
|
|
|
(e.g. using SHA-512 with brainpooolP385r1 on a Yubikey). */
|
2006-04-28 16:31:29 +02:00
|
|
|
|
2020-08-13 11:19:22 +02:00
|
|
|
if (pk->pubkey_algo == PUBKEY_ALGO_DSA && opt.personal_digest_prefs)
|
2006-04-28 16:31:29 +02:00
|
|
|
{
|
|
|
|
prefitem_t *prefs;
|
|
|
|
|
|
|
|
if (qbytes != 20 || opt.flags.dsa2)
|
|
|
|
{
|
|
|
|
for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
|
|
|
|
if (gcry_md_get_algo_dlen (prefs->value) >= qbytes)
|
|
|
|
return prefs->value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (prefs=opt.personal_digest_prefs; prefs->type; prefs++)
|
2006-05-23 18:19:43 +02:00
|
|
|
if (gcry_md_get_algo_dlen (prefs->value) == qbytes)
|
2006-04-28 16:31:29 +02:00
|
|
|
return prefs->value;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return match_dsa_hash(qbytes);
|
|
|
|
}
|
2010-10-20 13:33:50 +02:00
|
|
|
else if (openpgp_card_v1_p (pk))
|
2006-04-28 16:31:29 +02:00
|
|
|
{
|
2010-02-26 11:52:05 +01:00
|
|
|
/* The sk lives on a smartcard, and old smartcards only handle
|
|
|
|
SHA-1 and RIPEMD/160. Newer smartcards (v2.0) don't have
|
|
|
|
this restriction anymore. Fortunately the serial number
|
|
|
|
encodes the version of the card and thus we know that this
|
|
|
|
key is on a v1 card. */
|
2003-06-05 09:14:21 +02:00
|
|
|
if(opt.personal_digest_prefs)
|
|
|
|
{
|
|
|
|
prefitem_t *prefs;
|
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
for (prefs=opt.personal_digest_prefs;prefs->type;prefs++)
|
|
|
|
if (prefs->value==DIGEST_ALGO_SHA1
|
|
|
|
|| prefs->value==DIGEST_ALGO_RMD160)
|
2003-06-05 09:14:21 +02:00
|
|
|
return prefs->value;
|
|
|
|
}
|
|
|
|
|
|
|
|
return DIGEST_ALGO_SHA1;
|
|
|
|
}
|
2010-02-02 15:06:19 +01:00
|
|
|
else if (opt.personal_digest_prefs)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
|
|
|
/* It's not DSA, so we can use whatever the first hash algorithm
|
|
|
|
is in the pref list */
|
|
|
|
return opt.personal_digest_prefs[0].value;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return DEFAULT_DIGEST_ALGO;
|
|
|
|
}
|
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
static void
|
2010-02-02 15:06:19 +01:00
|
|
|
print_status_sig_created (PKT_public_key *pk, PKT_signature *sig, int what)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2010-02-02 15:06:19 +01:00
|
|
|
byte array[MAX_FINGERPRINT_LEN];
|
|
|
|
char buf[100+MAX_FINGERPRINT_LEN*2];
|
|
|
|
size_t n;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
snprintf (buf, sizeof buf - 2*MAX_FINGERPRINT_LEN, "%c %d %d %02x %lu ",
|
|
|
|
what, sig->pubkey_algo, sig->digest_algo, sig->sig_class,
|
|
|
|
(ulong)sig->timestamp );
|
|
|
|
fingerprint_from_pk (pk, array, &n);
|
|
|
|
bin2hex (array, n, buf + strlen (buf));
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
write_status_text( STATUS_SIG_CREATED, buf );
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop over the secret certificates in SK_LIST and build the one pass
|
|
|
|
* signature packets. OpenPGP says that the data should be bracket by
|
|
|
|
* the onepass-sig and signature-packet; so we build these onepass
|
2011-02-03 17:40:43 +01:00
|
|
|
* packet here in reverse order
|
2003-06-05 09:14:21 +02:00
|
|
|
*/
|
|
|
|
static int
|
2006-04-19 13:26:11 +02:00
|
|
|
write_onepass_sig_packets (SK_LIST sk_list, IOBUF out, int sigclass )
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
|
|
|
int skcount;
|
|
|
|
SK_LIST sk_rover;
|
|
|
|
|
|
|
|
for (skcount=0, sk_rover=sk_list; sk_rover; sk_rover = sk_rover->next)
|
|
|
|
skcount++;
|
|
|
|
|
|
|
|
for (; skcount; skcount--) {
|
2010-02-02 15:06:19 +01:00
|
|
|
PKT_public_key *pk;
|
2003-06-05 09:14:21 +02:00
|
|
|
PKT_onepass_sig *ops;
|
|
|
|
PACKET pkt;
|
|
|
|
int i, rc;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
for (i=0, sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
|
|
|
|
if (++i == skcount)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
pk = sk_rover->pk;
|
2006-04-19 13:26:11 +02:00
|
|
|
ops = xmalloc_clear (sizeof *ops);
|
2003-06-05 09:14:21 +02:00
|
|
|
ops->sig_class = sigclass;
|
2010-02-02 15:06:19 +01:00
|
|
|
ops->digest_algo = hash_for (pk);
|
|
|
|
ops->pubkey_algo = pk->pubkey_algo;
|
|
|
|
keyid_from_pk (pk, ops->keyid);
|
2003-06-05 09:14:21 +02:00
|
|
|
ops->last = (skcount == 1);
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
init_packet(&pkt);
|
|
|
|
pkt.pkttype = PKT_ONEPASS_SIG;
|
|
|
|
pkt.pkt.onepass_sig = ops;
|
|
|
|
rc = build_packet (out, &pkt);
|
2017-03-29 11:57:40 +02:00
|
|
|
free_packet (&pkt, NULL);
|
2003-06-05 09:14:21 +02:00
|
|
|
if (rc) {
|
|
|
|
log_error ("build onepass_sig packet failed: %s\n",
|
2015-01-22 12:06:11 +01:00
|
|
|
gpg_strerror (rc));
|
2003-06-05 09:14:21 +02:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper to write the plaintext (literal data) packet
|
|
|
|
*/
|
|
|
|
static int
|
2006-04-19 13:26:11 +02:00
|
|
|
write_plaintext_packet (IOBUF out, IOBUF inp, const char *fname, int ptmode)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
|
|
|
PKT_plaintext *pt = NULL;
|
|
|
|
u32 filesize;
|
|
|
|
int rc = 0;
|
|
|
|
|
2006-04-28 16:31:29 +02:00
|
|
|
if (!opt.no_literal)
|
|
|
|
pt=setup_plaintext_name(fname,inp);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-06-13 10:07:07 +02:00
|
|
|
/* Try to calculate the length of the data. */
|
2006-04-19 13:26:11 +02:00
|
|
|
if ( !iobuf_is_pipe_filename (fname) && *fname )
|
|
|
|
{
|
2023-06-13 10:07:07 +02:00
|
|
|
uint64_t tmpsize;
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2023-06-13 10:07:07 +02:00
|
|
|
tmpsize = iobuf_get_filelength (inp);
|
|
|
|
if (!tmpsize && opt.verbose)
|
2012-06-05 19:29:22 +02:00
|
|
|
log_info (_("WARNING: '%s' is an empty file\n"), fname);
|
2006-04-19 13:26:11 +02:00
|
|
|
|
|
|
|
/* We can't encode the length of very large files because
|
|
|
|
OpenPGP uses only 32 bit for file sizes. So if the size of
|
|
|
|
a file is larger than 2^32 minus some bytes for packet
|
|
|
|
headers, we switch to partial length encoding. */
|
|
|
|
if ( tmpsize < (IOBUF_FILELENGTH_LIMIT - 65536) )
|
|
|
|
filesize = tmpsize;
|
|
|
|
else
|
|
|
|
filesize = 0;
|
|
|
|
|
|
|
|
/* Because the text_filter modifies the length of the
|
2003-06-05 09:14:21 +02:00
|
|
|
* data, it is not possible to know the used length
|
|
|
|
* without a double read of the file - to avoid that
|
2006-04-19 13:26:11 +02:00
|
|
|
* we simple use partial length packets. */
|
2016-07-13 13:31:12 +02:00
|
|
|
if ( ptmode == 't' || ptmode == 'u' || ptmode == 'm')
|
2006-04-19 13:26:11 +02:00
|
|
|
filesize = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
filesize = opt.set_filesize? opt.set_filesize : 0; /* stdin */
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if (!opt.no_literal) {
|
|
|
|
PACKET pkt;
|
|
|
|
|
2016-01-06 08:42:07 +01:00
|
|
|
/* Note that PT has been initialized above in no_literal mode. */
|
2003-06-05 09:14:21 +02:00
|
|
|
pt->timestamp = make_timestamp ();
|
|
|
|
pt->mode = ptmode;
|
|
|
|
pt->len = filesize;
|
2014-08-12 10:36:30 +02:00
|
|
|
pt->new_ctb = !pt->len;
|
2003-06-05 09:14:21 +02:00
|
|
|
pt->buf = inp;
|
|
|
|
init_packet(&pkt);
|
|
|
|
pkt.pkttype = PKT_PLAINTEXT;
|
|
|
|
pkt.pkt.plaintext = pt;
|
|
|
|
/*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
|
|
|
|
if( (rc = build_packet (out, &pkt)) )
|
|
|
|
log_error ("build_packet(PLAINTEXT) failed: %s\n",
|
2015-01-22 12:06:11 +01:00
|
|
|
gpg_strerror (rc) );
|
2003-06-05 09:14:21 +02:00
|
|
|
pt->buf = NULL;
|
2017-03-29 11:57:40 +02:00
|
|
|
free_packet (&pkt, NULL);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
byte copy_buffer[4096];
|
|
|
|
int bytes_copied;
|
|
|
|
|
|
|
|
while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
|
2006-04-19 15:24:36 +02:00
|
|
|
if ( (rc=iobuf_write(out, copy_buffer, bytes_copied)) ) {
|
2003-06-05 09:14:21 +02:00
|
|
|
log_error ("copying input to output failed: %s\n",
|
2006-04-19 15:24:36 +02:00
|
|
|
gpg_strerror (rc));
|
2003-06-05 09:14:21 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
wipememory(copy_buffer,4096); /* burn buffer */
|
|
|
|
}
|
|
|
|
/* fixme: it seems that we never freed pt/pkt */
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write the signatures from the SK_LIST to OUT. HASH must be a non-finalized
|
|
|
|
* hash which will not be changes here.
|
|
|
|
*/
|
|
|
|
static int
|
2017-03-31 20:03:52 +02:00
|
|
|
write_signature_packets (ctrl_t ctrl,
|
|
|
|
SK_LIST sk_list, IOBUF out, gcry_md_hd_t hash,
|
2003-06-05 09:14:21 +02:00
|
|
|
int sigclass, u32 timestamp, u32 duration,
|
2010-09-01 14:49:05 +02:00
|
|
|
int status_letter, const char *cache_nonce)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2010-02-02 15:06:19 +01:00
|
|
|
SK_LIST sk_rover;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
/* Loop over the certificates with secret keys. */
|
|
|
|
for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
|
|
|
|
{
|
|
|
|
PKT_public_key *pk;
|
|
|
|
PKT_signature *sig;
|
|
|
|
gcry_md_hd_t md;
|
2020-03-13 13:28:35 +01:00
|
|
|
gpg_error_t err;
|
2010-02-02 15:06:19 +01:00
|
|
|
|
|
|
|
pk = sk_rover->pk;
|
|
|
|
|
|
|
|
/* Build the signature packet. */
|
2017-02-10 17:16:07 +01:00
|
|
|
sig = xtrycalloc (1, sizeof *sig);
|
|
|
|
if (!sig)
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
if (duration || opt.sig_policy_url
|
|
|
|
|| opt.sig_notations || opt.sig_keyserver_url)
|
2010-02-02 15:06:19 +01:00
|
|
|
sig->version = 4;
|
|
|
|
else
|
|
|
|
sig->version = pk->version;
|
|
|
|
|
|
|
|
keyid_from_pk (pk, sig->keyid);
|
|
|
|
sig->digest_algo = hash_for (pk);
|
|
|
|
sig->pubkey_algo = pk->pubkey_algo;
|
|
|
|
if (timestamp)
|
|
|
|
sig->timestamp = timestamp;
|
|
|
|
else
|
|
|
|
sig->timestamp = make_timestamp();
|
|
|
|
if (duration)
|
|
|
|
sig->expiredate = sig->timestamp + duration;
|
|
|
|
sig->sig_class = sigclass;
|
|
|
|
|
|
|
|
if (gcry_md_copy (&md, hash))
|
|
|
|
BUG ();
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2014-12-15 09:50:19 +01:00
|
|
|
if (sig->version >= 4)
|
|
|
|
{
|
2024-09-26 10:37:32 +02:00
|
|
|
build_sig_subpkt_from_sig (sig, pk, 0);
|
2014-12-15 09:50:19 +01:00
|
|
|
mk_notation_policy_etc (sig, NULL, pk);
|
2020-03-13 13:28:35 +01:00
|
|
|
if (opt.flags.include_key_block && IS_SIG (sig))
|
|
|
|
err = mk_sig_subpkt_key_block (ctrl, sig, pk);
|
|
|
|
else
|
|
|
|
err = 0;
|
2014-12-15 09:50:19 +01:00
|
|
|
}
|
2020-12-23 16:06:09 +01:00
|
|
|
else
|
|
|
|
err = 0; /* Actually never reached. */
|
2010-02-02 15:06:19 +01:00
|
|
|
hash_sigversion_to_magic (md, sig);
|
|
|
|
gcry_md_final (md);
|
|
|
|
|
2020-03-13 13:28:35 +01:00
|
|
|
if (!err)
|
|
|
|
err = do_sign (ctrl, pk, sig, md, hash_for (pk), cache_nonce, 0);
|
2010-02-02 15:06:19 +01:00
|
|
|
gcry_md_close (md);
|
2020-03-13 13:28:35 +01:00
|
|
|
if (!err)
|
2011-02-03 17:40:43 +01:00
|
|
|
{
|
2010-02-02 15:06:19 +01:00
|
|
|
/* Write the packet. */
|
|
|
|
PACKET pkt;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
init_packet (&pkt);
|
|
|
|
pkt.pkttype = PKT_SIGNATURE;
|
|
|
|
pkt.pkt.signature = sig;
|
2020-03-13 13:28:35 +01:00
|
|
|
err = build_packet (out, &pkt);
|
|
|
|
if (!err && is_status_enabled())
|
2010-02-02 15:06:19 +01:00
|
|
|
print_status_sig_created (pk, sig, status_letter);
|
2017-03-29 11:57:40 +02:00
|
|
|
free_packet (&pkt, NULL);
|
2020-03-13 13:28:35 +01:00
|
|
|
if (err)
|
2017-02-10 17:16:07 +01:00
|
|
|
log_error ("build signature packet failed: %s\n",
|
2020-03-13 13:28:35 +01:00
|
|
|
gpg_strerror (err));
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2017-02-10 17:16:07 +01:00
|
|
|
else
|
2018-07-03 02:07:03 +02:00
|
|
|
free_seckey_enc (sig);
|
2017-02-10 17:16:07 +01:00
|
|
|
|
2020-03-13 13:28:35 +01:00
|
|
|
if (err)
|
|
|
|
return err;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
return 0;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
|
2021-04-12 17:50:17 +02:00
|
|
|
/* Sign the files whose names are in FILENAME using all secret keys
|
|
|
|
* which can be taken from LOCUSR, if this is NULL, use the default
|
|
|
|
* secret key.
|
|
|
|
* If DETACHED has the value true, make a detached signature.
|
|
|
|
* If FILENAMES->d is NULL read from stdin and ignore the detached mode.
|
|
|
|
* If ENCRYPTFLAG is true, use REMUSER (or ask if it is NULL) to
|
|
|
|
* encrypt the signed data for these users. If ENCRYPTFLAG is 2
|
|
|
|
* symmetric encryption is also used.
|
|
|
|
* If OUTFILE is not NULL; this file is used for output and the
|
|
|
|
* function does not ask for overwrite permission; output is then
|
|
|
|
* always uncompressed, non-armored and in binary mode.
|
2003-06-05 09:14:21 +02:00
|
|
|
*/
|
|
|
|
int
|
2010-10-01 22:33:53 +02:00
|
|
|
sign_file (ctrl_t ctrl, strlist_t filenames, int detached, strlist_t locusr,
|
2006-10-02 13:54:35 +02:00
|
|
|
int encryptflag, strlist_t remusr, const char *outfile )
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2023-01-18 18:04:50 +01:00
|
|
|
const char *fname;
|
|
|
|
armor_filter_context_t *afx;
|
|
|
|
compress_filter_context_t zfx;
|
|
|
|
md_filter_context_t mfx;
|
|
|
|
text_filter_context_t tfx;
|
|
|
|
progress_filter_context_t *pfx;
|
|
|
|
encrypt_filter_context_t efx;
|
|
|
|
iobuf_t inp = NULL;
|
|
|
|
iobuf_t out = NULL;
|
|
|
|
PACKET pkt;
|
|
|
|
int rc = 0;
|
|
|
|
PK_LIST pk_list = NULL;
|
|
|
|
SK_LIST sk_list = NULL;
|
|
|
|
SK_LIST sk_rover = NULL;
|
|
|
|
int multifile = 0;
|
|
|
|
u32 duration=0;
|
|
|
|
char peekbuf[32];
|
|
|
|
int peekbuflen = 0;
|
|
|
|
|
|
|
|
|
|
|
|
pfx = new_progress_context ();
|
|
|
|
afx = new_armor_context ();
|
|
|
|
memset (&zfx, 0, sizeof zfx);
|
|
|
|
memset (&mfx, 0, sizeof mfx);
|
|
|
|
memset (&efx, 0, sizeof efx);
|
|
|
|
efx.ctrl = ctrl;
|
|
|
|
init_packet (&pkt);
|
|
|
|
|
|
|
|
if (filenames)
|
|
|
|
{
|
|
|
|
fname = filenames->d;
|
|
|
|
multifile = !!filenames->next;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
else
|
|
|
|
fname = NULL;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (fname && filenames->next && (!detached || encryptflag))
|
|
|
|
log_bug ("multiple files can only be detached signed");
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (encryptflag == 2
|
|
|
|
&& (rc = setup_symkey (&efx.symkey_s2k,&efx.symkey_dek)))
|
|
|
|
goto leave;
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (opt.ask_sig_expire && !opt.batch)
|
|
|
|
duration = ask_expire_interval(1,opt.def_sig_expire);
|
|
|
|
else
|
|
|
|
duration = parse_expire_string(opt.def_sig_expire);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Note: In the old non-agent version the following call used to
|
|
|
|
unprotect the secret key. This is now done on demand by the agent. */
|
|
|
|
if ((rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_SIG )))
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (encryptflag
|
|
|
|
&& (rc=build_pk_list (ctrl, remusr, &pk_list)))
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Prepare iobufs. */
|
|
|
|
if (multifile) /* have list of filenames */
|
|
|
|
inp = NULL; /* we do it later */
|
|
|
|
else
|
|
|
|
{
|
2006-04-19 13:26:11 +02:00
|
|
|
inp = iobuf_open(fname);
|
|
|
|
if (inp && is_secured_file (iobuf_get_fd (inp)))
|
|
|
|
{
|
|
|
|
iobuf_close (inp);
|
|
|
|
inp = NULL;
|
2010-04-01 15:24:55 +02:00
|
|
|
gpg_err_set_errno (EPERM);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2011-02-03 17:40:43 +01:00
|
|
|
if( !inp )
|
2006-04-19 15:24:36 +02:00
|
|
|
{
|
2006-09-14 18:50:33 +02:00
|
|
|
rc = gpg_error_from_syserror ();
|
2012-06-05 19:29:22 +02:00
|
|
|
log_error (_("can't open '%s': %s\n"), fname? fname: "[stdin]",
|
2006-04-19 15:24:36 +02:00
|
|
|
strerror(errno) );
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
peekbuflen = iobuf_ioctl (inp, IOBUF_IOCTL_PEEK, sizeof peekbuf, peekbuf);
|
|
|
|
if (peekbuflen < 0)
|
|
|
|
{
|
|
|
|
peekbuflen = 0;
|
|
|
|
if (DBG_FILTER)
|
|
|
|
log_debug ("peeking at input failed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
handle_progress (pfx, inp, fname);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (outfile)
|
|
|
|
{
|
|
|
|
if (is_secured_filename ( outfile ))
|
|
|
|
{
|
|
|
|
out = NULL;
|
|
|
|
gpg_err_set_errno (EPERM);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
else
|
|
|
|
out = iobuf_create (outfile, 0);
|
|
|
|
if (!out)
|
|
|
|
{
|
|
|
|
rc = gpg_error_from_syserror ();
|
|
|
|
log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
else if (opt.verbose)
|
|
|
|
log_info (_("writing to '%s'\n"), outfile);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
else if ((rc = open_outfile (-1, fname,
|
|
|
|
opt.armor? 1: detached? 2:0, 0, &out)))
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Prepare to calculate the MD over the input. */
|
|
|
|
if (opt.textmode && !outfile && !multifile)
|
|
|
|
{
|
|
|
|
memset( &tfx, 0, sizeof tfx);
|
|
|
|
iobuf_push_filter( inp, text_filter, &tfx );
|
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (gcry_md_open (&mfx.md, 0, 0))
|
|
|
|
BUG ();
|
|
|
|
if (DBG_HASHING)
|
|
|
|
gcry_md_debug (mfx.md, "sign");
|
|
|
|
|
|
|
|
/* If we're encrypting and signing, it is reasonable to pick the
|
|
|
|
* hash algorithm to use out of the recipient key prefs. This is
|
|
|
|
* best effort only, as in a DSA2 and smartcard world there are
|
|
|
|
* cases where we cannot please everyone with a single hash (DSA2
|
|
|
|
* wants >160 and smartcards want =160). In the future this could
|
|
|
|
* be more complex with different hashes for each sk, but the
|
|
|
|
* current design requires a single hash for all SKs. */
|
|
|
|
if (pk_list)
|
|
|
|
{
|
|
|
|
if (opt.def_digest_algo)
|
|
|
|
{
|
|
|
|
if (!opt.expert &&
|
|
|
|
select_algo_from_prefs(pk_list,PREFTYPE_HASH,
|
|
|
|
opt.def_digest_algo,
|
|
|
|
NULL)!=opt.def_digest_algo)
|
|
|
|
log_info (_("WARNING: forcing digest algorithm %s (%d)"
|
|
|
|
" violates recipient preferences\n"),
|
|
|
|
gcry_md_algo_name (opt.def_digest_algo),
|
|
|
|
opt.def_digest_algo );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int algo;
|
|
|
|
int conflict = 0;
|
|
|
|
struct pref_hint hint = { 0 };
|
|
|
|
|
|
|
|
/* Of course, if the recipient asks for something
|
|
|
|
* unreasonable (like the wrong hash for a DSA key) then
|
|
|
|
* don't do it. Check all sk's - if any are DSA or live
|
|
|
|
* on a smartcard, then the hash has restrictions and we
|
|
|
|
* may not be able to give the recipient what they want.
|
|
|
|
* For DSA, pass a hint for the largest q we have. Note
|
|
|
|
* that this means that a q>160 key will override a q=160
|
|
|
|
* key and force the use of truncation for the q=160 key.
|
|
|
|
* The alternative would be to ignore the recipient prefs
|
|
|
|
* completely and get a different hash for each DSA key in
|
|
|
|
* hash_for(). The override behavior here is more or less
|
|
|
|
* reasonable as it is under the control of the user which
|
|
|
|
* keys they sign with for a given message and the fact
|
|
|
|
* that the message with multiple signatures won't be
|
|
|
|
* usable on an implementation that doesn't understand
|
|
|
|
* DSA2 anyway. */
|
|
|
|
for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
|
|
|
|
{
|
|
|
|
if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_DSA
|
|
|
|
|| sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
|
|
|
|
{
|
|
|
|
int temp_hashlen = (gcry_mpi_get_nbits
|
|
|
|
(sk_rover->pk->pkey[1]));
|
|
|
|
|
|
|
|
if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
|
|
|
|
{
|
|
|
|
temp_hashlen = ecdsa_qbits_from_Q (temp_hashlen);
|
|
|
|
if (!temp_hashlen)
|
|
|
|
conflict = 1; /* Better don't use the prefs. */
|
|
|
|
temp_hashlen = (temp_hashlen+7)/8;
|
|
|
|
/* Fixup for that funny nistp521 (yes, 521)
|
|
|
|
* were we need to use a 512 bit hash algo. */
|
|
|
|
if (temp_hashlen == 66)
|
|
|
|
temp_hashlen = 64;
|
|
|
|
}
|
|
|
|
else
|
2020-11-13 15:43:30 +01:00
|
|
|
temp_hashlen = (temp_hashlen+7)/8;
|
2006-07-27 16:18:55 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Pick a hash that is large enough for our
|
|
|
|
* largest q or matches our Q but if tehreare
|
|
|
|
* several of them we run into a conflict and
|
|
|
|
* don't use the preferences. */
|
|
|
|
if (hint.digest_length < temp_hashlen)
|
|
|
|
{
|
|
|
|
if (sk_rover->pk->pubkey_algo == PUBKEY_ALGO_ECDSA)
|
|
|
|
{
|
|
|
|
if (hint.exact)
|
|
|
|
conflict = 1;
|
|
|
|
hint.exact = 1;
|
|
|
|
}
|
|
|
|
hint.digest_length = temp_hashlen;
|
|
|
|
}
|
2020-11-02 13:39:58 +01:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (!conflict
|
|
|
|
&& (algo = select_algo_from_prefs (pk_list,PREFTYPE_HASH,
|
|
|
|
-1,&hint)) > 0)
|
|
|
|
{
|
|
|
|
/* Note that we later check that the algo is not weak. */
|
|
|
|
recipient_digest_algo = algo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
|
|
|
|
gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (!multifile)
|
|
|
|
iobuf_push_filter (inp, md_filter, &mfx);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (detached && !encryptflag)
|
|
|
|
afx->what = 2;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (opt.armor && !outfile)
|
|
|
|
push_armor_filter (afx, out);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (encryptflag)
|
|
|
|
{
|
|
|
|
efx.pk_list = pk_list;
|
|
|
|
/* fixme: set efx.cfx.datalen if known */
|
|
|
|
iobuf_push_filter( out, encrypt_filter, &efx );
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (opt.compress_algo && !outfile && !detached)
|
|
|
|
{
|
|
|
|
int compr_algo = opt.compress_algo;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
if (!opt.explicit_compress_option
|
|
|
|
&& is_file_compressed (peekbuf, peekbuflen))
|
|
|
|
{
|
|
|
|
if (opt.verbose)
|
|
|
|
log_info(_("'%s' already compressed\n"), fname? fname: "[stdin]");
|
|
|
|
compr_algo = 0;
|
|
|
|
}
|
|
|
|
else if (compr_algo==-1)
|
|
|
|
{
|
|
|
|
/* If we're not encrypting, then select_algo_from_prefs
|
|
|
|
* will fail and we'll end up with the default. If we are
|
|
|
|
* encrypting, select_algo_from_prefs cannot fail since
|
|
|
|
* there is an assumed preference for uncompressed data.
|
|
|
|
* Still, if it did fail, we'll also end up with the
|
|
|
|
* default. */
|
|
|
|
if ((compr_algo = select_algo_from_prefs (pk_list, PREFTYPE_ZIP,
|
|
|
|
-1, NULL)) == -1)
|
|
|
|
{
|
|
|
|
compr_algo = default_compress_algo();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (!opt.expert && pk_list
|
|
|
|
&& select_algo_from_prefs (pk_list, PREFTYPE_ZIP,
|
|
|
|
compr_algo, NULL) != compr_algo)
|
|
|
|
{
|
|
|
|
log_info (_("WARNING: forcing compression algorithm %s (%d)"
|
|
|
|
" violates recipient preferences\n"),
|
|
|
|
compress_algo_to_string (compr_algo), compr_algo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Algo 0 means no compression. */
|
|
|
|
if (compr_algo)
|
|
|
|
push_compress_filter (out, &zfx, compr_algo);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Write the one-pass signature packets if needed */
|
|
|
|
if (!detached)
|
|
|
|
{
|
|
|
|
rc = write_onepass_sig_packets (sk_list, out,
|
|
|
|
opt.textmode && !outfile ? 0x01:0x00);
|
|
|
|
if (rc)
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_status_begin_signing (mfx.md);
|
|
|
|
|
|
|
|
/* Setup the inner packet. */
|
|
|
|
if (detached)
|
|
|
|
{
|
|
|
|
if (multifile)
|
|
|
|
{
|
|
|
|
strlist_t sl;
|
|
|
|
|
|
|
|
if (opt.verbose)
|
|
|
|
log_info(_("signing:") );
|
|
|
|
/* Must walk reverse trough this list. */
|
|
|
|
for (sl = strlist_last (filenames); sl;
|
|
|
|
sl = strlist_prev (filenames, sl))
|
|
|
|
{
|
|
|
|
inp = iobuf_open(sl->d);
|
|
|
|
if (inp && is_secured_file (iobuf_get_fd (inp)))
|
|
|
|
{
|
|
|
|
iobuf_close (inp);
|
|
|
|
inp = NULL;
|
|
|
|
gpg_err_set_errno (EPERM);
|
|
|
|
}
|
|
|
|
if (!inp)
|
|
|
|
{
|
|
|
|
rc = gpg_error_from_syserror ();
|
|
|
|
log_error(_("can't open '%s': %s\n"),
|
|
|
|
sl->d,strerror(errno));
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
handle_progress (pfx, inp, sl->d);
|
|
|
|
if (opt.verbose)
|
|
|
|
log_printf (" '%s'", sl->d );
|
|
|
|
if (opt.textmode)
|
|
|
|
{
|
|
|
|
memset( &tfx, 0, sizeof tfx);
|
|
|
|
iobuf_push_filter( inp, text_filter, &tfx );
|
|
|
|
}
|
|
|
|
iobuf_push_filter( inp, md_filter, &mfx );
|
|
|
|
while (iobuf_read (inp, NULL, 1<<30) != -1 )
|
|
|
|
;
|
|
|
|
iobuf_close(inp); inp = NULL;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
if (opt.verbose)
|
|
|
|
log_printf ("\n");
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Read, so that the filter can calculate the digest. */
|
|
|
|
while (iobuf_read (inp, NULL, 1<<30) != -1 )
|
|
|
|
;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
rc = write_plaintext_packet (out, inp, fname,
|
|
|
|
opt.textmode && !outfile ?
|
|
|
|
(opt.mimemode? 'm':'t'):'b');
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Catch errors from above. */
|
|
|
|
if (rc)
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
/* Write the signatures. */
|
|
|
|
rc = write_signature_packets (ctrl, sk_list, out, mfx.md,
|
|
|
|
opt.textmode && !outfile? 0x01 : 0x00,
|
|
|
|
0, duration, detached ? 'D':'S', NULL);
|
|
|
|
if (rc)
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
|
2023-01-18 18:04:50 +01:00
|
|
|
leave:
|
|
|
|
if (rc)
|
|
|
|
iobuf_cancel (out);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
iobuf_close(out);
|
|
|
|
if (encryptflag)
|
|
|
|
write_status( STATUS_END_ENCRYPTION );
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2023-01-18 18:04:50 +01:00
|
|
|
iobuf_close(inp);
|
|
|
|
gcry_md_close ( mfx.md );
|
|
|
|
release_sk_list( sk_list );
|
|
|
|
release_pk_list( pk_list );
|
|
|
|
recipient_digest_algo=0;
|
|
|
|
release_progress_context (pfx);
|
|
|
|
release_armor_context (afx);
|
|
|
|
return rc;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************
|
|
|
|
* make a clear signature. note that opt.armor is not needed
|
|
|
|
*/
|
|
|
|
int
|
2015-11-03 23:15:27 +01:00
|
|
|
clearsign_file (ctrl_t ctrl,
|
|
|
|
const char *fname, strlist_t locusr, const char *outfile )
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2006-12-06 11:16:50 +01:00
|
|
|
armor_filter_context_t *afx;
|
|
|
|
progress_filter_context_t *pfx;
|
2006-04-19 15:24:36 +02:00
|
|
|
gcry_md_hd_t textmd = NULL;
|
2006-04-19 13:26:11 +02:00
|
|
|
IOBUF inp = NULL, out = NULL;
|
2003-06-05 09:14:21 +02:00
|
|
|
PACKET pkt;
|
|
|
|
int rc = 0;
|
|
|
|
SK_LIST sk_list = NULL;
|
|
|
|
SK_LIST sk_rover = NULL;
|
|
|
|
u32 duration=0;
|
|
|
|
|
2006-12-06 11:16:50 +01:00
|
|
|
pfx = new_progress_context ();
|
|
|
|
afx = new_armor_context ();
|
2003-06-05 09:14:21 +02:00
|
|
|
init_packet( &pkt );
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
if (opt.ask_sig_expire && !opt.batch)
|
|
|
|
duration = ask_expire_interval (1,opt.def_sig_expire);
|
|
|
|
else
|
|
|
|
duration = parse_expire_string (opt.def_sig_expire);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2010-04-23 13:36:59 +02:00
|
|
|
/* Note: In the old non-agent version the following call used to
|
|
|
|
unprotect the secret key. This is now done on demand by the agent. */
|
2015-11-03 23:15:27 +01:00
|
|
|
if( (rc=build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_SIG )) )
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
|
|
|
|
|
|
|
/* prepare iobufs */
|
2006-04-19 13:26:11 +02:00
|
|
|
inp = iobuf_open(fname);
|
|
|
|
if (inp && is_secured_file (iobuf_get_fd (inp)))
|
|
|
|
{
|
|
|
|
iobuf_close (inp);
|
|
|
|
inp = NULL;
|
2010-04-01 15:24:55 +02:00
|
|
|
gpg_err_set_errno (EPERM);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
|
|
|
if( !inp ) {
|
2006-09-14 18:50:33 +02:00
|
|
|
rc = gpg_error_from_syserror ();
|
2012-06-05 19:29:22 +02:00
|
|
|
log_error (_("can't open '%s': %s\n"),
|
2006-04-19 15:24:36 +02:00
|
|
|
fname? fname: "[stdin]", strerror(errno) );
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
|
|
|
}
|
2006-12-06 11:16:50 +01:00
|
|
|
handle_progress (pfx, inp, fname);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if( outfile ) {
|
2006-04-19 13:26:11 +02:00
|
|
|
if (is_secured_filename (outfile) ) {
|
|
|
|
outfile = NULL;
|
2010-04-01 15:24:55 +02:00
|
|
|
gpg_err_set_errno (EPERM);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2011-02-03 17:40:43 +01:00
|
|
|
else
|
2014-06-25 20:25:28 +02:00
|
|
|
out = iobuf_create (outfile, 0);
|
2006-04-19 13:26:11 +02:00
|
|
|
if( !out )
|
|
|
|
{
|
2006-09-14 18:50:33 +02:00
|
|
|
rc = gpg_error_from_syserror ();
|
2012-06-05 19:29:22 +02:00
|
|
|
log_error(_("can't create '%s': %s\n"), outfile, strerror(errno) );
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
else if( opt.verbose )
|
2012-06-05 19:29:22 +02:00
|
|
|
log_info(_("writing to '%s'\n"), outfile );
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
2017-08-01 19:08:16 +02:00
|
|
|
else if ((rc = open_outfile (-1, fname, 1, 0, &out)))
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
|
|
|
|
|
|
|
iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----" LF );
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
{
|
2003-06-05 09:14:21 +02:00
|
|
|
const char *s;
|
|
|
|
int any = 0;
|
|
|
|
byte hashs_seen[256];
|
|
|
|
|
|
|
|
memset( hashs_seen, 0, sizeof hashs_seen );
|
|
|
|
iobuf_writestr(out, "Hash: " );
|
|
|
|
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
|
2010-02-02 15:06:19 +01:00
|
|
|
int i = hash_for (sk_rover->pk);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if( !hashs_seen[ i & 0xff ] ) {
|
2006-04-19 15:24:36 +02:00
|
|
|
s = gcry_md_algo_name ( i );
|
2003-06-05 09:14:21 +02:00
|
|
|
if( s ) {
|
|
|
|
hashs_seen[ i & 0xff ] = 1;
|
|
|
|
if( any )
|
|
|
|
iobuf_put(out, ',' );
|
|
|
|
iobuf_writestr(out, s );
|
|
|
|
any = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-04-29 11:05:24 +02:00
|
|
|
log_assert(any);
|
2003-06-05 09:14:21 +02:00
|
|
|
iobuf_writestr(out, LF );
|
|
|
|
}
|
|
|
|
|
|
|
|
if( opt.not_dash_escaped )
|
|
|
|
iobuf_writestr( out,
|
2013-11-18 14:09:47 +01:00
|
|
|
"NotDashEscaped: You need "GPG_NAME
|
|
|
|
" to verify this message" LF );
|
2003-06-05 09:14:21 +02:00
|
|
|
iobuf_writestr(out, LF );
|
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
if ( gcry_md_open (&textmd, 0, 0) )
|
|
|
|
BUG ();
|
2010-02-02 15:06:19 +01:00
|
|
|
for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
|
|
|
|
gcry_md_enable (textmd, hash_for(sk_rover->pk));
|
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
if ( DBG_HASHING )
|
2011-09-20 09:54:27 +02:00
|
|
|
gcry_md_debug ( textmd, "clearsign" );
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
copy_clearsig_text (out, inp, textmd, !opt.not_dash_escaped,
|
|
|
|
opt.escape_from);
|
2003-06-05 09:14:21 +02:00
|
|
|
/* fixme: check for read errors */
|
|
|
|
|
|
|
|
/* now write the armor */
|
2006-12-06 11:16:50 +01:00
|
|
|
afx->what = 2;
|
|
|
|
push_armor_filter (afx, out);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2010-09-01 14:49:05 +02:00
|
|
|
/* Write the signatures. */
|
2017-03-31 20:03:52 +02:00
|
|
|
rc = write_signature_packets (ctrl, sk_list, out, textmd, 0x01, 0,
|
|
|
|
duration, 'C', NULL);
|
2003-06-05 09:14:21 +02:00
|
|
|
if( rc )
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
leave:
|
|
|
|
if( rc )
|
|
|
|
iobuf_cancel(out);
|
|
|
|
else
|
|
|
|
iobuf_close(out);
|
|
|
|
iobuf_close(inp);
|
2003-06-18 21:56:13 +02:00
|
|
|
gcry_md_close ( textmd );
|
2003-06-05 09:14:21 +02:00
|
|
|
release_sk_list( sk_list );
|
2006-12-06 11:16:50 +01:00
|
|
|
release_progress_context (pfx);
|
2011-02-03 17:40:43 +01:00
|
|
|
release_armor_context (afx);
|
2003-06-05 09:14:21 +02:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sign and conventionally encrypt the given file.
|
|
|
|
* FIXME: Far too much code is duplicated - revamp the whole file.
|
|
|
|
*/
|
|
|
|
int
|
2015-11-03 23:15:27 +01:00
|
|
|
sign_symencrypt_file (ctrl_t ctrl, const char *fname, strlist_t locusr)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
2006-12-06 11:16:50 +01:00
|
|
|
armor_filter_context_t *afx;
|
|
|
|
progress_filter_context_t *pfx;
|
2003-06-05 09:14:21 +02:00
|
|
|
compress_filter_context_t zfx;
|
|
|
|
md_filter_context_t mfx;
|
|
|
|
text_filter_context_t tfx;
|
|
|
|
cipher_filter_context_t cfx;
|
2006-04-19 13:26:11 +02:00
|
|
|
IOBUF inp = NULL, out = NULL;
|
2003-06-05 09:14:21 +02:00
|
|
|
PACKET pkt;
|
|
|
|
STRING2KEY *s2k = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
SK_LIST sk_list = NULL;
|
|
|
|
SK_LIST sk_rover = NULL;
|
|
|
|
int algo;
|
|
|
|
u32 duration=0;
|
2006-12-06 11:16:50 +01:00
|
|
|
int canceled;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2006-12-06 11:16:50 +01:00
|
|
|
pfx = new_progress_context ();
|
|
|
|
afx = new_armor_context ();
|
2003-06-05 09:14:21 +02:00
|
|
|
memset( &zfx, 0, sizeof zfx);
|
|
|
|
memset( &mfx, 0, sizeof mfx);
|
|
|
|
memset( &tfx, 0, sizeof tfx);
|
|
|
|
memset( &cfx, 0, sizeof cfx);
|
|
|
|
init_packet( &pkt );
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
if (opt.ask_sig_expire && !opt.batch)
|
|
|
|
duration = ask_expire_interval (1, opt.def_sig_expire);
|
|
|
|
else
|
|
|
|
duration = parse_expire_string (opt.def_sig_expire);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2010-04-23 13:36:59 +02:00
|
|
|
/* Note: In the old non-agent version the following call used to
|
|
|
|
unprotect the secret key. This is now done on demand by the agent. */
|
2015-11-03 23:15:27 +01:00
|
|
|
rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_SIG);
|
2011-02-03 17:40:43 +01:00
|
|
|
if (rc)
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
|
|
|
|
|
|
|
/* prepare iobufs */
|
|
|
|
inp = iobuf_open(fname);
|
2006-04-19 13:26:11 +02:00
|
|
|
if (inp && is_secured_file (iobuf_get_fd (inp)))
|
|
|
|
{
|
|
|
|
iobuf_close (inp);
|
|
|
|
inp = NULL;
|
2010-04-01 15:24:55 +02:00
|
|
|
gpg_err_set_errno (EPERM);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
if( !inp ) {
|
2006-09-14 18:50:33 +02:00
|
|
|
rc = gpg_error_from_syserror ();
|
2012-06-05 19:29:22 +02:00
|
|
|
log_error (_("can't open '%s': %s\n"),
|
2006-04-19 15:24:36 +02:00
|
|
|
fname? fname: "[stdin]", strerror(errno) );
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
|
|
|
}
|
2006-12-06 11:16:50 +01:00
|
|
|
handle_progress (pfx, inp, fname);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
/* prepare key */
|
2006-04-19 13:26:11 +02:00
|
|
|
s2k = xmalloc_clear( sizeof *s2k );
|
2014-08-12 10:36:30 +02:00
|
|
|
s2k->mode = opt.s2k_mode;
|
2006-04-19 13:26:11 +02:00
|
|
|
s2k->hash_algo = S2K_DIGEST_ALGO;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
algo = default_cipher_algo();
|
|
|
|
if (!opt.quiet || !opt.batch)
|
|
|
|
log_info (_("%s encryption will be used\n"),
|
2007-12-12 11:28:30 +01:00
|
|
|
openpgp_cipher_algo_name (algo) );
|
2021-05-17 19:27:54 +02:00
|
|
|
cfx.dek = passphrase_to_dek (algo, s2k, 1, 1, NULL, 0, &canceled);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if (!cfx.dek || !cfx.dek->keylen) {
|
2006-12-06 11:16:50 +01:00
|
|
|
rc = gpg_error (canceled?GPG_ERR_CANCELED:GPG_ERR_BAD_PASSPHRASE);
|
2006-04-19 15:24:36 +02:00
|
|
|
log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
|
2003-06-05 09:14:21 +02:00
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
2015-10-12 09:31:44 +02:00
|
|
|
cfx.dek->use_mdc = use_mdc (NULL, cfx.dek->algo);
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/* now create the outfile */
|
2017-08-01 19:08:16 +02:00
|
|
|
rc = open_outfile (-1, fname, opt.armor? 1:0, 0, &out);
|
2003-06-05 09:14:21 +02:00
|
|
|
if (rc)
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
/* prepare to calculate the MD over the input */
|
|
|
|
if (opt.textmode)
|
|
|
|
iobuf_push_filter (inp, text_filter, &tfx);
|
2006-04-19 13:26:11 +02:00
|
|
|
if ( gcry_md_open (&mfx.md, 0, 0) )
|
|
|
|
BUG ();
|
|
|
|
if ( DBG_HASHING )
|
2011-09-20 09:54:27 +02:00
|
|
|
gcry_md_debug (mfx.md, "symc-sign");
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
|
|
|
|
gcry_md_enable (mfx.md, hash_for (sk_rover->pk));
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
iobuf_push_filter (inp, md_filter, &mfx);
|
|
|
|
|
|
|
|
/* Push armor output filter */
|
|
|
|
if (opt.armor)
|
2006-12-06 11:16:50 +01:00
|
|
|
push_armor_filter (afx, out);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
/* Write the symmetric key packet */
|
|
|
|
/*(current filters: armor)*/
|
2014-08-12 10:36:30 +02:00
|
|
|
{
|
2006-04-19 13:26:11 +02:00
|
|
|
PKT_symkey_enc *enc = xmalloc_clear( sizeof *enc );
|
2003-06-05 09:14:21 +02:00
|
|
|
enc->version = 4;
|
|
|
|
enc->cipher_algo = cfx.dek->algo;
|
|
|
|
enc->s2k = *s2k;
|
|
|
|
pkt.pkttype = PKT_SYMKEY_ENC;
|
|
|
|
pkt.pkt.symkey_enc = enc;
|
|
|
|
if( (rc = build_packet( out, &pkt )) )
|
2015-01-22 12:06:11 +01:00
|
|
|
log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
|
2006-04-19 13:26:11 +02:00
|
|
|
xfree(enc);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Push the encryption filter */
|
2022-08-29 13:13:45 +02:00
|
|
|
iobuf_push_filter (out, cipher_filter_cfb, &cfx );
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
/* Push the compress filter */
|
|
|
|
if (default_compress_algo())
|
2015-10-12 09:31:44 +02:00
|
|
|
{
|
|
|
|
if (cfx.dek && cfx.dek->use_mdc)
|
|
|
|
zfx.new_ctb = 1;
|
|
|
|
push_compress_filter (out, &zfx,default_compress_algo() );
|
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
/* Write the one-pass signature packets */
|
|
|
|
/*(current filters: zip - encrypt - armor)*/
|
2014-08-12 10:36:30 +02:00
|
|
|
rc = write_onepass_sig_packets (sk_list, out,
|
|
|
|
opt.textmode? 0x01:0x00);
|
|
|
|
if (rc)
|
|
|
|
goto leave;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2007-01-30 21:16:28 +01:00
|
|
|
write_status_begin_signing (mfx.md);
|
2006-04-19 13:26:11 +02:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/* Pipe data through all filters; i.e. write the signed stuff */
|
|
|
|
/*(current filters: zip - encrypt - armor)*/
|
2016-07-13 13:31:12 +02:00
|
|
|
rc = write_plaintext_packet (out, inp, fname,
|
|
|
|
opt.textmode ? (opt.mimemode?'m':'t'):'b');
|
2003-06-05 09:14:21 +02:00
|
|
|
if (rc)
|
|
|
|
goto leave;
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/* Write the signatures */
|
|
|
|
/*(current filters: zip - encrypt - armor)*/
|
2017-03-31 20:03:52 +02:00
|
|
|
rc = write_signature_packets (ctrl, sk_list, out, mfx.md,
|
2003-06-05 09:14:21 +02:00
|
|
|
opt.textmode? 0x01 : 0x00,
|
2010-09-01 14:49:05 +02:00
|
|
|
0, duration, 'S', NULL);
|
2003-06-05 09:14:21 +02:00
|
|
|
if( rc )
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
if( rc )
|
|
|
|
iobuf_cancel(out);
|
|
|
|
else {
|
|
|
|
iobuf_close(out);
|
|
|
|
write_status( STATUS_END_ENCRYPTION );
|
|
|
|
}
|
|
|
|
iobuf_close(inp);
|
|
|
|
release_sk_list( sk_list );
|
2006-04-19 13:26:11 +02:00
|
|
|
gcry_md_close( mfx.md );
|
|
|
|
xfree(cfx.dek);
|
|
|
|
xfree(s2k);
|
2006-12-06 11:16:50 +01:00
|
|
|
release_progress_context (pfx);
|
|
|
|
release_armor_context (afx);
|
2003-06-05 09:14:21 +02:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************
|
2016-11-29 14:41:22 +01:00
|
|
|
* Create a v4 signature in *RET_SIG.
|
|
|
|
*
|
|
|
|
* PK is the primary key to sign (required for all sigs)
|
|
|
|
* UID is the user id to sign (required for 0x10..0x13, 0x30)
|
|
|
|
* SUBPK is subkey to sign (required for 0x18, 0x19, 0x28)
|
|
|
|
*
|
|
|
|
* PKSK is the signing key
|
|
|
|
*
|
|
|
|
* SIGCLASS is the type of signature to create.
|
|
|
|
*
|
|
|
|
* DIGEST_ALGO is the digest algorithm. If it is 0 the function
|
|
|
|
* selects an appropriate one.
|
|
|
|
*
|
|
|
|
* TIMESTAMP is the timestamp to use for the signature. 0 means "now"
|
|
|
|
*
|
|
|
|
* DURATION is the amount of time (in seconds) until the signature
|
|
|
|
* expires.
|
|
|
|
*
|
|
|
|
* This function creates the following subpackets: issuer, created,
|
|
|
|
* and expire (if duration is not 0). Additional subpackets can be
|
|
|
|
* added using MKSUBPKT, which is called after these subpackets are
|
|
|
|
* added and before the signature is generated. OPAQUE is passed to
|
|
|
|
* MKSUBPKT.
|
|
|
|
*/
|
2003-06-05 09:14:21 +02:00
|
|
|
int
|
2017-03-31 20:03:52 +02:00
|
|
|
make_keysig_packet (ctrl_t ctrl,
|
|
|
|
PKT_signature **ret_sig, PKT_public_key *pk,
|
2003-06-05 09:14:21 +02:00
|
|
|
PKT_user_id *uid, PKT_public_key *subpk,
|
2010-02-02 15:06:19 +01:00
|
|
|
PKT_public_key *pksk,
|
2003-06-05 09:14:21 +02:00
|
|
|
int sigclass, int digest_algo,
|
2014-10-12 20:07:12 +02:00
|
|
|
u32 timestamp, u32 duration,
|
2010-09-01 14:49:05 +02:00
|
|
|
int (*mksubpkt)(PKT_signature *, void *), void *opaque,
|
|
|
|
const char *cache_nonce)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
|
|
|
PKT_signature *sig;
|
|
|
|
int rc=0;
|
2014-10-12 20:07:12 +02:00
|
|
|
int sigversion;
|
2006-04-19 15:24:36 +02:00
|
|
|
gcry_md_hd_t md;
|
2019-11-11 11:41:00 +01:00
|
|
|
u32 pk_keyid[2], pksk_keyid[2];
|
|
|
|
unsigned int signhints;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2016-04-29 11:05:24 +02:00
|
|
|
log_assert ((sigclass >= 0x10 && sigclass <= 0x13) || sigclass == 0x1F
|
|
|
|
|| sigclass == 0x20 || sigclass == 0x18 || sigclass == 0x19
|
|
|
|
|| sigclass == 0x30 || sigclass == 0x28 );
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
sigversion = 4;
|
2010-02-02 15:06:19 +01:00
|
|
|
if (sigversion < pksk->version)
|
|
|
|
sigversion = pksk->version;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if( !digest_algo )
|
|
|
|
{
|
2014-10-12 20:07:12 +02:00
|
|
|
/* Basically, this means use SHA1 always unless the user
|
|
|
|
specified something (use whatever they said), or it's DSA
|
|
|
|
(use the best match). They still can't pick an
|
|
|
|
inappropriate hash for DSA or the signature will fail.
|
|
|
|
Note that this still allows the caller of
|
|
|
|
make_keysig_packet to override the user setting if it
|
|
|
|
must. */
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if(opt.cert_digest_algo)
|
|
|
|
digest_algo=opt.cert_digest_algo;
|
2011-01-21 12:00:57 +01:00
|
|
|
else if(pksk->pubkey_algo == PUBKEY_ALGO_DSA)
|
|
|
|
digest_algo = match_dsa_hash (gcry_mpi_get_nbits (pksk->pkey[1])/8);
|
gpg: Use only OpenPGP public key algo ids and add the EdDSA algo id.
* common/sexputil.c (get_pk_algo_from_canon_sexp): Change to return a
string.
* g10/keygen.c (check_keygrip): Adjust for change.
* sm/certreqgen-ui.c (check_keygrip): Likewise.
* agent/pksign.c (do_encode_dsa): Remove bogus map_pk_openpgp_to_gcry.
* g10/misc.c (map_pk_openpgp_to_gcry): Remove.
(openpgp_pk_test_algo): Change to a wrapper for openpgp_pk_test_algo2.
(openpgp_pk_test_algo2): Rewrite.
(openpgp_pk_algo_usage, pubkey_nbits): Add support for EdDSA.
(openpgp_pk_algo_name): Rewrite to remove need for gcry calls.
(pubkey_get_npkey, pubkey_get_nskey): Ditto.
(pubkey_get_nsig, pubkey_get_nenc): Ditto.
* g10/keygen.c(do_create_from_keygrip): Support EdDSA.
(common_gen, gen_ecc, ask_keysize, generate_keypair): Ditto.
* g10/build-packet.c (do_key): Ditto.
* g10/export.c (transfer_format_to_openpgp): Ditto.
* g10/getkey.c (cache_public_key): Ditto.
* g10/import.c (transfer_secret_keys): Ditto.
* g10/keylist.c (list_keyblock_print, list_keyblock_colon): Ditto.
* g10/mainproc.c (proc_pubkey_enc): Ditto.
* g10/parse-packet.c (parse_key): Ditto,
* g10/sign.c (hash_for, sign_file, make_keysig_packet): Ditto.
* g10/keyserver.c (print_keyrec): Use openpgp_pk_algo_name.
* g10/pkglue.c (pk_verify, pk_encrypt, pk_check_secret_key): Use only
OpenPGP algo ids and support EdDSA.
* g10/pubkey-enc.c (get_it): Use only OpenPGP algo ids.
* g10/seskey.c (encode_md_value): Ditto.
--
This patch separates Libgcrypt and OpenPGP public key algorithms ids
and in most cases completely removes the Libgcrypt ones. This is
useful because for Libgcrypt we specify the algorithm in the
S-expressions and the public key ids are not anymore needed.
This patch also adds some support for PUBKEY_ALGO_EDDSA which will
eventually be used instead of merging EdDSA with ECDSA. As of now an
experimental algorithm id is used but the plan is to write an I-D so
that we can get a new id from the IETF. Note that EdDSA (Ed25519)
does not yet work and that more changes are required.
The ECC support is still broken right now. Needs to be fixed.
Signed-off-by: Werner Koch <wk@gnupg.org>
2014-01-30 18:48:37 +01:00
|
|
|
else if (pksk->pubkey_algo == PUBKEY_ALGO_ECDSA
|
|
|
|
|| pksk->pubkey_algo == PUBKEY_ALGO_EDDSA)
|
2013-11-15 08:59:45 +01:00
|
|
|
{
|
|
|
|
if (openpgp_oid_is_ed25519 (pksk->pkey[0]))
|
|
|
|
digest_algo = DIGEST_ALGO_SHA256;
|
|
|
|
else
|
|
|
|
digest_algo = match_dsa_hash
|
|
|
|
(ecdsa_qbits_from_Q (gcry_mpi_get_nbits (pksk->pkey[1]))/8);
|
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
else
|
2014-09-27 15:21:02 +02:00
|
|
|
digest_algo = DEFAULT_DIGEST_ALGO;
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
signhints = SIGNHINT_KEYSIG;
|
|
|
|
keyid_from_pk (pk, pk_keyid);
|
|
|
|
keyid_from_pk (pksk, pksk_keyid);
|
|
|
|
if (pk_keyid[0] == pksk_keyid[0] && pk_keyid[1] == pksk_keyid[1])
|
|
|
|
signhints |= SIGNHINT_SELFSIG;
|
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
if ( gcry_md_open (&md, digest_algo, 0 ) )
|
|
|
|
BUG ();
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
/* Hash the public key certificate. */
|
2003-06-05 09:14:21 +02:00
|
|
|
hash_public_key( md, pk );
|
2006-04-19 13:26:11 +02:00
|
|
|
|
|
|
|
if( sigclass == 0x18 || sigclass == 0x19 || sigclass == 0x28 )
|
|
|
|
{
|
|
|
|
/* hash the subkey binding/backsig/revocation */
|
2003-06-05 09:14:21 +02:00
|
|
|
hash_public_key( md, subpk );
|
2024-09-26 10:37:32 +02:00
|
|
|
if ((subpk->pubkey_usage & PUBKEY_USAGE_RENC))
|
|
|
|
signhints |= SIGNHINT_ADSK;
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
|
|
|
else if( sigclass != 0x1F && sigclass != 0x20 )
|
|
|
|
{
|
|
|
|
/* hash the user id */
|
2003-06-05 09:14:21 +02:00
|
|
|
hash_uid (md, sigversion, uid);
|
2006-04-19 13:26:11 +02:00
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
/* and make the signature packet */
|
2006-04-19 13:26:11 +02:00
|
|
|
sig = xmalloc_clear( sizeof *sig );
|
2003-06-05 09:14:21 +02:00
|
|
|
sig->version = sigversion;
|
|
|
|
sig->flags.exportable=1;
|
|
|
|
sig->flags.revocable=1;
|
2010-02-02 15:06:19 +01:00
|
|
|
keyid_from_pk (pksk, sig->keyid);
|
|
|
|
sig->pubkey_algo = pksk->pubkey_algo;
|
2003-06-05 09:14:21 +02:00
|
|
|
sig->digest_algo = digest_algo;
|
|
|
|
if(timestamp)
|
|
|
|
sig->timestamp=timestamp;
|
|
|
|
else
|
|
|
|
sig->timestamp=make_timestamp();
|
|
|
|
if(duration)
|
|
|
|
sig->expiredate=sig->timestamp+duration;
|
|
|
|
sig->sig_class = sigclass;
|
2014-10-12 20:07:12 +02:00
|
|
|
|
2024-09-26 10:37:32 +02:00
|
|
|
build_sig_subpkt_from_sig (sig, pksk, signhints);
|
2014-10-12 20:07:12 +02:00
|
|
|
mk_notation_policy_etc (sig, pk, pksk);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
/* Crucial that the call to mksubpkt comes LAST before the calls
|
|
|
|
to finalize the sig as that makes it possible for the mksubpkt
|
|
|
|
function to get a reliable pointer to the subpacket area. */
|
2014-10-12 20:07:12 +02:00
|
|
|
if (mksubpkt)
|
2003-06-05 09:14:21 +02:00
|
|
|
rc = (*mksubpkt)( sig, opaque );
|
|
|
|
|
|
|
|
if( !rc ) {
|
|
|
|
hash_sigversion_to_magic (md, sig);
|
2003-06-18 21:56:13 +02:00
|
|
|
gcry_md_final (md);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
rc = complete_sig (ctrl, sig, pksk, md, cache_nonce, signhints);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
gcry_md_close (md);
|
2003-06-05 09:14:21 +02:00
|
|
|
if( rc )
|
|
|
|
free_seckey_enc( sig );
|
|
|
|
else
|
|
|
|
*ret_sig = sig;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/****************
|
|
|
|
* Create a new signature packet based on an existing one.
|
|
|
|
* Only user ID signatures are supported for now.
|
2010-04-21 18:26:17 +02:00
|
|
|
* PK is the public key to work on.
|
|
|
|
* PKSK is the key used to make the signature.
|
|
|
|
*
|
2003-06-05 09:14:21 +02:00
|
|
|
* TODO: Merge this with make_keysig_packet.
|
|
|
|
*/
|
2015-10-01 17:59:03 +02:00
|
|
|
gpg_error_t
|
2017-03-31 20:03:52 +02:00
|
|
|
update_keysig_packet (ctrl_t ctrl,
|
|
|
|
PKT_signature **ret_sig,
|
2003-06-05 09:14:21 +02:00
|
|
|
PKT_signature *orig_sig,
|
|
|
|
PKT_public_key *pk,
|
2011-02-03 17:40:43 +01:00
|
|
|
PKT_user_id *uid,
|
2003-06-05 09:14:21 +02:00
|
|
|
PKT_public_key *subpk,
|
2010-02-02 15:06:19 +01:00
|
|
|
PKT_public_key *pksk,
|
2003-06-05 09:14:21 +02:00
|
|
|
int (*mksubpkt)(PKT_signature *, void *),
|
2010-09-01 14:49:05 +02:00
|
|
|
void *opaque)
|
2003-06-05 09:14:21 +02:00
|
|
|
{
|
|
|
|
PKT_signature *sig;
|
2015-10-01 17:59:03 +02:00
|
|
|
gpg_error_t rc = 0;
|
2012-12-19 11:47:23 +01:00
|
|
|
int digest_algo;
|
2006-04-19 15:24:36 +02:00
|
|
|
gcry_md_hd_t md;
|
2019-11-11 11:41:00 +01:00
|
|
|
u32 pk_keyid[2], pksk_keyid[2];
|
2024-09-26 10:37:32 +02:00
|
|
|
unsigned int signhints = 0;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2010-02-02 15:06:19 +01:00
|
|
|
if ((!orig_sig || !pk || !pksk)
|
2003-06-05 09:14:21 +02:00
|
|
|
|| (orig_sig->sig_class >= 0x10 && orig_sig->sig_class <= 0x13 && !uid)
|
|
|
|
|| (orig_sig->sig_class == 0x18 && !subpk))
|
2015-01-22 12:06:11 +01:00
|
|
|
return GPG_ERR_GENERAL;
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2012-02-01 03:30:05 +01:00
|
|
|
if ( opt.cert_digest_algo )
|
|
|
|
digest_algo = opt.cert_digest_algo;
|
2019-05-13 19:01:28 +02:00
|
|
|
else if (pksk->pubkey_algo == PUBKEY_ALGO_DSA
|
|
|
|
|| pksk->pubkey_algo == PUBKEY_ALGO_ECDSA
|
|
|
|
|| pksk->pubkey_algo == PUBKEY_ALGO_EDDSA)
|
|
|
|
digest_algo = orig_sig->digest_algo;
|
|
|
|
else if (orig_sig->digest_algo == DIGEST_ALGO_SHA1
|
|
|
|
|| orig_sig->digest_algo == DIGEST_ALGO_RMD160)
|
|
|
|
digest_algo = DEFAULT_DIGEST_ALGO;
|
2012-02-01 03:30:05 +01:00
|
|
|
else
|
|
|
|
digest_algo = orig_sig->digest_algo;
|
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
signhints = SIGNHINT_KEYSIG;
|
|
|
|
keyid_from_pk (pk, pk_keyid);
|
|
|
|
keyid_from_pk (pksk, pksk_keyid);
|
|
|
|
if (pk_keyid[0] == pksk_keyid[0] && pk_keyid[1] == pksk_keyid[1])
|
|
|
|
signhints |= SIGNHINT_SELFSIG;
|
|
|
|
|
2012-12-19 11:47:23 +01:00
|
|
|
if ( gcry_md_open (&md, digest_algo, 0 ) )
|
2006-04-19 13:26:11 +02:00
|
|
|
BUG ();
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2006-04-19 13:26:11 +02:00
|
|
|
/* Hash the public key certificate and the user id. */
|
2003-06-05 09:14:21 +02:00
|
|
|
hash_public_key( md, pk );
|
|
|
|
|
|
|
|
if( orig_sig->sig_class == 0x18 )
|
|
|
|
hash_public_key( md, subpk );
|
|
|
|
else
|
|
|
|
hash_uid (md, orig_sig->version, uid);
|
|
|
|
|
|
|
|
/* create a new signature packet */
|
|
|
|
sig = copy_signature (NULL, orig_sig);
|
2011-02-03 17:40:43 +01:00
|
|
|
|
2012-10-14 20:30:20 +02:00
|
|
|
sig->digest_algo=digest_algo;
|
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/* We need to create a new timestamp so that new sig expiration
|
|
|
|
calculations are done correctly... */
|
|
|
|
sig->timestamp=make_timestamp();
|
|
|
|
|
|
|
|
/* ... but we won't make a timestamp earlier than the existing
|
|
|
|
one. */
|
2015-10-01 17:59:03 +02:00
|
|
|
{
|
|
|
|
int tmout = 0;
|
|
|
|
while(sig->timestamp<=orig_sig->timestamp)
|
|
|
|
{
|
|
|
|
if (++tmout > 5 && !opt.ignore_time_conflict)
|
|
|
|
{
|
|
|
|
rc = gpg_error (GPG_ERR_TIME_CONFLICT);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
gnupg_sleep (1);
|
|
|
|
sig->timestamp=make_timestamp();
|
|
|
|
}
|
|
|
|
}
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2024-09-26 10:37:32 +02:00
|
|
|
/* Detect an ADSK key binding signature. */
|
|
|
|
if ((sig->sig_class == 0x18
|
|
|
|
|| sig->sig_class == 0x19 || sig->sig_class == 0x28)
|
|
|
|
&& (pk->pubkey_usage & PUBKEY_USAGE_RENC))
|
|
|
|
signhints |= SIGNHINT_ADSK;
|
|
|
|
|
2003-06-05 09:14:21 +02:00
|
|
|
/* Note that already expired sigs will remain expired (with a
|
2006-06-27 16:30:59 +02:00
|
|
|
duration of 1) since build-packet.c:build_sig_subpkt_from_sig
|
2003-06-05 09:14:21 +02:00
|
|
|
detects this case. */
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
/* Put the updated timestamp into the sig. Note that this will
|
|
|
|
automagically lower any sig expiration dates to correctly
|
|
|
|
correspond to the differences in the timestamps (i.e. the
|
|
|
|
duration will shrink). */
|
2024-09-26 10:37:32 +02:00
|
|
|
build_sig_subpkt_from_sig (sig, pksk, signhints);
|
2014-10-12 20:07:12 +02:00
|
|
|
|
|
|
|
if (mksubpkt)
|
|
|
|
rc = (*mksubpkt)(sig, opaque);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
|
|
|
if (!rc) {
|
|
|
|
hash_sigversion_to_magic (md, sig);
|
2006-04-19 15:24:36 +02:00
|
|
|
gcry_md_final (md);
|
2003-06-05 09:14:21 +02:00
|
|
|
|
2019-11-11 11:41:00 +01:00
|
|
|
rc = complete_sig (ctrl, sig, pksk, md, NULL, signhints);
|
2003-06-05 09:14:21 +02:00
|
|
|
}
|
|
|
|
|
2015-10-01 17:59:03 +02:00
|
|
|
leave:
|
2003-06-18 21:56:13 +02:00
|
|
|
gcry_md_close (md);
|
2003-06-05 09:14:21 +02:00
|
|
|
if( rc )
|
|
|
|
free_seckey_enc (sig);
|
|
|
|
else
|
|
|
|
*ret_sig = sig;
|
|
|
|
return rc;
|
|
|
|
}
|