/usr/src/sbin/isakmpd/ike

Bug Summary

File:	src/sbin/isakmpd/ike_auth.c
Warning:	line 295, column 5 Potential leak of memory pointed to by 'keyfile'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ike_auth.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fno-rounding-math -mconstructor-aliases -munwind-tables -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/lib/clang/13.0.0 -I /usr/src/sbin/isakmpd -I . -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/isakmpd/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -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/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/sbin/isakmpd/ike_auth.c
1/* $OpenBSD: ike_auth.c,v 1.118 2020/07/07 17:33:40 tobhe Exp $	 */
2/* $EOM: ike_auth.c,v 1.59 2000/11/21 00:21:31 angelos Exp $	 */

4/*
* Copyright (c) 1998, 1999, 2000, 2001 Niklas Hallqvist.  All rights reserved.
* Copyright (c) 1999 Niels Provos.  All rights reserved.
* Copyright (c) 1999 Angelos D. Keromytis.  All rights reserved.
* Copyright (c) 2000, 2001, 2003 Håkan Olsson.  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.
*/

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

35#include <sys/types.h>
36#include <sys/stat.h>
37#include <netinet/in.h>
38#include <arpa/inet.h>

40#include <errno(*__errno()).h>
41#include <fcntl.h>
42#include <stdlib.h>
43#include <string.h>
44#include <unistd.h>
45#include <regex.h>
46#include <keynote.h>
47#include <policy.h>

49#include "cert.h"
50#include "conf.h"
51#include "constants.h"
52#if defined (USE_DNSSEC)
53#include "dnssec.h"
54#endif
55#include "exchange.h"
56#include "hash.h"
57#include "ike_auth.h"
58#include "ipsec.h"
59#include "ipsec_doi.h"
60#include "libcrypto.h"
61#include "log.h"
62#include "message.h"
63#include "monitor.h"
64#include "prf.h"
65#include "transport.h"
66#include "util.h"
67#include "key.h"
68#include "x509.h"

70#ifdef notyet
71static u_int8_t *enc_gen_skeyid(struct exchange *, size_t *);
72#endif
73static u_int8_t *pre_shared_gen_skeyid(struct exchange *, size_t *);

75static int      pre_shared_decode_hash(struct message *);
76static int      pre_shared_encode_hash(struct message *);

78static u_int8_t *sig_gen_skeyid(struct exchange *, size_t *);
79static int      rsa_sig_decode_hash(struct message *);
80static int      rsa_sig_encode_hash(struct message *);

82static int      get_raw_key_from_file(int, u_int8_t *, size_t, RSA **);

84static int      ike_auth_hash(struct exchange *, u_int8_t *);

86static struct ike_auth ike_auth[] = {
{
IKE_AUTH_PRE_SHARED1, pre_shared_gen_skeyid,
pre_shared_decode_hash,
pre_shared_encode_hash
},
92#ifdef notdef
{
IKE_AUTH_DSS2, sig_gen_skeyid,
pre_shared_decode_hash,
pre_shared_encode_hash
},
98#endif
{
IKE_AUTH_RSA_SIG3, sig_gen_skeyid,
rsa_sig_decode_hash,
rsa_sig_encode_hash
},
104#ifdef notdef
{
IKE_AUTH_RSA_ENC4, enc_gen_skeyid,
pre_shared_decode_hash,
pre_shared_encode_hash
},
{
IKE_AUTH_RSA_ENC_REV5, enc_gen_skeyid,
pre_shared_decode_hash,
pre_shared_encode_hash
},
115#endif
116};

118struct ike_auth *
119ike_auth_get(u_int16_t id)
120{
size_t	i;

for (i = 0; i < sizeof ike_auth / sizeof ike_auth[0]; i++)
if (id == ike_auth[i].id)
	return &ike_auth[i];
return 0;
127}

129/*
* Find and decode the configured key (pre-shared or public) for the
* peer denoted by ID.  Stash the len in KEYLEN.
*/
133static void *
134ike_auth_get_key(int type, char *id, char *local_id, size_t *keylen)
135{
char	*key, *buf;
char	*keyfile, *privkeyfile;
FILE	*keyfp;
RSA	*rsakey;
size_t	 fsize, pkflen;
int	 fd;

switch (type) {
21
←
Control jumps to 'case 3:'  at line 183→
case IKE_AUTH_PRE_SHARED1:
/* Get the pre-shared key for our peer.  */
key = conf_get_str(id, "Authentication");
if (!key && local_id)
	key = conf_get_str(local_id, "Authentication");

if (!key) {
	log_print("ike_auth_get_key: "
	    "no key found for peer \"%s\" or local ID \"%s\"",
	    id, local_id ? local_id : "<none>");
	return 0;
}
/* If the key starts with 0x it is in hex format.  */
if (strncasecmp(key, "0x", 2) == 0) {
	*keylen = (strlen(key) - 1) / 2;
	buf = malloc(*keylen);
	if (!buf) {
		log_error("ike_auth_get_key: malloc (%lu) "
		    "failed", (unsigned long)*keylen);
		return 0;
	}
	if (hex2raw(key + 2, (unsigned char *)buf, *keylen)) {
		free(buf);
		log_print("ike_auth_get_key: invalid hex key "
		    "%s", key);
		return 0;
	}
	key = buf;
} else {
	buf = key;
	key = strdup(buf);
	if (!key) {
		log_error("ike_auth_get_key: strdup() failed");
		return 0;
	}
	*keylen = strlen(key);
}
break;

case IKE_AUTH_RSA_SIG3:
if (local_id21.1
'local_id' is non-null
 && (keyfile = conf_get_str("KeyNote",
22
←
Assuming the condition is false→
23
←
Taking false branch→
    "Credential-directory")) != 0) {
	struct stat     sb;
	struct keynote_deckey dc;
	char           *privkeyfile, *buf2;
	size_t          size;

	if (asprintf(&privkeyfile, "%s/%s/%s", keyfile,
	    local_id, PRIVATE_KEY_FILE"private_key") == -1) {
		log_print("ike_auth_get_key: failed to asprintf()");
		return 0;
	}
	keyfile = privkeyfile;

	fd = monitor_open(keyfile, O_RDONLY0x0000, 0);
	if (fd < 0) {
		free(keyfile);
		goto ignorekeynote;
	}

	if (fstat(fd, &sb) == -1) {
		log_print("ike_auth_get_key: fstat failed");
		free(keyfile);
		close(fd);
		return 0;
	}
	size = (size_t)sb.st_size;

	buf = calloc(size + 1, sizeof(char));
	if (!buf) {
		log_print("ike_auth_get_key: failed allocating"
		    " %lu bytes", (unsigned long)size + 1);
		free(keyfile);
		close(fd);
		return 0;
	}
	if (read(fd, buf, size) != (ssize_t)size) {
		free(buf);
		log_print("ike_auth_get_key: "
		    "failed reading %lu bytes from \"%s\"",
		    (unsigned long)size, keyfile);
		free(keyfile);
		close(fd);
		return 0;
	}
	close(fd);

	/* Parse private key string */
	buf2 = kn_get_string(buf);
	free(buf);

	if (!buf2 || kn_decode_key(&dc, buf2,
	    KEYNOTE_PRIVATE_KEY1) == -1) {
		free(buf2);
		log_print("ike_auth_get_key: failed decoding "
		    "key in \"%s\"", keyfile);
		free(keyfile);
		return 0;
	}
	free(buf2);

	if (dc.dec_algorithm != KEYNOTE_ALGORITHM_RSA6) {
		log_print("ike_auth_get_key: wrong algorithm "
		    "type %d in \"%s\"", dc.dec_algorithm,
		    keyfile);
		free(keyfile);
		kn_free_key(&dc);
		return 0;
	}
	free(keyfile);
	return dc.dec_key;
}
256ignorekeynote:
/* Otherwise, try X.509 */

privkeyfile = keyfile = NULL((void*)0);
fd = -1;

if (local_id23.1
'local_id' is non-null
) {
24
←
Taking true branch→
	/* Look in Private-key-directory. */
	keyfile = conf_get_str("X509-certificates",
	    "Private-key-directory");
	pkflen = strlen(keyfile) + strlen(local_id) + sizeof "/";
	privkeyfile = calloc(pkflen, sizeof(char));
25
←
Memory is allocated→
	if (!privkeyfile) {
26
←
Assuming 'privkeyfile' is non-null→
27
←
Taking false branch→
		log_print("ike_auth_get_key: failed to "
		    "allocate %lu bytes", (unsigned long)pkflen);
		return 0;
	}

	snprintf(privkeyfile, pkflen, "%s/%s", keyfile,
	    local_id);
	keyfile = privkeyfile;

	fd = monitor_open(keyfile, O_RDONLY0x0000, 0);
	if (fd == -1 && errno(*__errno()) != ENOENT2) {
28
←
Assuming the condition is true→
29
←
Assuming the condition is false→
30
←
Taking false branch→
		log_print("ike_auth_get_key: failed opening "
		    "\"%s\"", keyfile);
		free(privkeyfile);
		privkeyfile = NULL((void*)0);
		keyfile = NULL((void*)0);
	}
}

if (fd == -1) {
31
←
Taking true branch→
	/* No key found, try default key. */
	keyfile = conf_get_str("X509-certificates",
	    "Private-key");

	fd = monitor_open(keyfile, O_RDONLY0x0000, 0);
	if (fd == -1) {
32
←
Assuming the condition is true→
33
←
Taking true branch→
		log_print("ike_auth_get_key: failed opening "
34
←
Potential leak of memory pointed to by 'keyfile'
		    "\"%s\"", keyfile);
		return 0;
	}
}

if (check_file_secrecy_fd(fd, keyfile, &fsize)) {
	free(privkeyfile);
	close(fd);
	return 0;
}

if ((keyfp = fdopen(fd, "r")) == NULL((void*)0)) {
	log_print("ike_auth_get_key: fdopen failed");
	free(privkeyfile);
	close(fd);
	return 0;
}
313#if SSLEAY_VERSION_NUMBER0x20000000L >= 0x00904100L
rsakey = PEM_read_RSAPrivateKey(keyfp, NULL((void*)0), NULL((void*)0), NULL((void*)0));
315#else
rsakey = PEM_read_RSAPrivateKey(keyfp, NULL((void*)0), NULL((void*)0));
317#endif
fclose(keyfp);

free(privkeyfile);

if (!rsakey) {
	log_print("ike_auth_get_key: "
	    "PEM_read_bio_RSAPrivateKey failed");
	return 0;
}
return rsakey;

default:
log_print("ike_auth_get_key: unknown key type %d", type);
return 0;
}

return key;
335}

337static u_int8_t *
338pre_shared_gen_skeyid(struct exchange *exchange, size_t *sz)
339{
struct prf     *prf;
struct ipsec_exch *ie = exchange->data;
u_int8_t       *skeyid, *buf = 0;
unsigned char  *key;
size_t          keylen;

/*
* If we're the responder and have the initiator's ID (which is the
* case in Aggressive mode), try to find the preshared key in the
* section of the initiator's Phase 1 ID.  This allows us to do
* mobile user support with preshared keys.
*/
if (!exchange->initiator && exchange->id_i) {
switch (exchange->id_i[0]) {
case IPSEC_ID_IPV4_ADDR1:
case IPSEC_ID_IPV6_ADDR5:
	util_ntoa((char **) &buf,
	    exchange->id_i[0] == IPSEC_ID_IPV4_ADDR1 ? AF_INET2 :
	    AF_INET624, exchange->id_i + ISAKMP_ID_DATA_OFF8 -
	    ISAKMP_GEN_SZ4);
	if (!buf)
		return 0;
	break;

case IPSEC_ID_FQDN2:
case IPSEC_ID_USER_FQDN3:
	buf = calloc(exchange->id_i_len - ISAKMP_ID_DATA_OFF8 +
	    ISAKMP_GEN_SZ4 + 1, sizeof(char));
	if (!buf) {
		log_print("pre_shared_gen_skeyid: malloc (%lu"
		    ") failed",
		    (unsigned long)exchange->id_i_len -
		    ISAKMP_ID_DATA_OFF8 + ISAKMP_GEN_SZ4 + 1);
		return 0;
	}
	memcpy(buf,
	    exchange->id_i + ISAKMP_ID_DATA_OFF8 -
	    ISAKMP_GEN_SZ4,
	    exchange->id_i_len - ISAKMP_ID_DATA_OFF8 +
	    ISAKMP_GEN_SZ4);
	break;

	/* XXX Support more ID types ? */
default:
	break;
}
}
/*
* Get the pre-shared key for our peer. This will work even if the key
* has been passed to us through a mechanism like PFKEYv2.
*/
key = ike_auth_get_key(IKE_AUTH_PRE_SHARED1, exchange->name,
   (char *)buf, &keylen);
free(buf);

/* Fail if no key could be found.  */
if (!key)
return 0;

/* Store the secret key for later policy processing.  */
exchange->recv_key = calloc(keylen + 1, sizeof(char));
exchange->recv_keytype = ISAKMP_KEY_PASSPHRASE1;
if (!exchange->recv_key) {
log_error("pre_shared_gen_skeyid: malloc (%lu) failed",
    (unsigned long)keylen);
free(key);
return 0;
}
memcpy(exchange->recv_key, key, keylen);
exchange->recv_certtype = ISAKMP_CERTENC_NONE0;
free(key);

prf = prf_alloc(ie->prf_type, ie->hash->type, exchange->recv_key,
   keylen);
if (!prf)
return 0;

*sz = prf->blocksize;
skeyid = malloc(*sz);
if (!skeyid) {
log_error("pre_shared_gen_skeyid: malloc (%lu) failed",
    (unsigned long)*sz);
prf_free(prf);
return 0;
}
prf->Init(prf->prfctx);
prf->Update(prf->prfctx, exchange->nonce_i, exchange->nonce_i_len);
prf->Update(prf->prfctx, exchange->nonce_r, exchange->nonce_r_len);
prf->Final(skeyid, prf->prfctx);
prf_free(prf);
return skeyid;
431}

433/* Both DSS & RSA signature authentication use this algorithm.  */
434static u_int8_t *
435sig_gen_skeyid(struct exchange *exchange, size_t *sz)
436{
struct prf     *prf;
struct ipsec_exch *ie = exchange->data;
u_int8_t       *skeyid;
unsigned char  *key;

key = malloc(exchange->nonce_i_len + exchange->nonce_r_len);
if (!key)
return 0;
memcpy(key, exchange->nonce_i, exchange->nonce_i_len);
memcpy(key + exchange->nonce_i_len, exchange->nonce_r,
   exchange->nonce_r_len);

LOG_DBG((LOG_NEGOTIATION, 80, "sig_gen_skeyid: PRF type %d, hash %d",log_debug (LOG_NEGOTIATION, 80, "sig_gen_skeyid: PRF type %d, hash %d"
, ie->prf_type, ie->hash->type)
   ie->prf_type, ie->hash->type))log_debug (LOG_NEGOTIATION, 80, "sig_gen_skeyid: PRF type %d, hash %d"
, ie->prf_type, ie->hash->type);
LOG_DBG_BUF((LOG_NEGOTIATION, 80,log_debug_buf (LOG_NEGOTIATION, 80, "sig_gen_skeyid: SKEYID initialized with"
, (u_int8_t *)key, exchange->nonce_i_len + exchange->nonce_r_len
)
   "sig_gen_skeyid: SKEYID initialized with",log_debug_buf (LOG_NEGOTIATION, 80, "sig_gen_skeyid: SKEYID initialized with"
, (u_int8_t *)key, exchange->nonce_i_len + exchange->nonce_r_len
)
   (u_int8_t *)key, exchange->nonce_i_len + exchange->nonce_r_len))log_debug_buf (LOG_NEGOTIATION, 80, "sig_gen_skeyid: SKEYID initialized with"
, (u_int8_t *)key, exchange->nonce_i_len + exchange->nonce_r_len
);

prf = prf_alloc(ie->prf_type, ie->hash->type, key,
   exchange->nonce_i_len + exchange->nonce_r_len);
free(key);
if (!prf)
return 0;

*sz = prf->blocksize;
skeyid = malloc(*sz);
if (!skeyid) {
log_error("sig_gen_skeyid: malloc (%lu) failed",
    (unsigned long)*sz);
prf_free(prf);
return 0;
}
LOG_DBG((LOG_NEGOTIATION, 80, "sig_gen_skeyid: g^xy length %lu",log_debug (LOG_NEGOTIATION, 80, "sig_gen_skeyid: g^xy length %lu"
, (unsigned long)ie->g_xy_len)
   (unsigned long)ie->g_xy_len))log_debug (LOG_NEGOTIATION, 80, "sig_gen_skeyid: g^xy length %lu"
, (unsigned long)ie->g_xy_len);
LOG_DBG_BUF((LOG_NEGOTIATION, 80,log_debug_buf (LOG_NEGOTIATION, 80, "sig_gen_skeyid: SKEYID fed with g^xy"
, ie->g_xy, ie->g_xy_len)
   "sig_gen_skeyid: SKEYID fed with g^xy", ie->g_xy, ie->g_xy_len))log_debug_buf (LOG_NEGOTIATION, 80, "sig_gen_skeyid: SKEYID fed with g^xy"
, ie->g_xy, ie->g_xy_len);

prf->Init(prf->prfctx);
prf->Update(prf->prfctx, ie->g_xy, ie->g_xy_len);
prf->Final(skeyid, prf->prfctx);
prf_free(prf);
return skeyid;
479}

481#ifdef notdef
482/*
* Both standard and revised RSA encryption authentication use this SKEYID
* computation.
*/
486static u_int8_t *
487enc_gen_skeyid(struct exchange *exchange, size_t *sz)
488{
struct prf     *prf;
struct ipsec_exch *ie = exchange->data;
struct hash    *hash = ie->hash;
u_int8_t       *skeyid;

hash->Init(hash->ctx);
hash->Update(hash->ctx, exchange->nonce_i, exchange->nonce_i_len);
hash->Update(hash->ctx, exchange->nonce_r, exchange->nonce_r_len);
hash->Final(hash->digest, hash->ctx);
prf = prf_alloc(ie->prf_type, hash->type, hash->digest, *sz);
if (!prf)
return 0;

*sz = prf->blocksize;
skeyid = malloc(*sz);
if (!skeyid) {
log_error("enc_gen_skeyid: malloc (%d) failed", *sz);
prf_free(prf);
return 0;
}
prf->Init(prf->prfctx);
prf->Update(prf->prfctx, exchange->cookies, ISAKMP_HDR_COOKIES_LEN(8 + 8));
prf->Final(skeyid, prf->prfctx);
prf_free(prf);
return skeyid;
514}
515#endif				/* notdef */

517static int
518pre_shared_decode_hash(struct message *msg)
519{
struct exchange *exchange = msg->exchange;
struct ipsec_exch *ie = exchange->data;
struct payload *payload;
size_t          hashsize = ie->hash->hashsize;
char            header[80];
int             initiator = exchange->initiator;
u_int8_t      **hash_p;

/* Choose the right fields to fill-in.  */
hash_p = initiator ? &ie->hash_r : &ie->hash_i;

payload = payload_first(msg, ISAKMP_PAYLOAD_HASH8);
if (!payload) {
log_print("pre_shared_decode_hash: no HASH payload found");
return -1;
}
/* Check that the hash is of the correct size.  */
if (GET_ISAKMP_GEN_LENGTH(payload->p)field_get_num (isakmp_gen_fld + 2, payload->p) - ISAKMP_GEN_SZ4 != hashsize)
return -1;

/* XXX Need this hash be in the SA?  */
*hash_p = malloc(hashsize);
if (!*hash_p) {
log_error("pre_shared_decode_hash: malloc (%lu) failed",
    (unsigned long)hashsize);
return -1;
}
memcpy(*hash_p, payload->p + ISAKMP_HASH_DATA_OFF4, hashsize);
snprintf(header, sizeof header, "pre_shared_decode_hash: HASH_%c",
   initiator ? 'R' : 'I');
LOG_DBG_BUF((LOG_MISC, 80, header, *hash_p, hashsize))log_debug_buf (LOG_MISC, 80, header, *hash_p, hashsize);

payload->flags |= PL_MARK1;
return 0;
554}

556/* Decrypt the HASH in SIG, we already need a parsed ID payload.  */
557static int
558rsa_sig_decode_hash(struct message *msg)
559{
struct cert_handler *handler;
struct exchange *exchange = msg->exchange;
struct ipsec_exch *ie = exchange->data;
struct payload *p;
void           *cert = 0;
u_int8_t       *rawcert = 0, **hash_p, **id_cert, *id;
u_int32_t       rawcertlen, *id_cert_len;
RSA            *key = 0;
size_t          hashsize = ie->hash->hashsize, id_len;
char            header[80];
int             len, initiator = exchange->initiator;
int             found = 0, n, i, id_found;
572#if defined (USE_DNSSEC)
u_int8_t       *rawkey = 0;
u_int32_t       rawkeylen;
575#endif

/* Choose the right fields to fill-in.  */
hash_p = initiator ? &ie->hash_r : &ie->hash_i;
id = initiator ? exchange->id_r : exchange->id_i;
id_len = initiator ? exchange->id_r_len : exchange->id_i_len;

if (!id || id_len == 0) {
log_print("rsa_sig_decode_hash: ID is missing");
return -1;
}
/*
* XXX Assume we should use the same kind of certification as the
* remote...  moreover, just use the first CERT payload to decide what
* to use.
*/
p = payload_first(msg, ISAKMP_PAYLOAD_CERT6);
if (!p)
handler = cert_get(ISAKMP_CERTENC_KEYNOTE11);
else
handler = cert_get(GET_ISAKMP_CERT_ENCODING(p->p)field_get_num (isakmp_cert_fld + 0, p->p));
if (!handler) {
log_print("rsa_sig_decode_hash: cert_get (%d) failed",
    p ? GET_ISAKMP_CERT_ENCODING(p->p)field_get_num (isakmp_cert_fld + 0, p->p) : -1);
return -1;
}
/*
* We need the policy session initialized now, so we can add
* credentials etc.
*/
exchange->policy_id = kn_init();
if (exchange->policy_id == -1) {
log_print("rsa_sig_decode_hash: failed to initialize policy "
    "session");
return -1;
}

/* Obtain a certificate from our certificate storage.  */
if (handler->cert_obtain(id, id_len, 0, &rawcert, &rawcertlen)) {
if (handler->id == ISAKMP_CERTENC_X509_SIG4) {
	cert = handler->cert_get(rawcert, rawcertlen);
	if (!cert)
		LOG_DBG((LOG_CRYPTO, 50, "rsa_sig_decode_hash:"log_debug (LOG_CRYPTO, 50, "rsa_sig_decode_hash:" " certificate malformed"
)
		    " certificate malformed"))log_debug (LOG_CRYPTO, 50, "rsa_sig_decode_hash:" " certificate malformed"
);
	else {
		if (!handler->cert_get_key(cert, &key)) {
			log_print("rsa_sig_decode_hash: "
			    "decoding certificate failed");
			handler->cert_free(cert);
		} else {
			found++;
			LOG_DBG((LOG_CRYPTO, 40,log_debug (LOG_CRYPTO, 40, "rsa_sig_decode_hash: using cert "
 "of type %d", handler->id)
			    "rsa_sig_decode_hash: using cert "log_debug (LOG_CRYPTO, 40, "rsa_sig_decode_hash: using cert "
 "of type %d", handler->id)
			    "of type %d", handler->id))log_debug (LOG_CRYPTO, 40, "rsa_sig_decode_hash: using cert "
 "of type %d", handler->id);
			exchange->recv_cert = cert;
			exchange->recv_certtype = handler->id;
			x509_generate_kn(exchange->policy_id,
			    cert);
		}
	}
} else if (handler->id == ISAKMP_CERTENC_KEYNOTE11)
	handler->cert_insert(exchange->policy_id, rawcert);
free(rawcert);
}
/*
* Walk over potential CERT payloads in this message.
* XXX I believe this is the wrong spot for this.  CERTs can appear
* anytime.
*/
TAILQ_FOREACH(p, &msg->payload[ISAKMP_PAYLOAD_CERT], link)for((p) = ((&msg->payload[6])->tqh_first); (p) != (
(void*)0); (p) = ((p)->link.tqe_next)) {
p->flags |= PL_MARK1;

/*
 * When we have found a key, just walk over the rest, marking
 * them.
 */
if (found)
	continue;

handler = cert_get(GET_ISAKMP_CERT_ENCODING(p->p)field_get_num (isakmp_cert_fld + 0, p->p));
if (!handler) {
	LOG_DBG((LOG_MISC, 30, "rsa_sig_decode_hash: "log_debug (LOG_MISC, 30, "rsa_sig_decode_hash: " "no handler for %s CERT encoding"
, constant_name(isakmp_certenc_cst, field_get_num (isakmp_cert_fld
 + 0, p->p)))
	    "no handler for %s CERT encoding",log_debug (LOG_MISC, 30, "rsa_sig_decode_hash: " "no handler for %s CERT encoding"
, constant_name(isakmp_certenc_cst, field_get_num (isakmp_cert_fld
 + 0, p->p)))
	    constant_name(isakmp_certenc_cst,log_debug (LOG_MISC, 30, "rsa_sig_decode_hash: " "no handler for %s CERT encoding"
, constant_name(isakmp_certenc_cst, field_get_num (isakmp_cert_fld
 + 0, p->p)))
	    GET_ISAKMP_CERT_ENCODING(p->p))))log_debug (LOG_MISC, 30, "rsa_sig_decode_hash: " "no handler for %s CERT encoding"
, constant_name(isakmp_certenc_cst, field_get_num (isakmp_cert_fld
 + 0, p->p)));
	continue;
}
cert = handler->cert_get(p->p + ISAKMP_CERT_DATA_OFF5,
    GET_ISAKMP_GEN_LENGTH(p->p)field_get_num (isakmp_gen_fld + 2, p->p) - ISAKMP_CERT_DATA_OFF5);
if (!cert) {
	log_print("rsa_sig_decode_hash: "
	    "can not get data from CERT");
	continue;
}
if (!handler->cert_validate(cert)) {
	handler->cert_free(cert);
	log_print("rsa_sig_decode_hash: received CERT can't "
	    "be validated");
	continue;
}
if (GET_ISAKMP_CERT_ENCODING(p->p)field_get_num (isakmp_cert_fld + 0, p->p) ==
    ISAKMP_CERTENC_X509_SIG4) {
	if (!handler->cert_get_subjects(cert, &n, &id_cert,
	    &id_cert_len)) {
		handler->cert_free(cert);
		log_print("rsa_sig_decode_hash: can not get "
		    "subject from CERT");
		continue;
	}
	id_found = 0;
	for (i = 0; i < n; i++)
		if (id_cert_len[i] == id_len &&
		    id[0] == id_cert[i][0] &&
		    memcmp(id + 4, id_cert[i] + 4, id_len - 4)
		    == 0) {
			id_found++;
			break;
		}
	if (!id_found) {
		handler->cert_free(cert);
		log_print("rsa_sig_decode_hash: no CERT "
		    "subject match the ID");
		free(id_cert);
		continue;
	}
	cert_free_subjects(n, id_cert, id_cert_len);
}
if (!handler->cert_get_key(cert, &key)) {
	handler->cert_free(cert);
	log_print("rsa_sig_decode_hash: decoding payload CERT "
	    "failed");
	continue;
}
/* We validated the cert, cache it for later use.  */
handler->cert_insert(exchange->policy_id, cert);

exchange->recv_cert = cert;
exchange->recv_certtype = GET_ISAKMP_CERT_ENCODING(p->p)field_get_num (isakmp_cert_fld + 0, p->p);

if (exchange->recv_certtype == ISAKMP_CERTENC_KEYNOTE11) {
	struct keynote_deckey dc;
	char           *pp;

	dc.dec_algorithm = KEYNOTE_ALGORITHM_RSA6;
	dc.dec_key = key;

	pp = kn_encode_key(&dc, INTERNAL_ENC_PKCS11,
	    ENCODING_HEX1, KEYNOTE_PUBLIC_KEY0);
	if (pp == NULL((void*)0)) {
		kn_free_key(&dc);
		log_print("rsa_sig_decode_hash: failed to "
		    "ASCII-encode key");
		return -1;
	}
	if (asprintf(&exchange->keynote_key, "rsa-hex:%s",
	    pp) == -1) {
		free(pp);
		kn_free_key(&dc);
		log_print("rsa_sig_decode_hash: failed to asprintf()");
		return -1;
	}
	free(pp);
}
found++;
}

741#if defined (USE_DNSSEC)
/*
* If no certificate provided a key, try to find a validated DNSSEC
* KEY.
*/
if (!found) {
rawkey = dns_get_key(IKE_AUTH_RSA_SIG3, msg, &rawkeylen);

/* We need to convert 'void *rawkey' into 'RSA *key'.  */
if (dns_RSA_dns_to_x509(rawkey, rawkeylen, &key) == 0)
	found++;
else
	log_print("rsa_sig_decode_hash: KEY to RSA key "
	    "conversion failed");

free(rawkey);
}
758#endif				/* USE_DNSSEC */

/* If we still have not found a key, try to read it from a file. */
if (!found)
if (get_raw_key_from_file(IKE_AUTH_RSA_SIG3, id, id_len, &key)
    != -1)
	found++;

if (!found) {
log_print("rsa_sig_decode_hash: no public key found");
return -1;
}
p = payload_first(msg, ISAKMP_PAYLOAD_SIG9);
if (!p) {
log_print("rsa_sig_decode_hash: missing signature payload");
RSA_free(key);
return -1;
}
/* Check that the sig is of the correct size.  */
len = GET_ISAKMP_GEN_LENGTH(p->p)field_get_num (isakmp_gen_fld + 2, p->p) - ISAKMP_SIG_SZ4;
if (len != RSA_size(key)) {
RSA_free(key);
log_print("rsa_sig_decode_hash: "
    "SIG payload length does not match public key");
return -1;
}
*hash_p = malloc(len);
if (!*hash_p) {
RSA_free(key);
log_error("rsa_sig_decode_hash: malloc (%d) failed", len);
return -1;
}
len = RSA_public_decrypt(len, p->p + ISAKMP_SIG_DATA_OFF4, *hash_p, key,
   RSA_PKCS1_PADDING1);
if (len == -1) {
RSA_free(key);
log_print("rsa_sig_decode_hash: RSA_public_decrypt () failed");
return -1;
}
/* Store key for later use */
exchange->recv_key = key;
exchange->recv_keytype = ISAKMP_KEY_RSA2;

if (len != (int)hashsize) {
free(*hash_p);
*hash_p = 0;
log_print("rsa_sig_decode_hash: len %lu != hashsize %lu",
    (unsigned long)len, (unsigned long)hashsize);
return -1;
}
snprintf(header, sizeof header, "rsa_sig_decode_hash: HASH_%c",
   initiator ? 'R' : 'I');
LOG_DBG_BUF((LOG_MISC, 80, header, *hash_p, hashsize))log_debug_buf (LOG_MISC, 80, header, *hash_p, hashsize);

p->flags |= PL_MARK1;
return 0;
814}

816static int
817pre_shared_encode_hash(struct message *msg)
818{
struct exchange *exchange = msg->exchange;
struct ipsec_exch *ie = exchange->data;
size_t          hashsize = ie->hash->hashsize;
char            header[80];
int             initiator = exchange->initiator;
u_int8_t       *buf;

buf = ipsec_add_hash_payload(msg, hashsize);
if (!buf)
return -1;

if (ike_auth_hash(exchange, buf + ISAKMP_HASH_DATA_OFF4) == -1)
return -1;

snprintf(header, sizeof header, "pre_shared_encode_hash: HASH_%c",
   initiator ? 'I' : 'R');
LOG_DBG_BUF((LOG_MISC, 80, header, buf + ISAKMP_HASH_DATA_OFF,log_debug_buf (LOG_MISC, 80, header, buf + 4, hashsize)
   hashsize))log_debug_buf (LOG_MISC, 80, header, buf + 4, hashsize);
return 0;
838}

840/* Encrypt the HASH into a SIG type.  */
841static int
842rsa_sig_encode_hash(struct message *msg)
843{
struct exchange *exchange = msg->exchange;
struct ipsec_exch *ie = exchange->data;
size_t          hashsize = ie->hash->hashsize, id_len;
struct cert_handler *handler;
char            header[80];
int             initiator = exchange->initiator, idtype;
u_int8_t       *buf, *data, *buf2, *id;
u_int32_t       datalen;
int32_t         sigsize;
void           *sent_key;

id = initiator ? exchange->id_i : exchange->id_r;
1
Assuming 'initiator' is 0→
2
←
'?' condition is false→
id_len = initiator2.1
'initiator' is 0
 ? exchange->id_i_len : exchange->id_r_len;
3
←
'?' condition is false→

/* We may have been provided these by the kernel */
buf = (u_int8_t *)conf_get_str(exchange->name, "Credentials");
if (buf && (idtype = conf_get_num(exchange->name, "Credential_Type",
4
←
Assuming 'buf' is null→
   -1)) != -1) {
exchange->sent_certtype = idtype;
handler = cert_get(idtype);
if (!handler) {
	log_print("rsa_sig_encode_hash: cert_get (%d) failed",
	    idtype);
	return -1;
}
exchange->sent_cert =
    handler->cert_from_printable((char *)buf);
if (!exchange->sent_cert) {
	log_print("rsa_sig_encode_hash: failed to retrieve "
	    "certificate");
	return -1;
}
handler->cert_serialize(exchange->sent_cert, &data, &datalen);
if (!data) {
	log_print("rsa_sig_encode_hash: cert serialization "
	    "failed");
	return -1;
}
goto aftercert;	/* Skip all the certificate discovery */
}
/* XXX This needs to be configurable.  */
idtype = ISAKMP_CERTENC_KEYNOTE11;

/* Find a certificate with subjectAltName = id.  */
handler = cert_get(idtype);
if (!handler) {
5
←
Assuming 'handler' is null→
6
←
Taking true branch→
idtype = ISAKMP_CERTENC_X509_SIG4;
handler = cert_get(idtype);
if (!handler) {
7
←
Assuming 'handler' is non-null→
8
←
Taking false branch→
	log_print("rsa_sig_encode_hash: cert_get(%d) failed",
	    idtype);
	return -1;
}
}
if (handler->cert_obtain(id, id_len, 0, &data, &datalen) == 0) {
9
←
Assuming the condition is true→
10
←
Taking true branch→
if (idtype10.1
'idtype' is not equal to ISAKMP_CERTENC_KEYNOTE
 == ISAKMP_CERTENC_KEYNOTE11) {
11
←
Taking false branch→
	idtype = ISAKMP_CERTENC_X509_SIG4;
	handler = cert_get(idtype);
	if (!handler) {
		log_print("rsa_sig_encode_hash: cert_get(%d) "
		    "failed", idtype);
		return -1;
	}
	if (handler->cert_obtain(id, id_len, 0, &data,
	    &datalen) == 0) {
		LOG_DBG((LOG_MISC, 10, "rsa_sig_encode_hash: "log_debug (LOG_MISC, 10, "rsa_sig_encode_hash: " "no certificate to send for id %s"
, ipsec_id_string(id, id_len))
		    "no certificate to send for id %s",log_debug (LOG_MISC, 10, "rsa_sig_encode_hash: " "no certificate to send for id %s"
, ipsec_id_string(id, id_len))
		    ipsec_id_string(id, id_len)))log_debug (LOG_MISC, 10, "rsa_sig_encode_hash: " "no certificate to send for id %s"
, ipsec_id_string(id, id_len));
		goto skipcert;
	}
} else {
	LOG_DBG((LOG_MISC, 10,log_debug (LOG_MISC, 10, "rsa_sig_encode_hash: no certificate to send"
 " for id %s", ipsec_id_string(id, id_len))
	    "rsa_sig_encode_hash: no certificate to send"log_debug (LOG_MISC, 10, "rsa_sig_encode_hash: no certificate to send"
 " for id %s", ipsec_id_string(id, id_len))
	    " for id %s", ipsec_id_string(id, id_len)))log_debug (LOG_MISC, 10, "rsa_sig_encode_hash: no certificate to send"
 " for id %s", ipsec_id_string(id, id_len));
	goto skipcert;
12
←
Control jumps to line 949→
}
}
/* Let's store the certificate we are going to use */
exchange->sent_certtype = idtype;
exchange->sent_cert = handler->cert_get(data, datalen);
if (!exchange->sent_cert) {
free(data);
log_print("rsa_sig_encode_hash: failed to get certificate "
    "from wire encoding");
return -1;
}
930aftercert:

buf = realloc(data, ISAKMP_CERT_SZ5 + datalen);
if (!buf) {
log_error("rsa_sig_encode_hash: realloc (%p, %d) failed", data,
    ISAKMP_CERT_SZ5 + datalen);
free(data);
return -1;
}
memmove(buf + ISAKMP_CERT_SZ5, buf, datalen);
SET_ISAKMP_CERT_ENCODING(buf, idtype)field_set_num (isakmp_cert_fld + 0, buf, idtype);
if (message_add_payload(msg, ISAKMP_PAYLOAD_CERT6, buf,
   ISAKMP_CERT_SZ5 + datalen, 1)) {
free(buf);
return -1;
}
946skipcert:

/* Again, we may have these from the kernel */
buf = (u_int8_t *)conf_get_str(exchange->name, "PKAuthentication");
if (buf) {
13
←
Assuming 'buf' is null→
14
←
Taking false branch→
key_from_printable(ISAKMP_KEY_RSA2, ISAKMP_KEYTYPE_PRIVATE1,
    (char *)buf, &data, &datalen);
if (!data) {
	log_print("rsa_sig_encode_hash: badly formatted RSA "
	    "private key");
	return 0;
}
sent_key = key_internalize(ISAKMP_KEY_RSA2,
    ISAKMP_KEYTYPE_PRIVATE1, data, datalen);
if (!sent_key) {
	log_print("rsa_sig_encode_hash: bad RSA private key "
	    "from dynamic SA acquisition subsystem");
	return 0;
}
} else {
/* Try through the regular means.  */
switch (id[ISAKMP_ID_TYPE_OFF4 - ISAKMP_GEN_SZ4]) {
15
←
Control jumps to 'case 5:'  at line 969→
case IPSEC_ID_IPV4_ADDR1:
case IPSEC_ID_IPV6_ADDR5:
	util_ntoa((char **)&buf2,
	    id[ISAKMP_ID_TYPE_OFF4 - ISAKMP_GEN_SZ4] ==
16
←
'?' condition is false→
	    IPSEC_ID_IPV4_ADDR1 ? AF_INET2 : AF_INET624,
	    id + ISAKMP_ID_DATA_OFF8 - ISAKMP_GEN_SZ4);
	if (!buf2)
17
←
Assuming 'buf2' is non-null→
18
←
Taking false branch→
		return 0;
	break;
19
←
 Execution continues on line 998→

case IPSEC_ID_FQDN2:
case IPSEC_ID_USER_FQDN3:
	buf2 = calloc(id_len - ISAKMP_ID_DATA_OFF8 +
	    ISAKMP_GEN_SZ4 + 1, sizeof(char));
	if (!buf2) {
		log_print("rsa_sig_encode_hash: malloc (%lu) "
		    "failed", (unsigned long)id_len -
		    ISAKMP_ID_DATA_OFF8 + ISAKMP_GEN_SZ4 + 1);
		return 0;
	}
	memcpy(buf2, id + ISAKMP_ID_DATA_OFF8 - ISAKMP_GEN_SZ4,
	    id_len - ISAKMP_ID_DATA_OFF8 + ISAKMP_GEN_SZ4);
	break;

	/* XXX Support more ID types?  */
default:
	buf2 = 0;
	return 0;
}

sent_key = ike_auth_get_key(IKE_AUTH_RSA_SIG3, exchange->name,
20
←
Calling 'ike_auth_get_key'→
    (char *)buf2, 0);
free(buf2);

/* Did we find a key?  */
if (!sent_key) {
	log_print("rsa_sig_encode_hash: "
	    "could not get private key");
	return -1;
}
}

/* Enable RSA blinding.  */
if (RSA_blinding_on(sent_key, NULL((void*)0)) != 1) {
log_error("rsa_sig_encode_hash: RSA_blinding_on () failed.");
RSA_free(sent_key);
return -1;
}
/* XXX hashsize is not necessarily prf->blocksize.  */
buf = malloc(hashsize);
if (!buf) {
log_error("rsa_sig_encode_hash: malloc (%lu) failed",
    (unsigned long)hashsize);
RSA_free(sent_key);
return -1;
}
if (ike_auth_hash(exchange, buf) == -1) {
free(buf);
RSA_free(sent_key);
return -1;
}
snprintf(header, sizeof header, "rsa_sig_encode_hash: HASH_%c",
   initiator ? 'I' : 'R');
LOG_DBG_BUF((LOG_MISC, 80, header, buf, hashsize))log_debug_buf (LOG_MISC, 80, header, buf, hashsize);

data = malloc(RSA_size(sent_key));
if (!data) {
log_error("rsa_sig_encode_hash: malloc (%d) failed",
    RSA_size(sent_key));
free(buf);
RSA_free(sent_key);
return -1;
}
sigsize = RSA_private_encrypt(hashsize, buf, data, sent_key,
   RSA_PKCS1_PADDING1);
if (sigsize == -1) {
log_print("rsa_sig_encode_hash: "
    "RSA_private_encrypt () failed");
free(data);
free(buf);
RSA_free(sent_key);
return -1;
}
datalen = (u_int32_t) sigsize;

free(buf);
RSA_free(sent_key);

buf = realloc(data, ISAKMP_SIG_SZ4 + datalen);
if (!buf) {
log_error("rsa_sig_encode_hash: realloc (%p, %d) failed", data,
    ISAKMP_SIG_SZ4 + datalen);
free(data);
return -1;
}
memmove(buf + ISAKMP_SIG_SZ4, buf, datalen);

snprintf(header, sizeof header, "rsa_sig_encode_hash: SIG_%c",
   initiator ? 'I' : 'R');
LOG_DBG_BUF((LOG_MISC, 80, header, buf + ISAKMP_SIG_DATA_OFF,log_debug_buf (LOG_MISC, 80, header, buf + 4, datalen)
   datalen))log_debug_buf (LOG_MISC, 80, header, buf + 4, datalen);
if (message_add_payload(msg, ISAKMP_PAYLOAD_SIG9, buf,
   ISAKMP_SIG_SZ4 + datalen, 1)) {
free(buf);
return -1;
}
return 0;
1075}

1077int
1078ike_auth_hash(struct exchange *exchange, u_int8_t *buf)
1079{
struct ipsec_exch *ie = exchange->data;
struct prf     *prf;
struct hash    *hash = ie->hash;
int             initiator = exchange->initiator;
u_int8_t       *id;
size_t          id_len;

/* Choose the right fields to fill-in.  */
id = initiator ? exchange->id_i : exchange->id_r;
id_len = initiator ? exchange->id_i_len : exchange->id_r_len;

/* Allocate the prf and start calculating our HASH.  */
prf = prf_alloc(ie->prf_type, hash->type, ie->skeyid, ie->skeyid_len);
if (!prf)
return -1;

prf->Init(prf->prfctx);
prf->Update(prf->prfctx, initiator ? ie->g_xi : ie->g_xr, ie->g_x_len);
prf->Update(prf->prfctx, initiator ? ie->g_xr : ie->g_xi, ie->g_x_len);
prf->Update(prf->prfctx, exchange->cookies +
   (initiator ? ISAKMP_HDR_ICOOKIE_OFF0 : ISAKMP_HDR_RCOOKIE_OFF8),
   ISAKMP_HDR_ICOOKIE_LEN8);
prf->Update(prf->prfctx, exchange->cookies +
   (initiator ? ISAKMP_HDR_RCOOKIE_OFF8 : ISAKMP_HDR_ICOOKIE_OFF0),
   ISAKMP_HDR_ICOOKIE_LEN8);
prf->Update(prf->prfctx, ie->sa_i_b, ie->sa_i_b_len);
prf->Update(prf->prfctx, id, id_len);
prf->Final(buf, prf->prfctx);
prf_free(prf);
return 0;
1110}

1112static int
1113get_raw_key_from_file(int type, u_int8_t *id, size_t id_len, RSA **rsa)
1114{
char            filename[FILENAME_MAX1024];
char           *fstr;
FILE           *keyfp;

if (type != IKE_AUTH_RSA_SIG3) {	/* XXX More types? */
LOG_DBG((LOG_NEGOTIATION, 20, "get_raw_key_from_file: "log_debug (LOG_NEGOTIATION, 20, "get_raw_key_from_file: " "invalid auth type %d\n"
, type)
    "invalid auth type %d\n", type))log_debug (LOG_NEGOTIATION, 20, "get_raw_key_from_file: " "invalid auth type %d\n"
, type);
return -1;
}
*rsa = 0;

fstr = conf_get_str("General", "Pubkey-directory");
if (!fstr)
fstr = CONF_DFLT_PUBKEY_DIR"/etc/isakmpd/" "pubkeys/";

if (snprintf(filename, sizeof filename, "%s/", fstr) >
   (int)sizeof filename - 1)
return -1;

fstr = ipsec_id_string(id, id_len);
if (!fstr) {
LOG_DBG((LOG_NEGOTIATION, 50, "get_raw_key_from_file: "log_debug (LOG_NEGOTIATION, 50, "get_raw_key_from_file: " "ipsec_id_string failed"
)
    "ipsec_id_string failed"))log_debug (LOG_NEGOTIATION, 50, "get_raw_key_from_file: " "ipsec_id_string failed"
);
return -1;
}
strlcat(filename, fstr, sizeof filename - strlen(filename));
free(fstr);

/* If the file does not exist, fail silently.  */
keyfp = monitor_fopen(filename, "r");
if (keyfp) {
*rsa = PEM_read_RSA_PUBKEY(keyfp, NULL((void*)0), NULL((void*)0), NULL((void*)0));
if (!*rsa) {
	rewind(keyfp);
	*rsa = PEM_read_RSAPublicKey(keyfp, NULL((void*)0), NULL((void*)0), NULL((void*)0));
}
if (!*rsa)
	log_print("get_raw_key_from_file: failed to get "
	    "public key %s", filename);
fclose(keyfp);
} else if (errno(*__errno()) != ENOENT2) {
log_error("get_raw_key_from_file: monitor_fopen "
    "(\"%s\", \"r\") failed", filename);
return -1;
} else
LOG_DBG((LOG_NEGOTIATION, 50,log_debug (LOG_NEGOTIATION, 50, "get_raw_key_from_file: file %s not found"
, filename)
    "get_raw_key_from_file: file %s not found", filename))log_debug (LOG_NEGOTIATION, 50, "get_raw_key_from_file: file %s not found"
, filename);

return (*rsa ? 0 : -1);
1164}