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