g10/skclist.c

   1 /* skclist.c - Build a list of secret keys
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2006 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19  * USA.
  20  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <assert.h>
  28
  29 #include "gpg.h"
  30 #include "options.h"
  31 #include "packet.h"
  32 #include "errors.h"
  33 #include "keydb.h"
  34 #include "util.h"
  35 #include "i18n.h"
  36 #include "cipher.h"
  37
  38 #ifndef GCRYCTL_FAKED_RANDOM_P
  39 #define GCRYCTL_FAKED_RANDOM_P 51
  40 #endif
  41
  42 /* Return true if Libgcrypt's RNG is in faked mode.  */
  43 int
  44 random_is_faked (void)
  45 {
  46   /* We use a runtime check to allow for slow migrattion of libgcrypt.
  47      We can't use the constant becuase that one is actually an enum
  48      value.  */
  49   gpg_error_t err = gcry_control ( 51 /*GCRYCTL_FAKED_RANDOM_P*/, 0);
  50
  51   if (!err)
  52     return 0;
  53   if (gpg_err_code (err) != GPG_ERR_INV_OP)
  54     return 1;
  55   log_info ("WARNING: libgcrypt too old.\n");
  56   log_info ("         can't check whether we are in faked RNG mode\n");
  57   return 0; /* Need to return false.  */
  58 }
  59
  60
  61
  62 void
  63 release_sk_list( SK_LIST sk_list )
  64 {
  65     SK_LIST sk_rover;
  66
  67     for( ; sk_list; sk_list = sk_rover ) {
  68         sk_rover = sk_list->next;
  69         free_secret_key( sk_list->sk );
  70         xfree( sk_list );
  71     }
  72 }
  73
  74
  75 /* Check that we are only using keys which don't have
  76  * the string "(insecure!)" or "not secure" or "do not use"
  77  * in one of the user ids
  78  */
  79 static int
  80 is_insecure( PKT_secret_key *sk )
  81 {
  82     u32 keyid[2];
  83     KBNODE node = NULL, u;
  84     int insecure = 0;
  85
  86     keyid_from_sk( sk, keyid );
  87     node = get_pubkeyblock( keyid );
  88     for ( u = node; u; u = u->next ) {
  89         if ( u->pkt->pkttype == PKT_USER_ID ) {
  90             PKT_user_id *id = u->pkt->pkt.user_id;
  91             if ( id->attrib_data )
  92                 continue; /* skip attribute packets */
  93             if ( strstr( id->name, "(insecure!)" )
  94                  || strstr( id->name, "not secure" )
  95                  || strstr( id->name, "do not use" )
  96                  || strstr( id->name, "(INSECURE!)" ) ) {
  97                 insecure = 1;
  98                 break;
  99             }
 100         }
 101     }
 102     release_kbnode( node );
 103
 104     return insecure;
 105 }
 106
 107 static int
 108 key_present_in_sk_list(SK_LIST sk_list, PKT_secret_key *sk)
 109 {
 110     for (; sk_list; sk_list = sk_list->next) {
 111         if ( !cmp_secret_keys(sk_list->sk, sk) )
 112             return 0;
 113     }
 114     return -1;
 115 }
 116
 117 static int
 118 is_duplicated_entry (strlist_t list, strlist_t item)
 119 {
 120     for(; list && list != item; list = list->next) {
 121         if ( !strcmp (list->d, item->d) )
 122             return 1;
 123     }
 124     return 0;
 125 }
 126
 127
 128 int
 129 build_sk_list( strlist_t locusr, SK_LIST *ret_sk_list,
 130                int unlock, unsigned int use )
 131 {
 132     SK_LIST sk_list = NULL;
 133     int rc;
 134
 135     if( !locusr )
 136       { /* use the default one */
 137         PKT_secret_key *sk;
 138
 139         sk = xmalloc_clear( sizeof *sk );
 140         sk->req_usage = use;
 141         if( (rc = get_seckey_byname( sk, NULL, unlock )) ) {
 142           free_secret_key( sk ); sk = NULL;
 143           log_error("no default secret key: %s\n", g10_errstr(rc) );
 144         }
 145         else if( !(rc=openpgp_pk_test_algo2 (sk->pubkey_algo, use)) )
 146           {
 147             SK_LIST r;
 148
 149             if( random_is_faked() && !is_insecure( sk ) )
 150               {
 151                 log_info(_("key is not flagged as insecure - "
 152                            "can't use it with the faked RNG!\n"));
 153                 free_secret_key( sk ); sk = NULL;
 154               }
 155             else
 156               {
 157                 r = xmalloc( sizeof *r );
 158                 r->sk = sk; sk = NULL;
 159                 r->next = sk_list;
 160                 r->mark = 0;
 161                 sk_list = r;
 162               }
 163           }
 164         else
 165           {
 166             free_secret_key( sk ); sk = NULL;
 167             log_error("invalid default secret key: %s\n", g10_errstr(rc) );
 168           }
 169       }
 170     else {
 171         strlist_t locusr_orig = locusr;
 172         for(; locusr; locusr = locusr->next ) {
 173             PKT_secret_key *sk;
 174
 175             rc = 0;
 176             /* Do an early check agains duplicated entries.  However this
 177              * won't catch all duplicates because the user IDs may be
 178              * specified in different ways.
 179              */
 180             if ( is_duplicated_entry ( locusr_orig, locusr ) )
 181               {
 182                 log_error(_("skipped \"%s\": duplicated\n"), locusr->d );
 183                 continue;
 184               }
 185             sk = xmalloc_clear( sizeof *sk );
 186             sk->req_usage = use;
 187             if( (rc = get_seckey_byname( sk, locusr->d, 0 )) )
 188               {
 189                 free_secret_key( sk ); sk = NULL;
 190                 log_error(_("skipped \"%s\": %s\n"),
 191                           locusr->d, g10_errstr(rc) );
 192               }
 193             else if ( key_present_in_sk_list(sk_list, sk) == 0) {
 194                 free_secret_key(sk); sk = NULL;
 195                 log_info(_("skipped: secret key already present\n"));
 196             }
 197             else if ( unlock && (rc = check_secret_key( sk, 0 )) )
 198               {
 199                 free_secret_key( sk ); sk = NULL;
 200                 log_error(_("skipped \"%s\": %s\n"),
 201                           locusr->d, g10_errstr(rc) );
 202               }
 203             else if( !(rc=openpgp_pk_test_algo2 (sk->pubkey_algo, use)) ) {
 204                 SK_LIST r;
 205
 206                 if( sk->version == 4 && (use & PUBKEY_USAGE_SIG)
 207                     && sk->pubkey_algo == PUBKEY_ALGO_ELGAMAL_E )
 208                   {
 209                     log_info(_("skipped \"%s\": %s\n"),locusr->d,
 210                              _("this is a PGP generated Elgamal key which"
 211                                " is not secure for signatures!"));
 212                     free_secret_key( sk ); sk = NULL;
 213                   }
 214                 else if( random_is_faked() && !is_insecure( sk ) ) {
 215                     log_info(_("key is not flagged as insecure - "
 216                                "can't use it with the faked RNG!\n"));
 217                     free_secret_key( sk ); sk = NULL;
 218                 }
 219                 else {
 220                     r = xmalloc( sizeof *r );
 221                     r->sk = sk; sk = NULL;
 222                     r->next = sk_list;
 223                     r->mark = 0;
 224                     sk_list = r;
 225                 }
 226             }
 227             else {
 228                 free_secret_key( sk ); sk = NULL;
 229                 log_error("skipped \"%s\": %s\n", locusr->d, g10_errstr(rc) );
 230             }
 231         }
 232     }
 233
 234
 235     if( !rc && !sk_list ) {
 236         log_error("no valid signators\n");
 237         rc = G10ERR_NO_USER_ID;
 238     }
 239
 240     if( rc )
 241         release_sk_list( sk_list );
 242     else
 243         *ret_sk_list = sk_list;
 244     return rc;
 245 }
 246