Annotation of embedaddon/strongswan/src/libcharon/sa/ikev2/tasks/ike_init.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2008-2019 Tobias Brunner
! 3: * Copyright (C) 2005-2008 Martin Willi
! 4: * Copyright (C) 2005 Jan Hutter
! 5: * HSR Hochschule fuer Technik Rapperswil
! 6: *
! 7: * This program is free software; you can redistribute it and/or modify it
! 8: * under the terms of the GNU General Public License as published by the
! 9: * Free Software Foundation; either version 2 of the License, or (at your
! 10: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 11: *
! 12: * This program is distributed in the hope that it will be useful, but
! 13: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 14: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 15: * for more details.
! 16: */
! 17:
! 18: #include "ike_init.h"
! 19:
! 20: #include <string.h>
! 21:
! 22: #include <daemon.h>
! 23: #include <bio/bio_reader.h>
! 24: #include <bio/bio_writer.h>
! 25: #include <sa/ikev2/keymat_v2.h>
! 26: #include <crypto/diffie_hellman.h>
! 27: #include <crypto/hashers/hash_algorithm_set.h>
! 28: #include <encoding/payloads/sa_payload.h>
! 29: #include <encoding/payloads/ke_payload.h>
! 30: #include <encoding/payloads/nonce_payload.h>
! 31:
! 32: /** maximum retries to do with cookies/other dh groups */
! 33: #define MAX_RETRIES 5
! 34:
! 35: typedef struct private_ike_init_t private_ike_init_t;
! 36:
! 37: /**
! 38: * Private members of a ike_init_t task.
! 39: */
! 40: struct private_ike_init_t {
! 41:
! 42: /**
! 43: * Public methods and task_t interface.
! 44: */
! 45: ike_init_t public;
! 46:
! 47: /**
! 48: * Assigned IKE_SA.
! 49: */
! 50: ike_sa_t *ike_sa;
! 51:
! 52: /**
! 53: * Are we the initiator?
! 54: */
! 55: bool initiator;
! 56:
! 57: /**
! 58: * diffie hellman group to use
! 59: */
! 60: diffie_hellman_group_t dh_group;
! 61:
! 62: /**
! 63: * diffie hellman key exchange
! 64: */
! 65: diffie_hellman_t *dh;
! 66:
! 67: /**
! 68: * Applying DH public value failed?
! 69: */
! 70: bool dh_failed;
! 71:
! 72: /**
! 73: * Keymat derivation (from IKE_SA)
! 74: */
! 75: keymat_v2_t *keymat;
! 76:
! 77: /**
! 78: * nonce chosen by us
! 79: */
! 80: chunk_t my_nonce;
! 81:
! 82: /**
! 83: * nonce chosen by peer
! 84: */
! 85: chunk_t other_nonce;
! 86:
! 87: /**
! 88: * nonce generator
! 89: */
! 90: nonce_gen_t *nonceg;
! 91:
! 92: /**
! 93: * Negotiated proposal used for IKE_SA
! 94: */
! 95: proposal_t *proposal;
! 96:
! 97: /**
! 98: * Old IKE_SA which gets rekeyed
! 99: */
! 100: ike_sa_t *old_sa;
! 101:
! 102: /**
! 103: * cookie received from responder
! 104: */
! 105: chunk_t cookie;
! 106:
! 107: /**
! 108: * retries done so far after failure (cookie or bad dh group)
! 109: */
! 110: u_int retry;
! 111:
! 112: /**
! 113: * Whether to use Signature Authentication as per RFC 7427
! 114: */
! 115: bool signature_authentication;
! 116:
! 117: /**
! 118: * Whether to follow IKEv2 redirects as per RFC 5685
! 119: */
! 120: bool follow_redirects;
! 121: };
! 122:
! 123: /**
! 124: * Allocate our own nonce value
! 125: */
! 126: static bool generate_nonce(private_ike_init_t *this)
! 127: {
! 128: if (!this->nonceg)
! 129: {
! 130: DBG1(DBG_IKE, "no nonce generator found to create nonce");
! 131: return FALSE;
! 132: }
! 133: if (!this->nonceg->allocate_nonce(this->nonceg, NONCE_SIZE,
! 134: &this->my_nonce))
! 135: {
! 136: DBG1(DBG_IKE, "nonce allocation failed");
! 137: return FALSE;
! 138: }
! 139: return TRUE;
! 140: }
! 141:
! 142: /**
! 143: * Notify the peer about the hash algorithms we support or expect,
! 144: * as per RFC 7427
! 145: */
! 146: static void send_supported_hash_algorithms(private_ike_init_t *this,
! 147: message_t *message)
! 148: {
! 149: hash_algorithm_set_t *algos;
! 150: enumerator_t *enumerator, *rounds;
! 151: bio_writer_t *writer;
! 152: hash_algorithm_t hash;
! 153: peer_cfg_t *peer;
! 154: auth_cfg_t *auth;
! 155: auth_rule_t rule;
! 156: signature_params_t *config;
! 157: int written;
! 158: size_t len = BUF_LEN;
! 159: char buf[len];
! 160: char *pos = buf;
! 161: char *plugin_name;
! 162:
! 163: algos = hash_algorithm_set_create();
! 164: peer = this->ike_sa->get_peer_cfg(this->ike_sa);
! 165: if (peer)
! 166: {
! 167: rounds = peer->create_auth_cfg_enumerator(peer, FALSE);
! 168: while (rounds->enumerate(rounds, &auth))
! 169: {
! 170: enumerator = auth->create_enumerator(auth);
! 171: while (enumerator->enumerate(enumerator, &rule, &config))
! 172: {
! 173: if (rule == AUTH_RULE_IKE_SIGNATURE_SCHEME)
! 174: {
! 175: hash = hasher_from_signature_scheme(config->scheme,
! 176: config->params);
! 177: if (hasher_algorithm_for_ikev2(hash))
! 178: {
! 179: algos->add(algos, hash);
! 180: }
! 181: }
! 182: }
! 183: enumerator->destroy(enumerator);
! 184: }
! 185: rounds->destroy(rounds);
! 186: }
! 187:
! 188: if (!algos->count(algos))
! 189: {
! 190: enumerator = lib->crypto->create_hasher_enumerator(lib->crypto);
! 191: while (enumerator->enumerate(enumerator, &hash, &plugin_name))
! 192: {
! 193: if (hasher_algorithm_for_ikev2(hash))
! 194: {
! 195: algos->add(algos, hash);
! 196: }
! 197: }
! 198: enumerator->destroy(enumerator);
! 199: }
! 200:
! 201: if (algos->count(algos))
! 202: {
! 203: writer = bio_writer_create(0);
! 204: enumerator = algos->create_enumerator(algos);
! 205: while (enumerator->enumerate(enumerator, &hash))
! 206: {
! 207: writer->write_uint16(writer, hash);
! 208:
! 209: /* generate debug output */
! 210: written = snprintf(pos, len, " %N", hash_algorithm_short_names,
! 211: hash);
! 212: if (written > 0 && written < len)
! 213: {
! 214: pos += written;
! 215: len -= written;
! 216: }
! 217: }
! 218: enumerator->destroy(enumerator);
! 219: message->add_notify(message, FALSE, SIGNATURE_HASH_ALGORITHMS,
! 220: writer->get_buf(writer));
! 221: writer->destroy(writer);
! 222:
! 223: *pos = '\0';
! 224: DBG2(DBG_CFG, "sending supported signature hash algorithms:%s", buf);
! 225: }
! 226: algos->destroy(algos);
! 227: }
! 228:
! 229: /**
! 230: * Store algorithms supported by other peer
! 231: */
! 232: static void handle_supported_hash_algorithms(private_ike_init_t *this,
! 233: notify_payload_t *notify)
! 234: {
! 235: bio_reader_t *reader;
! 236: uint16_t algo;
! 237: int written;
! 238: size_t len = BUF_LEN;
! 239: char buf[len];
! 240: char *pos = buf;
! 241: bool added = FALSE;
! 242:
! 243: reader = bio_reader_create(notify->get_notification_data(notify));
! 244: while (reader->remaining(reader) >= 2 && reader->read_uint16(reader, &algo))
! 245: {
! 246: if (hasher_algorithm_for_ikev2(algo))
! 247: {
! 248: this->keymat->add_hash_algorithm(this->keymat, algo);
! 249: added = TRUE;
! 250:
! 251: /* generate debug output */
! 252: written = snprintf(pos, len, " %N", hash_algorithm_short_names,
! 253: algo);
! 254: if (written > 0 && written < len)
! 255: {
! 256: pos += written;
! 257: len -= written;
! 258: }
! 259: }
! 260: }
! 261: reader->destroy(reader);
! 262:
! 263: *pos = '\0';
! 264: DBG2(DBG_CFG, "received supported signature hash algorithms:%s", buf);
! 265:
! 266: if (added)
! 267: {
! 268: this->ike_sa->enable_extension(this->ike_sa, EXT_SIGNATURE_AUTH);
! 269: }
! 270: }
! 271:
! 272: /**
! 273: * Check whether to send a USE_PPK notify
! 274: */
! 275: static bool send_use_ppk(private_ike_init_t *this)
! 276: {
! 277: peer_cfg_t *peer;
! 278: enumerator_t *keys;
! 279: shared_key_t *key;
! 280: bool use_ppk = FALSE;
! 281:
! 282: if (this->initiator)
! 283: {
! 284: peer = this->ike_sa->get_peer_cfg(this->ike_sa);
! 285: if (peer->get_ppk_id(peer))
! 286: {
! 287: use_ppk = TRUE;
! 288: }
! 289: }
! 290: else if (this->ike_sa->supports_extension(this->ike_sa, EXT_PPK))
! 291: {
! 292: /* check if we have at least one PPK available */
! 293: keys = lib->credmgr->create_shared_enumerator(lib->credmgr, SHARED_PPK,
! 294: NULL, NULL);
! 295: if (keys->enumerate(keys, &key, NULL, NULL))
! 296: {
! 297: use_ppk = TRUE;
! 298: }
! 299: keys->destroy(keys);
! 300: }
! 301: return use_ppk;
! 302: }
! 303:
! 304: /**
! 305: * build the payloads for the message
! 306: */
! 307: static bool build_payloads(private_ike_init_t *this, message_t *message)
! 308: {
! 309: sa_payload_t *sa_payload;
! 310: ke_payload_t *ke_payload;
! 311: nonce_payload_t *nonce_payload;
! 312: linked_list_t *proposal_list, *other_dh_groups;
! 313: ike_sa_id_t *id;
! 314: proposal_t *proposal;
! 315: enumerator_t *enumerator;
! 316: ike_cfg_t *ike_cfg;
! 317:
! 318: id = this->ike_sa->get_id(this->ike_sa);
! 319:
! 320: ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
! 321:
! 322: if (this->initiator)
! 323: {
! 324: proposal_list = ike_cfg->get_proposals(ike_cfg);
! 325: other_dh_groups = linked_list_create();
! 326: enumerator = proposal_list->create_enumerator(proposal_list);
! 327: while (enumerator->enumerate(enumerator, (void**)&proposal))
! 328: {
! 329: /* include SPI of new IKE_SA when we are rekeying */
! 330: if (this->old_sa)
! 331: {
! 332: proposal->set_spi(proposal, id->get_initiator_spi(id));
! 333: }
! 334: /* move the selected DH group to the front of the proposal */
! 335: if (!proposal->promote_dh_group(proposal, this->dh_group))
! 336: { /* the proposal does not include the group, move to the back */
! 337: proposal_list->remove_at(proposal_list, enumerator);
! 338: other_dh_groups->insert_last(other_dh_groups, proposal);
! 339: }
! 340: }
! 341: enumerator->destroy(enumerator);
! 342: /* add proposals that don't contain the selected group */
! 343: enumerator = other_dh_groups->create_enumerator(other_dh_groups);
! 344: while (enumerator->enumerate(enumerator, (void**)&proposal))
! 345: { /* no need to remove from the list as we destroy it anyway*/
! 346: proposal_list->insert_last(proposal_list, proposal);
! 347: }
! 348: enumerator->destroy(enumerator);
! 349: other_dh_groups->destroy(other_dh_groups);
! 350:
! 351: sa_payload = sa_payload_create_from_proposals_v2(proposal_list);
! 352: proposal_list->destroy_offset(proposal_list, offsetof(proposal_t, destroy));
! 353: }
! 354: else
! 355: {
! 356: if (this->old_sa)
! 357: {
! 358: /* include SPI of new IKE_SA when we are rekeying */
! 359: this->proposal->set_spi(this->proposal, id->get_responder_spi(id));
! 360: }
! 361: sa_payload = sa_payload_create_from_proposal_v2(this->proposal);
! 362: }
! 363: message->add_payload(message, (payload_t*)sa_payload);
! 364:
! 365: ke_payload = ke_payload_create_from_diffie_hellman(PLV2_KEY_EXCHANGE,
! 366: this->dh);
! 367: if (!ke_payload)
! 368: {
! 369: DBG1(DBG_IKE, "creating KE payload failed");
! 370: return FALSE;
! 371: }
! 372: nonce_payload = nonce_payload_create(PLV2_NONCE);
! 373: nonce_payload->set_nonce(nonce_payload, this->my_nonce);
! 374:
! 375: if (this->old_sa)
! 376: { /* payload order differs if we are rekeying */
! 377: message->add_payload(message, (payload_t*)nonce_payload);
! 378: message->add_payload(message, (payload_t*)ke_payload);
! 379: }
! 380: else
! 381: {
! 382: message->add_payload(message, (payload_t*)ke_payload);
! 383: message->add_payload(message, (payload_t*)nonce_payload);
! 384: }
! 385:
! 386: /* negotiate fragmentation if we are not rekeying */
! 387: if (!this->old_sa &&
! 388: ike_cfg->fragmentation(ike_cfg) != FRAGMENTATION_NO)
! 389: {
! 390: if (this->initiator ||
! 391: this->ike_sa->supports_extension(this->ike_sa,
! 392: EXT_IKE_FRAGMENTATION))
! 393: {
! 394: message->add_notify(message, FALSE, FRAGMENTATION_SUPPORTED,
! 395: chunk_empty);
! 396: }
! 397: }
! 398: /* submit supported hash algorithms for signature authentication */
! 399: if (!this->old_sa && this->signature_authentication)
! 400: {
! 401: if (this->initiator ||
! 402: this->ike_sa->supports_extension(this->ike_sa,
! 403: EXT_SIGNATURE_AUTH))
! 404: {
! 405: send_supported_hash_algorithms(this, message);
! 406: }
! 407: }
! 408: /* notify other peer if we support redirection */
! 409: if (!this->old_sa && this->initiator && this->follow_redirects)
! 410: {
! 411: identification_t *gateway;
! 412: host_t *from;
! 413: chunk_t data;
! 414:
! 415: from = this->ike_sa->get_redirected_from(this->ike_sa);
! 416: if (from)
! 417: {
! 418: gateway = identification_create_from_sockaddr(
! 419: from->get_sockaddr(from));
! 420: data = redirect_data_create(gateway, chunk_empty);
! 421: message->add_notify(message, FALSE, REDIRECTED_FROM, data);
! 422: chunk_free(&data);
! 423: gateway->destroy(gateway);
! 424: }
! 425: else
! 426: {
! 427: message->add_notify(message, FALSE, REDIRECT_SUPPORTED,
! 428: chunk_empty);
! 429: }
! 430: }
! 431: /* notify the peer if we want to use/support PPK */
! 432: if (!this->old_sa && send_use_ppk(this))
! 433: {
! 434: message->add_notify(message, FALSE, USE_PPK, chunk_empty);
! 435: }
! 436: /* notify the peer if we accept childless IKE_SAs */
! 437: if (!this->old_sa && !this->initiator &&
! 438: ike_cfg->childless(ike_cfg) != CHILDLESS_NEVER)
! 439: {
! 440: message->add_notify(message, FALSE, CHILDLESS_IKEV2_SUPPORTED,
! 441: chunk_empty);
! 442: }
! 443: return TRUE;
! 444: }
! 445:
! 446: /**
! 447: * Process the SA payload and select a proposal
! 448: */
! 449: static void process_sa_payload(private_ike_init_t *this, message_t *message,
! 450: sa_payload_t *sa_payload)
! 451: {
! 452: ike_cfg_t *ike_cfg, *cfg, *alt_cfg = NULL;
! 453: enumerator_t *enumerator;
! 454: linked_list_t *proposal_list;
! 455: host_t *me, *other;
! 456: proposal_selection_flag_t flags = 0;
! 457:
! 458: ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
! 459:
! 460: proposal_list = sa_payload->get_proposals(sa_payload);
! 461: if (!this->ike_sa->supports_extension(this->ike_sa, EXT_STRONGSWAN) &&
! 462: !lib->settings->get_bool(lib->settings, "%s.accept_private_algs",
! 463: FALSE, lib->ns))
! 464: {
! 465: flags |= PROPOSAL_SKIP_PRIVATE;
! 466: }
! 467: if (!lib->settings->get_bool(lib->settings,
! 468: "%s.prefer_configured_proposals", TRUE, lib->ns))
! 469: {
! 470: flags |= PROPOSAL_PREFER_SUPPLIED;
! 471: }
! 472: this->proposal = ike_cfg->select_proposal(ike_cfg, proposal_list, flags);
! 473: if (!this->proposal)
! 474: {
! 475: if (!this->initiator && !this->old_sa)
! 476: {
! 477: me = message->get_destination(message);
! 478: other = message->get_source(message);
! 479: enumerator = charon->backends->create_ike_cfg_enumerator(
! 480: charon->backends, me, other, IKEV2);
! 481: while (enumerator->enumerate(enumerator, &cfg))
! 482: {
! 483: if (ike_cfg == cfg)
! 484: { /* already tried and failed */
! 485: continue;
! 486: }
! 487: DBG1(DBG_IKE, "no matching proposal found, trying alternative "
! 488: "config");
! 489: this->proposal = cfg->select_proposal(cfg, proposal_list,
! 490: flags);
! 491: if (this->proposal)
! 492: {
! 493: alt_cfg = cfg->get_ref(cfg);
! 494: break;
! 495: }
! 496: }
! 497: enumerator->destroy(enumerator);
! 498: }
! 499: if (alt_cfg)
! 500: {
! 501: this->ike_sa->set_ike_cfg(this->ike_sa, alt_cfg);
! 502: alt_cfg->destroy(alt_cfg);
! 503: }
! 504: else
! 505: {
! 506: charon->bus->alert(charon->bus, ALERT_PROPOSAL_MISMATCH_IKE,
! 507: proposal_list);
! 508: }
! 509: }
! 510: proposal_list->destroy_offset(proposal_list,
! 511: offsetof(proposal_t, destroy));
! 512: }
! 513:
! 514: /**
! 515: * Read payloads from message
! 516: */
! 517: static void process_payloads(private_ike_init_t *this, message_t *message)
! 518: {
! 519: enumerator_t *enumerator;
! 520: payload_t *payload;
! 521: ke_payload_t *ke_payload = NULL;
! 522:
! 523: enumerator = message->create_payload_enumerator(message);
! 524: while (enumerator->enumerate(enumerator, &payload))
! 525: {
! 526: switch (payload->get_type(payload))
! 527: {
! 528: case PLV2_SECURITY_ASSOCIATION:
! 529: {
! 530: process_sa_payload(this, message, (sa_payload_t*)payload);
! 531: break;
! 532: }
! 533: case PLV2_KEY_EXCHANGE:
! 534: {
! 535: ke_payload = (ke_payload_t*)payload;
! 536:
! 537: this->dh_group = ke_payload->get_dh_group_number(ke_payload);
! 538: break;
! 539: }
! 540: case PLV2_NONCE:
! 541: {
! 542: nonce_payload_t *nonce_payload = (nonce_payload_t*)payload;
! 543:
! 544: this->other_nonce = nonce_payload->get_nonce(nonce_payload);
! 545: break;
! 546: }
! 547: case PLV2_NOTIFY:
! 548: {
! 549: notify_payload_t *notify = (notify_payload_t*)payload;
! 550:
! 551: switch (notify->get_notify_type(notify))
! 552: {
! 553: case FRAGMENTATION_SUPPORTED:
! 554: this->ike_sa->enable_extension(this->ike_sa,
! 555: EXT_IKE_FRAGMENTATION);
! 556: break;
! 557: case SIGNATURE_HASH_ALGORITHMS:
! 558: if (this->signature_authentication)
! 559: {
! 560: handle_supported_hash_algorithms(this, notify);
! 561: }
! 562: break;
! 563: case USE_PPK:
! 564: if (!this->old_sa)
! 565: {
! 566: this->ike_sa->enable_extension(this->ike_sa,
! 567: EXT_PPK);
! 568: }
! 569: break;
! 570: case REDIRECTED_FROM:
! 571: {
! 572: identification_t *gateway;
! 573: chunk_t data;
! 574:
! 575: data = notify->get_notification_data(notify);
! 576: gateway = redirect_data_parse(data, NULL);
! 577: if (!gateway)
! 578: {
! 579: DBG1(DBG_IKE, "received invalid REDIRECTED_FROM "
! 580: "notify, ignored");
! 581: break;
! 582: }
! 583: DBG1(DBG_IKE, "client got redirected from %Y", gateway);
! 584: gateway->destroy(gateway);
! 585: /* fall-through */
! 586: }
! 587: case REDIRECT_SUPPORTED:
! 588: if (!this->old_sa)
! 589: {
! 590: this->ike_sa->enable_extension(this->ike_sa,
! 591: EXT_IKE_REDIRECTION);
! 592: }
! 593: break;
! 594: case CHILDLESS_IKEV2_SUPPORTED:
! 595: if (this->initiator && !this->old_sa)
! 596: {
! 597: this->ike_sa->enable_extension(this->ike_sa,
! 598: EXT_IKE_CHILDLESS);
! 599: }
! 600: break;
! 601: default:
! 602: /* other notifies are handled elsewhere */
! 603: break;
! 604: }
! 605:
! 606: }
! 607: default:
! 608: break;
! 609: }
! 610: }
! 611: enumerator->destroy(enumerator);
! 612:
! 613: if (this->proposal)
! 614: {
! 615: this->ike_sa->set_proposal(this->ike_sa, this->proposal);
! 616: }
! 617:
! 618: if (ke_payload && this->proposal &&
! 619: this->proposal->has_dh_group(this->proposal, this->dh_group))
! 620: {
! 621: if (!this->initiator)
! 622: {
! 623: this->dh = this->keymat->keymat.create_dh(
! 624: &this->keymat->keymat, this->dh_group);
! 625: }
! 626: else if (this->dh)
! 627: {
! 628: this->dh_failed = this->dh->get_dh_group(this->dh) != this->dh_group;
! 629: }
! 630: if (this->dh && !this->dh_failed)
! 631: {
! 632: this->dh_failed = !this->dh->set_other_public_value(this->dh,
! 633: ke_payload->get_key_exchange_data(ke_payload));
! 634: }
! 635: }
! 636: }
! 637:
! 638: METHOD(task_t, build_i, status_t,
! 639: private_ike_init_t *this, message_t *message)
! 640: {
! 641: ike_cfg_t *ike_cfg;
! 642:
! 643: ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
! 644:
! 645: DBG0(DBG_IKE, "initiating IKE_SA %s[%d] to %H",
! 646: this->ike_sa->get_name(this->ike_sa),
! 647: this->ike_sa->get_unique_id(this->ike_sa),
! 648: this->ike_sa->get_other_host(this->ike_sa));
! 649: this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
! 650:
! 651: if (this->retry >= MAX_RETRIES)
! 652: {
! 653: DBG1(DBG_IKE, "giving up after %d retries", MAX_RETRIES);
! 654: return FAILED;
! 655: }
! 656:
! 657: /* if we are retrying after an INVALID_KE_PAYLOAD we already have one */
! 658: if (!this->dh)
! 659: {
! 660: if (this->old_sa && lib->settings->get_bool(lib->settings,
! 661: "%s.prefer_previous_dh_group", TRUE, lib->ns))
! 662: { /* reuse the DH group we used for the old IKE_SA when rekeying */
! 663: proposal_t *proposal;
! 664: uint16_t dh_group;
! 665:
! 666: proposal = this->old_sa->get_proposal(this->old_sa);
! 667: if (proposal->get_algorithm(proposal, DIFFIE_HELLMAN_GROUP,
! 668: &dh_group, NULL))
! 669: {
! 670: this->dh_group = dh_group;
! 671: }
! 672: else
! 673: { /* this shouldn't happen, but let's be safe */
! 674: this->dh_group = ike_cfg->get_dh_group(ike_cfg);
! 675: }
! 676: }
! 677: else
! 678: {
! 679: this->dh_group = ike_cfg->get_dh_group(ike_cfg);
! 680: }
! 681: this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
! 682: this->dh_group);
! 683: if (!this->dh)
! 684: {
! 685: DBG1(DBG_IKE, "configured DH group %N not supported",
! 686: diffie_hellman_group_names, this->dh_group);
! 687: return FAILED;
! 688: }
! 689: }
! 690: else if (this->dh->get_dh_group(this->dh) != this->dh_group)
! 691: { /* reset DH instance if group changed (INVALID_KE_PAYLOAD) */
! 692: this->dh->destroy(this->dh);
! 693: this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
! 694: this->dh_group);
! 695: if (!this->dh)
! 696: {
! 697: DBG1(DBG_IKE, "requested DH group %N not supported",
! 698: diffie_hellman_group_names, this->dh_group);
! 699: return FAILED;
! 700: }
! 701: }
! 702:
! 703: /* generate nonce only when we are trying the first time */
! 704: if (this->my_nonce.ptr == NULL)
! 705: {
! 706: if (!generate_nonce(this))
! 707: {
! 708: return FAILED;
! 709: }
! 710: }
! 711:
! 712: if (this->cookie.ptr)
! 713: {
! 714: message->add_notify(message, FALSE, COOKIE, this->cookie);
! 715: }
! 716:
! 717: if (!build_payloads(this, message))
! 718: {
! 719: return FAILED;
! 720: }
! 721:
! 722: #ifdef ME
! 723: {
! 724: chunk_t connect_id = this->ike_sa->get_connect_id(this->ike_sa);
! 725: if (connect_id.ptr)
! 726: {
! 727: message->add_notify(message, FALSE, ME_CONNECTID, connect_id);
! 728: }
! 729: }
! 730: #endif /* ME */
! 731:
! 732: return NEED_MORE;
! 733: }
! 734:
! 735: METHOD(task_t, process_r, status_t,
! 736: private_ike_init_t *this, message_t *message)
! 737: {
! 738: DBG0(DBG_IKE, "%H is initiating an IKE_SA", message->get_source(message));
! 739: this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
! 740:
! 741: if (!generate_nonce(this))
! 742: {
! 743: return FAILED;
! 744: }
! 745:
! 746: #ifdef ME
! 747: {
! 748: notify_payload_t *notify = message->get_notify(message, ME_CONNECTID);
! 749: if (notify)
! 750: {
! 751: chunk_t connect_id = notify->get_notification_data(notify);
! 752: DBG2(DBG_IKE, "received ME_CONNECTID %#B", &connect_id);
! 753: charon->connect_manager->stop_checks(charon->connect_manager,
! 754: connect_id);
! 755: }
! 756: }
! 757: #endif /* ME */
! 758:
! 759: process_payloads(this, message);
! 760:
! 761: return NEED_MORE;
! 762: }
! 763:
! 764: /**
! 765: * Derive the keymat for the IKE_SA
! 766: */
! 767: static bool derive_keys(private_ike_init_t *this,
! 768: chunk_t nonce_i, chunk_t nonce_r)
! 769: {
! 770: keymat_v2_t *old_keymat;
! 771: pseudo_random_function_t prf_alg = PRF_UNDEFINED;
! 772: chunk_t skd = chunk_empty;
! 773: ike_sa_id_t *id;
! 774:
! 775: id = this->ike_sa->get_id(this->ike_sa);
! 776: if (this->old_sa)
! 777: {
! 778: /* rekeying: Include old SKd, use old PRF, apply SPI */
! 779: old_keymat = (keymat_v2_t*)this->old_sa->get_keymat(this->old_sa);
! 780: prf_alg = old_keymat->get_skd(old_keymat, &skd);
! 781: if (this->initiator)
! 782: {
! 783: id->set_responder_spi(id, this->proposal->get_spi(this->proposal));
! 784: }
! 785: else
! 786: {
! 787: id->set_initiator_spi(id, this->proposal->get_spi(this->proposal));
! 788: }
! 789: }
! 790: if (!this->keymat->derive_ike_keys(this->keymat, this->proposal, this->dh,
! 791: nonce_i, nonce_r, id, prf_alg, skd))
! 792: {
! 793: return FALSE;
! 794: }
! 795: charon->bus->ike_keys(charon->bus, this->ike_sa, this->dh, chunk_empty,
! 796: nonce_i, nonce_r, this->old_sa, NULL, AUTH_NONE);
! 797: return TRUE;
! 798: }
! 799:
! 800: METHOD(task_t, build_r, status_t,
! 801: private_ike_init_t *this, message_t *message)
! 802: {
! 803: identification_t *gateway;
! 804:
! 805: /* check if we have everything we need */
! 806: if (this->proposal == NULL ||
! 807: this->other_nonce.len == 0 || this->my_nonce.len == 0)
! 808: {
! 809: DBG1(DBG_IKE, "received proposals unacceptable");
! 810: message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
! 811: return FAILED;
! 812: }
! 813:
! 814: /* check if we'd have to redirect the client */
! 815: if (!this->old_sa &&
! 816: this->ike_sa->supports_extension(this->ike_sa, EXT_IKE_REDIRECTION) &&
! 817: charon->redirect->redirect_on_init(charon->redirect, this->ike_sa,
! 818: &gateway))
! 819: {
! 820: chunk_t data;
! 821:
! 822: DBG1(DBG_IKE, "redirecting peer to %Y", gateway);
! 823: data = redirect_data_create(gateway, this->other_nonce);
! 824: message->add_notify(message, TRUE, REDIRECT, data);
! 825: gateway->destroy(gateway);
! 826: chunk_free(&data);
! 827: return FAILED;
! 828: }
! 829:
! 830: if (this->dh == NULL ||
! 831: !this->proposal->has_dh_group(this->proposal, this->dh_group))
! 832: {
! 833: uint16_t group;
! 834:
! 835: if (this->proposal->get_algorithm(this->proposal, DIFFIE_HELLMAN_GROUP,
! 836: &group, NULL))
! 837: {
! 838: DBG1(DBG_IKE, "DH group %N unacceptable, requesting %N",
! 839: diffie_hellman_group_names, this->dh_group,
! 840: diffie_hellman_group_names, group);
! 841: this->dh_group = group;
! 842: group = htons(group);
! 843: message->add_notify(message, FALSE, INVALID_KE_PAYLOAD,
! 844: chunk_from_thing(group));
! 845: }
! 846: else
! 847: {
! 848: DBG1(DBG_IKE, "no acceptable proposal found");
! 849: message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
! 850: }
! 851: return FAILED;
! 852: }
! 853:
! 854: if (this->dh_failed)
! 855: {
! 856: DBG1(DBG_IKE, "applying DH public value failed");
! 857: message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
! 858: return FAILED;
! 859: }
! 860:
! 861: if (!derive_keys(this, this->other_nonce, this->my_nonce))
! 862: {
! 863: DBG1(DBG_IKE, "key derivation failed");
! 864: message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
! 865: return FAILED;
! 866: }
! 867: if (!build_payloads(this, message))
! 868: {
! 869: message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
! 870: return FAILED;
! 871: }
! 872: return SUCCESS;
! 873: }
! 874:
! 875: /**
! 876: * Raise alerts for received notify errors
! 877: */
! 878: static void raise_alerts(private_ike_init_t *this, notify_type_t type)
! 879: {
! 880: ike_cfg_t *ike_cfg;
! 881: linked_list_t *list;
! 882:
! 883: switch (type)
! 884: {
! 885: case NO_PROPOSAL_CHOSEN:
! 886: ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
! 887: list = ike_cfg->get_proposals(ike_cfg);
! 888: charon->bus->alert(charon->bus, ALERT_PROPOSAL_MISMATCH_IKE, list);
! 889: list->destroy_offset(list, offsetof(proposal_t, destroy));
! 890: break;
! 891: default:
! 892: break;
! 893: }
! 894: }
! 895:
! 896: METHOD(task_t, pre_process_i, status_t,
! 897: private_ike_init_t *this, message_t *message)
! 898: {
! 899: enumerator_t *enumerator;
! 900: payload_t *payload;
! 901:
! 902: /* check for erroneous notifies */
! 903: enumerator = message->create_payload_enumerator(message);
! 904: while (enumerator->enumerate(enumerator, &payload))
! 905: {
! 906: if (payload->get_type(payload) == PLV2_NOTIFY)
! 907: {
! 908: notify_payload_t *notify = (notify_payload_t*)payload;
! 909: notify_type_t type = notify->get_notify_type(notify);
! 910:
! 911: switch (type)
! 912: {
! 913: case COOKIE:
! 914: {
! 915: chunk_t cookie;
! 916:
! 917: cookie = notify->get_notification_data(notify);
! 918: if (chunk_equals(cookie, this->cookie))
! 919: {
! 920: DBG1(DBG_IKE, "ignore response with duplicate COOKIE "
! 921: "notify");
! 922: enumerator->destroy(enumerator);
! 923: return FAILED;
! 924: }
! 925: break;
! 926: }
! 927: case REDIRECT:
! 928: {
! 929: identification_t *gateway;
! 930: chunk_t data, nonce = chunk_empty;
! 931: status_t status = SUCCESS;
! 932:
! 933: if (this->old_sa)
! 934: {
! 935: break;
! 936: }
! 937: data = notify->get_notification_data(notify);
! 938: gateway = redirect_data_parse(data, &nonce);
! 939: if (!gateway || !chunk_equals(nonce, this->my_nonce))
! 940: {
! 941: DBG1(DBG_IKE, "received invalid REDIRECT notify");
! 942: status = FAILED;
! 943: }
! 944: DESTROY_IF(gateway);
! 945: chunk_free(&nonce);
! 946: enumerator->destroy(enumerator);
! 947: return status;
! 948: }
! 949: default:
! 950: break;
! 951: }
! 952: }
! 953: }
! 954: enumerator->destroy(enumerator);
! 955: return SUCCESS;
! 956: }
! 957:
! 958: METHOD(task_t, process_i, status_t,
! 959: private_ike_init_t *this, message_t *message)
! 960: {
! 961: enumerator_t *enumerator;
! 962: payload_t *payload;
! 963:
! 964: /* check for erroneous notifies */
! 965: enumerator = message->create_payload_enumerator(message);
! 966: while (enumerator->enumerate(enumerator, &payload))
! 967: {
! 968: if (payload->get_type(payload) == PLV2_NOTIFY)
! 969: {
! 970: notify_payload_t *notify = (notify_payload_t*)payload;
! 971: notify_type_t type = notify->get_notify_type(notify);
! 972:
! 973: switch (type)
! 974: {
! 975: case INVALID_KE_PAYLOAD:
! 976: {
! 977: chunk_t data;
! 978: diffie_hellman_group_t bad_group;
! 979:
! 980: bad_group = this->dh_group;
! 981: data = notify->get_notification_data(notify);
! 982: this->dh_group = ntohs(*((uint16_t*)data.ptr));
! 983: DBG1(DBG_IKE, "peer didn't accept DH group %N, "
! 984: "it requested %N", diffie_hellman_group_names,
! 985: bad_group, diffie_hellman_group_names, this->dh_group);
! 986:
! 987: if (this->old_sa == NULL)
! 988: { /* reset the IKE_SA if we are not rekeying */
! 989: this->ike_sa->reset(this->ike_sa, FALSE);
! 990: }
! 991:
! 992: enumerator->destroy(enumerator);
! 993: this->retry++;
! 994: return NEED_MORE;
! 995: }
! 996: case NAT_DETECTION_SOURCE_IP:
! 997: case NAT_DETECTION_DESTINATION_IP:
! 998: /* skip, handled in ike_natd_t */
! 999: break;
! 1000: case MULTIPLE_AUTH_SUPPORTED:
! 1001: /* handled in ike_auth_t */
! 1002: break;
! 1003: case COOKIE:
! 1004: {
! 1005: chunk_free(&this->cookie);
! 1006: this->cookie = chunk_clone(notify->get_notification_data(notify));
! 1007: this->ike_sa->reset(this->ike_sa, FALSE);
! 1008: enumerator->destroy(enumerator);
! 1009: DBG2(DBG_IKE, "received %N notify", notify_type_names, type);
! 1010: this->retry++;
! 1011: return NEED_MORE;
! 1012: }
! 1013: case REDIRECT:
! 1014: {
! 1015: identification_t *gateway;
! 1016: chunk_t data, nonce = chunk_empty;
! 1017: status_t status = FAILED;
! 1018:
! 1019: if (this->old_sa)
! 1020: {
! 1021: DBG1(DBG_IKE, "received REDIRECT notify during rekeying"
! 1022: ", ignored");
! 1023: break;
! 1024: }
! 1025: data = notify->get_notification_data(notify);
! 1026: gateway = redirect_data_parse(data, &nonce);
! 1027: if (this->ike_sa->handle_redirect(this->ike_sa, gateway))
! 1028: {
! 1029: status = NEED_MORE;
! 1030: }
! 1031: DESTROY_IF(gateway);
! 1032: chunk_free(&nonce);
! 1033: enumerator->destroy(enumerator);
! 1034: return status;
! 1035: }
! 1036: default:
! 1037: {
! 1038: if (type <= 16383)
! 1039: {
! 1040: DBG1(DBG_IKE, "received %N notify error",
! 1041: notify_type_names, type);
! 1042: enumerator->destroy(enumerator);
! 1043: raise_alerts(this, type);
! 1044: return FAILED;
! 1045: }
! 1046: DBG2(DBG_IKE, "received %N notify",
! 1047: notify_type_names, type);
! 1048: break;
! 1049: }
! 1050: }
! 1051: }
! 1052: }
! 1053: enumerator->destroy(enumerator);
! 1054:
! 1055: process_payloads(this, message);
! 1056:
! 1057: /* check if we have everything */
! 1058: if (this->proposal == NULL ||
! 1059: this->other_nonce.len == 0 || this->my_nonce.len == 0)
! 1060: {
! 1061: DBG1(DBG_IKE, "peers proposal selection invalid");
! 1062: return FAILED;
! 1063: }
! 1064:
! 1065: if (this->dh == NULL ||
! 1066: !this->proposal->has_dh_group(this->proposal, this->dh_group))
! 1067: {
! 1068: DBG1(DBG_IKE, "peer DH group selection invalid");
! 1069: return FAILED;
! 1070: }
! 1071:
! 1072: if (this->dh_failed)
! 1073: {
! 1074: DBG1(DBG_IKE, "applying DH public value failed");
! 1075: return FAILED;
! 1076: }
! 1077:
! 1078: if (!derive_keys(this, this->my_nonce, this->other_nonce))
! 1079: {
! 1080: DBG1(DBG_IKE, "key derivation failed");
! 1081: return FAILED;
! 1082: }
! 1083: return SUCCESS;
! 1084: }
! 1085:
! 1086: METHOD(task_t, get_type, task_type_t,
! 1087: private_ike_init_t *this)
! 1088: {
! 1089: return TASK_IKE_INIT;
! 1090: }
! 1091:
! 1092: METHOD(task_t, migrate, void,
! 1093: private_ike_init_t *this, ike_sa_t *ike_sa)
! 1094: {
! 1095: DESTROY_IF(this->proposal);
! 1096: chunk_free(&this->other_nonce);
! 1097:
! 1098: this->ike_sa = ike_sa;
! 1099: this->keymat = (keymat_v2_t*)ike_sa->get_keymat(ike_sa);
! 1100: this->proposal = NULL;
! 1101: this->dh_failed = FALSE;
! 1102: }
! 1103:
! 1104: METHOD(task_t, destroy, void,
! 1105: private_ike_init_t *this)
! 1106: {
! 1107: DESTROY_IF(this->dh);
! 1108: DESTROY_IF(this->proposal);
! 1109: DESTROY_IF(this->nonceg);
! 1110: chunk_free(&this->my_nonce);
! 1111: chunk_free(&this->other_nonce);
! 1112: chunk_free(&this->cookie);
! 1113: free(this);
! 1114: }
! 1115:
! 1116: METHOD(ike_init_t, get_lower_nonce, chunk_t,
! 1117: private_ike_init_t *this)
! 1118: {
! 1119: if (memcmp(this->my_nonce.ptr, this->other_nonce.ptr,
! 1120: min(this->my_nonce.len, this->other_nonce.len)) < 0)
! 1121: {
! 1122: return this->my_nonce;
! 1123: }
! 1124: else
! 1125: {
! 1126: return this->other_nonce;
! 1127: }
! 1128: }
! 1129:
! 1130: /*
! 1131: * Described in header.
! 1132: */
! 1133: ike_init_t *ike_init_create(ike_sa_t *ike_sa, bool initiator, ike_sa_t *old_sa)
! 1134: {
! 1135: private_ike_init_t *this;
! 1136:
! 1137: INIT(this,
! 1138: .public = {
! 1139: .task = {
! 1140: .get_type = _get_type,
! 1141: .migrate = _migrate,
! 1142: .destroy = _destroy,
! 1143: },
! 1144: .get_lower_nonce = _get_lower_nonce,
! 1145: },
! 1146: .ike_sa = ike_sa,
! 1147: .initiator = initiator,
! 1148: .dh_group = MODP_NONE,
! 1149: .keymat = (keymat_v2_t*)ike_sa->get_keymat(ike_sa),
! 1150: .old_sa = old_sa,
! 1151: .signature_authentication = lib->settings->get_bool(lib->settings,
! 1152: "%s.signature_authentication", TRUE, lib->ns),
! 1153: .follow_redirects = lib->settings->get_bool(lib->settings,
! 1154: "%s.follow_redirects", TRUE, lib->ns),
! 1155: );
! 1156: this->nonceg = this->keymat->keymat.create_nonce_gen(&this->keymat->keymat);
! 1157:
! 1158: if (initiator)
! 1159: {
! 1160: this->public.task.build = _build_i;
! 1161: this->public.task.process = _process_i;
! 1162: this->public.task.pre_process = _pre_process_i;
! 1163: }
! 1164: else
! 1165: {
! 1166: this->public.task.build = _build_r;
! 1167: this->public.task.process = _process_r;
! 1168: }
! 1169: return &this->public;
! 1170: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ike_init.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / sa / ikev2 / tasks