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