sjero.net Git - wget/blob - src/openssl.c

   1 /* SSL support via OpenSSL library.
   2    Copyright (C) 2000-2005 Free Software Foundation, Inc.
   3    Originally contributed by Christian Fraenkel.
   4
   5 This file is part of GNU Wget.
   6
   7 GNU Wget 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 2 of the License, or
  10 (at your option) any later version.
  11
  12 GNU Wget 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 Wget; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 In addition, as a special exception, the Free Software Foundation
  22 gives permission to link the code of its release of Wget with the
  23 OpenSSL project's "OpenSSL" library (or with modified versions of it
  24 that use the same license as the "OpenSSL" library), and distribute
  25 the linked executables.  You must obey the GNU General Public License
  26 in all respects for all of the code used other than "OpenSSL".  If you
  27 modify this file, you may extend this exception to your version of the
  28 file, but you are not obligated to do so.  If you do not wish to do
  29 so, delete this exception statement from your version.  */
  30
  31 #include <config.h>
  32
  33 #include <assert.h>
  34 #include <errno.h>
  35 #ifdef HAVE_UNISTD_H
  36 # include <unistd.h>
  37 #endif
  38 #ifdef HAVE_STRING_H
  39 # include <string.h>
  40 #else
  41 # include <strings.h>
  42 #endif
  43
  44 #include <openssl/bio.h>
  45 #include <openssl/crypto.h>
  46 #include <openssl/x509.h>
  47 #include <openssl/ssl.h>
  48 #include <openssl/err.h>
  49 #include <openssl/pem.h>
  50 #include <openssl/rand.h>
  51
  52 #include "wget.h"
  53 #include "utils.h"
  54 #include "connect.h"
  55 #include "url.h"
  56 #include "ssl.h"
  57
  58 #ifndef errno
  59 extern int errno;
  60 #endif
  61
  62 SSL_CTX *ssl_ctx;
  63
  64 static void
  65 ssl_init_prng (void)
  66 {
  67   /* It is likely that older versions of OpenSSL will fail on
  68      non-Linux machines because this code is unable to seed the PRNG
  69      on older versions of the library.  */
  70
  71 #if SSLEAY_VERSION_NUMBER >= 0x00905100
  72   char rand_file[256];
  73
  74   /* First, seed from a file specified by the user.  This will be
  75      $RANDFILE, if set, or ~/.rnd.  */
  76   RAND_file_name (rand_file, sizeof (rand_file));
  77   if (rand_file)
  78     /* Seed at most 16k (value borrowed from curl) from random file. */
  79     RAND_load_file (rand_file, 16384);
  80
  81   if (RAND_status ())
  82     return;
  83
  84   /* Get random data from EGD if opt.egd_file was set.  */
  85   if (opt.egd_file && *opt.egd_file)
  86     RAND_egd (opt.egd_file);
  87
  88   if (RAND_status ())
  89     return;
  90
  91 #ifdef WINDOWS
  92   /* Under Windows, we can try to seed the PRNG using screen content.
  93      This may or may not work, depending on whether we'll calling Wget
  94      interactively.  */
  95
  96   RAND_screen ();
  97   if (RAND_status ())
  98     return;
  99 #endif
 100
 101 #if 0 /* don't do this by default */
 102   {
 103     int maxrand = 500;
 104
 105     /* Still not random enough, presumably because neither /dev/random
 106        nor EGD were available.  Try to seed OpenSSL's PRNG with libc
 107        PRNG.  This is cryptographically weak and defeats the purpose
 108        of using OpenSSL, which is why it is highly discouraged.  */
 109
 110     logprintf (LOG_VERBOSE, _("WARNING: using a weak random seed.\n"));
 111
 112     while (RAND_status () == 0 && maxrand-- > 0)
 113       {
 114         unsigned char rnd = random_number (256);
 115         RAND_seed (&rnd, sizeof (rnd));
 116       }
 117   }
 118 #endif
 119
 120 #endif /* SSLEAY_VERSION_NUMBER >= 0x00905100 */
 121 }
 122
 123 static int
 124 verify_callback (int ok, X509_STORE_CTX *ctx)
 125 {
 126   char *s, buf[256];
 127   s = X509_NAME_oneline (X509_get_subject_name (ctx->current_cert),
 128                          buf, sizeof (buf));
 129   if (ok == 0)
 130     {
 131       switch (ctx->error)
 132         {
 133         case X509_V_ERR_CERT_NOT_YET_VALID:
 134         case X509_V_ERR_CERT_HAS_EXPIRED:
 135           /* This mean the CERT is not valid !!! */
 136           ok = 0;
 137           break;
 138         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 139           /* Unsure if we should handle that this way */
 140           ok = 1;
 141           break;
 142         }
 143     }
 144   return ok;
 145 }
 146
 147 /* Print SSL errors. */
 148
 149 static void
 150 ssl_print_errors (void)
 151 {
 152   unsigned long curerr = 0;
 153   while ((curerr = ERR_get_error ()) != 0)
 154     logprintf (LOG_NOTQUIET, "OpenSSL: %s\n", ERR_error_string (curerr, NULL));
 155 }
 156
 157 /* Convert keyfile type as used by options.h to a type as accepted by
 158    SSL_CTX_use_certificate_file and SSL_CTX_use_PrivateKey_file.
 159
 160    (options.h intentionally doesn't use values from openssl/ssl.h so
 161    it doesn't depend specifically on OpenSSL for SSL functionality.)  */
 162
 163 static int
 164 key_type_to_ssl_type (enum keyfile_type type)
 165 {
 166   switch (type)
 167     {
 168     case keyfile_pem:
 169       return SSL_FILETYPE_PEM;
 170     case keyfile_asn1:
 171       return SSL_FILETYPE_ASN1;
 172     default:
 173       abort ();
 174     }
 175 }
 176
 177 /* Creates a SSL Context and sets some defaults for it */
 178 uerr_t
 179 ssl_init ()
 180 {
 181   SSL_METHOD *meth = NULL;
 182
 183   if (ssl_ctx)
 184     return 0;
 185
 186   /* Init the PRNG.  If that fails, bail out.  */
 187   ssl_init_prng ();
 188   if (RAND_status () == 0)
 189     {
 190       logprintf (LOG_NOTQUIET,
 191                  _("Could not seed OpenSSL PRNG; disabling SSL.\n"));
 192       scheme_disable (SCHEME_HTTPS);
 193       return SSLERRCTXCREATE;
 194     }
 195
 196   SSL_library_init ();
 197   SSL_load_error_strings ();
 198   SSLeay_add_all_algorithms ();
 199   SSLeay_add_ssl_algorithms ();
 200   switch (opt.secure_protocol)
 201     {
 202     case secure_protocol_auto:
 203       meth = SSLv23_client_method ();
 204       break;
 205     case secure_protocol_sslv2:
 206       meth = SSLv2_client_method ();
 207       break;
 208     case secure_protocol_sslv3:
 209       meth = SSLv3_client_method ();
 210       break;
 211     case secure_protocol_tlsv1:
 212       meth = TLSv1_client_method ();
 213       break;
 214     default:
 215       abort ();
 216     }
 217
 218   ssl_ctx = SSL_CTX_new (meth);
 219   SSL_CTX_set_default_verify_paths (ssl_ctx);
 220   SSL_CTX_load_verify_locations (ssl_ctx, opt.ca_cert, opt.ca_directory);
 221   SSL_CTX_set_verify (ssl_ctx,
 222                       opt.check_cert ? SSL_VERIFY_PEER : SSL_VERIFY_NONE,
 223                       verify_callback);
 224
 225   if (opt.cert_file)
 226     if (SSL_CTX_use_certificate_file (ssl_ctx, opt.cert_file,
 227                                       key_type_to_ssl_type (opt.cert_type))
 228         != 1)
 229       {
 230         ssl_print_errors ();
 231         return SSLERRCERTFILE;
 232       }
 233   if (opt.private_key)
 234     if (SSL_CTX_use_PrivateKey_file (ssl_ctx, opt.private_key,
 235                                      key_type_to_ssl_type (opt.private_key_type))
 236         != 1)
 237       {
 238         ssl_print_errors ();
 239         return SSLERRCERTKEY;
 240       }
 241
 242   return 0; /* Succeded */
 243 }
 244
 245 static int
 246 ssl_read (int fd, char *buf, int bufsize, void *ctx)
 247 {
 248   int ret;
 249   SSL *ssl = (SSL *) ctx;
 250   do
 251     ret = SSL_read (ssl, buf, bufsize);
 252   while (ret == -1
 253          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 254          && errno == EINTR);
 255   return ret;
 256 }
 257
 258 static int
 259 ssl_write (int fd, char *buf, int bufsize, void *ctx)
 260 {
 261   int ret = 0;
 262   SSL *ssl = (SSL *) ctx;
 263   do
 264     ret = SSL_write (ssl, buf, bufsize);
 265   while (ret == -1
 266          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 267          && errno == EINTR);
 268   return ret;
 269 }
 270
 271 static int
 272 ssl_poll (int fd, double timeout, int wait_for, void *ctx)
 273 {
 274   SSL *ssl = (SSL *) ctx;
 275   if (timeout == 0)
 276     return 1;
 277   if (SSL_pending (ssl))
 278     return 1;
 279   return select_fd (fd, timeout, wait_for);
 280 }
 281
 282 static int
 283 ssl_peek (int fd, char *buf, int bufsize, void *ctx)
 284 {
 285   int ret;
 286   SSL *ssl = (SSL *) ctx;
 287   do
 288     ret = SSL_peek (ssl, buf, bufsize);
 289   while (ret == -1
 290          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 291          && errno == EINTR);
 292   return ret;
 293 }
 294
 295 static void
 296 ssl_close (int fd, void *ctx)
 297 {
 298   SSL *ssl = (SSL *) ctx;
 299   SSL_shutdown (ssl);
 300   SSL_free (ssl);
 301
 302 #ifdef WINDOWS
 303   closesocket (fd);
 304 #else
 305   close (fd);
 306 #endif
 307
 308   DEBUGP (("Closed %d/SSL 0x%0lx\n", fd, (unsigned long) ssl));
 309 }
 310
 311 /* Sets up a SSL structure and performs the handshake on fd.  The
 312    resulting SSL structure is registered with the file descriptor FD
 313    using fd_register_transport.  That way subsequent calls to xread,
 314    xwrite, etc., will use the appropriate SSL functions.
 315
 316    Returns 1 on success, 0 on failure.  */
 317
 318 int
 319 ssl_connect (int fd)
 320 {
 321   SSL *ssl;
 322
 323   assert (ssl_ctx != NULL);
 324   ssl = SSL_new (ssl_ctx);
 325   if (!ssl)
 326     goto err;
 327   if (!SSL_set_fd (ssl, fd))
 328     goto err;
 329   SSL_set_connect_state (ssl);
 330   if (SSL_connect (ssl) <= 0 || ssl->state != SSL_ST_OK)
 331     goto err;
 332
 333   /* Register FD with Wget's transport layer, i.e. arrange that
 334      SSL-enabled functions are used for reading, writing, and polling.
 335      That way the rest of Wget can keep using xread, xwrite, and
 336      friends and not care what happens underneath.  */
 337   fd_register_transport (fd, ssl_read, ssl_write, ssl_poll, ssl_peek,
 338                          ssl_close, ssl);
 339   DEBUGP (("Connected %d to SSL 0x%0*lx\n", fd, 2 * sizeof (void *),
 340            (unsigned long) ssl));
 341   return 1;
 342
 343  err:
 344   ssl_print_errors ();
 345   if (ssl)
 346     SSL_free (ssl);
 347   return 0;
 348 }