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