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

   1 /* SSL support via OpenSSL library.
   2    Copyright (C) 2000-2006 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   /* The OpenSSL library can handle renegotiations automatically, so
 229      tell it to do so.  */
 230   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_AUTO_RETRY);
 231
 232   return true;
 233
 234  error:
 235   if (ssl_ctx)
 236     SSL_CTX_free (ssl_ctx);
 237   print_errors ();
 238   return false;
 239 }
 240
 241 struct openssl_transport_context {
 242   SSL *conn;                    /* SSL connection handle */
 243   char *last_error;             /* last error printed with openssl_errstr */
 244 };
 245
 246 static int
 247 openssl_read (int fd, char *buf, int bufsize, void *arg)
 248 {
 249   int ret;
 250   struct openssl_transport_context *ctx = arg;
 251   SSL *conn = ctx->conn;
 252   do
 253     ret = SSL_read (conn, buf, bufsize);
 254   while (ret == -1
 255          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 256          && errno == EINTR);
 257   return ret;
 258 }
 259
 260 static int
 261 openssl_write (int fd, char *buf, int bufsize, void *arg)
 262 {
 263   int ret = 0;
 264   struct openssl_transport_context *ctx = arg;
 265   SSL *conn = ctx->conn;
 266   do
 267     ret = SSL_write (conn, buf, bufsize);
 268   while (ret == -1
 269          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 270          && errno == EINTR);
 271   return ret;
 272 }
 273
 274 static int
 275 openssl_poll (int fd, double timeout, int wait_for, void *arg)
 276 {
 277   struct openssl_transport_context *ctx = arg;
 278   SSL *conn = ctx->conn;
 279   if (timeout == 0)
 280     return 1;
 281   if (SSL_pending (conn))
 282     return 1;
 283   return select_fd (fd, timeout, wait_for);
 284 }
 285
 286 static int
 287 openssl_peek (int fd, char *buf, int bufsize, void *arg)
 288 {
 289   int ret;
 290   struct openssl_transport_context *ctx = arg;
 291   SSL *conn = ctx->conn;
 292   do
 293     ret = SSL_peek (conn, buf, bufsize);
 294   while (ret == -1
 295          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 296          && errno == EINTR);
 297   return ret;
 298 }
 299
 300 static const char *
 301 openssl_errstr (int fd, void *arg)
 302 {
 303   struct openssl_transport_context *ctx = arg;
 304   unsigned long errcode;
 305   char *errmsg = NULL;
 306   int msglen = 0;
 307
 308   /* If there are no SSL-specific errors, just return NULL. */
 309   if ((errcode = ERR_get_error ()) == 0)
 310     return NULL;
 311
 312   /* Get rid of previous contents of ctx->last_error, if any.  */
 313   xfree_null (ctx->last_error);
 314
 315   /* Iterate over OpenSSL's error stack and accumulate errors in the
 316      last_error buffer, separated by "; ".  This is better than using
 317      a static buffer, which *always* takes up space (and has to be
 318      large, to fit more than one error message), whereas these
 319      allocations are only performed when there is an actual error.  */
 320
 321   for (;;)
 322     {
 323       const char *str = ERR_error_string (errcode, NULL);
 324       int len = strlen (str);
 325
 326       /* Allocate space for the existing message, plus two more chars
 327          for the "; " separator and one for the terminating \0.  */
 328       errmsg = xrealloc (errmsg, msglen + len + 2 + 1);
 329       memcpy (errmsg + msglen, str, len);
 330       msglen += len;
 331
 332       /* Get next error and bail out if there are no more. */
 333       errcode = ERR_get_error ();
 334       if (errcode == 0)
 335         break;
 336
 337       errmsg[msglen++] = ';';
 338       errmsg[msglen++] = ' ';
 339     }
 340   errmsg[msglen] = '\0';
 341
 342   /* Store the error in ctx->last_error where openssl_close will
 343      eventually find it and free it.  */
 344   ctx->last_error = errmsg;
 345
 346   return errmsg;
 347 }
 348
 349 static void
 350 openssl_close (int fd, void *arg)
 351 {
 352   struct openssl_transport_context *ctx = arg;
 353   SSL *conn = ctx->conn;
 354
 355   SSL_shutdown (conn);
 356   SSL_free (conn);
 357   xfree_null (ctx->last_error);
 358   xfree (ctx);
 359
 360 #ifdef WINDOWS
 361   closesocket (fd);
 362 #else
 363   close (fd);
 364 #endif
 365
 366   DEBUGP (("Closed %d/SSL 0x%0*lx\n", fd, PTR_FORMAT (conn)));
 367 }
 368
 369 /* openssl_transport is the singleton that describes the SSL transport
 370    methods provided by this file.  */
 371
 372 static struct transport_implementation openssl_transport = {
 373   openssl_read, openssl_write, openssl_poll,
 374   openssl_peek, openssl_errstr, openssl_close
 375 };
 376
 377 /* Perform the SSL handshake on file descriptor FD, which is assumed
 378    to be connected to an SSL server.  The SSL handle provided by
 379    OpenSSL is registered with the file descriptor FD using
 380    fd_register_transport, so that subsequent calls to fd_read,
 381    fd_write, etc., will use the corresponding SSL functions.
 382
 383    Returns true on success, false on failure.  */
 384
 385 bool
 386 ssl_connect (int fd)
 387 {
 388   SSL *conn;
 389   struct openssl_transport_context *ctx;
 390
 391   DEBUGP (("Initiating SSL handshake.\n"));
 392
 393   assert (ssl_ctx != NULL);
 394   conn = SSL_new (ssl_ctx);
 395   if (!conn)
 396     goto error;
 397   if (!SSL_set_fd (conn, fd))
 398     goto error;
 399   SSL_set_connect_state (conn);
 400   if (SSL_connect (conn) <= 0 || conn->state != SSL_ST_OK)
 401     goto error;
 402
 403   ctx = xnew0 (struct openssl_transport_context);
 404   ctx->conn = conn;
 405
 406   /* Register FD with Wget's transport layer, i.e. arrange that our
 407      functions are used for reading, writing, and polling.  */
 408   fd_register_transport (fd, &openssl_transport, ctx);
 409   DEBUGP (("Handshake successful; connected socket %d to SSL handle 0x%0*lx\n",
 410            fd, PTR_FORMAT (conn)));
 411   return true;
 412
 413  error:
 414   DEBUGP (("SSL handshake failed.\n"));
 415   print_errors ();
 416   if (conn)
 417     SSL_free (conn);
 418   return false;
 419 }
 420
 421 #define ASTERISK_EXCLUDES_DOT   /* mandated by rfc2818 */
 422
 423 /* Return true is STRING (case-insensitively) matches PATTERN, false
 424    otherwise.  The recognized wildcard character is "*", which matches
 425    any character in STRING except ".".  Any number of the "*" wildcard
 426    may be present in the pattern.
 427
 428    This is used to match of hosts as indicated in rfc2818: "Names may
 429    contain the wildcard character * which is considered to match any
 430    single domain name component or component fragment. E.g., *.a.com
 431    matches foo.a.com but not bar.foo.a.com. f*.com matches foo.com but
 432    not bar.com [or foo.bar.com]."
 433
 434    If the pattern contain no wildcards, pattern_match(a, b) is
 435    equivalent to !strcasecmp(a, b).  */
 436
 437 static bool
 438 pattern_match (const char *pattern, const char *string)
 439 {
 440   const char *p = pattern, *n = string;
 441   char c;
 442   for (; (c = TOLOWER (*p++)) != '\0'; n++)
 443     if (c == '*')
 444       {
 445         for (c = TOLOWER (*p); c == '*'; c = TOLOWER (*++p))
 446           ;
 447         for (; *n != '\0'; n++)
 448           if (TOLOWER (*n) == c && pattern_match (p, n))
 449             return true;
 450 #ifdef ASTERISK_EXCLUDES_DOT
 451           else if (*n == '.')
 452             return false;
 453 #endif
 454         return c == '\0';
 455       }
 456     else
 457       {
 458         if (c != TOLOWER (*n))
 459           return false;
 460       }
 461   return *n == '\0';
 462 }
 463
 464 /* Verify the validity of the certificate presented by the server.
 465    Also check that the "common name" of the server, as presented by
 466    its certificate, corresponds to HOST.  (HOST typically comes from
 467    the URL and is what the user thinks he's connecting to.)
 468
 469    This assumes that ssl_connect has successfully finished, i.e. that
 470    the SSL handshake has been performed and that FD is connected to an
 471    SSL handle.
 472
 473    If opt.check_cert is true (the default), this returns 1 if the
 474    certificate is valid, 0 otherwise.  If opt.check_cert is 0, the
 475    function always returns 1, but should still be called because it
 476    warns the user about any problems with the certificate.  */
 477
 478 bool
 479 ssl_check_certificate (int fd, const char *host)
 480 {
 481   X509 *cert;
 482   char common_name[256];
 483   long vresult;
 484   bool success = true;
 485
 486   /* If the user has specified --no-check-cert, we still want to warn
 487      him about problems with the server's certificate.  */
 488   const char *severity = opt.check_cert ? _("ERROR") : _("WARNING");
 489
 490   struct openssl_transport_context *ctx = fd_transport_context (fd);
 491   SSL *conn = ctx->conn;
 492   assert (conn != NULL);
 493
 494   cert = SSL_get_peer_certificate (conn);
 495   if (!cert)
 496     {
 497       logprintf (LOG_NOTQUIET, _("%s: No certificate presented by %s.\n"),
 498                  severity, escnonprint (host));
 499       success = false;
 500       goto no_cert;             /* must bail out since CERT is NULL */
 501     }
 502
 503   IF_DEBUG
 504     {
 505       char *subject = X509_NAME_oneline (X509_get_subject_name (cert), 0, 0);
 506       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 507       DEBUGP (("certificate:\n  subject: %s\n  issuer:  %s\n",
 508                escnonprint (subject), escnonprint (issuer)));
 509       OPENSSL_free (subject);
 510       OPENSSL_free (issuer);
 511     }
 512
 513   vresult = SSL_get_verify_result (conn);
 514   if (vresult != X509_V_OK)
 515     {
 516       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 517       logprintf (LOG_NOTQUIET,
 518                  _("%s: cannot verify %s's certificate, issued by `%s':\n"),
 519                  severity, escnonprint (host), escnonprint (issuer));
 520       /* Try to print more user-friendly (and translated) messages for
 521          the frequent verification errors.  */
 522       switch (vresult)
 523         {
 524         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 525           logprintf (LOG_NOTQUIET,
 526                      _("  Unable to locally verify the issuer's authority.\n"));
 527           break;
 528         case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 529         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 530           logprintf (LOG_NOTQUIET, _("  Self-signed certificate encountered.\n"));
 531           break;
 532         case X509_V_ERR_CERT_NOT_YET_VALID:
 533           logprintf (LOG_NOTQUIET, _("  Issued certificate not yet valid.\n"));
 534           break;
 535         case X509_V_ERR_CERT_HAS_EXPIRED:
 536           logprintf (LOG_NOTQUIET, _("  Issued certificate has expired.\n"));
 537           break;
 538         default:
 539           /* For the less frequent error strings, simply provide the
 540              OpenSSL error message.  */
 541           logprintf (LOG_NOTQUIET, "  %s\n",
 542                      X509_verify_cert_error_string (vresult));
 543         }
 544       success = false;
 545       /* Fall through, so that the user is warned about *all* issues
 546          with the cert (important with --no-check-certificate.)  */
 547     }
 548
 549   /* Check that HOST matches the common name in the certificate.
 550      #### The following remains to be done:
 551
 552      - It should use dNSName/ipAddress subjectAltName extensions if
 553        available; according to rfc2818: "If a subjectAltName extension
 554        of type dNSName is present, that MUST be used as the identity."
 555
 556      - When matching against common names, it should loop over all
 557        common names and choose the most specific one, i.e. the last
 558        one, not the first one, which the current code picks.
 559
 560      - Ensure that ASN1 strings from the certificate are encoded as
 561        UTF-8 which can be meaningfully compared to HOST.  */
 562
 563   common_name[0] = '\0';
 564   X509_NAME_get_text_by_NID (X509_get_subject_name (cert),
 565                              NID_commonName, common_name, sizeof (common_name));
 566   if (!pattern_match (common_name, host))
 567     {
 568       logprintf (LOG_NOTQUIET, _("\
 569 %s: certificate common name `%s' doesn't match requested host name `%s'.\n"),
 570                  severity, escnonprint (common_name), escnonprint (host));
 571       success = false;
 572     }
 573
 574   if (success)
 575     DEBUGP (("X509 certificate successfully verified and matches host %s\n",
 576              escnonprint (host)));
 577   X509_free (cert);
 578
 579  no_cert:
 580   if (opt.check_cert && !success)
 581     logprintf (LOG_NOTQUIET, _("\
 582 To connect to %s insecurely, use `--no-check-certificate'.\n"),
 583                escnonprint (host));
 584
 585   /* Allow --no-check-cert to disable certificate checking. */
 586   return opt.check_cert ? success : true;
 587 }