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 Foundation, Inc.,
  19 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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 #include <string.h>
  39
  40 #include <openssl/ssl.h>
  41 #include <openssl/x509.h>
  42 #include <openssl/err.h>
  43 #include <openssl/rand.h>
  44
  45 #include "wget.h"
  46 #include "utils.h"
  47 #include "connect.h"
  48 #include "url.h"
  49 #include "ssl.h"
  50
  51 /* Application-wide SSL context.  This is common to all SSL
  52    connections.  */
  53 static SSL_CTX *ssl_ctx;
  54
  55 /* Initialize the SSL's PRNG using various methods. */
  56
  57 static void
  58 init_prng (void)
  59 {
  60   char namebuf[256];
  61   const char *random_file;
  62
  63   if (RAND_status ())
  64     /* The PRNG has been seeded; no further action is necessary. */
  65     return;
  66
  67   /* Seed from a file specified by the user.  This will be the file
  68      specified with --random-file, $RANDFILE, if set, or ~/.rnd, if it
  69      exists.  */
  70   if (opt.random_file)
  71     random_file = opt.random_file;
  72   else
  73     {
  74       /* Get the random file name using RAND_file_name. */
  75       namebuf[0] = '\0';
  76       random_file = RAND_file_name (namebuf, sizeof (namebuf));
  77     }
  78
  79   if (random_file && *random_file)
  80     /* Seed at most 16k (apparently arbitrary value borrowed from
  81        curl) from random file. */
  82     RAND_load_file (random_file, 16384);
  83
  84   if (RAND_status ())
  85     return;
  86
  87   /* Get random data from EGD if opt.egd_file was used.  */
  88   if (opt.egd_file && *opt.egd_file)
  89     RAND_egd (opt.egd_file);
  90
  91   if (RAND_status ())
  92     return;
  93
  94 #ifdef WINDOWS
  95   /* Under Windows, we can try to seed the PRNG using screen content.
  96      This may or may not work, depending on whether we'll calling Wget
  97      interactively.  */
  98
  99   RAND_screen ();
 100   if (RAND_status ())
 101     return;
 102 #endif
 103
 104 #if 0 /* don't do this by default */
 105   {
 106     int maxrand = 500;
 107
 108     /* Still not random enough, presumably because neither /dev/random
 109        nor EGD were available.  Try to seed OpenSSL's PRNG with libc
 110        PRNG.  This is cryptographically weak and defeats the purpose
 111        of using OpenSSL, which is why it is highly discouraged.  */
 112
 113     logprintf (LOG_NOTQUIET, _("WARNING: using a weak random seed.\n"));
 114
 115     while (RAND_status () == 0 && maxrand-- > 0)
 116       {
 117         unsigned char rnd = random_number (256);
 118         RAND_seed (&rnd, sizeof (rnd));
 119       }
 120   }
 121 #endif
 122 }
 123
 124 /* Print errors in the OpenSSL error stack. */
 125
 126 static void
 127 print_errors (void)
 128 {
 129   unsigned long err;
 130   while ((err = ERR_get_error ()) != 0)
 131     logprintf (LOG_NOTQUIET, "OpenSSL: %s\n", ERR_error_string (err, NULL));
 132 }
 133
 134 /* Convert keyfile type as used by options.h to a type as accepted by
 135    SSL_CTX_use_certificate_file and SSL_CTX_use_PrivateKey_file.
 136
 137    (options.h intentionally doesn't use values from openssl/ssl.h so
 138    it doesn't depend specifically on OpenSSL for SSL functionality.)  */
 139
 140 static int
 141 key_type_to_ssl_type (enum keyfile_type type)
 142 {
 143   switch (type)
 144     {
 145     case keyfile_pem:
 146       return SSL_FILETYPE_PEM;
 147     case keyfile_asn1:
 148       return SSL_FILETYPE_ASN1;
 149     default:
 150       abort ();
 151     }
 152 }
 153
 154 /* Create an SSL Context and set default paths etc.  Called the first
 155    time an HTTP download is attempted.
 156
 157    Returns true on success, false otherwise.  */
 158
 159 bool
 160 ssl_init ()
 161 {
 162   SSL_METHOD *meth;
 163
 164   if (ssl_ctx)
 165     /* The SSL has already been initialized. */
 166     return true;
 167
 168   /* Init the PRNG.  If that fails, bail out.  */
 169   init_prng ();
 170   if (RAND_status () != 1)
 171     {
 172       logprintf (LOG_NOTQUIET,
 173                  _("Could not seed PRNG; consider using --random-file.\n"));
 174       goto error;
 175     }
 176
 177   SSL_library_init ();
 178   SSL_load_error_strings ();
 179   SSLeay_add_all_algorithms ();
 180   SSLeay_add_ssl_algorithms ();
 181
 182   switch (opt.secure_protocol)
 183     {
 184     case secure_protocol_auto:
 185       meth = SSLv23_client_method ();
 186       break;
 187     case secure_protocol_sslv2:
 188       meth = SSLv2_client_method ();
 189       break;
 190     case secure_protocol_sslv3:
 191       meth = SSLv3_client_method ();
 192       break;
 193     case secure_protocol_tlsv1:
 194       meth = TLSv1_client_method ();
 195       break;
 196     default:
 197       abort ();
 198     }
 199
 200   ssl_ctx = SSL_CTX_new (meth);
 201   if (!ssl_ctx)
 202     goto error;
 203
 204   SSL_CTX_set_default_verify_paths (ssl_ctx);
 205   SSL_CTX_load_verify_locations (ssl_ctx, opt.ca_cert, opt.ca_directory);
 206
 207   /* SSL_VERIFY_NONE instructs OpenSSL not to abort SSL_connect if the
 208      certificate is invalid.  We verify the certificate separately in
 209      ssl_check_certificate, which provides much better diagnostics
 210      than examining the error stack after a failed SSL_connect.  */
 211   SSL_CTX_set_verify (ssl_ctx, SSL_VERIFY_NONE, NULL);
 212
 213   if (opt.cert_file)
 214     if (SSL_CTX_use_certificate_file (ssl_ctx, opt.cert_file,
 215                                       key_type_to_ssl_type (opt.cert_type))
 216         != 1)
 217       goto error;
 218   if (opt.private_key)
 219     if (SSL_CTX_use_PrivateKey_file (ssl_ctx, opt.private_key,
 220                                      key_type_to_ssl_type (opt.private_key_type))
 221         != 1)
 222       goto error;
 223
 224   /* Since fd_write unconditionally assumes partial writes (and
 225      handles them correctly), allow them in OpenSSL.  */
 226   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 227
 228   return true;
 229
 230  error:
 231   if (ssl_ctx)
 232     SSL_CTX_free (ssl_ctx);
 233   print_errors ();
 234   return false;
 235 }
 236
 237 static int
 238 openssl_read (int fd, char *buf, int bufsize, void *ctx)
 239 {
 240   int ret;
 241   SSL *ssl = ctx;
 242   do
 243     ret = SSL_read (ssl, buf, bufsize);
 244   while (ret == -1
 245          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 246          && errno == EINTR);
 247   return ret;
 248 }
 249
 250 static int
 251 openssl_write (int fd, char *buf, int bufsize, void *ctx)
 252 {
 253   int ret = 0;
 254   SSL *ssl = ctx;
 255   do
 256     ret = SSL_write (ssl, buf, bufsize);
 257   while (ret == -1
 258          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 259          && errno == EINTR);
 260   return ret;
 261 }
 262
 263 static int
 264 openssl_poll (int fd, double timeout, int wait_for, void *ctx)
 265 {
 266   SSL *ssl = ctx;
 267   if (timeout == 0)
 268     return 1;
 269   if (SSL_pending (ssl))
 270     return 1;
 271   return select_fd (fd, timeout, wait_for);
 272 }
 273
 274 static int
 275 openssl_peek (int fd, char *buf, int bufsize, void *ctx)
 276 {
 277   int ret;
 278   SSL *ssl = ctx;
 279   do
 280     ret = SSL_peek (ssl, buf, bufsize);
 281   while (ret == -1
 282          && SSL_get_error (ssl, ret) == SSL_ERROR_SYSCALL
 283          && errno == EINTR);
 284   return ret;
 285 }
 286
 287 static const char *
 288 openssl_errstr (int fd, void *ctx)
 289 {
 290   /* Unfortunately we cannot use ERR_error_string's internal buf
 291      because we must be prepared to printing more than one error in
 292      succession.  */
 293   static char errbuf[512];
 294   char *p = errbuf, *end = errbuf + sizeof errbuf;
 295   unsigned long err;
 296
 297   if ((err = ERR_get_error ()) == 0)
 298     /* Inform the caller that there have been no errors */
 299     return NULL;
 300
 301   /* Iterate over OpenSSL's error stack and print errors to ERRBUF,
 302      each followed by '\n', while being careful not to overrun
 303      ERRBUF.  */
 304   do
 305     {
 306       ERR_error_string_n (err, p, end - p);
 307       p = strchr (p, '\0');
 308       if (p < end)
 309        *p++ = '\n';
 310     }
 311   while ((err = ERR_get_error ()) != 0);
 312
 313   if (p < end)
 314     *p++ = '\0';
 315   else
 316     end[-1] = '\0';
 317   return errbuf;
 318 }
 319
 320 static void
 321 openssl_close (int fd, void *ctx)
 322 {
 323   SSL *ssl = ctx;
 324   SSL_shutdown (ssl);
 325   SSL_free (ssl);
 326
 327 #ifdef WINDOWS
 328   closesocket (fd);
 329 #else
 330   close (fd);
 331 #endif
 332
 333   DEBUGP (("Closed %d/SSL 0x%0lx\n", fd, (unsigned long) ssl));
 334 }
 335
 336 /* openssl_transport is the singleton that describes the SSL transport
 337    methods provided by this file.  */
 338
 339 static struct transport_implementation openssl_transport = {
 340   openssl_read, openssl_write, openssl_poll,
 341   openssl_peek, openssl_errstr, openssl_close
 342 };
 343
 344 /* Perform the SSL handshake on file descriptor FD, which is assumed
 345    to be connected to an SSL server.  The SSL handle provided by
 346    OpenSSL is registered with the file descriptor FD using
 347    fd_register_transport, so that subsequent calls to fd_read,
 348    fd_write, etc., will use the corresponding SSL functions.
 349
 350    Returns true on success, false on failure.  */
 351
 352 bool
 353 ssl_connect (int fd)
 354 {
 355   SSL *ssl;
 356
 357   DEBUGP (("Initiating SSL handshake.\n"));
 358
 359   assert (ssl_ctx != NULL);
 360   ssl = SSL_new (ssl_ctx);
 361   if (!ssl)
 362     goto error;
 363   if (!SSL_set_fd (ssl, fd))
 364     goto error;
 365   SSL_set_connect_state (ssl);
 366   if (SSL_connect (ssl) <= 0 || ssl->state != SSL_ST_OK)
 367     goto error;
 368
 369   /* Register FD with Wget's transport layer, i.e. arrange that our
 370      functions are used for reading, writing, and polling.  */
 371   fd_register_transport (fd, &openssl_transport, ssl);
 372   DEBUGP (("Handshake successful; connected socket %d to SSL handle 0x%0*lx\n",
 373            fd, PTR_FORMAT (ssl)));
 374   return true;
 375
 376  error:
 377   DEBUGP (("SSL handshake failed.\n"));
 378   print_errors ();
 379   if (ssl)
 380     SSL_free (ssl);
 381   return false;
 382 }
 383
 384 #define ASTERISK_EXCLUDES_DOT   /* mandated by rfc2818 */
 385
 386 /* Return true is STRING (case-insensitively) matches PATTERN, false
 387    otherwise.  The recognized wildcard character is "*", which matches
 388    any character in STRING except ".".  Any number of the "*" wildcard
 389    may be present in the pattern.
 390
 391    This is used to match of hosts as indicated in rfc2818: "Names may
 392    contain the wildcard character * which is considered to match any
 393    single domain name component or component fragment. E.g., *.a.com
 394    matches foo.a.com but not bar.foo.a.com. f*.com matches foo.com but
 395    not bar.com [or foo.bar.com]."
 396
 397    If the pattern contain no wildcards, pattern_match(a, b) is
 398    equivalent to !strcasecmp(a, b).  */
 399
 400 static bool
 401 pattern_match (const char *pattern, const char *string)
 402 {
 403   const char *p = pattern, *n = string;
 404   char c;
 405   for (; (c = TOLOWER (*p++)) != '\0'; n++)
 406     if (c == '*')
 407       {
 408         for (c = TOLOWER (*p); c == '*'; c = TOLOWER (*++p))
 409           ;
 410         for (; *n != '\0'; n++)
 411           if (TOLOWER (*n) == c && pattern_match (p, n))
 412             return true;
 413 #ifdef ASTERISK_EXCLUDES_DOT
 414           else if (*n == '.')
 415             return false;
 416 #endif
 417         return c == '\0';
 418       }
 419     else
 420       {
 421         if (c != TOLOWER (*n))
 422           return false;
 423       }
 424   return *n == '\0';
 425 }
 426
 427 /* Verify the validity of the certificate presented by the server.
 428    Also check that the "common name" of the server, as presented by
 429    its certificate, corresponds to HOST.  (HOST typically comes from
 430    the URL and is what the user thinks he's connecting to.)
 431
 432    This assumes that ssl_connect has successfully finished, i.e. that
 433    the SSL handshake has been performed and that FD is connected to an
 434    SSL handle.
 435
 436    If opt.check_cert is true (the default), this returns 1 if the
 437    certificate is valid, 0 otherwise.  If opt.check_cert is 0, the
 438    function always returns 1, but should still be called because it
 439    warns the user about any problems with the certificate.  */
 440
 441 bool
 442 ssl_check_certificate (int fd, const char *host)
 443 {
 444   X509 *cert;
 445   char common_name[256];
 446   long vresult;
 447   bool success = true;
 448
 449   /* If the user has specified --no-check-cert, we still want to warn
 450      him about problems with the server's certificate.  */
 451   const char *severity = opt.check_cert ? _("ERROR") : _("WARNING");
 452
 453   SSL *ssl = (SSL *) fd_transport_context (fd);
 454   assert (ssl != NULL);
 455
 456   cert = SSL_get_peer_certificate (ssl);
 457   if (!cert)
 458     {
 459       logprintf (LOG_NOTQUIET, _("%s: No certificate presented by %s.\n"),
 460                  severity, escnonprint (host));
 461       success = false;
 462       goto no_cert;             /* must bail out since CERT is NULL */
 463     }
 464
 465   IF_DEBUG
 466     {
 467       char *subject = X509_NAME_oneline (X509_get_subject_name (cert), 0, 0);
 468       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 469       DEBUGP (("certificate:\n  subject: %s\n  issuer:  %s\n",
 470                escnonprint (subject), escnonprint (issuer)));
 471       OPENSSL_free (subject);
 472       OPENSSL_free (issuer);
 473     }
 474
 475   vresult = SSL_get_verify_result (ssl);
 476   if (vresult != X509_V_OK)
 477     {
 478       /* #### We might want to print saner (and translatable) error
 479          messages for several frequently encountered errors.  The
 480          candidates would include
 481          X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY,
 482          X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN,
 483          X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT,
 484          X509_V_ERR_CERT_NOT_YET_VALID, X509_V_ERR_CERT_HAS_EXPIRED,
 485          and possibly others.  The current approach would still be
 486          used for the less frequent failure cases.  */
 487       logprintf (LOG_NOTQUIET,
 488                  _("%s: Certificate verification error for %s: %s\n"),
 489                  severity, escnonprint (host),
 490                  X509_verify_cert_error_string (vresult));
 491       success = false;
 492       /* Fall through, so that the user is warned about *all* issues
 493          with the cert (important with --no-check-certificate.)  */
 494     }
 495
 496   /* Check that HOST matches the common name in the certificate.
 497      #### The following remains to be done:
 498
 499      - It should use dNSName/ipAddress subjectAltName extensions if
 500        available; according to rfc2818: "If a subjectAltName extension
 501        of type dNSName is present, that MUST be used as the identity."
 502
 503      - When matching against common names, it should loop over all
 504        common names and choose the most specific one, i.e. the last
 505        one, not the first one, which the current code picks.
 506
 507      - Ensure that ASN1 strings from the certificate are encoded as
 508        UTF-8 which can be meaningfully compared to HOST.  */
 509
 510   common_name[0] = '\0';
 511   X509_NAME_get_text_by_NID (X509_get_subject_name (cert),
 512                              NID_commonName, common_name, sizeof (common_name));
 513   if (!pattern_match (common_name, host))
 514     {
 515       logprintf (LOG_NOTQUIET, _("\
 516 %s: certificate common name `%s' doesn't match requested host name `%s'.\n"),
 517                  severity, escnonprint (common_name), escnonprint (host));
 518       success = false;
 519     }
 520
 521   if (success)
 522     DEBUGP (("X509 certificate successfully verified and matches host %s\n",
 523              escnonprint (host)));
 524   X509_free (cert);
 525
 526  no_cert:
 527   if (opt.check_cert && !success)
 528     logprintf (LOG_NOTQUIET, _("\
 529 To connect to %s insecurely, use `--no-check-certificate'.\n"),
 530                escnonprint (host));
 531
 532   /* Allow --no-check-cert to disable certificate checking. */
 533   return opt.check_cert ? success : true;
 534 }