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