2006-04-19 11:26:11 +00:00
|
|
|
|
/* misc.c - miscellaneous functions
|
2008-10-03 20:00:46 +00:00
|
|
|
|
* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
|
2011-01-21 12:00:57 +01:00
|
|
|
|
* 2008, 2009, 2010 Free Software Foundation, Inc.
|
2014-01-31 15:33:03 +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 <unistd.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
|
|
|
|
|
#include <asm/sysinfo.h>
|
|
|
|
|
#include <asm/unistd.h>
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef HAVE_SETRLIMIT
|
|
|
|
|
#include <time.h>
|
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
#include <sys/resource.h>
|
|
|
|
|
#endif
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#ifdef ENABLE_SELINUX_HACKS
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
|
|
|
|
#include <time.h>
|
|
|
|
|
#include <process.h>
|
2014-03-07 09:46:44 +01:00
|
|
|
|
#ifdef HAVE_WINSOCK2_H
|
|
|
|
|
# include <winsock2.h>
|
|
|
|
|
#endif
|
2011-02-03 18:05:56 +01:00
|
|
|
|
#include <windows.h>
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#include <shlobj.h>
|
|
|
|
|
#ifndef CSIDL_APPDATA
|
|
|
|
|
#define CSIDL_APPDATA 0x001a
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef CSIDL_LOCAL_APPDATA
|
|
|
|
|
#define CSIDL_LOCAL_APPDATA 0x001c
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef CSIDL_FLAG_CREATE
|
|
|
|
|
#define CSIDL_FLAG_CREATE 0x8000
|
|
|
|
|
#endif
|
|
|
|
|
#endif /*HAVE_W32_SYSTEM*/
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
|
|
|
|
#include "gpg.h"
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#ifdef HAVE_W32_SYSTEM
|
2007-11-19 16:03:50 +00:00
|
|
|
|
# include "status.h"
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#endif /*HAVE_W32_SYSTEM*/
|
2003-06-05 07:14:21 +00:00
|
|
|
|
#include "util.h"
|
|
|
|
|
#include "main.h"
|
|
|
|
|
#include "photoid.h"
|
|
|
|
|
#include "options.h"
|
2006-08-16 10:47:53 +00:00
|
|
|
|
#include "call-agent.h"
|
2003-06-05 07:14:21 +00:00
|
|
|
|
#include "i18n.h"
|
|
|
|
|
|
2011-01-05 17:33:17 -08:00
|
|
|
|
#include <assert.h>
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef ENABLE_SELINUX_HACKS
|
|
|
|
|
/* A object and a global variable to keep track of files marked as
|
|
|
|
|
secured. */
|
2011-02-03 18:05:56 +01:00
|
|
|
|
struct secured_file_item
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
struct secured_file_item *next;
|
|
|
|
|
ino_t ino;
|
|
|
|
|
dev_t dev;
|
|
|
|
|
};
|
|
|
|
|
static struct secured_file_item *secured_files;
|
|
|
|
|
#endif /*ENABLE_SELINUX_HACKS*/
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* For the sake of SELinux we want to restrict access through gpg to
|
|
|
|
|
certain files we keep under our own control. This function
|
|
|
|
|
registers such a file and is_secured_file may then be used to
|
|
|
|
|
check whether a file has ben registered as secured. */
|
|
|
|
|
void
|
|
|
|
|
register_secured_file (const char *fname)
|
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_SELINUX_HACKS
|
|
|
|
|
struct stat buf;
|
|
|
|
|
struct secured_file_item *sf;
|
|
|
|
|
|
|
|
|
|
/* Note that we stop immediatley if something goes wrong here. */
|
|
|
|
|
if (stat (fname, &buf))
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_fatal (_("fstat of '%s' failed in %s: %s\n"), fname,
|
2006-04-19 11:26:11 +00:00
|
|
|
|
"register_secured_file", strerror (errno));
|
2012-06-05 19:29:22 +02:00
|
|
|
|
/* log_debug ("registering '%s' i=%lu.%lu\n", fname, */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
|
|
|
|
|
for (sf=secured_files; sf; sf = sf->next)
|
|
|
|
|
{
|
|
|
|
|
if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
|
|
|
|
|
return; /* Already registered. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sf = xmalloc (sizeof *sf);
|
|
|
|
|
sf->ino = buf.st_ino;
|
|
|
|
|
sf->dev = buf.st_dev;
|
|
|
|
|
sf->next = secured_files;
|
|
|
|
|
secured_files = sf;
|
2008-10-20 13:53:23 +00:00
|
|
|
|
#else /*!ENABLE_SELINUX_HACKS*/
|
|
|
|
|
(void)fname;
|
|
|
|
|
#endif /*!ENABLE_SELINUX_HACKS*/
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Remove a file registered as secure. */
|
|
|
|
|
void
|
|
|
|
|
unregister_secured_file (const char *fname)
|
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_SELINUX_HACKS
|
|
|
|
|
struct stat buf;
|
|
|
|
|
struct secured_file_item *sf, *sfprev;
|
|
|
|
|
|
|
|
|
|
if (stat (fname, &buf))
|
|
|
|
|
{
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error (_("fstat of '%s' failed in %s: %s\n"), fname,
|
2006-04-19 11:26:11 +00:00
|
|
|
|
"unregister_secured_file", strerror (errno));
|
|
|
|
|
return;
|
|
|
|
|
}
|
2012-06-05 19:29:22 +02:00
|
|
|
|
/* log_debug ("unregistering '%s' i=%lu.%lu\n", fname, */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
|
|
|
|
|
for (sfprev=NULL,sf=secured_files; sf; sfprev=sf, sf = sf->next)
|
|
|
|
|
{
|
|
|
|
|
if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
|
|
|
|
|
{
|
|
|
|
|
if (sfprev)
|
|
|
|
|
sfprev->next = sf->next;
|
|
|
|
|
else
|
|
|
|
|
secured_files = sf->next;
|
|
|
|
|
xfree (sf);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-10-20 13:53:23 +00:00
|
|
|
|
#else /*!ENABLE_SELINUX_HACKS*/
|
|
|
|
|
(void)fname;
|
|
|
|
|
#endif /*!ENABLE_SELINUX_HACKS*/
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return true if FD is corresponds to a secured file. Using -1 for
|
2011-02-03 18:05:56 +01:00
|
|
|
|
FS is allowed and will return false. */
|
|
|
|
|
int
|
2006-04-19 11:26:11 +00:00
|
|
|
|
is_secured_file (int fd)
|
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_SELINUX_HACKS
|
|
|
|
|
struct stat buf;
|
|
|
|
|
struct secured_file_item *sf;
|
|
|
|
|
|
|
|
|
|
if (fd == -1)
|
|
|
|
|
return 0; /* No file descriptor so it can't be secured either. */
|
|
|
|
|
|
|
|
|
|
/* Note that we print out a error here and claim that a file is
|
|
|
|
|
secure if something went wrong. */
|
|
|
|
|
if (fstat (fd, &buf))
|
|
|
|
|
{
|
2011-02-03 18:05:56 +01:00
|
|
|
|
log_error (_("fstat(%d) failed in %s: %s\n"), fd,
|
2006-04-19 11:26:11 +00:00
|
|
|
|
"is_secured_file", strerror (errno));
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
/* log_debug ("is_secured_file (%d) i=%lu.%lu\n", fd, */
|
|
|
|
|
/* (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
|
|
|
|
|
for (sf=secured_files; sf; sf = sf->next)
|
|
|
|
|
{
|
|
|
|
|
if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
|
|
|
|
|
return 1; /* Yes. */
|
|
|
|
|
}
|
2008-10-20 13:53:23 +00:00
|
|
|
|
#else /*!ENABLE_SELINUX_HACKS*/
|
|
|
|
|
(void)fd;
|
|
|
|
|
#endif /*!ENABLE_SELINUX_HACKS*/
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return 0; /* No. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return true if FNAME is corresponds to a secured file. Using NULL,
|
|
|
|
|
"" or "-" for FS is allowed and will return false. This function is
|
|
|
|
|
used before creating a file, thus it won't fail if the file does
|
2011-02-03 18:05:56 +01:00
|
|
|
|
not exist. */
|
|
|
|
|
int
|
2006-04-19 11:26:11 +00:00
|
|
|
|
is_secured_filename (const char *fname)
|
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_SELINUX_HACKS
|
|
|
|
|
struct stat buf;
|
|
|
|
|
struct secured_file_item *sf;
|
|
|
|
|
|
|
|
|
|
if (iobuf_is_pipe_filename (fname) || !*fname)
|
2011-02-03 18:05:56 +01:00
|
|
|
|
return 0;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
|
|
|
|
/* Note that we print out a error here and claim that a file is
|
|
|
|
|
secure if something went wrong. */
|
|
|
|
|
if (stat (fname, &buf))
|
|
|
|
|
{
|
|
|
|
|
if (errno == ENOENT || errno == EPERM || errno == EACCES)
|
|
|
|
|
return 0;
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error (_("fstat of '%s' failed in %s: %s\n"), fname,
|
2006-04-19 11:26:11 +00:00
|
|
|
|
"is_secured_filename", strerror (errno));
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
/* log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
|
|
|
|
|
/* (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
|
|
|
|
|
for (sf=secured_files; sf; sf = sf->next)
|
|
|
|
|
{
|
|
|
|
|
if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
|
|
|
|
|
return 1; /* Yes. */
|
|
|
|
|
}
|
2008-10-20 13:53:23 +00:00
|
|
|
|
#else /*!ENABLE_SELINUX_HACKS*/
|
|
|
|
|
(void)fname;
|
|
|
|
|
#endif /*!ENABLE_SELINUX_HACKS*/
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return 0; /* No. */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
u16
|
|
|
|
|
checksum_u16( unsigned n )
|
|
|
|
|
{
|
|
|
|
|
u16 a;
|
|
|
|
|
|
|
|
|
|
a = (n >> 8) & 0xff;
|
|
|
|
|
a += n & 0xff;
|
|
|
|
|
return a;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
u16
|
|
|
|
|
checksum( byte *p, unsigned n )
|
|
|
|
|
{
|
|
|
|
|
u16 a;
|
|
|
|
|
|
|
|
|
|
for(a=0; n; n-- )
|
|
|
|
|
a += *p++;
|
|
|
|
|
return a;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
u16
|
2006-04-19 11:26:11 +00:00
|
|
|
|
checksum_mpi (gcry_mpi_t a)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2003-06-18 19:56:13 +00:00
|
|
|
|
u16 csum;
|
|
|
|
|
byte *buffer;
|
2006-11-21 11:00:14 +00:00
|
|
|
|
size_t nbytes;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if ( gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0, &nbytes, a) )
|
2003-06-18 19:56:13 +00:00
|
|
|
|
BUG ();
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* Fixme: For numbers not in secure memory we should use a stack
|
|
|
|
|
* based buffer and only allocate a larger one if mpi_print returns
|
|
|
|
|
* an error. */
|
|
|
|
|
buffer = (gcry_is_secure(a)?
|
|
|
|
|
gcry_xmalloc_secure (nbytes) : gcry_xmalloc (nbytes));
|
|
|
|
|
if ( gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, NULL, a) )
|
2003-06-18 19:56:13 +00:00
|
|
|
|
BUG ();
|
2006-06-30 09:42:08 +00:00
|
|
|
|
csum = checksum (buffer, nbytes);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
xfree (buffer);
|
2003-06-18 19:56:13 +00:00
|
|
|
|
return csum;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
2014-01-31 15:33:03 +01:00
|
|
|
|
print_pubkey_algo_note (pubkey_algo_t algo)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if(algo >= 100 && algo <= 110)
|
|
|
|
|
{
|
|
|
|
|
static int warn=0;
|
|
|
|
|
if(!warn)
|
|
|
|
|
{
|
|
|
|
|
warn=1;
|
2014-10-09 20:57:02 +02:00
|
|
|
|
es_fflush (es_stdout);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
log_info (_("WARNING: using experimental public key algorithm %s\n"),
|
2014-05-07 13:39:28 +02:00
|
|
|
|
openpgp_pk_algo_name (algo));
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-05-07 13:39:28 +02:00
|
|
|
|
else if (algo == PUBKEY_ALGO_ELGAMAL)
|
2007-12-12 17:41:05 +00:00
|
|
|
|
{
|
2014-10-09 20:57:02 +02:00
|
|
|
|
es_fflush (es_stdout);
|
2007-12-12 17:41:05 +00:00
|
|
|
|
log_info (_("WARNING: Elgamal sign+encrypt keys are deprecated\n"));
|
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2014-01-31 15:33:03 +01:00
|
|
|
|
print_cipher_algo_note (cipher_algo_t algo)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if(algo >= 100 && algo <= 110)
|
|
|
|
|
{
|
|
|
|
|
static int warn=0;
|
|
|
|
|
if(!warn)
|
|
|
|
|
{
|
|
|
|
|
warn=1;
|
2014-10-09 20:57:02 +02:00
|
|
|
|
es_fflush (es_stdout);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
log_info (_("WARNING: using experimental cipher algorithm %s\n"),
|
2007-12-12 10:28:30 +00:00
|
|
|
|
openpgp_cipher_algo_name (algo));
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2014-01-31 15:33:03 +01:00
|
|
|
|
print_digest_algo_note (digest_algo_t algo)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2015-10-18 17:35:32 -04:00
|
|
|
|
int deprecated = 0;
|
|
|
|
|
const enum gcry_md_algos galgo = map_md_openpgp_to_gcry (algo);
|
|
|
|
|
const struct weakhash *weak;
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if(algo >= 100 && algo <= 110)
|
|
|
|
|
{
|
|
|
|
|
static int warn=0;
|
|
|
|
|
if(!warn)
|
|
|
|
|
{
|
|
|
|
|
warn=1;
|
2014-10-09 20:57:02 +02:00
|
|
|
|
es_fflush (es_stdout);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
log_info (_("WARNING: using experimental digest algorithm %s\n"),
|
2015-10-18 17:35:32 -04:00
|
|
|
|
gcry_md_algo_name (galgo));
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-10-18 17:35:32 -04:00
|
|
|
|
else if(algo == DIGEST_ALGO_MD5)
|
|
|
|
|
deprecated = 1;
|
|
|
|
|
else
|
|
|
|
|
for (weak = opt.additional_weak_digests; weak != NULL; weak = weak->next)
|
|
|
|
|
if (weak->algo == galgo)
|
|
|
|
|
deprecated = 1;
|
|
|
|
|
|
|
|
|
|
if (deprecated)
|
2014-10-09 20:57:02 +02:00
|
|
|
|
{
|
|
|
|
|
es_fflush (es_stdout);
|
|
|
|
|
log_info (_("WARNING: digest algorithm %s is deprecated\n"),
|
2015-10-18 17:35:32 -04:00
|
|
|
|
gcry_md_algo_name (galgo));
|
2014-10-09 20:57:02 +02:00
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
|
2014-08-12 10:36:30 +02:00
|
|
|
|
void
|
2015-10-19 10:41:23 -04:00
|
|
|
|
print_digest_rejected_note (enum gcry_md_algos algo)
|
2014-08-12 10:36:30 +02:00
|
|
|
|
{
|
|
|
|
|
static int shown;
|
|
|
|
|
|
|
|
|
|
if (!shown)
|
|
|
|
|
{
|
2014-10-09 20:57:02 +02:00
|
|
|
|
es_fflush (es_stdout);
|
2014-08-12 10:36:30 +02:00
|
|
|
|
log_info
|
|
|
|
|
(_("Note: signatures using the %s algorithm are rejected\n"),
|
2015-10-19 10:41:23 -04:00
|
|
|
|
gcry_md_algo_name(algo));
|
2014-08-12 10:36:30 +02:00
|
|
|
|
shown = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
/* Map OpenPGP algo numbers to those used by Libgcrypt. We need to do
|
|
|
|
|
this for algorithms we implemented in Libgcrypt after they become
|
|
|
|
|
part of OpenPGP. */
|
2014-01-31 14:35:49 +01:00
|
|
|
|
enum gcry_cipher_algos
|
|
|
|
|
map_cipher_openpgp_to_gcry (cipher_algo_t algo)
|
2007-12-12 10:28:30 +00:00
|
|
|
|
{
|
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_NONE: return GCRY_CIPHER_NONE;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_IDEA
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_IDEA: return GCRY_CIPHER_IDEA;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_IDEA: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_3DES: return GCRY_CIPHER_3DES;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_CAST5
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_CAST5: return GCRY_CIPHER_CAST5;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_CAST5: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_BLOWFISH
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_BLOWFISH: return GCRY_CIPHER_BLOWFISH;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_BLOWFISH: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_AES128
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_AES: return GCRY_CIPHER_AES;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_AES: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_AES192
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_AES192: return GCRY_CIPHER_AES192;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_AES192: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_AES256
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_AES256: return GCRY_CIPHER_AES256;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_AES256: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_TWOFISH
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_TWOFISH: return GCRY_CIPHER_TWOFISH;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_TWOFISH: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_CAMELLIA128
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_CAMELLIA128: return GCRY_CIPHER_CAMELLIA128;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA128: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_CAMELLIA192
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_CAMELLIA192: return GCRY_CIPHER_CAMELLIA192;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA192: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_CAMELLIA256
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_CAMELLIA256: return GCRY_CIPHER_CAMELLIA256;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA256: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2007-12-12 10:28:30 +00:00
|
|
|
|
}
|
2014-01-31 14:35:49 +01:00
|
|
|
|
return 0;
|
2007-12-12 10:28:30 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-31 14:35:49 +01:00
|
|
|
|
/* The inverse function of above. */
|
|
|
|
|
static cipher_algo_t
|
|
|
|
|
map_cipher_gcry_to_openpgp (enum gcry_cipher_algos algo)
|
2007-12-12 10:28:30 +00:00
|
|
|
|
{
|
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case GCRY_CIPHER_NONE: return CIPHER_ALGO_NONE;
|
|
|
|
|
case GCRY_CIPHER_IDEA: return CIPHER_ALGO_IDEA;
|
|
|
|
|
case GCRY_CIPHER_3DES: return CIPHER_ALGO_3DES;
|
|
|
|
|
case GCRY_CIPHER_CAST5: return CIPHER_ALGO_CAST5;
|
|
|
|
|
case GCRY_CIPHER_BLOWFISH: return CIPHER_ALGO_BLOWFISH;
|
|
|
|
|
case GCRY_CIPHER_AES: return CIPHER_ALGO_AES;
|
|
|
|
|
case GCRY_CIPHER_AES192: return CIPHER_ALGO_AES192;
|
|
|
|
|
case GCRY_CIPHER_AES256: return CIPHER_ALGO_AES256;
|
|
|
|
|
case GCRY_CIPHER_TWOFISH: return CIPHER_ALGO_TWOFISH;
|
|
|
|
|
case GCRY_CIPHER_CAMELLIA128: return CIPHER_ALGO_CAMELLIA128;
|
|
|
|
|
case GCRY_CIPHER_CAMELLIA192: return CIPHER_ALGO_CAMELLIA192;
|
|
|
|
|
case GCRY_CIPHER_CAMELLIA256: return CIPHER_ALGO_CAMELLIA256;
|
|
|
|
|
default: return 0;
|
2007-12-12 10:28:30 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
/* Map Gcrypt public key algorithm numbers to those used by OpenPGP.
|
|
|
|
|
FIXME: This mapping is used at only two places - we should get rid
|
|
|
|
|
of it. */
|
2014-01-31 14:35:49 +01:00
|
|
|
|
pubkey_algo_t
|
2011-01-31 09:27:06 +01:00
|
|
|
|
map_pk_gcry_to_openpgp (enum gcry_pk_algos algo)
|
|
|
|
|
{
|
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case GCRY_PK_ECDSA: return PUBKEY_ALGO_ECDSA;
|
|
|
|
|
case GCRY_PK_ECDH: return PUBKEY_ALGO_ECDH;
|
|
|
|
|
default: return algo < 110 ? algo : 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-18 09:20:25 +00:00
|
|
|
|
|
|
|
|
|
/* Return the block length of an OpenPGP cipher algorithm. */
|
2011-02-03 18:05:56 +01:00
|
|
|
|
int
|
2014-01-31 14:35:49 +01:00
|
|
|
|
openpgp_cipher_blocklen (cipher_algo_t algo)
|
2008-04-18 09:20:25 +00:00
|
|
|
|
{
|
|
|
|
|
/* We use the numbers from OpenPGP to be sure that we get the right
|
|
|
|
|
block length. This is so that the packet parsing code works even
|
|
|
|
|
for unknown algorithms (for which we assume 8 due to tradition).
|
|
|
|
|
|
|
|
|
|
NOTE: If you change the the returned blocklen above 16, check
|
|
|
|
|
the callers because they may use a fixed size buffer of that
|
|
|
|
|
size. */
|
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
2014-01-31 14:35:49 +01:00
|
|
|
|
case CIPHER_ALGO_AES:
|
|
|
|
|
case CIPHER_ALGO_AES192:
|
|
|
|
|
case CIPHER_ALGO_AES256:
|
|
|
|
|
case CIPHER_ALGO_TWOFISH:
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA128:
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA192:
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA256:
|
2008-04-18 09:20:25 +00:00
|
|
|
|
return 16;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return 8;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
/****************
|
2006-04-19 11:26:11 +00:00
|
|
|
|
* Wrapper around the libgcrypt function with additonal checks on
|
|
|
|
|
* the OpenPGP contraints for the algo ID.
|
2003-06-05 07:14:21 +00:00
|
|
|
|
*/
|
|
|
|
|
int
|
2014-01-31 14:35:49 +01:00
|
|
|
|
openpgp_cipher_test_algo (cipher_algo_t algo)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2014-01-31 14:35:49 +01:00
|
|
|
|
enum gcry_cipher_algos ga;
|
|
|
|
|
|
|
|
|
|
ga = map_cipher_openpgp_to_gcry (algo);
|
|
|
|
|
if (!ga)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return gpg_error (GPG_ERR_CIPHER_ALGO);
|
2007-12-12 10:28:30 +00:00
|
|
|
|
|
2014-01-31 14:35:49 +01:00
|
|
|
|
return gcry_cipher_test_algo (ga);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
/* Map the OpenPGP cipher algorithm whose ID is contained in ALGORITHM to a
|
|
|
|
|
string representation of the algorithm name. For unknown algorithm
|
|
|
|
|
IDs this function returns "?". */
|
|
|
|
|
const char *
|
2014-01-31 14:35:49 +01:00
|
|
|
|
openpgp_cipher_algo_name (cipher_algo_t algo)
|
2007-12-12 10:28:30 +00:00
|
|
|
|
{
|
2014-01-31 14:35:49 +01:00
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case CIPHER_ALGO_NONE: break;
|
|
|
|
|
case CIPHER_ALGO_IDEA: return "IDEA";
|
|
|
|
|
case CIPHER_ALGO_3DES: return "3DES";
|
|
|
|
|
case CIPHER_ALGO_CAST5: return "CAST5";
|
|
|
|
|
case CIPHER_ALGO_BLOWFISH: return "BLOWFISH";
|
|
|
|
|
case CIPHER_ALGO_AES: return "AES";
|
|
|
|
|
case CIPHER_ALGO_AES192: return "AES192";
|
|
|
|
|
case CIPHER_ALGO_AES256: return "AES256";
|
|
|
|
|
case CIPHER_ALGO_TWOFISH: return "TWOFISH";
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA128: return "CAMELLIA128";
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA192: return "CAMELLIA192";
|
|
|
|
|
case CIPHER_ALGO_CAMELLIA256: return "CAMELLIA256";
|
|
|
|
|
}
|
|
|
|
|
return "?";
|
2007-12-12 10:28:30 +00:00
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
/* Return 0 if ALGO is a supported OpenPGP public key algorithm. */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
int
|
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
|
|
|
|
openpgp_pk_test_algo (pubkey_algo_t algo)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
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
|
|
|
|
return openpgp_pk_test_algo2 (algo, 0);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
/* Return 0 if ALGO is a supported OpenPGP public key algorithm and
|
|
|
|
|
allows the usage USE. */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
int
|
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
|
|
|
|
openpgp_pk_test_algo2 (pubkey_algo_t algo, unsigned int use)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
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
|
|
|
|
enum gcry_pk_algos ga = 0;
|
2006-11-21 11:00:14 +00:00
|
|
|
|
size_t use_buf = use;
|
2006-05-23 16:19:43 +00:00
|
|
|
|
|
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
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_RSA
|
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_RSA: ga = GCRY_PK_RSA; break;
|
|
|
|
|
case PUBKEY_ALGO_RSA_E: ga = GCRY_PK_RSA_E; break;
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: ga = GCRY_PK_RSA_S; break;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case PUBKEY_ALGO_RSA: break;
|
|
|
|
|
case PUBKEY_ALGO_RSA_E: break;
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: break;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
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_ELGAMAL_E: ga = GCRY_PK_ELG; break;
|
|
|
|
|
case PUBKEY_ALGO_DSA: ga = GCRY_PK_DSA; break;
|
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_ECDH
|
|
|
|
|
case PUBKEY_ALGO_ECDH: ga = GCRY_PK_ECC; break;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case PUBKEY_ALGO_ECDH: break;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_ECDSA
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: ga = GCRY_PK_ECC; break;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: break;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_EDDSA
|
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: ga = GCRY_PK_ECC; break;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: break;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
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_ELGAMAL:
|
|
|
|
|
/* Dont't allow type 20 keys unless in rfc2440 mode. */
|
|
|
|
|
if (RFC2440)
|
|
|
|
|
ga = GCRY_PK_ELG;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (!ga)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return gpg_error (GPG_ERR_PUBKEY_ALGO);
|
2006-05-23 16:19:43 +00:00
|
|
|
|
|
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
|
|
|
|
/* No check whether Libgcrypt has support for the algorithm. */
|
|
|
|
|
return gcry_pk_algo_info (ga, GCRYCTL_TEST_ALGO, NULL, &use_buf);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
|
2011-02-03 18:05:56 +01:00
|
|
|
|
int
|
2003-06-05 07:14:21 +00:00
|
|
|
|
openpgp_pk_algo_usage ( int algo )
|
|
|
|
|
{
|
2011-02-03 18:05:56 +01:00
|
|
|
|
int use = 0;
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* They are hardwired in gpg 1.0. */
|
2011-02-03 18:05:56 +01:00
|
|
|
|
switch ( algo ) {
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case PUBKEY_ALGO_RSA:
|
2006-04-19 11:26:11 +00:00
|
|
|
|
use = (PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG
|
|
|
|
|
| PUBKEY_USAGE_ENC | PUBKEY_USAGE_AUTH);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
break;
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
2011-01-05 17:33:17 -08:00
|
|
|
|
case PUBKEY_ALGO_ECDH:
|
2003-06-05 07:14:21 +00:00
|
|
|
|
use = PUBKEY_USAGE_ENC;
|
|
|
|
|
break;
|
|
|
|
|
case PUBKEY_ALGO_RSA_S:
|
2006-04-19 11:26:11 +00:00
|
|
|
|
use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
break;
|
2007-12-10 15:19:34 +00:00
|
|
|
|
case PUBKEY_ALGO_ELGAMAL:
|
2007-12-12 17:41:05 +00:00
|
|
|
|
if (RFC2440)
|
|
|
|
|
use = PUBKEY_USAGE_ENC;
|
|
|
|
|
break;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E:
|
|
|
|
|
use = PUBKEY_USAGE_ENC;
|
|
|
|
|
break;
|
2011-02-03 18:05:56 +01:00
|
|
|
|
case PUBKEY_ALGO_DSA:
|
2006-04-19 11:26:11 +00:00
|
|
|
|
use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
break;
|
2011-01-05 17:33:17 -08:00
|
|
|
|
case PUBKEY_ALGO_ECDSA:
|
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
|
|
|
|
use = PUBKEY_USAGE_CERT | PUBKEY_USAGE_SIG | PUBKEY_USAGE_AUTH;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return use;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
/* Map the OpenPGP pubkey algorithm whose ID is contained in ALGO to a
|
|
|
|
|
string representation of the algorithm name. For unknown algorithm
|
2011-01-21 12:00:57 +01:00
|
|
|
|
IDs this function returns "?". */
|
2010-08-31 15:58:39 +00:00
|
|
|
|
const char *
|
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
|
|
|
|
openpgp_pk_algo_name (pubkey_algo_t algo)
|
2010-08-31 15:58:39 +00:00
|
|
|
|
{
|
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
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA:
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: return "RSA";
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL:
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: return "ELG";
|
|
|
|
|
case PUBKEY_ALGO_DSA: return "DSA";
|
2014-01-31 15:55:04 +01:00
|
|
|
|
case PUBKEY_ALGO_ECDH: return "ECDH";
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: return "ECDSA";
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: return "EDDSA";
|
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
|
|
|
|
}
|
|
|
|
|
return "?";
|
2010-08-31 15:58:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-01-31 15:33:03 +01:00
|
|
|
|
/* Explicit mapping of OpenPGP digest algos to Libgcrypt. */
|
|
|
|
|
/* FIXME: We do not yes use it everywhere. */
|
|
|
|
|
enum gcry_md_algos
|
|
|
|
|
map_md_openpgp_to_gcry (digest_algo_t algo)
|
|
|
|
|
{
|
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_MD5
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_MD5: return GCRY_MD_MD5;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case DIGEST_ALGO_MD5: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_SHA1: return GCRY_MD_SHA1;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_RMD160
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_RMD160: return GCRY_MD_RMD160;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case DIGEST_ALGO_RMD160: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_SHA224
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_SHA224: return GCRY_MD_SHA224;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case DIGEST_ALGO_SHA224: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_SHA256: return GCRY_MD_SHA256;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#ifdef GPG_USE_SHA384
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_SHA384: return GCRY_MD_SHA384;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case DIGEST_ALGO_SHA384: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-02-07 09:24:52 +01:00
|
|
|
|
|
|
|
|
|
#ifdef GPG_USE_SHA512
|
2014-01-31 15:33:03 +01:00
|
|
|
|
case DIGEST_ALGO_SHA512: return GCRY_MD_SHA512;
|
2014-02-07 09:24:52 +01:00
|
|
|
|
#else
|
|
|
|
|
case DIGEST_ALGO_SHA512: return 0;
|
2014-01-31 22:47:11 +01:00
|
|
|
|
#endif
|
2014-01-31 15:33:03 +01:00
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return 0 if ALGO is suitable and implemented OpenPGP hash
|
2014-01-31 22:47:11 +01:00
|
|
|
|
algorithm. */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
int
|
2014-01-31 15:33:03 +01:00
|
|
|
|
openpgp_md_test_algo (digest_algo_t algo)
|
|
|
|
|
{
|
|
|
|
|
enum gcry_md_algos ga;
|
|
|
|
|
|
|
|
|
|
ga = map_md_openpgp_to_gcry (algo);
|
|
|
|
|
if (!ga)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return gpg_error (GPG_ERR_DIGEST_ALGO);
|
2014-01-31 15:33:03 +01:00
|
|
|
|
|
|
|
|
|
return gcry_md_test_algo (ga);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
/* Map the OpenPGP digest algorithm whose ID is contained in ALGO to a
|
|
|
|
|
string representation of the algorithm name. For unknown algorithm
|
|
|
|
|
IDs this function returns "?". */
|
|
|
|
|
const char *
|
2011-02-03 18:05:56 +01:00
|
|
|
|
openpgp_md_algo_name (int algo)
|
2010-08-31 15:58:39 +00:00
|
|
|
|
{
|
2014-01-31 15:33:03 +01:00
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case DIGEST_ALGO_MD5: return "MD5";
|
|
|
|
|
case DIGEST_ALGO_SHA1: return "SHA1";
|
|
|
|
|
case DIGEST_ALGO_RMD160: return "RIPEMD160";
|
|
|
|
|
case DIGEST_ALGO_SHA256: return "SHA256";
|
|
|
|
|
case DIGEST_ALGO_SHA384: return "SHA384";
|
|
|
|
|
case DIGEST_ALGO_SHA512: return "SHA512";
|
|
|
|
|
case DIGEST_ALGO_SHA224: return "SHA224";
|
|
|
|
|
}
|
|
|
|
|
return "?";
|
2010-08-31 15:58:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-02-03 18:05:56 +01:00
|
|
|
|
static unsigned long
|
2010-02-02 14:06:19 +00:00
|
|
|
|
get_signature_count (PKT_public_key *pk)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
#ifdef ENABLE_CARD_SUPPORT
|
2010-11-17 13:21:24 +00:00
|
|
|
|
struct agent_card_info_s info;
|
2011-03-03 12:57:31 +01:00
|
|
|
|
|
|
|
|
|
(void)pk;
|
2010-11-17 13:21:24 +00:00
|
|
|
|
if (!agent_scd_getattr ("SIG-COUNTER",&info))
|
|
|
|
|
return info.sig_counter;
|
|
|
|
|
else
|
|
|
|
|
return 0;
|
2010-10-13 15:57:08 +00:00
|
|
|
|
#else
|
|
|
|
|
(void)pk;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return 0;
|
2010-10-13 15:57:08 +00:00
|
|
|
|
#endif
|
2006-04-19 11:26:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Expand %-strings. Returns a string which must be xfreed. Returns
|
2003-06-05 07:14:21 +00:00
|
|
|
|
NULL if the string cannot be expanded (too large). */
|
|
|
|
|
char *
|
|
|
|
|
pct_expando(const char *string,struct expando_args *args)
|
|
|
|
|
{
|
|
|
|
|
const char *ch=string;
|
|
|
|
|
int idx=0,maxlen=0,done=0;
|
|
|
|
|
u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
|
|
|
|
|
char *ret=NULL;
|
|
|
|
|
|
|
|
|
|
if(args->pk)
|
|
|
|
|
keyid_from_pk(args->pk,pk_keyid);
|
|
|
|
|
|
2010-02-02 14:06:19 +00:00
|
|
|
|
if(args->pksk)
|
|
|
|
|
keyid_from_pk (args->pksk, sk_keyid);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2003-09-23 17:48:33 +00:00
|
|
|
|
/* This is used so that %k works in photoid command strings in
|
|
|
|
|
--list-secret-keys (which of course has a sk, but no pk). */
|
2010-02-02 14:06:19 +00:00
|
|
|
|
if(!args->pk && args->pksk)
|
|
|
|
|
keyid_from_pk (args->pksk, pk_keyid);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
while(*ch!='\0')
|
|
|
|
|
{
|
|
|
|
|
if(!done)
|
|
|
|
|
{
|
|
|
|
|
/* 8192 is way bigger than we'll need here */
|
|
|
|
|
if(maxlen>=8192)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
|
|
maxlen+=1024;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
ret=xrealloc(ret,maxlen);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
done=0;
|
|
|
|
|
|
|
|
|
|
if(*ch=='%')
|
|
|
|
|
{
|
|
|
|
|
switch(*(ch+1))
|
|
|
|
|
{
|
|
|
|
|
case 's': /* short key id */
|
|
|
|
|
if(idx+8<maxlen)
|
|
|
|
|
{
|
|
|
|
|
sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
|
|
|
|
|
idx+=8;
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'S': /* long key id */
|
|
|
|
|
if(idx+16<maxlen)
|
|
|
|
|
{
|
|
|
|
|
sprintf(&ret[idx],"%08lX%08lX",
|
|
|
|
|
(ulong)sk_keyid[0],(ulong)sk_keyid[1]);
|
|
|
|
|
idx+=16;
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'k': /* short key id */
|
|
|
|
|
if(idx+8<maxlen)
|
|
|
|
|
{
|
|
|
|
|
sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
|
|
|
|
|
idx+=8;
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'K': /* long key id */
|
|
|
|
|
if(idx+16<maxlen)
|
|
|
|
|
{
|
|
|
|
|
sprintf(&ret[idx],"%08lX%08lX",
|
|
|
|
|
(ulong)pk_keyid[0],(ulong)pk_keyid[1]);
|
|
|
|
|
idx+=16;
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2014-04-15 16:40:48 +02:00
|
|
|
|
case 'U': /* z-base-32 encoded user id hash. */
|
|
|
|
|
if (args->namehash)
|
|
|
|
|
{
|
|
|
|
|
char *tmp = zb32_encode (args->namehash, 8*20);
|
|
|
|
|
if (tmp)
|
|
|
|
|
{
|
|
|
|
|
if (idx + strlen (tmp) < maxlen)
|
|
|
|
|
{
|
|
|
|
|
strcpy (ret+idx, tmp);
|
|
|
|
|
idx += strlen (tmp);
|
|
|
|
|
}
|
|
|
|
|
xfree (tmp);
|
|
|
|
|
done = 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
case 'c': /* signature count from card, if any. */
|
|
|
|
|
if(idx+10<maxlen)
|
|
|
|
|
{
|
2010-02-02 14:06:19 +00:00
|
|
|
|
sprintf (&ret[idx],"%lu", get_signature_count (args->pksk));
|
2006-04-19 11:26:11 +00:00
|
|
|
|
idx+=strlen(&ret[idx]);
|
|
|
|
|
done=1;
|
2011-02-03 18:05:56 +01:00
|
|
|
|
}
|
2006-04-19 11:26:11 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2014-12-15 09:50:19 +01:00
|
|
|
|
case 'f': /* Fingerprint of key being signed */
|
|
|
|
|
case 'p': /* Fingerprint of the primary key making the signature. */
|
|
|
|
|
case 'g': /* Fingerprint of thge key making the signature. */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
|
|
|
|
byte array[MAX_FINGERPRINT_LEN];
|
|
|
|
|
size_t len;
|
|
|
|
|
int i;
|
|
|
|
|
|
2014-12-15 09:50:19 +01:00
|
|
|
|
if ((*(ch+1))=='f' && args->pk)
|
|
|
|
|
fingerprint_from_pk (args->pk, array, &len);
|
|
|
|
|
else if ((*(ch+1))=='p' && args->pksk)
|
2003-09-23 17:48:33 +00:00
|
|
|
|
{
|
2010-10-20 11:33:50 +00:00
|
|
|
|
if(args->pksk->flags.primary)
|
2010-02-02 14:06:19 +00:00
|
|
|
|
fingerprint_from_pk (args->pksk, array, &len);
|
|
|
|
|
else if (args->pksk->main_keyid[0]
|
|
|
|
|
|| args->pksk->main_keyid[1])
|
2003-09-23 17:48:33 +00:00
|
|
|
|
{
|
2014-12-15 09:50:19 +01:00
|
|
|
|
/* Not the primary key: Find the fingerprint
|
|
|
|
|
of the primary key. */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
PKT_public_key *pk=
|
|
|
|
|
xmalloc_clear(sizeof(PKT_public_key));
|
2003-09-23 17:48:33 +00:00
|
|
|
|
|
2010-02-02 14:06:19 +00:00
|
|
|
|
if (!get_pubkey_fast (pk,args->pksk->main_keyid))
|
|
|
|
|
fingerprint_from_pk (pk, array, &len);
|
2003-09-23 17:48:33 +00:00
|
|
|
|
else
|
2010-02-02 14:06:19 +00:00
|
|
|
|
memset (array, 0, (len=MAX_FINGERPRINT_LEN));
|
|
|
|
|
free_public_key (pk);
|
2003-09-23 17:48:33 +00:00
|
|
|
|
}
|
2014-12-15 09:50:19 +01:00
|
|
|
|
else /* Oops: info about the primary key missing. */
|
2003-09-23 17:48:33 +00:00
|
|
|
|
memset(array,0,(len=MAX_FINGERPRINT_LEN));
|
|
|
|
|
}
|
2010-02-02 14:06:19 +00:00
|
|
|
|
else if((*(ch+1))=='g' && args->pksk)
|
|
|
|
|
fingerprint_from_pk (args->pksk, array, &len);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
else
|
2006-04-19 11:26:11 +00:00
|
|
|
|
memset(array,0,(len=MAX_FINGERPRINT_LEN));
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
if(idx+(len*2)<maxlen)
|
|
|
|
|
{
|
|
|
|
|
for(i=0;i<len;i++)
|
|
|
|
|
{
|
|
|
|
|
sprintf(&ret[idx],"%02X",array[i]);
|
|
|
|
|
idx+=2;
|
|
|
|
|
}
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2008-10-03 20:00:46 +00:00
|
|
|
|
case 'v': /* validity letters */
|
|
|
|
|
if(args->validity_info && idx+1<maxlen)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2008-10-03 20:00:46 +00:00
|
|
|
|
ret[idx++]=args->validity_info;
|
|
|
|
|
ret[idx]='\0';
|
2003-06-05 07:14:21 +00:00
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2008-10-03 20:00:46 +00:00
|
|
|
|
/* The text string types */
|
|
|
|
|
case 't':
|
|
|
|
|
case 'T':
|
|
|
|
|
case 'V':
|
|
|
|
|
{
|
|
|
|
|
const char *str=NULL;
|
|
|
|
|
|
|
|
|
|
switch(*(ch+1))
|
|
|
|
|
{
|
|
|
|
|
case 't': /* e.g. "jpg" */
|
|
|
|
|
str=image_type_to_string(args->imagetype,0);
|
|
|
|
|
break;
|
2011-02-03 18:05:56 +01:00
|
|
|
|
|
2008-10-03 20:00:46 +00:00
|
|
|
|
case 'T': /* e.g. "image/jpeg" */
|
|
|
|
|
str=image_type_to_string(args->imagetype,2);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'V': /* e.g. "full", "expired", etc. */
|
|
|
|
|
str=args->validity_string;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(str && idx+strlen(str)<maxlen)
|
|
|
|
|
{
|
|
|
|
|
strcpy(&ret[idx],str);
|
|
|
|
|
idx+=strlen(str);
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case '%':
|
|
|
|
|
if(idx+1<maxlen)
|
|
|
|
|
{
|
|
|
|
|
ret[idx++]='%';
|
|
|
|
|
ret[idx]='\0';
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* Any unknown %-keys (like %i, %o, %I, and %O) are
|
|
|
|
|
passed through for later expansion. Note this also
|
|
|
|
|
handles the case where the last character in the
|
|
|
|
|
string is a '%' - the terminating \0 will end up here
|
|
|
|
|
and properly terminate the string. */
|
|
|
|
|
default:
|
|
|
|
|
if(idx+2<maxlen)
|
|
|
|
|
{
|
|
|
|
|
ret[idx++]='%';
|
|
|
|
|
ret[idx++]=*(ch+1);
|
|
|
|
|
ret[idx]='\0';
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(done)
|
|
|
|
|
ch++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if(idx+1<maxlen)
|
|
|
|
|
{
|
|
|
|
|
ret[idx++]=*ch;
|
|
|
|
|
ret[idx]='\0';
|
|
|
|
|
done=1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(done)
|
|
|
|
|
ch++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
fail:
|
2006-04-19 11:26:11 +00:00
|
|
|
|
xfree(ret);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
deprecated_warning(const char *configname,unsigned int configlineno,
|
|
|
|
|
const char *option,const char *repl1,const char *repl2)
|
|
|
|
|
{
|
|
|
|
|
if(configname)
|
|
|
|
|
{
|
|
|
|
|
if(strncmp("--",option,2)==0)
|
|
|
|
|
option+=2;
|
|
|
|
|
|
|
|
|
|
if(strncmp("--",repl1,2)==0)
|
|
|
|
|
repl1+=2;
|
|
|
|
|
|
|
|
|
|
log_info(_("%s:%d: deprecated option \"%s\"\n"),
|
|
|
|
|
configname,configlineno,option);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
|
|
|
|
|
|
|
|
|
|
log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
deprecated_command (const char *name)
|
|
|
|
|
{
|
|
|
|
|
log_info(_("WARNING: \"%s\" is a deprecated command - do not use it\n"),
|
|
|
|
|
name);
|
2007-01-30 20:16:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-09-25 14:45:37 -04:00
|
|
|
|
void
|
|
|
|
|
obsolete_scdaemon_option (const char *configname, unsigned int configlineno,
|
|
|
|
|
const char *name)
|
|
|
|
|
{
|
|
|
|
|
if (configname)
|
|
|
|
|
log_info (_("%s:%u: \"%s\" is obsolete in this file"
|
|
|
|
|
" - it only has effect in %s\n"),
|
|
|
|
|
configname, configlineno, name, SCDAEMON_NAME EXTSEP_S "conf");
|
|
|
|
|
else
|
2014-09-25 22:13:03 +02:00
|
|
|
|
log_info (_("WARNING: \"%s%s\" is an obsolete option"
|
|
|
|
|
" - it has no effect except on %s\n"),
|
|
|
|
|
"--", name, SCDAEMON_NAME);
|
2014-09-25 14:45:37 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-05-24 11:12:28 +00:00
|
|
|
|
/*
|
|
|
|
|
* Wrapper around gcry_cipher_map_name to provide a fallback using the
|
|
|
|
|
* "Sn" syntax as used by the preference strings.
|
|
|
|
|
*/
|
2011-02-03 18:05:56 +01:00
|
|
|
|
int
|
|
|
|
|
string_to_cipher_algo (const char *string)
|
|
|
|
|
{
|
2006-05-24 11:12:28 +00:00
|
|
|
|
int val;
|
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
val = map_cipher_gcry_to_openpgp (gcry_cipher_map_name (string));
|
2006-05-24 11:12:28 +00:00
|
|
|
|
if (!val && string && (string[0]=='S' || string[0]=='s'))
|
|
|
|
|
{
|
|
|
|
|
char *endptr;
|
|
|
|
|
|
|
|
|
|
string++;
|
|
|
|
|
val = strtol (string, &endptr, 10);
|
|
|
|
|
if (!*string || *endptr || openpgp_cipher_test_algo (val))
|
|
|
|
|
val = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Wrapper around gcry_md_map_name to provide a fallback using the
|
|
|
|
|
* "Hn" syntax as used by the preference strings.
|
|
|
|
|
*/
|
2011-02-03 18:05:56 +01:00
|
|
|
|
int
|
|
|
|
|
string_to_digest_algo (const char *string)
|
|
|
|
|
{
|
2006-05-24 11:12:28 +00:00
|
|
|
|
int val;
|
|
|
|
|
|
2014-01-31 15:33:03 +01:00
|
|
|
|
/* FIXME: We should make use of our wrapper fucntion and not assume
|
|
|
|
|
that there is a 1 to 1 mapping between OpenPGP and Libgcrypt. */
|
2006-05-24 11:12:28 +00:00
|
|
|
|
val = gcry_md_map_name (string);
|
|
|
|
|
if (!val && string && (string[0]=='H' || string[0]=='h'))
|
|
|
|
|
{
|
|
|
|
|
char *endptr;
|
|
|
|
|
|
|
|
|
|
string++;
|
|
|
|
|
val = strtol (string, &endptr, 10);
|
|
|
|
|
if (!*string || *endptr || openpgp_md_test_algo (val))
|
|
|
|
|
val = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
const char *
|
|
|
|
|
compress_algo_to_string(int algo)
|
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
const char *s=NULL;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
switch(algo)
|
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
case COMPRESS_ALGO_NONE:
|
|
|
|
|
s=_("Uncompressed");
|
2003-06-05 07:14:21 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
case COMPRESS_ALGO_ZIP:
|
2003-06-05 07:14:21 +00:00
|
|
|
|
s="ZIP";
|
|
|
|
|
break;
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
case COMPRESS_ALGO_ZLIB:
|
2003-06-05 07:14:21 +00:00
|
|
|
|
s="ZLIB";
|
|
|
|
|
break;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
|
|
|
|
#ifdef HAVE_BZIP2
|
|
|
|
|
case COMPRESS_ALGO_BZIP2:
|
|
|
|
|
s="BZIP2";
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
string_to_compress_algo(const char *string)
|
|
|
|
|
{
|
2006-05-24 11:12:28 +00:00
|
|
|
|
/* TRANSLATORS: See doc/TRANSLATE about this string. */
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if(match_multistr(_("uncompressed|none"),string))
|
|
|
|
|
return 0;
|
|
|
|
|
else if(ascii_strcasecmp(string,"uncompressed")==0)
|
|
|
|
|
return 0;
|
|
|
|
|
else if(ascii_strcasecmp(string,"none")==0)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
return 0;
|
|
|
|
|
else if(ascii_strcasecmp(string,"zip")==0)
|
|
|
|
|
return 1;
|
|
|
|
|
else if(ascii_strcasecmp(string,"zlib")==0)
|
|
|
|
|
return 2;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#ifdef HAVE_BZIP2
|
|
|
|
|
else if(ascii_strcasecmp(string,"bzip2")==0)
|
|
|
|
|
return 3;
|
|
|
|
|
#endif
|
2003-06-05 07:14:21 +00:00
|
|
|
|
else if(ascii_strcasecmp(string,"z0")==0)
|
|
|
|
|
return 0;
|
|
|
|
|
else if(ascii_strcasecmp(string,"z1")==0)
|
|
|
|
|
return 1;
|
|
|
|
|
else if(ascii_strcasecmp(string,"z2")==0)
|
|
|
|
|
return 2;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#ifdef HAVE_BZIP2
|
|
|
|
|
else if(ascii_strcasecmp(string,"z3")==0)
|
|
|
|
|
return 3;
|
|
|
|
|
#endif
|
2003-06-05 07:14:21 +00:00
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
check_compress_algo(int algo)
|
|
|
|
|
{
|
2010-04-14 14:39:16 +00:00
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case 0: return 0;
|
|
|
|
|
#ifdef HAVE_ZIP
|
2011-02-03 18:05:56 +01:00
|
|
|
|
case 1:
|
2010-04-14 14:39:16 +00:00
|
|
|
|
case 2: return 0;
|
|
|
|
|
#endif
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#ifdef HAVE_BZIP2
|
2010-04-14 14:39:16 +00:00
|
|
|
|
case 3: return 0;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
#endif
|
2015-01-22 12:06:11 +01:00
|
|
|
|
default: return GPG_ERR_COMPR_ALGO;
|
2010-04-14 14:39:16 +00:00
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
default_cipher_algo(void)
|
|
|
|
|
{
|
|
|
|
|
if(opt.def_cipher_algo)
|
|
|
|
|
return opt.def_cipher_algo;
|
|
|
|
|
else if(opt.personal_cipher_prefs)
|
|
|
|
|
return opt.personal_cipher_prefs[0].value;
|
|
|
|
|
else
|
|
|
|
|
return opt.s2k_cipher_algo;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* There is no default_digest_algo function, but see
|
2006-04-19 11:26:11 +00:00
|
|
|
|
sign.c:hash_for() */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
default_compress_algo(void)
|
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if(opt.compress_algo!=-1)
|
|
|
|
|
return opt.compress_algo;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
else if(opt.personal_compress_prefs)
|
|
|
|
|
return opt.personal_compress_prefs[0].value;
|
|
|
|
|
else
|
|
|
|
|
return DEFAULT_COMPRESS_ALGO;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
|
compliance_option_string(void)
|
|
|
|
|
{
|
2007-10-25 09:06:21 +00:00
|
|
|
|
char *ver="???";
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
switch(opt.compliance)
|
|
|
|
|
{
|
2007-10-25 09:06:21 +00:00
|
|
|
|
case CO_GNUPG: return "--gnupg";
|
|
|
|
|
case CO_RFC4880: return "--openpgp";
|
|
|
|
|
case CO_RFC2440: return "--rfc2440";
|
|
|
|
|
case CO_PGP6: return "--pgp6";
|
|
|
|
|
case CO_PGP7: return "--pgp7";
|
|
|
|
|
case CO_PGP8: return "--pgp8";
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2007-10-25 09:06:21 +00:00
|
|
|
|
|
|
|
|
|
return ver;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-10-25 09:06:21 +00:00
|
|
|
|
void
|
|
|
|
|
compliance_failure(void)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2007-10-25 09:06:21 +00:00
|
|
|
|
char *ver="???";
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
switch(opt.compliance)
|
|
|
|
|
{
|
2007-10-25 09:06:21 +00:00
|
|
|
|
case CO_GNUPG:
|
|
|
|
|
ver="GnuPG";
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CO_RFC4880:
|
|
|
|
|
ver="OpenPGP";
|
|
|
|
|
break;
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case CO_RFC2440:
|
2007-10-25 09:06:21 +00:00
|
|
|
|
ver="OpenPGP (older)";
|
|
|
|
|
break;
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case CO_PGP6:
|
2007-10-25 09:06:21 +00:00
|
|
|
|
ver="PGP 6.x";
|
|
|
|
|
break;
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case CO_PGP7:
|
2007-10-25 09:06:21 +00:00
|
|
|
|
ver="PGP 7.x";
|
|
|
|
|
break;
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
case CO_PGP8:
|
2007-10-25 09:06:21 +00:00
|
|
|
|
ver="PGP 8.x";
|
|
|
|
|
break;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2007-10-25 09:06:21 +00:00
|
|
|
|
log_info(_("this message may not be usable by %s\n"),ver);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
opt.compliance=CO_GNUPG;
|
|
|
|
|
}
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* Break a string into successive option pieces. Accepts single word
|
|
|
|
|
options and key=value argument options. */
|
|
|
|
|
char *
|
|
|
|
|
optsep(char **stringp)
|
|
|
|
|
{
|
|
|
|
|
char *tok,*end;
|
|
|
|
|
|
|
|
|
|
tok=*stringp;
|
|
|
|
|
if(tok)
|
|
|
|
|
{
|
|
|
|
|
end=strpbrk(tok," ,=");
|
|
|
|
|
if(end)
|
|
|
|
|
{
|
|
|
|
|
int sawequals=0;
|
|
|
|
|
char *ptr=end;
|
|
|
|
|
|
|
|
|
|
/* what we need to do now is scan along starting with *end,
|
|
|
|
|
If the next character we see (ignoring spaces) is an =
|
|
|
|
|
sign, then there is an argument. */
|
|
|
|
|
|
|
|
|
|
while(*ptr)
|
|
|
|
|
{
|
|
|
|
|
if(*ptr=='=')
|
|
|
|
|
sawequals=1;
|
|
|
|
|
else if(*ptr!=' ')
|
|
|
|
|
break;
|
|
|
|
|
ptr++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* There is an argument, so grab that too. At this point,
|
|
|
|
|
ptr points to the first character of the argument. */
|
|
|
|
|
if(sawequals)
|
|
|
|
|
{
|
|
|
|
|
/* Is it a quoted argument? */
|
|
|
|
|
if(*ptr=='"')
|
|
|
|
|
{
|
|
|
|
|
ptr++;
|
|
|
|
|
end=strchr(ptr,'"');
|
|
|
|
|
if(end)
|
|
|
|
|
end++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
end=strpbrk(ptr," ,");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(end && *end)
|
|
|
|
|
{
|
|
|
|
|
*end='\0';
|
|
|
|
|
*stringp=end+1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*stringp=NULL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*stringp=NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return tok;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Breaks an option value into key and value. Returns NULL if there
|
|
|
|
|
is no value. Note that "string" is modified to remove the =value
|
|
|
|
|
part. */
|
|
|
|
|
char *
|
|
|
|
|
argsplit(char *string)
|
|
|
|
|
{
|
|
|
|
|
char *equals,*arg=NULL;
|
|
|
|
|
|
|
|
|
|
equals=strchr(string,'=');
|
|
|
|
|
if(equals)
|
|
|
|
|
{
|
|
|
|
|
char *quote,*space;
|
|
|
|
|
|
|
|
|
|
*equals='\0';
|
|
|
|
|
arg=equals+1;
|
|
|
|
|
|
|
|
|
|
/* Quoted arg? */
|
|
|
|
|
quote=strchr(arg,'"');
|
|
|
|
|
if(quote)
|
|
|
|
|
{
|
|
|
|
|
arg=quote+1;
|
|
|
|
|
|
|
|
|
|
quote=strchr(arg,'"');
|
|
|
|
|
if(quote)
|
|
|
|
|
*quote='\0';
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
size_t spaces;
|
|
|
|
|
|
|
|
|
|
/* Trim leading spaces off of the arg */
|
|
|
|
|
spaces=strspn(arg," ");
|
|
|
|
|
arg+=spaces;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Trim tailing spaces off of the tag */
|
|
|
|
|
space=strchr(string,' ');
|
|
|
|
|
if(space)
|
|
|
|
|
*space='\0';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return arg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the length of the initial token, leaving off any
|
|
|
|
|
argument. */
|
|
|
|
|
static size_t
|
|
|
|
|
optlen(const char *s)
|
|
|
|
|
{
|
|
|
|
|
char *end=strpbrk(s," =");
|
|
|
|
|
|
|
|
|
|
if(end)
|
|
|
|
|
return end-s;
|
|
|
|
|
else
|
|
|
|
|
return strlen(s);
|
|
|
|
|
}
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
int
|
2006-04-19 11:26:11 +00:00
|
|
|
|
parse_options(char *str,unsigned int *options,
|
|
|
|
|
struct parse_options *opts,int noisy)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
|
|
|
|
char *tok;
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
if (str && !strcmp (str, "help"))
|
|
|
|
|
{
|
|
|
|
|
int i,maxlen=0;
|
|
|
|
|
|
|
|
|
|
/* Figure out the longest option name so we can line these up
|
|
|
|
|
neatly. */
|
|
|
|
|
for(i=0;opts[i].name;i++)
|
|
|
|
|
if(opts[i].help && maxlen<strlen(opts[i].name))
|
|
|
|
|
maxlen=strlen(opts[i].name);
|
|
|
|
|
|
|
|
|
|
for(i=0;opts[i].name;i++)
|
|
|
|
|
if(opts[i].help)
|
2015-02-19 17:22:27 +01:00
|
|
|
|
es_printf("%s%*s%s\n",opts[i].name,
|
|
|
|
|
maxlen+2-(int)strlen(opts[i].name),"",_(opts[i].help));
|
2006-04-19 11:26:11 +00:00
|
|
|
|
|
|
|
|
|
g10_exit(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while((tok=optsep(&str)))
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
|
|
|
|
int i,rev=0;
|
2006-04-19 11:26:11 +00:00
|
|
|
|
char *otok=tok;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
if(tok[0]=='\0')
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
if(ascii_strncasecmp("no-",tok,3)==0)
|
|
|
|
|
{
|
|
|
|
|
rev=1;
|
|
|
|
|
tok+=3;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for(i=0;opts[i].name;i++)
|
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
size_t toklen=optlen(tok);
|
|
|
|
|
|
|
|
|
|
if(ascii_strncasecmp(opts[i].name,tok,toklen)==0)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* We have a match, but it might be incomplete */
|
|
|
|
|
if(toklen!=strlen(opts[i].name))
|
|
|
|
|
{
|
|
|
|
|
int j;
|
|
|
|
|
|
|
|
|
|
for(j=i+1;opts[j].name;j++)
|
|
|
|
|
{
|
|
|
|
|
if(ascii_strncasecmp(opts[j].name,tok,toklen)==0)
|
|
|
|
|
{
|
|
|
|
|
if(noisy)
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info(_("ambiguous option '%s'\n"),otok);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
if(rev)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
*options&=~opts[i].bit;
|
|
|
|
|
if(opts[i].value)
|
|
|
|
|
*opts[i].value=NULL;
|
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
else
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
*options|=opts[i].bit;
|
|
|
|
|
if(opts[i].value)
|
|
|
|
|
*opts[i].value=argsplit(tok);
|
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(!opts[i].name)
|
2006-04-19 11:26:11 +00:00
|
|
|
|
{
|
|
|
|
|
if(noisy)
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info(_("unknown option '%s'\n"),otok);
|
2006-04-19 11:26:11 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
|
|
|
|
|
2006-04-19 11:26:11 +00:00
|
|
|
|
/* Similar to access(2), but uses PATH to find the file. */
|
|
|
|
|
int
|
|
|
|
|
path_access(const char *file,int mode)
|
|
|
|
|
{
|
|
|
|
|
char *envpath;
|
|
|
|
|
int ret=-1;
|
|
|
|
|
|
|
|
|
|
envpath=getenv("PATH");
|
|
|
|
|
|
|
|
|
|
if(!envpath
|
|
|
|
|
#ifdef HAVE_DRIVE_LETTERS
|
|
|
|
|
|| (((file[0]>='A' && file[0]<='Z')
|
|
|
|
|
|| (file[0]>='a' && file[0]<='z'))
|
|
|
|
|
&& file[1]==':')
|
|
|
|
|
#else
|
|
|
|
|
|| file[0]=='/'
|
|
|
|
|
#endif
|
|
|
|
|
)
|
|
|
|
|
return access(file,mode);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* At least as large as, but most often larger than we need. */
|
|
|
|
|
char *buffer=xmalloc(strlen(envpath)+1+strlen(file)+1);
|
|
|
|
|
char *split,*item,*path=xstrdup(envpath);
|
|
|
|
|
|
|
|
|
|
split=path;
|
|
|
|
|
|
|
|
|
|
while((item=strsep(&split,PATHSEP_S)))
|
|
|
|
|
{
|
|
|
|
|
strcpy(buffer,item);
|
|
|
|
|
strcat(buffer,"/");
|
|
|
|
|
strcat(buffer,file);
|
|
|
|
|
ret=access(buffer,mode);
|
|
|
|
|
if(ret==0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
xfree(path);
|
|
|
|
|
xfree(buffer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-01-31 09:27:06 +01:00
|
|
|
|
/* Return the number of public key parameters as used by OpenPGP. */
|
2003-06-18 19:56:13 +00:00
|
|
|
|
int
|
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
|
|
|
|
pubkey_get_npkey (pubkey_algo_t algo)
|
2003-06-18 19:56:13 +00:00
|
|
|
|
{
|
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
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA:
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: return 2;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: return 3;
|
|
|
|
|
case PUBKEY_ALGO_DSA: return 4;
|
|
|
|
|
case PUBKEY_ALGO_ECDH: return 3;
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: return 2;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL: return 3;
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: return 2;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-01-31 09:27:06 +01:00
|
|
|
|
|
|
|
|
|
/* Return the number of secret key parameters as used by OpenPGP. */
|
2003-06-18 19:56:13 +00:00
|
|
|
|
int
|
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
|
|
|
|
pubkey_get_nskey (pubkey_algo_t algo)
|
2003-06-18 19:56:13 +00:00
|
|
|
|
{
|
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
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA:
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: return 6;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: return 4;
|
|
|
|
|
case PUBKEY_ALGO_DSA: return 5;
|
|
|
|
|
case PUBKEY_ALGO_ECDH: return 4;
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: return 3;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL: return 4;
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: return 3;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Temporary helper. */
|
|
|
|
|
int
|
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
|
|
|
|
pubkey_get_nsig (pubkey_algo_t algo)
|
2003-06-18 19:56:13 +00:00
|
|
|
|
{
|
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
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA:
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: return 1;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: return 0;
|
|
|
|
|
case PUBKEY_ALGO_DSA: return 2;
|
|
|
|
|
case PUBKEY_ALGO_ECDH: return 0;
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: return 2;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL: return 2;
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: return 2;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-01-31 09:27:06 +01:00
|
|
|
|
|
2003-06-18 19:56:13 +00:00
|
|
|
|
/* Temporary helper. */
|
|
|
|
|
int
|
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
|
|
|
|
pubkey_get_nenc (pubkey_algo_t algo)
|
2003-06-18 19:56:13 +00:00
|
|
|
|
{
|
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
|
|
|
|
switch (algo)
|
|
|
|
|
{
|
|
|
|
|
case PUBKEY_ALGO_RSA:
|
|
|
|
|
case PUBKEY_ALGO_RSA_E:
|
|
|
|
|
case PUBKEY_ALGO_RSA_S: return 1;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL_E: return 2;
|
|
|
|
|
case PUBKEY_ALGO_DSA: return 0;
|
|
|
|
|
case PUBKEY_ALGO_ECDH: return 2;
|
|
|
|
|
case PUBKEY_ALGO_ECDSA: return 0;
|
|
|
|
|
case PUBKEY_ALGO_ELGAMAL: return 2;
|
|
|
|
|
case PUBKEY_ALGO_EDDSA: return 0;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Temporary helper. */
|
|
|
|
|
unsigned int
|
|
|
|
|
pubkey_nbits( int algo, gcry_mpi_t *key )
|
|
|
|
|
{
|
2014-06-02 19:51:23 +02:00
|
|
|
|
int rc, nbits;
|
|
|
|
|
gcry_sexp_t sexp;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
2014-06-02 19:51:23 +02:00
|
|
|
|
if (algo == PUBKEY_ALGO_DSA
|
|
|
|
|
&& key[0] && key[1] && key[2] && key[3])
|
|
|
|
|
{
|
|
|
|
|
rc = gcry_sexp_build (&sexp, NULL,
|
|
|
|
|
"(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
|
|
|
|
|
key[0], key[1], key[2], key[3] );
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
2014-06-02 19:51:23 +02:00
|
|
|
|
else if ((algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E)
|
|
|
|
|
&& key[0] && key[1] && key[2])
|
|
|
|
|
{
|
|
|
|
|
rc = gcry_sexp_build (&sexp, NULL,
|
|
|
|
|
"(public-key(elg(p%m)(g%m)(y%m)))",
|
|
|
|
|
key[0], key[1], key[2] );
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
2014-06-02 19:51:23 +02:00
|
|
|
|
else if (is_RSA (algo)
|
|
|
|
|
&& key[0] && key[1])
|
|
|
|
|
{
|
|
|
|
|
rc = gcry_sexp_build (&sexp, NULL,
|
|
|
|
|
"(public-key(rsa(n%m)(e%m)))",
|
|
|
|
|
key[0], key[1] );
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
2014-06-02 19:51:23 +02:00
|
|
|
|
else if ((algo == PUBKEY_ALGO_ECDSA || algo == PUBKEY_ALGO_ECDH
|
|
|
|
|
|| algo == PUBKEY_ALGO_EDDSA)
|
|
|
|
|
&& key[0] && key[1])
|
|
|
|
|
{
|
|
|
|
|
char *curve = openpgp_oid_to_str (key[0]);
|
|
|
|
|
if (!curve)
|
|
|
|
|
rc = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rc = gcry_sexp_build (&sexp, NULL,
|
|
|
|
|
"(public-key(ecc(curve%s)(q%m)))",
|
|
|
|
|
curve, key[1]);
|
|
|
|
|
xfree (curve);
|
|
|
|
|
}
|
2011-01-05 17:33:17 -08:00
|
|
|
|
}
|
2014-06-02 19:51:23 +02:00
|
|
|
|
else
|
|
|
|
|
return 0;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
2014-06-02 19:51:23 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
BUG ();
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
2014-06-02 19:51:23 +02:00
|
|
|
|
nbits = gcry_pk_get_nbits (sexp);
|
|
|
|
|
gcry_sexp_release (sexp);
|
|
|
|
|
return nbits;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int
|
2010-03-15 11:15:45 +00:00
|
|
|
|
mpi_print (estream_t fp, gcry_mpi_t a, int mode)
|
2003-06-18 19:56:13 +00:00
|
|
|
|
{
|
2015-03-16 19:57:11 +01:00
|
|
|
|
int n = 0;
|
|
|
|
|
size_t nwritten;
|
2011-02-03 18:05:56 +01:00
|
|
|
|
|
2010-03-15 11:15:45 +00:00
|
|
|
|
if (!a)
|
|
|
|
|
return es_fprintf (fp, "[MPI_NULL]");
|
|
|
|
|
if (!mode)
|
|
|
|
|
{
|
|
|
|
|
unsigned int n1;
|
|
|
|
|
n1 = gcry_mpi_get_nbits(a);
|
|
|
|
|
n += es_fprintf (fp, "[%u bits]", n1);
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
2011-01-31 09:27:06 +01:00
|
|
|
|
else if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
|
|
|
|
|
{
|
|
|
|
|
unsigned int nbits;
|
|
|
|
|
unsigned char *p = gcry_mpi_get_opaque (a, &nbits);
|
|
|
|
|
if (!p)
|
|
|
|
|
n += es_fprintf (fp, "[invalid opaque value]");
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-03-16 19:57:11 +01:00
|
|
|
|
if (!es_write_hexstring (fp, p, (nbits + 7)/8, 0, &nwritten))
|
|
|
|
|
n += nwritten;
|
2011-01-31 09:27:06 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-15 11:15:45 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
unsigned char *buffer;
|
2015-03-16 19:57:11 +01:00
|
|
|
|
size_t buflen;
|
2011-02-03 18:05:56 +01:00
|
|
|
|
|
2015-03-16 19:57:11 +01:00
|
|
|
|
if (gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &buflen, a))
|
2010-03-15 11:15:45 +00:00
|
|
|
|
BUG ();
|
2015-03-16 19:57:11 +01:00
|
|
|
|
if (!es_write_hexstring (fp, buffer, buflen, 0, &nwritten))
|
|
|
|
|
n += nwritten;
|
2010-03-15 11:15:45 +00:00
|
|
|
|
gcry_free (buffer);
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
2010-03-15 11:15:45 +00:00
|
|
|
|
return n;
|
2003-06-18 19:56:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-01-21 12:00:57 +01:00
|
|
|
|
|
|
|
|
|
/* pkey[1] or skey[1] is Q for ECDSA, which is an uncompressed point,
|
|
|
|
|
i.e. 04 <x> <y> */
|
2011-02-03 18:05:56 +01:00
|
|
|
|
unsigned int
|
2011-01-26 17:17:43 +01:00
|
|
|
|
ecdsa_qbits_from_Q (unsigned int qbits)
|
2011-01-21 12:00:57 +01:00
|
|
|
|
{
|
|
|
|
|
if ((qbits%8) > 3)
|
|
|
|
|
{
|
2011-01-26 17:17:43 +01:00
|
|
|
|
log_error (_("ECDSA public key is expected to be in SEC encoding "
|
|
|
|
|
"multiple of 8 bits\n"));
|
2011-01-21 12:00:57 +01:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
qbits -= qbits%8;
|
|
|
|
|
qbits /= 2;
|
|
|
|
|
return qbits;
|
2011-01-05 17:33:17 -08:00
|
|
|
|
}
|
2015-10-18 17:35:32 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Ignore signatures and certifications made over certain digest
|
|
|
|
|
* algorithms by default, MD5 is considered weak. This allows users
|
|
|
|
|
* to deprecate support for other algorithms as well.
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
additional_weak_digest (const char* digestname)
|
|
|
|
|
{
|
|
|
|
|
struct weakhash *weak = NULL;
|
|
|
|
|
const enum gcry_md_algos algo = string_to_digest_algo(digestname);
|
|
|
|
|
|
|
|
|
|
if (algo == GCRY_MD_MD5)
|
|
|
|
|
return; /* MD5 is always considered weak, no need to add it. */
|
|
|
|
|
|
|
|
|
|
if (algo == GCRY_MD_NONE)
|
|
|
|
|
{
|
|
|
|
|
log_error(_("Unknown weak digest '%s'\n"), digestname);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check to ensure it's not already present. */
|
|
|
|
|
for (weak = opt.additional_weak_digests; weak != NULL; weak = weak->next)
|
|
|
|
|
{
|
|
|
|
|
if (algo == weak->algo)
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Add it to the head of the list. */
|
|
|
|
|
weak = xmalloc(sizeof(*weak));
|
|
|
|
|
weak->algo = algo;
|
|
|
|
|
weak->next = opt.additional_weak_digests;
|
|
|
|
|
opt.additional_weak_digests = weak;
|
|
|
|
|
}
|