/* This file contains both code from cURL and hostname
  * validation code from the ssl conservatory (in that order).
  *
  * The goal is that all this code won't be needed anymore once
  * everyone is running a recent OpenSSL/LibreSSL that has
  * X509_check_host(). Until that time, unfortunately, we need
  * these 400+ lines to do just that... -- Syzop, Sep/2017
  */
 
 // Get rid of OSX 10.7 and greater deprecation warnings.
 #if defined(__APPLE__) && defined(__clang__)
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 #include <openssl/x509v3.h>
 #include <openssl/ssl.h>
 #include <string.h>
 
 #include "openssl_hostname_validation.h"
 
 #define HOSTNAME_MAX_SIZE 255
 
 #if (OPENSSL_VERSION_NUMBER < 0x10100000L) || defined(LIBRESSL_VERSION_NUMBER)
 #define ASN1_STRING_get0_data ASN1_STRING_data
 #endif
 
 /***************************************************************************
  *                                  _   _ ____  _
  *  Project                     ___| | | |  _ \| |
  *                             / __| | | | |_) | |
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
  * Copyright (C) 1998 - 2012, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
  * are also available at http://curl.haxx.se/docs/copyright.html.
  *
  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  * copies of the Software, and permit persons to whom the Software is
  * furnished to do so, under the terms of the COPYING file.
  *
  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  * KIND, either express or implied.
  *
  ***************************************************************************/
 
 /* This file is an amalgamation of hostcheck.c and most of rawstr.c
    from cURL.  The contents of the COPYING file mentioned above are:
 
 COPYRIGHT AND PERMISSION NOTICE
 
 Copyright (c) 1996 - 2013, Daniel Stenberg, <daniel@haxx.se>.
 
 All rights reserved.
 
 Permission to use, copy, modify, and distribute this software for any purpose
 with or without fee is hereby granted, provided that the above copyright
 notice and this permission notice appear in all copies.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN
 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
 OR OTHER DEALINGS IN THE SOFTWARE.
 
 Except as contained in this notice, the name of a copyright holder shall not
 be used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization of the copyright holder.
 */
 
 /* Portable, consistent toupper (remember EBCDIC). Do not use toupper() because
    its behavior is altered by the current locale. */
 static char Curl_raw_toupper(char in)
 {
   switch (in) {
   case 'a':
     return 'A';
   case 'b':
     return 'B';
   case 'c':
     return 'C';
   case 'd':
     return 'D';
   case 'e':
     return 'E';
   case 'f':
     return 'F';
   case 'g':
     return 'G';
   case 'h':
     return 'H';
   case 'i':
     return 'I';
   case 'j':
     return 'J';
   case 'k':
     return 'K';
   case 'l':
     return 'L';
   case 'm':
     return 'M';
   case 'n':
     return 'N';
   case 'o':
     return 'O';
   case 'p':
     return 'P';
   case 'q':
     return 'Q';
   case 'r':
     return 'R';
   case 's':
     return 'S';
   case 't':
     return 'T';
   case 'u':
     return 'U';
   case 'v':
     return 'V';
   case 'w':
     return 'W';
   case 'x':
     return 'X';
   case 'y':
     return 'Y';
   case 'z':
     return 'Z';
   }
   return in;
 }
 
 /*
  * Curl_raw_equal() is for doing "raw" case insensitive strings. This is meant
  * to be locale independent and only compare strings we know are safe for
  * this.  See http://daniel.haxx.se/blog/2008/10/15/strcasecmp-in-turkish/ for
  * some further explanation to why this function is necessary.
  *
  * The function is capable of comparing a-z case insensitively even for
  * non-ascii.
  */
 
 static int Curl_raw_equal(const char *first, const char *second)
 {
   while(*first && *second) {
     if (Curl_raw_toupper(*first) != Curl_raw_toupper(*second))
       /* get out of the loop as soon as they don't match */
       break;
     first++;
     second++;
   }
   /* we do the comparison here (possibly again), just to make sure that if the
      loop above is skipped because one of the strings reached zero, we must not
      return this as a successful match */
   return (Curl_raw_toupper(*first) == Curl_raw_toupper(*second));
 }
 
 static int Curl_raw_nequal(const char *first, const char *second, size_t max)
 {
   while(*first && *second && max) {
     if (Curl_raw_toupper(*first) != Curl_raw_toupper(*second)) {
       break;
     }
     max--;
     first++;
     second++;
   }
   if (0 == max)
     return 1; /* they are equal this far */
 
   return Curl_raw_toupper(*first) == Curl_raw_toupper(*second);
 }
 
 /*
  * Match a hostname against a wildcard pattern.
  * E.g.
  *  "foo.host.com" matches "*.host.com".
  *
  * We use the matching rule described in RFC6125, section 6.4.3.
  * http://tools.ietf.org/html/rfc6125#section-6.4.3
  */
 
 static int hostmatch(const char *hostname, const char *pattern)
 {
   const char *pattern_label_end, *pattern_wildcard, *hostname_label_end;
   int wildcard_enabled;
   size_t prefixlen, suffixlen;
   pattern_wildcard = strchr(pattern, '*');
   if (pattern_wildcard == NULL)
     return Curl_raw_equal(pattern, hostname) ?
       CURL_HOST_MATCH : CURL_HOST_NOMATCH;
 
   /* We require at least 2 dots in pattern to avoid too wide wildcard
      match. */
   wildcard_enabled = 1;
   pattern_label_end = strchr(pattern, '.');
   if (pattern_label_end == NULL || strchr(pattern_label_end+1, '.') == NULL ||
      pattern_wildcard > pattern_label_end ||
      Curl_raw_nequal(pattern, "xn--", 4)) {
     wildcard_enabled = 0;
   }
   if (!wildcard_enabled)
     return Curl_raw_equal(pattern, hostname) ?
       CURL_HOST_MATCH : CURL_HOST_NOMATCH;
 
   hostname_label_end = strchr(hostname, '.');
   if (hostname_label_end == NULL ||
      !Curl_raw_equal(pattern_label_end, hostname_label_end))
     return CURL_HOST_NOMATCH;
 
   /* The wildcard must match at least one character, so the left-most
      label of the hostname is at least as large as the left-most label
      of the pattern. */
   if (hostname_label_end - hostname < pattern_label_end - pattern)
     return CURL_HOST_NOMATCH;
 
   prefixlen = pattern_wildcard - pattern;
   suffixlen = pattern_label_end - (pattern_wildcard+1);
   return Curl_raw_nequal(pattern, hostname, prefixlen) &&
     Curl_raw_nequal(pattern_wildcard+1, hostname_label_end - suffixlen,
                     suffixlen) ?
     CURL_HOST_MATCH : CURL_HOST_NOMATCH;
 }
 
 int Curl_cert_hostcheck(const char *match_pattern, const char *hostname)
 {
   if (!match_pattern || !*match_pattern ||
       !hostname || !*hostname) /* sanity check */
     return 0;
 
   if (Curl_raw_equal(hostname, match_pattern)) /* trivial case */
     return 1;
 
   if (hostmatch(hostname,match_pattern) == CURL_HOST_MATCH)
     return 1;
   return 0;
 }
 /* End of cURL related functions */
 
 /* Start of host validation code */
 /* Obtained from: https://github.com/iSECPartners/ssl-conservatory */
 
 /*
 Copyright (C) 2012, iSEC Partners.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
 the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 of the Software, and to permit persons to whom the Software is furnished to do
 so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
 /*
  * Helper functions to perform basic hostname validation using OpenSSL.
  *
  * Please read "everything-you-wanted-to-know-about-openssl.pdf" before
  * attempting to use this code. This whitepaper describes how the code works,
  * how it should be used, and what its limitations are.
  *
  * Author:  Alban Diquet
  * License: See LICENSE
  *
  */
 
 /**
 * Tries to find a match for hostname in the certificate's Common Name field.
 *
 * Returns MatchFound if a match was found.
 * Returns MatchNotFound if no matches were found.
 * Returns MalformedCertificate if the Common Name had a NUL character embedded in it.
 * Returns Error if the Common Name could not be extracted.
 */
 static HostnameValidationResult matches_common_name(const char *hostname, const X509 *server_cert) {
         int common_name_loc = -1;
         X509_NAME_ENTRY *common_name_entry = NULL;
         ASN1_STRING *common_name_asn1 = NULL;
         const char *common_name_str = NULL;
 
         // Find the position of the CN field in the Subject field of the certificate
         common_name_loc = X509_NAME_get_index_by_NID(X509_get_subject_name((X509 *) server_cert), NID_commonName, -1);
         if (common_name_loc < 0) {
                 return Error;
         }
 
         // Extract the CN field
         common_name_entry = X509_NAME_get_entry(X509_get_subject_name((X509 *) server_cert), common_name_loc);
         if (common_name_entry == NULL) {
                 return Error;
         }
 
         // Convert the CN field to a C string
         common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry);
         if (common_name_asn1 == NULL) {
                 return Error;
         }
         common_name_str = (char *) ASN1_STRING_get0_data(common_name_asn1);
 
         // Make sure there isn't an embedded NUL character in the CN
         if ((size_t)ASN1_STRING_length(common_name_asn1) != strlen(common_name_str)) {
                 return MalformedCertificate;
         }
 
         // Compare expected hostname with the CN
         if (Curl_cert_hostcheck(common_name_str, hostname) == CURL_HOST_MATCH) {
                 return MatchFound;
         }
         else {
                 return MatchNotFound;
         }
 }
 
 
 /**
 * Tries to find a match for hostname in the certificate's Subject Alternative Name extension.
 *
 * Returns MatchFound if a match was found.
 * Returns MatchNotFound if no matches were found.
 * Returns MalformedCertificate if any of the hostnames had a NUL character embedded in it.
 * Returns NoSANPresent if the SAN extension was not present in the certificate.
 */
 static HostnameValidationResult matches_subject_alternative_name(const char *hostname, const X509 *server_cert) {
         HostnameValidationResult result = MatchNotFound;
         int i;
         int san_names_nb = -1;
         STACK_OF(GENERAL_NAME) *san_names = NULL;
 
         // Try to extract the names within the SAN extension from the certificate
         san_names = X509_get_ext_d2i((X509 *) server_cert, NID_subject_alt_name, NULL, NULL);
         if (san_names == NULL) {
                 return NoSANPresent;
         }
         san_names_nb = sk_GENERAL_NAME_num(san_names);
 
         // Check each name within the extension
         for (i=0; i<san_names_nb; i++) {
                 const GENERAL_NAME *current_name = sk_GENERAL_NAME_value(san_names, i);
 
                 if (current_name->type == GEN_DNS) {
                         // Current name is a DNS name, let's check it
                         const char *dns_name = (char *) ASN1_STRING_get0_data(current_name->d.dNSName);
 
                         // Make sure there isn't an embedded NUL character in the DNS name
                         if ((size_t)ASN1_STRING_length(current_name->d.dNSName) != strlen(dns_name)) {
                                 result = MalformedCertificate;
                                 break;
                         }
                         else { // Compare expected hostname with the DNS name
                                 if (Curl_cert_hostcheck(dns_name, hostname)
                                     == CURL_HOST_MATCH) {
                                         result = MatchFound;
                                         break;
                                 }
                         }
                 }
         }
         sk_GENERAL_NAME_pop_free(san_names, GENERAL_NAME_free);
 
         return result;
 }
 
 
 /**
 * Validates the server's identity by looking for the expected hostname in the
 * server's certificate. As described in RFC 6125, it first tries to find a match
 * in the Subject Alternative Name extension. If the extension is not present in
 * the certificate, it checks the Common Name instead.
 *
 * Returns MatchFound if a match was found.
 * Returns MatchNotFound if no matches were found.
 * Returns MalformedCertificate if any of the hostnames had a NUL character embedded in it.
 * Returns Error if there was an error.
 */
 HostnameValidationResult validate_hostname(const char *hostname, const X509 *server_cert) {
         HostnameValidationResult result;
 
         if ((hostname == NULL) || (server_cert == NULL))
                 return Error;
 
         // First try the Subject Alternative Names extension
         result = matches_subject_alternative_name(hostname, server_cert);
         if (result == NoSANPresent) {
                 // Extension was not found: try the Common Name
                 result = matches_common_name(hostname, server_cert);
         }
 
         return result;
 }

© 2023 acidvegas, inc • generated with stagit