src/libcharon/sa/ikev2/tasks/ike_init.c

   1 /*
   2  * Copyright (C) 2008-2015 Tobias Brunner
   3  * Copyright (C) 2005-2008 Martin Willi
   4  * Copyright (C) 2005 Jan Hutter
   5  * 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          * IKE config to establish
  59          */
  60         ike_cfg_t *config;
  61
  62         /**
  63          * diffie hellman group to use
  64          */
  65         diffie_hellman_group_t dh_group;
  66
  67         /**
  68          * diffie hellman key exchange
  69          */
  70         diffie_hellman_t *dh;
  71
  72         /**
  73          * Applying DH public value failed?
  74          */
  75         bool dh_failed;
  76
  77         /**
  78          * Keymat derivation (from IKE_SA)
  79          */
  80         keymat_v2_t *keymat;
  81
  82         /**
  83          * nonce chosen by us
  84          */
  85         chunk_t my_nonce;
  86
  87         /**
  88          * nonce chosen by peer
  89          */
  90         chunk_t other_nonce;
  91
  92         /**
  93          * nonce generator
  94          */
  95         nonce_gen_t *nonceg;
  96
  97         /**
  98          * Negotiated proposal used for IKE_SA
  99          */
 100         proposal_t *proposal;
 101
 102         /**
 103          * Old IKE_SA which gets rekeyed
 104          */
 105         ike_sa_t *old_sa;
 106
 107         /**
 108          * cookie received from responder
 109          */
 110         chunk_t cookie;
 111
 112         /**
 113          * retries done so far after failure (cookie or bad dh group)
 114          */
 115         u_int retry;
 116
 117         /**
 118          * Whether to use Signature Authentication as per RFC 7427
 119          */
 120         bool signature_authentication;
 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         uintptr_t config;
 157         char *plugin_name;
 158
 159         algos = hash_algorithm_set_create();
 160         peer = this->ike_sa->get_peer_cfg(this->ike_sa);
 161         if (peer)
 162         {
 163                 rounds = peer->create_auth_cfg_enumerator(peer, FALSE);
 164                 while (rounds->enumerate(rounds, &auth))
 165                 {
 166                         enumerator = auth->create_enumerator(auth);
 167                         while (enumerator->enumerate(enumerator, &rule, &config))
 168                         {
 169                                 if (rule == AUTH_RULE_SIGNATURE_SCHEME)
 170                                 {
 171                                         hash = hasher_from_signature_scheme(config);
 172                                         if (hasher_algorithm_for_ikev2(hash))
 173                                         {
 174                                                 algos->add(algos, hash);
 175                                         }
 176                                 }
 177                         }
 178                         enumerator->destroy(enumerator);
 179                 }
 180                 rounds->destroy(rounds);
 181         }
 182
 183         if (!algos->count(algos))
 184         {
 185                 enumerator = lib->crypto->create_hasher_enumerator(lib->crypto);
 186                 while (enumerator->enumerate(enumerator, &hash, &plugin_name))
 187                 {
 188                         if (hasher_algorithm_for_ikev2(hash))
 189                         {
 190                                 algos->add(algos, hash);
 191                         }
 192                 }
 193                 enumerator->destroy(enumerator);
 194         }
 195
 196         if (algos->count(algos))
 197         {
 198                 writer = bio_writer_create(0);
 199                 enumerator = algos->create_enumerator(algos);
 200                 while (enumerator->enumerate(enumerator, &hash))
 201                 {
 202                         writer->write_uint16(writer, hash);
 203                 }
 204                 enumerator->destroy(enumerator);
 205                 message->add_notify(message, FALSE, SIGNATURE_HASH_ALGORITHMS,
 206                                                         writer->get_buf(writer));
 207                 writer->destroy(writer);
 208         }
 209         algos->destroy(algos);
 210 }
 211
 212 /**
 213  * Store algorithms supported by other peer
 214  */
 215 static void handle_supported_hash_algorithms(private_ike_init_t *this,
 216                                                                                          notify_payload_t *notify)
 217 {
 218         bio_reader_t *reader;
 219         u_int16_t algo;
 220         bool added = FALSE;
 221
 222         reader = bio_reader_create(notify->get_notification_data(notify));
 223         while (reader->remaining(reader) >= 2 && reader->read_uint16(reader, &algo))
 224         {
 225                 if (hasher_algorithm_for_ikev2(algo))
 226                 {
 227                         this->keymat->add_hash_algorithm(this->keymat, algo);
 228                         added = TRUE;
 229                 }
 230         }
 231         reader->destroy(reader);
 232
 233         if (added)
 234         {
 235                 this->ike_sa->enable_extension(this->ike_sa, EXT_SIGNATURE_AUTH);
 236         }
 237 }
 238
 239 /**
 240  * build the payloads for the message
 241  */
 242 static bool build_payloads(private_ike_init_t *this, message_t *message)
 243 {
 244         sa_payload_t *sa_payload;
 245         ke_payload_t *ke_payload;
 246         nonce_payload_t *nonce_payload;
 247         linked_list_t *proposal_list;
 248         ike_sa_id_t *id;
 249         proposal_t *proposal;
 250         enumerator_t *enumerator;
 251
 252         id = this->ike_sa->get_id(this->ike_sa);
 253
 254         this->config = this->ike_sa->get_ike_cfg(this->ike_sa);
 255
 256         if (this->initiator)
 257         {
 258                 proposal_list = this->config->get_proposals(this->config);
 259                 if (this->old_sa)
 260                 {
 261                         /* include SPI of new IKE_SA when we are rekeying */
 262                         enumerator = proposal_list->create_enumerator(proposal_list);
 263                         while (enumerator->enumerate(enumerator, (void**)&proposal))
 264                         {
 265                                 proposal->set_spi(proposal, id->get_initiator_spi(id));
 266                         }
 267                         enumerator->destroy(enumerator);
 268                 }
 269
 270                 sa_payload = sa_payload_create_from_proposals_v2(proposal_list);
 271                 proposal_list->destroy_offset(proposal_list, offsetof(proposal_t, destroy));
 272         }
 273         else
 274         {
 275                 if (this->old_sa)
 276                 {
 277                         /* include SPI of new IKE_SA when we are rekeying */
 278                         this->proposal->set_spi(this->proposal, id->get_responder_spi(id));
 279                 }
 280                 sa_payload = sa_payload_create_from_proposal_v2(this->proposal);
 281         }
 282         message->add_payload(message, (payload_t*)sa_payload);
 283
 284         nonce_payload = nonce_payload_create(PLV2_NONCE);
 285         nonce_payload->set_nonce(nonce_payload, this->my_nonce);
 286         ke_payload = ke_payload_create_from_diffie_hellman(PLV2_KEY_EXCHANGE,
 287                                                                                                            this->dh);
 288         if (!ke_payload)
 289         {
 290                 DBG1(DBG_IKE, "creating KE payload failed");
 291                 return FALSE;
 292         }
 293
 294         if (this->old_sa)
 295         {       /* payload order differs if we are rekeying */
 296                 message->add_payload(message, (payload_t*)nonce_payload);
 297                 message->add_payload(message, (payload_t*)ke_payload);
 298         }
 299         else
 300         {
 301                 message->add_payload(message, (payload_t*)ke_payload);
 302                 message->add_payload(message, (payload_t*)nonce_payload);
 303         }
 304
 305         /* negotiate fragmentation if we are not rekeying */
 306         if (!this->old_sa &&
 307                  this->config->fragmentation(this->config) != FRAGMENTATION_NO)
 308         {
 309                 if (this->initiator ||
 310                         this->ike_sa->supports_extension(this->ike_sa,
 311                                                                                          EXT_IKE_FRAGMENTATION))
 312                 {
 313                         message->add_notify(message, FALSE, FRAGMENTATION_SUPPORTED,
 314                                                                 chunk_empty);
 315                 }
 316         }
 317         /* submit supported hash algorithms for signature authentication */
 318         if (!this->old_sa && this->signature_authentication)
 319         {
 320                 if (this->initiator ||
 321                         this->ike_sa->supports_extension(this->ike_sa,
 322                                                                                          EXT_SIGNATURE_AUTH))
 323                 {
 324                         send_supported_hash_algorithms(this, message);
 325                 }
 326         }
 327         /* notify other peer if we support redirection */
 328         if (!this->old_sa && this->initiator)
 329         {
 330                 message->add_notify(message, FALSE, REDIRECT_SUPPORTED, chunk_empty);
 331         }
 332         return TRUE;
 333 }
 334
 335 /**
 336  * Read payloads from message
 337  */
 338 static void process_payloads(private_ike_init_t *this, message_t *message)
 339 {
 340         enumerator_t *enumerator;
 341         payload_t *payload;
 342         ke_payload_t *ke_payload = NULL;
 343
 344         enumerator = message->create_payload_enumerator(message);
 345         while (enumerator->enumerate(enumerator, &payload))
 346         {
 347                 switch (payload->get_type(payload))
 348                 {
 349                         case PLV2_SECURITY_ASSOCIATION:
 350                         {
 351                                 sa_payload_t *sa_payload = (sa_payload_t*)payload;
 352                                 linked_list_t *proposal_list;
 353                                 bool private;
 354
 355                                 proposal_list = sa_payload->get_proposals(sa_payload);
 356                                 private = this->ike_sa->supports_extension(this->ike_sa,
 357                                                                                                                    EXT_STRONGSWAN);
 358                                 this->proposal = this->config->select_proposal(this->config,
 359                                                                                                                 proposal_list, private);
 360                                 if (!this->proposal)
 361                                 {
 362                                         charon->bus->alert(charon->bus, ALERT_PROPOSAL_MISMATCH_IKE,
 363                                                                            proposal_list);
 364                                 }
 365                                 proposal_list->destroy_offset(proposal_list,
 366                                                                                           offsetof(proposal_t, destroy));
 367                                 break;
 368                         }
 369                         case PLV2_KEY_EXCHANGE:
 370                         {
 371                                 ke_payload = (ke_payload_t*)payload;
 372
 373                                 this->dh_group = ke_payload->get_dh_group_number(ke_payload);
 374                                 break;
 375                         }
 376                         case PLV2_NONCE:
 377                         {
 378                                 nonce_payload_t *nonce_payload = (nonce_payload_t*)payload;
 379
 380                                 this->other_nonce = nonce_payload->get_nonce(nonce_payload);
 381                                 break;
 382                         }
 383                         case PLV2_NOTIFY:
 384                         {
 385                                 notify_payload_t *notify = (notify_payload_t*)payload;
 386
 387                                 switch (notify->get_notify_type(notify))
 388                                 {
 389                                         case FRAGMENTATION_SUPPORTED:
 390                                                 this->ike_sa->enable_extension(this->ike_sa,
 391                                                                                                            EXT_IKE_FRAGMENTATION);
 392                                                 break;
 393                                         case SIGNATURE_HASH_ALGORITHMS:
 394                                                 if (this->signature_authentication)
 395                                                 {
 396                                                         handle_supported_hash_algorithms(this, notify);
 397                                                 }
 398                                                 break;
 399                                         case REDIRECT_SUPPORTED:
 400                                                 this->ike_sa->enable_extension(this->ike_sa,
 401                                                                                                            EXT_IKE_REDIRECTION);
 402                                                 break;
 403                                         default:
 404                                                 /* other notifies are handled elsewhere */
 405                                                 break;
 406                                 }
 407
 408                         }
 409                         default:
 410                                 break;
 411                 }
 412         }
 413         enumerator->destroy(enumerator);
 414
 415         if (ke_payload && this->proposal &&
 416                 this->proposal->has_dh_group(this->proposal, this->dh_group))
 417         {
 418                 if (!this->initiator)
 419                 {
 420                         this->dh = this->keymat->keymat.create_dh(
 421                                                                 &this->keymat->keymat, this->dh_group);
 422                 }
 423                 if (this->dh)
 424                 {
 425                         this->dh_failed = !this->dh->set_other_public_value(this->dh,
 426                                                                 ke_payload->get_key_exchange_data(ke_payload));
 427                 }
 428         }
 429 }
 430
 431 METHOD(task_t, build_i, status_t,
 432         private_ike_init_t *this, message_t *message)
 433 {
 434         this->config = this->ike_sa->get_ike_cfg(this->ike_sa);
 435         DBG0(DBG_IKE, "initiating IKE_SA %s[%d] to %H",
 436                  this->ike_sa->get_name(this->ike_sa),
 437                  this->ike_sa->get_unique_id(this->ike_sa),
 438                  this->ike_sa->get_other_host(this->ike_sa));
 439         this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
 440
 441         if (this->retry >= MAX_RETRIES)
 442         {
 443                 DBG1(DBG_IKE, "giving up after %d retries", MAX_RETRIES);
 444                 return FAILED;
 445         }
 446
 447         /* if the DH group is set via use_dh_group(), we already have a DH object */
 448         if (!this->dh)
 449         {
 450                 this->dh_group = this->config->get_dh_group(this->config);
 451                 this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
 452                                                                                                   this->dh_group);
 453                 if (!this->dh)
 454                 {
 455                         DBG1(DBG_IKE, "configured DH group %N not supported",
 456                                 diffie_hellman_group_names, this->dh_group);
 457                         return FAILED;
 458                 }
 459         }
 460
 461         /* generate nonce only when we are trying the first time */
 462         if (this->my_nonce.ptr == NULL)
 463         {
 464                 if (!generate_nonce(this))
 465                 {
 466                         return FAILED;
 467                 }
 468         }
 469
 470         if (this->cookie.ptr)
 471         {
 472                 message->add_notify(message, FALSE, COOKIE, this->cookie);
 473         }
 474
 475         if (!build_payloads(this, message))
 476         {
 477                 return FAILED;
 478         }
 479
 480 #ifdef ME
 481         {
 482                 chunk_t connect_id = this->ike_sa->get_connect_id(this->ike_sa);
 483                 if (connect_id.ptr)
 484                 {
 485                         message->add_notify(message, FALSE, ME_CONNECTID, connect_id);
 486                 }
 487         }
 488 #endif /* ME */
 489
 490         return NEED_MORE;
 491 }
 492
 493 METHOD(task_t, process_r,  status_t,
 494         private_ike_init_t *this, message_t *message)
 495 {
 496         this->config = this->ike_sa->get_ike_cfg(this->ike_sa);
 497         DBG0(DBG_IKE, "%H is initiating an IKE_SA", message->get_source(message));
 498         this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
 499
 500         if (!generate_nonce(this))
 501         {
 502                 return FAILED;
 503         }
 504
 505 #ifdef ME
 506         {
 507                 notify_payload_t *notify = message->get_notify(message, ME_CONNECTID);
 508                 if (notify)
 509                 {
 510                         chunk_t connect_id = notify->get_notification_data(notify);
 511                         DBG2(DBG_IKE, "received ME_CONNECTID %#B", &connect_id);
 512                         charon->connect_manager->stop_checks(charon->connect_manager,
 513                                                                                                  connect_id);
 514                 }
 515         }
 516 #endif /* ME */
 517
 518         process_payloads(this, message);
 519
 520         return NEED_MORE;
 521 }
 522
 523 /**
 524  * Derive the keymat for the IKE_SA
 525  */
 526 static bool derive_keys(private_ike_init_t *this,
 527                                                 chunk_t nonce_i, chunk_t nonce_r)
 528 {
 529         keymat_v2_t *old_keymat;
 530         pseudo_random_function_t prf_alg = PRF_UNDEFINED;
 531         chunk_t skd = chunk_empty;
 532         ike_sa_id_t *id;
 533
 534         id = this->ike_sa->get_id(this->ike_sa);
 535         if (this->old_sa)
 536         {
 537                 /* rekeying: Include old SKd, use old PRF, apply SPI */
 538                 old_keymat = (keymat_v2_t*)this->old_sa->get_keymat(this->old_sa);
 539                 prf_alg = old_keymat->get_skd(old_keymat, &skd);
 540                 if (this->initiator)
 541                 {
 542                         id->set_responder_spi(id, this->proposal->get_spi(this->proposal));
 543                 }
 544                 else
 545                 {
 546                         id->set_initiator_spi(id, this->proposal->get_spi(this->proposal));
 547                 }
 548         }
 549         if (!this->keymat->derive_ike_keys(this->keymat, this->proposal, this->dh,
 550                                                                            nonce_i, nonce_r, id, prf_alg, skd))
 551         {
 552                 return FALSE;
 553         }
 554         charon->bus->ike_keys(charon->bus, this->ike_sa, this->dh, chunk_empty,
 555                                                   nonce_i, nonce_r, this->old_sa, NULL);
 556         return TRUE;
 557 }
 558
 559 METHOD(task_t, build_r, status_t,
 560         private_ike_init_t *this, message_t *message)
 561 {
 562         identification_t *gateway;
 563
 564         /* check if we have everything we need */
 565         if (this->proposal == NULL ||
 566                 this->other_nonce.len == 0 || this->my_nonce.len == 0)
 567         {
 568                 DBG1(DBG_IKE, "received proposals inacceptable");
 569                 message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
 570                 return FAILED;
 571         }
 572         this->ike_sa->set_proposal(this->ike_sa, this->proposal);
 573
 574         /* check if we'd have to redirect the client */
 575         if (this->ike_sa->supports_extension(this->ike_sa, EXT_IKE_REDIRECTION) &&
 576                 charon->redirect->redirect_on_init(charon->redirect, this->ike_sa,
 577                                                                                    &gateway))
 578         {
 579                 chunk_t data;
 580
 581                 DBG1(DBG_IKE, "redirecting peer to %Y", gateway);
 582                 data = redirect_data_create(gateway, this->other_nonce);
 583                 message->add_notify(message, TRUE, REDIRECT, data);
 584                 gateway->destroy(gateway);
 585                 chunk_free(&data);
 586                 return FAILED;
 587         }
 588
 589         if (this->dh == NULL ||
 590                 !this->proposal->has_dh_group(this->proposal, this->dh_group))
 591         {
 592                 u_int16_t group;
 593
 594                 if (this->proposal->get_algorithm(this->proposal, DIFFIE_HELLMAN_GROUP,
 595                                                                                   &group, NULL))
 596                 {
 597                         DBG1(DBG_IKE, "DH group %N inacceptable, requesting %N",
 598                                  diffie_hellman_group_names, this->dh_group,
 599                                  diffie_hellman_group_names, group);
 600                         this->dh_group = group;
 601                         group = htons(group);
 602                         message->add_notify(message, FALSE, INVALID_KE_PAYLOAD,
 603                                                                 chunk_from_thing(group));
 604                 }
 605                 else
 606                 {
 607                         DBG1(DBG_IKE, "no acceptable proposal found");
 608                 }
 609                 return FAILED;
 610         }
 611
 612         if (this->dh_failed)
 613         {
 614                 DBG1(DBG_IKE, "applying DH public value failed");
 615                 message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
 616                 return FAILED;
 617         }
 618
 619         if (!derive_keys(this, this->other_nonce, this->my_nonce))
 620         {
 621                 DBG1(DBG_IKE, "key derivation failed");
 622                 message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
 623                 return FAILED;
 624         }
 625         if (!build_payloads(this, message))
 626         {
 627                 message->add_notify(message, TRUE, NO_PROPOSAL_CHOSEN, chunk_empty);
 628                 return FAILED;
 629         }
 630         return SUCCESS;
 631 }
 632
 633 /**
 634  * Raise alerts for received notify errors
 635  */
 636 static void raise_alerts(private_ike_init_t *this, notify_type_t type)
 637 {
 638         linked_list_t *list;
 639
 640         switch (type)
 641         {
 642                 case NO_PROPOSAL_CHOSEN:
 643                         list = this->config->get_proposals(this->config);
 644                         charon->bus->alert(charon->bus, ALERT_PROPOSAL_MISMATCH_IKE, list);
 645                         list->destroy_offset(list, offsetof(proposal_t, destroy));
 646                         break;
 647                 default:
 648                         break;
 649         }
 650 }
 651
 652 METHOD(task_t, process_i, status_t,
 653         private_ike_init_t *this, message_t *message)
 654 {
 655         enumerator_t *enumerator;
 656         payload_t *payload;
 657
 658         /* check for erroneous notifies */
 659         enumerator = message->create_payload_enumerator(message);
 660         while (enumerator->enumerate(enumerator, &payload))
 661         {
 662                 if (payload->get_type(payload) == PLV2_NOTIFY)
 663                 {
 664                         notify_payload_t *notify = (notify_payload_t*)payload;
 665                         notify_type_t type = notify->get_notify_type(notify);
 666
 667                         switch (type)
 668                         {
 669                                 case INVALID_KE_PAYLOAD:
 670                                 {
 671                                         chunk_t data;
 672                                         diffie_hellman_group_t bad_group;
 673
 674                                         bad_group = this->dh_group;
 675                                         data = notify->get_notification_data(notify);
 676                                         this->dh_group = ntohs(*((u_int16_t*)data.ptr));
 677                                         DBG1(DBG_IKE, "peer didn't accept DH group %N, "
 678                                                  "it requested %N", diffie_hellman_group_names,
 679                                                  bad_group, diffie_hellman_group_names, this->dh_group);
 680
 681                                         if (this->old_sa == NULL)
 682                                         {       /* reset the IKE_SA if we are not rekeying */
 683                                                 this->ike_sa->reset(this->ike_sa);
 684                                         }
 685
 686                                         enumerator->destroy(enumerator);
 687                                         this->retry++;
 688                                         return NEED_MORE;
 689                                 }
 690                                 case NAT_DETECTION_SOURCE_IP:
 691                                 case NAT_DETECTION_DESTINATION_IP:
 692                                         /* skip, handled in ike_natd_t */
 693                                         break;
 694                                 case MULTIPLE_AUTH_SUPPORTED:
 695                                         /* handled in ike_auth_t */
 696                                         break;
 697                                 case COOKIE:
 698                                 {
 699                                         chunk_free(&this->cookie);
 700                                         this->cookie = chunk_clone(notify->get_notification_data(notify));
 701                                         this->ike_sa->reset(this->ike_sa);
 702                                         enumerator->destroy(enumerator);
 703                                         DBG2(DBG_IKE, "received %N notify", notify_type_names, type);
 704                                         this->retry++;
 705                                         return NEED_MORE;
 706                                 }
 707                                 case REDIRECT:
 708                                 {
 709                                         identification_t *gateway;
 710                                         chunk_t data, nonce = chunk_empty;
 711                                         status_t status = FAILED;
 712
 713                                         data = notify->get_notification_data(notify);
 714                                         gateway = redirect_data_parse(data, &nonce);
 715                                         enumerator->destroy(enumerator);
 716                                         if (!gateway || !chunk_equals(nonce, this->my_nonce))
 717                                         {
 718                                                 DBG1(DBG_IKE, "received invalid REDIRECT notify");
 719                                         }
 720                                         else if (this->ike_sa->handle_redirect(this->ike_sa,
 721                                                                                                                         gateway))
 722                                         {
 723                                                 status = NEED_MORE;
 724                                         }
 725                                         DESTROY_IF(gateway);
 726                                         chunk_free(&nonce);
 727                                         return status;
 728                                 }
 729                                 default:
 730                                 {
 731                                         if (type <= 16383)
 732                                         {
 733                                                 DBG1(DBG_IKE, "received %N notify error",
 734                                                          notify_type_names, type);
 735                                                 enumerator->destroy(enumerator);
 736                                                 raise_alerts(this, type);
 737                                                 return FAILED;
 738                                         }
 739                                         DBG2(DBG_IKE, "received %N notify",
 740                                                 notify_type_names, type);
 741                                         break;
 742                                 }
 743                         }
 744                 }
 745         }
 746         enumerator->destroy(enumerator);
 747
 748         process_payloads(this, message);
 749
 750         /* check if we have everything */
 751         if (this->proposal == NULL ||
 752                 this->other_nonce.len == 0 || this->my_nonce.len == 0)
 753         {
 754                 DBG1(DBG_IKE, "peers proposal selection invalid");
 755                 return FAILED;
 756         }
 757         this->ike_sa->set_proposal(this->ike_sa, this->proposal);
 758
 759         if (this->dh == NULL ||
 760                 !this->proposal->has_dh_group(this->proposal, this->dh_group))
 761         {
 762                 DBG1(DBG_IKE, "peer DH group selection invalid");
 763                 return FAILED;
 764         }
 765
 766         if (this->dh_failed)
 767         {
 768                 DBG1(DBG_IKE, "applying DH public value failed");
 769                 return FAILED;
 770         }
 771
 772         if (!derive_keys(this, this->my_nonce, this->other_nonce))
 773         {
 774                 DBG1(DBG_IKE, "key derivation failed");
 775                 return FAILED;
 776         }
 777         return SUCCESS;
 778 }
 779
 780 METHOD(task_t, get_type, task_type_t,
 781         private_ike_init_t *this)
 782 {
 783         return TASK_IKE_INIT;
 784 }
 785
 786 METHOD(task_t, migrate, void,
 787         private_ike_init_t *this, ike_sa_t *ike_sa)
 788 {
 789         DESTROY_IF(this->proposal);
 790         chunk_free(&this->other_nonce);
 791
 792         this->ike_sa = ike_sa;
 793         this->keymat = (keymat_v2_t*)ike_sa->get_keymat(ike_sa);
 794         this->proposal = NULL;
 795         this->dh_failed = FALSE;
 796         if (this->dh && this->dh->get_dh_group(this->dh) != this->dh_group)
 797         {       /* reset DH value only if group changed (INVALID_KE_PAYLOAD) */
 798                 this->dh->destroy(this->dh);
 799                 this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
 800                                                                                                   this->dh_group);
 801         }
 802 }
 803
 804 METHOD(task_t, destroy, void,
 805         private_ike_init_t *this)
 806 {
 807         DESTROY_IF(this->dh);
 808         DESTROY_IF(this->proposal);
 809         DESTROY_IF(this->nonceg);
 810         chunk_free(&this->my_nonce);
 811         chunk_free(&this->other_nonce);
 812         chunk_free(&this->cookie);
 813         free(this);
 814 }
 815
 816 METHOD(ike_init_t, get_lower_nonce, chunk_t,
 817         private_ike_init_t *this)
 818 {
 819         if (memcmp(this->my_nonce.ptr, this->other_nonce.ptr,
 820                            min(this->my_nonce.len, this->other_nonce.len)) < 0)
 821         {
 822                 return this->my_nonce;
 823         }
 824         else
 825         {
 826                 return this->other_nonce;
 827         }
 828 }
 829
 830 /*
 831  * Described in header.
 832  */
 833 ike_init_t *ike_init_create(ike_sa_t *ike_sa, bool initiator, ike_sa_t *old_sa)
 834 {
 835         private_ike_init_t *this;
 836
 837         INIT(this,
 838                 .public = {
 839                         .task = {
 840                                 .get_type = _get_type,
 841                                 .migrate = _migrate,
 842                                 .destroy = _destroy,
 843                         },
 844                         .get_lower_nonce = _get_lower_nonce,
 845                 },
 846                 .ike_sa = ike_sa,
 847                 .initiator = initiator,
 848                 .dh_group = MODP_NONE,
 849                 .keymat = (keymat_v2_t*)ike_sa->get_keymat(ike_sa),
 850                 .old_sa = old_sa,
 851                 .signature_authentication = lib->settings->get_bool(lib->settings,
 852                                                                 "%s.signature_authentication", TRUE, lib->ns),
 853         );
 854         this->nonceg = this->keymat->keymat.create_nonce_gen(&this->keymat->keymat);
 855
 856         if (initiator)
 857         {
 858                 this->public.task.build = _build_i;
 859                 this->public.task.process = _process_i;
 860         }
 861         else
 862         {
 863                 this->public.task.build = _build_r;
 864                 this->public.task.process = _process_r;
 865         }
 866         return &this->public;
 867 }