1
0
mirror of git://git.gnupg.org/gnupg.git synced 2024-06-09 23:39:51 +02:00
gnupg/g10/seckey-cert.c

333 lines
9.4 KiB
C
Raw Normal View History

1997-11-18 15:06:00 +01:00
/* seckey-cert.c - secret key certifucate packet handling
1998-02-24 19:50:46 +01:00
* Copyright (C) 1998 Free Software Foundation, Inc.
1997-11-18 15:06:00 +01:00
*
1998-02-24 19:50:46 +01:00
* This file is part of GNUPG.
1997-11-18 15:06:00 +01:00
*
1998-02-24 19:50:46 +01:00
* GNUPG is free software; you can redistribute it and/or modify
1997-11-18 15:06:00 +01: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-02-24 19:50:46 +01:00
* GNUPG is distributed in the hope that it will be useful,
1997-11-18 15:06:00 +01: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 <assert.h>
#include "util.h"
#include "memory.h"
#include "packet.h"
#include "mpi.h"
#include "keydb.h"
#include "cipher.h"
1998-04-07 20:16:10 +02:00
#include "main.h"
#include "options.h"
1998-05-29 13:53:54 +02:00
#include "i18n.h"
1997-11-18 15:06:00 +01:00
1997-11-24 23:24:04 +01:00
static int
1998-04-09 13:19:09 +02:00
do_check( PKT_secret_cert *cert )
1997-11-18 15:06:00 +01:00
{
1997-12-09 13:46:23 +01:00
byte *buffer;
1998-01-16 22:15:24 +01:00
u16 csum=0;
1997-11-18 15:06:00 +01:00
int res;
1997-12-09 13:46:23 +01:00
unsigned nbytes;
1997-11-18 15:06:00 +01:00
1998-04-02 12:30:03 +02:00
if( cert->is_protected ) { /* remove the protection */
1997-11-24 23:24:04 +01:00
DEK *dek = NULL;
1998-04-09 13:19:09 +02:00
u32 keyid[2];
1998-04-07 20:16:10 +02:00
CIPHER_HANDLE cipher_hd=NULL;
1998-04-09 13:19:09 +02:00
PKT_secret_cert *save_cert;
char save_iv[8];
1997-11-24 23:24:04 +01:00
1998-06-09 17:14:06 +02:00
if( cert->protect.algo == CIPHER_ALGO_NONE )
BUG();
if( check_cipher_algo( cert->protect.algo ) )
return G10ERR_CIPHER_ALGO; /* unsupported protection algorithm */
keyid_from_skc( cert, keyid );
dek = passphrase_to_dek( keyid, cert->protect.algo,
&cert->protect.s2k, 0 );
cipher_hd = cipher_open( cert->protect.algo,
CIPHER_MODE_AUTO_CFB, 1);
cipher_setkey( cipher_hd, dek->key, dek->keylen );
cipher_setiv( cipher_hd, NULL );
m_free(dek); /* pw is in secure memory, so m_free() burns it */
save_cert = copy_secret_cert( NULL, cert );
memcpy(save_iv, cert->protect.iv, 8 );
cipher_decrypt( cipher_hd, cert->protect.iv, cert->protect.iv, 8 );
switch( cert->pubkey_algo ) {
case PUBKEY_ALGO_ELGAMAL:
case PUBKEY_ALGO_ELGAMAL_E:
buffer = mpi_get_secure_buffer( cert->d.elg.x, &nbytes, NULL );
cipher_decrypt( cipher_hd, buffer, buffer, nbytes );
mpi_set_buffer( cert->d.elg.x, buffer, nbytes, 0 );
csum = checksum_mpi( cert->d.elg.x );
m_free( buffer );
break;
case PUBKEY_ALGO_DSA:
buffer = mpi_get_secure_buffer( cert->d.dsa.x, &nbytes, NULL );
cipher_decrypt( cipher_hd, buffer, buffer, nbytes );
mpi_set_buffer( cert->d.dsa.x, buffer, nbytes, 0 );
csum = checksum_mpi( cert->d.dsa.x );
m_free( buffer );
break;
#ifdef HAVE_RSA_CIPHER
case PUBKEY_ALGO_RSA:
case PUBKEY_ALGO_RSA_E:
case PUBKEY_ALGO_RSA_S:
csum = 0;
#define X(a) do { \
buffer = mpi_get_secure_buffer( cert->d.rsa.##a, \
&nbytes, NULL ); \
csum += checksum_u16( nbytes*8 ); \
cipher_decrypt( cipher_hd, buffer, buffer, nbytes ); \
csum += checksum( buffer, nbytes ); \
mpi_set_buffer(cert->d.rsa.##a, buffer, nbytes, 0 ); \
m_free( buffer ); \
} while(0)
X(d);
X(p);
X(q);
X(u);
#undef X
break;
#endif /* HAVE_RSA_CIPHER */
1998-04-09 13:19:09 +02:00
1998-06-09 17:14:06 +02:00
default: BUG();
}
cipher_close( cipher_hd );
/* now let's see whether we have used the right passphrase */
if( csum != cert->csum ) {
if( cert->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
/* very bad kludge to work around an early bug */
csum -= checksum_u16( mpi_get_nbits(cert->d.elg.x) );
nbytes = mpi_get_nlimbs(cert->d.elg.x) * 4;
csum += checksum_u16( nbytes*8 );
if( !opt.batch && csum == cert->csum )
log_info("Probably you have an old key - use "
"\"--change-passphrase\" to convert.\n");
1998-04-09 13:19:09 +02:00
}
1998-04-02 12:30:03 +02:00
if( csum != cert->csum ) {
1998-04-09 13:19:09 +02:00
copy_secret_cert( cert, save_cert );
free_secret_cert( save_cert );
1998-04-02 12:30:03 +02:00
memcpy( cert->protect.iv, save_iv, 8 );
1997-11-24 23:24:04 +01:00
return G10ERR_BAD_PASS;
1997-12-09 13:46:23 +01:00
}
1998-06-09 17:14:06 +02:00
}
1997-11-24 23:24:04 +01:00
1998-06-09 17:14:06 +02:00
switch( cert->pubkey_algo ) {
case PUBKEY_ALGO_ELGAMAL_E:
case PUBKEY_ALGO_ELGAMAL:
res = elg_check_secret_key( &cert->d.elg );
break;
case PUBKEY_ALGO_DSA:
res = dsa_check_secret_key( &cert->d.dsa );
break;
#ifdef HAVE_RSA_CIPHER
case PUBKEY_ALGO_RSA:
case PUBKEY_ALGO_RSA_E:
case PUBKEY_ALGO_RSA_S:
res = rsa_check_secret_key( &cert->d.rsa );
break;
#endif
default: BUG();
1997-11-24 23:24:04 +01:00
}
1998-06-09 17:14:06 +02:00
if( !res ) {
copy_secret_cert( cert, save_cert );
free_secret_cert( save_cert );
memcpy( cert->protect.iv, save_iv, 8 );
return G10ERR_BAD_PASS;
}
free_secret_cert( save_cert );
cert->is_protected = 0;
1997-11-24 23:24:04 +01:00
}
1997-12-09 13:46:23 +01:00
else { /* not protected */
1998-04-09 13:19:09 +02:00
switch( cert->pubkey_algo ) {
1998-05-04 20:49:26 +02:00
case PUBKEY_ALGO_ELGAMAL_E:
1998-04-09 13:19:09 +02:00
case PUBKEY_ALGO_ELGAMAL:
csum = checksum_mpi( cert->d.elg.x );
break;
case PUBKEY_ALGO_DSA:
csum = checksum_mpi( cert->d.dsa.x );
break;
#ifdef HAVE_RSA_CIPHER
1998-05-04 20:49:26 +02:00
case PUBKEY_ALGO_RSA_E:
case PUBKEY_ALGO_RSA_S:
1998-04-09 13:19:09 +02:00
case PUBKEY_ALGO_RSA:
csum =0;
buffer = mpi_get_buffer( cert->d.rsa.rsa_d, &nbytes, NULL );
1998-04-07 20:16:10 +02:00
csum += checksum_u16( nbytes*8 );
1998-04-09 13:19:09 +02:00
csum += checksum( buffer, nbytes );
m_free( buffer );
buffer = mpi_get_buffer( cert->d.rsa.rsa_p, &nbytes, NULL );
csum += checksum_u16( nbytes*8 );
csum += checksum( buffer, nbytes );
m_free( buffer );
buffer = mpi_get_buffer( cert->d.rsa.rsa_q, &nbytes, NULL );
csum += checksum_u16( nbytes*8 );
csum += checksum( buffer, nbytes );
m_free( buffer );
buffer = mpi_get_buffer( cert->d.rsa.rsa_u, &nbytes, NULL );
csum += checksum_u16( nbytes*8 );
csum += checksum( buffer, nbytes );
1998-03-09 22:44:06 +01:00
m_free( buffer );
break;
1998-04-09 13:19:09 +02:00
#endif
default: BUG();
1998-03-09 22:44:06 +01:00
}
1998-04-09 13:19:09 +02:00
if( csum != cert->csum ) {
1998-05-04 20:49:26 +02:00
if( cert->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E ) {
1998-04-09 13:19:09 +02:00
/* very bad kludge to work around an early bug */
csum -= checksum_u16( mpi_get_nbits(cert->d.elg.x) );
nbytes = mpi_get_nlimbs(cert->d.elg.x) * 4;
csum += checksum_u16( nbytes*8 );
if( !opt.batch && csum == cert->csum )
log_info("Probably you have an old key - use "
"\"--change-passphrase\" to convert.\n");
}
1998-04-02 12:30:03 +02:00
if( csum != cert->csum )
1998-04-09 13:19:09 +02:00
return G10ERR_CHECKSUM;
1997-11-18 15:06:00 +01:00
}
}
1997-12-09 13:46:23 +01:00
1997-11-18 15:06:00 +01:00
return 0;
}
1997-11-24 23:24:04 +01:00
1997-11-18 15:06:00 +01:00
1997-11-24 23:24:04 +01:00
/****************
* Check the secret key certificate
1998-04-14 19:51:16 +02:00
* Ask up to 3 times for a correct passphrase
1997-11-24 23:24:04 +01:00
*/
int
1997-12-01 11:33:23 +01:00
check_secret_key( PKT_secret_cert *cert )
1997-11-24 23:24:04 +01:00
{
1997-12-09 13:46:23 +01:00
int rc = G10ERR_BAD_PASS;
int i;
for(i=0; i < 3 && rc == G10ERR_BAD_PASS; i++ ) {
if( i )
1998-05-29 13:53:54 +02:00
log_error(_("Invalid passphrase; please try again ...\n"));
1998-04-09 13:19:09 +02:00
switch( cert->pubkey_algo ) {
1998-05-04 20:49:26 +02:00
case PUBKEY_ALGO_ELGAMAL_E:
1998-04-09 13:19:09 +02:00
case PUBKEY_ALGO_ELGAMAL:
case PUBKEY_ALGO_DSA:
rc = do_check( cert );
1998-05-26 15:38:00 +02:00
#if 0 /* set to 1 to enable the workaround */
1998-05-03 21:35:33 +02:00
if( rc == G10ERR_BAD_PASS && cert->is_protected
1998-05-04 20:49:26 +02:00
&& cert->protect.algo == CIPHER_ALGO_BLOWFISH
&& cert->pubkey_algo != PUBKEY_ALGO_ELGAMAL ) {
1998-05-03 21:35:33 +02:00
/* Workaround for a bug in 0.2.16 which still used
* a 160 bit key for BLOWFISH. */
1998-05-04 20:49:26 +02:00
log_info("trying workaround for 0.2.16 passphrase bug ...\n");
log_info("If you don't need this, uncomment it in g10/seckey-cert.c\n\n");
1998-05-03 21:35:33 +02:00
cert->protect.algo = CIPHER_ALGO_BLOWFISH160;
rc = do_check( cert );
if( rc )
rc = G10ERR_BAD_PASS;
cert->protect.algo = CIPHER_ALGO_BLOWFISH;
}
1998-05-04 20:49:26 +02:00
#endif
1998-04-09 13:19:09 +02:00
break;
1998-05-26 15:38:00 +02:00
#ifdef HAVE_RSA_CIPHER
case PUBKEY_ALGO_RSA:
case PUBKEY_ALGO_RSA_E:
case PUBKEY_ALGO_RSA_S:
rc = do_check( cert );
break;
#endif
1998-04-09 13:19:09 +02:00
default: rc = G10ERR_PUBKEY_ALGO;
}
1998-01-02 21:40:10 +01:00
if( get_passphrase_fd() != -1 )
break;
1997-12-09 13:46:23 +01:00
}
1998-05-26 15:38:00 +02:00
1997-12-09 13:46:23 +01:00
return rc;
}
1998-01-06 22:01:36 +01:00
/****************
1998-04-14 19:51:16 +02:00
* check whether the secret key is protected.
1998-01-06 22:01:36 +01:00
* Returns: 0 not protected, -1 on error or the protection algorithm
*/
int
is_secret_key_protected( PKT_secret_cert *cert )
{
1998-04-02 12:30:03 +02:00
return cert->is_protected? cert->protect.algo : 0;
}
static int
1998-04-07 20:16:10 +02:00
do_protect( void (*fnc)(CIPHER_HANDLE, byte *, byte *, unsigned),
CIPHER_HANDLE fnc_hd, PKT_secret_cert *cert )
1998-04-02 12:30:03 +02:00
{
byte *buffer;
unsigned nbytes;
switch( cert->pubkey_algo ) {
1998-05-04 20:49:26 +02:00
case PUBKEY_ALGO_ELGAMAL_E:
1998-04-07 20:16:10 +02:00
/* recalculate the checksum, so that --change-passphrase
* can be used to convert from the faulty to the correct one
* wk 06.04.98:
* fixme: remove this some time in the future.
*/
cert->csum = checksum_mpi( cert->d.elg.x );
1998-05-04 20:49:26 +02:00
case PUBKEY_ALGO_ELGAMAL:
1998-04-02 12:30:03 +02:00
buffer = mpi_get_buffer( cert->d.elg.x, &nbytes, NULL );
1998-04-07 20:16:10 +02:00
(*fnc)( fnc_hd, buffer, buffer, nbytes );
1998-04-02 12:30:03 +02:00
mpi_set_buffer( cert->d.elg.x, buffer, nbytes, 0 );
m_free( buffer );
break;
case PUBKEY_ALGO_DSA:
buffer = mpi_get_buffer( cert->d.dsa.x, &nbytes, NULL );
1998-04-07 20:16:10 +02:00
(*fnc)( fnc_hd, buffer, buffer, nbytes );
1998-04-02 12:30:03 +02:00
mpi_set_buffer( cert->d.dsa.x, buffer, nbytes, 0 );
m_free( buffer );
break;
default: return G10ERR_PUBKEY_ALGO;
}
return 0;
1998-01-06 22:01:36 +01:00
}
1997-12-09 13:46:23 +01:00
/****************
* Protect the secret key certificate with the passphrase from DEK
*/
int
protect_secret_key( PKT_secret_cert *cert, DEK *dek )
{
1998-04-02 12:30:03 +02:00
int rc=0;
1997-12-09 13:46:23 +01:00
if( !dek )
return 0;
1998-04-02 12:30:03 +02:00
if( !cert->is_protected ) { /* okay, apply the protection */
1998-04-07 20:16:10 +02:00
CIPHER_HANDLE cipher_hd=NULL;
1998-04-02 12:30:03 +02:00
1998-06-09 17:14:06 +02:00
if( check_cipher_algo( cert->protect.algo ) )
rc = G10ERR_CIPHER_ALGO; /* unsupport protection algorithm */
else {
1998-04-07 20:16:10 +02:00
cipher_hd = cipher_open( cert->protect.algo,
CIPHER_MODE_AUTO_CFB, 1 );
cipher_setkey( cipher_hd, dek->key, dek->keylen );
cipher_setiv( cipher_hd, NULL );
cipher_encrypt( cipher_hd, cert->protect.iv, cert->protect.iv, 8 );
if( !do_protect( &cipher_encrypt, cipher_hd, cert ) )
1998-04-04 22:16:55 +02:00
cert->is_protected = 1;
1998-04-07 20:16:10 +02:00
cipher_close( cipher_hd );
1998-04-02 12:30:03 +02:00
}
}
return rc;
1997-11-24 23:24:04 +01:00
}
1997-11-18 15:06:00 +01:00