2003-06-05 07:14:21 +00:00
|
|
|
|
/* keyid.c - key ID and fingerprint handling
|
2006-04-19 11:26:11 +00:00
|
|
|
|
* Copyright (C) 1998, 1999, 2000, 2001, 2003,
|
2010-04-20 17:57:50 +00:00
|
|
|
|
* 2004, 2006, 2010 Free Software Foundation, Inc.
|
2014-02-05 10:37:59 +01:00
|
|
|
|
* Copyright (C) 2014 Werner Koch
|
2003-06-05 07:14:21 +00: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 19:49:40 +00:00
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-06-05 07:14:21 +00: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
|
2007-07-04 19:49:40 +00:00
|
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2003-06-05 07:14:21 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#include <time.h>
|
|
|
|
|
#include <assert.h>
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
|
|
|
|
#include "gpg.h"
|
2003-06-05 07:14:21 +00:00
|
|
|
|
#include "util.h"
|
|
|
|
|
#include "main.h"
|
|
|
|
|
#include "packet.h"
|
|
|
|
|
#include "options.h"
|
|
|
|
|
#include "keydb.h"
|
|
|
|
|
#include "i18n.h"
|
2008-12-11 17:44:52 +00:00
|
|
|
|
#include "rmd160.h"
|
2015-02-11 10:27:57 +01:00
|
|
|
|
#include "host2net.h"
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
#define KEYID_STR_SIZE 19
|
|
|
|
|
|
2010-10-27 11:26:53 +00:00
|
|
|
|
#ifdef HAVE_UNSIGNED_TIME_T
|
|
|
|
|
# define IS_INVALID_TIME_T(a) ((a) == (time_t)(-1))
|
2011-02-02 15:48:54 +01:00
|
|
|
|
#else
|
2010-10-27 11:26:53 +00:00
|
|
|
|
/* Error or 32 bit time_t and value after 2038-01-19. */
|
|
|
|
|
# define IS_INVALID_TIME_T(a) ((a) < 0)
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
/* Return a letter describing the public key algorithms. */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
int
|
|
|
|
|
pubkey_letter( int algo )
|
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA: return 'R' ;
|
|
|
|
|
case PUBKEY_ALGO_RSA_E: return 'r' ;
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: return 's' ;
|
2011-01-21 12:00:57 +01:00
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: return 'g' ;
|
2010-09-06 19:57:42 +00:00
|
|
|
|
case PUBKEY_ALGO_ELGAMAL: return 'G' ;
|
|
|
|
|
case PUBKEY_ALGO_DSA: return 'D' ;
|
2011-01-21 12:00:57 +01:00
|
|
|
|
case PUBKEY_ALGO_ECDH: return 'e' ; /* ECC DH (encrypt only) */
|
2014-02-05 10:37:59 +01:00
|
|
|
|
case PUBKEY_ALGO_ECDSA: return 'E' ; /* ECC DSA (sign only) */
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: return 'E' ; /* ECC EdDSA (sign only) */
|
2010-09-06 19:57:42 +00:00
|
|
|
|
default: return '?';
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-05 10:37:59 +01:00
|
|
|
|
/* Return a string describing the public key algorithm and the
|
|
|
|
|
keysize. For elliptic curves the functions prints the name of the
|
|
|
|
|
curve because the keysize is a property of the curve. The string
|
|
|
|
|
is copied to the supplied buffer up a length of BUFSIZE-1.
|
|
|
|
|
Examples for the output are:
|
|
|
|
|
|
|
|
|
|
"rsa2048" - RSA with 2048 bit
|
|
|
|
|
"elg1024" - Elgamal with 1024 bit
|
|
|
|
|
"ed25519" - ECC using the curve Ed25519.
|
|
|
|
|
"E_1.2.3.4" - ECC using the unsupported curve with OID "1.2.3.4".
|
|
|
|
|
"E_1.3.6.1.4.1.11591.2.12242973" ECC with a bogus OID.
|
|
|
|
|
"unknown_N" - Unknown OpenPGP algorithm N.
|
|
|
|
|
|
|
|
|
|
If the option --legacy-list-mode is active, the output use the
|
|
|
|
|
legacy format:
|
|
|
|
|
|
|
|
|
|
"2048R" - RSA with 2048 bit
|
|
|
|
|
"1024g" - Elgamal with 1024 bit
|
|
|
|
|
"256E" - ECDSA using a curve with 256 bit
|
|
|
|
|
|
|
|
|
|
The macro PUBKEY_STRING_SIZE may be used to allocate a buffer with
|
|
|
|
|
a suitable size.*/
|
|
|
|
|
char *
|
|
|
|
|
pubkey_string (PKT_public_key *pk, char *buffer, size_t bufsize)
|
|
|
|
|
{
|
|
|
|
|
const char *prefix = NULL;
|
|
|
|
|
|
|
|
|
|
if (opt.legacy_list_mode)
|
|
|
|
|
{
|
|
|
|
|
snprintf (buffer, bufsize, "%4u%c",
|
|
|
|
|
nbits_from_pk (pk), pubkey_letter (pk->pubkey_algo));
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (pk->pubkey_algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA:
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: prefix = "rsa"; break;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: prefix = "elg"; break;
|
|
|
|
|
case PUBKEY_ALGO_DSA: prefix = "dsa"; break;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL: prefix = "xxx"; break;
|
|
|
|
|
case PUBKEY_ALGO_ECDH:
|
|
|
|
|
case PUBKEY_ALGO_ECDSA:
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: prefix = ""; break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (prefix && *prefix)
|
|
|
|
|
snprintf (buffer, bufsize, "%s%u", prefix, nbits_from_pk (pk));
|
|
|
|
|
else if (prefix)
|
|
|
|
|
{
|
|
|
|
|
char *curve = openpgp_oid_to_str (pk->pkey[0]);
|
|
|
|
|
const char *name = openpgp_oid_to_curve (curve);
|
|
|
|
|
|
|
|
|
|
if (*name && *name != '?')
|
|
|
|
|
snprintf (buffer, bufsize, "%s", name);
|
|
|
|
|
else if (curve)
|
|
|
|
|
snprintf (buffer, bufsize, "E_%s", curve);
|
|
|
|
|
else
|
|
|
|
|
snprintf (buffer, bufsize, "E_error");
|
|
|
|
|
xfree (curve);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
snprintf (buffer, bufsize, "unknown_%u", (unsigned int)pk->pubkey_algo);
|
|
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
|
|
|
|
/* Hash a public key. This function is useful for v4 fingerprints and
|
|
|
|
|
for v3 or v4 key signing. */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
void
|
2010-09-06 19:57:42 +00:00
|
|
|
|
hash_public_key (gcry_md_hd_t md, PKT_public_key *pk)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
unsigned int n = 6;
|
|
|
|
|
unsigned int nn[PUBKEY_MAX_NPKEY];
|
|
|
|
|
byte *pp[PUBKEY_MAX_NPKEY];
|
|
|
|
|
int i;
|
2006-11-21 11:00:14 +00:00
|
|
|
|
unsigned int nbits;
|
|
|
|
|
size_t nbytes;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
int npkey = pubkey_get_npkey (pk->pubkey_algo);
|
2003-07-23 07:11:06 +00:00
|
|
|
|
|
2011-02-02 15:48:54 +01:00
|
|
|
|
/* FIXME: We can avoid the extra malloc by calling only the first
|
|
|
|
|
mpi_print here which computes the required length and calling the
|
|
|
|
|
real mpi_print only at the end. The speed advantage would only be
|
|
|
|
|
for ECC (opaque MPIs) or if we could implement an mpi_print
|
|
|
|
|
variant with a callback handler to do the hashing. */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if (npkey==0 && pk->pkey[0]
|
|
|
|
|
&& gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
|
|
|
|
|
{
|
|
|
|
|
pp[0] = gcry_mpi_get_opaque (pk->pkey[0], &nbits);
|
|
|
|
|
nn[0] = (nbits+7)/8;
|
|
|
|
|
n+=nn[0];
|
|
|
|
|
}
|
|
|
|
|
else
|
2010-09-06 19:57:42 +00:00
|
|
|
|
{
|
2011-01-21 12:00:57 +01:00
|
|
|
|
for (i=0; i < npkey; i++ )
|
2010-09-06 19:57:42 +00:00
|
|
|
|
{
|
2014-06-02 19:51:23 +02:00
|
|
|
|
if (!pk->pkey[i])
|
|
|
|
|
{
|
|
|
|
|
/* This case may only happen if the parsing of the MPI
|
|
|
|
|
failed but the key was anyway created. May happen
|
|
|
|
|
during "gpg KEYFILE". */
|
|
|
|
|
pp[i] = NULL;
|
|
|
|
|
nn[i] = 0;
|
|
|
|
|
}
|
|
|
|
|
else if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
|
2011-02-02 15:48:54 +01:00
|
|
|
|
{
|
|
|
|
|
const void *p;
|
|
|
|
|
|
|
|
|
|
p = gcry_mpi_get_opaque (pk->pkey[i], &nbits);
|
|
|
|
|
pp[i] = xmalloc ((nbits+7)/8);
|
2015-02-19 16:29:58 +01:00
|
|
|
|
if (p)
|
|
|
|
|
memcpy (pp[i], p, (nbits+7)/8);
|
|
|
|
|
else
|
|
|
|
|
pp[i] = NULL;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
nn[i] = (nbits+7)/8;
|
|
|
|
|
n += nn[i];
|
|
|
|
|
}
|
2011-01-21 12:00:57 +01:00
|
|
|
|
else
|
2011-02-02 15:48:54 +01:00
|
|
|
|
{
|
|
|
|
|
if (gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0,
|
|
|
|
|
&nbytes, pk->pkey[i]))
|
|
|
|
|
BUG ();
|
|
|
|
|
pp[i] = xmalloc (nbytes);
|
|
|
|
|
if (gcry_mpi_print (GCRYMPI_FMT_PGP, pp[i], nbytes,
|
|
|
|
|
&nbytes, pk->pkey[i]))
|
|
|
|
|
BUG ();
|
|
|
|
|
nn[i] = nbytes;
|
|
|
|
|
n += nn[i];
|
|
|
|
|
}
|
2010-09-06 19:57:42 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
gcry_md_putc ( md, 0x99 ); /* ctb */
|
|
|
|
|
/* What does it mean if n is greater than than 0xFFFF ? */
|
|
|
|
|
gcry_md_putc ( md, n >> 8 ); /* 2 byte length header */
|
|
|
|
|
gcry_md_putc ( md, n );
|
|
|
|
|
gcry_md_putc ( md, pk->version );
|
|
|
|
|
|
|
|
|
|
gcry_md_putc ( md, pk->timestamp >> 24 );
|
|
|
|
|
gcry_md_putc ( md, pk->timestamp >> 16 );
|
|
|
|
|
gcry_md_putc ( md, pk->timestamp >> 8 );
|
|
|
|
|
gcry_md_putc ( md, pk->timestamp );
|
|
|
|
|
|
|
|
|
|
gcry_md_putc ( md, pk->pubkey_algo );
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if(npkey==0 && pk->pkey[0]
|
|
|
|
|
&& gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
|
|
|
|
|
{
|
2015-02-19 16:29:58 +01:00
|
|
|
|
if (pp[0])
|
|
|
|
|
gcry_md_write (md, pp[0], nn[0]);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2006-04-19 11:26:11 +00:00
|
|
|
|
else
|
2015-02-19 16:29:58 +01:00
|
|
|
|
{
|
|
|
|
|
for(i=0; i < npkey; i++ )
|
|
|
|
|
{
|
|
|
|
|
if (pp[i])
|
|
|
|
|
gcry_md_write ( md, pp[i], nn[i] );
|
|
|
|
|
xfree(pp[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
static gcry_md_hd_t
|
|
|
|
|
do_fingerprint_md( PKT_public_key *pk )
|
|
|
|
|
{
|
|
|
|
|
gcry_md_hd_t md;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if (gcry_md_open (&md, DIGEST_ALGO_SHA1, 0))
|
|
|
|
|
BUG ();
|
|
|
|
|
hash_public_key(md,pk);
|
|
|
|
|
gcry_md_final( md );
|
|
|
|
|
|
|
|
|
|
return md;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
/* fixme: Check whether we can replace this function or if not
|
|
|
|
|
describe why we need it. */
|
2003-06-18 19:56:13 +00:00
|
|
|
|
u32
|
|
|
|
|
v3_keyid (gcry_mpi_t a, u32 *ki)
|
|
|
|
|
{
|
2006-10-18 15:34:54 +00:00
|
|
|
|
byte *buffer, *p;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
size_t nbytes;
|
|
|
|
|
|
2003-07-28 08:59:18 +00:00
|
|
|
|
if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &nbytes, a ))
|
2003-06-18 19:56:13 +00:00
|
|
|
|
BUG ();
|
|
|
|
|
/* fixme: allocate it on the stack */
|
|
|
|
|
buffer = xmalloc (nbytes);
|
2003-07-28 08:59:18 +00:00
|
|
|
|
if (gcry_mpi_print( GCRYMPI_FMT_USG, buffer, nbytes, NULL, a ))
|
2003-06-18 19:56:13 +00:00
|
|
|
|
BUG ();
|
|
|
|
|
if (nbytes < 8) /* oops */
|
|
|
|
|
ki[0] = ki[1] = 0;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
else
|
2003-06-18 19:56:13 +00:00
|
|
|
|
{
|
2006-10-18 15:34:54 +00:00
|
|
|
|
p = buffer + nbytes - 8;
|
2015-02-11 10:27:57 +01:00
|
|
|
|
ki[0] = buf32_to_u32 (p);
|
2006-10-18 15:34:54 +00:00
|
|
|
|
p += 4;
|
2015-02-11 10:27:57 +01:00
|
|
|
|
ki[1] = buf32_to_u32 (p);
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
xfree (buffer);
|
|
|
|
|
return ki[1];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
size_t
|
|
|
|
|
keystrlen(void)
|
|
|
|
|
{
|
|
|
|
|
switch(opt.keyid_format)
|
|
|
|
|
{
|
|
|
|
|
case KF_SHORT:
|
|
|
|
|
return 8;
|
|
|
|
|
|
|
|
|
|
case KF_LONG:
|
|
|
|
|
return 16;
|
|
|
|
|
|
|
|
|
|
case KF_0xSHORT:
|
|
|
|
|
return 10;
|
|
|
|
|
|
|
|
|
|
case KF_0xLONG:
|
|
|
|
|
return 18;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
const char *
|
2010-08-31 15:58:39 +00:00
|
|
|
|
keystr (u32 *keyid)
|
2011-02-02 15:48:54 +01:00
|
|
|
|
{
|
2010-08-31 15:58:39 +00:00
|
|
|
|
static char keyid_str[KEYID_STR_SIZE];
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
switch (opt.keyid_format)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
case KF_SHORT:
|
2010-08-31 15:58:39 +00:00
|
|
|
|
snprintf (keyid_str, sizeof keyid_str, "%08lX", (ulong)keyid[1]);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case KF_LONG:
|
2010-08-31 15:58:39 +00:00
|
|
|
|
if (keyid[0])
|
2011-02-02 15:48:54 +01:00
|
|
|
|
snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX",
|
2010-08-31 15:58:39 +00:00
|
|
|
|
(ulong)keyid[0], (ulong)keyid[1]);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
else
|
2010-08-31 15:58:39 +00:00
|
|
|
|
snprintf (keyid_str, sizeof keyid_str, "%08lX", (ulong)keyid[1]);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case KF_0xSHORT:
|
2010-08-31 15:58:39 +00:00
|
|
|
|
snprintf (keyid_str, sizeof keyid_str, "0x%08lX", (ulong)keyid[1]);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case KF_0xLONG:
|
|
|
|
|
if(keyid[0])
|
2011-02-02 15:48:54 +01:00
|
|
|
|
snprintf (keyid_str, sizeof keyid_str, "0x%08lX%08lX",
|
2010-08-31 15:58:39 +00:00
|
|
|
|
(ulong)keyid[0],(ulong)keyid[1]);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
else
|
2010-08-31 15:58:39 +00:00
|
|
|
|
snprintf (keyid_str, sizeof keyid_str, "0x%08lX", (ulong)keyid[1]);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
break;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return keyid_str;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
keystr_with_sub (u32 *main_kid, u32 *sub_kid)
|
2011-02-02 15:48:54 +01:00
|
|
|
|
{
|
2010-08-31 15:58:39 +00:00
|
|
|
|
static char buffer[KEYID_STR_SIZE+1+KEYID_STR_SIZE];
|
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
mem2str (buffer, keystr (main_kid), KEYID_STR_SIZE);
|
2010-10-01 20:33:53 +00:00
|
|
|
|
if (sub_kid)
|
|
|
|
|
{
|
|
|
|
|
p = buffer + strlen (buffer);
|
|
|
|
|
*p++ = '/';
|
|
|
|
|
mem2str (p, keystr (sub_kid), KEYID_STR_SIZE);
|
|
|
|
|
}
|
2010-08-31 15:58:39 +00:00
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
const char *
|
|
|
|
|
keystr_from_pk(PKT_public_key *pk)
|
|
|
|
|
{
|
|
|
|
|
keyid_from_pk(pk,NULL);
|
|
|
|
|
|
|
|
|
|
return keystr(pk->keyid);
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
keystr_from_pk_with_sub (PKT_public_key *main_pk, PKT_public_key *sub_pk)
|
|
|
|
|
{
|
|
|
|
|
keyid_from_pk (main_pk, NULL);
|
2010-10-01 20:33:53 +00:00
|
|
|
|
if (sub_pk)
|
|
|
|
|
keyid_from_pk (sub_pk, NULL);
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
2010-10-01 20:33:53 +00:00
|
|
|
|
return keystr_with_sub (main_pk->keyid, sub_pk? sub_pk->keyid:NULL);
|
2010-08-31 15:58:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
const char *
|
|
|
|
|
keystr_from_desc(KEYDB_SEARCH_DESC *desc)
|
|
|
|
|
{
|
|
|
|
|
switch(desc->mode)
|
|
|
|
|
{
|
|
|
|
|
case KEYDB_SEARCH_MODE_LONG_KID:
|
|
|
|
|
case KEYDB_SEARCH_MODE_SHORT_KID:
|
|
|
|
|
return keystr(desc->u.kid);
|
|
|
|
|
|
|
|
|
|
case KEYDB_SEARCH_MODE_FPR20:
|
|
|
|
|
{
|
|
|
|
|
u32 keyid[2];
|
|
|
|
|
|
2015-02-11 10:27:57 +01:00
|
|
|
|
keyid[0] = buf32_to_u32 (desc->u.fpr+12);
|
|
|
|
|
keyid[1] = buf32_to_u32 (desc->u.fpr+16);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return keystr(keyid);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case KEYDB_SEARCH_MODE_FPR16:
|
|
|
|
|
return "?v3 fpr?";
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
BUG();
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
/*
|
2003-06-05 07:14:21 +00:00
|
|
|
|
* Get the keyid from the public key and put it into keyid
|
|
|
|
|
* if this is not NULL. Return the 32 low bits of the keyid.
|
|
|
|
|
*/
|
|
|
|
|
u32
|
2010-09-06 19:57:42 +00:00
|
|
|
|
keyid_from_pk (PKT_public_key *pk, u32 *keyid)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
u32 lowbits;
|
|
|
|
|
u32 dummy_keyid[2];
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
if (!keyid)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
keyid = dummy_keyid;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if( pk->keyid[0] || pk->keyid[1] )
|
|
|
|
|
{
|
|
|
|
|
keyid[0] = pk->keyid[0];
|
|
|
|
|
keyid[1] = pk->keyid[1];
|
|
|
|
|
lowbits = keyid[1];
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2006-04-19 11:26:11 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
const byte *dp;
|
|
|
|
|
gcry_md_hd_t md;
|
|
|
|
|
|
|
|
|
|
md = do_fingerprint_md(pk);
|
|
|
|
|
if(md)
|
|
|
|
|
{
|
|
|
|
|
dp = gcry_md_read ( md, 0 );
|
2015-02-11 10:27:57 +01:00
|
|
|
|
keyid[0] = buf32_to_u32 (dp+12);
|
|
|
|
|
keyid[1] = buf32_to_u32 (dp+16);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
lowbits = keyid[1];
|
|
|
|
|
gcry_md_close (md);
|
|
|
|
|
pk->keyid[0] = keyid[0];
|
|
|
|
|
pk->keyid[1] = keyid[1];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pk->keyid[0]=pk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return lowbits;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
/*
|
2003-06-05 07:14:21 +00:00
|
|
|
|
* Get the keyid from the fingerprint. This function is simple for most
|
|
|
|
|
* keys, but has to do a keylookup for old stayle keys.
|
|
|
|
|
*/
|
|
|
|
|
u32
|
|
|
|
|
keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
|
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
u32 dummy_keyid[2];
|
|
|
|
|
|
|
|
|
|
if( !keyid )
|
|
|
|
|
keyid = dummy_keyid;
|
|
|
|
|
|
|
|
|
|
if (fprint_len != 20)
|
|
|
|
|
{
|
|
|
|
|
/* This is special as we have to lookup the key first. */
|
|
|
|
|
PKT_public_key pk;
|
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
|
|
memset (&pk, 0, sizeof pk);
|
|
|
|
|
rc = get_pubkey_byfprint (&pk, fprint, fprint_len);
|
|
|
|
|
if( rc )
|
|
|
|
|
{
|
|
|
|
|
log_error("Oops: keyid_from_fingerprint: no pubkey\n");
|
|
|
|
|
keyid[0] = 0;
|
|
|
|
|
keyid[1] = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
keyid_from_pk (&pk, keyid);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2011-02-02 15:48:54 +01:00
|
|
|
|
else
|
2010-09-06 19:57:42 +00:00
|
|
|
|
{
|
|
|
|
|
const byte *dp = fprint;
|
2015-02-11 10:27:57 +01:00
|
|
|
|
keyid[0] = buf32_to_u32 (dp+12);
|
|
|
|
|
keyid[1] = buf32_to_u32 (dp+16);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
return keyid[1];
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
u32
|
2010-09-06 19:57:42 +00:00
|
|
|
|
keyid_from_sig (PKT_signature *sig, u32 *keyid)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2011-02-02 15:48:54 +01:00
|
|
|
|
if( keyid )
|
2010-09-06 19:57:42 +00:00
|
|
|
|
{
|
|
|
|
|
keyid[0] = sig->keyid[0];
|
|
|
|
|
keyid[1] = sig->keyid[1];
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2010-09-06 19:57:42 +00:00
|
|
|
|
return sig->keyid[1];
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
byte *
|
2010-09-06 19:57:42 +00:00
|
|
|
|
namehash_from_uid (PKT_user_id *uid)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2008-12-11 17:44:52 +00:00
|
|
|
|
if (!uid->namehash)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2008-12-11 17:44:52 +00:00
|
|
|
|
uid->namehash = xmalloc (20);
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
if (uid->attrib_data)
|
2008-12-11 17:44:52 +00:00
|
|
|
|
rmd160_hash_buffer (uid->namehash, uid->attrib_data, uid->attrib_len);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
else
|
2008-12-11 17:44:52 +00:00
|
|
|
|
rmd160_hash_buffer (uid->namehash, uid->name, uid->len);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
return uid->namehash;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
/*
|
|
|
|
|
* Return the number of bits used in PK.
|
2003-06-05 07:14:21 +00:00
|
|
|
|
*/
|
2010-09-06 19:57:42 +00:00
|
|
|
|
unsigned int
|
|
|
|
|
nbits_from_pk (PKT_public_key *pk)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
return pubkey_nbits (pk->pubkey_algo, pk->pkey);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
static const char *
|
|
|
|
|
mk_datestr (char *buffer, time_t atime)
|
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
struct tm *tp;
|
|
|
|
|
|
2010-10-27 11:26:53 +00:00
|
|
|
|
if (IS_INVALID_TIME_T (atime))
|
|
|
|
|
strcpy (buffer, "????" "-??" "-??"); /* Mark this as invalid. */
|
2011-02-02 15:48:54 +01:00
|
|
|
|
else
|
2010-09-06 19:57:42 +00:00
|
|
|
|
{
|
|
|
|
|
tp = gmtime (&atime);
|
|
|
|
|
sprintf (buffer,"%04d-%02d-%02d",
|
|
|
|
|
1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2010-09-06 19:57:42 +00:00
|
|
|
|
return buffer;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2003-06-05 07:14:21 +00:00
|
|
|
|
* return a string with the creation date of the pk
|
|
|
|
|
* Note: this is alloced in a static buffer.
|
|
|
|
|
* Format is: yyyy-mm-dd
|
|
|
|
|
*/
|
|
|
|
|
const char *
|
2010-09-06 19:57:42 +00:00
|
|
|
|
datestr_from_pk (PKT_public_key *pk)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
static char buffer[11+5];
|
|
|
|
|
time_t atime = pk->timestamp;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
return mk_datestr (buffer, atime);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *
|
2010-09-06 19:57:42 +00:00
|
|
|
|
datestr_from_sig (PKT_signature *sig )
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
static char buffer[11+5];
|
|
|
|
|
time_t atime = sig->timestamp;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
return mk_datestr (buffer, atime);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *
|
2010-09-06 19:57:42 +00:00
|
|
|
|
expirestr_from_pk (PKT_public_key *pk)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
static char buffer[11+5];
|
|
|
|
|
time_t atime;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
if (!pk->expiredate)
|
|
|
|
|
return _("never ");
|
|
|
|
|
atime = pk->expiredate;
|
|
|
|
|
return mk_datestr (buffer, atime);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
const char *
|
2010-09-06 19:57:42 +00:00
|
|
|
|
expirestr_from_sig (PKT_signature *sig)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
static char buffer[11+5];
|
|
|
|
|
time_t atime;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
if (!sig->expiredate)
|
|
|
|
|
return _("never ");
|
|
|
|
|
atime=sig->expiredate;
|
|
|
|
|
return mk_datestr (buffer, atime);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
const char *
|
|
|
|
|
revokestr_from_pk( PKT_public_key *pk )
|
|
|
|
|
{
|
2010-09-06 19:57:42 +00:00
|
|
|
|
static char buffer[11+5];
|
|
|
|
|
time_t atime;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
if(!pk->revoked.date)
|
|
|
|
|
return _("never ");
|
|
|
|
|
atime=pk->revoked.date;
|
|
|
|
|
return mk_datestr (buffer, atime);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *
|
2014-08-12 10:36:30 +02:00
|
|
|
|
usagestr_from_pk (PKT_public_key *pk, int fill)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
static char buffer[10];
|
|
|
|
|
int i = 0;
|
|
|
|
|
unsigned int use = pk->pubkey_usage;
|
|
|
|
|
|
|
|
|
|
if ( use & PUBKEY_USAGE_SIG )
|
|
|
|
|
buffer[i++] = 'S';
|
|
|
|
|
|
|
|
|
|
if ( use & PUBKEY_USAGE_CERT )
|
|
|
|
|
buffer[i++] = 'C';
|
|
|
|
|
|
|
|
|
|
if ( use & PUBKEY_USAGE_ENC )
|
|
|
|
|
buffer[i++] = 'E';
|
|
|
|
|
|
|
|
|
|
if ( (use & PUBKEY_USAGE_AUTH) )
|
|
|
|
|
buffer[i++] = 'A';
|
|
|
|
|
|
2014-08-12 10:36:30 +02:00
|
|
|
|
while (fill && i < 4)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
buffer[i++] = ' ';
|
|
|
|
|
|
|
|
|
|
buffer[i] = 0;
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
const char *
|
|
|
|
|
colon_strtime (u32 t)
|
|
|
|
|
{
|
2008-06-11 08:07:54 +00:00
|
|
|
|
static char buf[20];
|
|
|
|
|
|
|
|
|
|
if (!t)
|
|
|
|
|
return "";
|
|
|
|
|
snprintf (buf, sizeof buf, "%lu", (ulong)t);
|
|
|
|
|
return buf;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
colon_datestr_from_pk (PKT_public_key *pk)
|
|
|
|
|
{
|
2008-06-11 08:07:54 +00:00
|
|
|
|
static char buf[20];
|
|
|
|
|
|
|
|
|
|
snprintf (buf, sizeof buf, "%lu", (ulong)pk->timestamp);
|
|
|
|
|
return buf;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
colon_datestr_from_sig (PKT_signature *sig)
|
|
|
|
|
{
|
2008-06-11 08:07:54 +00:00
|
|
|
|
static char buf[20];
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2008-06-11 08:07:54 +00:00
|
|
|
|
snprintf (buf, sizeof buf, "%lu", (ulong)sig->timestamp);
|
|
|
|
|
return buf;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
colon_expirestr_from_sig (PKT_signature *sig)
|
|
|
|
|
{
|
2008-06-11 08:07:54 +00:00
|
|
|
|
static char buf[20];
|
|
|
|
|
|
|
|
|
|
if (!sig->expiredate)
|
|
|
|
|
return "";
|
|
|
|
|
|
|
|
|
|
snprintf (buf, sizeof buf,"%lu", (ulong)sig->expiredate);
|
|
|
|
|
return buf;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-09-06 19:57:42 +00:00
|
|
|
|
/*
|
2003-06-05 07:14:21 +00:00
|
|
|
|
* Return a byte array with the fingerprint for the given PK/SK
|
|
|
|
|
* The length of the array is returned in ret_len. Caller must free
|
|
|
|
|
* the array or provide an array of length MAX_FINGERPRINT_LEN.
|
|
|
|
|
*/
|
|
|
|
|
byte *
|
2010-09-06 19:57:42 +00:00
|
|
|
|
fingerprint_from_pk (PKT_public_key *pk, byte *array, size_t *ret_len)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
const byte *dp;
|
2014-10-12 20:07:12 +02:00
|
|
|
|
size_t len;
|
|
|
|
|
gcry_md_hd_t md;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2014-10-12 20:07:12 +02:00
|
|
|
|
md = do_fingerprint_md(pk);
|
|
|
|
|
dp = gcry_md_read( md, 0 );
|
|
|
|
|
len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
|
|
|
|
|
assert( len <= MAX_FINGERPRINT_LEN );
|
|
|
|
|
if (!array)
|
|
|
|
|
array = xmalloc ( len );
|
|
|
|
|
memcpy (array, dp, len );
|
2015-02-11 10:27:57 +01:00
|
|
|
|
pk->keyid[0] = buf32_to_u32 (dp+12);
|
|
|
|
|
pk->keyid[1] = buf32_to_u32 (dp+16);
|
2014-10-12 20:07:12 +02:00
|
|
|
|
gcry_md_close( md);
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2014-10-13 14:54:26 +02:00
|
|
|
|
if (ret_len)
|
|
|
|
|
*ret_len = len;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return array;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-08-16 10:47:53 +00:00
|
|
|
|
|
2014-06-25 20:25:28 +02:00
|
|
|
|
/* Return an allocated buffer with the fingerprint of PK formatted as
|
|
|
|
|
a plain hexstring. */
|
|
|
|
|
char *
|
|
|
|
|
hexfingerprint (PKT_public_key *pk)
|
|
|
|
|
{
|
|
|
|
|
unsigned char fpr[MAX_FINGERPRINT_LEN];
|
|
|
|
|
size_t len;
|
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
|
|
fingerprint_from_pk (pk, fpr, &len);
|
|
|
|
|
result = xmalloc (2 * len + 1);
|
|
|
|
|
bin2hex (fpr, len, result);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
2006-08-16 10:47:53 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the so called KEYGRIP which is the SHA-1 hash of the public
|
|
|
|
|
key parameters expressed as an canoncial encoded S-Exp. ARRAY must
|
|
|
|
|
be 20 bytes long. Returns 0 on sucess or an error code. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
keygrip_from_pk (PKT_public_key *pk, unsigned char *array)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
gcry_sexp_t s_pkey;
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
if (DBG_PACKET)
|
|
|
|
|
log_debug ("get_keygrip for public key\n");
|
|
|
|
|
|
|
|
|
|
switch (pk->pubkey_algo)
|
|
|
|
|
{
|
|
|
|
|
case GCRY_PK_DSA:
|
|
|
|
|
err = gcry_sexp_build (&s_pkey, NULL,
|
|
|
|
|
"(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
|
|
|
|
|
pk->pkey[0], pk->pkey[1],
|
|
|
|
|
pk->pkey[2], pk->pkey[3]);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case GCRY_PK_ELG:
|
|
|
|
|
case GCRY_PK_ELG_E:
|
|
|
|
|
err = gcry_sexp_build (&s_pkey, NULL,
|
|
|
|
|
"(public-key(elg(p%m)(g%m)(y%m)))",
|
|
|
|
|
pk->pkey[0], pk->pkey[1], pk->pkey[2]);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case GCRY_PK_RSA:
|
|
|
|
|
case GCRY_PK_RSA_S:
|
|
|
|
|
case GCRY_PK_RSA_E:
|
|
|
|
|
err = gcry_sexp_build (&s_pkey, NULL,
|
|
|
|
|
"(public-key(rsa(n%m)(e%m)))",
|
|
|
|
|
pk->pkey[0], pk->pkey[1]);
|
|
|
|
|
break;
|
|
|
|
|
|
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
|
|
|
|
case PUBKEY_ALGO_EDDSA:
|
2011-01-05 17:33:17 -08:00
|
|
|
|
case PUBKEY_ALGO_ECDSA:
|
|
|
|
|
case PUBKEY_ALGO_ECDH:
|
2011-01-31 09:27:06 +01:00
|
|
|
|
{
|
|
|
|
|
char *curve = openpgp_oid_to_str (pk->pkey[0]);
|
|
|
|
|
if (!curve)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = gcry_sexp_build (&s_pkey, NULL,
|
2014-04-08 11:59:39 +09:00
|
|
|
|
pk->pubkey_algo == PUBKEY_ALGO_EDDSA ?
|
|
|
|
|
"(public-key(ecc(curve%s)(flags eddsa)(q%m)))"
|
|
|
|
|
: "(public-key(ecc(curve%s)(q%m)))",
|
2011-01-31 09:27:06 +01:00
|
|
|
|
curve, pk->pkey[1]);
|
|
|
|
|
xfree (curve);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-01-05 17:33:17 -08:00
|
|
|
|
break;
|
2011-01-21 12:00:57 +01:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
default:
|
|
|
|
|
err = gpg_error (GPG_ERR_PUBKEY_ALGO);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (!gcry_pk_get_keygrip (s_pkey, array))
|
|
|
|
|
{
|
2014-10-08 21:40:34 +02:00
|
|
|
|
log_info ("error computing keygrip\n");
|
|
|
|
|
memset (array, 0, 20);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
err = gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (DBG_PACKET)
|
|
|
|
|
log_printhex ("keygrip=", array, 20);
|
|
|
|
|
/* FIXME: Save the keygrip in PK. */
|
|
|
|
|
}
|
|
|
|
|
gcry_sexp_release (s_pkey);
|
2011-02-02 15:48:54 +01:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Store an allocated buffer with the keygrip of PK encoded as a
|
|
|
|
|
hexstring at r_GRIP. Returns 0 on success. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
hexkeygrip_from_pk (PKT_public_key *pk, char **r_grip)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
unsigned char grip[20];
|
|
|
|
|
|
|
|
|
|
*r_grip = NULL;
|
|
|
|
|
err = keygrip_from_pk (pk, grip);
|
|
|
|
|
if (!err)
|
|
|
|
|
{
|
|
|
|
|
char * buf = xtrymalloc (20*2+1);
|
|
|
|
|
if (!buf)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
bin2hex (grip, 20, buf);
|
|
|
|
|
*r_grip = buf;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|