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 /* Creates a SSL Context and sets some defaults for it */
 158 uerr_t
 159 ssl_init ()
 160 {
 161   SSL_METHOD *meth = NULL;
 162
 163   if (ssl_ctx)
 164     return 0;
 165
 166   /* Init the PRNG.  If that fails, bail out.  */
 167   ssl_init_prng ();
 168   if (RAND_status () == 0)
 169     {
 170       logprintf (LOG_NOTQUIET,
 171                  _("Could not seed OpenSSL PRNG; disabling SSL.\n"));
 172       scheme_disable (SCHEME_HTTPS);
 173       return SSLERRCTXCREATE;
 174     }
 175
 176   SSL_library_init ();
 177   SSL_load_error_strings ();
 178   SSLeay_add_all_algorithms ();
 179   SSLeay_add_ssl_algorithms ();
 180   switch (opt.secure_protocol)
 181     {
 182     case secure_protocol_auto:
 183       meth = SSLv23_client_method ();
 184       break;
 185     case secure_protocol_sslv2:
 186       meth = SSLv2_client_method ();
 187       break;
 188     case secure_protocol_sslv3:
 189       meth = SSLv3_client_method ();
 190       break;
 191     case secure_protocol_tlsv1:
 192       meth = TLSv1_client_method ();
 193       break;
 194     }
 195   if (meth == NULL)
 196     {
 197       ssl_print_errors ();
 198       return SSLERRCTXCREATE;
 199     }
 200
 201   ssl_ctx = SSL_CTX_new (meth);
 202   if (meth == NULL)
 203     {
 204       ssl_print_errors ();
 205       return SSLERRCTXCREATE;
 206     }
 207
 208   SSL_CTX_set_default_verify_paths (ssl_ctx);
 209   SSL_CTX_load_verify_locations (ssl_ctx, opt.ca_cert, opt.ca_directory);
 210   SSL_CTX_set_verify (ssl_ctx,
 211                       opt.check_cert ? SSL_VERIFY_PEER : SSL_VERIFY_NONE,
 212                       verify_callback);
 213
 214   if (opt.cert_file != NULL || opt.cert_key != NULL)
 215     {
 216       int ssl_cert_type = SSL_FILETYPE_PEM;
 217       switch (opt.cert_type)
 218         {
 219         case cert_type_pem:
 220           ssl_cert_type = SSL_FILETYPE_PEM;
 221           break;
 222         case cert_type_asn1:
 223           ssl_cert_type = SSL_FILETYPE_ASN1;
 224           break;
 225         }
 226
 227 #if 0 /* what was this supposed to achieve? */
 228       if (opt.cert_key == NULL)
 229         opt.cert_key = opt.cert_file;
 230       if (opt.cert_file == NULL)
 231         opt.cert_file = opt.cert_key;
 232 #endif
 233
 234       if (SSL_CTX_use_certificate_file (ssl_ctx, opt.cert_file,
 235                                         ssl_cert_type) != 1)
 236         {
 237           ssl_print_errors ();
 238           return SSLERRCERTFILE;
 239         }
 240       if (SSL_CTX_use_PrivateKey_file (ssl_ctx, opt.cert_key,
 241                                        ssl_cert_type) != 1)
 242         {
 243           ssl_print_errors ();
 244           return SSLERRCERTKEY;
 245         }
 246     }
 247
 248   return 0; /* Succeded */
 249 }
 250
 251 static int
 252 ssl_read (int fd, char *buf, int bufsize, void *ctx)
 253 {
 254   int ret;
 255   SSL *ssl = (SSL *) ctx;
 256   do
 257     ret = SSL_read (ssl, buf, bufsize);
 258   while (ret == -1
 259          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 260          && errno == EINTR);
 261   return ret;
 262 }
 263
 264 static int
 265 ssl_write (int fd, char *buf, int bufsize, void *ctx)
 266 {
 267   int ret = 0;
 268   SSL *ssl = (SSL *) ctx;
 269   do
 270     ret = SSL_write (ssl, buf, bufsize);
 271   while (ret == -1
 272          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 273          && errno == EINTR);
 274   return ret;
 275 }
 276
 277 static int
 278 ssl_poll (int fd, double timeout, int wait_for, void *ctx)
 279 {
 280   SSL *ssl = (SSL *) ctx;
 281   if (timeout == 0)
 282     return 1;
 283   if (SSL_pending (ssl))
 284     return 1;
 285   return select_fd (fd, timeout, wait_for);
 286 }
 287
 288 static int
 289 ssl_peek (int fd, char *buf, int bufsize, void *ctx)
 290 {
 291   int ret;
 292   SSL *ssl = (SSL *) ctx;
 293   do
 294     ret = SSL_peek (ssl, buf, bufsize);
 295   while (ret == -1
 296          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 297          && errno == EINTR);
 298   return ret;
 299 }
 300
 301 static void
 302 ssl_close (int fd, void *ctx)
 303 {
 304   SSL *ssl = (SSL *) ctx;
 305   SSL_shutdown (ssl);
 306   SSL_free (ssl);
 307
 308 #ifdef WINDOWS
 309   closesocket (fd);
 310 #else
 311   close (fd);
 312 #endif
 313
 314   DEBUGP (("Closed %d/SSL 0x%0lx\n", fd, (unsigned long) ssl));
 315 }
 316
 317 /* Sets up a SSL structure and performs the handshake on fd.  The
 318    resulting SSL structure is registered with the file descriptor FD
 319    using fd_register_transport.  That way subsequent calls to xread,
 320    xwrite, etc., will use the appropriate SSL functions.
 321
 322    Returns 1 on success, 0 on failure.  */
 323
 324 int
 325 ssl_connect (int fd)
 326 {
 327   SSL *ssl;
 328
 329   assert (ssl_ctx != NULL);
 330   ssl = SSL_new (ssl_ctx);
 331   if (!ssl)
 332     goto err;
 333   if (!SSL_set_fd (ssl, fd))
 334     goto err;
 335   SSL_set_connect_state (ssl);
 336   if (SSL_connect (ssl) <= 0 || ssl->state != SSL_ST_OK)
 337     goto err;
 338
 339   /* Register FD with Wget's transport layer, i.e. arrange that
 340      SSL-enabled functions are used for reading, writing, and polling.
 341      That way the rest of Wget can keep using xread, xwrite, and
 342      friends and not care what happens underneath.  */
 343   fd_register_transport (fd, ssl_read, ssl_write, ssl_poll, ssl_peek,
 344                          ssl_close, ssl);
 345   DEBUGP (("Connected %d to SSL 0x%0*lx\n", fd, 2 * sizeof (void *),
 346            (unsigned long) ssl));
 347   return 1;
 348
 349  err:
 350   ssl_print_errors ();
 351   if (ssl)
 352     SSL_free (ssl);
 353   return 0;
 354 }