mirror of
git://git.gnupg.org/gnupg.git
synced 2024-12-23 10:29:58 +01:00
b1eac93431
* cipher/idea.c: New. Take from Libgcrypt master and adjust for direct use in GnuPG. * cipher/idea-stub.c: Remove. * cipher/Makefile.am: Add idea.c and remove idea-stub.c rules. * configure.ac: Remove idea-stub code. * g10/gpg.c (check_permissions): Remove code path for ITEM==2. (main): Make --load-extension a dummy option. * g10/keygen.c (keygen_set_std_prefs): Include IDEA only in PGP2 compatibility mode. * g10/misc.c (idea_cipher_warn): Remove. Also remove all callers. * g10/seckey-cert.c (do_check): Remove emitting of STATUS_RSA_OR_IDEA. * g10/status.c (get_status_string): Remove STATUS_RSA_OR_IDEA. * g10/status.h (STATUS_RSA_OR_IDEA): Remove. -- To keep the number of actually used algorithms low, we support IDEA only in a basically read-only way (unless --pgp2 is used during key generation). It does not make sense to suggest the use of this old 64 bit blocksize algorithm. However, there is old data available where it might be helpful to have IDEA available.
1475 lines
44 KiB
C
1475 lines
44 KiB
C
/* pkclist.c
|
|
* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
|
|
* 2008, 2010 Free Software Foundation, Inc.
|
|
*
|
|
* This file is part of GnuPG.
|
|
*
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GnuPG is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#ifdef HAVE_STRINGS_H
|
|
#include <strings.h>
|
|
#endif
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
|
|
#include "options.h"
|
|
#include "packet.h"
|
|
#include "errors.h"
|
|
#include "keydb.h"
|
|
#include "memory.h"
|
|
#include "util.h"
|
|
#include "main.h"
|
|
#include "trustdb.h"
|
|
#include "ttyio.h"
|
|
#include "status.h"
|
|
#include "photoid.h"
|
|
#include "i18n.h"
|
|
|
|
#define CONTROL_D ('D' - 'A' + 1)
|
|
|
|
/****************
|
|
* Show the revocation reason as it is stored with the given signature
|
|
*/
|
|
static void
|
|
do_show_revocation_reason( PKT_signature *sig )
|
|
{
|
|
size_t n, nn;
|
|
const byte *p, *pp;
|
|
int seq = 0;
|
|
const char *text;
|
|
|
|
while( (p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_REVOC_REASON,
|
|
&n, &seq, NULL )) ) {
|
|
if( !n )
|
|
continue; /* invalid - just skip it */
|
|
|
|
if( *p == 0 )
|
|
text = _("No reason specified");
|
|
else if( *p == 0x01 )
|
|
text = _("Key is superseded");
|
|
else if( *p == 0x02 )
|
|
text = _("Key has been compromised");
|
|
else if( *p == 0x03 )
|
|
text = _("Key is no longer used");
|
|
else if( *p == 0x20 )
|
|
text = _("User ID is no longer valid");
|
|
else
|
|
text = NULL;
|
|
|
|
log_info( _("reason for revocation: ") );
|
|
if( text )
|
|
fputs( text, log_stream() );
|
|
else
|
|
fprintf( log_stream(), "code=%02x", *p );
|
|
putc( '\n', log_stream() );
|
|
n--; p++;
|
|
pp = NULL;
|
|
do {
|
|
/* We don't want any empty lines, so skip them */
|
|
while( n && *p == '\n' ) {
|
|
p++;
|
|
n--;
|
|
}
|
|
if( n ) {
|
|
pp = memchr( p, '\n', n );
|
|
nn = pp? pp - p : n;
|
|
log_info( _("revocation comment: ") );
|
|
print_string( log_stream(), p, nn, 0 );
|
|
putc( '\n', log_stream() );
|
|
p += nn; n -= nn;
|
|
}
|
|
} while( pp );
|
|
}
|
|
}
|
|
|
|
/* Mode 0: try and find the revocation based on the pk (i.e. check
|
|
subkeys, etc.) Mode 1: use only the revocation on the main pk */
|
|
|
|
void
|
|
show_revocation_reason( PKT_public_key *pk, int mode )
|
|
{
|
|
/* Hmmm, this is not so easy becuase we have to duplicate the code
|
|
* used in the trustbd to calculate the keyflags. We need to find
|
|
* a clean way to check revocation certificates on keys and
|
|
* signatures. And there should be no duplicate code. Because we
|
|
* enter this function only when the trustdb told us that we have
|
|
* a revoked key, we could simply look for a revocation cert and
|
|
* display this one, when there is only one. Let's try to do this
|
|
* until we have a better solution. */
|
|
KBNODE node, keyblock = NULL;
|
|
byte fingerprint[MAX_FINGERPRINT_LEN];
|
|
size_t fingerlen;
|
|
int rc;
|
|
|
|
/* get the keyblock */
|
|
fingerprint_from_pk( pk, fingerprint, &fingerlen );
|
|
rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
|
|
if( rc ) { /* that should never happen */
|
|
log_debug( "failed to get the keyblock\n");
|
|
return;
|
|
}
|
|
|
|
for( node=keyblock; node; node = node->next ) {
|
|
if( (mode && node->pkt->pkttype == PKT_PUBLIC_KEY) ||
|
|
( ( node->pkt->pkttype == PKT_PUBLIC_KEY
|
|
|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
|
|
&& !cmp_public_keys( node->pkt->pkt.public_key, pk ) ) )
|
|
break;
|
|
}
|
|
if( !node ) {
|
|
log_debug("Oops, PK not in keyblock\n");
|
|
release_kbnode( keyblock );
|
|
return;
|
|
}
|
|
/* now find the revocation certificate */
|
|
for( node = node->next; node ; node = node->next ) {
|
|
if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
|
|
break;
|
|
if( node->pkt->pkttype == PKT_SIGNATURE
|
|
&& (node->pkt->pkt.signature->sig_class == 0x20
|
|
|| node->pkt->pkt.signature->sig_class == 0x28 ) ) {
|
|
/* FIXME: we should check the signature here */
|
|
do_show_revocation_reason ( node->pkt->pkt.signature );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* We didn't find it, so check if the whole key is revoked */
|
|
if(!node && !mode)
|
|
show_revocation_reason(pk,1);
|
|
|
|
release_kbnode( keyblock );
|
|
}
|
|
|
|
|
|
/****************
|
|
* mode: 0 = standard
|
|
* 1 = Without key info and additional menu option 'm'
|
|
* this does also add an option to set the key to ultimately trusted.
|
|
* Returns:
|
|
* -2 = nothing changed - caller should show some additional info
|
|
* -1 = quit operation
|
|
* 0 = nothing changed
|
|
* 1 = new ownertrust now in new_trust
|
|
*/
|
|
static int
|
|
do_edit_ownertrust (PKT_public_key *pk, int mode,
|
|
unsigned *new_trust, int defer_help )
|
|
{
|
|
char *p;
|
|
u32 keyid[2];
|
|
int changed=0;
|
|
int quit=0;
|
|
int show=0;
|
|
int min_num;
|
|
int did_help=defer_help;
|
|
unsigned int minimum=get_min_ownertrust(pk);
|
|
|
|
switch(minimum)
|
|
{
|
|
default:
|
|
case TRUST_UNDEFINED: min_num=1; break;
|
|
case TRUST_NEVER: min_num=2; break;
|
|
case TRUST_MARGINAL: min_num=3; break;
|
|
case TRUST_FULLY: min_num=4; break;
|
|
}
|
|
|
|
keyid_from_pk (pk, keyid);
|
|
for(;;) {
|
|
/* A string with valid answers.
|
|
|
|
TRANSLATORS: These are the allowed answers in lower and
|
|
uppercase. Below you will find the matching strings which
|
|
should be translated accordingly and the letter changed to
|
|
match the one in the answer string.
|
|
|
|
i = please show me more information
|
|
m = back to the main menu
|
|
s = skip this key
|
|
q = quit
|
|
*/
|
|
const char *ans = _("iImMqQsS");
|
|
|
|
if( !did_help )
|
|
{
|
|
if( !mode )
|
|
{
|
|
KBNODE keyblock, un;
|
|
|
|
tty_printf(_("No trust value assigned to:\n"));
|
|
tty_printf("%4u%c/%s %s\n",nbits_from_pk( pk ),
|
|
pubkey_letter( pk->pubkey_algo ),
|
|
keystr(keyid), datestr_from_pk( pk ) );
|
|
p=get_user_id_native(keyid);
|
|
tty_printf(_(" \"%s\"\n"),p);
|
|
xfree(p);
|
|
|
|
keyblock = get_pubkeyblock (keyid);
|
|
if (!keyblock)
|
|
BUG ();
|
|
for (un=keyblock; un; un = un->next)
|
|
{
|
|
if (un->pkt->pkttype != PKT_USER_ID )
|
|
continue;
|
|
if (un->pkt->pkt.user_id->is_revoked )
|
|
continue;
|
|
if (un->pkt->pkt.user_id->is_expired )
|
|
continue;
|
|
/* Only skip textual primaries */
|
|
if (un->pkt->pkt.user_id->is_primary
|
|
&& !un->pkt->pkt.user_id->attrib_data )
|
|
continue;
|
|
|
|
if((opt.verify_options&VERIFY_SHOW_PHOTOS)
|
|
&& un->pkt->pkt.user_id->attrib_data)
|
|
show_photos(un->pkt->pkt.user_id->attribs,
|
|
un->pkt->pkt.user_id->numattribs,pk,NULL,
|
|
un->pkt->pkt.user_id);
|
|
|
|
p=utf8_to_native(un->pkt->pkt.user_id->name,
|
|
un->pkt->pkt.user_id->len,0);
|
|
|
|
tty_printf(_(" aka \"%s\"\n"),p);
|
|
}
|
|
|
|
print_fingerprint (pk, NULL, 2);
|
|
tty_printf("\n");
|
|
release_kbnode (keyblock);
|
|
}
|
|
|
|
if(opt.trust_model==TM_DIRECT)
|
|
{
|
|
tty_printf(_("How much do you trust that this key actually "
|
|
"belongs to the named user?\n"));
|
|
tty_printf("\n");
|
|
}
|
|
else
|
|
{
|
|
/* This string also used in keyedit.c:trustsig_prompt */
|
|
tty_printf(_("Please decide how far you trust this user to"
|
|
" correctly verify other users' keys\n"
|
|
"(by looking at passports, checking fingerprints from"
|
|
" different sources, etc.)\n"));
|
|
tty_printf("\n");
|
|
}
|
|
|
|
if(min_num<=1)
|
|
tty_printf (_(" %d = I don't know or won't say\n"), 1);
|
|
if(min_num<=2)
|
|
tty_printf (_(" %d = I do NOT trust\n"), 2);
|
|
if(min_num<=3)
|
|
tty_printf (_(" %d = I trust marginally\n"), 3);
|
|
if(min_num<=4)
|
|
tty_printf (_(" %d = I trust fully\n"), 4);
|
|
if (mode)
|
|
tty_printf (_(" %d = I trust ultimately\n"), 5);
|
|
#if 0
|
|
/* not yet implemented */
|
|
tty_printf (" i = please show me more information\n");
|
|
#endif
|
|
if( mode )
|
|
tty_printf(_(" m = back to the main menu\n"));
|
|
else
|
|
{
|
|
tty_printf(_(" s = skip this key\n"));
|
|
tty_printf(_(" q = quit\n"));
|
|
}
|
|
tty_printf("\n");
|
|
if(minimum)
|
|
tty_printf(_("The minimum trust level for this key is: %s\n\n"),
|
|
trust_value_to_string(minimum));
|
|
did_help = 1;
|
|
}
|
|
if( strlen(ans) != 8 )
|
|
BUG();
|
|
p = cpr_get("edit_ownertrust.value",_("Your decision? "));
|
|
trim_spaces(p);
|
|
cpr_kill_prompt();
|
|
if( !*p )
|
|
did_help = 0;
|
|
else if( *p && p[1] )
|
|
;
|
|
else if( !p[1] && ((*p >= '0'+min_num) && *p <= (mode?'5':'4')) )
|
|
{
|
|
unsigned int trust;
|
|
switch( *p )
|
|
{
|
|
case '1': trust = TRUST_UNDEFINED; break;
|
|
case '2': trust = TRUST_NEVER ; break;
|
|
case '3': trust = TRUST_MARGINAL ; break;
|
|
case '4': trust = TRUST_FULLY ; break;
|
|
case '5': trust = TRUST_ULTIMATE ; break;
|
|
default: BUG();
|
|
}
|
|
if (trust == TRUST_ULTIMATE
|
|
&& !cpr_get_answer_is_yes ("edit_ownertrust.set_ultimate.okay",
|
|
_("Do you really want to set this key"
|
|
" to ultimate trust? (y/N) ")))
|
|
; /* no */
|
|
else
|
|
{
|
|
*new_trust = trust;
|
|
changed = 1;
|
|
break;
|
|
}
|
|
}
|
|
#if 0
|
|
/* not yet implemented */
|
|
else if( *p == ans[0] || *p == ans[1] )
|
|
{
|
|
tty_printf(_("Certificates leading to an ultimately trusted key:\n"));
|
|
show = 1;
|
|
break;
|
|
}
|
|
#endif
|
|
else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) )
|
|
{
|
|
break ; /* back to the menu */
|
|
}
|
|
else if( !mode && (*p == ans[6] || *p == ans[7] ) )
|
|
{
|
|
break; /* skip */
|
|
}
|
|
else if( !mode && (*p == ans[4] || *p == ans[5] ) )
|
|
{
|
|
quit = 1;
|
|
break ; /* back to the menu */
|
|
}
|
|
xfree(p); p = NULL;
|
|
}
|
|
xfree(p);
|
|
return show? -2: quit? -1 : changed;
|
|
}
|
|
|
|
/*
|
|
* Display a menu to change the ownertrust of the key PK (which should
|
|
* be a primary key).
|
|
* For mode values see do_edit_ownertrust ()
|
|
*/
|
|
int
|
|
edit_ownertrust (PKT_public_key *pk, int mode )
|
|
{
|
|
unsigned int trust = 0; /* Needs to be initialized to avoid gcc warning. */
|
|
int no_help = 0;
|
|
|
|
for(;;)
|
|
{
|
|
switch ( do_edit_ownertrust (pk, mode, &trust, no_help ) )
|
|
{
|
|
case -1: /* quit */
|
|
return -1;
|
|
case -2: /* show info */
|
|
no_help = 1;
|
|
break;
|
|
case 1: /* trust value set */
|
|
trust &= ~TRUST_FLAG_DISABLED;
|
|
trust |= get_ownertrust (pk) & TRUST_FLAG_DISABLED;
|
|
update_ownertrust (pk, trust );
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/****************
|
|
* Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
|
|
* Returns: true if we trust.
|
|
*/
|
|
static int
|
|
do_we_trust( PKT_public_key *pk, unsigned int trustlevel )
|
|
{
|
|
/* We should not be able to get here with a revoked or expired
|
|
key */
|
|
if(trustlevel & TRUST_FLAG_REVOKED
|
|
|| trustlevel & TRUST_FLAG_SUB_REVOKED
|
|
|| (trustlevel & TRUST_MASK) == TRUST_EXPIRED)
|
|
BUG();
|
|
|
|
if( opt.trust_model==TM_ALWAYS )
|
|
{
|
|
if( opt.verbose )
|
|
log_info("No trust check due to `--trust-model always' option\n");
|
|
return 1;
|
|
}
|
|
|
|
switch(trustlevel & TRUST_MASK)
|
|
{
|
|
default:
|
|
log_error ("invalid trustlevel %u returned from validation layer\n",
|
|
trustlevel);
|
|
/* fall thru */
|
|
case TRUST_UNKNOWN:
|
|
case TRUST_UNDEFINED:
|
|
log_info(_("%s: There is no assurance this key belongs"
|
|
" to the named user\n"),keystr_from_pk(pk));
|
|
return 0; /* no */
|
|
|
|
case TRUST_MARGINAL:
|
|
log_info(_("%s: There is limited assurance this key belongs"
|
|
" to the named user\n"),keystr_from_pk(pk));
|
|
return 1; /* yes */
|
|
|
|
case TRUST_FULLY:
|
|
if( opt.verbose )
|
|
log_info(_("This key probably belongs to the named user\n"));
|
|
return 1; /* yes */
|
|
|
|
case TRUST_ULTIMATE:
|
|
if( opt.verbose )
|
|
log_info(_("This key belongs to us\n"));
|
|
return 1; /* yes */
|
|
}
|
|
|
|
return 1; /*NOTREACHED*/
|
|
}
|
|
|
|
|
|
/****************
|
|
* wrapper around do_we_trust, so we can ask whether to use the
|
|
* key anyway.
|
|
*/
|
|
static int
|
|
do_we_trust_pre( PKT_public_key *pk, unsigned int trustlevel )
|
|
{
|
|
int rc;
|
|
|
|
rc = do_we_trust( pk, trustlevel );
|
|
|
|
if( !opt.batch && !rc )
|
|
{
|
|
print_pubkey_info(NULL,pk);
|
|
print_fingerprint (pk, NULL, 2);
|
|
tty_printf("\n");
|
|
|
|
tty_printf(
|
|
_("It is NOT certain that the key belongs to the person named\n"
|
|
"in the user ID. If you *really* know what you are doing,\n"
|
|
"you may answer the next question with yes.\n"));
|
|
|
|
tty_printf("\n");
|
|
|
|
if( cpr_get_answer_is_yes("untrusted_key.override",
|
|
_("Use this key anyway? (y/N) ")) )
|
|
rc = 1;
|
|
|
|
/* Hmmm: Should we set a flag to tell the user about
|
|
* his decision the next time he encrypts for this recipient?
|
|
*/
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
/****************
|
|
* Check whether we can trust this signature.
|
|
* Returns: Error if we shall not trust this signatures.
|
|
*/
|
|
int
|
|
check_signatures_trust( PKT_signature *sig )
|
|
{
|
|
PKT_public_key *pk = xmalloc_clear( sizeof *pk );
|
|
unsigned int trustlevel;
|
|
int rc=0;
|
|
|
|
rc = get_pubkey( pk, sig->keyid );
|
|
if (rc)
|
|
{ /* this should not happen */
|
|
log_error("Ooops; the key vanished - can't check the trust\n");
|
|
rc = G10ERR_NO_PUBKEY;
|
|
goto leave;
|
|
}
|
|
|
|
if ( opt.trust_model==TM_ALWAYS )
|
|
{
|
|
if( !opt.quiet )
|
|
log_info(_("WARNING: Using untrusted key!\n"));
|
|
if (opt.with_fingerprint)
|
|
print_fingerprint (pk, NULL, 1);
|
|
goto leave;
|
|
}
|
|
|
|
if(pk->maybe_revoked && !pk->is_revoked)
|
|
log_info(_("WARNING: this key might be revoked (revocation key"
|
|
" not present)\n"));
|
|
|
|
trustlevel = get_validity (pk, NULL);
|
|
|
|
if ( (trustlevel & TRUST_FLAG_REVOKED) )
|
|
{
|
|
write_status( STATUS_KEYREVOKED );
|
|
if(pk->is_revoked==2)
|
|
log_info(_("WARNING: This key has been revoked by its"
|
|
" designated revoker!\n"));
|
|
else
|
|
log_info(_("WARNING: This key has been revoked by its owner!\n"));
|
|
log_info(_(" This could mean that the signature is forged.\n"));
|
|
show_revocation_reason( pk, 0 );
|
|
}
|
|
else if ((trustlevel & TRUST_FLAG_SUB_REVOKED) )
|
|
{
|
|
write_status( STATUS_KEYREVOKED );
|
|
log_info(_("WARNING: This subkey has been revoked by its owner!\n"));
|
|
show_revocation_reason( pk, 0 );
|
|
}
|
|
|
|
if ((trustlevel & TRUST_FLAG_DISABLED))
|
|
log_info (_("Note: This key has been disabled.\n"));
|
|
|
|
/* If we have PKA information adjust the trustlevel. */
|
|
if (sig->pka_info && sig->pka_info->valid)
|
|
{
|
|
unsigned char fpr[MAX_FINGERPRINT_LEN];
|
|
PKT_public_key *primary_pk;
|
|
size_t fprlen;
|
|
int okay;
|
|
|
|
|
|
primary_pk = xmalloc_clear (sizeof *primary_pk);
|
|
get_pubkey (primary_pk, pk->main_keyid);
|
|
fingerprint_from_pk (primary_pk, fpr, &fprlen);
|
|
free_public_key (primary_pk);
|
|
|
|
if ( fprlen == 20 && !memcmp (sig->pka_info->fpr, fpr, 20) )
|
|
{
|
|
okay = 1;
|
|
write_status_text (STATUS_PKA_TRUST_GOOD, sig->pka_info->email);
|
|
log_info (_("Note: Verified signer's address is `%s'\n"),
|
|
sig->pka_info->email);
|
|
}
|
|
else
|
|
{
|
|
okay = 0;
|
|
write_status_text (STATUS_PKA_TRUST_BAD, sig->pka_info->email);
|
|
log_info (_("Note: Signer's address `%s' "
|
|
"does not match DNS entry\n"), sig->pka_info->email);
|
|
}
|
|
|
|
switch ( (trustlevel & TRUST_MASK) )
|
|
{
|
|
case TRUST_UNKNOWN:
|
|
case TRUST_UNDEFINED:
|
|
case TRUST_MARGINAL:
|
|
if (okay && opt.verify_options&VERIFY_PKA_TRUST_INCREASE)
|
|
{
|
|
trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_FULLY);
|
|
log_info (_("trustlevel adjusted to FULL"
|
|
" due to valid PKA info\n"));
|
|
}
|
|
/* (fall through) */
|
|
case TRUST_FULLY:
|
|
if (!okay)
|
|
{
|
|
trustlevel = ((trustlevel & ~TRUST_MASK) | TRUST_NEVER);
|
|
log_info (_("trustlevel adjusted to NEVER"
|
|
" due to bad PKA info\n"));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Now let the user know what up with the trustlevel. */
|
|
switch ( (trustlevel & TRUST_MASK) )
|
|
{
|
|
case TRUST_EXPIRED:
|
|
log_info(_("Note: This key has expired!\n"));
|
|
print_fingerprint (pk, NULL, 1);
|
|
break;
|
|
|
|
default:
|
|
log_error ("invalid trustlevel %u returned from validation layer\n",
|
|
trustlevel);
|
|
/* fall thru */
|
|
case TRUST_UNKNOWN:
|
|
case TRUST_UNDEFINED:
|
|
write_status( STATUS_TRUST_UNDEFINED );
|
|
log_info(_("WARNING: This key is not certified with"
|
|
" a trusted signature!\n"));
|
|
log_info(_(" There is no indication that the "
|
|
"signature belongs to the owner.\n" ));
|
|
print_fingerprint (pk, NULL, 1);
|
|
break;
|
|
|
|
case TRUST_NEVER:
|
|
/* currently we won't get that status */
|
|
write_status( STATUS_TRUST_NEVER );
|
|
log_info(_("WARNING: We do NOT trust this key!\n"));
|
|
log_info(_(" The signature is probably a FORGERY.\n"));
|
|
if (opt.with_fingerprint)
|
|
print_fingerprint (pk, NULL, 1);
|
|
rc = G10ERR_BAD_SIGN;
|
|
break;
|
|
|
|
case TRUST_MARGINAL:
|
|
write_status( STATUS_TRUST_MARGINAL );
|
|
log_info(_("WARNING: This key is not certified with"
|
|
" sufficiently trusted signatures!\n"));
|
|
log_info(_(" It is not certain that the"
|
|
" signature belongs to the owner.\n" ));
|
|
print_fingerprint (pk, NULL, 1);
|
|
break;
|
|
|
|
case TRUST_FULLY:
|
|
write_status( STATUS_TRUST_FULLY );
|
|
if (opt.with_fingerprint)
|
|
print_fingerprint (pk, NULL, 1);
|
|
break;
|
|
|
|
case TRUST_ULTIMATE:
|
|
write_status( STATUS_TRUST_ULTIMATE );
|
|
if (opt.with_fingerprint)
|
|
print_fingerprint (pk, NULL, 1);
|
|
break;
|
|
}
|
|
|
|
leave:
|
|
free_public_key( pk );
|
|
return rc;
|
|
}
|
|
|
|
|
|
void
|
|
release_pk_list( PK_LIST pk_list )
|
|
{
|
|
PK_LIST pk_rover;
|
|
|
|
for( ; pk_list; pk_list = pk_rover ) {
|
|
pk_rover = pk_list->next;
|
|
free_public_key( pk_list->pk );
|
|
xfree( pk_list );
|
|
}
|
|
}
|
|
|
|
|
|
static int
|
|
key_present_in_pk_list(PK_LIST pk_list, PKT_public_key *pk)
|
|
{
|
|
for( ; pk_list; pk_list = pk_list->next)
|
|
if (cmp_public_keys(pk_list->pk, pk) == 0)
|
|
return 0;
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/****************
|
|
* Return a malloced string with a default reciepient if there is any
|
|
*/
|
|
static char *
|
|
default_recipient(void)
|
|
{
|
|
PKT_secret_key *sk;
|
|
byte fpr[MAX_FINGERPRINT_LEN+1];
|
|
size_t n;
|
|
char *p;
|
|
int i;
|
|
|
|
if( opt.def_recipient )
|
|
return xstrdup( opt.def_recipient );
|
|
if( !opt.def_recipient_self )
|
|
return NULL;
|
|
sk = xmalloc_clear( sizeof *sk );
|
|
i = get_seckey_byname( sk, NULL, 0 );
|
|
if( i ) {
|
|
free_secret_key( sk );
|
|
return NULL;
|
|
}
|
|
n = MAX_FINGERPRINT_LEN;
|
|
fingerprint_from_sk( sk, fpr, &n );
|
|
free_secret_key( sk );
|
|
p = xmalloc( 2*n+3 );
|
|
*p++ = '0';
|
|
*p++ = 'x';
|
|
for(i=0; i < n; i++ )
|
|
sprintf( p+2*i, "%02X", fpr[i] );
|
|
p -= 2;
|
|
return p;
|
|
}
|
|
|
|
static int
|
|
expand_id(const char *id,STRLIST *into,unsigned int flags)
|
|
{
|
|
struct groupitem *groups;
|
|
int count=0;
|
|
|
|
for(groups=opt.grouplist;groups;groups=groups->next)
|
|
{
|
|
/* need strcasecmp() here, as this should be localized */
|
|
if(strcasecmp(groups->name,id)==0)
|
|
{
|
|
STRLIST each,sl;
|
|
|
|
/* this maintains the current utf8-ness */
|
|
for(each=groups->values;each;each=each->next)
|
|
{
|
|
sl=add_to_strlist(into,each->d);
|
|
sl->flags=flags;
|
|
count++;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/* For simplicity, and to avoid potential loops, we only expand once -
|
|
you can't make an alias that points to an alias. */
|
|
static STRLIST
|
|
expand_group(STRLIST input)
|
|
{
|
|
STRLIST sl,output=NULL,rover;
|
|
|
|
for(rover=input;rover;rover=rover->next)
|
|
if(expand_id(rover->d,&output,rover->flags)==0)
|
|
{
|
|
/* Didn't find any groups, so use the existing string */
|
|
sl=add_to_strlist(&output,rover->d);
|
|
sl->flags=rover->flags;
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
|
|
/* This is the central function to collect the keys for recipients.
|
|
It is thus used to prepare a public key encryption. encrypt-to
|
|
keys, default keys and the keys for the actual recipients are all
|
|
collected here. When not in batch mode and no recipient has been
|
|
passed on the commandline, the function will also ask for
|
|
recipients.
|
|
|
|
RCPTS is a string list with the recipients; NULL is an allowed
|
|
value but not very useful. Group expansion is done on these names;
|
|
they may be in any of the user Id formats we can handle. The flags
|
|
bits for each string in the string list are used for:
|
|
Bit 0: This is an encrypt-to recipient.
|
|
Bit 1: This is a hidden recipient.
|
|
|
|
USE is the desired use for the key - usually PUBKEY_USAGE_ENC.
|
|
RET_PK_LIST.
|
|
|
|
On success a list of keys is stored at the address RET_PK_LIST; the
|
|
caller must free this list. On error the value at this address is
|
|
not changed.
|
|
*/
|
|
int
|
|
build_pk_list( STRLIST rcpts, PK_LIST *ret_pk_list, unsigned int use )
|
|
{
|
|
PK_LIST pk_list = NULL;
|
|
PKT_public_key *pk=NULL;
|
|
int rc=0;
|
|
int any_recipients=0;
|
|
STRLIST rov,remusr;
|
|
char *def_rec = NULL;
|
|
|
|
/* Try to expand groups if any have been defined. */
|
|
if (opt.grouplist)
|
|
remusr = expand_group (rcpts);
|
|
else
|
|
remusr = rcpts;
|
|
|
|
/* Check whether there are any recipients in the list and build the
|
|
* list of the encrypt-to ones (we always trust them). */
|
|
for ( rov = remusr; rov; rov = rov->next )
|
|
{
|
|
if ( !(rov->flags & 1) )
|
|
{
|
|
/* This is a regular recipient; i.e. not an encrypt-to
|
|
one. */
|
|
any_recipients = 1;
|
|
|
|
/* Hidden recipients are not allowed while in PGP mode,
|
|
issue a warning and switch into GnuPG mode. */
|
|
if ((rov->flags&2) && (PGP2 || PGP6 || PGP7 || PGP8))
|
|
{
|
|
log_info(_("you may not use %s while in %s mode\n"),
|
|
"--hidden-recipient",
|
|
compliance_option_string());
|
|
|
|
compliance_failure();
|
|
}
|
|
}
|
|
else if ( (use & PUBKEY_USAGE_ENC) && !opt.no_encrypt_to )
|
|
{
|
|
/* Encryption has been requested and --encrypt-to has not
|
|
been disabled. Check this encrypt-to key. */
|
|
pk = xmalloc_clear( sizeof *pk );
|
|
pk->req_usage = use;
|
|
|
|
/* We explicitly allow encrypt-to to an disabled key; thus
|
|
we pass 1 as last argument. */
|
|
if ( (rc = get_pubkey_byname ( pk, rov->d, NULL, NULL, 1 )) )
|
|
{
|
|
free_public_key ( pk ); pk = NULL;
|
|
log_error (_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
|
|
write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
|
|
rov->d, strlen (rov->d), -1);
|
|
goto fail;
|
|
}
|
|
else if ( !(rc=check_pubkey_algo2 (pk->pubkey_algo, use )) )
|
|
{
|
|
/* Skip the actual key if the key is already present
|
|
* in the list. Add it to our list if not. */
|
|
if (key_present_in_pk_list(pk_list, pk) == 0)
|
|
{
|
|
free_public_key (pk); pk = NULL;
|
|
log_info (_("%s: skipped: public key already present\n"),
|
|
rov->d);
|
|
}
|
|
else
|
|
{
|
|
PK_LIST r;
|
|
r = xmalloc( sizeof *r );
|
|
r->pk = pk; pk = NULL;
|
|
r->next = pk_list;
|
|
r->flags = (rov->flags&2)?1:0;
|
|
pk_list = r;
|
|
|
|
/* Hidden encrypt-to recipients are not allowed while
|
|
in PGP mode, issue a warning and switch into
|
|
GnuPG mode. */
|
|
if ((r->flags&1) && (PGP2 || PGP6 || PGP7 || PGP8))
|
|
{
|
|
log_info(_("you may not use %s while in %s mode\n"),
|
|
"--hidden-encrypt-to",
|
|
compliance_option_string());
|
|
|
|
compliance_failure();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* The public key is not usable for encryption or not
|
|
available. */
|
|
free_public_key( pk ); pk = NULL;
|
|
log_error(_("%s: skipped: %s\n"), rov->d, g10_errstr(rc) );
|
|
write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
|
|
rov->d, strlen (rov->d), -1);
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If we don't have any recipients yet and we are not in batch mode
|
|
drop into interactive selection mode. */
|
|
if ( !any_recipients && !opt.batch )
|
|
{
|
|
int have_def_rec;
|
|
char *answer = NULL;
|
|
STRLIST backlog = NULL;
|
|
|
|
if (pk_list)
|
|
any_recipients = 1;
|
|
def_rec = default_recipient();
|
|
have_def_rec = !!def_rec;
|
|
if ( !have_def_rec )
|
|
tty_printf(_("You did not specify a user ID. (you may use \"-r\")\n"));
|
|
|
|
for (;;)
|
|
{
|
|
rc = 0;
|
|
xfree(answer);
|
|
if ( have_def_rec )
|
|
{
|
|
/* A default recipient is taken as the first entry. */
|
|
answer = def_rec;
|
|
def_rec = NULL;
|
|
}
|
|
else if (backlog)
|
|
{
|
|
/* This is part of our trick to expand and display groups. */
|
|
answer = pop_strlist (&backlog);
|
|
}
|
|
else
|
|
{
|
|
/* Show the list of already collected recipients and ask
|
|
for more. */
|
|
PK_LIST iter;
|
|
|
|
tty_printf("\n");
|
|
tty_printf(_("Current recipients:\n"));
|
|
for (iter=pk_list;iter;iter=iter->next)
|
|
{
|
|
u32 keyid[2];
|
|
|
|
keyid_from_pk(iter->pk,keyid);
|
|
tty_printf("%4u%c/%s %s \"",
|
|
nbits_from_pk(iter->pk),
|
|
pubkey_letter(iter->pk->pubkey_algo),
|
|
keystr(keyid),
|
|
datestr_from_pk(iter->pk));
|
|
|
|
if (iter->pk->user_id)
|
|
tty_print_utf8_string(iter->pk->user_id->name,
|
|
iter->pk->user_id->len);
|
|
else
|
|
{
|
|
size_t n;
|
|
char *p = get_user_id( keyid, &n );
|
|
tty_print_utf8_string( p, n );
|
|
xfree(p);
|
|
}
|
|
tty_printf("\"\n");
|
|
}
|
|
|
|
answer = cpr_get_utf8("pklist.user_id.enter",
|
|
_("\nEnter the user ID. "
|
|
"End with an empty line: "));
|
|
trim_spaces(answer);
|
|
cpr_kill_prompt();
|
|
}
|
|
|
|
if ( !answer || !*answer )
|
|
{
|
|
xfree(answer);
|
|
break; /* No more recipients entered - get out of loop. */
|
|
}
|
|
|
|
/* Do group expand here too. The trick here is to continue
|
|
the loop if any expansion occured. The code above will
|
|
then list all expanded keys. */
|
|
if (expand_id(answer,&backlog,0))
|
|
continue;
|
|
|
|
/* Get and check key for the current name. */
|
|
if (pk)
|
|
free_public_key (pk);
|
|
pk = xmalloc_clear( sizeof *pk );
|
|
pk->req_usage = use;
|
|
rc = get_pubkey_byname( pk, answer, NULL, NULL, 0 );
|
|
if (rc)
|
|
tty_printf(_("No such user ID.\n"));
|
|
else if ( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) )
|
|
{
|
|
if ( have_def_rec )
|
|
{
|
|
/* No validation for a default recipient. */
|
|
if (!key_present_in_pk_list(pk_list, pk))
|
|
{
|
|
free_public_key (pk); pk = NULL;
|
|
log_info (_("skipped: public key "
|
|
"already set as default recipient\n") );
|
|
}
|
|
else
|
|
{
|
|
PK_LIST r = xmalloc (sizeof *r);
|
|
r->pk = pk; pk = NULL;
|
|
r->next = pk_list;
|
|
r->flags = 0; /* No throwing default ids. */
|
|
pk_list = r;
|
|
}
|
|
any_recipients = 1;
|
|
continue;
|
|
}
|
|
else
|
|
{ /* Check validity of this key. */
|
|
int trustlevel;
|
|
|
|
trustlevel = get_validity (pk, pk->user_id);
|
|
if ( (trustlevel & TRUST_FLAG_DISABLED) )
|
|
{
|
|
tty_printf (_("Public key is disabled.\n") );
|
|
}
|
|
else if ( do_we_trust_pre (pk, trustlevel) )
|
|
{
|
|
/* Skip the actual key if the key is already
|
|
* present in the list */
|
|
if (!key_present_in_pk_list(pk_list, pk))
|
|
{
|
|
free_public_key(pk); pk = NULL;
|
|
log_info(_("skipped: public key already set\n") );
|
|
}
|
|
else
|
|
{
|
|
PK_LIST r;
|
|
r = xmalloc( sizeof *r );
|
|
r->pk = pk; pk = NULL;
|
|
r->next = pk_list;
|
|
r->flags = 0; /* No throwing interactive ids. */
|
|
pk_list = r;
|
|
}
|
|
any_recipients = 1;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
xfree(def_rec); def_rec = NULL;
|
|
have_def_rec = 0;
|
|
}
|
|
if ( pk )
|
|
{
|
|
free_public_key( pk );
|
|
pk = NULL;
|
|
}
|
|
}
|
|
else if ( !any_recipients && (def_rec = default_recipient()) )
|
|
{
|
|
/* We are in batch mode and have only a default recipient. */
|
|
pk = xmalloc_clear( sizeof *pk );
|
|
pk->req_usage = use;
|
|
|
|
/* The default recipient is allowed to be disabled; thus pass 1
|
|
as last argument. */
|
|
rc = get_pubkey_byname (pk, def_rec, NULL, NULL, 1);
|
|
if (rc)
|
|
log_error(_("unknown default recipient \"%s\"\n"), def_rec );
|
|
else if ( !(rc=check_pubkey_algo2(pk->pubkey_algo, use)) )
|
|
{
|
|
/* Mark any_recipients here since the default recipient
|
|
would have been used if it wasn't already there. It
|
|
doesn't really matter if we got this key from the default
|
|
recipient or an encrypt-to. */
|
|
any_recipients = 1;
|
|
if (!key_present_in_pk_list(pk_list, pk))
|
|
log_info (_("skipped: public key already set "
|
|
"as default recipient\n"));
|
|
else
|
|
{
|
|
PK_LIST r = xmalloc( sizeof *r );
|
|
r->pk = pk; pk = NULL;
|
|
r->next = pk_list;
|
|
r->flags = 0; /* No throwing default ids. */
|
|
pk_list = r;
|
|
}
|
|
}
|
|
if ( pk )
|
|
{
|
|
free_public_key( pk );
|
|
pk = NULL;
|
|
}
|
|
xfree(def_rec); def_rec = NULL;
|
|
}
|
|
else
|
|
{
|
|
/* General case: Check all keys. */
|
|
any_recipients = 0;
|
|
for (; remusr; remusr = remusr->next )
|
|
{
|
|
if ( (remusr->flags & 1) )
|
|
continue; /* encrypt-to keys are already handled. */
|
|
|
|
pk = xmalloc_clear( sizeof *pk );
|
|
pk->req_usage = use;
|
|
if ( (rc = get_pubkey_byname( pk, remusr->d, NULL, NULL, 0 )) )
|
|
{
|
|
/* Key not found or other error. */
|
|
free_public_key( pk ); pk = NULL;
|
|
log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
|
|
write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
|
|
remusr->d, strlen (remusr->d),
|
|
-1);
|
|
goto fail;
|
|
}
|
|
else if ( !(rc=check_pubkey_algo2(pk->pubkey_algo, use )) )
|
|
{
|
|
/* Key found and usable. Check validity. */
|
|
int trustlevel;
|
|
|
|
trustlevel = get_validity (pk, pk->user_id);
|
|
if ( (trustlevel & TRUST_FLAG_DISABLED) )
|
|
{
|
|
/*Key has been disabled. */
|
|
free_public_key(pk); pk = NULL;
|
|
log_info(_("%s: skipped: public key is disabled\n"),
|
|
remusr->d);
|
|
write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
|
|
remusr->d,
|
|
strlen (remusr->d),
|
|
-1);
|
|
rc=G10ERR_UNU_PUBKEY;
|
|
goto fail;
|
|
}
|
|
else if ( do_we_trust_pre( pk, trustlevel ) )
|
|
{
|
|
/* Note: do_we_trust may have changed the trustlevel */
|
|
|
|
/* We have at least one valid recipient. It doesn't
|
|
* matters if this recipient is already present. */
|
|
any_recipients = 1;
|
|
|
|
/* Skip the actual key if the key is already present
|
|
* in the list */
|
|
if (!key_present_in_pk_list(pk_list, pk))
|
|
{
|
|
free_public_key(pk); pk = NULL;
|
|
log_info(_("%s: skipped: public key already present\n"),
|
|
remusr->d);
|
|
}
|
|
else
|
|
{
|
|
PK_LIST r;
|
|
r = xmalloc( sizeof *r );
|
|
r->pk = pk; pk = NULL;
|
|
r->next = pk_list;
|
|
r->flags = (remusr->flags&2)?1:0;
|
|
pk_list = r;
|
|
}
|
|
}
|
|
else
|
|
{ /* We don't trust this key. */
|
|
free_public_key( pk ); pk = NULL;
|
|
write_status_text_and_buffer (STATUS_INV_RECP, "10 ",
|
|
remusr->d,
|
|
strlen (remusr->d),
|
|
-1);
|
|
rc=G10ERR_UNU_PUBKEY;
|
|
goto fail;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Key found but not usable for us (e.g. sign-only key). */
|
|
free_public_key( pk ); pk = NULL;
|
|
write_status_text_and_buffer (STATUS_INV_RECP, "0 ",
|
|
remusr->d,
|
|
strlen (remusr->d),
|
|
-1);
|
|
log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
|
|
goto fail;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !rc && !any_recipients )
|
|
{
|
|
log_error(_("no valid addressees\n"));
|
|
write_status_text (STATUS_NO_RECP, "0");
|
|
rc = G10ERR_NO_USER_ID;
|
|
}
|
|
|
|
fail:
|
|
|
|
if ( rc )
|
|
release_pk_list( pk_list );
|
|
else
|
|
*ret_pk_list = pk_list;
|
|
if (opt.grouplist)
|
|
free_strlist(remusr);
|
|
return rc;
|
|
}
|
|
|
|
|
|
/* In pgp6 mode, disallow all ciphers except IDEA (1), 3DES (2), and
|
|
CAST5 (3), all hashes except MD5 (1), SHA1 (2), and RIPEMD160 (3),
|
|
and all compressions except none (0) and ZIP (1). pgp7 and pgp8
|
|
mode expands the cipher list to include AES128 (7), AES192 (8),
|
|
AES256 (9), and TWOFISH (10). pgp8 adds the SHA-256 hash (8). For
|
|
a true PGP key all of this is unneeded as they are the only items
|
|
present in the preferences subpacket, but checking here covers the
|
|
weird case of encrypting to a key that had preferences from a
|
|
different implementation which was then used with PGP. I am not
|
|
completely comfortable with this as the right thing to do, as it
|
|
slightly alters the list of what the user is supposedly requesting.
|
|
It is not against the RFC however, as the preference chosen will
|
|
never be one that the user didn't specify somewhere ("The
|
|
implementation may use any mechanism to pick an algorithm in the
|
|
intersection"), and PGP has no mechanism to fix such a broken
|
|
preference list, so I'm including it. -dms */
|
|
|
|
int
|
|
algo_available( preftype_t preftype, int algo, const union pref_hint *hint )
|
|
{
|
|
if( preftype == PREFTYPE_SYM )
|
|
{
|
|
if(PGP6 && (algo != CIPHER_ALGO_IDEA
|
|
&& algo != CIPHER_ALGO_3DES
|
|
&& algo != CIPHER_ALGO_CAST5))
|
|
return 0;
|
|
|
|
if(PGP7 && (algo != CIPHER_ALGO_IDEA
|
|
&& algo != CIPHER_ALGO_3DES
|
|
&& algo != CIPHER_ALGO_CAST5
|
|
&& algo != CIPHER_ALGO_AES
|
|
&& algo != CIPHER_ALGO_AES192
|
|
&& algo != CIPHER_ALGO_AES256
|
|
&& algo != CIPHER_ALGO_TWOFISH))
|
|
return 0;
|
|
|
|
/* PGP8 supports all the ciphers we do.. */
|
|
|
|
return algo && !check_cipher_algo( algo );
|
|
}
|
|
else if( preftype == PREFTYPE_HASH )
|
|
{
|
|
if(hint && hint->digest_length)
|
|
{
|
|
if(hint->digest_length!=20 || opt.flags.dsa2)
|
|
{
|
|
/* If --enable-dsa2 is set or the hash isn't 160 bits
|
|
(which implies DSA2), then we'll accept a hash that
|
|
is larger than we need. Otherwise we won't accept
|
|
any hash that isn't exactly the right size. */
|
|
if(hint->digest_length > md_digest_length(algo))
|
|
return 0;
|
|
}
|
|
else if(hint->digest_length != md_digest_length(algo))
|
|
return 0;
|
|
}
|
|
|
|
if((PGP6 || PGP7) && (algo != DIGEST_ALGO_MD5
|
|
&& algo != DIGEST_ALGO_SHA1
|
|
&& algo != DIGEST_ALGO_RMD160))
|
|
return 0;
|
|
|
|
|
|
if(PGP8 && (algo != DIGEST_ALGO_MD5
|
|
&& algo != DIGEST_ALGO_SHA1
|
|
&& algo != DIGEST_ALGO_RMD160
|
|
&& algo != DIGEST_ALGO_SHA256))
|
|
return 0;
|
|
|
|
return algo && !check_digest_algo( algo );
|
|
}
|
|
else if( preftype == PREFTYPE_ZIP )
|
|
{
|
|
if((PGP6 || PGP7) && (algo != COMPRESS_ALGO_NONE
|
|
&& algo != COMPRESS_ALGO_ZIP))
|
|
return 0;
|
|
|
|
/* PGP8 supports all the compression algos we do */
|
|
|
|
return !check_compress_algo( algo );
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/****************
|
|
* Return -1 if we could not find an algorithm.
|
|
*/
|
|
int
|
|
select_algo_from_prefs(PK_LIST pk_list, int preftype,
|
|
int request, const union pref_hint *hint)
|
|
{
|
|
PK_LIST pkr;
|
|
u32 bits[8];
|
|
const prefitem_t *prefs;
|
|
int result=-1,i;
|
|
u16 scores[256];
|
|
|
|
if( !pk_list )
|
|
return -1;
|
|
|
|
memset(bits,0xFF,sizeof(bits));
|
|
memset(scores,0,sizeof(scores));
|
|
|
|
for( pkr = pk_list; pkr; pkr = pkr->next )
|
|
{
|
|
u32 mask[8];
|
|
int rank=1,implicit=-1;
|
|
|
|
memset(mask,0,sizeof(mask));
|
|
|
|
switch(preftype)
|
|
{
|
|
case PREFTYPE_SYM:
|
|
/* IDEA is implicitly there for v3 keys with v3 selfsigs if
|
|
--pgp2 mode is on. This was a 2440 thing that was
|
|
dropped from 4880 but is still relevant to GPG's 1991
|
|
support. */
|
|
if(PGP2 && pkr->pk->version<4 && pkr->pk->selfsigversion<4)
|
|
implicit=CIPHER_ALGO_IDEA;
|
|
else
|
|
implicit=CIPHER_ALGO_3DES;
|
|
|
|
break;
|
|
|
|
case PREFTYPE_HASH:
|
|
/* While I am including this code for completeness, note
|
|
that currently --pgp2 mode locks the hash at MD5, so this
|
|
code will never even be called. Even if the hash wasn't
|
|
locked at MD5, we don't support sign+encrypt in --pgp2
|
|
mode, and that's the only time PREFTYPE_HASH is used
|
|
anyway. -dms */
|
|
|
|
/* MD5 is there for v3 keys with v3 selfsigs when --pgp2 is
|
|
on. */
|
|
if(PGP2 && pkr->pk->version<4 && pkr->pk->selfsigversion<4)
|
|
implicit=DIGEST_ALGO_MD5;
|
|
else
|
|
implicit=DIGEST_ALGO_SHA1;
|
|
|
|
break;
|
|
|
|
case PREFTYPE_ZIP:
|
|
/* Uncompressed is always an option. */
|
|
implicit=COMPRESS_ALGO_NONE;
|
|
}
|
|
|
|
if (pkr->pk->user_id) /* selected by user ID */
|
|
prefs = pkr->pk->user_id->prefs;
|
|
else
|
|
prefs = pkr->pk->prefs;
|
|
|
|
if( prefs )
|
|
{
|
|
for (i=0; prefs[i].type; i++ )
|
|
{
|
|
if( prefs[i].type == preftype )
|
|
{
|
|
/* Make sure all scores don't add up past 0xFFFF
|
|
(and roll around) */
|
|
if(rank+scores[prefs[i].value]<=0xFFFF)
|
|
scores[prefs[i].value]+=rank;
|
|
else
|
|
scores[prefs[i].value]=0xFFFF;
|
|
|
|
mask[prefs[i].value/32] |= 1<<(prefs[i].value%32);
|
|
|
|
rank++;
|
|
|
|
/* We saw the implicit algorithm, so we don't need
|
|
tack it on the end ourselves. */
|
|
if(implicit==prefs[i].value)
|
|
implicit=-1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(rank==1 && preftype==PREFTYPE_ZIP)
|
|
{
|
|
/* If the compression preferences are not present, they are
|
|
assumed to be ZIP, Uncompressed (RFC4880:13.3.1) */
|
|
scores[1]=1; /* ZIP is first choice */
|
|
scores[0]=2; /* Uncompressed is second choice */
|
|
mask[0]|=3;
|
|
}
|
|
|
|
/* If the key didn't have the implicit algorithm listed
|
|
explicitly, add it here at the tail of the list. */
|
|
if(implicit>-1)
|
|
{
|
|
scores[implicit]+=rank;
|
|
mask[implicit/32] |= 1<<(implicit%32);
|
|
}
|
|
|
|
for(i=0;i<8;i++)
|
|
bits[i]&=mask[i];
|
|
}
|
|
|
|
/* We've now scored all of the algorithms, and the usable ones have
|
|
bits set. Let's pick the winner. */
|
|
|
|
/* The caller passed us a request. Can we use it? */
|
|
if(request>-1 && (bits[request/32] & (1<<(request%32))) &&
|
|
algo_available(preftype,request,hint))
|
|
result=request;
|
|
|
|
if(result==-1)
|
|
{
|
|
/* If we have personal prefs set, use them. */
|
|
prefs=NULL;
|
|
if(preftype==PREFTYPE_SYM && opt.personal_cipher_prefs)
|
|
prefs=opt.personal_cipher_prefs;
|
|
else if(preftype==PREFTYPE_HASH && opt.personal_digest_prefs)
|
|
prefs=opt.personal_digest_prefs;
|
|
else if(preftype==PREFTYPE_ZIP && opt.personal_compress_prefs)
|
|
prefs=opt.personal_compress_prefs;
|
|
|
|
if( prefs )
|
|
for(i=0; prefs[i].type; i++ )
|
|
{
|
|
if(bits[prefs[i].value/32] & (1<<(prefs[i].value%32))
|
|
&& algo_available( preftype, prefs[i].value, hint))
|
|
{
|
|
result = prefs[i].value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(result==-1)
|
|
{
|
|
unsigned int best=-1;
|
|
|
|
/* At this point, we have not selected an algorithm due to a
|
|
special request or via personal prefs. Pick the highest
|
|
ranked algorithm (i.e. the one with the lowest score). */
|
|
|
|
if(preftype==PREFTYPE_HASH && scores[DIGEST_ALGO_MD5])
|
|
{
|
|
/* "If you are building an authentication system, the recipient
|
|
may specify a preferred signing algorithm. However, the
|
|
signer would be foolish to use a weak algorithm simply
|
|
because the recipient requests it." (RFC4880:14). If any
|
|
other hash algorithm is available, pretend that MD5 isn't.
|
|
Note that if the user intentionally chose MD5 by putting it
|
|
in their personal prefs, then we do what the user said (as we
|
|
never reach this code). */
|
|
|
|
for(i=DIGEST_ALGO_MD5+1;i<256;i++)
|
|
if(scores[i])
|
|
{
|
|
scores[DIGEST_ALGO_MD5]=0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(i=0;i<256;i++)
|
|
{
|
|
/* Note the '<' here. This means in case of a tie, we will
|
|
favor the lower algorithm number. We have a choice
|
|
between the lower number (probably an older algorithm
|
|
with more time in use), or the higher number (probably a
|
|
newer algorithm with less time in use). Older is
|
|
probably safer here, even though the newer algorithms
|
|
tend to be "stronger". */
|
|
if(scores[i] && scores[i]<best
|
|
&& (bits[i/32] & (1<<(i%32)))
|
|
&& algo_available(preftype,i,hint))
|
|
{
|
|
best=scores[i];
|
|
result=i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Select the MDC flag from the pk_list. We can only use MDC if all recipients
|
|
* support this feature
|
|
*/
|
|
int
|
|
select_mdc_from_pklist (PK_LIST pk_list)
|
|
{
|
|
PK_LIST pkr;
|
|
|
|
if( !pk_list )
|
|
return 0;
|
|
|
|
for (pkr = pk_list; pkr; pkr = pkr->next) {
|
|
int mdc;
|
|
|
|
if (pkr->pk->user_id) /* selected by user ID */
|
|
mdc = pkr->pk->user_id->flags.mdc;
|
|
else
|
|
mdc = pkr->pk->mdc_feature;
|
|
if (!mdc)
|
|
return 0; /* at least one recipient does not support it */
|
|
}
|
|
return 1; /* can be used */
|
|
}
|