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