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

   1 /* SSL support via OpenSSL library.
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free
   3    Software Foundation, Inc.
   4    Originally contributed by Christian Fraenkel.
   5
   6 This file is part of GNU Wget.
   7
   8 GNU Wget is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Wget is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 Additional permission under GNU GPL version 3 section 7
  22
  23 If you modify this program, or any covered work, by linking or
  24 combining it with the OpenSSL project's OpenSSL library (or a
  25 modified version of that library), containing parts covered by the
  26 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
  27 grants you additional permission to convey the resulting work.
  28 Corresponding Source for a non-source form of such a combination
  29 shall include the source code for the parts of OpenSSL used as well
  30 as that of the covered work.  */
  31
  32 #include <config.h>
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #ifdef HAVE_UNISTD_H
  37 # include <unistd.h>
  38 #endif
  39 #include <string.h>
  40
  41 #include <openssl/ssl.h>
  42 #include <openssl/x509.h>
  43 #include <openssl/err.h>
  44 #include <openssl/rand.h>
  45
  46 #include "wget.h"
  47 #include "utils.h"
  48 #include "connect.h"
  49 #include "url.h"
  50 #include "ssl.h"
  51
  52 /* Application-wide SSL context.  This is common to all SSL
  53    connections.  */
  54 static SSL_CTX *ssl_ctx;
  55
  56 /* Initialize the SSL's PRNG using various methods. */
  57
  58 static void
  59 init_prng (void)
  60 {
  61   char namebuf[256];
  62   const char *random_file;
  63
  64   if (RAND_status ())
  65     /* The PRNG has been seeded; no further action is necessary. */
  66     return;
  67
  68   /* Seed from a file specified by the user.  This will be the file
  69      specified with --random-file, $RANDFILE, if set, or ~/.rnd, if it
  70      exists.  */
  71   if (opt.random_file)
  72     random_file = opt.random_file;
  73   else
  74     {
  75       /* Get the random file name using RAND_file_name. */
  76       namebuf[0] = '\0';
  77       random_file = RAND_file_name (namebuf, sizeof (namebuf));
  78     }
  79
  80   if (random_file && *random_file)
  81     /* Seed at most 16k (apparently arbitrary value borrowed from
  82        curl) from random file. */
  83     RAND_load_file (random_file, 16384);
  84
  85   if (RAND_status ())
  86     return;
  87
  88   /* Get random data from EGD if opt.egd_file was used.  */
  89   if (opt.egd_file && *opt.egd_file)
  90     RAND_egd (opt.egd_file);
  91
  92   if (RAND_status ())
  93     return;
  94
  95 #ifdef WINDOWS
  96   /* Under Windows, we can try to seed the PRNG using screen content.
  97      This may or may not work, depending on whether we'll calling Wget
  98      interactively.  */
  99
 100   RAND_screen ();
 101   if (RAND_status ())
 102     return;
 103 #endif
 104
 105 #if 0 /* don't do this by default */
 106   {
 107     int maxrand = 500;
 108
 109     /* Still not random enough, presumably because neither /dev/random
 110        nor EGD were available.  Try to seed OpenSSL's PRNG with libc
 111        PRNG.  This is cryptographically weak and defeats the purpose
 112        of using OpenSSL, which is why it is highly discouraged.  */
 113
 114     logprintf (LOG_NOTQUIET, _("WARNING: using a weak random seed.\n"));
 115
 116     while (RAND_status () == 0 && maxrand-- > 0)
 117       {
 118         unsigned char rnd = random_number (256);
 119         RAND_seed (&rnd, sizeof (rnd));
 120       }
 121   }
 122 #endif
 123 }
 124
 125 /* Print errors in the OpenSSL error stack. */
 126
 127 static void
 128 print_errors (void)
 129 {
 130   unsigned long err;
 131   while ((err = ERR_get_error ()) != 0)
 132     logprintf (LOG_NOTQUIET, "OpenSSL: %s\n", ERR_error_string (err, NULL));
 133 }
 134
 135 /* Convert keyfile type as used by options.h to a type as accepted by
 136    SSL_CTX_use_certificate_file and SSL_CTX_use_PrivateKey_file.
 137
 138    (options.h intentionally doesn't use values from openssl/ssl.h so
 139    it doesn't depend specifically on OpenSSL for SSL functionality.)  */
 140
 141 static int
 142 key_type_to_ssl_type (enum keyfile_type type)
 143 {
 144   switch (type)
 145     {
 146     case keyfile_pem:
 147       return SSL_FILETYPE_PEM;
 148     case keyfile_asn1:
 149       return SSL_FILETYPE_ASN1;
 150     default:
 151       abort ();
 152     }
 153 }
 154
 155 /* Create an SSL Context and set default paths etc.  Called the first
 156    time an HTTP download is attempted.
 157
 158    Returns true on success, false otherwise.  */
 159
 160 bool
 161 ssl_init ()
 162 {
 163   SSL_METHOD *meth;
 164
 165   if (ssl_ctx)
 166     /* The SSL has already been initialized. */
 167     return true;
 168
 169   /* Init the PRNG.  If that fails, bail out.  */
 170   init_prng ();
 171   if (RAND_status () != 1)
 172     {
 173       logprintf (LOG_NOTQUIET,
 174                  _("Could not seed PRNG; consider using --random-file.\n"));
 175       goto error;
 176     }
 177
 178   SSL_library_init ();
 179   SSL_load_error_strings ();
 180   SSLeay_add_all_algorithms ();
 181   SSLeay_add_ssl_algorithms ();
 182
 183   switch (opt.secure_protocol)
 184     {
 185     case secure_protocol_auto:
 186       meth = SSLv23_client_method ();
 187       break;
 188     case secure_protocol_sslv2:
 189       meth = SSLv2_client_method ();
 190       break;
 191     case secure_protocol_sslv3:
 192       meth = SSLv3_client_method ();
 193       break;
 194     case secure_protocol_tlsv1:
 195       meth = TLSv1_client_method ();
 196       break;
 197     default:
 198       abort ();
 199     }
 200
 201   ssl_ctx = SSL_CTX_new (meth);
 202   if (!ssl_ctx)
 203     goto error;
 204
 205   SSL_CTX_set_default_verify_paths (ssl_ctx);
 206   SSL_CTX_load_verify_locations (ssl_ctx, opt.ca_cert, opt.ca_directory);
 207
 208   /* SSL_VERIFY_NONE instructs OpenSSL not to abort SSL_connect if the
 209      certificate is invalid.  We verify the certificate separately in
 210      ssl_check_certificate, which provides much better diagnostics
 211      than examining the error stack after a failed SSL_connect.  */
 212   SSL_CTX_set_verify (ssl_ctx, SSL_VERIFY_NONE, NULL);
 213
 214   if (opt.cert_file)
 215     if (SSL_CTX_use_certificate_file (ssl_ctx, opt.cert_file,
 216                                       key_type_to_ssl_type (opt.cert_type))
 217         != 1)
 218       goto error;
 219   if (opt.private_key)
 220     if (SSL_CTX_use_PrivateKey_file (ssl_ctx, opt.private_key,
 221                                      key_type_to_ssl_type (opt.private_key_type))
 222         != 1)
 223       goto error;
 224
 225   /* Since fd_write unconditionally assumes partial writes (and
 226      handles them correctly), allow them in OpenSSL.  */
 227   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 228
 229   /* The OpenSSL library can handle renegotiations automatically, so
 230      tell it to do so.  */
 231   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_AUTO_RETRY);
 232
 233   return true;
 234
 235  error:
 236   if (ssl_ctx)
 237     SSL_CTX_free (ssl_ctx);
 238   print_errors ();
 239   return false;
 240 }
 241
 242 struct openssl_transport_context {
 243   SSL *conn;                    /* SSL connection handle */
 244   char *last_error;             /* last error printed with openssl_errstr */
 245 };
 246
 247 static int
 248 openssl_read (int fd, char *buf, int bufsize, void *arg)
 249 {
 250   int ret;
 251   struct openssl_transport_context *ctx = arg;
 252   SSL *conn = ctx->conn;
 253   do
 254     ret = SSL_read (conn, buf, bufsize);
 255   while (ret == -1
 256          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 257          && errno == EINTR);
 258   return ret;
 259 }
 260
 261 static int
 262 openssl_write (int fd, char *buf, int bufsize, void *arg)
 263 {
 264   int ret = 0;
 265   struct openssl_transport_context *ctx = arg;
 266   SSL *conn = ctx->conn;
 267   do
 268     ret = SSL_write (conn, buf, bufsize);
 269   while (ret == -1
 270          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 271          && errno == EINTR);
 272   return ret;
 273 }
 274
 275 static int
 276 openssl_poll (int fd, double timeout, int wait_for, void *arg)
 277 {
 278   struct openssl_transport_context *ctx = arg;
 279   SSL *conn = ctx->conn;
 280   if (timeout == 0)
 281     return 1;
 282   if (SSL_pending (conn))
 283     return 1;
 284   return select_fd (fd, timeout, wait_for);
 285 }
 286
 287 static int
 288 openssl_peek (int fd, char *buf, int bufsize, void *arg)
 289 {
 290   int ret;
 291   struct openssl_transport_context *ctx = arg;
 292   SSL *conn = ctx->conn;
 293   do
 294     ret = SSL_peek (conn, buf, bufsize);
 295   while (ret == -1
 296          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 297          && errno == EINTR);
 298   return ret;
 299 }
 300
 301 static const char *
 302 openssl_errstr (int fd, void *arg)
 303 {
 304   struct openssl_transport_context *ctx = arg;
 305   unsigned long errcode;
 306   char *errmsg = NULL;
 307   int msglen = 0;
 308
 309   /* If there are no SSL-specific errors, just return NULL. */
 310   if ((errcode = ERR_get_error ()) == 0)
 311     return NULL;
 312
 313   /* Get rid of previous contents of ctx->last_error, if any.  */
 314   xfree_null (ctx->last_error);
 315
 316   /* Iterate over OpenSSL's error stack and accumulate errors in the
 317      last_error buffer, separated by "; ".  This is better than using
 318      a static buffer, which *always* takes up space (and has to be
 319      large, to fit more than one error message), whereas these
 320      allocations are only performed when there is an actual error.  */
 321
 322   for (;;)
 323     {
 324       const char *str = ERR_error_string (errcode, NULL);
 325       int len = strlen (str);
 326
 327       /* Allocate space for the existing message, plus two more chars
 328          for the "; " separator and one for the terminating \0.  */
 329       errmsg = xrealloc (errmsg, msglen + len + 2 + 1);
 330       memcpy (errmsg + msglen, str, len);
 331       msglen += len;
 332
 333       /* Get next error and bail out if there are no more. */
 334       errcode = ERR_get_error ();
 335       if (errcode == 0)
 336         break;
 337
 338       errmsg[msglen++] = ';';
 339       errmsg[msglen++] = ' ';
 340     }
 341   errmsg[msglen] = '\0';
 342
 343   /* Store the error in ctx->last_error where openssl_close will
 344      eventually find it and free it.  */
 345   ctx->last_error = errmsg;
 346
 347   return errmsg;
 348 }
 349
 350 static void
 351 openssl_close (int fd, void *arg)
 352 {
 353   struct openssl_transport_context *ctx = arg;
 354   SSL *conn = ctx->conn;
 355
 356   SSL_shutdown (conn);
 357   SSL_free (conn);
 358   xfree_null (ctx->last_error);
 359   xfree (ctx);
 360
 361 #if defined(WINDOWS) || defined(MSDOS)
 362   closesocket (fd);
 363 #else
 364   close (fd);
 365 #endif
 366
 367   DEBUGP (("Closed %d/SSL 0x%0*lx\n", fd, PTR_FORMAT (conn)));
 368 }
 369
 370 /* openssl_transport is the singleton that describes the SSL transport
 371    methods provided by this file.  */
 372
 373 static struct transport_implementation openssl_transport = {
 374   openssl_read, openssl_write, openssl_poll,
 375   openssl_peek, openssl_errstr, openssl_close
 376 };
 377
 378 /* Perform the SSL handshake on file descriptor FD, which is assumed
 379    to be connected to an SSL server.  The SSL handle provided by
 380    OpenSSL is registered with the file descriptor FD using
 381    fd_register_transport, so that subsequent calls to fd_read,
 382    fd_write, etc., will use the corresponding SSL functions.
 383
 384    Returns true on success, false on failure.  */
 385
 386 bool
 387 ssl_connect (int fd)
 388 {
 389   SSL *conn;
 390   struct openssl_transport_context *ctx;
 391
 392   DEBUGP (("Initiating SSL handshake.\n"));
 393
 394   assert (ssl_ctx != NULL);
 395   conn = SSL_new (ssl_ctx);
 396   if (!conn)
 397     goto error;
 398   if (!SSL_set_fd (conn, fd))
 399     goto error;
 400   SSL_set_connect_state (conn);
 401   if (SSL_connect (conn) <= 0 || conn->state != SSL_ST_OK)
 402     goto error;
 403
 404   ctx = xnew0 (struct openssl_transport_context);
 405   ctx->conn = conn;
 406
 407   /* Register FD with Wget's transport layer, i.e. arrange that our
 408      functions are used for reading, writing, and polling.  */
 409   fd_register_transport (fd, &openssl_transport, ctx);
 410   DEBUGP (("Handshake successful; connected socket %d to SSL handle 0x%0*lx\n",
 411            fd, PTR_FORMAT (conn)));
 412   return true;
 413
 414  error:
 415   DEBUGP (("SSL handshake failed.\n"));
 416   print_errors ();
 417   if (conn)
 418     SSL_free (conn);
 419   return false;
 420 }
 421
 422 #define ASTERISK_EXCLUDES_DOT   /* mandated by rfc2818 */
 423
 424 /* Return true is STRING (case-insensitively) matches PATTERN, false
 425    otherwise.  The recognized wildcard character is "*", which matches
 426    any character in STRING except ".".  Any number of the "*" wildcard
 427    may be present in the pattern.
 428
 429    This is used to match of hosts as indicated in rfc2818: "Names may
 430    contain the wildcard character * which is considered to match any
 431    single domain name component or component fragment. E.g., *.a.com
 432    matches foo.a.com but not bar.foo.a.com. f*.com matches foo.com but
 433    not bar.com [or foo.bar.com]."
 434
 435    If the pattern contain no wildcards, pattern_match(a, b) is
 436    equivalent to !strcasecmp(a, b).  */
 437
 438 static bool
 439 pattern_match (const char *pattern, const char *string)
 440 {
 441   const char *p = pattern, *n = string;
 442   char c;
 443   for (; (c = TOLOWER (*p++)) != '\0'; n++)
 444     if (c == '*')
 445       {
 446         for (c = TOLOWER (*p); c == '*'; c = TOLOWER (*++p))
 447           ;
 448         for (; *n != '\0'; n++)
 449           if (TOLOWER (*n) == c && pattern_match (p, n))
 450             return true;
 451 #ifdef ASTERISK_EXCLUDES_DOT
 452           else if (*n == '.')
 453             return false;
 454 #endif
 455         return c == '\0';
 456       }
 457     else
 458       {
 459         if (c != TOLOWER (*n))
 460           return false;
 461       }
 462   return *n == '\0';
 463 }
 464
 465 /* Verify the validity of the certificate presented by the server.
 466    Also check that the "common name" of the server, as presented by
 467    its certificate, corresponds to HOST.  (HOST typically comes from
 468    the URL and is what the user thinks he's connecting to.)
 469
 470    This assumes that ssl_connect has successfully finished, i.e. that
 471    the SSL handshake has been performed and that FD is connected to an
 472    SSL handle.
 473
 474    If opt.check_cert is true (the default), this returns 1 if the
 475    certificate is valid, 0 otherwise.  If opt.check_cert is 0, the
 476    function always returns 1, but should still be called because it
 477    warns the user about any problems with the certificate.  */
 478
 479 bool
 480 ssl_check_certificate (int fd, const char *host)
 481 {
 482   X509 *cert;
 483   char common_name[256];
 484   long vresult;
 485   bool success = true;
 486
 487   /* If the user has specified --no-check-cert, we still want to warn
 488      him about problems with the server's certificate.  */
 489   const char *severity = opt.check_cert ? _("ERROR") : _("WARNING");
 490
 491   struct openssl_transport_context *ctx = fd_transport_context (fd);
 492   SSL *conn = ctx->conn;
 493   assert (conn != NULL);
 494
 495   cert = SSL_get_peer_certificate (conn);
 496   if (!cert)
 497     {
 498       logprintf (LOG_NOTQUIET, _("%s: No certificate presented by %s.\n"),
 499                  severity, escnonprint (host));
 500       success = false;
 501       goto no_cert;             /* must bail out since CERT is NULL */
 502     }
 503
 504   IF_DEBUG
 505     {
 506       char *subject = X509_NAME_oneline (X509_get_subject_name (cert), 0, 0);
 507       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 508       DEBUGP (("certificate:\n  subject: %s\n  issuer:  %s\n",
 509                escnonprint (subject), escnonprint (issuer)));
 510       OPENSSL_free (subject);
 511       OPENSSL_free (issuer);
 512     }
 513
 514   vresult = SSL_get_verify_result (conn);
 515   if (vresult != X509_V_OK)
 516     {
 517       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 518       logprintf (LOG_NOTQUIET,
 519                  _("%s: cannot verify %s's certificate, issued by `%s':\n"),
 520                  severity, escnonprint (host), escnonprint (issuer));
 521       /* Try to print more user-friendly (and translated) messages for
 522          the frequent verification errors.  */
 523       switch (vresult)
 524         {
 525         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 526           logprintf (LOG_NOTQUIET,
 527                      _("  Unable to locally verify the issuer's authority.\n"));
 528           break;
 529         case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 530         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 531           logprintf (LOG_NOTQUIET, _("  Self-signed certificate encountered.\n"));
 532           break;
 533         case X509_V_ERR_CERT_NOT_YET_VALID:
 534           logprintf (LOG_NOTQUIET, _("  Issued certificate not yet valid.\n"));
 535           break;
 536         case X509_V_ERR_CERT_HAS_EXPIRED:
 537           logprintf (LOG_NOTQUIET, _("  Issued certificate has expired.\n"));
 538           break;
 539         default:
 540           /* For the less frequent error strings, simply provide the
 541              OpenSSL error message.  */
 542           logprintf (LOG_NOTQUIET, "  %s\n",
 543                      X509_verify_cert_error_string (vresult));
 544         }
 545       success = false;
 546       /* Fall through, so that the user is warned about *all* issues
 547          with the cert (important with --no-check-certificate.)  */
 548     }
 549
 550   /* Check that HOST matches the common name in the certificate.
 551      #### The following remains to be done:
 552
 553      - It should use dNSName/ipAddress subjectAltName extensions if
 554        available; according to rfc2818: "If a subjectAltName extension
 555        of type dNSName is present, that MUST be used as the identity."
 556
 557      - When matching against common names, it should loop over all
 558        common names and choose the most specific one, i.e. the last
 559        one, not the first one, which the current code picks.
 560
 561      - Ensure that ASN1 strings from the certificate are encoded as
 562        UTF-8 which can be meaningfully compared to HOST.  */
 563
 564   common_name[0] = '\0';
 565   X509_NAME_get_text_by_NID (X509_get_subject_name (cert),
 566                              NID_commonName, common_name, sizeof (common_name));
 567   if (!pattern_match (common_name, host))
 568     {
 569       logprintf (LOG_NOTQUIET, _("\
 570 %s: certificate common name `%s' doesn't match requested host name `%s'.\n"),
 571                  severity, escnonprint (common_name), escnonprint (host));
 572       success = false;
 573     }
 574
 575   if (success)
 576     DEBUGP (("X509 certificate successfully verified and matches host %s\n",
 577              escnonprint (host)));
 578   X509_free (cert);
 579
 580  no_cert:
 581   if (opt.check_cert && !success)
 582     logprintf (LOG_NOTQUIET, _("\
 583 To connect to %s insecurely, use `--no-check-certificate'.\n"),
 584                escnonprint (host));
 585
 586   /* Allow --no-check-cert to disable certificate checking. */
 587   return opt.check_cert ? success : true;
 588 }