/usr/src/sbin/isakmpd/x509.c

Bug Summary

File:	src/sbin/isakmpd/x509.c
Warning:	line 534, column 35 Array access results in a null pointer dereference
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name x509.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/isakmpd/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sbin/isakmpd -I . -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/isakmpd/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/sbin/isakmpd/x509.c
1/* $OpenBSD: x509.c,v 1.125 2022/01/16 14:30:11 naddy Exp $	 */
2/* $EOM: x509.c,v 1.54 2001/01/16 18:42:16 ho Exp $	 */

4/*
* Copyright (c) 1998, 1999 Niels Provos.  All rights reserved.
* Copyright (c) 1999, 2000, 2001 Niklas Hallqvist.  All rights reserved.
* Copyright (c) 1999, 2000, 2001 Angelos D. Keromytis.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

30/*
* This code was written under funding by Ericsson Radio Systems.
*/

34#include <sys/types.h>
35#include <sys/stat.h>
36#include <dirent.h>
37#include <errno(*__errno()).h>
38#include <fcntl.h>
39#include <stdio.h>
40#include <stdlib.h>
41#include <string.h>
42#include <unistd.h>
43#include <limits.h>

45#include <regex.h>
46#include <keynote.h>

48#include "cert.h"
49#include "conf.h"
50#include "exchange.h"
51#include "hash.h"
52#include "ike_auth.h"
53#include "ipsec.h"
54#include "log.h"
55#include "dh.h"
56#include "monitor.h"
57#include "policy.h"
58#include "sa.h"
59#include "util.h"
60#include "x509.h"

62static u_int16_t x509_hash(u_int8_t *, size_t);
63static void	 x509_hash_init(void);
64static X509	*x509_hash_find(u_int8_t *, size_t);
65static int	 x509_hash_enter(X509 *);

67/*
* X509_STOREs do not support subjectAltNames, so we have to build
* our own hash table.
*/

72/*
* XXX Actually this store is not really useful, we never use it as we have
* our own hash table.  It also gets collisions if we have several certificates
* only differing in subjectAltName.
*/
77static X509_STORE *x509_certs = 0;
78static X509_STORE *x509_cas = 0;

80static int n_x509_cas = 0;

82/* Initial number of bits used as hash.  */
83#define INITIAL_BUCKET_BITS6 6

85struct x509_hash {
LIST_ENTRY(x509_hash)struct { struct x509_hash *le_next; struct x509_hash **le_prev
; } link;

X509		*cert;
89};

91static LIST_HEAD(x509_list, x509_hash)struct x509_list { struct x509_hash *lh_first; } *x509_tab = 0;

93/* Works both as a maximum index and a mask.  */
94static int	bucket_mask;

96/*
* Given an X509 certificate, create a KeyNote assertion where
* Issuer/Subject -> Authorizer/Licensees.
* XXX RSA-specific.
*/
101int
102x509_generate_kn(int id, X509 *cert)
103{
static const char fmt[] = "Authorizer: \"rsa-hex:%s\"\nLicensees: \"rsa-hex:%s"
    "\"\nConditions: %s >= \"%s\" && %s <= \"%s\";\n";
char	*ikey = NULL((void *)0), *skey = NULL((void *)0), *buf = NULL((void *)0);
char	isname[256], subname[256];
static const char fmt2[] = "Authorizer: \"DN:%s\"\nLicensees: \"DN:%s\"\n"
    "Conditions: %s >= \"%s\" && %s <= \"%s\";\n";
X509_NAME *issuer, *subject;
struct keynote_deckey dc;
X509_STORE_CTX *csc = NULL((void *)0);
X509_OBJECT *obj = NULL((void *)0);
X509	*icert;
RSA	*key = NULL((void *)0);
time_t	tt;
char	before[15], after[15], *timecomp, *timecomp2;
ASN1_TIME *tm;
int	i;

LOG_DBG((LOG_POLICY, 90,log_debug (LOG_POLICY, 90, "x509_generate_kn: generating KeyNote policy for certificate %p"
, cert)
   "x509_generate_kn: generating KeyNote policy for certificate %p",log_debug (LOG_POLICY, 90, "x509_generate_kn: generating KeyNote policy for certificate %p"
, cert)
   cert))log_debug (LOG_POLICY, 90, "x509_generate_kn: generating KeyNote policy for certificate %p"
, cert);

issuer = X509_get_issuer_name(cert);
subject = X509_get_subject_name(cert);

/* Missing or self-signed, ignore cert but don't report failure.  */
if (!issuer || !subject || !X509_NAME_cmp(issuer, subject))
return 1;

if (!x509_cert_get_key(cert, &key)) {
LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to get public key from cert"
)
    "x509_generate_kn: failed to get public key from cert"))log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to get public key from cert"
);
return 0;
}
dc.dec_algorithm = KEYNOTE_ALGORITHM_RSA6;
dc.dec_key = key;
ikey = kn_encode_key(&dc, INTERNAL_ENC_PKCS11, ENCODING_HEX1,
   KEYNOTE_PUBLIC_KEY0);
if (keynote_errno == ERROR_MEMORY-1) {
log_print("x509_generate_kn: failed to get memory for "
    "public key");
LOG_DBG((LOG_POLICY, 30, "x509_generate_kn: cannot get "log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get " "subject key"
)
    "subject key"))log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get " "subject key"
);
goto fail;
}
if (!ikey) {
LOG_DBG((LOG_POLICY, 30, "x509_generate_kn: cannot get "log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get " "subject key"
)
    "subject key"))log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get " "subject key"
);
goto fail;
}

RSA_free(key);
key = NULL((void *)0);

csc = X509_STORE_CTX_new();
if (csc == NULL((void *)0)) {
log_print("x509_generate_kn: failed to get memory for "
    "certificate store");
goto fail;
}
obj = X509_OBJECT_new();
if (obj == NULL((void *)0)) {
log_print("x509_generate_kn: failed to get memory for "
    "certificate object");
goto fail;
}

/* Now find issuer's certificate so we can get the public key.  */
X509_STORE_CTX_init(csc, x509_cas, cert, NULL((void *)0));
if (X509_STORE_get_by_subjectX509_STORE_CTX_get_by_subject(csc, X509_LU_X509, issuer, obj) !=
   X509_LU_X509) {
X509_STORE_CTX_cleanup(csc);
X509_STORE_CTX_init(csc, x509_certs, cert, NULL((void *)0));
if (X509_STORE_get_by_subjectX509_STORE_CTX_get_by_subject(csc, X509_LU_X509, issuer, obj)
    != X509_LU_X509) {
	X509_STORE_CTX_cleanup(csc);
	LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: no certificate found for "
 "issuer")
	    "x509_generate_kn: no certificate found for "log_debug (LOG_POLICY, 30, "x509_generate_kn: no certificate found for "
 "issuer")
	    "issuer"))log_debug (LOG_POLICY, 30, "x509_generate_kn: no certificate found for "
 "issuer");
	goto fail;
}
}
X509_STORE_CTX_free(csc);
csc = NULL((void *)0);

icert = X509_OBJECT_get0_X509(obj);
if (icert == NULL((void *)0)) {
LOG_DBG((LOG_POLICY, 30, "x509_generate_kn: "log_debug (LOG_POLICY, 30, "x509_generate_kn: " "missing certificates, cannot construct X509 chain"
)
    "missing certificates, cannot construct X509 chain"))log_debug (LOG_POLICY, 30, "x509_generate_kn: " "missing certificates, cannot construct X509 chain"
);
goto fail;
}
if (!x509_cert_get_key(icert, &key)) {
LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to get public key from cert"
)
    "x509_generate_kn: failed to get public key from cert"))log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to get public key from cert"
);
goto fail;
}
X509_OBJECT_free(obj);
obj = NULL((void *)0);

dc.dec_algorithm = KEYNOTE_ALGORITHM_RSA6;
dc.dec_key = key;
skey = kn_encode_key(&dc, INTERNAL_ENC_PKCS11, ENCODING_HEX1,
   KEYNOTE_PUBLIC_KEY0);
if (keynote_errno == ERROR_MEMORY-1) {
log_error("x509_generate_kn: failed to get memory for public "
    "key");
LOG_DBG((LOG_POLICY, 30, "x509_generate_kn: cannot get issuer "log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get issuer "
 "key")
    "key"))log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get issuer "
 "key");
goto fail;
}
if (!skey) {
LOG_DBG((LOG_POLICY, 30, "x509_generate_kn: cannot get issuer "log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get issuer "
 "key")
    "key"))log_debug (LOG_POLICY, 30, "x509_generate_kn: cannot get issuer "
 "key");
goto fail;
}

RSA_free(key);
key = NULL((void *)0);

if (((tm = X509_get_notBeforeX509_getm_notBefore(cert)) == NULL((void *)0)) ||
   (tm->type != V_ASN1_UTCTIME23 &&
tm->type != V_ASN1_GENERALIZEDTIME24)) {
tt = time(0);
strftime(before, 14, "%Y%m%d%H%M%S", localtime(&tt));
timecomp = "LocalTimeOfDay";
} else {
if (tm->data[tm->length - 1] == 'Z') {
	timecomp = "GMTTimeOfDay";
	i = tm->length - 2;
} else {
	timecomp = "LocalTimeOfDay";
	i = tm->length - 1;
}

for (; i >= 0; i--) {
	if (tm->data[i] < '0' || tm->data[i] > '9') {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid data in "
 "NotValidBefore time field")
		    "x509_generate_kn: invalid data in "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid data in "
 "NotValidBefore time field")
		    "NotValidBefore time field"))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid data in "
 "NotValidBefore time field");
		goto fail;
	}
}

if (tm->type == V_ASN1_UTCTIME23) {
	if ((tm->length < 10) || (tm->length > 13)) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length "
 "of NotValidBefore time field (%d)", tm->length)
		    "x509_generate_kn: invalid length "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length "
 "of NotValidBefore time field (%d)", tm->length)
		    "of NotValidBefore time field (%d)",log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length "
 "of NotValidBefore time field (%d)", tm->length)
		    tm->length))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length "
 "of NotValidBefore time field (%d)", tm->length);
		goto fail;
	}
	/* Validity checks.  */
	if ((tm->data[2] != '0' && tm->data[2] != '1') ||
	    (tm->data[2] == '0' && tm->data[3] == '0') ||
	    (tm->data[2] == '1' && tm->data[3] > '2') ||
	    (tm->data[4] > '3') ||
	    (tm->data[4] == '0' && tm->data[5] == '0') ||
	    (tm->data[4] == '3' && tm->data[5] > '1') ||
	    (tm->data[6] > '2') ||
	    (tm->data[6] == '2' && tm->data[7] > '3') ||
	    (tm->data[8] > '5')) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidBefore time field")
		    "x509_generate_kn: invalid value in "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidBefore time field")
		    "NotValidBefore time field"))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidBefore time field");
		goto fail;
	}
	/* Stupid UTC tricks.  */
	if (tm->data[0] < '5')
		snprintf(before, sizeof before, "20%s",
		    tm->data);
	else
		snprintf(before, sizeof before, "19%s",
		    tm->data);
} else {	/* V_ASN1_GENERICTIME */
	if ((tm->length < 12) || (tm->length > 15)) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidBefore time field (%d)", tm->length)
		    "x509_generate_kn: invalid length of "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidBefore time field (%d)", tm->length)
		    "NotValidBefore time field (%d)",log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidBefore time field (%d)", tm->length)
		    tm->length))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidBefore time field (%d)", tm->length);
		goto fail;
	}
	/* Validity checks.  */
	if ((tm->data[4] != '0' && tm->data[4] != '1') ||
	    (tm->data[4] == '0' && tm->data[5] == '0') ||
	    (tm->data[4] == '1' && tm->data[5] > '2') ||
	    (tm->data[6] > '3') ||
	    (tm->data[6] == '0' && tm->data[7] == '0') ||
	    (tm->data[6] == '3' && tm->data[7] > '1') ||
	    (tm->data[8] > '2') ||
	    (tm->data[8] == '2' && tm->data[9] > '3') ||
	    (tm->data[10] > '5')) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidBefore time field")
		    "x509_generate_kn: invalid value in "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidBefore time field")
		    "NotValidBefore time field"))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidBefore time field");
		goto fail;
	}
	snprintf(before, sizeof before, "%s", tm->data);
}

/* Fix missing seconds.  */
if (tm->length < 12) {
	before[12] = '0';
	before[13] = '0';
}
/* This will overwrite trailing 'Z'.  */
before[14] = '\0';
}

tm = X509_get_notAfterX509_getm_notAfter(cert);
if (tm == NULL((void *)0) ||
   (tm->type != V_ASN1_UTCTIME23 &&
tm->type != V_ASN1_GENERALIZEDTIME24)) {
tt = time(0);
strftime(after, 14, "%Y%m%d%H%M%S", localtime(&tt));
timecomp2 = "LocalTimeOfDay";
} else {
if (tm->data[tm->length - 1] == 'Z') {
	timecomp2 = "GMTTimeOfDay";
	i = tm->length - 2;
} else {
	timecomp2 = "LocalTimeOfDay";
	i = tm->length - 1;
}

for (; i >= 0; i--) {
	if (tm->data[i] < '0' || tm->data[i] > '9') {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid data in "
 "NotValidAfter time field")
		    "x509_generate_kn: invalid data in "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid data in "
 "NotValidAfter time field")
		    "NotValidAfter time field"))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid data in "
 "NotValidAfter time field");
		goto fail;
	}
}

if (tm->type == V_ASN1_UTCTIME23) {
	if ((tm->length < 10) || (tm->length > 13)) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length)
		    "x509_generate_kn: invalid length of "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length)
		    "NotValidAfter time field (%d)",log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length)
		    tm->length))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length);
		goto fail;
	}
	/* Validity checks. */
	if ((tm->data[2] != '0' && tm->data[2] != '1') ||
	    (tm->data[2] == '0' && tm->data[3] == '0') ||
	    (tm->data[2] == '1' && tm->data[3] > '2') ||
	    (tm->data[4] > '3') ||
	    (tm->data[4] == '0' && tm->data[5] == '0') ||
	    (tm->data[4] == '3' && tm->data[5] > '1') ||
	    (tm->data[6] > '2') ||
	    (tm->data[6] == '2' && tm->data[7] > '3') ||
	    (tm->data[8] > '5')) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidAfter time field")
		    "x509_generate_kn: invalid value in "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidAfter time field")
		    "NotValidAfter time field"))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidAfter time field");
		goto fail;
	}
	/* Stupid UTC tricks.  */
	if (tm->data[0] < '5')
		snprintf(after, sizeof after, "20%s",
		    tm->data);
	else
		snprintf(after, sizeof after, "19%s",
		    tm->data);
} else {	/* V_ASN1_GENERICTIME */
	if ((tm->length < 12) || (tm->length > 15)) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length)
		    "x509_generate_kn: invalid length of "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length)
		    "NotValidAfter time field (%d)",log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length)
		    tm->length))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid length of "
 "NotValidAfter time field (%d)", tm->length);
		goto fail;
	}
	/* Validity checks.  */
	if ((tm->data[4] != '0' && tm->data[4] != '1') ||
	    (tm->data[4] == '0' && tm->data[5] == '0') ||
	    (tm->data[4] == '1' && tm->data[5] > '2') ||
	    (tm->data[6] > '3') ||
	    (tm->data[6] == '0' && tm->data[7] == '0') ||
	    (tm->data[6] == '3' && tm->data[7] > '1') ||
	    (tm->data[8] > '2') ||
	    (tm->data[8] == '2' && tm->data[9] > '3') ||
	    (tm->data[10] > '5')) {
		LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidAfter time field")
		    "x509_generate_kn: invalid value in "log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidAfter time field")
		    "NotValidAfter time field"))log_debug (LOG_POLICY, 30, "x509_generate_kn: invalid value in "
 "NotValidAfter time field");
		goto fail;
	}
	snprintf(after, sizeof after, "%s", tm->data);
}

/* Fix missing seconds.  */
if (tm->length < 12) {
	after[12] = '0';
	after[13] = '0';
}
after[14] = '\0';	/* This will overwrite trailing 'Z' */
}

if (asprintf(&buf, fmt, skey, ikey, timecomp, before, timecomp2,
   after) == -1) {
log_error("x509_generate_kn: "
    "failed to allocate memory for KeyNote credential");
goto fail;
}

free(ikey);
ikey = NULL((void *)0);
free(skey);
skey = NULL((void *)0);

if (kn_add_assertion(id, buf, strlen(buf), ASSERT_FLAG_LOCAL0x0001) == -1) {
LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to add new KeyNote credential"
)
    "x509_generate_kn: failed to add new KeyNote credential"))log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to add new KeyNote credential"
);
goto fail;
}
/* We could print the assertion here, but log_print() truncates...  */
LOG_DBG((LOG_POLICY, 60, "x509_generate_kn: added credential"))log_debug (LOG_POLICY, 60, "x509_generate_kn: added credential"
);

free(buf);
buf = NULL((void *)0);

if (!X509_NAME_oneline(issuer, isname, 256)) {
LOG_DBG((LOG_POLICY, 50,log_debug (LOG_POLICY, 50, "x509_generate_kn: " "X509_NAME_oneline (issuer, ...) failed"
)
    "x509_generate_kn: "log_debug (LOG_POLICY, 50, "x509_generate_kn: " "X509_NAME_oneline (issuer, ...) failed"
)
    "X509_NAME_oneline (issuer, ...) failed"))log_debug (LOG_POLICY, 50, "x509_generate_kn: " "X509_NAME_oneline (issuer, ...) failed"
);
goto fail;
}
if (!X509_NAME_oneline(subject, subname, 256)) {
LOG_DBG((LOG_POLICY, 50,log_debug (LOG_POLICY, 50, "x509_generate_kn: " "X509_NAME_oneline (subject, ...) failed"
)
    "x509_generate_kn: "log_debug (LOG_POLICY, 50, "x509_generate_kn: " "X509_NAME_oneline (subject, ...) failed"
)
    "X509_NAME_oneline (subject, ...) failed"))log_debug (LOG_POLICY, 50, "x509_generate_kn: " "X509_NAME_oneline (subject, ...) failed"
);
goto fail;
}
if (asprintf(&buf, fmt2, isname, subname, timecomp, before,
   timecomp2, after) == -1) {
log_error("x509_generate_kn: malloc failed");
return 0;
}

if (kn_add_assertion(id, buf, strlen(buf), ASSERT_FLAG_LOCAL0x0001) == -1) {
LOG_DBG((LOG_POLICY, 30,log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to add new KeyNote credential"
)
    "x509_generate_kn: failed to add new KeyNote credential"))log_debug (LOG_POLICY, 30, "x509_generate_kn: failed to add new KeyNote credential"
);
goto fail;
}
LOG_DBG((LOG_POLICY, 80, "x509_generate_kn: added credential:\n%s",log_debug (LOG_POLICY, 80, "x509_generate_kn: added credential:\n%s"
, buf)
   buf))log_debug (LOG_POLICY, 80, "x509_generate_kn: added credential:\n%s"
, buf);

free(buf);
return 1;

452fail:
X509_STORE_CTX_free(csc);
X509_OBJECT_free(obj);
free(buf);
free(skey);
free(ikey);
if (key)
RSA_free(key);

return 0;
462}

464static u_int16_t
465x509_hash(u_int8_t *id, size_t len)
466{
u_int16_t bucket = 0;
size_t	i;

/* XXX We might resize if we are crossing a certain threshold.  */
for (i = 4; i < (len & ~1); i += 2) {
/* Doing it this way avoids alignment problems.  */
bucket ^= (id[i] + 1) * (id[i + 1] + 257);
}
/* Hash in the last character of odd length IDs too.  */
if (i < len)
bucket ^= (id[i] + 1) * (id[i] + 257);

bucket &= bucket_mask;
return bucket;
481}

483static void
484x509_hash_init(void)
485{
struct x509_hash *certh;
int	i;

bucket_mask = (1 << INITIAL_BUCKET_BITS6) - 1;

/* If reinitializing, free existing entries.  */
if (x509_tab) {
for (i = 0; i <= bucket_mask; i++)
	for (certh = LIST_FIRST(&x509_tab[i])((&x509_tab[i])->lh_first); certh;
	    certh = LIST_FIRST(&x509_tab[i])((&x509_tab[i])->lh_first)) {
		LIST_REMOVE(certh, link)do { if ((certh)->link.le_next != ((void *)0)) (certh)->
link.le_next->link.le_prev = (certh)->link.le_prev; *(certh
)->link.le_prev = (certh)->link.le_next; ; ; } while (0
);
		free(certh);
	}
free(x509_tab);
}
x509_tab = calloc(bucket_mask + 1, sizeof(struct x509_list));
if (!x509_tab)
log_fatal("x509_hash_init: malloc (%lu) failed",
    (bucket_mask + 1) *
    (unsigned long)sizeof(struct x509_list));
for (i = 0; i <= bucket_mask; i++) {
LIST_INIT(&x509_tab[i])do { ((&x509_tab[i])->lh_first) = ((void *)0); } while
 (0);
}
509}

511/* Lookup a certificate by an ID blob.  */
512static X509 *
513x509_hash_find(u_int8_t *id, size_t len)
514{
struct x509_hash *cert;
u_int8_t	**cid;
u_int32_t	*clen;
int	n, i, id_found;

for (cert = LIST_FIRST(&x509_tab[x509_hash(id, len)])((&x509_tab[x509_hash(id, len)])->lh_first); cert;
6
←
Loop condition is true.  Entering loop body→
   cert = LIST_NEXT(cert, link)((cert)->link.le_next)) {
if (!x509_cert_get_subjects(cert->cert, &n, &cid, &clen))
7
←
Calling 'x509_cert_get_subjects'→
21
←
Returning from 'x509_cert_get_subjects'→
22
←
Taking false branch→
	continue;

id_found = 0;
for (i = 0; i < n; i++) {
23
←
Loop condition is true.  Entering loop body→
25
←
The value 1 is assigned to 'i'→
26
←
Loop condition is true.  Entering loop body→
	LOG_DBG_BUF((LOG_CRYPTO, 70, "cert_cmp", id, len))log_debug_buf (LOG_CRYPTO, 70, "cert_cmp", id, len);
	LOG_DBG_BUF((LOG_CRYPTO, 70, "cert_cmp", cid[i],log_debug_buf (LOG_CRYPTO, 70, "cert_cmp", cid[i], clen[i])
	    clen[i]))log_debug_buf (LOG_CRYPTO, 70, "cert_cmp", cid[i], clen[i]);
	/*
	 * XXX This identity predicate needs to be
	 * understood.
	 */
	if (clen[i] == len && id[0] == cid[i][0] &&
24
←
Assuming the condition is false→
27
←
Assuming the condition is true→
28
←
Array access results in a null pointer dereference
	    memcmp(id + 4, cid[i] + 4, len - 4) == 0) {
		id_found++;
		break;
	}
}
cert_free_subjects(n, cid, clen);
if (!id_found)
	continue;

LOG_DBG((LOG_CRYPTO, 70, "x509_hash_find: return X509 %p",log_debug (LOG_CRYPTO, 70, "x509_hash_find: return X509 %p", cert
->cert)
    cert->cert))log_debug (LOG_CRYPTO, 70, "x509_hash_find: return X509 %p", cert
->cert);
return cert->cert;
}

LOG_DBG((LOG_CRYPTO, 70,log_debug (LOG_CRYPTO, 70, "x509_hash_find: no certificate matched query"
)
   "x509_hash_find: no certificate matched query"))log_debug (LOG_CRYPTO, 70, "x509_hash_find: no certificate matched query"
);
return 0;
552}

554static int
555x509_hash_enter(X509 *cert)
556{
u_int16_t	bucket = 0;
u_int8_t	**id;
u_int32_t	*len;
struct x509_hash *certh;
int	n, i;

if (!x509_cert_get_subjects(cert, &n, &id, &len)) {
log_print("x509_hash_enter: cannot retrieve subjects");
return 0;
}
for (i = 0; i < n; i++) {
certh = calloc(1, sizeof *certh);
if (!certh) {
	cert_free_subjects(n, id, len);
	log_error("x509_hash_enter: calloc (1, %lu) failed",
	    (unsigned long)sizeof *certh);
	return 0;
}
certh->cert = cert;

bucket = x509_hash(id[i], len[i]);

LIST_INSERT_HEAD(&x509_tab[bucket], certh, link)do { if (((certh)->link.le_next = (&x509_tab[bucket])->
lh_first) != ((void *)0)) (&x509_tab[bucket])->lh_first
->link.le_prev = &(certh)->link.le_next; (&x509_tab
[bucket])->lh_first = (certh); (certh)->link.le_prev = &
(&x509_tab[bucket])->lh_first; } while (0);
LOG_DBG((LOG_CRYPTO, 70,log_debug (LOG_CRYPTO, 70, "x509_hash_enter: cert %p added to bucket %d"
, cert, bucket)
    "x509_hash_enter: cert %p added to bucket %d",log_debug (LOG_CRYPTO, 70, "x509_hash_enter: cert %p added to bucket %d"
, cert, bucket)
    cert, bucket))log_debug (LOG_CRYPTO, 70, "x509_hash_enter: cert %p added to bucket %d"
, cert, bucket);
}
cert_free_subjects(n, id, len);

return 1;
587}

589/* X509 Certificate Handling functions.  */

591int
592x509_read_from_dir(X509_STORE *ctx, char *name, int hash, int *pcount)
593{
FILE		*certfp;
X509		*cert;
struct stat	sb;
char		fullname[PATH_MAX1024];
char		file[PATH_MAX1024];
int		fd;

if (strlen(name) >= sizeof fullname - 1) {
log_print("x509_read_from_dir: directory name too long");
return 0;
}
LOG_DBG((LOG_CRYPTO, 40, "x509_read_from_dir: reading certs from %s",log_debug (LOG_CRYPTO, 40, "x509_read_from_dir: reading certs from %s"
, name)
   name))log_debug (LOG_CRYPTO, 40, "x509_read_from_dir: reading certs from %s"
, name);

if (monitor_req_readdir(name) == -1) {
LOG_DBG((LOG_CRYPTO, 10,log_debug (LOG_CRYPTO, 10, "x509_read_from_dir: opendir (\"%s\") failed: %s"
, name, strerror((*__errno())))
    "x509_read_from_dir: opendir (\"%s\") failed: %s",log_debug (LOG_CRYPTO, 10, "x509_read_from_dir: opendir (\"%s\") failed: %s"
, name, strerror((*__errno())))
    name, strerror(errno)))log_debug (LOG_CRYPTO, 10, "x509_read_from_dir: opendir (\"%s\") failed: %s"
, name, strerror((*__errno())));
return 0;
}

while ((fd = monitor_readdir(file, sizeof file)) != -1) {
LOG_DBG((LOG_CRYPTO, 60,log_debug (LOG_CRYPTO, 60, "x509_read_from_dir: reading certificate %s"
, file)
    "x509_read_from_dir: reading certificate %s",log_debug (LOG_CRYPTO, 60, "x509_read_from_dir: reading certificate %s"
, file)
    file))log_debug (LOG_CRYPTO, 60, "x509_read_from_dir: reading certificate %s"
, file);

if (fstat(fd, &sb) == -1) {
	log_error("x509_read_from_dir: fstat failed");
	close(fd);
	continue;
}

if (!S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000)) {
	close(fd);
	continue;
}

if ((certfp = fdopen(fd, "r")) == NULL((void *)0)) {
	log_error("x509_read_from_dir: fdopen failed");
	close(fd);
	continue;
}

637#if SSLEAY_VERSION_NUMBER0x20000000L >= 0x00904100L
cert = PEM_read_X509(certfp, NULL((void *)0), NULL((void *)0), NULL((void *)0));
639#else
cert = PEM_read_X509(certfp, NULL((void *)0), NULL((void *)0));
641#endif
fclose(certfp);

if (cert == NULL((void *)0)) {
	log_print("x509_read_from_dir: PEM_read_X509 "
	    "failed for %s", file);
	continue;
}

if (pcount != NULL((void *)0))
	(*pcount)++;

if (!X509_STORE_add_cert(ctx, cert)) {
	/*
	 * This is actually expected if we have several
	 * certificates only differing in subjectAltName,
	 * which is not an something that is strange.
	 * Consider multi-homed machines.
	*/
	LOG_DBG((LOG_CRYPTO, 50,log_debug (LOG_CRYPTO, 50, "x509_read_from_dir: X509_STORE_add_cert failed "
 "for %s", file)
	    "x509_read_from_dir: X509_STORE_add_cert failed "log_debug (LOG_CRYPTO, 50, "x509_read_from_dir: X509_STORE_add_cert failed "
 "for %s", file)
	    "for %s", file))log_debug (LOG_CRYPTO, 50, "x509_read_from_dir: X509_STORE_add_cert failed "
 "for %s", file);
}
if (hash)
	if (!x509_hash_enter(cert))
		log_print("x509_read_from_dir: "
		    "x509_hash_enter (%s) failed",
		    file);
}

return 1;
672}

674/* XXX share code with x509_read_from_dir() ?  */
675int
676x509_read_crls_from_dir(X509_STORE *ctx, char *name)
677{
FILE		*crlfp;
X509_CRL	*crl;
struct stat	sb;
char		fullname[PATH_MAX1024];
char		file[PATH_MAX1024];
int		fd;

if (strlen(name) >= sizeof fullname - 1) {
log_print("x509_read_crls_from_dir: directory name too long");
return 0;
}
LOG_DBG((LOG_CRYPTO, 40, "x509_read_crls_from_dir: reading CRLs "log_debug (LOG_CRYPTO, 40, "x509_read_crls_from_dir: reading CRLs "
 "from %s", name)
   "from %s", name))log_debug (LOG_CRYPTO, 40, "x509_read_crls_from_dir: reading CRLs "
 "from %s", name);

if (monitor_req_readdir(name) == -1) {
LOG_DBG((LOG_CRYPTO, 10, "x509_read_crls_from_dir: opendir "log_debug (LOG_CRYPTO, 10, "x509_read_crls_from_dir: opendir "
 "(\"%s\") failed: %s", name, strerror((*__errno())))
    "(\"%s\") failed: %s", name, strerror(errno)))log_debug (LOG_CRYPTO, 10, "x509_read_crls_from_dir: opendir "
 "(\"%s\") failed: %s", name, strerror((*__errno())));
return 0;
}
strlcpy(fullname, name, sizeof fullname);

while ((fd = monitor_readdir(file, sizeof file)) != -1) {
LOG_DBG((LOG_CRYPTO, 60, "x509_read_crls_from_dir: reading "log_debug (LOG_CRYPTO, 60, "x509_read_crls_from_dir: reading "
 "CRL %s", file)
    "CRL %s", file))log_debug (LOG_CRYPTO, 60, "x509_read_crls_from_dir: reading "
 "CRL %s", file);

if (fstat(fd, &sb) == -1) {
	log_error("x509_read_crls_from_dir: fstat failed");
	close(fd);
	continue;
}

if (!S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000)) {
	close(fd);
	continue;
}

if ((crlfp = fdopen(fd, "r")) == NULL((void *)0)) {
	log_error("x509_read_crls_from_dir: fdopen failed");
	close(fd);
	continue;
}

crl = PEM_read_X509_CRL(crlfp, NULL((void *)0), NULL((void *)0), NULL((void *)0));

fclose(crlfp);

if (crl == NULL((void *)0)) {
	log_print("x509_read_crls_from_dir: "
	    "PEM_read_X509_CRL failed for %s",
	    file);
	continue;
}
if (!X509_STORE_add_crl(ctx, crl)) {
	LOG_DBG((LOG_CRYPTO, 50, "x509_read_crls_from_dir: "log_debug (LOG_CRYPTO, 50, "x509_read_crls_from_dir: " "X509_STORE_add_crl failed for %s"
, file)
	    "X509_STORE_add_crl failed for %s", file))log_debug (LOG_CRYPTO, 50, "x509_read_crls_from_dir: " "X509_STORE_add_crl failed for %s"
, file);
	continue;
}
/*
 * XXX This is to make x509_cert_validate set this (and
 * XXX another) flag when validating certificates. Currently,
 * XXX OpenSSL defaults to reject an otherwise valid
 * XXX certificate (chain) if these flags are set but there
 * XXX are no CRLs to check. The current workaround is to only
 * XXX set the flags if we actually loaded some CRL data.
 */
X509_STORE_set_flags(ctx, X509_V_FLAG_CRL_CHECK0x4);
}

return 1;
747}

749/* Initialize our databases and load our own certificates.  */
750int
751x509_cert_init(void)
752{
char	*dirname;

x509_hash_init();

/* Process CA certificates we will trust.  */
dirname = conf_get_str("X509-certificates", "CA-directory");
if (!dirname) {
log_print("x509_cert_init: no CA-directory");
return 0;
}
/* Free if already initialized.  */
if (x509_cas)
X509_STORE_free(x509_cas);

x509_cas = X509_STORE_new();
if (!x509_cas) {
log_print("x509_cert_init: creating new X509_STORE failed");
return 0;
}
if (!x509_read_from_dir(x509_cas, dirname, 0, &n_x509_cas)) {
log_print("x509_cert_init: x509_read_from_dir failed");
return 0;
}
/* Process client certificates we will accept.  */
dirname = conf_get_str("X509-certificates", "Cert-directory");
if (!dirname) {
log_print("x509_cert_init: no Cert-directory");
return 0;
}
/* Free if already initialized.  */
if (x509_certs)
X509_STORE_free(x509_certs);

x509_certs = X509_STORE_new();
if (!x509_certs) {
log_print("x509_cert_init: creating new X509_STORE failed");
return 0;
}
if (!x509_read_from_dir(x509_certs, dirname, 1, NULL((void *)0))) {
log_print("x509_cert_init: x509_read_from_dir failed");
return 0;
}
return 1;
796}

798int
799x509_crl_init(void)
800{
/*
* XXX I'm not sure if the method to use CRLs in certificate validation
* is valid for OpenSSL versions prior to 0.9.7. For now, simply do not
* support it.
*/
char	*dirname;
dirname = conf_get_str("X509-certificates", "CRL-directory");
if (!dirname) {
log_print("x509_crl_init: no CRL-directory");
return 0;
}
if (!x509_read_crls_from_dir(x509_cas, dirname)) {
LOG_DBG((LOG_MISC, 10,log_debug (LOG_MISC, 10, "x509_crl_init: x509_read_crls_from_dir failed"
)
    "x509_crl_init: x509_read_crls_from_dir failed"))log_debug (LOG_MISC, 10, "x509_crl_init: x509_read_crls_from_dir failed"
);
return 0;
}

return 1;
819}

821void *
822x509_cert_get(u_int8_t *asn, u_int32_t len)
823{
return x509_from_asn(asn, len);
825}

827int
828x509_cert_validate(void *scert)
829{
X509_STORE_CTX	*csc;
X509_NAME	*issuer, *subject;
X509		*cert = (X509 *) scert;
EVP_PKEY	*key;
int		res, err, flags;

/*
* Validate the peer certificate by checking with the CA certificates
* we trust.
*/
csc = X509_STORE_CTX_new();
if (csc == NULL((void *)0)) {
log_print("x509_cert_validate: failed to get memory for "
    "certificate store");
return 0;
}
X509_STORE_CTX_init(csc, x509_cas, cert, NULL((void *)0));
/* XXX See comment in x509_read_crls_from_dir.  */
flags = X509_VERIFY_PARAM_get_flags(X509_STORE_get0_param(x509_cas));
if (flags & X509_V_FLAG_CRL_CHECK0x4) {
X509_STORE_CTX_set_flags(csc, X509_V_FLAG_CRL_CHECK0x4);
X509_STORE_CTX_set_flags(csc, X509_V_FLAG_CRL_CHECK_ALL0x8);
}
res = X509_verify_cert(csc);
err = X509_STORE_CTX_get_error(csc);
X509_STORE_CTX_free(csc);

/*
* Return if validation succeeded or self-signed certs are not
* accepted.
*
* XXX X509_verify_cert seems to return -1 if the validation should be
* retried somehow.  We take this as an error and give up.
*/
if (res > 0)
return 1;
else if (res < 0 ||
   (res == 0 && err != X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT18)) {
if (err)
	log_print("x509_cert_validate: %.100s",
	    X509_verify_cert_error_string(err));
return 0;
} else if (!conf_get_str("X509-certificates", "Accept-self-signed")) {
if (err)
	log_print("x509_cert_validate: %.100s",
	    X509_verify_cert_error_string(err));
return 0;
}
issuer = X509_get_issuer_name(cert);
subject = X509_get_subject_name(cert);

if (!issuer || !subject || X509_NAME_cmp(issuer, subject))
return 0;

key = X509_get_pubkey(cert);
if (!key) {
log_print("x509_cert_validate: could not get public key from "
    "self-signed cert");
return 0;
}
if (X509_verify(cert, key) == -1) {
log_print("x509_cert_validate: self-signed cert is bad");
return 0;
}
return 1;
895}

897int
898x509_cert_insert(int id, void *scert)
899{
X509	*cert;
int	 res;

cert = X509_dup((X509 *)scert);
if (!cert) {
log_print("x509_cert_insert: X509_dup failed");
return 0;
}
if (x509_generate_kn(id, cert) == 0) {
LOG_DBG((LOG_POLICY, 50,log_debug (LOG_POLICY, 50, "x509_cert_insert: x509_generate_kn failed"
)
    "x509_cert_insert: x509_generate_kn failed"))log_debug (LOG_POLICY, 50, "x509_cert_insert: x509_generate_kn failed"
);
X509_free(cert);
return 0;
}

res = x509_hash_enter(cert);
if (!res)
X509_free(cert);

return res;
920}

922static struct x509_hash *
923x509_hash_lookup(X509 *cert)
924{
struct x509_hash *certh;
int	i;

for (i = 0; i <= bucket_mask; i++)
for (certh = LIST_FIRST(&x509_tab[i])((&x509_tab[i])->lh_first); certh;
    certh = LIST_NEXT(certh, link)((certh)->link.le_next))
	if (certh->cert == cert)
		return certh;
return 0;
934}

936void
937x509_cert_free(void *cert)
938{
struct x509_hash *certh = x509_hash_lookup((X509 *) cert);

if (certh)
LIST_REMOVE(certh, link)do { if ((certh)->link.le_next != ((void *)0)) (certh)->
link.le_next->link.le_prev = (certh)->link.le_prev; *(certh
)->link.le_prev = (certh)->link.le_next; ; ; } while (0
);
X509_free((X509 *) cert);
944}

946/* Validate the BER Encoding of a RDNSequence in the CERT_REQ payload.  */
947int
948x509_certreq_validate(u_int8_t *asn, u_int32_t len)
949{
int	res = 1;
951#if 0
struct norm_type name = SEQOF("issuer", RDNSequence);

if (!asn_template_clone(&name, 1) ||
   (asn = asn_decode_sequence(asn, len, &name)) == 0) {
log_print("x509_certreq_validate: can not decode 'acceptable "
    "CA' info");
res = 0;
}
asn_free(&name);
961#endif

/* XXX - not supported directly in SSL - later.  */

return res;
966}

968/* Decode the BER Encoding of a RDNSequence in the CERT_REQ payload.  */
969int
970x509_certreq_decode(void **pdata, u_int8_t *asn, u_int32_t len)
971{
972#if 0
/* XXX This needs to be done later.  */
struct norm_type aca = SEQOF("aca", RDNSequence);
struct norm_type *tmp;
struct x509_aca naca, *ret;

if (!asn_template_clone(&aca, 1) ||
   (asn = asn_decode_sequence(asn, len, &aca)) == 0) {
log_print("x509_certreq_decode: can not decode 'acceptable "
    "CA' info");
goto fail;
}
bzero(&naca, sizeof(naca));

tmp = asn_decompose("aca.RelativeDistinguishedName."
   "AttributeValueAssertion", &aca);
if (!tmp)
goto fail;
x509_get_attribval(tmp, &naca.name1);

tmp = asn_decompose("aca.RelativeDistinguishedName[1]"
   ".AttributeValueAssertion", &aca);
if (tmp)
x509_get_attribval(tmp, &naca.name2);

asn_free(&aca);

ret = malloc(sizeof(struct x509_aca));
if (ret)
memcpy(ret, &naca, sizeof(struct x509_aca));
else {
log_error("x509_certreq_decode: malloc (%lu) failed",
    (unsigned long) sizeof(struct x509_aca));
x509_free_aca(&aca);
}

return ret;

1010fail:
asn_free(&aca);
1012#endif
return 1;
1014}

1016void
1017x509_free_aca(void *blob)
1018{
struct x509_aca *aca = blob;

if (aca != NULL((void *)0)) {
free(aca->name1.type);
free(aca->name1.val);

free(aca->name2.type);
free(aca->name2.val);
}
1028}

1030X509 *
1031x509_from_asn(u_char *asn, u_int len)
1032{
BIO		*certh;
X509		*scert = 0;

certh = BIO_new(BIO_s_mem());
if (!certh) {
log_error("x509_from_asn: BIO_new (BIO_s_mem ()) failed");
return 0;
}
if (BIO_write(certh, asn, len) == -1) {
log_error("x509_from_asn: BIO_write failed\n");
goto end;
}
scert = d2i_X509_bio(certh, NULL((void *)0));
if (!scert) {
log_print("x509_from_asn: d2i_X509_bio failed\n");
goto end;
}
1050end:
BIO_free(certh);
return scert;
1053}

1055/*
* Obtain a certificate from an acceptable CA.
* XXX We don't check if the certificate we find is from an accepted CA.
*/
1059int
1060x509_cert_obtain(u_int8_t *id, size_t id_len, void *data, u_int8_t **cert,
  u_int32_t *certlen)
1062{
struct x509_aca *aca = data;
X509		*scert;

if (aca)
1
Assuming 'aca' is null→
2
←
Taking false branch→
LOG_DBG((LOG_CRYPTO, 60, "x509_cert_obtain: "log_debug (LOG_CRYPTO, 60, "x509_cert_obtain: " "acceptable certificate authorities here"
)
    "acceptable certificate authorities here"))log_debug (LOG_CRYPTO, 60, "x509_cert_obtain: " "acceptable certificate authorities here"
);

/* We need our ID to find a certificate.  */
if (!id) {
3
←
Assuming 'id' is non-null→
4
←
Taking false branch→
log_print("x509_cert_obtain: ID is missing");
return 0;
}
scert = x509_hash_find(id, id_len);
5
←
Calling 'x509_hash_find'→
if (!scert)
return 0;

x509_serialize(scert, cert, certlen);
if (!*cert)
return 0;
return 1;
1083}

1085/* Returns a pointer to the subjectAltName information of X509 certificate.  */
1086int
1087x509_cert_subjectaltname(X509 *scert, u_int8_t **altname, u_int32_t *len)
1088{
X509_EXTENSION		*subjectaltname;
ASN1_OCTET_STRING	*sanasn1data;
u_int8_t		*sandata;
int			 extpos, santype, sanlen;

extpos = X509_get_ext_by_NID(scert, NID_subject_alt_name85, -1);
if (extpos == -1) {
log_print("x509_cert_subjectaltname: "
    "certificate does not contain subjectAltName");
return 0;
}
subjectaltname = X509_get_ext(scert, extpos);
sanasn1data = X509_EXTENSION_get_data(subjectaltname);

if (!subjectaltname || !sanasn1data || !sanasn1data->data ||
   sanasn1data->length < 4) {
log_print("x509_cert_subjectaltname: invalid "
    "subjectaltname extension");
return 0;
}
/* SSL does not handle unknown ASN stuff well, do it by hand.  */
sandata = sanasn1data->data;
santype = sandata[2] & 0x3f;
sanlen = sandata[3];
sandata += 4;

/*
* The test here used to be !=, but some certificates can include
* extra stuff in subjectAltName, so we will just take the first
* salen bytes, and not worry about what follows.
*/
if (sanlen + 4 > sanasn1data->length) {
log_print("x509_cert_subjectaltname: subjectaltname invalid "
    "length");
return 0;
}
*len = sanlen;
*altname = sandata;
return santype;
1128}

1130int
1131x509_cert_get_subjects(void *scert, int *cnt, u_int8_t ***id,
  u_int32_t **id_len)
1133{
X509		*cert = scert;
X509_NAME	*subject;
int		type;
u_int8_t	*altname;
u_int32_t	altlen;
u_int8_t	*buf = 0;
unsigned char	*ubuf;
int		i;

*id = 0;
*id_len = 0;

/*
* XXX There can be a collection of subjectAltNames, but for now I
* only return the subjectName and a single subjectAltName, if
* present.
*/
type = x509_cert_subjectaltname(cert, &altname, &altlen);
if (!type) {
8
←
Assuming 'type' is not equal to 0→
9
←
Taking false branch→
*cnt = 1;
altlen = 0;
} else
*cnt = 2;

*id = calloc(*cnt, sizeof **id);
10
←
Storing null pointer value→
if (!*id) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
log_print("x509_cert_get_subject: malloc (%lu) failed",
    *cnt * (unsigned long)sizeof **id);
*cnt = 0;
goto fail;
}
*id_len = calloc(*cnt, sizeof **id_len);
if (!*id_len) {
13
←
Assuming the condition is false→
14
←
Taking false branch→
log_print("x509_cert_get_subject: malloc (%lu) failed",
    *cnt * (unsigned long)sizeof **id_len);
goto fail;
}
/* Stash the subjectName into the first slot.  */
subject = X509_get_subject_name(cert);
if (!subject)
15
←
Assuming 'subject' is non-null→
16
←
Taking false branch→
goto fail;

(*id_len)[0] =
ISAKMP_ID_DATA_OFF8 + i2d_X509_NAME(subject, NULL((void *)0)) -
    ISAKMP_GEN_SZ4;
(*id)[0] = malloc((*id_len)[0]);
if (!(*id)[0]) {
17
←
Assuming the condition is false→
18
←
Taking false branch→
log_print("x509_cert_get_subject: malloc (%d) failed",
    (*id_len)[0]);
goto fail;
}
SET_ISAKMP_ID_TYPE((*id)[0] - ISAKMP_GEN_SZ, IPSEC_ID_DER_ASN1_DN)field_set_num (isakmp_id_fld + 0, (*id)[0] - 4, 9);
ubuf = (*id)[0] + ISAKMP_ID_DATA_OFF8 - ISAKMP_GEN_SZ4;
i2d_X509_NAME(subject, &ubuf);

if (altlen) {
19
←
Assuming 'altlen' is 0→
20
←
Taking false branch→
/* Stash the subjectAltName into the second slot.  */
buf = malloc(altlen + ISAKMP_ID_DATA_OFF8);
if (!buf) {
	log_print("x509_cert_get_subject: malloc (%d) failed",
	    altlen + ISAKMP_ID_DATA_OFF8);
	goto fail;
}
switch (type) {
case X509v3_DNS_NAME2:
	SET_ISAKMP_ID_TYPE(buf, IPSEC_ID_FQDN)field_set_num (isakmp_id_fld + 0, buf, 2);
	break;

case X509v3_RFC_NAME1:
	SET_ISAKMP_ID_TYPE(buf, IPSEC_ID_USER_FQDN)field_set_num (isakmp_id_fld + 0, buf, 3);
	break;

case X509v3_IP_ADDR7:
	/*
	 * XXX I dislike the numeric constants, but I don't
	 * know what we should use otherwise.
	 */
	switch (altlen) {
	case 4:
		SET_ISAKMP_ID_TYPE(buf, IPSEC_ID_IPV4_ADDR)field_set_num (isakmp_id_fld + 0, buf, 1);
		break;

	case 16:
		SET_ISAKMP_ID_TYPE(buf, IPSEC_ID_IPV6_ADDR)field_set_num (isakmp_id_fld + 0, buf, 5);
		break;

	default:
		log_print("x509_cert_get_subject: invalid "
		    "subjectAltName IPaddress length %d ",
		    altlen);
		goto fail;
	}
	break;
}

SET_IPSEC_ID_PROTO(buf + ISAKMP_ID_DOI_DATA_OFF, 0)field_set_num (ipsec_id_fld + 0, buf + 5, 0);
SET_IPSEC_ID_PORT(buf + ISAKMP_ID_DOI_DATA_OFF, 0)field_set_num (ipsec_id_fld + 1, buf + 5, 0);
memcpy(buf + ISAKMP_ID_DATA_OFF8, altname, altlen);

(*id_len)[1] = ISAKMP_ID_DATA_OFF8 + altlen - ISAKMP_GEN_SZ4;
(*id)[1] = malloc((*id_len)[1]);
if (!(*id)[1]) {
	log_print("x509_cert_get_subject: malloc (%d) failed",
	    (*id_len)[1]);
	goto fail;
}
memcpy((*id)[1], buf + ISAKMP_GEN_SZ4, (*id_len)[1]);

free(buf);
buf = 0;
}
return 1;

1247fail:
for (i = 0; i < *cnt; i++)
free((*id)[i]);
free(*id);
free(*id_len);
free(buf);
return 0;
1254}

1256int
1257x509_cert_get_key(void *scert, void *keyp)
1258{
X509		*cert = scert;
EVP_PKEY	*key;

key = X509_get_pubkey(cert);

/* Check if we got the right key type.  */
if (EVP_PKEY_id(key) != EVP_PKEY_RSA6) {
log_print("x509_cert_get_key: public key is not a RSA key");
X509_free(cert);
return 0;
}
*(RSA **)keyp = RSAPublicKey_dup(EVP_PKEY_get0_RSA(key));

return *(RSA **)keyp == NULL((void *)0) ? 0 : 1;
1273}

1275void *
1276x509_cert_dup(void *scert)
1277{
return X509_dup(scert);
1279}

1281void
1282x509_serialize(void *scert, u_int8_t **data, u_int32_t *datalen)
1283{
u_int8_t	*p;

*datalen = i2d_X509((X509 *)scert, NULL((void *)0));
*data = p = malloc(*datalen);
if (!p) {
log_error("x509_serialize: malloc (%d) failed", *datalen);
return;
}
*datalen = i2d_X509((X509 *)scert, &p);
1293}

1295/* From cert to printable */
1296char *
1297x509_printable(void *cert)
1298{
char		*s;
u_int8_t	*data;
u_int32_t	datalen;

x509_serialize(cert, &data, &datalen);
if (!data)
return 0;

s = raw2hex(data, datalen);
free(data);
return s;
1310}

1312/* From printable to cert */
1313void *
1314x509_from_printable(char *cert)
1315{
u_int8_t	*buf;
int		plen, ret;
void		*foo;

plen = (strlen(cert) + 1) / 2;
buf = malloc(plen);
if (!buf) {
log_error("x509_from_printable: malloc (%d) failed", plen);
return 0;
}
ret = hex2raw(cert, buf, plen);
if (ret == -1) {
free(buf);
log_print("x509_from_printable: badly formatted cert");
return 0;
}
foo = x509_cert_get(buf, plen);
free(buf);
if (!foo)
log_print("x509_from_printable: "
    "could not retrieve certificate");
return foo;
1338}

1340char *
1341x509_DN_string(u_int8_t *asn1, size_t sz)
1342{
X509_NAME	*name;
const u_int8_t	*p = asn1;
char		buf[256];	/* XXX Just a guess at a maximum length.  */
long len = sz;

name = d2i_X509_NAME(NULL((void *)0), &p, len);
if (!name) {
log_print("x509_DN_string: d2i_X509_NAME failed");
return 0;
}
if (!X509_NAME_oneline(name, buf, sizeof buf - 1)) {
log_print("x509_DN_string: X509_NAME_oneline failed");
X509_NAME_free(name);
return 0;
}
X509_NAME_free(name);
buf[sizeof buf - 1] = '\0';
return strdup(buf);
1361}

1363/* Number of CAs we trust (to decide whether we can send CERT_REQ) */
1364int
1365x509_ca_count(void)
1366{
return n_x509_cas;
1368}