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