1*d39d09feSreyk /* $OpenBSD: ikev2_msg.c,v 1.30 2014/04/10 16:08:02 reyk Exp $ */ 2fde46d6eSreyk 3fde46d6eSreyk /* 4fcebd35dSreyk * Copyright (c) 2010-2013 Reyk Floeter <reyk@openbsd.org> 5fde46d6eSreyk * 6fde46d6eSreyk * Permission to use, copy, modify, and distribute this software for any 7fde46d6eSreyk * purpose with or without fee is hereby granted, provided that the above 8fde46d6eSreyk * copyright notice and this permission notice appear in all copies. 9fde46d6eSreyk * 10fde46d6eSreyk * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11fde46d6eSreyk * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12fde46d6eSreyk * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13fde46d6eSreyk * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14fde46d6eSreyk * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15fde46d6eSreyk * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16fde46d6eSreyk * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17fde46d6eSreyk */ 18fde46d6eSreyk 19fde46d6eSreyk #include <sys/param.h> 20fde46d6eSreyk #include <sys/queue.h> 21fde46d6eSreyk #include <sys/socket.h> 22fde46d6eSreyk #include <sys/wait.h> 23fde46d6eSreyk #include <sys/uio.h> 24fde46d6eSreyk 25fde46d6eSreyk #include <netinet/in.h> 26fde46d6eSreyk #include <netinet/ip_ipsp.h> 27fde46d6eSreyk #include <arpa/inet.h> 28fde46d6eSreyk 29fde46d6eSreyk #include <stdlib.h> 30fde46d6eSreyk #include <stdio.h> 31fde46d6eSreyk #include <unistd.h> 32fde46d6eSreyk #include <string.h> 33fde46d6eSreyk #include <getopt.h> 34fde46d6eSreyk #include <signal.h> 35fde46d6eSreyk #include <errno.h> 36fde46d6eSreyk #include <err.h> 37fde46d6eSreyk #include <pwd.h> 38fde46d6eSreyk #include <event.h> 39fde46d6eSreyk 40fde46d6eSreyk #include <openssl/sha.h> 41fde46d6eSreyk #include <openssl/evp.h> 42fde46d6eSreyk 43fde46d6eSreyk #include "iked.h" 44fde46d6eSreyk #include "ikev2.h" 45fde46d6eSreyk #include "eap.h" 46fde46d6eSreyk #include "dh.h" 47fde46d6eSreyk 48c45fd413Smikeb void ikev2_msg_response_timeout(struct iked *, void *); 49c45fd413Smikeb void ikev2_msg_retransmit_timeout(struct iked *, void *); 50c45fd413Smikeb 51fde46d6eSreyk void 52fde46d6eSreyk ikev2_msg_cb(int fd, short event, void *arg) 53fde46d6eSreyk { 54fde46d6eSreyk struct iked_socket *sock = arg; 55fde46d6eSreyk struct iked *env = sock->sock_env; 56fde46d6eSreyk struct iked_message msg; 57fde46d6eSreyk struct ike_header hdr; 58fde46d6eSreyk u_int32_t natt = 0x00000000; 59fde46d6eSreyk u_int8_t buf[IKED_MSGBUF_MAX]; 60fde46d6eSreyk ssize_t len; 61fde46d6eSreyk off_t off; 62fde46d6eSreyk struct iovec iov[2]; 63fde46d6eSreyk 64fde46d6eSreyk bzero(&msg, sizeof(msg)); 65fde46d6eSreyk bzero(buf, sizeof(buf)); 66fde46d6eSreyk 67fde46d6eSreyk msg.msg_peerlen = sizeof(msg.msg_peer); 68fde46d6eSreyk msg.msg_locallen = sizeof(msg.msg_local); 6926d7dba1Sreyk msg.msg_parent = &msg; 70fde46d6eSreyk memcpy(&msg.msg_local, &sock->sock_addr, sizeof(sock->sock_addr)); 71fde46d6eSreyk 72fde46d6eSreyk if ((len = recvfromto(fd, buf, sizeof(buf), 0, 73fde46d6eSreyk (struct sockaddr *)&msg.msg_peer, &msg.msg_peerlen, 74fde46d6eSreyk (struct sockaddr *)&msg.msg_local, &msg.msg_locallen)) < 75fde46d6eSreyk (ssize_t)sizeof(natt)) 76fde46d6eSreyk return; 77fde46d6eSreyk 7847d6a31cSmarkus if (socket_getport((struct sockaddr *)&msg.msg_local) == 7947d6a31cSmarkus IKED_NATT_PORT) { 80fde46d6eSreyk if (bcmp(&natt, buf, sizeof(natt)) != 0) 81fde46d6eSreyk return; 82fde46d6eSreyk msg.msg_natt = 1; 83fde46d6eSreyk off = sizeof(natt); 84fde46d6eSreyk } else 85fde46d6eSreyk off = 0; 86fde46d6eSreyk 87fde46d6eSreyk if ((size_t)(len - off) <= sizeof(hdr)) 88fde46d6eSreyk return; 89fde46d6eSreyk memcpy(&hdr, buf + off, sizeof(hdr)); 90fde46d6eSreyk 91fde46d6eSreyk if ((msg.msg_data = ibuf_new(buf + off, len - off)) == NULL) 92fde46d6eSreyk return; 93fde46d6eSreyk 94fde46d6eSreyk if (hdr.ike_version == IKEV1_VERSION) { 95fde46d6eSreyk iov[0].iov_base = &msg; 96fde46d6eSreyk iov[0].iov_len = sizeof(msg); 97fde46d6eSreyk iov[1].iov_base = buf; 98fde46d6eSreyk iov[1].iov_len = len; 99fde46d6eSreyk 100fc7fd3e3Sreyk proc_composev_imsg(env, PROC_IKEV1, IMSG_IKE_MESSAGE, -1, 101fde46d6eSreyk iov, 2); 102fde46d6eSreyk goto done; 103fde46d6eSreyk } 104fde46d6eSreyk TAILQ_INIT(&msg.msg_proposals); 105fde46d6eSreyk 106fde46d6eSreyk msg.msg_fd = fd; 107fde46d6eSreyk ikev2_recv(env, &msg); 108fde46d6eSreyk 109fde46d6eSreyk done: 110763023d6Sreyk ikev2_msg_cleanup(env, &msg); 111fde46d6eSreyk } 112fde46d6eSreyk 113fde46d6eSreyk struct ibuf * 114fde46d6eSreyk ikev2_msg_init(struct iked *env, struct iked_message *msg, 115fde46d6eSreyk struct sockaddr_storage *peer, socklen_t peerlen, 116fde46d6eSreyk struct sockaddr_storage *local, socklen_t locallen, int response) 117fde46d6eSreyk { 118fde46d6eSreyk bzero(msg, sizeof(*msg)); 119fde46d6eSreyk memcpy(&msg->msg_peer, peer, peerlen); 120fde46d6eSreyk msg->msg_peerlen = peerlen; 121fde46d6eSreyk memcpy(&msg->msg_local, local, locallen); 122fde46d6eSreyk msg->msg_locallen = locallen; 123fde46d6eSreyk msg->msg_response = response ? 1 : 0; 124fde46d6eSreyk msg->msg_fd = -1; 125fde46d6eSreyk msg->msg_data = ibuf_static(); 12626d7dba1Sreyk msg->msg_e = 0; 12726d7dba1Sreyk msg->msg_parent = msg; /* has to be set */ 128763023d6Sreyk TAILQ_INIT(&msg->msg_proposals); 129fde46d6eSreyk 130fde46d6eSreyk return (msg->msg_data); 131fde46d6eSreyk } 132fde46d6eSreyk 133c45fd413Smikeb struct iked_message * 134c45fd413Smikeb ikev2_msg_copy(struct iked *env, struct iked_message *msg) 135c45fd413Smikeb { 136c45fd413Smikeb struct iked_message *m = NULL; 137c45fd413Smikeb struct ibuf *buf; 138*d39d09feSreyk size_t len; 13912c9fd31Sreyk void *ptr; 140c45fd413Smikeb 141*d39d09feSreyk if (ibuf_size(msg->msg_data) < msg->msg_offset) 142*d39d09feSreyk return (NULL); 143*d39d09feSreyk len = ibuf_size(msg->msg_data) - msg->msg_offset; 144*d39d09feSreyk 145*d39d09feSreyk if ((ptr = ibuf_seek(msg->msg_data, msg->msg_offset, len)) == NULL || 14612c9fd31Sreyk (m = malloc(sizeof(*m))) == NULL || 147c45fd413Smikeb (buf = ikev2_msg_init(env, m, &msg->msg_peer, msg->msg_peerlen, 148c45fd413Smikeb &msg->msg_local, msg->msg_locallen, msg->msg_response)) == NULL || 14912c9fd31Sreyk ibuf_add(buf, ptr, len)) 150c45fd413Smikeb return (NULL); 151c45fd413Smikeb 152c45fd413Smikeb m->msg_fd = msg->msg_fd; 153c45fd413Smikeb m->msg_msgid = msg->msg_msgid; 154c45fd413Smikeb m->msg_offset = msg->msg_offset; 155c45fd413Smikeb m->msg_sa = msg->msg_sa; 156c45fd413Smikeb 157c45fd413Smikeb return (m); 158c45fd413Smikeb } 159c45fd413Smikeb 160763023d6Sreyk void 161763023d6Sreyk ikev2_msg_cleanup(struct iked *env, struct iked_message *msg) 162763023d6Sreyk { 16326d7dba1Sreyk if (msg == msg->msg_parent) { 16426d7dba1Sreyk ibuf_release(msg->msg_nonce); 16526d7dba1Sreyk ibuf_release(msg->msg_ke); 16626d7dba1Sreyk ibuf_release(msg->msg_auth.id_buf); 16726d7dba1Sreyk ibuf_release(msg->msg_id.id_buf); 16826d7dba1Sreyk ibuf_release(msg->msg_cert.id_buf); 16926d7dba1Sreyk 17026d7dba1Sreyk config_free_proposals(&msg->msg_proposals, 0); 17126d7dba1Sreyk } 17226d7dba1Sreyk 173763023d6Sreyk if (msg->msg_data != NULL) { 174763023d6Sreyk ibuf_release(msg->msg_data); 175763023d6Sreyk msg->msg_data = NULL; 176763023d6Sreyk } 177763023d6Sreyk } 178763023d6Sreyk 179fde46d6eSreyk int 180fde46d6eSreyk ikev2_msg_valid_ike_sa(struct iked *env, struct ike_header *oldhdr, 181fde46d6eSreyk struct iked_message *msg) 182fde46d6eSreyk { 183fde46d6eSreyk #if 0 184fde46d6eSreyk /* XXX Disabled, see comment below */ 185fde46d6eSreyk struct iked_message resp; 186fde46d6eSreyk struct ike_header *hdr; 187fde46d6eSreyk struct ikev2_payload *pld; 188fde46d6eSreyk struct ikev2_notify *n; 189fde46d6eSreyk struct ibuf *buf; 190fde46d6eSreyk struct iked_sa sa; 191fde46d6eSreyk #endif 192fde46d6eSreyk 193fde46d6eSreyk if (msg->msg_sa != NULL && msg->msg_policy != NULL) 194fde46d6eSreyk return (0); 195fde46d6eSreyk 196fde46d6eSreyk #if 0 197fde46d6eSreyk /* 198fde46d6eSreyk * XXX Sending INVALID_IKE_SPIs notifications is disabled 199fde46d6eSreyk * XXX because it is not mandatory and ignored by most 200fde46d6eSreyk * XXX implementations. We might want to enable it in 201fde46d6eSreyk * XXX combination with a rate-limitation to avoid DoS situations. 202fde46d6eSreyk */ 203fde46d6eSreyk 204fde46d6eSreyk /* Fail without error message */ 205fde46d6eSreyk if (msg->msg_response || msg->msg_policy == NULL) 206fde46d6eSreyk return (-1); 207fde46d6eSreyk 208fde46d6eSreyk /* Invalid IKE SA, return notification */ 209fde46d6eSreyk if ((buf = ikev2_msg_init(env, &resp, 210fde46d6eSreyk &msg->msg_peer, msg->msg_peerlen, 211fde46d6eSreyk &msg->msg_local, msg->msg_locallen, 1)) == NULL) 212fde46d6eSreyk goto done; 213fde46d6eSreyk 214d9c13a0aSmikeb resp.msg_fd = msg->msg_fd; 215d9c13a0aSmikeb 216fde46d6eSreyk bzero(&sa, sizeof(sa)); 217fde46d6eSreyk if ((oldhdr->ike_flags & IKEV2_FLAG_INITIATOR) == 0) 218fde46d6eSreyk sa.sa_hdr.sh_initiator = 1; 219fde46d6eSreyk sa.sa_hdr.sh_ispi = betoh64(oldhdr->ike_ispi); 220fde46d6eSreyk sa.sa_hdr.sh_rspi = betoh64(oldhdr->ike_rspi); 221fde46d6eSreyk 222c45fd413Smikeb resp.msg_msgid = betoh32(oldhdr->ike_msgid); 223c45fd413Smikeb 224fde46d6eSreyk /* IKE header */ 225c45fd413Smikeb if ((hdr = ikev2_add_header(buf, &sa, resp.msg_msgid, 226fde46d6eSreyk IKEV2_PAYLOAD_NOTIFY, IKEV2_EXCHANGE_INFORMATIONAL, 227fde46d6eSreyk IKEV2_FLAG_RESPONSE)) == NULL) 228fde46d6eSreyk goto done; 229fde46d6eSreyk 230fde46d6eSreyk /* SA payload */ 231fde46d6eSreyk if ((pld = ikev2_add_payload(buf)) == NULL) 232fde46d6eSreyk goto done; 233fde46d6eSreyk if ((n = ibuf_advance(buf, sizeof(*n))) == NULL) 234fde46d6eSreyk goto done; 235fde46d6eSreyk n->n_protoid = IKEV2_SAPROTO_IKE; 236fde46d6eSreyk n->n_spisize = 0; 237fde46d6eSreyk n->n_type = htobe16(IKEV2_N_INVALID_IKE_SPI); 238fde46d6eSreyk 239fde46d6eSreyk if (ikev2_next_payload(pld, sizeof(*n), IKEV2_PAYLOAD_NONE) == -1) 240fde46d6eSreyk goto done; 241fde46d6eSreyk 242fde46d6eSreyk if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1) 243fde46d6eSreyk goto done; 244fde46d6eSreyk 245fde46d6eSreyk (void)ikev2_pld_parse(env, hdr, &resp, 0); 246d9c13a0aSmikeb (void)ikev2_msg_send(env, &resp); 247fde46d6eSreyk 248fde46d6eSreyk done: 249763023d6Sreyk ikev2_msg_cleanup(env, &resp); 250fde46d6eSreyk #endif 251fde46d6eSreyk 252fde46d6eSreyk /* Always fail */ 253fde46d6eSreyk return (-1); 254fde46d6eSreyk } 255fde46d6eSreyk 256fde46d6eSreyk int 257d9c13a0aSmikeb ikev2_msg_send(struct iked *env, struct iked_message *msg) 258fde46d6eSreyk { 259c45fd413Smikeb struct iked_sa *sa = msg->msg_sa; 260fde46d6eSreyk struct ibuf *buf = msg->msg_data; 261fde46d6eSreyk u_int32_t natt = 0x00000000; 26212c9fd31Sreyk int isnatt = 0; 263670a137dSmikeb u_int8_t exchange, flags; 264fde46d6eSreyk struct ike_header *hdr; 265c45fd413Smikeb struct iked_message *m; 266fde46d6eSreyk 267fde46d6eSreyk if (buf == NULL || (hdr = ibuf_seek(msg->msg_data, 268fde46d6eSreyk msg->msg_offset, sizeof(*hdr))) == NULL) 269fde46d6eSreyk return (-1); 270fde46d6eSreyk 27112c9fd31Sreyk isnatt = (msg->msg_natt || (msg->msg_sa && msg->msg_sa->sa_natt)); 27212c9fd31Sreyk 273670a137dSmikeb exchange = hdr->ike_exchange; 274670a137dSmikeb flags = hdr->ike_flags; 27512c9fd31Sreyk log_info("%s: %s from %s to %s, %ld bytes%s", __func__, 276670a137dSmikeb print_map(exchange, ikev2_exchange_map), 27747d6a31cSmarkus print_host((struct sockaddr *)&msg->msg_local, NULL, 0), 27847d6a31cSmarkus print_host((struct sockaddr *)&msg->msg_peer, NULL, 0), 27912c9fd31Sreyk ibuf_length(buf), isnatt ? ", NAT-T" : ""); 280fde46d6eSreyk 28112c9fd31Sreyk if (isnatt) { 282fde46d6eSreyk if (ibuf_prepend(buf, &natt, sizeof(natt)) == -1) { 283fde46d6eSreyk log_debug("%s: failed to set NAT-T", __func__); 284fde46d6eSreyk return (-1); 285fde46d6eSreyk } 286c45fd413Smikeb msg->msg_offset += sizeof(natt); 287fde46d6eSreyk } 288d9c13a0aSmikeb 289d9c13a0aSmikeb if ((sendto(msg->msg_fd, ibuf_data(buf), ibuf_size(buf), 0, 290fde46d6eSreyk (struct sockaddr *)&msg->msg_peer, msg->msg_peerlen)) == -1) { 291fde46d6eSreyk log_warn("%s: sendto", __func__); 292fde46d6eSreyk return (-1); 293fde46d6eSreyk } 294fde46d6eSreyk 295c45fd413Smikeb if (!sa) 296c45fd413Smikeb return (0); 297c45fd413Smikeb 298c45fd413Smikeb if ((m = ikev2_msg_copy(env, msg)) == NULL) { 299c45fd413Smikeb log_debug("%s: failed to copy a message", __func__); 300c45fd413Smikeb return (-1); 301c45fd413Smikeb } 302670a137dSmikeb m->msg_exchange = exchange; 303c45fd413Smikeb 304670a137dSmikeb if (flags & IKEV2_FLAG_RESPONSE) { 305c45fd413Smikeb TAILQ_INSERT_TAIL(&sa->sa_responses, m, msg_entry); 306b3eeacebSmikeb timer_set(env, &m->msg_timer, ikev2_msg_response_timeout, m); 307b3eeacebSmikeb timer_add(env, &m->msg_timer, IKED_RESPONSE_TIMEOUT); 308c45fd413Smikeb } else { 309c45fd413Smikeb TAILQ_INSERT_TAIL(&sa->sa_requests, m, msg_entry); 310b3eeacebSmikeb timer_set(env, &m->msg_timer, ikev2_msg_retransmit_timeout, m); 311b3eeacebSmikeb timer_add(env, &m->msg_timer, IKED_RETRANSMIT_TIMEOUT); 312c45fd413Smikeb } 313c45fd413Smikeb 314fde46d6eSreyk return (0); 315fde46d6eSreyk } 316fde46d6eSreyk 317fde46d6eSreyk u_int32_t 318c45fd413Smikeb ikev2_msg_id(struct iked *env, struct iked_sa *sa) 319fde46d6eSreyk { 320c45fd413Smikeb u_int32_t id = sa->sa_reqid; 321fde46d6eSreyk 32210650a52Smikeb if (++sa->sa_reqid == UINT32_MAX) { 323fde46d6eSreyk /* XXX we should close and renegotiate the connection now */ 324fde46d6eSreyk log_debug("%s: IKEv2 message sequence overflow", __func__); 325fde46d6eSreyk } 32610650a52Smikeb return (id); 327fde46d6eSreyk } 328fde46d6eSreyk 329fde46d6eSreyk struct ibuf * 330fde46d6eSreyk ikev2_msg_encrypt(struct iked *env, struct iked_sa *sa, struct ibuf *src) 331fde46d6eSreyk { 332fde46d6eSreyk size_t len, ivlen, encrlen, integrlen, blocklen, 333fde46d6eSreyk outlen; 334fde46d6eSreyk u_int8_t *buf, pad = 0, *ptr; 33588d75aadSreyk struct ibuf *encr, *dst = NULL, *out = NULL; 336fde46d6eSreyk 337fde46d6eSreyk buf = ibuf_data(src); 338fde46d6eSreyk len = ibuf_size(src); 339fde46d6eSreyk 340328746baSreyk log_debug("%s: decrypted length %zu", __func__, len); 341fde46d6eSreyk print_hex(buf, 0, len); 342fde46d6eSreyk 343fde46d6eSreyk if (sa == NULL || 344fde46d6eSreyk sa->sa_encr == NULL || 345fde46d6eSreyk sa->sa_integr == NULL) { 346fde46d6eSreyk log_debug("%s: invalid SA", __func__); 347fde46d6eSreyk goto done; 348fde46d6eSreyk } 349fde46d6eSreyk 35088d75aadSreyk if (sa->sa_hdr.sh_initiator) 351fde46d6eSreyk encr = sa->sa_key_iencr; 35288d75aadSreyk else 353fde46d6eSreyk encr = sa->sa_key_rencr; 354fde46d6eSreyk 355fde46d6eSreyk blocklen = cipher_length(sa->sa_encr); 356fde46d6eSreyk ivlen = cipher_ivlength(sa->sa_encr); 357fde46d6eSreyk integrlen = hash_length(sa->sa_integr); 358fde46d6eSreyk encrlen = roundup(len + sizeof(pad), blocklen); 359fde46d6eSreyk pad = encrlen - (len + sizeof(pad)); 360fde46d6eSreyk 361fde46d6eSreyk /* 362fde46d6eSreyk * Pad the payload and encrypt it 363fde46d6eSreyk */ 364fde46d6eSreyk if (pad) { 365fde46d6eSreyk if ((ptr = ibuf_advance(src, pad)) == NULL) 366fde46d6eSreyk goto done; 367fde46d6eSreyk arc4random_buf(ptr, pad); 368fde46d6eSreyk } 369fde46d6eSreyk if (ibuf_add(src, &pad, sizeof(pad)) != 0) 370fde46d6eSreyk goto done; 371fde46d6eSreyk 372328746baSreyk log_debug("%s: padded length %zu", __func__, ibuf_size(src)); 373fde46d6eSreyk print_hex(ibuf_data(src), 0, ibuf_size(src)); 374fde46d6eSreyk 375fde46d6eSreyk cipher_setkey(sa->sa_encr, encr->buf, ibuf_length(encr)); 37688d75aadSreyk cipher_setiv(sa->sa_encr, NULL, 0); /* XXX ivlen */ 377fde46d6eSreyk cipher_init_encrypt(sa->sa_encr); 378fde46d6eSreyk 379fde46d6eSreyk if ((dst = ibuf_dup(sa->sa_encr->encr_iv)) == NULL) 380fde46d6eSreyk goto done; 381fde46d6eSreyk 382fde46d6eSreyk if ((out = ibuf_new(NULL, 383fde46d6eSreyk cipher_outlength(sa->sa_encr, encrlen))) == NULL) 384fde46d6eSreyk goto done; 385fde46d6eSreyk 386fde46d6eSreyk outlen = ibuf_size(out); 387fde46d6eSreyk cipher_update(sa->sa_encr, 388fde46d6eSreyk ibuf_data(src), encrlen, ibuf_data(out), &outlen); 389fde46d6eSreyk 390fde46d6eSreyk if (outlen && ibuf_add(dst, ibuf_data(out), outlen) != 0) 391fde46d6eSreyk goto done; 392fde46d6eSreyk 393fde46d6eSreyk if ((ptr = ibuf_advance(dst, integrlen)) == NULL) 394fde46d6eSreyk goto done; 395fde46d6eSreyk bzero(ptr, integrlen); 396fde46d6eSreyk 397328746baSreyk log_debug("%s: length %zu, padding %d, output length %zu", 398fde46d6eSreyk __func__, len + sizeof(pad), pad, ibuf_size(dst)); 399fde46d6eSreyk print_hex(ibuf_data(dst), 0, ibuf_size(dst)); 400fde46d6eSreyk 401fde46d6eSreyk ibuf_release(src); 402fde46d6eSreyk ibuf_release(out); 403fde46d6eSreyk return (dst); 404fde46d6eSreyk done: 405fde46d6eSreyk ibuf_release(src); 406fde46d6eSreyk ibuf_release(out); 407fde46d6eSreyk ibuf_release(dst); 408fde46d6eSreyk return (NULL); 409fde46d6eSreyk } 410fde46d6eSreyk 411fde46d6eSreyk int 412fde46d6eSreyk ikev2_msg_integr(struct iked *env, struct iked_sa *sa, struct ibuf *src) 413fde46d6eSreyk { 414fde46d6eSreyk int ret = -1; 415fde46d6eSreyk size_t integrlen, tmplen; 41688d75aadSreyk struct ibuf *integr, *tmp = NULL; 417fde46d6eSreyk u_int8_t *ptr; 418fde46d6eSreyk 419328746baSreyk log_debug("%s: message length %zu", __func__, ibuf_size(src)); 420fde46d6eSreyk print_hex(ibuf_data(src), 0, ibuf_size(src)); 421fde46d6eSreyk 422fde46d6eSreyk if (sa == NULL || 423fde46d6eSreyk sa->sa_integr == NULL) { 424fde46d6eSreyk log_debug("%s: invalid SA", __func__); 425fde46d6eSreyk return (-1); 426fde46d6eSreyk } 427fde46d6eSreyk 42888d75aadSreyk if (sa->sa_hdr.sh_initiator) 429fde46d6eSreyk integr = sa->sa_key_iauth; 43088d75aadSreyk else 431fde46d6eSreyk integr = sa->sa_key_rauth; 432fde46d6eSreyk 433fde46d6eSreyk integrlen = hash_length(sa->sa_integr); 434fde46d6eSreyk 435328746baSreyk log_debug("%s: integrity checksum length %zu", __func__, 436fde46d6eSreyk integrlen); 437fde46d6eSreyk 438fde46d6eSreyk /* 439fde46d6eSreyk * Validate packet checksum 440fde46d6eSreyk */ 441fde46d6eSreyk if ((tmp = ibuf_new(NULL, hash_keylength(sa->sa_integr))) == NULL) 442fde46d6eSreyk goto done; 443fde46d6eSreyk 444fde46d6eSreyk hash_setkey(sa->sa_integr, ibuf_data(integr), ibuf_size(integr)); 445fde46d6eSreyk hash_init(sa->sa_integr); 446fde46d6eSreyk hash_update(sa->sa_integr, ibuf_data(src), 447fde46d6eSreyk ibuf_size(src) - integrlen); 448fde46d6eSreyk hash_final(sa->sa_integr, ibuf_data(tmp), &tmplen); 449fde46d6eSreyk 450fde46d6eSreyk if (tmplen != integrlen) { 451fde46d6eSreyk log_debug("%s: hash failure", __func__); 452fde46d6eSreyk goto done; 453fde46d6eSreyk } 454fde46d6eSreyk 455fde46d6eSreyk if ((ptr = ibuf_seek(src, 456fde46d6eSreyk ibuf_size(src) - integrlen, integrlen)) == NULL) 457fde46d6eSreyk goto done; 458fde46d6eSreyk memcpy(ptr, ibuf_data(tmp), tmplen); 459fde46d6eSreyk 460fde46d6eSreyk print_hex(ibuf_data(tmp), 0, ibuf_size(tmp)); 461fde46d6eSreyk 462fde46d6eSreyk ret = 0; 463fde46d6eSreyk done: 464fde46d6eSreyk ibuf_release(tmp); 465fde46d6eSreyk 466fde46d6eSreyk return (ret); 467fde46d6eSreyk } 468fde46d6eSreyk 469fde46d6eSreyk struct ibuf * 470fde46d6eSreyk ikev2_msg_decrypt(struct iked *env, struct iked_sa *sa, 471fde46d6eSreyk struct ibuf *msg, struct ibuf *src) 472fde46d6eSreyk { 473e0696045Sreyk ssize_t ivlen, encrlen, integrlen, blocklen, 474fde46d6eSreyk outlen, tmplen; 475e0696045Sreyk u_int8_t pad = 0, *ptr; 476fde46d6eSreyk struct ibuf *integr, *encr, *tmp = NULL, *out = NULL; 477fde46d6eSreyk off_t ivoff, encroff, integroff; 478fde46d6eSreyk 479fde46d6eSreyk if (sa == NULL || 480fde46d6eSreyk sa->sa_encr == NULL || 481fde46d6eSreyk sa->sa_integr == NULL) { 482fde46d6eSreyk log_debug("%s: invalid SA", __func__); 483fde46d6eSreyk print_hex(ibuf_data(src), 0, ibuf_size(src)); 484fde46d6eSreyk goto done; 485fde46d6eSreyk } 486fde46d6eSreyk 487fde46d6eSreyk if (!sa->sa_hdr.sh_initiator) { 488fde46d6eSreyk encr = sa->sa_key_iencr; 489fde46d6eSreyk integr = sa->sa_key_iauth; 490fde46d6eSreyk } else { 491fde46d6eSreyk encr = sa->sa_key_rencr; 492fde46d6eSreyk integr = sa->sa_key_rauth; 493fde46d6eSreyk } 494fde46d6eSreyk 495fde46d6eSreyk blocklen = cipher_length(sa->sa_encr); 496fde46d6eSreyk ivlen = cipher_ivlength(sa->sa_encr); 497fde46d6eSreyk ivoff = 0; 498fde46d6eSreyk integrlen = hash_length(sa->sa_integr); 499fde46d6eSreyk integroff = ibuf_size(src) - integrlen; 500fde46d6eSreyk encroff = ivlen; 501fde46d6eSreyk encrlen = ibuf_size(src) - integrlen - ivlen; 502fde46d6eSreyk 503e0696045Sreyk if (encrlen < 0 || integroff < 0) { 504e0696045Sreyk log_debug("%s: invalid integrity value", __func__); 505e0696045Sreyk goto done; 506e0696045Sreyk } 507e0696045Sreyk 508328746baSreyk log_debug("%s: IV length %zd", __func__, ivlen); 509fde46d6eSreyk print_hex(ibuf_data(src), 0, ivlen); 510328746baSreyk log_debug("%s: encrypted payload length %zd", __func__, encrlen); 511fde46d6eSreyk print_hex(ibuf_data(src), encroff, encrlen); 512328746baSreyk log_debug("%s: integrity checksum length %zd", __func__, integrlen); 513fde46d6eSreyk print_hex(ibuf_data(src), integroff, integrlen); 514fde46d6eSreyk 515fde46d6eSreyk /* 516fde46d6eSreyk * Validate packet checksum 517fde46d6eSreyk */ 518fde46d6eSreyk if ((tmp = ibuf_new(NULL, ibuf_length(integr))) == NULL) 519fde46d6eSreyk goto done; 520fde46d6eSreyk 521fde46d6eSreyk hash_setkey(sa->sa_integr, integr->buf, ibuf_length(integr)); 522fde46d6eSreyk hash_init(sa->sa_integr); 523fde46d6eSreyk hash_update(sa->sa_integr, ibuf_data(msg), 524fde46d6eSreyk ibuf_size(msg) - integrlen); 525fde46d6eSreyk hash_final(sa->sa_integr, tmp->buf, &tmplen); 526fde46d6eSreyk 527fde46d6eSreyk if (memcmp(tmp->buf, ibuf_data(src) + integroff, integrlen) != 0) { 528fde46d6eSreyk log_debug("%s: integrity check failed", __func__); 529fde46d6eSreyk goto done; 530fde46d6eSreyk } 531fde46d6eSreyk 532b0eeedd0Smikeb log_debug("%s: integrity check succeeded", __func__); 533fde46d6eSreyk print_hex(tmp->buf, 0, tmplen); 534fde46d6eSreyk 535fde46d6eSreyk ibuf_release(tmp); 536fde46d6eSreyk tmp = NULL; 537fde46d6eSreyk 538fde46d6eSreyk /* 539fde46d6eSreyk * Decrypt the payload and strip any padding 540fde46d6eSreyk */ 541fde46d6eSreyk if ((encrlen % blocklen) != 0) { 542fde46d6eSreyk log_debug("%s: unaligned encrypted payload", __func__); 543fde46d6eSreyk goto done; 544fde46d6eSreyk } 545fde46d6eSreyk 546fde46d6eSreyk cipher_setkey(sa->sa_encr, encr->buf, ibuf_length(encr)); 547fde46d6eSreyk cipher_setiv(sa->sa_encr, ibuf_data(src) + ivoff, ivlen); 548fde46d6eSreyk cipher_init_decrypt(sa->sa_encr); 549fde46d6eSreyk 550fde46d6eSreyk if ((out = ibuf_new(NULL, cipher_outlength(sa->sa_encr, 551fde46d6eSreyk encrlen))) == NULL) 552fde46d6eSreyk goto done; 553fde46d6eSreyk 554e0696045Sreyk if ((outlen = ibuf_length(out)) != 0) { 5553189733aSmikeb cipher_update(sa->sa_encr, ibuf_data(src) + encroff, encrlen, 5563189733aSmikeb ibuf_data(out), &outlen); 5573189733aSmikeb 558fde46d6eSreyk ptr = ibuf_seek(out, outlen - 1, 1); 559fde46d6eSreyk pad = *ptr; 560e0696045Sreyk } 561fde46d6eSreyk 562328746baSreyk log_debug("%s: decrypted payload length %zd/%zd padding %d", 563fde46d6eSreyk __func__, outlen, encrlen, pad); 564fde46d6eSreyk print_hex(ibuf_data(out), 0, ibuf_size(out)); 565fde46d6eSreyk 566fde46d6eSreyk if (ibuf_setsize(out, outlen) != 0) 567fde46d6eSreyk goto done; 568fde46d6eSreyk 569fde46d6eSreyk ibuf_release(src); 570fde46d6eSreyk return (out); 571fde46d6eSreyk done: 572fde46d6eSreyk ibuf_release(tmp); 573fde46d6eSreyk ibuf_release(out); 574fde46d6eSreyk ibuf_release(src); 575fde46d6eSreyk return (NULL); 576fde46d6eSreyk } 577fde46d6eSreyk 578fde46d6eSreyk int 579c45fd413Smikeb ikev2_msg_send_encrypt(struct iked *env, struct iked_sa *sa, struct ibuf **ep, 580c45fd413Smikeb u_int8_t exchange, u_int8_t firstpayload, int response) 581fde46d6eSreyk { 582fde46d6eSreyk struct iked_message resp; 583fde46d6eSreyk struct ike_header *hdr; 584fde46d6eSreyk struct ikev2_payload *pld; 585fde46d6eSreyk struct ibuf *buf, *e = *ep; 586fde46d6eSreyk int ret = -1; 587fde46d6eSreyk 588c45fd413Smikeb if ((buf = ikev2_msg_init(env, &resp, &sa->sa_peer.addr, 589c45fd413Smikeb sa->sa_peer.addr.ss_len, &sa->sa_local.addr, 590c45fd413Smikeb sa->sa_local.addr.ss_len, response)) == NULL) 591fde46d6eSreyk goto done; 592fde46d6eSreyk 593c45fd413Smikeb resp.msg_msgid = response ? sa->sa_msgid : ikev2_msg_id(env, sa); 594c45fd413Smikeb 595fde46d6eSreyk /* IKE header */ 596c45fd413Smikeb if ((hdr = ikev2_add_header(buf, sa, resp.msg_msgid, IKEV2_PAYLOAD_SK, 597c45fd413Smikeb exchange, response ? IKEV2_FLAG_RESPONSE : 0)) == NULL) 598fde46d6eSreyk goto done; 599fde46d6eSreyk 600fde46d6eSreyk if ((pld = ikev2_add_payload(buf)) == NULL) 601fde46d6eSreyk goto done; 602fde46d6eSreyk 603fde46d6eSreyk /* Encrypt message and add as an E payload */ 604fde46d6eSreyk if ((e = ikev2_msg_encrypt(env, sa, e)) == NULL) { 605fde46d6eSreyk log_debug("%s: encryption failed", __func__); 606fde46d6eSreyk goto done; 607fde46d6eSreyk } 608fde46d6eSreyk if (ibuf_cat(buf, e) != 0) 609fde46d6eSreyk goto done; 610fde46d6eSreyk if (ikev2_next_payload(pld, ibuf_size(e), firstpayload) == -1) 611fde46d6eSreyk goto done; 612fde46d6eSreyk 613fde46d6eSreyk if (ikev2_set_header(hdr, ibuf_size(buf) - sizeof(*hdr)) == -1) 614fde46d6eSreyk goto done; 615fde46d6eSreyk 616fde46d6eSreyk /* Add integrity checksum (HMAC) */ 617fde46d6eSreyk if (ikev2_msg_integr(env, sa, buf) != 0) { 618fde46d6eSreyk log_debug("%s: integrity checksum failed", __func__); 619fde46d6eSreyk goto done; 620fde46d6eSreyk } 621fde46d6eSreyk 622fde46d6eSreyk resp.msg_data = buf; 623fde46d6eSreyk resp.msg_sa = sa; 624d9c13a0aSmikeb resp.msg_fd = sa->sa_fd; 625fde46d6eSreyk TAILQ_INIT(&resp.msg_proposals); 626fde46d6eSreyk 627fde46d6eSreyk (void)ikev2_pld_parse(env, hdr, &resp, 0); 628fde46d6eSreyk 629d9c13a0aSmikeb ret = ikev2_msg_send(env, &resp); 630fde46d6eSreyk 631fde46d6eSreyk done: 632fde46d6eSreyk /* e is cleaned up by the calling function */ 633fde46d6eSreyk *ep = e; 634763023d6Sreyk ikev2_msg_cleanup(env, &resp); 635fde46d6eSreyk 636fde46d6eSreyk return (ret); 637fde46d6eSreyk } 638fde46d6eSreyk 639fde46d6eSreyk struct ibuf * 640fde46d6eSreyk ikev2_msg_auth(struct iked *env, struct iked_sa *sa, int response) 641fde46d6eSreyk { 642fde46d6eSreyk struct ibuf *authmsg = NULL, *nonce, *prfkey, *buf; 643fde46d6eSreyk u_int8_t *ptr; 644fde46d6eSreyk struct iked_id *id; 645fde46d6eSreyk size_t tmplen; 646fde46d6eSreyk 647fde46d6eSreyk /* 648fde46d6eSreyk * Create the payload to be signed/MAC'ed for AUTH 649fde46d6eSreyk */ 650fde46d6eSreyk 651fde46d6eSreyk if (!response) { 652fde46d6eSreyk if ((nonce = sa->sa_rnonce) == NULL || 653fde46d6eSreyk (sa->sa_iid.id_type == 0) || 654fde46d6eSreyk (prfkey = sa->sa_key_iprf) == NULL || 655fde46d6eSreyk (buf = sa->sa_1stmsg) == NULL) 656fde46d6eSreyk return (NULL); 657fde46d6eSreyk id = &sa->sa_iid; 658fde46d6eSreyk } else { 659fde46d6eSreyk if ((nonce = sa->sa_inonce) == NULL || 660fde46d6eSreyk (sa->sa_rid.id_type == 0) || 661fde46d6eSreyk (prfkey = sa->sa_key_rprf) == NULL || 662fde46d6eSreyk (buf = sa->sa_2ndmsg) == NULL) 663fde46d6eSreyk return (NULL); 664fde46d6eSreyk id = &sa->sa_rid; 665fde46d6eSreyk } 666fde46d6eSreyk 667fde46d6eSreyk if ((authmsg = ibuf_dup(buf)) == NULL) 668fde46d6eSreyk return (NULL); 669fde46d6eSreyk if (ibuf_cat(authmsg, nonce) != 0) 670fde46d6eSreyk goto fail; 671fde46d6eSreyk 672fde46d6eSreyk if ((hash_setkey(sa->sa_prf, ibuf_data(prfkey), 673fde46d6eSreyk ibuf_size(prfkey))) == NULL) 674fde46d6eSreyk goto fail; 675fde46d6eSreyk 676fde46d6eSreyk if ((ptr = ibuf_advance(authmsg, 677fde46d6eSreyk hash_length(sa->sa_prf))) == NULL) 678fde46d6eSreyk goto fail; 679fde46d6eSreyk 680fde46d6eSreyk hash_init(sa->sa_prf); 681fde46d6eSreyk hash_update(sa->sa_prf, ibuf_data(id->id_buf), ibuf_size(id->id_buf)); 682fde46d6eSreyk hash_final(sa->sa_prf, ptr, &tmplen); 683fde46d6eSreyk 684fde46d6eSreyk if (tmplen != hash_length(sa->sa_prf)) 685fde46d6eSreyk goto fail; 686fde46d6eSreyk 687328746baSreyk log_debug("%s: %s auth data length %zu", 688fde46d6eSreyk __func__, response ? "responder" : "initiator", 689fde46d6eSreyk ibuf_size(authmsg)); 690fde46d6eSreyk print_hex(ibuf_data(authmsg), 0, ibuf_size(authmsg)); 691fde46d6eSreyk 692fde46d6eSreyk return (authmsg); 693fde46d6eSreyk 694fde46d6eSreyk fail: 695fde46d6eSreyk ibuf_release(authmsg); 696fde46d6eSreyk return (NULL); 697fde46d6eSreyk } 698fde46d6eSreyk 699fde46d6eSreyk int 700fde46d6eSreyk ikev2_msg_authverify(struct iked *env, struct iked_sa *sa, 701fde46d6eSreyk struct iked_auth *auth, u_int8_t *buf, size_t len, struct ibuf *authmsg) 702fde46d6eSreyk { 703fde46d6eSreyk u_int8_t *key, *psk = NULL; 704fde46d6eSreyk ssize_t keylen; 705fde46d6eSreyk struct iked_id *id; 706fde46d6eSreyk struct iked_dsa *dsa = NULL; 707fde46d6eSreyk int ret = -1; 708fde46d6eSreyk u_int8_t keytype; 709fde46d6eSreyk 710fde46d6eSreyk if (sa->sa_hdr.sh_initiator) 711fde46d6eSreyk id = &sa->sa_rcert; 712fde46d6eSreyk else 713fde46d6eSreyk id = &sa->sa_icert; 714fde46d6eSreyk 715fde46d6eSreyk if ((dsa = dsa_verify_new(auth->auth_method, sa->sa_prf)) == NULL) { 716fde46d6eSreyk log_debug("%s: invalid auth method", __func__); 717fde46d6eSreyk return (-1); 718fde46d6eSreyk } 719fde46d6eSreyk 720fde46d6eSreyk switch (auth->auth_method) { 721fde46d6eSreyk case IKEV2_AUTH_SHARED_KEY_MIC: 722fde46d6eSreyk if (!auth->auth_length) { 723fde46d6eSreyk log_debug("%s: no pre-shared key found", __func__); 724fde46d6eSreyk goto done; 725fde46d6eSreyk } 726fde46d6eSreyk if ((keylen = ikev2_psk(sa, auth->auth_data, 727fde46d6eSreyk auth->auth_length, &psk)) == -1) { 728fde46d6eSreyk log_debug("%s: failed to get PSK", __func__); 729fde46d6eSreyk goto done; 730fde46d6eSreyk } 731fde46d6eSreyk key = psk; 732fde46d6eSreyk keytype = 0; 733fde46d6eSreyk break; 734fde46d6eSreyk default: 735202133c5Sreyk if (!id->id_type || !ibuf_length(id->id_buf)) { 736fde46d6eSreyk log_debug("%s: no cert found", __func__); 737fde46d6eSreyk goto done; 738fde46d6eSreyk } 739fde46d6eSreyk key = ibuf_data(id->id_buf); 740fde46d6eSreyk keylen = ibuf_size(id->id_buf); 741fde46d6eSreyk keytype = id->id_type; 742fde46d6eSreyk break; 743fde46d6eSreyk } 744fde46d6eSreyk 745328746baSreyk log_debug("%s: method %s keylen %zd type %s", __func__, 746fde46d6eSreyk print_map(auth->auth_method, ikev2_auth_map), keylen, 747fde46d6eSreyk print_map(id->id_type, ikev2_cert_map)); 748fde46d6eSreyk 749fde46d6eSreyk if (dsa_setkey(dsa, key, keylen, keytype) == NULL || 750fde46d6eSreyk dsa_init(dsa) != 0 || 751fde46d6eSreyk dsa_update(dsa, ibuf_data(authmsg), ibuf_size(authmsg))) { 752fde46d6eSreyk log_debug("%s: failed to compute digital signature", __func__); 753fde46d6eSreyk goto done; 754fde46d6eSreyk } 755fde46d6eSreyk 756fde46d6eSreyk if ((ret = dsa_verify_final(dsa, buf, len)) == 0) { 757fde46d6eSreyk log_debug("%s: authentication successful", __func__); 758fde46d6eSreyk sa_state(env, sa, IKEV2_STATE_AUTH_SUCCESS); 759fde46d6eSreyk 760fde46d6eSreyk if (!sa->sa_policy->pol_auth.auth_eap && 761fde46d6eSreyk auth->auth_method == IKEV2_AUTH_SHARED_KEY_MIC) 762fde46d6eSreyk sa_state(env, sa, IKEV2_STATE_VALID); 763fde46d6eSreyk } else { 764fde46d6eSreyk log_debug("%s: authentication failed", __func__); 765fde46d6eSreyk sa_state(env, sa, IKEV2_STATE_AUTH_REQUEST); 766fde46d6eSreyk } 767fde46d6eSreyk 768fde46d6eSreyk done: 769fde46d6eSreyk if (psk != NULL) 770fde46d6eSreyk free(psk); 771fde46d6eSreyk dsa_free(dsa); 772fde46d6eSreyk 773fde46d6eSreyk return (ret); 774fde46d6eSreyk } 775fde46d6eSreyk 776fde46d6eSreyk int 777fde46d6eSreyk ikev2_msg_authsign(struct iked *env, struct iked_sa *sa, 778fde46d6eSreyk struct iked_auth *auth, struct ibuf *authmsg) 779fde46d6eSreyk { 780fde46d6eSreyk u_int8_t *key, *psk = NULL; 781fde46d6eSreyk ssize_t keylen; 782fde46d6eSreyk struct iked_hash *prf = sa->sa_prf; 783fde46d6eSreyk struct iked_id *id; 784fde46d6eSreyk struct iked_dsa *dsa = NULL; 785fde46d6eSreyk struct ibuf *buf; 786fde46d6eSreyk int ret = -1; 787fde46d6eSreyk u_int8_t keytype; 788fde46d6eSreyk 789fde46d6eSreyk if (sa->sa_hdr.sh_initiator) 790fde46d6eSreyk id = &sa->sa_icert; 791fde46d6eSreyk else 792fde46d6eSreyk id = &sa->sa_rcert; 793fde46d6eSreyk 794fde46d6eSreyk if ((dsa = dsa_sign_new(auth->auth_method, prf)) == NULL) { 795fde46d6eSreyk log_debug("%s: invalid auth method", __func__); 796fde46d6eSreyk return (-1); 797fde46d6eSreyk } 798fde46d6eSreyk 799fde46d6eSreyk switch (auth->auth_method) { 800fde46d6eSreyk case IKEV2_AUTH_SHARED_KEY_MIC: 801fde46d6eSreyk if (!auth->auth_length) { 802fde46d6eSreyk log_debug("%s: no pre-shared key found", __func__); 803fde46d6eSreyk goto done; 804fde46d6eSreyk } 805fde46d6eSreyk if ((keylen = ikev2_psk(sa, auth->auth_data, 806fde46d6eSreyk auth->auth_length, &psk)) == -1) { 807fde46d6eSreyk log_debug("%s: failed to get PSK", __func__); 808fde46d6eSreyk goto done; 809fde46d6eSreyk } 810fde46d6eSreyk key = psk; 811fde46d6eSreyk keytype = 0; 812fde46d6eSreyk break; 813fde46d6eSreyk default: 814fde46d6eSreyk if (id == NULL) { 815fde46d6eSreyk log_debug("%s: no cert found", __func__); 816fde46d6eSreyk goto done; 817fde46d6eSreyk } 818fde46d6eSreyk key = ibuf_data(id->id_buf); 819fde46d6eSreyk keylen = ibuf_size(id->id_buf); 820fde46d6eSreyk keytype = id->id_type; 821fde46d6eSreyk break; 822fde46d6eSreyk } 823fde46d6eSreyk 824fde46d6eSreyk if (dsa_setkey(dsa, key, keylen, keytype) == NULL || 825fde46d6eSreyk dsa_init(dsa) != 0 || 826fde46d6eSreyk dsa_update(dsa, ibuf_data(authmsg), ibuf_size(authmsg))) { 827fde46d6eSreyk log_debug("%s: failed to compute digital signature", __func__); 828fde46d6eSreyk goto done; 829fde46d6eSreyk } 830fde46d6eSreyk 831fde46d6eSreyk ibuf_release(sa->sa_localauth.id_buf); 832fde46d6eSreyk sa->sa_localauth.id_buf = NULL; 833fde46d6eSreyk 834fde46d6eSreyk if ((buf = ibuf_new(NULL, dsa_length(dsa))) == NULL) { 835fde46d6eSreyk log_debug("%s: failed to get auth buffer", __func__); 836fde46d6eSreyk goto done; 837fde46d6eSreyk } 838fde46d6eSreyk 839fde46d6eSreyk if ((ret = dsa_sign_final(dsa, 840fde46d6eSreyk ibuf_data(buf), ibuf_size(buf))) == -1) { 841fde46d6eSreyk log_debug("%s: failed to create auth signature", __func__); 842fde46d6eSreyk ibuf_release(buf); 843fde46d6eSreyk goto done; 844fde46d6eSreyk } 845fde46d6eSreyk 846fde46d6eSreyk sa->sa_localauth.id_type = auth->auth_method; 847fde46d6eSreyk sa->sa_localauth.id_buf = buf; 848fde46d6eSreyk 849fde46d6eSreyk ret = 0; 850fde46d6eSreyk done: 851fde46d6eSreyk if (psk != NULL) 852fde46d6eSreyk free(psk); 853fde46d6eSreyk dsa_free(dsa); 854fde46d6eSreyk 855fde46d6eSreyk return (ret); 856fde46d6eSreyk } 857ae494144Sreyk 858ae494144Sreyk int 859ae494144Sreyk ikev2_msg_frompeer(struct iked_message *msg) 860ae494144Sreyk { 861ae494144Sreyk struct iked_sa *sa = msg->msg_sa; 862ae494144Sreyk struct ike_header *hdr; 863ae494144Sreyk 86426d7dba1Sreyk msg = msg->msg_parent; 8651b0d4946Sreyk 866ae494144Sreyk if (sa == NULL || 867ae494144Sreyk (hdr = ibuf_seek(msg->msg_data, 0, sizeof(*hdr))) == NULL) 868ae494144Sreyk return (0); 869ae494144Sreyk 870ae494144Sreyk if (!sa->sa_hdr.sh_initiator && 871ae494144Sreyk (hdr->ike_flags & IKEV2_FLAG_INITIATOR)) 872ae494144Sreyk return (1); 873ae494144Sreyk else if (sa->sa_hdr.sh_initiator && 874ae494144Sreyk (hdr->ike_flags & IKEV2_FLAG_INITIATOR) == 0) 875ae494144Sreyk return (1); 876ae494144Sreyk 877ae494144Sreyk return (0); 878ae494144Sreyk } 879ae494144Sreyk 880ae494144Sreyk struct iked_socket * 88112c9fd31Sreyk ikev2_msg_getsocket(struct iked *env, int af, int natt) 882ae494144Sreyk { 883ae494144Sreyk switch (af) { 884ae494144Sreyk case AF_INET: 88512c9fd31Sreyk return (env->sc_sock4[natt ? 1 : 0]); 886ae494144Sreyk case AF_INET6: 88712c9fd31Sreyk return (env->sc_sock6[natt ? 1 : 0]); 888ae494144Sreyk } 889ae494144Sreyk 890ae494144Sreyk log_debug("%s: af socket %d not available", __func__, af); 891ae494144Sreyk return (NULL); 892ae494144Sreyk } 893c45fd413Smikeb 894c45fd413Smikeb void 895c45fd413Smikeb ikev2_msg_prevail(struct iked *env, struct iked_msgqueue *queue, 896c45fd413Smikeb struct iked_message *msg) 897c45fd413Smikeb { 89804ab0f1dSmikeb struct iked_message *m, *mtmp; 899c45fd413Smikeb 90004ab0f1dSmikeb TAILQ_FOREACH_SAFE(m, queue, msg_entry, mtmp) { 901c45fd413Smikeb if (m->msg_msgid < msg->msg_msgid) 902c45fd413Smikeb ikev2_msg_dispose(env, queue, m); 903c45fd413Smikeb } 904c45fd413Smikeb } 905c45fd413Smikeb 906c45fd413Smikeb void 907c45fd413Smikeb ikev2_msg_dispose(struct iked *env, struct iked_msgqueue *queue, 908c45fd413Smikeb struct iked_message *msg) 909c45fd413Smikeb { 910c45fd413Smikeb TAILQ_REMOVE(queue, msg, msg_entry); 911b3eeacebSmikeb timer_del(env, &msg->msg_timer); 912c45fd413Smikeb ikev2_msg_cleanup(env, msg); 913c45fd413Smikeb free(msg); 914c45fd413Smikeb } 915c45fd413Smikeb 916c45fd413Smikeb void 917c45fd413Smikeb ikev2_msg_flushqueue(struct iked *env, struct iked_msgqueue *queue) 918c45fd413Smikeb { 919c45fd413Smikeb struct iked_message *m = NULL; 920c45fd413Smikeb 921c45fd413Smikeb while ((m = TAILQ_FIRST(queue)) != NULL) 922c45fd413Smikeb ikev2_msg_dispose(env, queue, m); 923c45fd413Smikeb } 924c45fd413Smikeb 925c45fd413Smikeb struct iked_message * 92656d51042Smikeb ikev2_msg_lookup(struct iked *env, struct iked_msgqueue *queue, 92756d51042Smikeb struct iked_message *msg, struct ike_header *hdr) 928c45fd413Smikeb { 929c45fd413Smikeb struct iked_message *m = NULL; 930c45fd413Smikeb 931c45fd413Smikeb TAILQ_FOREACH(m, queue, msg_entry) { 93256d51042Smikeb if (m->msg_msgid == msg->msg_msgid && 93356d51042Smikeb m->msg_exchange == hdr->ike_exchange) 934c45fd413Smikeb break; 935c45fd413Smikeb } 936c45fd413Smikeb 93756d51042Smikeb return (m); 938c45fd413Smikeb } 939c45fd413Smikeb 940c45fd413Smikeb int 941c45fd413Smikeb ikev2_msg_retransmit_response(struct iked *env, struct iked_sa *sa, 942c45fd413Smikeb struct iked_message *msg) 943c45fd413Smikeb { 944c45fd413Smikeb if ((sendto(msg->msg_fd, ibuf_data(msg->msg_data), 945c45fd413Smikeb ibuf_size(msg->msg_data), 0, (struct sockaddr *)&msg->msg_peer, 946c45fd413Smikeb msg->msg_peerlen)) == -1) { 947c45fd413Smikeb log_warn("%s: sendto", __func__); 948c45fd413Smikeb sa_free(env, sa); 949c45fd413Smikeb return (-1); 950c45fd413Smikeb } 951c45fd413Smikeb 952b3eeacebSmikeb timer_add(env, &msg->msg_timer, IKED_RESPONSE_TIMEOUT); 953c45fd413Smikeb return (0); 954c45fd413Smikeb } 955c45fd413Smikeb 956c45fd413Smikeb void 957c45fd413Smikeb ikev2_msg_response_timeout(struct iked *env, void *arg) 958c45fd413Smikeb { 959c45fd413Smikeb struct iked_message *msg = arg; 960c45fd413Smikeb struct iked_sa *sa = msg->msg_sa; 961c45fd413Smikeb 962c45fd413Smikeb ikev2_msg_dispose(env, &sa->sa_responses, msg); 963c45fd413Smikeb } 964c45fd413Smikeb 965c45fd413Smikeb void 966c45fd413Smikeb ikev2_msg_retransmit_timeout(struct iked *env, void *arg) 967c45fd413Smikeb { 968c45fd413Smikeb struct iked_message *msg = arg; 969c45fd413Smikeb struct iked_sa *sa = msg->msg_sa; 970c45fd413Smikeb 9718d81c769Smikeb if (msg->msg_tries < IKED_RETRANSMIT_TRIES) { 972c45fd413Smikeb if ((sendto(msg->msg_fd, ibuf_data(msg->msg_data), 973c45fd413Smikeb ibuf_size(msg->msg_data), 0, 9748d81c769Smikeb (struct sockaddr *)&msg->msg_peer, 9758d81c769Smikeb msg->msg_peerlen)) == -1) { 976c45fd413Smikeb log_warn("%s: sendto", __func__); 977c45fd413Smikeb sa_free(env, sa); 978c45fd413Smikeb return; 979c45fd413Smikeb } 980c45fd413Smikeb /* Exponential timeout */ 981b3eeacebSmikeb timer_add(env, &msg->msg_timer, 982c45fd413Smikeb IKED_RETRANSMIT_TIMEOUT * (2 << (msg->msg_tries++))); 9838d81c769Smikeb } else { 9848d81c769Smikeb log_debug("%s: retransmit limit reached", __func__); 985c45fd413Smikeb sa_free(env, sa); 986c45fd413Smikeb } 9878d81c769Smikeb } 988