1998-01-16 21:15:24 +00:00
|
|
|
/* import.c
|
2004-02-12 16:31:07 +00:00
|
|
|
* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
|
|
|
|
* 2004 Free Software Foundation, Inc.
|
1998-01-16 21:15:24 +00:00
|
|
|
*
|
1998-12-08 12:20:53 +00:00
|
|
|
* This file is part of GnuPG.
|
1998-01-16 21:15:24 +00:00
|
|
|
*
|
1998-12-08 12:20:53 +00:00
|
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
1998-01-16 21:15:24 +00:00
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
1998-12-08 12:20:53 +00:00
|
|
|
* GnuPG is distributed in the hope that it will be useful,
|
1998-01-16 21:15:24 +00:00
|
|
|
* 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
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
|
|
|
#include "options.h"
|
|
|
|
#include "packet.h"
|
|
|
|
#include "errors.h"
|
|
|
|
#include "keydb.h"
|
2002-06-29 13:46:34 +00:00
|
|
|
#include "memory.h"
|
1998-01-16 21:15:24 +00:00
|
|
|
#include "util.h"
|
|
|
|
#include "trustdb.h"
|
1998-02-16 20:05:02 +00:00
|
|
|
#include "main.h"
|
1998-07-08 09:29:43 +00:00
|
|
|
#include "i18n.h"
|
2002-08-19 08:28:00 +00:00
|
|
|
#include "ttyio.h"
|
1999-07-14 17:47:23 +00:00
|
|
|
#include "status.h"
|
2002-06-29 13:46:34 +00:00
|
|
|
#include "keyserver-internal.h"
|
1998-02-16 20:05:02 +00:00
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
struct stats_s {
|
2000-07-14 17:34:53 +00:00
|
|
|
ulong count;
|
1998-10-25 19:00:01 +00:00
|
|
|
ulong no_user_id;
|
|
|
|
ulong imported;
|
|
|
|
ulong imported_rsa;
|
|
|
|
ulong n_uids;
|
|
|
|
ulong n_sigs;
|
|
|
|
ulong n_subk;
|
|
|
|
ulong unchanged;
|
|
|
|
ulong n_revoc;
|
|
|
|
ulong secret_read;
|
|
|
|
ulong secret_imported;
|
|
|
|
ulong secret_dups;
|
2000-09-18 14:35:34 +00:00
|
|
|
ulong skipped_new_keys;
|
2002-08-21 14:59:05 +00:00
|
|
|
ulong not_imported;
|
2002-06-29 13:46:34 +00:00
|
|
|
};
|
1998-10-25 19:00:01 +00:00
|
|
|
|
|
|
|
|
2002-09-23 13:03:52 +00:00
|
|
|
static int import( IOBUF inp, const char* fname,
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
struct stats_s *stats, unsigned int options );
|
1999-02-19 14:54:00 +00:00
|
|
|
static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
|
2002-06-29 13:46:34 +00:00
|
|
|
static void revocation_present(KBNODE keyblock);
|
2002-09-23 13:03:52 +00:00
|
|
|
static int import_one( const char *fname, KBNODE keyblock,
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
struct stats_s *stats, unsigned int options);
|
2002-06-29 13:46:34 +00:00
|
|
|
static int import_secret_one( const char *fname, KBNODE keyblock,
|
2002-10-23 15:59:45 +00:00
|
|
|
struct stats_s *stats, unsigned int options);
|
2002-06-29 13:46:34 +00:00
|
|
|
static int import_revoke_cert( const char *fname, KBNODE node,
|
|
|
|
struct stats_s *stats);
|
1998-02-16 20:05:02 +00:00
|
|
|
static int chk_self_sigs( const char *fname, KBNODE keyblock,
|
2002-12-13 21:10:53 +00:00
|
|
|
PKT_public_key *pk, u32 *keyid, int *non_self );
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
static int delete_inv_parts( const char *fname, KBNODE keyblock,
|
|
|
|
u32 *keyid, unsigned int options );
|
1998-02-17 20:48:52 +00:00
|
|
|
static int merge_blocks( const char *fname, KBNODE keyblock_orig,
|
1998-05-26 13:38:00 +00:00
|
|
|
KBNODE keyblock, u32 *keyid,
|
|
|
|
int *n_uids, int *n_sigs, int *n_subk );
|
1998-02-17 20:48:52 +00:00
|
|
|
static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid );
|
1998-12-08 12:20:53 +00:00
|
|
|
static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid );
|
1998-02-17 20:48:52 +00:00
|
|
|
static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid );
|
1998-12-08 12:20:53 +00:00
|
|
|
static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid );
|
1998-01-16 21:15:24 +00:00
|
|
|
|
2002-07-22 22:26:14 +00:00
|
|
|
int
|
2003-12-28 03:46:43 +00:00
|
|
|
parse_import_options(char *str,unsigned int *options,int noisy)
|
2002-07-22 22:26:14 +00:00
|
|
|
{
|
2003-05-31 21:52:16 +00:00
|
|
|
struct parse_options import_opts[]=
|
2002-07-22 22:26:14 +00:00
|
|
|
{
|
2004-02-14 05:03:45 +00:00
|
|
|
{"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS,NULL},
|
|
|
|
{"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
|
|
|
|
{"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
|
|
|
|
{"fast-import",IMPORT_FAST_IMPORT,NULL},
|
|
|
|
{"convert-sk-to-pk",IMPORT_SK2PK,NULL},
|
|
|
|
{"merge-only",IMPORT_MERGE_ONLY,NULL},
|
|
|
|
{NULL,0,NULL}
|
2002-07-22 22:26:14 +00:00
|
|
|
};
|
|
|
|
|
2003-12-28 03:46:43 +00:00
|
|
|
return parse_options(str,options,import_opts,noisy);
|
2002-07-22 22:26:14 +00:00
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
void *
|
|
|
|
import_new_stats_handle (void)
|
|
|
|
{
|
|
|
|
return m_alloc_clear ( sizeof (struct stats_s) );
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
import_release_stats_handle (void *p)
|
|
|
|
{
|
|
|
|
m_free (p);
|
|
|
|
}
|
|
|
|
|
1998-01-16 21:15:24 +00:00
|
|
|
/****************
|
1998-02-13 20:58:50 +00:00
|
|
|
* Import the public keys from the given filename. Input may be armored.
|
1998-04-14 17:51:16 +00:00
|
|
|
* This function rejects all keys which are not validly self signed on at
|
1998-02-13 20:58:50 +00:00
|
|
|
* least one userid. Only user ids which are self signed will be imported.
|
1998-04-14 17:51:16 +00:00
|
|
|
* Other signatures are not checked.
|
1998-02-13 20:58:50 +00:00
|
|
|
*
|
1998-10-25 19:00:01 +00:00
|
|
|
* Actually this function does a merge. It works like this:
|
1998-02-13 20:58:50 +00:00
|
|
|
*
|
|
|
|
* - get the keyblock
|
1998-02-16 20:05:02 +00:00
|
|
|
* - check self-signatures and remove all userids and their signatures
|
1998-02-13 20:58:50 +00:00
|
|
|
* without/invalid self-signatures.
|
|
|
|
* - reject the keyblock, if we have no valid userid.
|
1998-04-14 17:51:16 +00:00
|
|
|
* - See whether we have this key already in one of our pubrings.
|
1998-02-13 20:58:50 +00:00
|
|
|
* If not, simply add it to the default keyring.
|
|
|
|
* - Compare the key and the self-signatures of the new and the one in
|
1998-04-14 17:51:16 +00:00
|
|
|
* our keyring. If they are different something weird is going on;
|
1998-02-13 20:58:50 +00:00
|
|
|
* ask what to do.
|
1998-04-14 17:51:16 +00:00
|
|
|
* - See whether we have only non-self-signature on one user id; if not
|
1998-02-13 20:58:50 +00:00
|
|
|
* ask the user what to do.
|
|
|
|
* - compare the signatures: If we already have this signature, check
|
1998-02-16 20:05:02 +00:00
|
|
|
* that they compare okay; if not, issue a warning and ask the user.
|
1998-04-14 17:51:16 +00:00
|
|
|
* (consider looking at the timestamp and use the newest?)
|
1998-02-13 20:58:50 +00:00
|
|
|
* - Simply add the signature. Can't verify here because we may not have
|
1998-04-14 17:51:16 +00:00
|
|
|
* the signature's public key yet; verification is done when putting it
|
1998-02-13 20:58:50 +00:00
|
|
|
* into the trustdb, which is done automagically as soon as this pubkey
|
|
|
|
* is used.
|
|
|
|
* - Proceed with next signature.
|
1998-01-16 21:15:24 +00:00
|
|
|
*
|
1998-04-14 17:51:16 +00:00
|
|
|
* Key revocation certificates have special handling.
|
1998-02-18 13:58:46 +00:00
|
|
|
*
|
1998-01-16 21:15:24 +00:00
|
|
|
*/
|
2002-09-22 09:20:08 +00:00
|
|
|
static int
|
2002-09-23 13:03:52 +00:00
|
|
|
import_keys_internal( IOBUF inp, char **fnames, int nnames,
|
2002-09-22 09:20:08 +00:00
|
|
|
void *stats_handle, unsigned int options )
|
1999-01-16 08:29:29 +00:00
|
|
|
{
|
2002-09-22 09:20:08 +00:00
|
|
|
int i, rc = 0;
|
2002-06-29 13:46:34 +00:00
|
|
|
struct stats_s *stats = stats_handle;
|
1999-01-16 08:29:29 +00:00
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
if (!stats)
|
|
|
|
stats = import_new_stats_handle ();
|
1999-01-16 08:29:29 +00:00
|
|
|
|
2002-09-22 09:20:08 +00:00
|
|
|
if (inp) {
|
2002-09-23 13:03:52 +00:00
|
|
|
rc = import( inp, "[stream]", stats, options);
|
2002-09-22 09:20:08 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if( !fnames && !nnames )
|
|
|
|
nnames = 1; /* Ohh what a ugly hack to jump into the loop */
|
1999-01-16 08:29:29 +00:00
|
|
|
|
2002-09-22 09:20:08 +00:00
|
|
|
for(i=0; i < nnames; i++ ) {
|
|
|
|
const char *fname = fnames? fnames[i] : NULL;
|
2002-10-04 05:43:54 +00:00
|
|
|
IOBUF inp2 = iobuf_open(fname);
|
2002-09-22 09:20:08 +00:00
|
|
|
if( !fname )
|
|
|
|
fname = "[stdin]";
|
2002-10-07 22:19:11 +00:00
|
|
|
if( !inp2 )
|
2002-09-22 09:20:08 +00:00
|
|
|
log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
|
|
|
|
else {
|
2002-10-04 05:43:54 +00:00
|
|
|
rc = import( inp2, fname, stats, options );
|
|
|
|
iobuf_close(inp2);
|
2003-06-08 21:35:25 +00:00
|
|
|
/* Must invalidate that ugly cache to actually close it. */
|
2003-06-08 21:23:48 +00:00
|
|
|
iobuf_ioctl (NULL, 2, 0, (char*)fname);
|
2002-09-22 09:20:08 +00:00
|
|
|
if( rc )
|
|
|
|
log_error("import from `%s' failed: %s\n", fname,
|
|
|
|
g10_errstr(rc) );
|
|
|
|
}
|
|
|
|
if( !fname )
|
|
|
|
break;
|
2000-07-14 17:34:53 +00:00
|
|
|
}
|
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
if (!stats_handle) {
|
|
|
|
import_print_stats (stats);
|
|
|
|
import_release_stats_handle (stats);
|
|
|
|
}
|
2002-12-13 21:10:53 +00:00
|
|
|
/* If no fast import and the trustdb is dirty (i.e. we added a key
|
|
|
|
or userID that had something other than a selfsig, a signature
|
|
|
|
that was other than a selfsig, or any revocation), then
|
|
|
|
update/check the trustdb if the user specified by setting
|
|
|
|
interactive or by not setting no-auto-check-trustdb */
|
|
|
|
if (!(options&IMPORT_FAST_IMPORT) && trustdb_pending_check())
|
|
|
|
{
|
|
|
|
if (opt.interactive)
|
|
|
|
update_trustdb();
|
2002-09-21 21:57:22 +00:00
|
|
|
else if (!opt.no_auto_check_trustdb)
|
2002-12-13 21:10:53 +00:00
|
|
|
check_trustdb();
|
|
|
|
}
|
|
|
|
|
2002-09-22 09:20:08 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2002-09-23 13:03:52 +00:00
|
|
|
import_keys( char **fnames, int nnames,
|
2002-09-22 09:20:08 +00:00
|
|
|
void *stats_handle, unsigned int options )
|
|
|
|
{
|
2002-09-23 13:03:52 +00:00
|
|
|
import_keys_internal( NULL, fnames, nnames, stats_handle, options);
|
1999-01-16 08:29:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2002-09-23 13:03:52 +00:00
|
|
|
import_keys_stream( IOBUF inp, void *stats_handle, unsigned int options )
|
1999-01-16 08:29:29 +00:00
|
|
|
{
|
2002-09-24 21:20:48 +00:00
|
|
|
return import_keys_internal( inp, NULL, 0, stats_handle, options);
|
1999-01-16 08:29:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-09-23 13:03:52 +00:00
|
|
|
import( IOBUF inp, const char* fname,
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
struct stats_s *stats, unsigned int options )
|
1998-02-16 20:05:02 +00:00
|
|
|
{
|
|
|
|
PACKET *pending_pkt = NULL;
|
|
|
|
KBNODE keyblock;
|
|
|
|
int rc = 0;
|
1998-10-25 19:00:01 +00:00
|
|
|
|
1998-12-23 12:41:40 +00:00
|
|
|
getkey_disable_caches();
|
|
|
|
|
1999-02-19 14:54:00 +00:00
|
|
|
if( !opt.no_armor ) { /* armored reading is not disabled */
|
2002-06-29 13:46:34 +00:00
|
|
|
armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
|
1999-02-19 14:54:00 +00:00
|
|
|
afx->only_keyblocks = 1;
|
|
|
|
iobuf_push_filter2( inp, armor_filter, afx, 1 );
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
|
1999-02-19 14:54:00 +00:00
|
|
|
while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
|
1998-06-29 12:30:57 +00:00
|
|
|
if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
|
2002-09-23 13:03:52 +00:00
|
|
|
rc = import_one( fname, keyblock, stats, options );
|
2002-06-29 13:46:34 +00:00
|
|
|
else if( keyblock->pkt->pkttype == PKT_SECRET_KEY )
|
2002-10-23 15:59:45 +00:00
|
|
|
rc = import_secret_one( fname, keyblock, stats, options );
|
1998-02-18 13:58:46 +00:00
|
|
|
else if( keyblock->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& keyblock->pkt->pkt.signature->sig_class == 0x20 )
|
2002-06-29 13:46:34 +00:00
|
|
|
rc = import_revoke_cert( fname, keyblock, stats );
|
1998-07-08 09:29:43 +00:00
|
|
|
else {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_info( _("skipping block of type %d\n"),
|
1998-07-08 09:29:43 +00:00
|
|
|
keyblock->pkt->pkttype );
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
release_kbnode(keyblock);
|
2002-08-21 14:59:05 +00:00
|
|
|
/* fixme: we should increment the not imported counter but this
|
|
|
|
does only make sense if we keep on going despite of errors. */
|
1998-02-16 20:05:02 +00:00
|
|
|
if( rc )
|
|
|
|
break;
|
2002-06-29 13:46:34 +00:00
|
|
|
if( !(++stats->count % 100) && !opt.quiet )
|
2002-09-24 21:20:48 +00:00
|
|
|
log_info(_("%lu keys processed so far\n"), stats->count );
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
|
|
|
if( rc == -1 )
|
|
|
|
rc = 0;
|
2002-06-29 13:46:34 +00:00
|
|
|
else if( rc && rc != G10ERR_INV_KEYRING )
|
|
|
|
log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
|
1998-02-16 20:05:02 +00:00
|
|
|
|
2000-07-14 17:34:53 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
void
|
|
|
|
import_print_stats (void *hd)
|
2000-07-14 17:34:53 +00:00
|
|
|
{
|
2002-06-29 13:46:34 +00:00
|
|
|
struct stats_s *stats = hd;
|
|
|
|
|
1999-04-18 08:18:52 +00:00
|
|
|
if( !opt.quiet ) {
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info(_("Total number processed: %lu\n"), stats->count );
|
|
|
|
if( stats->skipped_new_keys )
|
2000-09-18 14:35:34 +00:00
|
|
|
log_info(_(" skipped new keys: %lu\n"),
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->skipped_new_keys );
|
|
|
|
if( stats->no_user_id )
|
|
|
|
log_info(_(" w/o user IDs: %lu\n"), stats->no_user_id );
|
|
|
|
if( stats->imported || stats->imported_rsa ) {
|
|
|
|
log_info(_(" imported: %lu"), stats->imported );
|
|
|
|
if( stats->imported_rsa )
|
|
|
|
fprintf(stderr, " (RSA: %lu)", stats->imported_rsa );
|
1999-04-18 08:18:52 +00:00
|
|
|
putc('\n', stderr);
|
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
if( stats->unchanged )
|
|
|
|
log_info(_(" unchanged: %lu\n"), stats->unchanged );
|
|
|
|
if( stats->n_uids )
|
|
|
|
log_info(_(" new user IDs: %lu\n"), stats->n_uids );
|
|
|
|
if( stats->n_subk )
|
|
|
|
log_info(_(" new subkeys: %lu\n"), stats->n_subk );
|
|
|
|
if( stats->n_sigs )
|
|
|
|
log_info(_(" new signatures: %lu\n"), stats->n_sigs );
|
|
|
|
if( stats->n_revoc )
|
|
|
|
log_info(_(" new key revocations: %lu\n"), stats->n_revoc );
|
|
|
|
if( stats->secret_read )
|
|
|
|
log_info(_(" secret keys read: %lu\n"), stats->secret_read );
|
|
|
|
if( stats->secret_imported )
|
|
|
|
log_info(_(" secret keys imported: %lu\n"), stats->secret_imported );
|
|
|
|
if( stats->secret_dups )
|
|
|
|
log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
|
2002-08-21 14:59:05 +00:00
|
|
|
if( stats->not_imported )
|
|
|
|
log_info(_(" not imported: %lu\n"), stats->not_imported );
|
1998-10-25 19:00:01 +00:00
|
|
|
}
|
|
|
|
|
1999-07-14 17:47:23 +00:00
|
|
|
if( is_status_enabled() ) {
|
2002-08-21 14:59:05 +00:00
|
|
|
char buf[14*20];
|
|
|
|
sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->count,
|
|
|
|
stats->no_user_id,
|
|
|
|
stats->imported,
|
|
|
|
stats->imported_rsa,
|
|
|
|
stats->unchanged,
|
|
|
|
stats->n_uids,
|
|
|
|
stats->n_subk,
|
|
|
|
stats->n_sigs,
|
|
|
|
stats->n_revoc,
|
|
|
|
stats->secret_read,
|
|
|
|
stats->secret_imported,
|
|
|
|
stats->secret_dups,
|
2002-08-21 14:59:05 +00:00
|
|
|
stats->skipped_new_keys,
|
|
|
|
stats->not_imported );
|
1999-07-14 17:47:23 +00:00
|
|
|
write_status_text( STATUS_IMPORT_RES, buf );
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************
|
1999-02-19 14:54:00 +00:00
|
|
|
* Read the next keyblock from stream A.
|
|
|
|
* PENDING_PKT should be initialzed to NULL
|
1998-02-16 20:05:02 +00:00
|
|
|
* and not chnaged form the caller.
|
|
|
|
* Retunr: 0 = okay, -1 no more blocks or another errorcode.
|
|
|
|
*/
|
|
|
|
static int
|
1999-02-19 14:54:00 +00:00
|
|
|
read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
|
1998-01-16 21:15:24 +00:00
|
|
|
{
|
1998-02-16 20:05:02 +00:00
|
|
|
int rc;
|
|
|
|
PACKET *pkt;
|
|
|
|
KBNODE root = NULL;
|
1998-02-17 20:48:52 +00:00
|
|
|
int in_cert;
|
1998-02-16 20:05:02 +00:00
|
|
|
|
|
|
|
if( *pending_pkt ) {
|
|
|
|
root = new_kbnode( *pending_pkt );
|
|
|
|
*pending_pkt = NULL;
|
1998-02-17 20:48:52 +00:00
|
|
|
in_cert = 1;
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
else
|
|
|
|
in_cert = 0;
|
2002-06-29 13:46:34 +00:00
|
|
|
pkt = m_alloc( sizeof *pkt );
|
1998-02-16 20:05:02 +00:00
|
|
|
init_packet(pkt);
|
2002-06-29 13:46:34 +00:00
|
|
|
while( (rc=parse_packet(a, pkt)) != -1 ) {
|
1998-02-16 20:05:02 +00:00
|
|
|
if( rc ) { /* ignore errors */
|
2002-06-29 13:46:34 +00:00
|
|
|
if( rc != G10ERR_UNKNOWN_PACKET ) {
|
|
|
|
log_error("read_block: read error: %s\n", g10_errstr(rc) );
|
|
|
|
rc = G10ERR_INV_KEYRING;
|
1998-02-16 20:05:02 +00:00
|
|
|
goto ready;
|
|
|
|
}
|
|
|
|
free_packet( pkt );
|
|
|
|
init_packet(pkt);
|
|
|
|
continue;
|
|
|
|
}
|
1998-02-18 13:58:46 +00:00
|
|
|
|
|
|
|
if( !root && pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& pkt->pkt.signature->sig_class == 0x20 ) {
|
|
|
|
/* this is a revocation certificate which is handled
|
|
|
|
* in a special way */
|
|
|
|
root = new_kbnode( pkt );
|
|
|
|
pkt = NULL;
|
|
|
|
goto ready;
|
|
|
|
}
|
|
|
|
|
1998-02-16 20:05:02 +00:00
|
|
|
/* make a linked list of all packets */
|
|
|
|
switch( pkt->pkttype ) {
|
|
|
|
case PKT_COMPRESSED:
|
* misc.c (compress_algo_to_string, string_to_compress_algo,
check_compress_algo): Add bzip2.
* compress.c (compress_filter): Make static to help force the use of
push_compress_filter. Remove default algorithm setting since that is done
in push_compress_filter now.
* main.h: Use named algorithm.
* filter.h, compress.c (push_compress_filter, push_compress_filter2): New.
Figure out which is the appropriate compression filter to use, and push it
into place.
* compress.c (handle_compressed), encode.c (encode_simple, encode_crypt),
sign.c (sign_file, sign_symencrypt_file), import.c (read_block), export.c
(do_export): Use push_compress_filter instead of pushing the compression
filter ourselves.
* compress-bz2.c: New. Bzlib versions of the compression filter routines.
* Makefile.am: Include compress-bz2.c if bz2lib is available.
2003-10-31 05:39:02 +00:00
|
|
|
if(check_compress_algo(pkt->pkt.compressed->algorithm))
|
|
|
|
{
|
2002-06-29 13:46:34 +00:00
|
|
|
rc = G10ERR_COMPR_ALGO;
|
1998-02-16 20:05:02 +00:00
|
|
|
goto ready;
|
* misc.c (compress_algo_to_string, string_to_compress_algo,
check_compress_algo): Add bzip2.
* compress.c (compress_filter): Make static to help force the use of
push_compress_filter. Remove default algorithm setting since that is done
in push_compress_filter now.
* main.h: Use named algorithm.
* filter.h, compress.c (push_compress_filter, push_compress_filter2): New.
Figure out which is the appropriate compression filter to use, and push it
into place.
* compress.c (handle_compressed), encode.c (encode_simple, encode_crypt),
sign.c (sign_file, sign_symencrypt_file), import.c (read_block), export.c
(do_export): Use push_compress_filter instead of pushing the compression
filter ourselves.
* compress-bz2.c: New. Bzlib versions of the compression filter routines.
* Makefile.am: Include compress-bz2.c if bz2lib is available.
2003-10-31 05:39:02 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2002-06-29 13:46:34 +00:00
|
|
|
compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
|
1999-02-19 14:54:00 +00:00
|
|
|
pkt->pkt.compressed->buf = NULL;
|
* misc.c (compress_algo_to_string, string_to_compress_algo,
check_compress_algo): Add bzip2.
* compress.c (compress_filter): Make static to help force the use of
push_compress_filter. Remove default algorithm setting since that is done
in push_compress_filter now.
* main.h: Use named algorithm.
* filter.h, compress.c (push_compress_filter, push_compress_filter2): New.
Figure out which is the appropriate compression filter to use, and push it
into place.
* compress.c (handle_compressed), encode.c (encode_simple, encode_crypt),
sign.c (sign_file, sign_symencrypt_file), import.c (read_block), export.c
(do_export): Use push_compress_filter instead of pushing the compression
filter ourselves.
* compress-bz2.c: New. Bzlib versions of the compression filter routines.
* Makefile.am: Include compress-bz2.c if bz2lib is available.
2003-10-31 05:39:02 +00:00
|
|
|
push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
free_packet( pkt );
|
|
|
|
init_packet(pkt);
|
|
|
|
break;
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
case PKT_RING_TRUST:
|
|
|
|
/* skip those packets */
|
|
|
|
free_packet( pkt );
|
|
|
|
init_packet(pkt);
|
|
|
|
break;
|
1998-02-17 20:48:52 +00:00
|
|
|
|
1998-06-29 12:30:57 +00:00
|
|
|
case PKT_PUBLIC_KEY:
|
|
|
|
case PKT_SECRET_KEY:
|
1998-02-16 20:05:02 +00:00
|
|
|
if( in_cert ) { /* store this packet */
|
|
|
|
*pending_pkt = pkt;
|
|
|
|
pkt = NULL;
|
|
|
|
goto ready;
|
|
|
|
}
|
|
|
|
in_cert = 1;
|
|
|
|
default:
|
1998-02-17 20:48:52 +00:00
|
|
|
if( in_cert ) {
|
|
|
|
if( !root )
|
|
|
|
root = new_kbnode( pkt );
|
|
|
|
else
|
|
|
|
add_kbnode( root, new_kbnode( pkt ) );
|
2002-06-29 13:46:34 +00:00
|
|
|
pkt = m_alloc( sizeof *pkt );
|
1998-02-17 20:48:52 +00:00
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
init_packet(pkt);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ready:
|
|
|
|
if( rc == -1 && root )
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
if( rc )
|
|
|
|
release_kbnode( root );
|
|
|
|
else
|
|
|
|
*ret_root = root;
|
|
|
|
free_packet( pkt );
|
2002-06-29 13:46:34 +00:00
|
|
|
m_free( pkt );
|
1998-02-16 20:05:02 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2003-04-09 01:57:46 +00:00
|
|
|
/* Walk through the subkeys on a pk to find if we have the PKS
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
disease: multiple subkeys with their binding sigs stripped, and the
|
|
|
|
sig for the first subkey placed after the last subkey. That is,
|
|
|
|
instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
|
|
|
|
"pk uid sig sub1 sub2 sub3 bind1". We can't do anything about sub2
|
|
|
|
and sub3, as they are already lost, but we can try and rescue sub1
|
|
|
|
by reordering the keyblock so that it reads "pk uid sig sub1 bind1
|
|
|
|
sub2 sub3". Returns TRUE if the keyblock was modified. */
|
|
|
|
|
|
|
|
static int
|
2003-04-09 01:57:46 +00:00
|
|
|
fix_pks_corruption(KBNODE keyblock)
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
{
|
|
|
|
int changed=0,keycount=0;
|
|
|
|
KBNODE node,last=NULL,sknode=NULL;
|
|
|
|
|
|
|
|
/* First determine if we have the problem at all. Look for 2 or
|
|
|
|
more subkeys in a row, followed by a single binding sig. */
|
|
|
|
for(node=keyblock;node;last=node,node=node->next)
|
|
|
|
{
|
|
|
|
if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
|
|
|
|
{
|
|
|
|
keycount++;
|
|
|
|
if(!sknode)
|
|
|
|
sknode=node;
|
|
|
|
}
|
|
|
|
else if(node->pkt->pkttype==PKT_SIGNATURE &&
|
|
|
|
node->pkt->pkt.signature->sig_class==0x18 &&
|
|
|
|
keycount>=2 && node->next==NULL)
|
|
|
|
{
|
|
|
|
/* We might have the problem, as this key has two subkeys in
|
|
|
|
a row without any intervening packets. */
|
|
|
|
|
|
|
|
/* Sanity check */
|
|
|
|
if(last==NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Temporarily attach node to sknode. */
|
|
|
|
node->next=sknode->next;
|
|
|
|
sknode->next=node;
|
|
|
|
last->next=NULL;
|
|
|
|
|
2002-12-01 20:59:04 +00:00
|
|
|
/* Note we aren't checking whether this binding sig is a
|
|
|
|
selfsig. This is not necessary here as the subkey and
|
|
|
|
binding sig will be rejected later if that is the
|
|
|
|
case. */
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
if(check_key_signature(keyblock,node,NULL))
|
|
|
|
{
|
|
|
|
/* Not a match, so undo the changes. */
|
|
|
|
sknode->next=node->next;
|
|
|
|
last->next=node;
|
|
|
|
node->next=NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sknode->flag |= 1; /* Mark it good so we don't need to
|
|
|
|
check it again */
|
|
|
|
changed=1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
keycount=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2002-09-02 10:59:04 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
|
|
|
|
{
|
|
|
|
byte array[MAX_FINGERPRINT_LEN], *s;
|
|
|
|
char buf[MAX_FINGERPRINT_LEN*2+30], *p;
|
|
|
|
size_t i, n;
|
|
|
|
|
|
|
|
sprintf (buf, "%u ", reason);
|
|
|
|
p = buf + strlen (buf);
|
|
|
|
|
|
|
|
if (pk)
|
|
|
|
fingerprint_from_pk (pk, array, &n);
|
|
|
|
else
|
|
|
|
fingerprint_from_sk (sk, array, &n);
|
|
|
|
s = array;
|
|
|
|
for (i=0; i < n ; i++, s++, p += 2)
|
|
|
|
sprintf (p, "%02X", *s);
|
|
|
|
|
|
|
|
write_status_text (STATUS_IMPORT_OK, buf);
|
|
|
|
}
|
|
|
|
|
2004-02-12 16:31:07 +00:00
|
|
|
static void
|
2002-12-22 20:53:20 +00:00
|
|
|
print_import_check (PKT_public_key * pk, PKT_user_id * id)
|
|
|
|
{
|
2003-02-02 15:47:43 +00:00
|
|
|
char * buf;
|
2002-12-22 20:53:20 +00:00
|
|
|
byte fpr[24];
|
|
|
|
u32 keyid[2];
|
2002-12-27 22:17:25 +00:00
|
|
|
size_t i, pos = 0, n;
|
2002-12-22 20:53:20 +00:00
|
|
|
|
|
|
|
buf = m_alloc (17+41+id->len+32);
|
|
|
|
keyid_from_pk (pk, keyid);
|
|
|
|
sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
|
|
|
|
pos = 17;
|
|
|
|
fingerprint_from_pk (pk, fpr, &n);
|
|
|
|
for (i = 0; i < n; i++, pos += 2)
|
|
|
|
sprintf (buf+pos, "%02X", fpr[i]);
|
|
|
|
strcat (buf, " ");
|
|
|
|
pos += 1;
|
2003-02-02 15:47:43 +00:00
|
|
|
strcat (buf, id->name);
|
2002-12-22 20:53:20 +00:00
|
|
|
write_status_text (STATUS_IMPORT_CHECK, buf);
|
|
|
|
m_free (buf);
|
|
|
|
}
|
|
|
|
|
2004-02-12 19:18:27 +00:00
|
|
|
static void
|
|
|
|
check_prefs(KBNODE keyblock)
|
|
|
|
{
|
|
|
|
KBNODE node;
|
|
|
|
u32 keyid[2];
|
|
|
|
int problem=0;
|
|
|
|
|
|
|
|
merge_keys_and_selfsig(keyblock);
|
|
|
|
keyid_from_pk(keyblock->pkt->pkt.public_key,keyid);
|
|
|
|
|
|
|
|
for(node=keyblock;node;node=node->next)
|
|
|
|
{
|
|
|
|
if(node->pkt->pkttype==PKT_USER_ID
|
|
|
|
&& node->pkt->pkt.user_id->created
|
|
|
|
&& node->pkt->pkt.user_id->prefs)
|
|
|
|
{
|
|
|
|
PKT_user_id *uid=node->pkt->pkt.user_id;
|
|
|
|
prefitem_t *prefs=uid->prefs;
|
|
|
|
char *user=utf8_to_native(uid->name,strlen(uid->name),0);
|
|
|
|
|
|
|
|
for(;prefs->type;prefs++)
|
|
|
|
{
|
|
|
|
char num[10]; /* prefs->value is a byte, so we're over
|
|
|
|
safe here */
|
|
|
|
|
|
|
|
sprintf(num,"%u",prefs->value);
|
|
|
|
|
|
|
|
if(prefs->type==PREFTYPE_SYM)
|
|
|
|
{
|
|
|
|
if(check_cipher_algo(prefs->value))
|
|
|
|
{
|
|
|
|
const char *algo=cipher_algo_to_string(prefs->value);
|
|
|
|
if(!problem)
|
|
|
|
log_info(_("WARNING: key %08lX contains preferences"
|
|
|
|
" for unavailable algorithms:\n"),
|
|
|
|
(ulong)keyid[1]);
|
|
|
|
log_info(_(" \"%s\": preference for cipher"
|
|
|
|
" algorithm %s\n"),user,algo?algo:num);
|
|
|
|
problem=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(prefs->type==PREFTYPE_HASH)
|
|
|
|
{
|
|
|
|
if(check_digest_algo(prefs->value))
|
|
|
|
{
|
|
|
|
const char *algo=digest_algo_to_string(prefs->value);
|
|
|
|
if(!problem)
|
|
|
|
log_info(_("WARNING: key %08lX contains preferences"
|
|
|
|
" for unavailable algorithms:\n"),
|
|
|
|
(ulong)keyid[1]);
|
|
|
|
log_info(_(" \"%s\": preference for digest"
|
|
|
|
" algorithm %s\n"),user,algo?algo:num);
|
|
|
|
problem=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(prefs->type==PREFTYPE_ZIP)
|
|
|
|
{
|
|
|
|
if(check_compress_algo(prefs->value))
|
|
|
|
{
|
|
|
|
const char *algo=compress_algo_to_string(prefs->value);
|
|
|
|
if(!problem)
|
|
|
|
log_info(_("WARNING: key %08lX contains preferences"
|
|
|
|
" for unavailable algorithms:\n"),
|
|
|
|
(ulong)keyid[1]);
|
|
|
|
log_info(_(" \"%s\": preference for compression"
|
|
|
|
" algorithm %s\n"),user,algo?algo:num);
|
|
|
|
problem=1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_free(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(problem)
|
|
|
|
{
|
2004-02-14 01:54:12 +00:00
|
|
|
log_info(_("it is strongly suggested that you update"
|
|
|
|
" your preferences and\n"));
|
|
|
|
log_info(_("re-distribute this key to avoid potential algorithm"
|
|
|
|
" mismatch problems\n"));
|
2004-02-12 19:18:27 +00:00
|
|
|
|
|
|
|
if(!opt.batch)
|
|
|
|
{
|
|
|
|
STRLIST sl=NULL,locusr=NULL;
|
|
|
|
size_t fprlen=0;
|
|
|
|
byte fpr[MAX_FINGERPRINT_LEN],*p;
|
|
|
|
char username[(MAX_FINGERPRINT_LEN*2)+1];
|
2004-02-14 05:03:45 +00:00
|
|
|
unsigned int i;
|
2004-02-12 19:18:27 +00:00
|
|
|
|
|
|
|
p=fingerprint_from_pk(keyblock->pkt->pkt.public_key,fpr,&fprlen);
|
|
|
|
for(i=0;i<fprlen;i++,p++)
|
|
|
|
sprintf(username+2*i,"%02X",*p);
|
|
|
|
add_to_strlist(&locusr,username);
|
|
|
|
|
|
|
|
append_to_strlist(&sl,"updpref");
|
|
|
|
append_to_strlist(&sl,"save");
|
|
|
|
|
|
|
|
keyedit_menu( username, locusr, sl, 1, 1 );
|
|
|
|
free_strlist(sl);
|
|
|
|
free_strlist(locusr);
|
|
|
|
}
|
|
|
|
else if(!opt.quiet)
|
|
|
|
log_info(_("you can update your preferences with:"
|
|
|
|
" gpg --edit-key %08lX updpref save\n"),(ulong)keyid[1]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-02-16 20:05:02 +00:00
|
|
|
/****************
|
|
|
|
* Try to import one keyblock. Return an error only in serious cases, but
|
|
|
|
* never for an invalid keyblock. It uses log_error to increase the
|
|
|
|
* internal errorcount, so that invalid input can be detected by programs
|
2002-06-29 13:46:34 +00:00
|
|
|
* which called g10.
|
1998-02-16 20:05:02 +00:00
|
|
|
*/
|
|
|
|
static int
|
2002-09-23 13:03:52 +00:00
|
|
|
import_one( const char *fname, KBNODE keyblock,
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
struct stats_s *stats, unsigned int options )
|
1998-02-16 20:05:02 +00:00
|
|
|
{
|
1998-06-29 12:30:57 +00:00
|
|
|
PKT_public_key *pk;
|
|
|
|
PKT_public_key *pk_orig;
|
1998-02-16 20:05:02 +00:00
|
|
|
KBNODE node, uidnode;
|
1998-02-17 20:48:52 +00:00
|
|
|
KBNODE keyblock_orig = NULL;
|
1998-02-16 20:05:02 +00:00
|
|
|
u32 keyid[2];
|
|
|
|
int rc = 0;
|
1998-08-11 17:29:34 +00:00
|
|
|
int new_key = 0;
|
1998-09-29 16:15:15 +00:00
|
|
|
int mod_key = 0;
|
2002-12-13 21:10:53 +00:00
|
|
|
int non_self = 0;
|
1998-02-16 20:05:02 +00:00
|
|
|
|
1998-04-14 17:51:16 +00:00
|
|
|
/* get the key and print some info about it */
|
1998-06-29 12:30:57 +00:00
|
|
|
node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
|
|
|
|
if( !node )
|
|
|
|
BUG();
|
1998-02-16 20:05:02 +00:00
|
|
|
|
1998-06-29 12:30:57 +00:00
|
|
|
pk = node->pkt->pkt.public_key;
|
|
|
|
keyid_from_pk( pk, keyid );
|
1998-02-16 20:05:02 +00:00
|
|
|
uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
|
|
|
|
|
2002-12-26 22:22:50 +00:00
|
|
|
if( opt.verbose && !opt.interactive ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_info( "pub %4u%c/%08lX %s ",
|
1998-06-29 12:30:57 +00:00
|
|
|
nbits_from_pk( pk ),
|
|
|
|
pubkey_letter( pk->pubkey_algo ),
|
|
|
|
(ulong)keyid[1], datestr_from_pk(pk) );
|
1998-02-16 20:05:02 +00:00
|
|
|
if( uidnode )
|
2000-07-14 17:34:53 +00:00
|
|
|
print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
|
|
|
|
uidnode->pkt->pkt.user_id->len );
|
1998-02-16 20:05:02 +00:00
|
|
|
putc('\n', stderr);
|
|
|
|
}
|
|
|
|
if( !uidnode ) {
|
1999-09-01 13:40:07 +00:00
|
|
|
log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
|
1998-02-16 20:05:02 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2002-08-18 17:24:21 +00:00
|
|
|
|
2002-08-19 08:28:00 +00:00
|
|
|
if (opt.interactive) {
|
2003-01-03 21:41:53 +00:00
|
|
|
if(is_status_enabled())
|
|
|
|
print_import_check (pk, uidnode->pkt->pkt.user_id);
|
2003-02-02 15:47:43 +00:00
|
|
|
merge_keys_and_selfsig (keyblock);
|
2002-08-19 08:28:00 +00:00
|
|
|
tty_printf ("\n");
|
|
|
|
show_basic_key_info (keyblock);
|
|
|
|
tty_printf ("\n");
|
|
|
|
if (!cpr_get_answer_is_yes ("import.okay",
|
|
|
|
"Do you want to import this key? (y/N) "))
|
2002-08-18 17:24:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
|
|
|
|
clear_kbnode_flags( keyblock );
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
|
|
|
|
&& opt.verbose)
|
2003-04-09 01:57:46 +00:00
|
|
|
log_info(_("key %08lX: PKS subkey corruption repaired\n"),
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
(ulong)keyid[1]);
|
|
|
|
|
2002-12-13 21:10:53 +00:00
|
|
|
rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
|
1998-02-16 20:05:02 +00:00
|
|
|
if( rc )
|
|
|
|
return rc== -1? 0:rc;
|
1998-02-17 20:48:52 +00:00
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* If we allow such a thing, mark unsigned uids as valid */
|
1999-07-22 18:11:55 +00:00
|
|
|
if( opt.allow_non_selfsigned_uid )
|
2002-06-29 13:46:34 +00:00
|
|
|
for( node=keyblock; node; node = node->next )
|
|
|
|
if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
|
|
|
|
{
|
|
|
|
char *user=utf8_to_native(node->pkt->pkt.user_id->name,
|
|
|
|
node->pkt->pkt.user_id->len,0);
|
|
|
|
node->flag |= 1;
|
|
|
|
log_info( _("key %08lX: accepted non self-signed user ID '%s'\n"),
|
|
|
|
(ulong)keyid[1],user);
|
|
|
|
m_free(user);
|
|
|
|
}
|
1999-07-22 18:11:55 +00:00
|
|
|
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
log_error( _("key %08lX: no valid user IDs\n"), (ulong)keyid[1]);
|
|
|
|
if( !opt.quiet )
|
|
|
|
log_info(_("this may be caused by a missing self-signature\n"));
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->no_user_id++;
|
1998-02-16 20:05:02 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do we have this key already in one of our pubrings ? */
|
2002-06-29 13:46:34 +00:00
|
|
|
pk_orig = m_alloc_clear( sizeof *pk_orig );
|
2002-11-13 17:43:27 +00:00
|
|
|
rc = get_pubkey_fast ( pk_orig, keyid );
|
2002-06-29 13:46:34 +00:00
|
|
|
if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_error( _("key %08lX: public key not found: %s\n"),
|
2002-06-29 13:46:34 +00:00
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
2003-12-31 04:58:52 +00:00
|
|
|
else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
|
|
|
|
{
|
2000-09-18 14:35:34 +00:00
|
|
|
if( opt.verbose )
|
2003-12-31 04:58:52 +00:00
|
|
|
log_info( _("key %08lX: new key - skipped\n"), (ulong)keyid[1] );
|
2000-09-18 14:35:34 +00:00
|
|
|
rc = 0;
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->skipped_new_keys++;
|
2003-12-31 04:58:52 +00:00
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
else if( rc ) { /* insert this key */
|
2002-06-29 13:46:34 +00:00
|
|
|
KEYDB_HANDLE hd = keydb_new (0);
|
|
|
|
|
|
|
|
rc = keydb_locate_writable (hd, NULL);
|
|
|
|
if (rc) {
|
|
|
|
log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
|
|
|
|
keydb_release (hd);
|
|
|
|
return G10ERR_GENERAL;
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
if( opt.verbose > 1 )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
|
|
|
|
rc = keydb_insert_keyblock (hd, keyblock );
|
|
|
|
if (rc)
|
|
|
|
log_error (_("error writing keyring `%s': %s\n"),
|
|
|
|
keydb_get_resource_name (hd), g10_errstr(rc));
|
|
|
|
else
|
2002-10-01 17:32:06 +00:00
|
|
|
{
|
|
|
|
/* This should not be possible since we delete the
|
|
|
|
ownertrust when a key is deleted, but it can happen if
|
|
|
|
the keyring and trustdb are out of sync. It can also
|
|
|
|
be made to happen with the trusted-key command. */
|
|
|
|
|
2002-10-30 03:11:57 +00:00
|
|
|
clear_ownertrusts (pk);
|
2002-12-13 21:10:53 +00:00
|
|
|
if(non_self)
|
|
|
|
revalidation_mark ();
|
2002-10-01 17:32:06 +00:00
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
keydb_release (hd);
|
|
|
|
|
|
|
|
/* we are ready */
|
|
|
|
if( !opt.quiet ) {
|
2002-08-19 08:28:00 +00:00
|
|
|
char *p=get_user_id_printable (keyid);
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: public key \"%s\" imported\n"),
|
|
|
|
(ulong)keyid[1],p);
|
|
|
|
m_free(p);
|
|
|
|
}
|
1999-07-14 17:47:23 +00:00
|
|
|
if( is_status_enabled() ) {
|
|
|
|
char *us = get_long_user_id_string( keyid );
|
|
|
|
write_status_text( STATUS_IMPORTED, us );
|
2002-06-29 13:46:34 +00:00
|
|
|
m_free(us);
|
2002-09-02 10:59:04 +00:00
|
|
|
print_import_ok (pk,NULL, 1);
|
1999-07-14 17:47:23 +00:00
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->imported++;
|
1998-10-25 19:00:01 +00:00
|
|
|
if( is_RSA( pk->pubkey_algo ) )
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->imported_rsa++;
|
1998-08-11 17:29:34 +00:00
|
|
|
new_key = 1;
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
else { /* merge */
|
2002-06-29 13:46:34 +00:00
|
|
|
KEYDB_HANDLE hd;
|
1998-05-26 13:38:00 +00:00
|
|
|
int n_uids, n_sigs, n_subk;
|
1998-02-17 20:48:52 +00:00
|
|
|
|
|
|
|
/* Compare the original against the new key; just to be sure nothing
|
|
|
|
* weird is going on */
|
1998-06-29 12:30:57 +00:00
|
|
|
if( cmp_public_keys( pk_orig, pk ) ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_error( _("key %08lX: doesn't match our copy\n"),
|
1998-07-08 09:29:43 +00:00
|
|
|
(ulong)keyid[1]);
|
1998-02-17 20:48:52 +00:00
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* now read the original keyblock */
|
2002-06-29 13:46:34 +00:00
|
|
|
hd = keydb_new (0);
|
|
|
|
{
|
|
|
|
byte afp[MAX_FINGERPRINT_LEN];
|
|
|
|
size_t an;
|
|
|
|
|
|
|
|
fingerprint_from_pk (pk_orig, afp, &an);
|
|
|
|
while (an < MAX_FINGERPRINT_LEN)
|
|
|
|
afp[an++] = 0;
|
|
|
|
rc = keydb_search_fpr (hd, afp);
|
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
if( rc ) {
|
2002-06-29 13:46:34 +00:00
|
|
|
log_error (_("key %08lX: can't locate original keyblock: %s\n"),
|
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
|
|
|
keydb_release (hd);
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
rc = keydb_get_keyblock (hd, &keyblock_orig );
|
|
|
|
if (rc) {
|
|
|
|
log_error (_("key %08lX: can't read original keyblock: %s\n"),
|
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
|
|
|
keydb_release (hd);
|
1998-02-17 20:48:52 +00:00
|
|
|
goto leave;
|
|
|
|
}
|
1999-05-22 20:54:54 +00:00
|
|
|
|
|
|
|
collapse_uids( &keyblock );
|
1998-02-17 20:48:52 +00:00
|
|
|
/* and try to merge the block */
|
|
|
|
clear_kbnode_flags( keyblock_orig );
|
1999-05-19 14:12:26 +00:00
|
|
|
clear_kbnode_flags( keyblock );
|
1999-05-22 20:54:54 +00:00
|
|
|
n_uids = n_sigs = n_subk = 0;
|
1998-02-17 20:48:52 +00:00
|
|
|
rc = merge_blocks( fname, keyblock_orig, keyblock,
|
1998-05-26 13:38:00 +00:00
|
|
|
keyid, &n_uids, &n_sigs, &n_subk );
|
2002-06-29 13:46:34 +00:00
|
|
|
if( rc ) {
|
|
|
|
keydb_release (hd);
|
1998-02-17 20:48:52 +00:00
|
|
|
goto leave;
|
2002-06-29 13:46:34 +00:00
|
|
|
}
|
1998-05-26 13:38:00 +00:00
|
|
|
if( n_uids || n_sigs || n_subk ) {
|
1998-09-29 16:15:15 +00:00
|
|
|
mod_key = 1;
|
1998-05-26 13:38:00 +00:00
|
|
|
/* keyblock_orig has been updated; write */
|
2002-06-29 13:46:34 +00:00
|
|
|
rc = keydb_update_keyblock (hd, keyblock_orig);
|
|
|
|
if (rc)
|
|
|
|
log_error (_("error writing keyring `%s': %s\n"),
|
|
|
|
keydb_get_resource_name (hd), g10_errstr(rc) );
|
2002-12-13 21:10:53 +00:00
|
|
|
else if(non_self)
|
2002-06-29 13:46:34 +00:00
|
|
|
revalidation_mark ();
|
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
/* we are ready */
|
1998-10-25 19:00:01 +00:00
|
|
|
if( !opt.quiet ) {
|
2002-08-19 08:28:00 +00:00
|
|
|
char *p=get_user_id_printable(keyid);
|
1998-10-25 19:00:01 +00:00
|
|
|
if( n_uids == 1 )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" 1 new user ID\n"),
|
|
|
|
(ulong)keyid[1], p);
|
1998-10-25 19:00:01 +00:00
|
|
|
else if( n_uids )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" %d new user IDs\n"),
|
|
|
|
(ulong)keyid[1], p, n_uids );
|
1998-10-25 19:00:01 +00:00
|
|
|
if( n_sigs == 1 )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" 1 new signature\n"),
|
|
|
|
(ulong)keyid[1], p);
|
1998-10-25 19:00:01 +00:00
|
|
|
else if( n_sigs )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" %d new signatures\n"),
|
|
|
|
(ulong)keyid[1], p, n_sigs );
|
1998-10-25 19:00:01 +00:00
|
|
|
if( n_subk == 1 )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" 1 new subkey\n"),
|
|
|
|
(ulong)keyid[1], p);
|
1998-10-25 19:00:01 +00:00
|
|
|
else if( n_subk )
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" %d new subkeys\n"),
|
|
|
|
(ulong)keyid[1], p, n_subk );
|
|
|
|
m_free(p);
|
1998-10-25 19:00:01 +00:00
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->n_uids +=n_uids;
|
|
|
|
stats->n_sigs +=n_sigs;
|
|
|
|
stats->n_subk +=n_subk;
|
2002-09-02 10:59:04 +00:00
|
|
|
|
|
|
|
if (is_status_enabled ())
|
|
|
|
print_import_ok (pk, NULL,
|
|
|
|
((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
|
1998-10-25 19:00:01 +00:00
|
|
|
}
|
2004-02-12 19:18:27 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (is_status_enabled ())
|
|
|
|
print_import_ok (pk, NULL, 0);
|
|
|
|
|
|
|
|
if( !opt.quiet )
|
|
|
|
{
|
|
|
|
char *p=get_user_id_printable(keyid);
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" not changed\n"),
|
|
|
|
(ulong)keyid[1],p);
|
|
|
|
m_free(p);
|
2004-02-12 19:18:27 +00:00
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->unchanged++;
|
2004-02-12 19:18:27 +00:00
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
keydb_release (hd); hd = NULL;
|
1998-07-21 12:53:38 +00:00
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
leave:
|
2004-02-12 19:18:27 +00:00
|
|
|
|
|
|
|
/* Now that the key is definitely incorporated into the keydb, we
|
|
|
|
need to check if a designated revocation is present or if the
|
|
|
|
prefs are not rational so we can warn the user. */
|
|
|
|
|
2004-02-12 16:31:07 +00:00
|
|
|
if(mod_key)
|
2004-02-12 19:18:27 +00:00
|
|
|
{
|
|
|
|
revocation_present(keyblock_orig);
|
|
|
|
if(seckey_available(keyid)==0)
|
|
|
|
check_prefs(keyblock_orig);
|
|
|
|
}
|
2004-02-12 16:31:07 +00:00
|
|
|
else if(new_key)
|
2004-02-12 19:18:27 +00:00
|
|
|
{
|
|
|
|
revocation_present(keyblock);
|
|
|
|
if(seckey_available(keyid)==0)
|
|
|
|
check_prefs(keyblock);
|
|
|
|
}
|
2004-02-12 16:31:07 +00:00
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
release_kbnode( keyblock_orig );
|
1998-06-29 12:30:57 +00:00
|
|
|
free_public_key( pk_orig );
|
2002-06-29 13:46:34 +00:00
|
|
|
|
1998-06-29 12:30:57 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2002-10-23 15:59:45 +00:00
|
|
|
/* Walk a secret keyblock and produce a public keyblock out of it. */
|
|
|
|
static KBNODE
|
|
|
|
sec_to_pub_keyblock(KBNODE sec_keyblock)
|
|
|
|
{
|
|
|
|
KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
|
|
|
|
|
|
|
|
while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
|
|
|
|
{
|
|
|
|
KBNODE pubnode;
|
|
|
|
|
|
|
|
if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
|
|
|
|
secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
|
|
|
|
{
|
|
|
|
/* Make a public key. We only need to convert enough to
|
|
|
|
write the keyblock out. */
|
|
|
|
|
|
|
|
PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
|
|
|
|
PACKET *pkt=m_alloc_clear(sizeof(PACKET));
|
|
|
|
PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if(secnode->pkt->pkttype==PKT_SECRET_KEY)
|
|
|
|
pkt->pkttype=PKT_PUBLIC_KEY;
|
|
|
|
else
|
|
|
|
pkt->pkttype=PKT_PUBLIC_SUBKEY;
|
|
|
|
|
|
|
|
pkt->pkt.public_key=pk;
|
|
|
|
|
|
|
|
pk->version=sk->version;
|
|
|
|
pk->timestamp=sk->timestamp;
|
|
|
|
pk->expiredate=sk->expiredate;
|
|
|
|
pk->pubkey_algo=sk->pubkey_algo;
|
|
|
|
|
|
|
|
n=pubkey_get_npkey(pk->pubkey_algo);
|
|
|
|
if(n==0)
|
2004-02-14 01:54:12 +00:00
|
|
|
{
|
|
|
|
/* we can't properly extract the pubkey without knowing
|
|
|
|
the number of MPIs */
|
|
|
|
release_kbnode(pub_keyblock);
|
|
|
|
return NULL;
|
|
|
|
}
|
2002-10-23 15:59:45 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i=0;i<n;i++)
|
|
|
|
pk->pkey[i]=mpi_copy(sk->skey[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
pubnode=new_kbnode(pkt);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pubnode=clone_kbnode(secnode);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(pub_keyblock==NULL)
|
|
|
|
pub_keyblock=pubnode;
|
|
|
|
else
|
|
|
|
add_kbnode(pub_keyblock,pubnode);
|
|
|
|
}
|
|
|
|
|
|
|
|
return pub_keyblock;
|
|
|
|
}
|
1998-06-29 12:30:57 +00:00
|
|
|
|
|
|
|
/****************
|
|
|
|
* Ditto for secret keys. Handling is simpler than for public keys.
|
2002-06-29 13:46:34 +00:00
|
|
|
* We allow secret key importing only when allow is true, this is so
|
|
|
|
* that a secret key can not be imported accidently and thereby tampering
|
|
|
|
* with the trust calculation.
|
1998-06-29 12:30:57 +00:00
|
|
|
*/
|
|
|
|
static int
|
2002-06-29 13:46:34 +00:00
|
|
|
import_secret_one( const char *fname, KBNODE keyblock,
|
2002-10-23 15:59:45 +00:00
|
|
|
struct stats_s *stats, unsigned int options)
|
1998-06-29 12:30:57 +00:00
|
|
|
{
|
|
|
|
PKT_secret_key *sk;
|
|
|
|
KBNODE node, uidnode;
|
|
|
|
u32 keyid[2];
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
/* get the key and print some info about it */
|
|
|
|
node = find_kbnode( keyblock, PKT_SECRET_KEY );
|
|
|
|
if( !node )
|
|
|
|
BUG();
|
|
|
|
|
|
|
|
sk = node->pkt->pkt.secret_key;
|
|
|
|
keyid_from_sk( sk, keyid );
|
|
|
|
uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
|
|
|
|
|
|
|
|
if( opt.verbose ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_info( "sec %4u%c/%08lX %s ",
|
1998-06-29 12:30:57 +00:00
|
|
|
nbits_from_sk( sk ),
|
|
|
|
pubkey_letter( sk->pubkey_algo ),
|
|
|
|
(ulong)keyid[1], datestr_from_sk(sk) );
|
|
|
|
if( uidnode )
|
2000-07-14 17:34:53 +00:00
|
|
|
print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
|
|
|
|
uidnode->pkt->pkt.user_id->len );
|
1998-06-29 12:30:57 +00:00
|
|
|
putc('\n', stderr);
|
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->secret_read++;
|
|
|
|
|
1998-06-29 12:30:57 +00:00
|
|
|
if( !uidnode ) {
|
1999-09-01 13:40:07 +00:00
|
|
|
log_error( _("key %08lX: no user ID\n"), (ulong)keyid[1]);
|
1998-06-29 12:30:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-10-02 22:01:29 +00:00
|
|
|
if(sk->protect.algo>110)
|
|
|
|
{
|
|
|
|
log_error(_("key %08lX: secret key with invalid cipher %d "
|
|
|
|
"- skipped\n"),(ulong)keyid[1],sk->protect.algo);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1998-06-29 12:30:57 +00:00
|
|
|
clear_kbnode_flags( keyblock );
|
|
|
|
|
|
|
|
/* do we have this key already in one of our secrings ? */
|
|
|
|
rc = seckey_available( keyid );
|
2003-12-31 04:58:52 +00:00
|
|
|
if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
|
|
|
|
{
|
|
|
|
/* simply insert this key */
|
2002-06-29 13:46:34 +00:00
|
|
|
KEYDB_HANDLE hd = keydb_new (1);
|
|
|
|
|
|
|
|
/* get default resource */
|
|
|
|
rc = keydb_locate_writable (hd, NULL);
|
|
|
|
if (rc) {
|
2003-12-31 04:58:52 +00:00
|
|
|
log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
|
|
|
|
keydb_release (hd);
|
|
|
|
return G10ERR_GENERAL;
|
2002-06-29 13:46:34 +00:00
|
|
|
}
|
|
|
|
rc = keydb_insert_keyblock (hd, keyblock );
|
|
|
|
if (rc)
|
2003-12-31 04:58:52 +00:00
|
|
|
log_error (_("error writing keyring `%s': %s\n"),
|
|
|
|
keydb_get_resource_name (hd), g10_errstr(rc) );
|
2002-06-29 13:46:34 +00:00
|
|
|
keydb_release (hd);
|
1998-06-29 12:30:57 +00:00
|
|
|
/* we are ready */
|
1999-04-18 08:18:52 +00:00
|
|
|
if( !opt.quiet )
|
2003-12-31 04:58:52 +00:00
|
|
|
log_info( _("key %08lX: secret key imported\n"), (ulong)keyid[1]);
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->secret_imported++;
|
2002-09-02 10:59:04 +00:00
|
|
|
if (is_status_enabled ())
|
2003-12-31 04:58:52 +00:00
|
|
|
print_import_ok (NULL, sk, 1|16);
|
2002-10-23 15:59:45 +00:00
|
|
|
|
|
|
|
if(options&IMPORT_SK2PK)
|
|
|
|
{
|
|
|
|
/* Try and make a public key out of this. */
|
|
|
|
|
|
|
|
KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
|
2004-02-14 01:54:12 +00:00
|
|
|
if(pub_keyblock)
|
|
|
|
{
|
|
|
|
import_one(fname,pub_keyblock,stats,opt.import_options);
|
|
|
|
release_kbnode(pub_keyblock);
|
|
|
|
}
|
2002-10-23 15:59:45 +00:00
|
|
|
}
|
|
|
|
|
2004-02-12 19:18:27 +00:00
|
|
|
/* Now that the key is definitely incorporated into the keydb,
|
|
|
|
if we have the public part of this key, we need to check if
|
|
|
|
the prefs are rational. */
|
|
|
|
node=get_pubkeyblock(keyid);
|
|
|
|
if(node)
|
|
|
|
{
|
|
|
|
check_prefs(node);
|
|
|
|
release_kbnode(node);
|
|
|
|
}
|
2003-12-31 04:58:52 +00:00
|
|
|
}
|
1998-06-29 12:30:57 +00:00
|
|
|
else if( !rc ) { /* we can't merge secret keys */
|
1999-05-22 20:54:54 +00:00
|
|
|
log_error( _("key %08lX: already in secret keyring\n"),
|
|
|
|
(ulong)keyid[1]);
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->secret_dups++;
|
2002-09-02 10:59:04 +00:00
|
|
|
if (is_status_enabled ())
|
|
|
|
print_import_ok (NULL, sk, 16);
|
2002-10-23 15:59:45 +00:00
|
|
|
|
|
|
|
/* TODO: if we ever do merge secret keys, make sure to handle
|
|
|
|
the sec_to_pub_keyblock feature as well. */
|
1998-06-29 12:30:57 +00:00
|
|
|
}
|
|
|
|
else
|
1999-05-22 20:54:54 +00:00
|
|
|
log_error( _("key %08lX: secret key not found: %s\n"),
|
2002-06-29 13:46:34 +00:00
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
1998-06-29 12:30:57 +00:00
|
|
|
|
1998-02-16 20:05:02 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
|
1998-02-18 13:58:46 +00:00
|
|
|
/****************
|
1998-04-14 17:51:16 +00:00
|
|
|
* Import a revocation certificate; this is a single signature packet.
|
1998-02-18 13:58:46 +00:00
|
|
|
*/
|
|
|
|
static int
|
2002-06-29 13:46:34 +00:00
|
|
|
import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
|
1998-02-18 13:58:46 +00:00
|
|
|
{
|
1998-06-29 12:30:57 +00:00
|
|
|
PKT_public_key *pk=NULL;
|
1998-02-18 13:58:46 +00:00
|
|
|
KBNODE onode, keyblock = NULL;
|
2002-06-29 13:46:34 +00:00
|
|
|
KEYDB_HANDLE hd = NULL;
|
1998-02-18 13:58:46 +00:00
|
|
|
u32 keyid[2];
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
assert( !node->next );
|
|
|
|
assert( node->pkt->pkttype == PKT_SIGNATURE );
|
|
|
|
assert( node->pkt->pkt.signature->sig_class == 0x20 );
|
|
|
|
|
|
|
|
keyid[0] = node->pkt->pkt.signature->keyid[0];
|
|
|
|
keyid[1] = node->pkt->pkt.signature->keyid[1];
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
pk = m_alloc_clear( sizeof *pk );
|
1998-06-29 12:30:57 +00:00
|
|
|
rc = get_pubkey( pk, keyid );
|
2002-06-29 13:46:34 +00:00
|
|
|
if( rc == G10ERR_NO_PUBKEY ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
log_error( _("key %08lX: no public key - "
|
|
|
|
"can't apply revocation certificate\n"), (ulong)keyid[1]);
|
1998-02-18 13:58:46 +00:00
|
|
|
rc = 0;
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
else if( rc ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_error( _("key %08lX: public key not found: %s\n"),
|
2002-06-29 13:46:34 +00:00
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
1998-02-18 13:58:46 +00:00
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* read the original keyblock */
|
2002-06-29 13:46:34 +00:00
|
|
|
hd = keydb_new (0);
|
|
|
|
{
|
|
|
|
byte afp[MAX_FINGERPRINT_LEN];
|
|
|
|
size_t an;
|
|
|
|
|
|
|
|
fingerprint_from_pk (pk, afp, &an);
|
|
|
|
while (an < MAX_FINGERPRINT_LEN)
|
|
|
|
afp[an++] = 0;
|
|
|
|
rc = keydb_search_fpr (hd, afp);
|
|
|
|
}
|
|
|
|
if (rc) {
|
|
|
|
log_error (_("key %08lX: can't locate original keyblock: %s\n"),
|
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
rc = keydb_get_keyblock (hd, &keyblock );
|
|
|
|
if (rc) {
|
|
|
|
log_error (_("key %08lX: can't read original keyblock: %s\n"),
|
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
1998-02-18 13:58:46 +00:00
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* it is okay, that node is not in keyblock because
|
|
|
|
* check_key_signature works fine for sig_class 0x20 in this
|
|
|
|
* special case. */
|
|
|
|
rc = check_key_signature( keyblock, node, NULL);
|
|
|
|
if( rc ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_error( _("key %08lX: invalid revocation certificate"
|
2002-06-29 13:46:34 +00:00
|
|
|
": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
|
|
|
|
goto leave;
|
1998-02-18 13:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-04-14 17:51:16 +00:00
|
|
|
/* check whether we already have this */
|
1998-02-18 13:58:46 +00:00
|
|
|
for(onode=keyblock->next; onode; onode=onode->next ) {
|
|
|
|
if( onode->pkt->pkttype == PKT_USER_ID )
|
|
|
|
break;
|
|
|
|
else if( onode->pkt->pkttype == PKT_SIGNATURE
|
2003-08-13 03:31:36 +00:00
|
|
|
&& !cmp_signatures(node->pkt->pkt.signature,
|
|
|
|
onode->pkt->pkt.signature))
|
|
|
|
{
|
1998-02-18 13:58:46 +00:00
|
|
|
rc = 0;
|
|
|
|
goto leave; /* yes, we already know about it */
|
2003-08-13 03:31:36 +00:00
|
|
|
}
|
1998-02-18 13:58:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* insert it */
|
|
|
|
insert_kbnode( keyblock, clone_kbnode(node), 0 );
|
|
|
|
|
|
|
|
/* and write the keyblock back */
|
2002-06-29 13:46:34 +00:00
|
|
|
rc = keydb_update_keyblock (hd, keyblock );
|
|
|
|
if (rc)
|
|
|
|
log_error (_("error writing keyring `%s': %s\n"),
|
|
|
|
keydb_get_resource_name (hd), g10_errstr(rc) );
|
|
|
|
keydb_release (hd); hd = NULL;
|
1998-02-18 13:58:46 +00:00
|
|
|
/* we are ready */
|
2002-06-29 13:46:34 +00:00
|
|
|
if( !opt.quiet ) {
|
2002-08-19 08:28:00 +00:00
|
|
|
char *p=get_user_id_printable (keyid);
|
2002-06-29 13:46:34 +00:00
|
|
|
log_info( _("key %08lX: \"%s\" revocation certificate imported\n"),
|
|
|
|
(ulong)keyid[1],p);
|
|
|
|
m_free(p);
|
2000-07-14 17:34:53 +00:00
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
stats->n_revoc++;
|
2003-04-23 21:18:39 +00:00
|
|
|
|
|
|
|
/* If the key we just revoked was ultimately trusted, remove its
|
|
|
|
ultimate trust. This doesn't stop the user from putting the
|
|
|
|
ultimate trust back, but is a reasonable solution for now. */
|
|
|
|
if(get_ownertrust(pk)==TRUST_ULTIMATE)
|
|
|
|
clear_ownertrusts(pk);
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
revalidation_mark ();
|
1998-02-18 13:58:46 +00:00
|
|
|
|
|
|
|
leave:
|
2002-06-29 13:46:34 +00:00
|
|
|
keydb_release (hd);
|
1998-02-18 13:58:46 +00:00
|
|
|
release_kbnode( keyblock );
|
1998-06-29 12:30:57 +00:00
|
|
|
free_public_key( pk );
|
1998-02-18 13:58:46 +00:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-02-16 20:05:02 +00:00
|
|
|
/****************
|
1998-04-14 17:51:16 +00:00
|
|
|
* loop over the keyblock and check all self signatures.
|
1998-02-16 20:05:02 +00:00
|
|
|
* Mark all user-ids with a self-signature by setting flag bit 0.
|
|
|
|
* Mark all user-ids with an invalid self-signature by setting bit 1.
|
2002-08-22 17:47:42 +00:00
|
|
|
* This works also for subkeys, here the subkey is marked. Invalid or
|
|
|
|
* extra subkey sigs (binding or revocation) are marked for deletion.
|
2002-12-13 21:10:53 +00:00
|
|
|
* non_self is set to true if there are any sigs other than self-sigs
|
|
|
|
* in this keyblock.
|
1998-02-16 20:05:02 +00:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
chk_self_sigs( const char *fname, KBNODE keyblock,
|
2002-12-13 21:10:53 +00:00
|
|
|
PKT_public_key *pk, u32 *keyid, int *non_self )
|
1998-02-16 20:05:02 +00:00
|
|
|
{
|
2002-08-22 17:47:42 +00:00
|
|
|
KBNODE n,knode=NULL;
|
1998-02-16 20:05:02 +00:00
|
|
|
PKT_signature *sig;
|
|
|
|
int rc;
|
2002-08-22 17:47:42 +00:00
|
|
|
u32 bsdate=0,rsdate=0;
|
|
|
|
KBNODE bsnode=NULL,rsnode=NULL;
|
1998-02-16 20:05:02 +00:00
|
|
|
|
|
|
|
for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
|
2002-08-22 17:47:42 +00:00
|
|
|
if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
|
|
|
|
{
|
|
|
|
knode=n;
|
|
|
|
bsdate=0;
|
|
|
|
rsdate=0;
|
|
|
|
bsnode=NULL;
|
|
|
|
rsnode=NULL;
|
2002-12-13 21:10:53 +00:00
|
|
|
continue;
|
2002-08-22 17:47:42 +00:00
|
|
|
}
|
|
|
|
else if( n->pkt->pkttype != PKT_SIGNATURE )
|
1998-02-16 20:05:02 +00:00
|
|
|
continue;
|
|
|
|
sig = n->pkt->pkt.signature;
|
|
|
|
if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
|
2002-12-11 17:50:38 +00:00
|
|
|
|
|
|
|
/* This just caches the sigs for later use. That way we
|
|
|
|
import a fully-cached key which speeds things up. */
|
|
|
|
if(!opt.no_sig_cache)
|
|
|
|
check_key_signature(keyblock,n,NULL);
|
|
|
|
|
1999-01-12 10:20:24 +00:00
|
|
|
if( (sig->sig_class&~3) == 0x10 ) {
|
|
|
|
KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
|
|
|
|
if( !unode ) {
|
1999-09-01 13:40:07 +00:00
|
|
|
log_error( _("key %08lX: no user ID for signature\n"),
|
1999-01-12 10:20:24 +00:00
|
|
|
(ulong)keyid[1]);
|
|
|
|
return -1; /* the complete keyblock is invalid */
|
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* If it hasn't been marked valid yet, keep trying */
|
|
|
|
if(!(unode->flag&1)) {
|
|
|
|
rc = check_key_signature( keyblock, n, NULL);
|
|
|
|
if( rc )
|
|
|
|
{
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if( opt.verbose )
|
|
|
|
{
|
|
|
|
char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
|
2002-06-29 13:46:34 +00:00
|
|
|
strlen(unode->pkt->pkt.user_id->name),0);
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
log_info( rc == G10ERR_PUBKEY_ALGO ?
|
|
|
|
_("key %08lX: unsupported public key "
|
|
|
|
"algorithm on user id \"%s\"\n"):
|
|
|
|
_("key %08lX: invalid self-signature "
|
|
|
|
"on user id \"%s\"\n"),
|
|
|
|
(ulong)keyid[1],p);
|
|
|
|
m_free(p);
|
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
unode->flag |= 1; /* mark that signature checked */
|
1999-01-12 10:20:24 +00:00
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
1999-01-12 10:20:24 +00:00
|
|
|
else if( sig->sig_class == 0x18 ) {
|
2002-08-22 17:47:42 +00:00
|
|
|
/* Note that this works based solely on the timestamps
|
|
|
|
like the rest of gpg. If the standard gets
|
|
|
|
revocation targets, this may need to be revised. */
|
1999-01-12 10:20:24 +00:00
|
|
|
|
1999-07-22 18:11:55 +00:00
|
|
|
if( !knode ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info( _("key %08lX: no subkey for key binding\n"),
|
|
|
|
(ulong)keyid[1]);
|
1999-02-19 14:54:00 +00:00
|
|
|
n->flag |= 4; /* delete this */
|
1999-01-12 10:20:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2002-08-22 17:47:42 +00:00
|
|
|
rc = check_key_signature( keyblock, n, NULL);
|
|
|
|
if( rc ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info(rc == G10ERR_PUBKEY_ALGO ?
|
2002-08-22 17:47:42 +00:00
|
|
|
_("key %08lX: unsupported public key algorithm\n"):
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
_("key %08lX: invalid subkey binding\n"),
|
|
|
|
(ulong)keyid[1]);
|
2002-08-22 17:47:42 +00:00
|
|
|
n->flag|=4;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* It's valid, so is it newer? */
|
|
|
|
if(sig->timestamp>=bsdate) {
|
|
|
|
knode->flag |= 1; /* the subkey is valid */
|
|
|
|
if(bsnode) {
|
|
|
|
bsnode->flag|=4; /* Delete the last binding
|
|
|
|
sig since this one is
|
|
|
|
newer */
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info(_("key %08lX: removed multiple subkey "
|
|
|
|
"binding\n"),(ulong)keyid[1]);
|
2002-08-22 17:47:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bsnode=n;
|
|
|
|
bsdate=sig->timestamp;
|
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
else
|
2002-08-22 17:47:42 +00:00
|
|
|
n->flag|=4; /* older */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if( sig->sig_class == 0x28 ) {
|
|
|
|
/* We don't actually mark the subkey as revoked right
|
|
|
|
now, so just check that the revocation sig is the
|
|
|
|
most recent valid one. Note that we don't care if
|
|
|
|
the binding sig is newer than the revocation sig.
|
|
|
|
See the comment in getkey.c:merge_selfsigs_subkey for
|
|
|
|
more */
|
|
|
|
if( !knode ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info( _("key %08lX: no subkey for key revocation\n"),
|
|
|
|
(ulong)keyid[1]);
|
2002-08-22 17:47:42 +00:00
|
|
|
n->flag |= 4; /* delete this */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rc = check_key_signature( keyblock, n, NULL);
|
|
|
|
if( rc ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info(rc == G10ERR_PUBKEY_ALGO ?
|
2002-08-22 17:47:42 +00:00
|
|
|
_("key %08lX: unsupported public key algorithm\n"):
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
_("key %08lX: invalid subkey revocation\n"),
|
|
|
|
(ulong)keyid[1]);
|
|
|
|
|
|
|
|
n->flag|=4;
|
2002-08-22 17:47:42 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* It's valid, so is it newer? */
|
|
|
|
if(sig->timestamp>=rsdate) {
|
|
|
|
if(rsnode) {
|
|
|
|
rsnode->flag|=4; /* Delete the last revocation
|
|
|
|
sig since this one is
|
|
|
|
newer */
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info(_("key %08lX: removed multiple subkey "
|
|
|
|
"revocation\n"),(ulong)keyid[1]);
|
2002-08-22 17:47:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rsnode=n;
|
|
|
|
rsdate=sig->timestamp;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
n->flag|=4; /* older */
|
2002-06-29 13:46:34 +00:00
|
|
|
}
|
1999-01-12 10:20:24 +00:00
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
|
|
|
}
|
2002-12-13 21:10:53 +00:00
|
|
|
else
|
|
|
|
*non_self=1;
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
2002-08-22 17:47:42 +00:00
|
|
|
|
1998-01-19 18:54:44 +00:00
|
|
|
return 0;
|
1998-01-16 21:15:24 +00:00
|
|
|
}
|
|
|
|
|
1998-02-16 20:05:02 +00:00
|
|
|
/****************
|
1998-04-14 17:51:16 +00:00
|
|
|
* delete all parts which are invalid and those signatures whose
|
|
|
|
* public key algorithm is not available in this implemenation;
|
1998-02-17 20:48:52 +00:00
|
|
|
* but consider RSA as valid, because parse/build_packets knows
|
|
|
|
* about it.
|
1998-02-16 20:05:02 +00:00
|
|
|
* returns: true if at least one valid user-id is left over.
|
|
|
|
*/
|
|
|
|
static int
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
delete_inv_parts( const char *fname, KBNODE keyblock,
|
|
|
|
u32 *keyid, unsigned int options)
|
1998-02-16 20:05:02 +00:00
|
|
|
{
|
|
|
|
KBNODE node;
|
2002-07-24 03:29:02 +00:00
|
|
|
int nvalid=0, uid_seen=0, subkey_seen=0;
|
1998-01-16 21:15:24 +00:00
|
|
|
|
1998-02-16 20:05:02 +00:00
|
|
|
for(node=keyblock->next; node; node = node->next ) {
|
|
|
|
if( node->pkt->pkttype == PKT_USER_ID ) {
|
1998-02-18 13:58:46 +00:00
|
|
|
uid_seen = 1;
|
1998-02-16 20:05:02 +00:00
|
|
|
if( (node->flag & 2) || !(node->flag & 1) ) {
|
1998-02-17 20:48:52 +00:00
|
|
|
if( opt.verbose ) {
|
1999-09-01 13:40:07 +00:00
|
|
|
log_info( _("key %08lX: skipped user ID '"),
|
1998-07-08 09:29:43 +00:00
|
|
|
(ulong)keyid[1]);
|
2000-07-14 17:34:53 +00:00
|
|
|
print_utf8_string( stderr, node->pkt->pkt.user_id->name,
|
|
|
|
node->pkt->pkt.user_id->len );
|
1998-02-17 20:48:52 +00:00
|
|
|
fputs("'\n", stderr );
|
|
|
|
}
|
1998-02-16 20:05:02 +00:00
|
|
|
delete_kbnode( node ); /* the user-id */
|
|
|
|
/* and all following packets up to the next user-id */
|
1999-04-07 18:58:34 +00:00
|
|
|
while( node->next
|
|
|
|
&& node->next->pkt->pkttype != PKT_USER_ID
|
|
|
|
&& node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
|
|
|
|
&& node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
|
1998-02-16 20:05:02 +00:00
|
|
|
delete_kbnode( node->next );
|
|
|
|
node = node->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
nvalid++;
|
|
|
|
}
|
1999-01-12 10:20:24 +00:00
|
|
|
else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
|
|
|
|
if( (node->flag & 2) || !(node->flag & 1) ) {
|
|
|
|
if( opt.verbose ) {
|
1999-05-22 20:54:54 +00:00
|
|
|
log_info( _("key %08lX: skipped subkey\n"),
|
1999-01-12 10:20:24 +00:00
|
|
|
(ulong)keyid[1]);
|
|
|
|
}
|
|
|
|
delete_kbnode( node ); /* the subkey */
|
|
|
|
/* and all following signature packets */
|
|
|
|
while( node->next
|
|
|
|
&& node->next->pkt->pkttype == PKT_SIGNATURE ) {
|
|
|
|
delete_kbnode( node->next );
|
|
|
|
node = node->next;
|
|
|
|
}
|
|
|
|
}
|
2002-07-24 03:29:02 +00:00
|
|
|
else
|
|
|
|
subkey_seen = 1;
|
1999-01-12 10:20:24 +00:00
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE
|
2002-06-29 13:46:34 +00:00
|
|
|
&& check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
|
|
|
|
&& node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
|
1998-02-17 20:48:52 +00:00
|
|
|
delete_kbnode( node ); /* build_packet() can't handle this */
|
2002-06-29 13:46:34 +00:00
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE &&
|
|
|
|
!node->pkt->pkt.signature->flags.exportable &&
|
* main.h, import.c (parse_import_options, fix_hkp_corruption, import_one,
delete_inv_parts), g10.c (main): New import-option
"repair-hkp-subkey-bug", which repairs as much as possible the HKP
mangling multiple subkeys bug. It is on by default for keyserver
receives, and off by default for regular --import.
* main.h, import.c (import, import_one, delete_inv_parts), hkp.c
(hkp_ask_import), keyserver.c (keyserver_spawn): Use keyserver import
options when doing keyserver receives.
2002-07-24 21:17:19 +00:00
|
|
|
!(options&IMPORT_ALLOW_LOCAL_SIGS) &&
|
2002-06-29 13:46:34 +00:00
|
|
|
seckey_available( node->pkt->pkt.signature->keyid ) ) {
|
1999-04-06 18:04:55 +00:00
|
|
|
/* here we violate the rfc a bit by still allowing
|
|
|
|
* to import non-exportable signature when we have the
|
|
|
|
* the secret key used to create this signature - it
|
|
|
|
* seems that this makes sense */
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info( _("key %08lX: non exportable signature "
|
|
|
|
"(class %02x) - skipped\n"),
|
|
|
|
(ulong)keyid[1], node->pkt->pkt.signature->sig_class );
|
1999-03-11 15:42:06 +00:00
|
|
|
delete_kbnode( node );
|
|
|
|
}
|
1998-02-18 13:58:46 +00:00
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& node->pkt->pkt.signature->sig_class == 0x20 ) {
|
|
|
|
if( uid_seen ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info( _("key %08lX: revocation certificate "
|
|
|
|
"at wrong place - skipped\n"), (ulong)keyid[1]);
|
1998-02-18 13:58:46 +00:00
|
|
|
delete_kbnode( node );
|
|
|
|
}
|
|
|
|
else {
|
2002-06-29 13:46:34 +00:00
|
|
|
/* If the revocation cert is from a different key than
|
|
|
|
the one we're working on don't check it - it's
|
|
|
|
probably from a revocation key and won't be
|
|
|
|
verifiable with this key anyway. */
|
|
|
|
|
|
|
|
if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
|
|
|
|
node->pkt->pkt.signature->keyid[1]==keyid[1])
|
|
|
|
{
|
|
|
|
int rc = check_key_signature( keyblock, node, NULL);
|
|
|
|
if( rc )
|
|
|
|
{
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info( _("key %08lX: invalid revocation "
|
|
|
|
"certificate: %s - skipped\n"),
|
|
|
|
(ulong)keyid[1], g10_errstr(rc));
|
2002-06-29 13:46:34 +00:00
|
|
|
delete_kbnode( node );
|
|
|
|
}
|
1998-02-18 13:58:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-07-24 03:29:02 +00:00
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE &&
|
|
|
|
(node->pkt->pkt.signature->sig_class == 0x18 ||
|
|
|
|
node->pkt->pkt.signature->sig_class == 0x28) &&
|
|
|
|
!subkey_seen ) {
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info( _("key %08lX: subkey signature "
|
|
|
|
"in wrong place - skipped\n"), (ulong)keyid[1]);
|
2002-07-24 03:29:02 +00:00
|
|
|
delete_kbnode( node );
|
|
|
|
}
|
2003-03-24 20:05:53 +00:00
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& !IS_CERT(node->pkt->pkt.signature))
|
|
|
|
{
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(opt.verbose)
|
|
|
|
log_info(_("key %08lX: unexpected signature class (0x%02X) -"
|
|
|
|
" skipped\n"),(ulong)keyid[1],
|
|
|
|
node->pkt->pkt.signature->sig_class);
|
2003-03-24 20:05:53 +00:00
|
|
|
delete_kbnode(node);
|
|
|
|
}
|
1999-02-19 14:54:00 +00:00
|
|
|
else if( (node->flag & 4) ) /* marked for deletion */
|
|
|
|
delete_kbnode( node );
|
1998-02-16 20:05:02 +00:00
|
|
|
}
|
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
/* note: because keyblock is the public key, it is never marked
|
|
|
|
* for deletion and so keyblock cannot change */
|
1998-02-16 20:05:02 +00:00
|
|
|
commit_kbnode( &keyblock );
|
|
|
|
return nvalid;
|
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
|
|
|
|
|
1999-05-19 14:12:26 +00:00
|
|
|
/****************
|
|
|
|
* It may happen that the imported keyblock has duplicated user IDs.
|
|
|
|
* We check this here and collapse those user IDs together with their
|
|
|
|
* sigs into one.
|
1999-05-22 20:54:54 +00:00
|
|
|
* Returns: True if the keyblock hash changed.
|
1999-05-19 14:12:26 +00:00
|
|
|
*/
|
1999-05-22 20:54:54 +00:00
|
|
|
int
|
|
|
|
collapse_uids( KBNODE *keyblock )
|
1999-05-19 14:12:26 +00:00
|
|
|
{
|
1999-05-22 20:54:54 +00:00
|
|
|
KBNODE n, n2;
|
|
|
|
int in_uid;
|
|
|
|
int any=0;
|
|
|
|
u32 kid1;
|
1999-05-19 14:12:26 +00:00
|
|
|
|
1999-05-22 20:54:54 +00:00
|
|
|
restart:
|
|
|
|
for( n = *keyblock; n; n = n->next ) {
|
|
|
|
if( n->pkt->pkttype != PKT_USER_ID )
|
|
|
|
continue;
|
|
|
|
for( n2 = n->next; n2; n2 = n2->next ) {
|
|
|
|
if( n2->pkt->pkttype == PKT_USER_ID
|
|
|
|
&& !cmp_user_ids( n->pkt->pkt.user_id,
|
|
|
|
n2->pkt->pkt.user_id ) ) {
|
|
|
|
/* found a duplicate */
|
|
|
|
any = 1;
|
|
|
|
if( !n2->next
|
|
|
|
|| n2->next->pkt->pkttype == PKT_USER_ID
|
|
|
|
|| n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| n2->next->pkt->pkttype == PKT_SECRET_SUBKEY ) {
|
|
|
|
/* no more signatures: delete the user ID
|
|
|
|
* and start over */
|
|
|
|
remove_kbnode( keyblock, n2 );
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* The simple approach: Move one signature and
|
|
|
|
* then start over to delete the next one :-( */
|
|
|
|
move_kbnode( keyblock, n2->next, n->next );
|
1999-05-19 14:12:26 +00:00
|
|
|
}
|
1999-05-22 20:54:54 +00:00
|
|
|
goto restart;
|
1999-05-19 14:12:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-05-22 20:54:54 +00:00
|
|
|
if( !any )
|
|
|
|
return 0;
|
1999-05-19 14:12:26 +00:00
|
|
|
|
1999-05-22 20:54:54 +00:00
|
|
|
restart_sig:
|
|
|
|
/* now we may have duplicate signatures on one user ID: fix this */
|
|
|
|
for( in_uid = 0, n = *keyblock; n; n = n->next ) {
|
|
|
|
if( n->pkt->pkttype == PKT_USER_ID )
|
|
|
|
in_uid = 1;
|
|
|
|
else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| n->pkt->pkttype == PKT_SECRET_SUBKEY )
|
|
|
|
in_uid = 0;
|
|
|
|
else if( in_uid ) {
|
|
|
|
n2 = n;
|
|
|
|
do {
|
|
|
|
KBNODE ncmp = NULL;
|
|
|
|
for( ; n2; n2 = n2->next ) {
|
|
|
|
if( n2->pkt->pkttype == PKT_USER_ID
|
|
|
|
|| n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| n2->pkt->pkttype == PKT_SECRET_SUBKEY )
|
|
|
|
break;
|
|
|
|
if( n2->pkt->pkttype != PKT_SIGNATURE )
|
|
|
|
;
|
|
|
|
else if( !ncmp )
|
|
|
|
ncmp = n2;
|
|
|
|
else if( !cmp_signatures( ncmp->pkt->pkt.signature,
|
|
|
|
n2->pkt->pkt.signature )) {
|
|
|
|
remove_kbnode( keyblock, n2 );
|
|
|
|
goto restart_sig;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
n2 = ncmp? ncmp->next : NULL;
|
|
|
|
} while( n2 );
|
|
|
|
}
|
|
|
|
}
|
1999-05-19 14:12:26 +00:00
|
|
|
|
1999-05-22 20:54:54 +00:00
|
|
|
if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
|
|
|
|
kid1 = keyid_from_pk( n->pkt->pkt.public_key, NULL );
|
|
|
|
else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
|
|
|
|
kid1 = keyid_from_sk( n->pkt->pkt.secret_key, NULL );
|
|
|
|
else
|
|
|
|
kid1 = 0;
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(!opt.quiet)
|
|
|
|
log_info(_("key %08lX: duplicated user ID detected - merged\n"),
|
|
|
|
(ulong)kid1);
|
1999-05-19 14:12:26 +00:00
|
|
|
|
1999-05-22 20:54:54 +00:00
|
|
|
return 1;
|
1999-05-19 14:12:26 +00:00
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* Check for a 0x20 revocation from a revocation key that is not
|
2004-02-12 16:31:07 +00:00
|
|
|
present. This may be called without the benefit of merge_xxxx so
|
|
|
|
you can't rely on pk->revkey and friends. */
|
2002-06-29 13:46:34 +00:00
|
|
|
static void
|
|
|
|
revocation_present(KBNODE keyblock)
|
|
|
|
{
|
|
|
|
KBNODE onode,inode;
|
|
|
|
PKT_public_key *pk=keyblock->pkt->pkt.public_key;
|
|
|
|
|
|
|
|
for(onode=keyblock->next;onode;onode=onode->next)
|
|
|
|
{
|
|
|
|
/* If we reach user IDs, we're done. */
|
|
|
|
if(onode->pkt->pkttype==PKT_USER_ID)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if(onode->pkt->pkttype==PKT_SIGNATURE &&
|
|
|
|
onode->pkt->pkt.signature->sig_class==0x1F &&
|
|
|
|
onode->pkt->pkt.signature->revkey)
|
|
|
|
{
|
|
|
|
int idx;
|
|
|
|
PKT_signature *sig=onode->pkt->pkt.signature;
|
|
|
|
|
|
|
|
for(idx=0;idx<sig->numrevkeys;idx++)
|
|
|
|
{
|
|
|
|
u32 keyid[2];
|
|
|
|
|
|
|
|
keyid_from_fingerprint(sig->revkey[idx]->fpr,
|
|
|
|
MAX_FINGERPRINT_LEN,keyid);
|
|
|
|
|
|
|
|
for(inode=keyblock->next;inode;inode=inode->next)
|
|
|
|
{
|
|
|
|
/* If we reach user IDs, we're done. */
|
|
|
|
if(inode->pkt->pkttype==PKT_USER_ID)
|
|
|
|
break;
|
1999-05-19 14:12:26 +00:00
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
if(inode->pkt->pkttype==PKT_SIGNATURE &&
|
|
|
|
inode->pkt->pkt.signature->sig_class==0x20 &&
|
|
|
|
inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
|
|
|
|
inode->pkt->pkt.signature->keyid[1]==keyid[1])
|
|
|
|
{
|
|
|
|
/* Okay, we have a revocation key, and a
|
|
|
|
revocation issued by it. Do we have the key
|
|
|
|
itself? */
|
|
|
|
int rc;
|
|
|
|
|
2002-11-13 17:43:27 +00:00
|
|
|
rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
|
|
|
|
MAX_FINGERPRINT_LEN);
|
2002-06-29 13:46:34 +00:00
|
|
|
if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
|
|
|
|
{
|
|
|
|
/* No, so try and get it */
|
|
|
|
if(opt.keyserver_scheme &&
|
|
|
|
opt.keyserver_options.auto_key_retrieve)
|
|
|
|
{
|
2002-07-25 18:08:09 +00:00
|
|
|
log_info(_("WARNING: key %08lX may be revoked: "
|
2002-06-29 13:46:34 +00:00
|
|
|
"fetching revocation key %08lX\n"),
|
|
|
|
(ulong)keyid_from_pk(pk,NULL),
|
|
|
|
(ulong)keyid[1]);
|
|
|
|
keyserver_import_fprint(sig->revkey[idx]->fpr,
|
|
|
|
MAX_FINGERPRINT_LEN);
|
|
|
|
|
|
|
|
/* Do we have it now? */
|
2002-11-13 17:43:27 +00:00
|
|
|
rc=get_pubkey_byfprint_fast (NULL,
|
2002-06-29 13:46:34 +00:00
|
|
|
sig->revkey[idx]->fpr,
|
|
|
|
MAX_FINGERPRINT_LEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
|
2002-07-25 18:08:09 +00:00
|
|
|
log_info(_("WARNING: key %08lX may be revoked: "
|
2002-06-29 13:46:34 +00:00
|
|
|
"revocation key %08lX not present.\n"),
|
|
|
|
(ulong)keyid_from_pk(pk,NULL),
|
|
|
|
(ulong)keyid[1]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1999-05-19 14:12:26 +00:00
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
/****************
|
|
|
|
* compare and merge the blocks
|
|
|
|
*
|
|
|
|
* o compare the signatures: If we already have this signature, check
|
|
|
|
* that they compare okay; if not, issue a warning and ask the user.
|
|
|
|
* o Simply add the signature. Can't verify here because we may not have
|
1998-04-14 17:51:16 +00:00
|
|
|
* the signature's public key yet; verification is done when putting it
|
1998-02-17 20:48:52 +00:00
|
|
|
* into the trustdb, which is done automagically as soon as this pubkey
|
|
|
|
* is used.
|
|
|
|
* Note: We indicate newly inserted packets with flag bit 0
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
|
1998-05-26 13:38:00 +00:00
|
|
|
u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
|
1998-02-17 20:48:52 +00:00
|
|
|
{
|
1998-02-18 13:58:46 +00:00
|
|
|
KBNODE onode, node;
|
|
|
|
int rc, found;
|
|
|
|
|
|
|
|
/* 1st: handle revocation certificates */
|
|
|
|
for(node=keyblock->next; node; node=node->next ) {
|
|
|
|
if( node->pkt->pkttype == PKT_USER_ID )
|
|
|
|
break;
|
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& node->pkt->pkt.signature->sig_class == 0x20 ) {
|
1998-04-14 17:51:16 +00:00
|
|
|
/* check whether we already have this */
|
1998-02-18 13:58:46 +00:00
|
|
|
found = 0;
|
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next ) {
|
|
|
|
if( onode->pkt->pkttype == PKT_USER_ID )
|
|
|
|
break;
|
|
|
|
else if( onode->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& onode->pkt->pkt.signature->sig_class == 0x20
|
2003-08-13 03:31:36 +00:00
|
|
|
&& !cmp_signatures(onode->pkt->pkt.signature,
|
|
|
|
node->pkt->pkt.signature))
|
|
|
|
{
|
1998-02-18 13:58:46 +00:00
|
|
|
found = 1;
|
|
|
|
break;
|
2003-08-13 03:31:36 +00:00
|
|
|
}
|
1998-02-18 13:58:46 +00:00
|
|
|
}
|
|
|
|
if( !found ) {
|
|
|
|
KBNODE n2 = clone_kbnode(node);
|
|
|
|
insert_kbnode( keyblock_orig, n2, 0 );
|
|
|
|
n2->flag |= 1;
|
2002-06-29 13:46:34 +00:00
|
|
|
++*n_sigs;
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(!opt.quiet)
|
|
|
|
{
|
|
|
|
char *p=get_user_id_printable (keyid);
|
|
|
|
log_info(_("key %08lX: \"%s\" revocation "
|
|
|
|
"certificate added\n"), (ulong)keyid[1],p);
|
|
|
|
m_free(p);
|
|
|
|
}
|
2002-06-29 13:46:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 2nd: merge in any direct key (0x1F) sigs */
|
|
|
|
for(node=keyblock->next; node; node=node->next ) {
|
|
|
|
if( node->pkt->pkttype == PKT_USER_ID )
|
|
|
|
break;
|
|
|
|
else if( node->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& node->pkt->pkt.signature->sig_class == 0x1F ) {
|
|
|
|
/* check whether we already have this */
|
|
|
|
found = 0;
|
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next ) {
|
|
|
|
if( onode->pkt->pkttype == PKT_USER_ID )
|
|
|
|
break;
|
|
|
|
else if( onode->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& onode->pkt->pkt.signature->sig_class == 0x1F
|
|
|
|
&& !cmp_signatures(onode->pkt->pkt.signature,
|
|
|
|
node->pkt->pkt.signature)) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( !found ) {
|
|
|
|
KBNODE n2 = clone_kbnode(node);
|
|
|
|
insert_kbnode( keyblock_orig, n2, 0 );
|
|
|
|
n2->flag |= 1;
|
|
|
|
++*n_sigs;
|
* gpgv.c: Remove extra semicolon (typo).
* options.skel: Note that keyserver.pgp.com isn't synchronized, and
explain the roundrobin a bit better.
* sig-check.c (check_key_signature2), import.c (import_one,
import_revoke_cert, chk_self_sigs, delete_inv_parts, collapse_uids,
merge_blocks): Make much quieter during import of slightly munged, but
recoverable, keys. Use log_error for unrecoverable import failures.
* keyring.c (keyring_rebuild_cache): Comment.
* sign.c (mk_notation_and_policy): Making a v3 signature with notations or
policy urls is an error, not an info (i.e. increment the errorcount).
Don't print the notation or policy url to stdout since it can be mixed
into the output stream when piping and munge the stream.
2003-08-21 23:20:58 +00:00
|
|
|
if(!opt.quiet)
|
|
|
|
log_info( _("key %08lX: direct key signature added\n"),
|
|
|
|
(ulong)keyid[1]);
|
1998-02-18 13:58:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* 3rd: try to merge new certificates in */
|
1998-02-18 13:58:46 +00:00
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next ) {
|
|
|
|
if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
|
1998-02-17 20:48:52 +00:00
|
|
|
/* find the user id in the imported keyblock */
|
|
|
|
for(node=keyblock->next; node; node=node->next )
|
1998-12-08 12:20:53 +00:00
|
|
|
if( node->pkt->pkttype == PKT_USER_ID
|
1998-02-18 13:58:46 +00:00
|
|
|
&& !cmp_user_ids( onode->pkt->pkt.user_id,
|
1998-02-17 20:48:52 +00:00
|
|
|
node->pkt->pkt.user_id ) )
|
|
|
|
break;
|
|
|
|
if( node ) { /* found: merge */
|
1998-02-18 13:58:46 +00:00
|
|
|
rc = merge_sigs( onode, node, n_sigs, fname, keyid );
|
1998-02-17 20:48:52 +00:00
|
|
|
if( rc )
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* 4th: add new user-ids */
|
1998-02-17 20:48:52 +00:00
|
|
|
for(node=keyblock->next; node; node=node->next ) {
|
1998-12-08 12:20:53 +00:00
|
|
|
if( node->pkt->pkttype == PKT_USER_ID) {
|
1998-02-17 20:48:52 +00:00
|
|
|
/* do we have this in the original keyblock */
|
1998-02-18 13:58:46 +00:00
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next )
|
1998-12-08 12:20:53 +00:00
|
|
|
if( onode->pkt->pkttype == PKT_USER_ID
|
|
|
|
&& !cmp_user_ids( onode->pkt->pkt.user_id,
|
|
|
|
node->pkt->pkt.user_id ) )
|
1998-02-17 20:48:52 +00:00
|
|
|
break;
|
1998-12-08 12:20:53 +00:00
|
|
|
if( !onode ) { /* this is a new user id: append */
|
1998-02-17 20:48:52 +00:00
|
|
|
rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
|
|
|
|
if( rc )
|
|
|
|
return rc;
|
|
|
|
++*n_uids;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* 5th: add new subkeys */
|
1998-12-08 12:20:53 +00:00
|
|
|
for(node=keyblock->next; node; node=node->next ) {
|
|
|
|
onode = NULL;
|
|
|
|
if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
|
|
|
|
/* do we have this in the original keyblock? */
|
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next )
|
|
|
|
if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
&& !cmp_public_keys( onode->pkt->pkt.public_key,
|
|
|
|
node->pkt->pkt.public_key ) )
|
|
|
|
break;
|
|
|
|
if( !onode ) { /* this is a new subkey: append */
|
|
|
|
rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
|
|
|
|
if( rc )
|
|
|
|
return rc;
|
|
|
|
++*n_subk;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
|
|
|
|
/* do we have this in the original keyblock? */
|
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next )
|
|
|
|
if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
|
|
|
|
&& !cmp_secret_keys( onode->pkt->pkt.secret_key,
|
|
|
|
node->pkt->pkt.secret_key ) )
|
|
|
|
break;
|
|
|
|
if( !onode ) { /* this is a new subkey: append */
|
|
|
|
rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
|
|
|
|
if( rc )
|
|
|
|
return rc;
|
|
|
|
++*n_subk;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
1998-05-26 13:38:00 +00:00
|
|
|
|
2002-06-29 13:46:34 +00:00
|
|
|
/* 6th: merge subkey certificates */
|
1999-09-02 14:50:38 +00:00
|
|
|
for(onode=keyblock_orig->next; onode; onode=onode->next ) {
|
|
|
|
if( !(onode->flag & 1)
|
|
|
|
&& ( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
|
|
|
|
/* find the subkey in the imported keyblock */
|
|
|
|
for(node=keyblock->next; node; node=node->next ) {
|
|
|
|
if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
&& !cmp_public_keys( onode->pkt->pkt.public_key,
|
|
|
|
node->pkt->pkt.public_key ) )
|
|
|
|
break;
|
|
|
|
else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
|
|
|
|
&& !cmp_secret_keys( onode->pkt->pkt.secret_key,
|
|
|
|
node->pkt->pkt.secret_key ) )
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if( node ) { /* found: merge */
|
|
|
|
rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
|
|
|
|
if( rc )
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-02-17 20:48:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************
|
|
|
|
* append the userid starting with NODE and all signatures to KEYBLOCK.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid )
|
|
|
|
{
|
1998-12-08 12:20:53 +00:00
|
|
|
KBNODE n, n_where=NULL;
|
1998-02-17 20:48:52 +00:00
|
|
|
|
|
|
|
assert(node->pkt->pkttype == PKT_USER_ID );
|
|
|
|
|
1998-12-08 12:20:53 +00:00
|
|
|
/* find the position */
|
|
|
|
for( n = keyblock; n; n_where = n, n = n->next ) {
|
|
|
|
if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| n->pkt->pkttype == PKT_SECRET_SUBKEY )
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if( !n )
|
|
|
|
n_where = NULL;
|
|
|
|
|
|
|
|
/* and append/insert */
|
|
|
|
while( node ) {
|
1998-02-17 20:48:52 +00:00
|
|
|
/* we add a clone to the original keyblock, because this
|
|
|
|
* one is released first */
|
|
|
|
n = clone_kbnode(node);
|
1998-12-08 12:20:53 +00:00
|
|
|
if( n_where ) {
|
|
|
|
insert_kbnode( n_where, n, 0 );
|
|
|
|
n_where = n;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
add_kbnode( keyblock, n );
|
1998-02-17 20:48:52 +00:00
|
|
|
n->flag |= 1;
|
1998-12-08 12:20:53 +00:00
|
|
|
node->flag |= 1;
|
1998-02-17 20:48:52 +00:00
|
|
|
if( n->pkt->pkttype == PKT_SIGNATURE )
|
|
|
|
++*n_sigs;
|
1998-12-08 12:20:53 +00:00
|
|
|
|
|
|
|
node = node->next;
|
|
|
|
if( node && node->pkt->pkttype != PKT_SIGNATURE )
|
|
|
|
break;
|
1998-02-17 20:48:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************
|
|
|
|
* Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
|
|
|
|
* (how should we handle comment packets here?)
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid )
|
|
|
|
{
|
|
|
|
KBNODE n, n2;
|
|
|
|
int found=0;
|
|
|
|
|
|
|
|
assert(dst->pkt->pkttype == PKT_USER_ID );
|
|
|
|
assert(src->pkt->pkttype == PKT_USER_ID );
|
|
|
|
|
|
|
|
for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
|
|
|
|
if( n->pkt->pkttype != PKT_SIGNATURE )
|
|
|
|
continue;
|
1999-09-02 14:50:38 +00:00
|
|
|
if( n->pkt->pkt.signature->sig_class == 0x18
|
|
|
|
|| n->pkt->pkt.signature->sig_class == 0x28 )
|
|
|
|
continue; /* skip signatures which are only valid on subkeys */
|
1998-02-17 20:48:52 +00:00
|
|
|
found = 0;
|
2003-08-13 03:31:36 +00:00
|
|
|
for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
|
|
|
|
if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
|
|
|
|
{
|
|
|
|
found++;
|
|
|
|
break;
|
1998-12-08 12:20:53 +00:00
|
|
|
}
|
|
|
|
if( !found ) {
|
|
|
|
/* This signature is new or newer, append N to DST.
|
|
|
|
* We add a clone to the original keyblock, because this
|
|
|
|
* one is released first */
|
|
|
|
n2 = clone_kbnode(n);
|
|
|
|
insert_kbnode( dst, n2, PKT_SIGNATURE );
|
|
|
|
n2->flag |= 1;
|
|
|
|
n->flag |= 1;
|
|
|
|
++*n_sigs;
|
|
|
|
}
|
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
|
1998-12-08 12:20:53 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/****************
|
|
|
|
* Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid )
|
|
|
|
{
|
|
|
|
KBNODE n, n2;
|
|
|
|
int found=0;
|
|
|
|
|
|
|
|
assert( dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| dst->pkt->pkttype == PKT_SECRET_SUBKEY );
|
|
|
|
|
|
|
|
for(n=src->next; n ; n = n->next ) {
|
|
|
|
if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| n->pkt->pkttype == PKT_PUBLIC_KEY )
|
|
|
|
break;
|
|
|
|
if( n->pkt->pkttype != PKT_SIGNATURE )
|
1998-02-17 20:48:52 +00:00
|
|
|
continue;
|
1998-12-08 12:20:53 +00:00
|
|
|
found = 0;
|
|
|
|
for(n2=dst->next; n2; n2 = n2->next){
|
|
|
|
if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| n2->pkt->pkttype == PKT_PUBLIC_KEY )
|
|
|
|
break;
|
|
|
|
if( n2->pkt->pkttype == PKT_SIGNATURE
|
|
|
|
&& n->pkt->pkt.signature->keyid[0]
|
|
|
|
== n2->pkt->pkt.signature->keyid[0]
|
|
|
|
&& n->pkt->pkt.signature->keyid[1]
|
|
|
|
== n2->pkt->pkt.signature->keyid[1]
|
|
|
|
&& n->pkt->pkt.signature->timestamp
|
|
|
|
<= n2->pkt->pkt.signature->timestamp
|
|
|
|
&& n->pkt->pkt.signature->sig_class
|
|
|
|
== n2->pkt->pkt.signature->sig_class ) {
|
|
|
|
found++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( !found ) {
|
|
|
|
/* This signature is new or newer, append N to DST.
|
|
|
|
* We add a clone to the original keyblock, because this
|
|
|
|
* one is released first */
|
|
|
|
n2 = clone_kbnode(n);
|
|
|
|
insert_kbnode( dst, n2, PKT_SIGNATURE );
|
|
|
|
n2->flag |= 1;
|
|
|
|
n->flag |= 1;
|
|
|
|
++*n_sigs;
|
1998-02-17 20:48:52 +00:00
|
|
|
}
|
1998-12-08 12:20:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
1998-02-17 20:48:52 +00:00
|
|
|
|
1998-12-08 12:20:53 +00:00
|
|
|
/****************
|
|
|
|
* append the subkey starting with NODE and all signatures to KEYBLOCK.
|
|
|
|
* Mark all new and copied packets by setting flag bit 0.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
|
|
|
|
const char *fname, u32 *keyid )
|
|
|
|
{
|
|
|
|
KBNODE n;
|
|
|
|
|
|
|
|
assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|| node->pkt->pkttype == PKT_SECRET_SUBKEY );
|
|
|
|
|
|
|
|
while( node ) {
|
|
|
|
/* we add a clone to the original keyblock, because this
|
1998-02-17 20:48:52 +00:00
|
|
|
* one is released first */
|
1998-12-08 12:20:53 +00:00
|
|
|
n = clone_kbnode(node);
|
|
|
|
add_kbnode( keyblock, n );
|
1998-02-17 20:48:52 +00:00
|
|
|
n->flag |= 1;
|
1998-12-08 12:20:53 +00:00
|
|
|
node->flag |= 1;
|
|
|
|
if( n->pkt->pkttype == PKT_SIGNATURE )
|
|
|
|
++*n_sigs;
|
|
|
|
|
|
|
|
node = node->next;
|
|
|
|
if( node && node->pkt->pkttype != PKT_SIGNATURE )
|
|
|
|
break;
|
1998-02-17 20:48:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|