g10/seckey-cert.c

   1 /* seckey-cert.c - Not anymore used
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
   3  *               2006, 2009 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #error Not anymore used - only kept for reference in the repository.
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "gpg.h"
  29 #include "util.h"
  30 #include "packet.h"
  31 #include "keydb.h"
  32 #include "cipher.h"
  33 #include "main.h"
  34 #include "options.h"
  35 #include "i18n.h"
  36 #include "status.h"
  37 #include "pkglue.h"
  38
  39 static int
  40 xxxx_do_check( PKT_secret_key *sk, const char *tryagain_text, int mode,
  41                int *canceled )
  42 {
  43     gpg_error_t err;
  44     byte *buffer;
  45     u16 csum=0;
  46     int i, res;
  47     size_t nbytes;
  48
  49     if( sk->is_protected ) { /* remove the protection */
  50         DEK *dek = NULL;
  51         u32 keyid[4]; /* 4! because we need two of them */
  52         gcry_cipher_hd_t cipher_hd=NULL;
  53         PKT_secret_key *save_sk;
  54
  55         if( sk->protect.s2k.mode == 1001 ) {
  56             log_info(_("secret key parts are not available\n"));
  57             return GPG_ERR_UNUSABLE_SECKEY;
  58         }
  59         if( sk->protect.algo == CIPHER_ALGO_NONE )
  60             BUG();
  61         if( openpgp_cipher_test_algo( sk->protect.algo ) ) {
  62             log_info(_("protection algorithm %d%s is not supported\n"),
  63                         sk->protect.algo,sk->protect.algo==1?" (IDEA)":"" );
  64             return GPG_ERR_CIPHER_ALGO;
  65         }
  66         if(gcry_md_test_algo (sk->protect.s2k.hash_algo))
  67           {
  68             log_info(_("protection digest %d is not supported\n"),
  69                      sk->protect.s2k.hash_algo);
  70             return GPG_ERR_DIGEST_ALGO;
  71           }
  72         keyid_from_sk( sk, keyid );
  73         keyid[2] = keyid[3] = 0;
  74         if (!sk->flags.primary)
  75           {
  76             keyid[2] = sk->main_keyid[0];
  77             keyid[3] = sk->main_keyid[1];
  78           }
  79         dek = passphrase_to_dek( keyid, sk->pubkey_algo, sk->protect.algo,
  80                                  &sk->protect.s2k, mode,
  81                                  tryagain_text, canceled );
  82         if (!dek && canceled && *canceled)
  83             return GPG_ERR_CANCELED;
  84
  85
  86         err = openpgp_cipher_open (&cipher_hd, sk->protect.algo,
  87                                    GCRY_CIPHER_MODE_CFB,
  88                                    (GCRY_CIPHER_SECURE
  89                                     | (sk->protect.algo >= 100 ?
  90                                        0 : GCRY_CIPHER_ENABLE_SYNC)));
  91         if (err)
  92           log_fatal ("cipher open failed: %s\n", gpg_strerror (err) );
  93
  94         err = gcry_cipher_setkey (cipher_hd, dek->key, dek->keylen);
  95         if (err)
  96           log_fatal ("set key failed: %s\n", gpg_strerror (err) );
  97
  98         xfree(dek);
  99         save_sk = copy_secret_key( NULL, sk );
 100
 101         gcry_cipher_setiv ( cipher_hd, sk->protect.iv, sk->protect.ivlen );
 102
 103         csum = 0;
 104         if( sk->version >= 4 ) {
 105             int ndata;
 106             unsigned int ndatabits;
 107             byte *p, *data;
 108             u16 csumc = 0;
 109
 110             i = pubkey_get_npkey(sk->pubkey_algo);
 111
 112             assert ( gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE ));
 113             p = gcry_mpi_get_opaque ( sk->skey[i], &ndatabits );
 114             ndata = (ndatabits+7)/8;
 115
 116             if ( ndata > 1 )
 117               csumc = buf16_to_u16 (p+ndata-2);
 118             data = xmalloc_secure ( ndata );
 119             gcry_cipher_decrypt ( cipher_hd, data, ndata, p, ndata );
 120             gcry_mpi_release (sk->skey[i]); sk->skey[i] = NULL ;
 121
 122             p = data;
 123             if (sk->protect.sha1chk) {
 124                 /* This is the new SHA1 checksum method to detect
 125                    tampering with the key as used by the Klima/Rosa
 126                    attack */
 127                 sk->csum = 0;
 128                 csum = 1;
 129                 if( ndata < 20 )
 130                     log_error("not enough bytes for SHA-1 checksum\n");
 131                 else {
 132                     gcry_md_hd_t h;
 133
 134                     if ( gcry_md_open (&h, DIGEST_ALGO_SHA1, 1))
 135                         BUG(); /* Algo not available. */
 136                     gcry_md_write (h, data, ndata - 20);
 137                     gcry_md_final (h);
 138                     if (!memcmp (gcry_md_read (h, DIGEST_ALGO_SHA1),
 139                                  data + ndata - 20, 20) )
 140                       {
 141                         /* Digest does match.  We have to keep the old
 142                            style checksum in sk->csum, so that the
 143                            test used for unprotected keys does work.
 144                            This test gets used when we are adding new
 145                            keys. */
 146                         sk->csum = csum = checksum (data, ndata-20);
 147                       }
 148                     gcry_md_close (h);
 149                 }
 150             }
 151             else {
 152                 if( ndata < 2 ) {
 153                     log_error("not enough bytes for checksum\n");
 154                     sk->csum = 0;
 155                     csum = 1;
 156                 }
 157                 else {
 158                     csum = checksum( data, ndata-2);
 159                     sk->csum = data[ndata-2] << 8 | data[ndata-1];
 160                     if ( sk->csum != csum ) {
 161                         /* This is a PGP 7.0.0 workaround */
 162                         sk->csum = csumc; /* take the encrypted one */
 163                     }
 164                 }
 165             }
 166
 167             /* Must check it here otherwise the mpi_read_xx would fail
 168                because the length may have an arbitrary value */
 169             if( sk->csum == csum ) {
 170                 for( ; i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
 171                     if ( gcry_mpi_scan( &sk->skey[i], GCRYMPI_FMT_PGP,
 172                                         p, ndata, &nbytes))
 173                       {
 174                         /* Checksum was okay, but not correctly
 175                            decrypted.  */
 176                         sk->csum = 0;
 177                         csum = 1;
 178                         break;
 179                       }
 180                     ndata -= nbytes;
 181                     p += nbytes;
 182                 }
 183                 /* Note: at this point ndata should be 2 for a simple
 184                    checksum or 20 for the sha1 digest */
 185             }
 186             xfree(data);
 187         }
 188         else {
 189             for(i=pubkey_get_npkey(sk->pubkey_algo);
 190                     i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
 191                 byte *p;
 192                 size_t ndata;
 193                 unsigned int ndatabits;
 194
 195                 assert (gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE));
 196                 p = gcry_mpi_get_opaque (sk->skey[i], &ndatabits);
 197                 ndata = (ndatabits+7)/8;
 198                 assert (ndata >= 2);
 199                 assert (ndata == ((p[0] << 8 | p[1]) + 7)/8 + 2);
 200                 buffer = xmalloc_secure (ndata);
 201                 gcry_cipher_sync (cipher_hd);
 202                 buffer[0] = p[0];
 203                 buffer[1] = p[1];
 204                 gcry_cipher_decrypt (cipher_hd, buffer+2, ndata-2,
 205                                      p+2, ndata-2);
 206                 csum += checksum (buffer, ndata);
 207                 gcry_mpi_release (sk->skey[i]);
 208
 209                 err = gcry_mpi_scan( &sk->skey[i], GCRYMPI_FMT_PGP,
 210                                      buffer, ndata, &ndata );
 211                 xfree (buffer);
 212                 if (err)
 213                   {
 214                     /* Checksum was okay, but not correctly
 215                        decrypted.  */
 216                     sk->csum = 0;
 217                     csum = 1;
 218                     break;
 219                   }
 220 /*              csum += checksum_mpi (sk->skey[i]); */
 221             }
 222         }
 223         gcry_cipher_close ( cipher_hd );
 224
 225         /* Now let's see whether we have used the correct passphrase. */
 226         if( csum != sk->csum ) {
 227             copy_secret_key( sk, save_sk );
 228             passphrase_clear_cache ( keyid, NULL, sk->pubkey_algo );
 229             free_secret_key( save_sk );
 230             return gpg_error (GPG_ERR_BAD_PASSPHRASE);
 231         }
 232
 233         /* The checksum may fail, so we also check the key itself. */
 234         res = pk_check_secret_key ( sk->pubkey_algo, sk->skey );
 235         if( res ) {
 236             copy_secret_key( sk, save_sk );
 237             passphrase_clear_cache ( keyid, NULL, sk->pubkey_algo );
 238             free_secret_key( save_sk );
 239             return gpg_error (GPG_ERR_BAD_PASSPHRASE);
 240         }
 241         free_secret_key( save_sk );
 242         sk->is_protected = 0;
 243     }
 244     else { /* not protected, assume it is okay if the checksum is okay */
 245         csum = 0;
 246         for(i=pubkey_get_npkey(sk->pubkey_algo);
 247                 i < pubkey_get_nskey(sk->pubkey_algo); i++ ) {
 248             csum += checksum_mpi( sk->skey[i] );
 249         }
 250         if( csum != sk->csum )
 251             return GPG_ERR_CHECKSUM;
 252     }
 253
 254     return 0;
 255 }