static int verify_server_cert(SSL *ssl, const char *host)
{
X509 *cert;
X509_NAME *peer_name;
ASN1_STRING *str;
unsigned char *peer_cn = NULL;
int matched = -1, type = GEN_DNS;
GENERAL_NAMES *alts;
struct in6_addr addr6;
struct in_addr addr4;
void *addr;
int i = -1,j;
if (SSL_get_verify_result(ssl) != X509_V_OK) {
giterr_set(GITERR_SSL, "The SSL certificate is invalid");
return GIT_ECERTIFICATE;
}
/* Try to parse the host as an IP address to see if it is */
if (p_inet_pton(AF_INET, host, &addr4)) {
type = GEN_IPADD;
addr = &addr4;
} else {
if(p_inet_pton(AF_INET6, host, &addr6)) {
type = GEN_IPADD;
addr = &addr6;
}
}
cert = SSL_get_peer_certificate(ssl);
if (!cert) {
giterr_set(GITERR_SSL, "the server did not provide a certificate");
return -1;
}
/* Check the alternative names */
alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
if (alts) {
int num;
num = sk_GENERAL_NAME_num(alts);
for (i = 0; i < num && matched != 1; i++) {
const GENERAL_NAME *gn = sk_GENERAL_NAME_value(alts, i);
const char *name = (char *) ASN1_STRING_data(gn->d.ia5);
size_t namelen = (size_t) ASN1_STRING_length(gn->d.ia5);
/* Skip any names of a type we're not looking for */
if (gn->type != type)
continue;
if (type == GEN_DNS) {
/* If it contains embedded NULs, don't even try */
if (memchr(name, '\0', namelen))
continue;
if (check_host_name(name, host) < 0)
matched = 0;
else
matched = 1;
} else if (type == GEN_IPADD) {
/* Here name isn't so much a name but a binary representation of the IP */
matched = !!memcmp(name, addr, namelen);
}
}
}
GENERAL_NAMES_free(alts);
if (matched == 0)
goto cert_fail_name;
if (matched == 1)
return 0;
/* If no alternative names are available, check the common name */
peer_name = X509_get_subject_name(cert);
if (peer_name == NULL)
goto on_error;
if (peer_name) {
/* Get the index of the last CN entry */
while ((j = X509_NAME_get_index_by_NID(peer_name, NID_commonName, i)) >= 0)
i = j;
}
if (i < 0)
goto on_error;
str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(peer_name, i));
if (str == NULL)
goto on_error;
/* Work around a bug in OpenSSL whereby ASN1_STRING_to_UTF8 fails if it's already in utf-8 */
if (ASN1_STRING_type(str) == V_ASN1_UTF8STRING) {
int size = ASN1_STRING_length(str);
if (size > 0) {
peer_cn = OPENSSL_malloc(size + 1);
GITERR_CHECK_ALLOC(peer_cn);
memcpy(peer_cn, ASN1_STRING_data(str), size);
peer_cn[size] = '\0';
} else {
goto cert_fail_name;
}
} else {
int size = ASN1_STRING_to_UTF8(&peer_cn, str);
GITERR_CHECK_ALLOC(peer_cn);
if (memchr(peer_cn, '\0', size))
goto cert_fail_name;
}
if (check_host_name((char *)peer_cn, host) < 0)
goto cert_fail_name;
OPENSSL_free(peer_cn);
return 0;
on_error:
OPENSSL_free(peer_cn);
return ssl_set_error(ssl, 0);
cert_fail_name:
OPENSSL_free(peer_cn);
giterr_set(GITERR_SSL, "hostname does not match certificate");
return GIT_ECERTIFICATE;
}
/*
* This function is based on verifyhost in libcurl - I hope that it is correct.
*/
static int verify_ssl_host_name(X509 *server_cert, unsigned char *host)
{
unsigned char ipv4_address[4];
#ifdef SUPPORT_IPV6
unsigned char ipv6_address[16];
#endif
unsigned char *address = NULL;
int address_len = 0;
int type = GEN_DNS;
STACK_OF(GENERAL_NAME) *altnames;
if (!numeric_ip_address(host, ipv4_address)) {
address = ipv4_address;
address_len = 4;
type = GEN_IPADD;
}
#ifdef SUPPORT_IPV6
if (!numeric_ipv6_address(host, ipv6_address, NULL)) {
address = ipv6_address;
address_len = 16;
type = GEN_IPADD;
}
#endif
#if 1
altnames = X509_get_ext_d2i(server_cert, NID_subject_alt_name, NULL, NULL);
if (altnames) {
int retval = 1;
int i;
int n_altnames = sk_GENERAL_NAME_num(altnames);
for (i = 0; i < n_altnames; i++) {
const GENERAL_NAME *altname = sk_GENERAL_NAME_value(altnames, i);
const unsigned char *altname_ptr;
int altname_len;
if (altname->type != type) {
if (altname->type == GEN_IPADD || altname->type == GEN_DNS || altname->type == GEN_URI)
retval = S_INVALID_CERTIFICATE;
continue;
}
altname_ptr = ASN1_STRING_data(altname->d.ia5);
altname_len = ASN1_STRING_length(altname->d.ia5);
if (type == GEN_IPADD) {
if (altname_len == address_len && !memcmp(altname_ptr, address, address_len)) {
retval = 0;
break;
}
} else {
if (altname_len == (int)strlen(cast_const_char altname_ptr) && !check_host_name(altname_ptr, host)) {
retval = 0;
break;
}
}
retval = S_INVALID_CERTIFICATE;
}
sk_GENERAL_NAME_free(altnames);
if (retval != 1)
return retval;
}
#endif
{
unsigned char *nulstr = cast_uchar "";
unsigned char *peer_CN = nulstr;
X509_NAME *name;
int j, i = -1;
retval = 1;
name = X509_get_subject_name(server_cert);
if (name)
while ((j = X509_NAME_get_index_by_NID(name, NID_commonName, i)) >= 0)
i = j;
if (i >= 0) {
ASN1_STRING *tmp = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, i));
if (tmp) {
if (ASN1_STRING_type(tmp) == V_ASN1_UTF8STRING) {
j = ASN1_STRING_length(tmp);
if (j >= 0) {
peer_CN = OPENSSL_malloc(j + 1);
if (peer_CN) {
memcpy(peer_CN, ASN1_STRING_data(tmp), j);
peer_CN[j] = '\0';
}
}
} else {
j = ASN1_STRING_to_UTF8(&peer_CN, tmp);
}
if (peer_CN && (int)strlen(cast_const_char peer_CN) != j) {
retval = S_INVALID_CERTIFICATE;
}
}
}
if (peer_CN && peer_CN != nulstr) {
if (retval == 1 && !check_host_name(peer_CN, host))
retval = 0;
OPENSSL_free(peer_CN);
}
if (retval != 1)
return retval;
}
return S_INVALID_CERTIFICATE;
}