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 /* Application-wide SSL context.  This is common to all SSL
  63    connections.  */
  64 SSL_CTX *ssl_ctx;
  65
  66 /* Initialize the SSL's PRNG using various methods. */
  67
  68 static void
  69 init_prng (void)
  70 {
  71   char namebuf[256];
  72   const char *random_file;
  73
  74   if (RAND_status ())
  75     /* The PRNG has been seeded; no further action is necessary. */
  76     return;
  77
  78   /* Seed from a file specified by the user.  This will be the file
  79      specified with --random-file, $RANDFILE, if set, or ~/.rnd, if it
  80      exists.  */
  81   if (opt.random_file)
  82     random_file = opt.random_file;
  83   else
  84     {
  85       /* Get the random file name using RAND_file_name. */
  86       namebuf[0] = '\0';
  87       random_file = RAND_file_name (namebuf, sizeof (namebuf));
  88     }
  89
  90   if (random_file && *random_file)
  91     /* Seed at most 16k (apparently arbitrary value borrowed from
  92        curl) from random file. */
  93     RAND_load_file (random_file, 16384);
  94
  95   if (RAND_status ())
  96     return;
  97
  98   /* Get random data from EGD if opt.egd_file was used.  */
  99   if (opt.egd_file && *opt.egd_file)
 100     RAND_egd (opt.egd_file);
 101
 102   if (RAND_status ())
 103     return;
 104
 105 #ifdef WINDOWS
 106   /* Under Windows, we can try to seed the PRNG using screen content.
 107      This may or may not work, depending on whether we'll calling Wget
 108      interactively.  */
 109
 110   RAND_screen ();
 111   if (RAND_status ())
 112     return;
 113 #endif
 114
 115 #if 0 /* don't do this by default */
 116   {
 117     int maxrand = 500;
 118
 119     /* Still not random enough, presumably because neither /dev/random
 120        nor EGD were available.  Try to seed OpenSSL's PRNG with libc
 121        PRNG.  This is cryptographically weak and defeats the purpose
 122        of using OpenSSL, which is why it is highly discouraged.  */
 123
 124     logprintf (LOG_NOTQUIET, _("WARNING: using a weak random seed.\n"));
 125
 126     while (RAND_status () == 0 && maxrand-- > 0)
 127       {
 128         unsigned char rnd = random_number (256);
 129         RAND_seed (&rnd, sizeof (rnd));
 130       }
 131   }
 132 #endif
 133 }
 134
 135 /* This function is called for additional (app-specific) verification
 136    of the server certificate.  We basically confirm the validity as
 137    determined by OpenSSL.
 138
 139    #### Someone should audit this for correctness and document it
 140    better.  */
 141
 142 static int
 143 verify_cert_callback (int ok, X509_STORE_CTX *ctx)
 144 {
 145   char buf[256];
 146   X509 *cert = X509_STORE_CTX_get_current_cert (ctx);
 147   X509_NAME_oneline (X509_get_subject_name (cert), buf, sizeof (buf));
 148   /* #### Why are we not using the result of the above call?  Are we
 149      supposed to print it?  */
 150   DEBUGP (("verify_cert_callback: %s\n", buf));
 151   return ok;
 152 }
 153
 154 /* Print errors in the OpenSSL error stack. */
 155
 156 static void
 157 print_errors (void)
 158 {
 159   unsigned long curerr = 0;
 160   while ((curerr = ERR_get_error ()) != 0)
 161     logprintf (LOG_NOTQUIET, "OpenSSL: %s\n", ERR_error_string (curerr, NULL));
 162 }
 163
 164 /* Convert keyfile type as used by options.h to a type as accepted by
 165    SSL_CTX_use_certificate_file and SSL_CTX_use_PrivateKey_file.
 166
 167    (options.h intentionally doesn't use values from openssl/ssl.h so
 168    it doesn't depend specifically on OpenSSL for SSL functionality.)  */
 169
 170 static int
 171 key_type_to_ssl_type (enum keyfile_type type)
 172 {
 173   switch (type)
 174     {
 175     case keyfile_pem:
 176       return SSL_FILETYPE_PEM;
 177     case keyfile_asn1:
 178       return SSL_FILETYPE_ASN1;
 179     default:
 180       abort ();
 181     }
 182 }
 183
 184 /* Create an SSL Context and set default paths etc.  Called the first
 185    time an HTTP download is attempted.
 186
 187    Returns 0 on success, non-zero otherwise.  */
 188
 189 int
 190 ssl_init ()
 191 {
 192   SSL_METHOD *meth;
 193
 194   if (ssl_ctx)
 195     /* The SSL has already been initialized. */
 196     return 1;
 197
 198   /* Init the PRNG.  If that fails, bail out.  */
 199   init_prng ();
 200   if (RAND_status () != 1)
 201     {
 202       logprintf (LOG_NOTQUIET,
 203                  _("Could not seed PRNG; consider using --random-file.\n"));
 204       goto error;
 205     }
 206
 207   SSL_library_init ();
 208   SSL_load_error_strings ();
 209   SSLeay_add_all_algorithms ();
 210   SSLeay_add_ssl_algorithms ();
 211
 212   switch (opt.secure_protocol)
 213     {
 214     case secure_protocol_auto:
 215       meth = SSLv23_client_method ();
 216       break;
 217     case secure_protocol_sslv2:
 218       meth = SSLv2_client_method ();
 219       break;
 220     case secure_protocol_sslv3:
 221       meth = SSLv3_client_method ();
 222       break;
 223     case secure_protocol_tlsv1:
 224       meth = TLSv1_client_method ();
 225       break;
 226     default:
 227       abort ();
 228     }
 229
 230   ssl_ctx = SSL_CTX_new (meth);
 231   if (!ssl_ctx)
 232     goto error;
 233
 234   SSL_CTX_set_default_verify_paths (ssl_ctx);
 235   SSL_CTX_load_verify_locations (ssl_ctx, opt.ca_cert, opt.ca_directory);
 236
 237   /* Specify whether the connect should fail if the verification of
 238      the peer fails or if it should go ahead.  */
 239   SSL_CTX_set_verify (ssl_ctx,
 240                       opt.check_cert ? SSL_VERIFY_PEER : SSL_VERIFY_NONE,
 241                       verify_cert_callback);
 242
 243   if (opt.cert_file)
 244     if (SSL_CTX_use_certificate_file (ssl_ctx, opt.cert_file,
 245                                       key_type_to_ssl_type (opt.cert_type))
 246         != 1)
 247       goto error;
 248   if (opt.private_key)
 249     if (SSL_CTX_use_PrivateKey_file (ssl_ctx, opt.private_key,
 250                                      key_type_to_ssl_type (opt.private_key_type))
 251         != 1)
 252       goto error;
 253
 254   /* Since fd_write unconditionally assumes partial writes (and
 255      handles them correctly), allow them in OpenSSL.  */
 256   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 257
 258   return 1;
 259
 260  error:
 261   if (ssl_ctx)
 262     SSL_CTX_free (ssl_ctx);
 263   print_errors ();
 264   return 0;
 265 }
 266
 267 static int
 268 openssl_read (int fd, char *buf, int bufsize, void *ctx)
 269 {
 270   int ret;
 271   SSL *ssl = (SSL *) ctx;
 272   do
 273     ret = SSL_read (ssl, buf, bufsize);
 274   while (ret == -1
 275          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 276          && errno == EINTR);
 277   return ret;
 278 }
 279
 280 static int
 281 openssl_write (int fd, char *buf, int bufsize, void *ctx)
 282 {
 283   int ret = 0;
 284   SSL *ssl = (SSL *) ctx;
 285   do
 286     ret = SSL_write (ssl, buf, bufsize);
 287   while (ret == -1
 288          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 289          && errno == EINTR);
 290   return ret;
 291 }
 292
 293 static int
 294 openssl_poll (int fd, double timeout, int wait_for, void *ctx)
 295 {
 296   SSL *ssl = (SSL *) ctx;
 297   if (timeout == 0)
 298     return 1;
 299   if (SSL_pending (ssl))
 300     return 1;
 301   return select_fd (fd, timeout, wait_for);
 302 }
 303
 304 static int
 305 openssl_peek (int fd, char *buf, int bufsize, void *ctx)
 306 {
 307   int ret;
 308   SSL *ssl = (SSL *) ctx;
 309   do
 310     ret = SSL_peek (ssl, buf, bufsize);
 311   while (ret == -1
 312          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 313          && errno == EINTR);
 314   return ret;
 315 }
 316
 317 static void
 318 openssl_close (int fd, void *ctx)
 319 {
 320   SSL *ssl = (SSL *) ctx;
 321   SSL_shutdown (ssl);
 322   SSL_free (ssl);
 323
 324 #ifdef WINDOWS
 325   closesocket (fd);
 326 #else
 327   close (fd);
 328 #endif
 329
 330   DEBUGP (("Closed %d/SSL 0x%0lx\n", fd, (unsigned long) ssl));
 331 }
 332
 333 /* Sets up a SSL structure and performs the handshake on fd.  The
 334    resulting SSL structure is registered with the file descriptor FD
 335    using fd_register_transport.  That way subsequent calls to xread,
 336    xwrite, etc., will use the appropriate SSL functions.
 337
 338    Returns 1 on success, 0 on failure.  */
 339
 340 int
 341 ssl_connect (int fd)
 342 {
 343   SSL *ssl;
 344
 345   assert (ssl_ctx != NULL);
 346   ssl = SSL_new (ssl_ctx);
 347   if (!ssl)
 348     goto err;
 349   if (!SSL_set_fd (ssl, fd))
 350     goto err;
 351   SSL_set_connect_state (ssl);
 352   if (SSL_connect (ssl) <= 0 || ssl->state != SSL_ST_OK)
 353     goto err;
 354
 355   /* Register FD with Wget's transport layer, i.e. arrange that
 356      SSL-enabled functions are used for reading, writing, and polling.
 357      That way the rest of Wget can keep using fd_read, fd_write, and
 358      friends and not care what happens underneath.  */
 359   fd_register_transport (fd, openssl_read, openssl_write, openssl_poll,
 360                          openssl_peek, openssl_close, ssl);
 361   DEBUGP (("Connected %d to SSL 0x%0*lx\n", fd, 2 * sizeof (void *),
 362            (unsigned long) ssl));
 363   return 1;
 364
 365  err:
 366   print_errors ();
 367   if (ssl)
 368     SSL_free (ssl);
 369   return 0;
 370 }