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, 2008,
   3    2009, 2010, 2011 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 #include "wget.h"
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #include <string.h>
  38
  39 #include <openssl/ssl.h>
  40 #include <openssl/x509v3.h>
  41 #include <openssl/err.h>
  42 #include <openssl/rand.h>
  43
  44 #include "utils.h"
  45 #include "connect.h"
  46 #include "url.h"
  47 #include "ssl.h"
  48
  49 #ifdef WINDOWS
  50 # include <w32sock.h>
  51 #endif
  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 #ifndef OPENSSL_NO_SSL2
 190     case secure_protocol_sslv2:
 191       meth = SSLv2_client_method ();
 192       break;
 193 #endif
 194     case secure_protocol_sslv3:
 195       meth = SSLv3_client_method ();
 196       break;
 197     case secure_protocol_tlsv1:
 198       meth = TLSv1_client_method ();
 199       break;
 200     default:
 201       abort ();
 202     }
 203
 204   ssl_ctx = SSL_CTX_new (meth);
 205   if (!ssl_ctx)
 206     goto error;
 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
 211   /* SSL_VERIFY_NONE instructs OpenSSL not to abort SSL_connect if the
 212      certificate is invalid.  We verify the certificate separately in
 213      ssl_check_certificate, which provides much better diagnostics
 214      than examining the error stack after a failed SSL_connect.  */
 215   SSL_CTX_set_verify (ssl_ctx, SSL_VERIFY_NONE, NULL);
 216
 217   /* Use the private key from the cert file unless otherwise specified. */
 218   if (opt.cert_file && !opt.private_key)
 219     {
 220       opt.private_key = opt.cert_file;
 221       opt.private_key_type = opt.cert_type;
 222     }
 223
 224   if (opt.cert_file)
 225     if (SSL_CTX_use_certificate_file (ssl_ctx, opt.cert_file,
 226                                       key_type_to_ssl_type (opt.cert_type))
 227         != 1)
 228       goto error;
 229   if (opt.private_key)
 230     if (SSL_CTX_use_PrivateKey_file (ssl_ctx, opt.private_key,
 231                                      key_type_to_ssl_type (opt.private_key_type))
 232         != 1)
 233       goto error;
 234
 235   /* Since fd_write unconditionally assumes partial writes (and
 236      handles them correctly), allow them in OpenSSL.  */
 237   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 238
 239   /* The OpenSSL library can handle renegotiations automatically, so
 240      tell it to do so.  */
 241   SSL_CTX_set_mode (ssl_ctx, SSL_MODE_AUTO_RETRY);
 242
 243   return true;
 244
 245  error:
 246   if (ssl_ctx)
 247     SSL_CTX_free (ssl_ctx);
 248   print_errors ();
 249   return false;
 250 }
 251
 252 struct openssl_transport_context {
 253   SSL *conn;                    /* SSL connection handle */
 254   char *last_error;             /* last error printed with openssl_errstr */
 255 };
 256
 257 static int
 258 openssl_read (int fd, char *buf, int bufsize, void *arg)
 259 {
 260   int ret;
 261   struct openssl_transport_context *ctx = arg;
 262   SSL *conn = ctx->conn;
 263   do
 264     ret = SSL_read (conn, buf, bufsize);
 265   while (ret == -1
 266          && (SSL_get_error (conn, ret) == SSL_ERROR_WANT_READ
 267              || (SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 268                  && errno == EINTR)));
 269
 270   return ret;
 271 }
 272
 273 static int
 274 openssl_write (int fd, char *buf, int bufsize, void *arg)
 275 {
 276   int ret = 0;
 277   struct openssl_transport_context *ctx = arg;
 278   SSL *conn = ctx->conn;
 279   do
 280     ret = SSL_write (conn, buf, bufsize);
 281   while (ret == -1
 282          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 283          && errno == EINTR);
 284   return ret;
 285 }
 286
 287 static int
 288 openssl_poll (int fd, double timeout, int wait_for, void *arg)
 289 {
 290   struct openssl_transport_context *ctx = arg;
 291   SSL *conn = ctx->conn;
 292   if (SSL_pending (conn))
 293     return 1;
 294   if (timeout == 0)
 295     return 1;
 296   return select_fd (fd, timeout, wait_for);
 297 }
 298
 299 static int
 300 openssl_peek (int fd, char *buf, int bufsize, void *arg)
 301 {
 302   int ret;
 303   struct openssl_transport_context *ctx = arg;
 304   SSL *conn = ctx->conn;
 305   if (! openssl_poll (fd, 0.0, WAIT_FOR_READ, arg))
 306     return 0;
 307   do
 308     ret = SSL_peek (conn, buf, bufsize);
 309   while (ret == -1
 310          && SSL_get_error (conn, ret) == SSL_ERROR_SYSCALL
 311          && errno == EINTR);
 312   return ret;
 313 }
 314
 315 static const char *
 316 openssl_errstr (int fd, void *arg)
 317 {
 318   struct openssl_transport_context *ctx = arg;
 319   unsigned long errcode;
 320   char *errmsg = NULL;
 321   int msglen = 0;
 322
 323   /* If there are no SSL-specific errors, just return NULL. */
 324   if ((errcode = ERR_get_error ()) == 0)
 325     return NULL;
 326
 327   /* Get rid of previous contents of ctx->last_error, if any.  */
 328   xfree_null (ctx->last_error);
 329
 330   /* Iterate over OpenSSL's error stack and accumulate errors in the
 331      last_error buffer, separated by "; ".  This is better than using
 332      a static buffer, which *always* takes up space (and has to be
 333      large, to fit more than one error message), whereas these
 334      allocations are only performed when there is an actual error.  */
 335
 336   for (;;)
 337     {
 338       const char *str = ERR_error_string (errcode, NULL);
 339       int len = strlen (str);
 340
 341       /* Allocate space for the existing message, plus two more chars
 342          for the "; " separator and one for the terminating \0.  */
 343       errmsg = xrealloc (errmsg, msglen + len + 2 + 1);
 344       memcpy (errmsg + msglen, str, len);
 345       msglen += len;
 346
 347       /* Get next error and bail out if there are no more. */
 348       errcode = ERR_get_error ();
 349       if (errcode == 0)
 350         break;
 351
 352       errmsg[msglen++] = ';';
 353       errmsg[msglen++] = ' ';
 354     }
 355   errmsg[msglen] = '\0';
 356
 357   /* Store the error in ctx->last_error where openssl_close will
 358      eventually find it and free it.  */
 359   ctx->last_error = errmsg;
 360
 361   return errmsg;
 362 }
 363
 364 static void
 365 openssl_close (int fd, void *arg)
 366 {
 367   struct openssl_transport_context *ctx = arg;
 368   SSL *conn = ctx->conn;
 369
 370   SSL_shutdown (conn);
 371   SSL_free (conn);
 372   xfree_null (ctx->last_error);
 373   xfree (ctx);
 374
 375   close (fd);
 376
 377   DEBUGP (("Closed %d/SSL 0x%0*lx\n", fd, PTR_FORMAT (conn)));
 378 }
 379
 380 /* openssl_transport is the singleton that describes the SSL transport
 381    methods provided by this file.  */
 382
 383 static struct transport_implementation openssl_transport = {
 384   openssl_read, openssl_write, openssl_poll,
 385   openssl_peek, openssl_errstr, openssl_close
 386 };
 387
 388 /* Perform the SSL handshake on file descriptor FD, which is assumed
 389    to be connected to an SSL server.  The SSL handle provided by
 390    OpenSSL is registered with the file descriptor FD using
 391    fd_register_transport, so that subsequent calls to fd_read,
 392    fd_write, etc., will use the corresponding SSL functions.
 393
 394    Returns true on success, false on failure.  */
 395
 396 bool
 397 ssl_connect_wget (int fd)
 398 {
 399   SSL *conn;
 400   struct openssl_transport_context *ctx;
 401
 402   DEBUGP (("Initiating SSL handshake.\n"));
 403
 404   assert (ssl_ctx != NULL);
 405   conn = SSL_new (ssl_ctx);
 406   if (!conn)
 407     goto error;
 408 #ifndef FD_TO_SOCKET
 409 # define FD_TO_SOCKET(X) (X)
 410 #endif
 411   if (!SSL_set_fd (conn, FD_TO_SOCKET (fd)))
 412     goto error;
 413   SSL_set_connect_state (conn);
 414   if (SSL_connect (conn) <= 0 || conn->state != SSL_ST_OK)
 415     goto error;
 416
 417   ctx = xnew0 (struct openssl_transport_context);
 418   ctx->conn = conn;
 419
 420   /* Register FD with Wget's transport layer, i.e. arrange that our
 421      functions are used for reading, writing, and polling.  */
 422   fd_register_transport (fd, &openssl_transport, ctx);
 423   DEBUGP (("Handshake successful; connected socket %d to SSL handle 0x%0*lx\n",
 424            fd, PTR_FORMAT (conn)));
 425   return true;
 426
 427  error:
 428   DEBUGP (("SSL handshake failed.\n"));
 429   print_errors ();
 430   if (conn)
 431     SSL_free (conn);
 432   return false;
 433 }
 434
 435 #define ASTERISK_EXCLUDES_DOT   /* mandated by rfc2818 */
 436
 437 /* Return true is STRING (case-insensitively) matches PATTERN, false
 438    otherwise.  The recognized wildcard character is "*", which matches
 439    any character in STRING except ".".  Any number of the "*" wildcard
 440    may be present in the pattern.
 441
 442    This is used to match of hosts as indicated in rfc2818: "Names may
 443    contain the wildcard character * which is considered to match any
 444    single domain name component or component fragment. E.g., *.a.com
 445    matches foo.a.com but not bar.foo.a.com. f*.com matches foo.com but
 446    not bar.com [or foo.bar.com]."
 447
 448    If the pattern contain no wildcards, pattern_match(a, b) is
 449    equivalent to !strcasecmp(a, b).  */
 450
 451 static bool
 452 pattern_match (const char *pattern, const char *string)
 453 {
 454   const char *p = pattern, *n = string;
 455   char c;
 456   for (; (c = c_tolower (*p++)) != '\0'; n++)
 457     if (c == '*')
 458       {
 459         for (c = c_tolower (*p); c == '*'; c = c_tolower (*++p))
 460           ;
 461         for (; *n != '\0'; n++)
 462           if (c_tolower (*n) == c && pattern_match (p, n))
 463             return true;
 464 #ifdef ASTERISK_EXCLUDES_DOT
 465           else if (*n == '.')
 466             return false;
 467 #endif
 468         return c == '\0';
 469       }
 470     else
 471       {
 472         if (c != c_tolower (*n))
 473           return false;
 474       }
 475   return *n == '\0';
 476 }
 477
 478 /* Verify the validity of the certificate presented by the server.
 479    Also check that the "common name" of the server, as presented by
 480    its certificate, corresponds to HOST.  (HOST typically comes from
 481    the URL and is what the user thinks he's connecting to.)
 482
 483    This assumes that ssl_connect_wget has successfully finished, i.e. that
 484    the SSL handshake has been performed and that FD is connected to an
 485    SSL handle.
 486
 487    If opt.check_cert is true (the default), this returns 1 if the
 488    certificate is valid, 0 otherwise.  If opt.check_cert is 0, the
 489    function always returns 1, but should still be called because it
 490    warns the user about any problems with the certificate.  */
 491
 492 bool
 493 ssl_check_certificate (int fd, const char *host)
 494 {
 495   X509 *cert;
 496   GENERAL_NAMES *subjectAltNames;
 497   char common_name[256];
 498   long vresult;
 499   bool success = true;
 500   bool alt_name_checked = false;
 501
 502   /* If the user has specified --no-check-cert, we still want to warn
 503      him about problems with the server's certificate.  */
 504   const char *severity = opt.check_cert ? _("ERROR") : _("WARNING");
 505
 506   struct openssl_transport_context *ctx = fd_transport_context (fd);
 507   SSL *conn = ctx->conn;
 508   assert (conn != NULL);
 509
 510   cert = SSL_get_peer_certificate (conn);
 511   if (!cert)
 512     {
 513       logprintf (LOG_NOTQUIET, _("%s: No certificate presented by %s.\n"),
 514                  severity, quotearg_style (escape_quoting_style, host));
 515       success = false;
 516       goto no_cert;             /* must bail out since CERT is NULL */
 517     }
 518
 519   IF_DEBUG
 520     {
 521       char *subject = X509_NAME_oneline (X509_get_subject_name (cert), 0, 0);
 522       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 523       DEBUGP (("certificate:\n  subject: %s\n  issuer:  %s\n",
 524                quotearg_n_style (0, escape_quoting_style, subject),
 525                quotearg_n_style (1, escape_quoting_style, issuer)));
 526       OPENSSL_free (subject);
 527       OPENSSL_free (issuer);
 528     }
 529
 530   vresult = SSL_get_verify_result (conn);
 531   if (vresult != X509_V_OK)
 532     {
 533       char *issuer = X509_NAME_oneline (X509_get_issuer_name (cert), 0, 0);
 534       logprintf (LOG_NOTQUIET,
 535                  _("%s: cannot verify %s's certificate, issued by %s:\n"),
 536                  severity, quotearg_n_style (0, escape_quoting_style, host),
 537                  quote_n (1, issuer));
 538       /* Try to print more user-friendly (and translated) messages for
 539          the frequent verification errors.  */
 540       switch (vresult)
 541         {
 542         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 543           logprintf (LOG_NOTQUIET,
 544                      _("  Unable to locally verify the issuer's authority.\n"));
 545           break;
 546         case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 547         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 548           logprintf (LOG_NOTQUIET,
 549                      _("  Self-signed certificate encountered.\n"));
 550           break;
 551         case X509_V_ERR_CERT_NOT_YET_VALID:
 552           logprintf (LOG_NOTQUIET, _("  Issued certificate not yet valid.\n"));
 553           break;
 554         case X509_V_ERR_CERT_HAS_EXPIRED:
 555           logprintf (LOG_NOTQUIET, _("  Issued certificate has expired.\n"));
 556           break;
 557         default:
 558           /* For the less frequent error strings, simply provide the
 559              OpenSSL error message.  */
 560           logprintf (LOG_NOTQUIET, "  %s\n",
 561                      X509_verify_cert_error_string (vresult));
 562         }
 563       success = false;
 564       /* Fall through, so that the user is warned about *all* issues
 565          with the cert (important with --no-check-certificate.)  */
 566     }
 567
 568   /* Check that HOST matches the common name in the certificate.
 569      #### The following remains to be done:
 570
 571      - When matching against common names, it should loop over all
 572        common names and choose the most specific one, i.e. the last
 573        one, not the first one, which the current code picks.
 574
 575      - Ensure that ASN1 strings from the certificate are encoded as
 576        UTF-8 which can be meaningfully compared to HOST.  */
 577
 578   subjectAltNames = X509_get_ext_d2i (cert, NID_subject_alt_name, NULL, NULL);
 579
 580   if (subjectAltNames)
 581     {
 582       /* Test subject alternative names */
 583
 584       /* Do we want to check for dNSNAmes or ipAddresses (see RFC 2818)?
 585        * Signal it by host_in_octet_string. */
 586       ASN1_OCTET_STRING *host_in_octet_string = a2i_IPADDRESS (host);
 587
 588       int numaltnames = sk_GENERAL_NAME_num (subjectAltNames);
 589       int i;
 590       for (i=0; i < numaltnames; i++)
 591         {
 592           const GENERAL_NAME *name =
 593             sk_GENERAL_NAME_value (subjectAltNames, i);
 594           if (name)
 595             {
 596               if (host_in_octet_string)
 597                 {
 598                   if (name->type == GEN_IPADD)
 599                     {
 600                       /* Check for ipAddress */
 601                       /* TODO: Should we convert between IPv4-mapped IPv6
 602                        * addresses and IPv4 addresses? */
 603                       alt_name_checked = true;
 604                       if (!ASN1_STRING_cmp (host_in_octet_string,
 605                             name->d.iPAddress))
 606                         break;
 607                     }
 608                 }
 609               else if (name->type == GEN_DNS)
 610                 {
 611                   /* dNSName should be IA5String (i.e. ASCII), however who
 612                    * does trust CA? Convert it into UTF-8 for sure. */
 613                   unsigned char *name_in_utf8 = NULL;
 614
 615                   /* Check for dNSName */
 616                   alt_name_checked = true;
 617
 618                   if (0 <= ASN1_STRING_to_UTF8 (&name_in_utf8, name->d.dNSName))
 619                     {
 620                       /* Compare and check for NULL attack in ASN1_STRING */
 621                       if (pattern_match ((char *)name_in_utf8, host) &&
 622                             (strlen ((char *)name_in_utf8) ==
 623                                 ASN1_STRING_length (name->d.dNSName)))
 624                         {
 625                           OPENSSL_free (name_in_utf8);
 626                           break;
 627                         }
 628                       OPENSSL_free (name_in_utf8);
 629                     }
 630                 }
 631             }
 632         }
 633       sk_GENERAL_NAME_free (subjectAltNames);
 634       if (host_in_octet_string)
 635         ASN1_OCTET_STRING_free(host_in_octet_string);
 636
 637       if (alt_name_checked == true && i >= numaltnames)
 638         {
 639           logprintf (LOG_NOTQUIET,
 640               _("%s: no certificate subject alternative name matches\n"
 641                 "\trequested host name %s.\n"),
 642                      severity, quote_n (1, host));
 643           success = false;
 644         }
 645     }
 646
 647   if (alt_name_checked == false)
 648     {
 649       /* Test commomName */
 650       X509_NAME *xname = X509_get_subject_name(cert);
 651       common_name[0] = '\0';
 652       X509_NAME_get_text_by_NID (xname, NID_commonName, common_name,
 653                                  sizeof (common_name));
 654
 655       if (!pattern_match (common_name, host))
 656         {
 657           logprintf (LOG_NOTQUIET, _("\
 658     %s: certificate common name %s doesn't match requested host name %s.\n"),
 659                      severity, quote_n (0, common_name), quote_n (1, host));
 660           success = false;
 661         }
 662       else
 663         {
 664           /* We now determine the length of the ASN1 string. If it
 665            * differs from common_name's length, then there is a \0
 666            * before the string terminates.  This can be an instance of a
 667            * null-prefix attack.
 668            *
 669            * https://www.blackhat.com/html/bh-usa-09/bh-usa-09-archives.html#Marlinspike
 670            * */
 671
 672           int i = -1, j;
 673           X509_NAME_ENTRY *xentry;
 674           ASN1_STRING *sdata;
 675
 676           if (xname) {
 677             for (;;)
 678               {
 679                 j = X509_NAME_get_index_by_NID (xname, NID_commonName, i);
 680                 if (j == -1) break;
 681                 i = j;
 682               }
 683           }
 684
 685           xentry = X509_NAME_get_entry(xname,i);
 686           sdata = X509_NAME_ENTRY_get_data(xentry);
 687           if (strlen (common_name) != ASN1_STRING_length (sdata))
 688             {
 689               logprintf (LOG_NOTQUIET, _("\
 690     %s: certificate common name is invalid (contains a NUL character).\n\
 691     This may be an indication that the host is not who it claims to be\n\
 692     (that is, it is not the real %s).\n"),
 693                          severity, quote (host));
 694               success = false;
 695             }
 696         }
 697     }
 698
 699
 700   if (success)
 701     DEBUGP (("X509 certificate successfully verified and matches host %s\n",
 702              quotearg_style (escape_quoting_style, host)));
 703   X509_free (cert);
 704
 705  no_cert:
 706   if (opt.check_cert && !success)
 707     logprintf (LOG_NOTQUIET, _("\
 708 To connect to %s insecurely, use `--no-check-certificate'.\n"),
 709                quotearg_style (escape_quoting_style, host));
 710
 711   /* Allow --no-check-cert to disable certificate checking. */
 712   return opt.check_cert ? success : true;
 713 }
 714
 715 /*
 716  * vim: tabstop=2 shiftwidth=2 softtabstop=2
 717  */