int
ca_key_serialize(EVP_PKEY *key, struct iked_id *id)
{
int len;
u_int8_t *d;
RSA *rsa;
switch (key->type) {
case EVP_PKEY_RSA:
id->id_type = 0;
id->id_offset = 0;
ibuf_release(id->id_buf);
if ((rsa = EVP_PKEY_get1_RSA(key)) == NULL)
return (-1);
if ((len = i2d_RSAPrivateKey(rsa, NULL)) <= 0)
return (-1);
if ((id->id_buf = ibuf_new(NULL, len)) == NULL)
return (-1);
d = ibuf_data(id->id_buf);
if (i2d_RSAPrivateKey(rsa, &d) != len) {
ibuf_release(id->id_buf);
return (-1);
}
id->id_type = IKEV2_CERT_RSA_KEY;
break;
default:
log_debug("%s: unsupported key type %d", __func__, key->type);
return (-1);
}
return (0);
}
int
ca_getauth(struct iked *env, struct imsg *imsg)
{
struct ca_store *store = env->sc_priv;
struct iked_sahdr sh;
uint8_t method;
uint8_t *ptr;
size_t len;
unsigned int i;
int ret = -1;
struct iked_sa sa;
struct iked_policy policy;
struct iked_id *id;
struct ibuf *authmsg;
ptr = (uint8_t *)imsg->data;
len = IMSG_DATA_SIZE(imsg);
i = sizeof(method) + sizeof(sh);
if (len <= i)
return (-1);
memcpy(&sh, ptr, sizeof(sh));
memcpy(&method, ptr + sizeof(sh), sizeof(uint8_t));
if (method == IKEV2_AUTH_SHARED_KEY_MIC)
return (-1);
ptr += i;
len -= i;
if ((authmsg = ibuf_new(ptr, len)) == NULL)
return (-1);
/*
* Create fake SA and policy
*/
bzero(&sa, sizeof(sa));
bzero(&policy, sizeof(policy));
memcpy(&sa.sa_hdr, &sh, sizeof(sh));
sa.sa_policy = &policy;
policy.pol_auth.auth_method = method;
if (sh.sh_initiator)
id = &sa.sa_icert;
else
id = &sa.sa_rcert;
memcpy(id, &store->ca_privkey, sizeof(*id));
if (ikev2_msg_authsign(env, &sa, &policy.pol_auth, authmsg) != 0) {
log_debug("%s: AUTH sign failed", __func__);
policy.pol_auth.auth_method = IKEV2_AUTH_NONE;
}
ret = ca_setauth(env, &sa, sa.sa_localauth.id_buf, PROC_IKEV2);
ibuf_release(sa.sa_localauth.id_buf);
ibuf_release(authmsg);
return (ret);
}
int
ikev2_pld_ke(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, off_t offset)
{
struct ikev2_keyexchange kex;
u_int8_t *buf;
size_t len;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
memcpy(&kex, msgbuf + offset, sizeof(kex));
log_debug("%s: dh group %s reserved %d", __func__,
print_map(betoh16(kex.kex_dhgroup), ikev2_xformdh_map),
betoh16(kex.kex_reserved));
buf = msgbuf + offset + sizeof(kex);
len = betoh16(pld->pld_length) - sizeof(*pld) - sizeof(kex);
print_hex(buf, 0, len);
if (ikev2_msg_frompeer(msg)) {
ibuf_release(msg->msg_parent->msg_ke);
if ((msg->msg_parent->msg_ke = ibuf_new(buf, len)) == NULL) {
log_debug("%s: failed to get exchange", __func__);
return (-1);
}
}
return (0);
}
int
ikev2_msg_integr(struct iked *env, struct iked_sa *sa, struct ibuf *src)
{
int ret = -1;
size_t integrlen, tmplen;
struct ibuf *integr, *prf, *tmp = NULL;
u_int8_t *ptr;
log_debug("%s: message length %d", __func__, ibuf_size(src));
print_hex(ibuf_data(src), 0, ibuf_size(src));
if (sa == NULL ||
sa->sa_integr == NULL) {
log_debug("%s: invalid SA", __func__);
return (-1);
}
if (sa->sa_hdr.sh_initiator) {
integr = sa->sa_key_iauth;
prf = sa->sa_key_iprf;
} else {
integr = sa->sa_key_rauth;
prf = sa->sa_key_rprf;
}
integrlen = hash_length(sa->sa_integr);
log_debug("%s: integrity checksum length %d", __func__,
integrlen);
/*
* Validate packet checksum
*/
if ((tmp = ibuf_new(NULL, hash_keylength(sa->sa_integr))) == NULL)
goto done;
hash_setkey(sa->sa_integr, ibuf_data(integr), ibuf_size(integr));
hash_init(sa->sa_integr);
hash_update(sa->sa_integr, ibuf_data(src),
ibuf_size(src) - integrlen);
hash_final(sa->sa_integr, ibuf_data(tmp), &tmplen);
if (tmplen != integrlen) {
log_debug("%s: hash failure", __func__);
goto done;
}
if ((ptr = ibuf_seek(src,
ibuf_size(src) - integrlen, integrlen)) == NULL)
goto done;
memcpy(ptr, ibuf_data(tmp), tmplen);
print_hex(ibuf_data(tmp), 0, ibuf_size(tmp));
ret = 0;
done:
ibuf_release(tmp);
return (ret);
}
int
ca_x509_subjectaltname_cmp(X509 *cert, struct iked_static_id *id)
{
struct iked_id sanid;
char idstr[IKED_ID_SIZE];
int ret = -1;
bzero(&sanid, sizeof(sanid));
if (ca_x509_subjectaltname(cert, &sanid) != 0)
return (-1);
ikev2_print_id(&sanid, idstr, sizeof(idstr));
/* Compare id types, length and data */
if ((id->id_type != sanid.id_type) ||
((ssize_t)ibuf_size(sanid.id_buf) !=
(id->id_length - id->id_offset)) ||
(memcmp(id->id_data + id->id_offset,
ibuf_data(sanid.id_buf),
ibuf_size(sanid.id_buf)) != 0)) {
log_debug("%s: %s mismatched", __func__, idstr);
goto done;
}
ret = 0;
done:
ibuf_release(sanid.id_buf);
return (ret);
}
struct ibuf *
ikev2_msg_auth(struct iked *env, struct iked_sa *sa, int response)
{
struct ibuf *authmsg = NULL, *nonce, *prfkey, *buf;
uint8_t *ptr;
struct iked_id *id;
size_t tmplen;
/*
* Create the payload to be signed/MAC'ed for AUTH
*/
if (!response) {
if ((nonce = sa->sa_rnonce) == NULL ||
(sa->sa_iid.id_type == 0) ||
(prfkey = sa->sa_key_iprf) == NULL ||
(buf = sa->sa_1stmsg) == NULL)
return (NULL);
id = &sa->sa_iid;
} else {
if ((nonce = sa->sa_inonce) == NULL ||
(sa->sa_rid.id_type == 0) ||
(prfkey = sa->sa_key_rprf) == NULL ||
(buf = sa->sa_2ndmsg) == NULL)
return (NULL);
id = &sa->sa_rid;
}
if ((authmsg = ibuf_dup(buf)) == NULL)
return (NULL);
if (ibuf_cat(authmsg, nonce) != 0)
goto fail;
if ((hash_setkey(sa->sa_prf, ibuf_data(prfkey),
ibuf_size(prfkey))) == NULL)
goto fail;
if ((ptr = ibuf_advance(authmsg,
hash_length(sa->sa_prf))) == NULL)
goto fail;
hash_init(sa->sa_prf);
hash_update(sa->sa_prf, ibuf_data(id->id_buf), ibuf_size(id->id_buf));
hash_final(sa->sa_prf, ptr, &tmplen);
if (tmplen != hash_length(sa->sa_prf))
goto fail;
log_debug("%s: %s auth data length %zu",
__func__, response ? "responder" : "initiator",
ibuf_size(authmsg));
print_hex(ibuf_data(authmsg), 0, ibuf_size(authmsg));
return (authmsg);
fail:
ibuf_release(authmsg);
return (NULL);
}
int
ikev2_pld_id(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, size_t offset, size_t left, u_int payload)
{
u_int8_t *ptr;
struct ikev2_id id;
size_t len;
struct iked_id *idp, idb;
struct iked_sa *sa = msg->msg_sa;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
char idstr[IKED_ID_SIZE];
if (ikev2_validate_id(msg, offset, left, pld, &id))
return (-1);
bzero(&idb, sizeof(idb));
/* Don't strip the Id payload header */
ptr = msgbuf + offset;
len = betoh16(pld->pld_length) - sizeof(*pld);
idb.id_type = id.id_type;
idb.id_offset = sizeof(id);
if ((idb.id_buf = ibuf_new(ptr, len)) == NULL)
return (-1);
if (ikev2_print_id(&idb, idstr, sizeof(idstr)) == -1) {
log_debug("%s: malformed id", __func__);
return (-1);
}
log_debug("%s: id %s length %zu", __func__, idstr, len);
if (!ikev2_msg_frompeer(msg)) {
ibuf_release(idb.id_buf);
return (0);
}
if (!((sa->sa_hdr.sh_initiator && payload == IKEV2_PAYLOAD_IDr) ||
(!sa->sa_hdr.sh_initiator && payload == IKEV2_PAYLOAD_IDi))) {
log_debug("%s: unexpected id payload", __func__);
return (0);
}
idp = &msg->msg_parent->msg_id;
if (idp->id_type) {
log_debug("%s: duplicate id payload", __func__);
return (-1);
}
idp->id_buf = idb.id_buf;
idp->id_offset = idb.id_offset;
idp->id_type = idb.id_type;
return (0);
}
struct ibuf *
hash_setkey(struct iked_hash *hash, void *key, size_t keylen)
{
ibuf_release(hash->hash_key);
if ((hash->hash_key = ibuf_new(key, keylen)) == NULL) {
log_debug("%s: alloc hash key", __func__);
return (NULL);
}
return (hash->hash_key);
}
struct ibuf *
cipher_setkey(struct iked_cipher *encr, void *key, size_t keylen)
{
ibuf_release(encr->encr_key);
if ((encr->encr_key = ibuf_new(key, keylen)) == NULL) {
log_debug("%s: alloc cipher key", __func__);
return (NULL);
}
return (encr->encr_key);
}
int
ca_privkey_serialize(EVP_PKEY *key, struct iked_id *id)
{
RSA *rsa = NULL;
uint8_t *d;
int len = 0;
int ret = -1;
switch (key->type) {
case EVP_PKEY_RSA:
id->id_type = 0;
id->id_offset = 0;
ibuf_release(id->id_buf);
if ((rsa = EVP_PKEY_get1_RSA(key)) == NULL)
goto done;
if ((len = i2d_RSAPrivateKey(rsa, NULL)) <= 0)
goto done;
if ((id->id_buf = ibuf_new(NULL, len)) == NULL)
goto done;
d = ibuf_data(id->id_buf);
if (i2d_RSAPrivateKey(rsa, &d) != len) {
ibuf_release(id->id_buf);
goto done;
}
id->id_type = IKEV2_CERT_RSA_KEY;
break;
default:
log_debug("%s: unsupported key type %d", __func__, key->type);
return (-1);
}
log_debug("%s: type %s length %d", __func__,
print_map(id->id_type, ikev2_cert_map), len);
ret = 0;
done:
if (rsa != NULL)
RSA_free(rsa);
return (ret);
}
int
eap_challenge_request(struct iked *env, struct iked_sa *sa,
struct eap_header *hdr)
{
struct eap_message *eap;
struct eap_mschap_challenge *ms;
const char *name;
int ret = -1;
struct ibuf *e;
if ((e = ibuf_static()) == NULL)
return (-1);
if ((eap = ibuf_advance(e, sizeof(*eap))) == NULL)
goto done;
eap->eap_code = EAP_CODE_REQUEST;
eap->eap_id = hdr->eap_id + 1;
eap->eap_type = sa->sa_policy->pol_auth.auth_eap;
switch (sa->sa_policy->pol_auth.auth_eap) {
case EAP_TYPE_MSCHAP_V2:
name = IKED_USER; /* XXX should be user-configurable */
eap->eap_length = htobe16(sizeof(*eap) +
sizeof(*ms) + strlen(name));
if ((ms = ibuf_advance(e, sizeof(*ms))) == NULL)
return (-1);
ms->msc_opcode = EAP_MSOPCODE_CHALLENGE;
ms->msc_id = eap->eap_id;
ms->msc_length = htobe16(sizeof(*ms) + strlen(name));
ms->msc_valuesize = sizeof(ms->msc_challenge);
arc4random_buf(ms->msc_challenge, sizeof(ms->msc_challenge));
if (ibuf_add(e, name, strlen(name)) == -1)
goto done;
/* Store the EAP challenge value */
sa->sa_eap.id_type = eap->eap_type;
if ((sa->sa_eap.id_buf = ibuf_new(ms->msc_challenge,
sizeof(ms->msc_challenge))) == NULL)
goto done;
break;
default:
log_debug("%s: unsupported EAP type %s", __func__,
print_map(eap->eap_type, eap_type_map));
goto done;
}
ret = ikev2_send_ike_e(env, sa, e,
IKEV2_PAYLOAD_EAP, IKEV2_EXCHANGE_IKE_AUTH, 1);
done:
ibuf_release(e);
return (ret);
}
void
hash_free(struct iked_hash *hash)
{
if (hash == NULL)
return;
if (hash->hash_ctx != NULL) {
HMAC_CTX_cleanup(hash->hash_ctx);
free(hash->hash_ctx);
}
ibuf_release(hash->hash_key);
free(hash);
}
void
cipher_free(struct iked_cipher *encr)
{
if (encr == NULL)
return;
if (encr->encr_ctx != NULL) {
EVP_CIPHER_CTX_cleanup(encr->encr_ctx);
free(encr->encr_ctx);
}
ibuf_release(encr->encr_key);
free(encr);
}
int
ikev2_pld_e(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, off_t offset)
{
struct iked_sa *sa = msg->msg_sa;
struct ibuf *e = NULL;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
struct iked_message emsg;
u_int8_t *buf;
size_t len;
int ret = -1;
buf = msgbuf + offset;
len = betoh16(pld->pld_length) - sizeof(*pld);
if ((e = ibuf_new(buf, len)) == NULL)
goto done;
if (ikev2_msg_frompeer(msg)) {
e = ikev2_msg_decrypt(env, msg->msg_sa, msg->msg_data, e);
} else {
sa->sa_hdr.sh_initiator = sa->sa_hdr.sh_initiator ? 0 : 1;
e = ikev2_msg_decrypt(env, msg->msg_sa, msg->msg_data, e);
sa->sa_hdr.sh_initiator = sa->sa_hdr.sh_initiator ? 0 : 1;
}
if (e == NULL)
goto done;
/*
* Parse decrypted payload
*/
bzero(&emsg, sizeof(emsg));
memcpy(&emsg, msg, sizeof(*msg));
emsg.msg_data = e;
emsg.msg_e = 1;
emsg.msg_parent = msg;
TAILQ_INIT(&emsg.msg_proposals);
ret = ikev2_pld_payloads(env, &emsg, 0, ibuf_size(e),
pld->pld_nextpayload, 0);
done:
ibuf_release(e);
return (ret);
}
int
ca_setreq(struct iked *env, struct iked_sa *sa,
struct iked_static_id *localid, uint8_t type, uint8_t *data,
size_t len, enum privsep_procid procid)
{
struct iovec iov[4];
int iovcnt = 0;
struct iked_static_id idb;
struct iked_id id;
int ret = -1;
/* Convert to a static Id */
bzero(&id, sizeof(id));
if (ikev2_policy2id(localid, &id, 1) != 0)
return (-1);
bzero(&idb, sizeof(idb));
idb.id_type = id.id_type;
idb.id_offset = id.id_offset;
idb.id_length = ibuf_length(id.id_buf);
memcpy(&idb.id_data, ibuf_data(id.id_buf),
ibuf_length(id.id_buf));
iov[iovcnt].iov_base = &idb;
iov[iovcnt].iov_len = sizeof(idb);
iovcnt++;
iov[iovcnt].iov_base = &sa->sa_hdr;
iov[iovcnt].iov_len = sizeof(sa->sa_hdr);
iovcnt++;
iov[iovcnt].iov_base = &type;
iov[iovcnt].iov_len = sizeof(type);
iovcnt++;
iov[iovcnt].iov_base = data;
iov[iovcnt].iov_len = len;
iovcnt++;
if (proc_composev(&env->sc_ps, procid, IMSG_CERTREQ, iov, iovcnt) == -1)
goto done;
sa_stateflags(sa, IKED_REQ_CERTREQ);
ret = 0;
done:
ibuf_release(id.id_buf);
return (ret);
}
int
ikev2_pld_auth(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, size_t offset, size_t left)
{
struct ikev2_auth auth;
struct iked_id *idp;
u_int8_t *buf;
size_t len;
struct iked_sa *sa = msg->msg_sa;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
if (ikev2_validate_auth(msg, offset, left, pld, &auth))
return (-1);
offset += sizeof(auth);
buf = msgbuf + offset;
len = betoh16(pld->pld_length) - sizeof(*pld) - sizeof(auth);
log_debug("%s: method %s length %zu",
__func__, print_map(auth.auth_method, ikev2_auth_map), len);
print_hex(buf, 0, len);
if (!ikev2_msg_frompeer(msg))
return (0);
/* The AUTH payload indicates if the responder wants EAP or not */
if (!sa_stateok(sa, IKEV2_STATE_EAP))
sa_state(env, sa, IKEV2_STATE_AUTH_REQUEST);
idp = &msg->msg_parent->msg_auth;
if (idp->id_type) {
log_debug("%s: duplicate auth payload", __func__);
return (-1);
}
ibuf_release(idp->id_buf);
idp->id_type = auth.auth_method;
idp->id_offset = 0;
if ((idp->id_buf = ibuf_new(buf, len)) == NULL)
return (-1);
return (0);
}
void
dsa_free(struct iked_dsa *dsa)
{
if (dsa == NULL)
return;
if (dsa->dsa_hmac) {
HMAC_CTX_cleanup((HMAC_CTX *)dsa->dsa_ctx);
free(dsa->dsa_ctx);
} else {
EVP_MD_CTX_destroy((EVP_MD_CTX *)dsa->dsa_ctx);
if (dsa->dsa_key)
EVP_PKEY_free(dsa->dsa_key);
if (dsa->dsa_cert)
X509_free(dsa->dsa_cert);
}
ibuf_release(dsa->dsa_keydata);
free(dsa);
}
int
ikev2_pld_ke(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, size_t offset, size_t left)
{
struct ikev2_keyexchange kex;
u_int8_t *buf;
size_t len;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
if (ikev2_validate_ke(msg, offset, left, pld, &kex))
return (-1);
log_debug("%s: dh group %s reserved %d", __func__,
print_map(betoh16(kex.kex_dhgroup), ikev2_xformdh_map),
betoh16(kex.kex_reserved));
buf = msgbuf + offset + sizeof(kex);
len = betoh16(pld->pld_length) - sizeof(*pld) - sizeof(kex);
if (len == 0) {
log_debug("%s: malformed payload: no KE data given", __func__);
return (-1);
}
/* This will actually be caught by earlier checks. */
if (left < len) {
log_debug("%s: malformed payload: smaller than specified "
"(%zu < %zu)", __func__, left, len);
return (-1);
}
print_hex(buf, 0, len);
if (ikev2_msg_frompeer(msg)) {
ibuf_release(msg->msg_parent->msg_ke);
if ((msg->msg_parent->msg_ke = ibuf_new(buf, len)) == NULL) {
log_debug("%s: failed to get exchange", __func__);
return (-1);
}
}
return (0);
}
int
ca_pubkey_serialize(EVP_PKEY *key, struct iked_id *id)
{
RSA *rsa;
BIO *out = NULL;
u_int8_t *d;
int len = 0;
int ret = -1;
switch (key->type) {
case EVP_PKEY_RSA:
id->id_type = 0;
id->id_offset = 0;
ibuf_release(id->id_buf);
if ((rsa = EVP_PKEY_get1_RSA(key)) == NULL)
goto done;
if ((out = BIO_new(BIO_s_mem())) == NULL)
goto done;
if (!i2d_RSAPublicKey_bio(out, rsa))
goto done;
len = BIO_get_mem_data(out, &d);
if ((id->id_buf = ibuf_new(d, len)) == NULL)
goto done;
id->id_type = IKEV2_CERT_RSA_KEY;
break;
default:
log_debug("%s: unsupported key type %d", __func__, key->type);
return (-1);
}
log_debug("%s: type %s length %d", __func__,
print_map(id->id_type, ikev2_cert_map), len);
ret = 0;
done:
if (out != NULL)
BIO_free(out);
return (ret);
}
struct ibuf *
cipher_setiv(struct iked_cipher *encr, void *iv, size_t len)
{
ibuf_release(encr->encr_iv);
if (iv != NULL) {
if (len < encr->encr_ivlength) {
log_debug("%s: invalid IV length %zu", __func__, len);
return (NULL);
}
encr->encr_iv = ibuf_new(iv, encr->encr_ivlength);
} else {
/* Get new random IV */
encr->encr_iv = ibuf_random(encr->encr_ivlength);
}
if (encr->encr_iv == NULL) {
log_debug("%s: failed to set IV", __func__);
return (NULL);
}
return (encr->encr_iv);
}
int
ikev2_pld_nonce(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, size_t offset, size_t left)
{
size_t len;
u_int8_t *buf;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
if (ikev2_validate_nonce(msg, offset, left, pld))
return (-1);
buf = msgbuf + offset;
len = betoh16(pld->pld_length) - sizeof(*pld);
if (len == 0) {
log_debug("%s: malformed payload: no NONCE given", __func__);
return (-1);
}
/* This will actually be caught by earlier checks. */
if (left < len) {
log_debug("%s: malformed payload: smaller than specified "
"(%zu < %zu)", __func__, left, len);
return (-1);
}
print_hex(buf, 0, len);
if (ikev2_msg_frompeer(msg)) {
ibuf_release(msg->msg_nonce);
if ((msg->msg_nonce = ibuf_new(buf, len)) == NULL) {
log_debug("%s: failed to get peer nonce", __func__);
return (-1);
}
msg->msg_parent->msg_nonce = msg->msg_nonce;
}
return (0);
}
int
ikev2_pld_nonce(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, off_t offset)
{
size_t len;
u_int8_t *buf;
u_int8_t *msgbuf = ibuf_data(msg->msg_data);
buf = msgbuf + offset;
len = betoh16(pld->pld_length) - sizeof(*pld);
print_hex(buf, 0, len);
if (ikev2_msg_frompeer(msg)) {
ibuf_release(msg->msg_nonce);
if ((msg->msg_nonce = ibuf_new(buf, len)) == NULL) {
log_debug("%s: failed to get peer nonce", __func__);
return (-1);
}
msg->msg_parent->msg_nonce = msg->msg_nonce;
}
return (0);
}
void
ikev2_msg_cleanup(struct iked *env, struct iked_message *msg)
{
if (msg == msg->msg_parent) {
ibuf_release(msg->msg_nonce);
ibuf_release(msg->msg_ke);
ibuf_release(msg->msg_auth.id_buf);
ibuf_release(msg->msg_id.id_buf);
ibuf_release(msg->msg_cert.id_buf);
config_free_proposals(&msg->msg_proposals, 0);
}
if (msg->msg_data != NULL) {
ibuf_release(msg->msg_data);
msg->msg_data = NULL;
}
}
int
eap_success(struct iked *env, struct iked_sa *sa, struct eap_header *hdr)
{
struct eap_header *resp;
int ret = -1;
struct ibuf *e;
if ((e = ibuf_static()) == NULL)
return (-1);
if ((resp = ibuf_advance(e, sizeof(*resp))) == NULL)
goto done;
resp->eap_code = EAP_CODE_SUCCESS;
resp->eap_id = hdr->eap_id;
resp->eap_length = htobe16(sizeof(*resp));
ret = ikev2_send_ike_e(env, sa, e,
IKEV2_PAYLOAD_EAP, IKEV2_EXCHANGE_IKE_AUTH, 1);
done:
ibuf_release(e);
return (ret);
}
int
ca_x509_subjectaltname(X509 *cert, struct iked_id *id)
{
X509_EXTENSION *san;
uint8_t sanhdr[4], *data;
int ext, santype, sanlen;
char idstr[IKED_ID_SIZE];
if ((ext = X509_get_ext_by_NID(cert,
NID_subject_alt_name, -1)) == -1 ||
((san = X509_get_ext(cert, ext)) == NULL)) {
log_debug("%s: did not find subjectAltName in certificate",
__func__);
return (-1);
}
if (san->value == NULL || san->value->data == NULL ||
san->value->length < (int)sizeof(sanhdr)) {
log_debug("%s: invalid subjectAltName in certificate",
__func__);
return (-1);
}
/* This is partially based on isakmpd's x509 subjectaltname code */
data = (uint8_t *)san->value->data;
memcpy(&sanhdr, data, sizeof(sanhdr));
santype = sanhdr[2] & 0x3f;
sanlen = sanhdr[3];
if ((sanlen + (int)sizeof(sanhdr)) > san->value->length) {
log_debug("%s: invalid subjectAltName length", __func__);
return (-1);
}
switch (santype) {
case GEN_DNS:
id->id_type = IKEV2_ID_FQDN;
break;
case GEN_EMAIL:
id->id_type = IKEV2_ID_UFQDN;
break;
case GEN_IPADD:
if (sanlen == 4)
id->id_type = IKEV2_ID_IPV4;
else if (sanlen == 16)
id->id_type = IKEV2_ID_IPV6;
else {
log_debug("%s: invalid subjectAltName IP address",
__func__);
return (-1);
}
break;
default:
log_debug("%s: unsupported subjectAltName type %d",
__func__, santype);
return (-1);
}
ibuf_release(id->id_buf);
if ((id->id_buf = ibuf_new(data + sizeof(sanhdr), sanlen)) == NULL) {
log_debug("%s: failed to get id buffer", __func__);
return (-1);
}
id->id_offset = 0;
ikev2_print_id(id, idstr, sizeof(idstr));
log_debug("%s: %s", __func__, idstr);
return (0);
}
int
eap_mschap(struct iked *env, struct iked_sa *sa, struct eap_message *eap)
{
struct iked_user *usr;
struct eap_message *resp;
struct eap_mschap_response *msr;
struct eap_mschap_peer *msp;
struct eap_mschap *ms;
struct eap_mschap_success *mss;
u_int8_t *ptr, *pass;
size_t len, passlen;
char *name, *msg;
u_int8_t ntresponse[EAP_MSCHAP_NTRESPONSE_SZ];
u_int8_t successmsg[EAP_MSCHAP_SUCCESS_SZ];
struct ibuf *eapmsg = NULL;
int ret = -1;
if (!sa_stateok(sa, IKEV2_STATE_EAP)) {
log_debug("%s: unexpected EAP", __func__);
return (0); /* ignore */
}
if (sa->sa_hdr.sh_initiator) {
log_debug("%s: initiator EAP not supported", __func__);
return (-1);
}
/* Only MSCHAP-V2 */
if (eap->eap_type != EAP_TYPE_MSCHAP_V2) {
log_debug("%s: unsupported type EAP-%s", __func__,
print_map(eap->eap_type, eap_type_map));
return (-1);
}
if (betoh16(eap->eap_length) < (sizeof(*eap) + sizeof(*ms))) {
log_debug("%s: short message", __func__);
return (-1);
}
ms = (struct eap_mschap *)(eap + 1);
ptr = (u_int8_t *)(eap + 1);
switch (ms->ms_opcode) {
case EAP_MSOPCODE_RESPONSE:
msr = (struct eap_mschap_response *)ms;
if (betoh16(eap->eap_length) < (sizeof(*eap) + sizeof(*msr))) {
log_debug("%s: short response", __func__);
return (-1);
}
ptr += sizeof(*msr);
len = betoh16(eap->eap_length) -
sizeof(*eap) - sizeof(*msr);
if (len == 0 && sa->sa_eapid != NULL)
name = strdup(sa->sa_eapid);
else
name = get_string(ptr, len);
if (name == NULL) {
log_debug("%s: invalid response name", __func__);
return (-1);
}
if ((usr = user_lookup(env, name)) == NULL) {
log_debug("%s: unknown user '%s'", __func__, name);
free(name);
return (-1);
}
free(name);
if ((pass = string2unicode(usr->usr_pass, &passlen)) == NULL)
return (-1);
msp = &msr->msr_response.resp_peer;
mschap_nt_response(ibuf_data(sa->sa_eap.id_buf),
msp->msp_challenge, usr->usr_name, strlen(usr->usr_name),
pass, passlen, ntresponse);
if (memcmp(ntresponse, msp->msp_ntresponse,
sizeof(ntresponse)) != 0) {
log_debug("%s: '%s' authentication failed", __func__,
usr->usr_name);
free(pass);
/* XXX should we send an EAP failure packet? */
return (-1);
}
bzero(&successmsg, sizeof(successmsg));
mschap_auth_response(pass, passlen,
ntresponse, ibuf_data(sa->sa_eap.id_buf),
msp->msp_challenge, usr->usr_name, strlen(usr->usr_name),
successmsg);
if ((sa->sa_eapmsk = ibuf_new(NULL, MSCHAP_MSK_SZ)) == NULL) {
log_debug("%s: failed to get MSK", __func__);
free(pass);
return (-1);
}
mschap_msk(pass, passlen, ntresponse,
ibuf_data(sa->sa_eapmsk));
free(pass);
log_info("%s: '%s' authenticated", __func__, usr->usr_name);
if ((eapmsg = ibuf_static()) == NULL)
return (-1);
msg = " M=Welcome";
if ((resp = ibuf_advance(eapmsg, sizeof(*resp))) == NULL)
goto done;
resp->eap_code = EAP_CODE_REQUEST;
resp->eap_id = eap->eap_id + 1;
resp->eap_length = htobe16(sizeof(*resp) + sizeof(*mss) +
sizeof(successmsg) + strlen(msg));
resp->eap_type = EAP_TYPE_MSCHAP_V2;
if ((mss = ibuf_advance(eapmsg, sizeof(*mss))) == NULL)
goto done;
mss->mss_opcode = EAP_MSOPCODE_SUCCESS;
mss->mss_id = msr->msr_id;
mss->mss_length = htobe16(sizeof(*mss) +
sizeof(successmsg) + strlen(msg));
if (ibuf_add(eapmsg, successmsg, sizeof(successmsg)) != 0)
goto done;
if (ibuf_add(eapmsg, msg, strlen(msg)) != 0)
goto done;
break;
case EAP_MSOPCODE_SUCCESS:
if ((eapmsg = ibuf_static()) == NULL)
return (-1);
if ((resp = ibuf_advance(eapmsg, sizeof(*resp))) == NULL)
goto done;
resp->eap_code = EAP_CODE_RESPONSE;
resp->eap_id = eap->eap_id;
resp->eap_length = htobe16(sizeof(*resp) + sizeof(*ms));
resp->eap_type = EAP_TYPE_MSCHAP_V2;
if ((ms = ibuf_advance(eapmsg, sizeof(*ms))) == NULL)
goto done;
ms->ms_opcode = EAP_MSOPCODE_SUCCESS;
break;
case EAP_MSOPCODE_FAILURE:
case EAP_MSOPCODE_CHANGE_PASSWORD:
case EAP_MSOPCODE_CHALLENGE:
default:
log_debug("%s: EAP-%s unsupported "
"responder operation %s", __func__,
print_map(eap->eap_type, eap_type_map),
print_map(ms->ms_opcode, eap_msopcode_map));
return (-1);
}
if (eapmsg != NULL)
ret = ikev2_send_ike_e(env, sa, eapmsg,
IKEV2_PAYLOAD_EAP, IKEV2_EXCHANGE_IKE_AUTH, 1);
if (ret == 0)
sa_state(env, sa, IKEV2_STATE_AUTH_SUCCESS);
done:
ibuf_release(eapmsg);
return (ret);
}
struct ibuf *
dsa_setkey(struct iked_dsa *dsa, void *key, size_t keylen, uint8_t type)
{
BIO *rawcert = NULL;
X509 *cert = NULL;
RSA *rsa = NULL;
EVP_PKEY *pkey = NULL;
ibuf_release(dsa->dsa_keydata);
if ((dsa->dsa_keydata = ibuf_new(key, keylen)) == NULL) {
log_debug("%s: alloc signature key", __func__);
return (NULL);
}
if ((rawcert = BIO_new_mem_buf(key, keylen)) == NULL)
goto err;
switch (type) {
case IKEV2_CERT_X509_CERT:
if ((cert = d2i_X509_bio(rawcert, NULL)) == NULL)
goto sslerr;
if ((pkey = X509_get_pubkey(cert)) == NULL)
goto sslerr;
dsa->dsa_cert = cert;
dsa->dsa_key = pkey;
break;
case IKEV2_CERT_RSA_KEY:
if (dsa->dsa_sign) {
if ((rsa = d2i_RSAPrivateKey_bio(rawcert,
NULL)) == NULL)
goto sslerr;
} else {
if ((rsa = d2i_RSAPublicKey_bio(rawcert,
NULL)) == NULL)
goto sslerr;
}
if ((pkey = EVP_PKEY_new()) == NULL)
goto sslerr;
if (!EVP_PKEY_set1_RSA(pkey, rsa))
goto sslerr;
RSA_free(rsa); /* pkey now has the reference */
dsa->dsa_cert = NULL;
dsa->dsa_key = pkey;
break;
default:
if (dsa->dsa_hmac)
break;
log_debug("%s: unsupported key type", __func__);
goto err;
}
return (dsa->dsa_keydata);
sslerr:
ca_sslerror(__func__);
err:
log_debug("%s: error", __func__);
if (rsa != NULL)
RSA_free(rsa);
if (pkey != NULL)
EVP_PKEY_free(pkey);
if (cert != NULL)
X509_free(cert);
if (rawcert != NULL)
BIO_free(rawcert);
ibuf_release(dsa->dsa_keydata);
return (NULL);
}
int
ca_validate_pubkey(struct iked *env, struct iked_static_id *id,
void *data, size_t len)
{
BIO *rawcert = NULL;
RSA *peerrsa = NULL, *localrsa = NULL;
EVP_PKEY *peerkey = NULL, *localkey = NULL;
int ret = -1;
FILE *fp = NULL;
char idstr[IKED_ID_SIZE];
char file[PATH_MAX];
struct iked_id idp;
if (len == 0 && data == NULL)
return (-1);
switch (id->id_type) {
case IKEV2_ID_IPV4:
case IKEV2_ID_FQDN:
case IKEV2_ID_UFQDN:
case IKEV2_ID_IPV6:
break;
default:
/* Some types like ASN1_DN will not be mapped to file names */
return (-1);
}
bzero(&idp, sizeof(idp));
if ((idp.id_buf = ibuf_new(id->id_data, id->id_length)) == NULL)
goto done;
idp.id_type = id->id_type;
idp.id_offset = id->id_offset;
if (ikev2_print_id(&idp, idstr, sizeof(idstr)) == -1)
goto done;
if (len == 0) {
/* Data is already an public key */
peerkey = (EVP_PKEY *)data;
} else {
if ((rawcert = BIO_new_mem_buf(data, len)) == NULL)
goto done;
if ((peerrsa = d2i_RSAPublicKey_bio(rawcert, NULL)) == NULL)
goto sslerr;
if ((peerkey = EVP_PKEY_new()) == NULL)
goto sslerr;
if (!EVP_PKEY_set1_RSA(peerkey, peerrsa))
goto sslerr;
}
lc_string(idstr);
if (strlcpy(file, IKED_PUBKEY_DIR, sizeof(file)) >= sizeof(file) ||
strlcat(file, idstr, sizeof(file)) >= sizeof(file))
goto done;
if ((fp = fopen(file, "r")) == NULL)
goto done;
localkey = PEM_read_PUBKEY(fp, NULL, NULL, NULL);
if (localkey == NULL) {
/* reading PKCS #8 failed, try PEM */
rewind(fp);
localrsa = PEM_read_RSAPublicKey(fp, NULL, NULL, NULL);
fclose(fp);
if (localrsa == NULL)
goto sslerr;
if ((localkey = EVP_PKEY_new()) == NULL)
goto sslerr;
if (!EVP_PKEY_set1_RSA(localkey, localrsa))
goto sslerr;
} else {
fclose(fp);
}
if (localkey == NULL)
goto sslerr;
if (!EVP_PKEY_cmp(peerkey, localkey))
goto done;
log_debug("%s: valid public key in file %s", __func__, file);
ret = 0;
sslerr:
if (ret != 0)
ca_sslerror(__func__);
done:
ibuf_release(idp.id_buf);
if (peerkey != NULL)
EVP_PKEY_free(peerkey);
if (localkey != NULL)
EVP_PKEY_free(localkey);
if (peerrsa != NULL)
RSA_free(peerrsa);
if (localrsa != NULL)
RSA_free(localrsa);
if (rawcert != NULL)
BIO_free(rawcert);
return (ret);
}
int
ca_reload(struct iked *env)
{
struct ca_store *store = env->sc_priv;
uint8_t md[EVP_MAX_MD_SIZE];
char file[PATH_MAX];
struct iovec iov[2];
struct dirent *entry;
STACK_OF(X509_OBJECT) *h;
X509_OBJECT *xo;
X509 *x509;
DIR *dir;
int i, len, iovcnt = 0;
/*
* Load CAs
*/
if ((dir = opendir(IKED_CA_DIR)) == NULL)
return (-1);
while ((entry = readdir(dir)) != NULL) {
if ((entry->d_type != DT_REG) &&
(entry->d_type != DT_LNK))
continue;
if (snprintf(file, sizeof(file), "%s%s",
IKED_CA_DIR, entry->d_name) == -1)
continue;
if (!X509_load_cert_file(store->ca_calookup, file,
X509_FILETYPE_PEM)) {
log_warn("%s: failed to load ca file %s", __func__,
entry->d_name);
ca_sslerror(__func__);
continue;
}
log_debug("%s: loaded ca file %s", __func__, entry->d_name);
}
closedir(dir);
/*
* Load CRLs for the CAs
*/
if ((dir = opendir(IKED_CRL_DIR)) == NULL)
return (-1);
while ((entry = readdir(dir)) != NULL) {
if ((entry->d_type != DT_REG) &&
(entry->d_type != DT_LNK))
continue;
if (snprintf(file, sizeof(file), "%s%s",
IKED_CRL_DIR, entry->d_name) == -1)
continue;
if (!X509_load_crl_file(store->ca_calookup, file,
X509_FILETYPE_PEM)) {
log_warn("%s: failed to load crl file %s", __func__,
entry->d_name);
ca_sslerror(__func__);
continue;
}
/* Only enable CRL checks if we actually loaded a CRL */
X509_STORE_set_flags(store->ca_cas, X509_V_FLAG_CRL_CHECK);
log_debug("%s: loaded crl file %s", __func__, entry->d_name);
}
closedir(dir);
/*
* Save CAs signatures for the IKEv2 CERTREQ
*/
ibuf_release(env->sc_certreq);
if ((env->sc_certreq = ibuf_new(NULL, 0)) == NULL)
return (-1);
h = store->ca_cas->objs;
for (i = 0; i < sk_X509_OBJECT_num(h); i++) {
xo = sk_X509_OBJECT_value(h, i);
if (xo->type != X509_LU_X509)
continue;
x509 = xo->data.x509;
len = sizeof(md);
ca_subjectpubkey_digest(x509, md, &len);
log_debug("%s: %s", __func__, x509->name);
if (ibuf_add(env->sc_certreq, md, len) != 0) {
ibuf_release(env->sc_certreq);
return (-1);
}
}
if (ibuf_length(env->sc_certreq)) {
env->sc_certreqtype = IKEV2_CERT_X509_CERT;
iov[0].iov_base = &env->sc_certreqtype;
iov[0].iov_len = sizeof(env->sc_certreqtype);
iovcnt++;
iov[1].iov_base = ibuf_data(env->sc_certreq);
iov[1].iov_len = ibuf_length(env->sc_certreq);
iovcnt++;
log_debug("%s: loaded %zu ca certificate%s", __func__,
ibuf_length(env->sc_certreq) / SHA_DIGEST_LENGTH,
ibuf_length(env->sc_certreq) == SHA_DIGEST_LENGTH ?
"" : "s");
(void)proc_composev(&env->sc_ps, PROC_IKEV2, IMSG_CERTREQ,
iov, iovcnt);
}
/*
* Load certificates
*/
if ((dir = opendir(IKED_CERT_DIR)) == NULL)
return (-1);
while ((entry = readdir(dir)) != NULL) {
if ((entry->d_type != DT_REG) &&
(entry->d_type != DT_LNK))
continue;
if (snprintf(file, sizeof(file), "%s%s",
IKED_CERT_DIR, entry->d_name) == -1)
continue;
if (!X509_load_cert_file(store->ca_certlookup, file,
X509_FILETYPE_PEM)) {
log_warn("%s: failed to load cert file %s", __func__,
entry->d_name);
ca_sslerror(__func__);
continue;
}
log_debug("%s: loaded cert file %s", __func__, entry->d_name);
}
closedir(dir);
h = store->ca_certs->objs;
for (i = 0; i < sk_X509_OBJECT_num(h); i++) {
xo = sk_X509_OBJECT_value(h, i);
if (xo->type != X509_LU_X509)
continue;
x509 = xo->data.x509;
(void)ca_validate_cert(env, NULL, x509, 0);
}
if (!env->sc_certreqtype)
env->sc_certreqtype = store->ca_pubkey.id_type;
log_debug("%s: local cert type %s", __func__,
print_map(env->sc_certreqtype, ikev2_cert_map));
iov[0].iov_base = &env->sc_certreqtype;
iov[0].iov_len = sizeof(env->sc_certreqtype);
if (iovcnt == 0)
iovcnt++;
(void)proc_composev(&env->sc_ps, PROC_IKEV2, IMSG_CERTREQ, iov, iovcnt);
return (0);
}
int
ikev2_pld_delete(struct iked *env, struct ikev2_payload *pld,
struct iked_message *msg, off_t offset)
{
struct iked_childsa **peersas = NULL;
struct iked_sa *sa = msg->msg_sa;
struct ikev2_delete *del, *localdel;
struct ibuf *resp = NULL;
u_int64_t *localspi = NULL;
u_int64_t spi64, spi = 0;
u_int32_t spi32;
u_int8_t *buf, *msgbuf = ibuf_data(msg->msg_data);
size_t found = 0, failed = 0;
int cnt, i, len, sz, ret = -1;
/* Skip if it's a reply and we don't have to deal with it */
if (ikev2_msg_frompeer(msg) && sa &&
(sa->sa_stateflags & IKED_REQ_INF)) {
sa->sa_stateflags &= ~IKED_REQ_INF;
if ((sa->sa_stateflags & IKED_REQ_DELETE) == 0)
return (0);
}
if ((del = ibuf_seek(msg->msg_data, offset, sizeof(*del))) == NULL)
return (-1);
cnt = betoh16(del->del_nspi);
sz = del->del_spisize;
log_debug("%s: proto %s spisize %d nspi %d",
__func__, print_map(del->del_protoid, ikev2_saproto_map),
sz, cnt);
buf = msgbuf + offset + sizeof(*del);
len = betoh16(pld->pld_length) - sizeof(*pld) - sizeof(*del);
print_hex(buf, 0, len);
switch (sz) {
case 4:
case 8:
break;
default:
if (ikev2_msg_frompeer(msg) &&
del->del_protoid == IKEV2_SAPROTO_IKE) {
/* Send an empty informational response */
if ((resp = ibuf_static()) == NULL)
goto done;
ret = ikev2_send_ike_e(env, sa, resp,
IKEV2_PAYLOAD_NONE,
IKEV2_EXCHANGE_INFORMATIONAL, 1);
ibuf_release(resp);
sa_state(env, sa, IKEV2_STATE_CLOSED);
return (ret);
}
log_debug("%s: invalid SPI size", __func__);
return (-1);
}
if ((len / sz) != cnt) {
log_debug("%s: invalid payload length %d/%d != %d",
__func__, len, sz, cnt);
return (-1);
}
if (ikev2_msg_frompeer(msg) &&
((peersas = calloc(cnt, sizeof(struct iked_childsa *))) == NULL ||
(localspi = calloc(cnt, sizeof(u_int64_t))) == NULL)) {
log_warn("%s", __func__);
goto done;
}
for (i = 0; i < cnt; i++) {
switch (sz) {
case 4:
memcpy(&spi32, buf + (i * sz), sizeof(spi32));
spi = betoh32(spi32);
break;
case 8:
memcpy(&spi64, buf + (i * sz), sizeof(spi64));
spi = betoh64(spi64);
break;
}
log_debug("%s: spi %s", __func__, print_spi(spi, sz));
if (peersas == NULL || sa == NULL)
continue;
if ((peersas[i] = childsa_lookup(sa, spi,
del->del_protoid)) == NULL) {
log_warnx("%s: CHILD SA doesn't exist for spi %s",
__func__, print_spi(spi, del->del_spisize));
goto done;
}
if (ikev2_childsa_delete(env, sa, del->del_protoid, spi,
&localspi[i], 0) == -1)
failed++;
else
found++;
/*
* Flows are left in the require mode so that it would be
* possible to quickly negotiate a new Child SA
*/
}
/* Parsed outgoing message? */
if (!ikev2_msg_frompeer(msg))
goto done;
if (sa && (sa->sa_stateflags & IKED_REQ_DELETE)) {
/* Finish rekeying */
sa->sa_stateflags &= ~IKED_REQ_DELETE;
ret = 0;
goto done;
}
/* Response to the INFORMATIONAL with Delete payload */
if ((resp = ibuf_static()) == NULL)
goto done;
if (found) {
if ((localdel = ibuf_advance(resp, sizeof(*localdel))) == NULL)
goto done;
localdel->del_protoid = del->del_protoid;
localdel->del_spisize = del->del_spisize;
localdel->del_nspi = htobe16(found);
for (i = 0; i < cnt; i++) {
switch (sz) {
case 4:
spi32 = htobe32(localspi[i]);
if (ibuf_add(resp, &spi32, sizeof(spi32)) != 0)
goto done;
break;
case 8:
spi64 = htobe64(localspi[i]);
if (ibuf_add(resp, &spi64, sizeof(spi64)) != 0)
goto done;
break;
}
}
log_warnx("%s: deleted %d spis", __func__, found);
}
if (found) {
ret = ikev2_send_ike_e(env, sa, resp, IKEV2_PAYLOAD_DELETE,
IKEV2_EXCHANGE_INFORMATIONAL, 1);
} else {
/* XXX should we send an INVALID_SPI notification? */
ret = 0;
}
done:
if (localspi)
free(localspi);
if (peersas)
free(peersas);
ibuf_release(resp);
return (ret);
}