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

   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 "child_create.h"
  19
  20 #include <daemon.h>
  21 #include <sa/ikev2/keymat_v2.h>
  22 #include <crypto/diffie_hellman.h>
  23 #include <credentials/certificates/x509.h>
  24 #include <encoding/payloads/sa_payload.h>
  25 #include <encoding/payloads/ke_payload.h>
  26 #include <encoding/payloads/ts_payload.h>
  27 #include <encoding/payloads/nonce_payload.h>
  28 #include <encoding/payloads/notify_payload.h>
  29 #include <encoding/payloads/delete_payload.h>
  30 #include <processing/jobs/delete_ike_sa_job.h>
  31 #include <processing/jobs/inactivity_job.h>
  32 #include <processing/jobs/initiate_tasks_job.h>
  33
  34 typedef struct private_child_create_t private_child_create_t;
  35
  36 /**
  37  * Private members of a child_create_t task.
  38  */
  39 struct private_child_create_t {
  40
  41         /**
  42          * Public methods and task_t interface.
  43          */
  44         child_create_t public;
  45
  46         /**
  47          * Assigned IKE_SA.
  48          */
  49         ike_sa_t *ike_sa;
  50
  51         /**
  52          * Are we the initiator?
  53          */
  54         bool initiator;
  55
  56         /**
  57          * nonce chosen by us
  58          */
  59         chunk_t my_nonce;
  60
  61         /**
  62          * nonce chosen by peer
  63          */
  64         chunk_t other_nonce;
  65
  66         /**
  67          * nonce generator
  68          */
  69         nonce_gen_t *nonceg;
  70
  71         /**
  72          * config to create the CHILD_SA from
  73          */
  74         child_cfg_t *config;
  75
  76         /**
  77          * list of proposal candidates
  78          */
  79         linked_list_t *proposals;
  80
  81         /**
  82          * selected proposal to use for CHILD_SA
  83          */
  84         proposal_t *proposal;
  85
  86         /**
  87          * traffic selectors for initiators side
  88          */
  89         linked_list_t *tsi;
  90
  91         /**
  92          * traffic selectors for responders side
  93          */
  94         linked_list_t *tsr;
  95
  96         /**
  97          * source of triggering packet
  98          */
  99         traffic_selector_t *packet_tsi;
 100
 101         /**
 102          * destination of triggering packet
 103          */
 104         traffic_selector_t *packet_tsr;
 105
 106         /**
 107          * optional diffie hellman exchange
 108          */
 109         diffie_hellman_t *dh;
 110
 111         /**
 112          * Applying DH public value failed?
 113          */
 114         bool dh_failed;
 115
 116         /**
 117          * group used for DH exchange
 118          */
 119         diffie_hellman_group_t dh_group;
 120
 121         /**
 122          * IKE_SAs keymat
 123          */
 124         keymat_v2_t *keymat;
 125
 126         /**
 127          * mode the new CHILD_SA uses (transport/tunnel/beet)
 128          */
 129         ipsec_mode_t mode;
 130
 131         /**
 132          * peer accepts TFC padding for this SA
 133          */
 134         bool tfcv3;
 135
 136         /**
 137          * IPComp transform to use
 138          */
 139         ipcomp_transform_t ipcomp;
 140
 141         /**
 142          * IPComp transform proposed or accepted by the other peer
 143          */
 144         ipcomp_transform_t ipcomp_received;
 145
 146         /**
 147          * IPsec protocol
 148          */
 149         protocol_id_t proto;
 150
 151         /**
 152          * Own allocated SPI
 153          */
 154         uint32_t my_spi;
 155
 156         /**
 157          * SPI received in proposal
 158          */
 159         uint32_t other_spi;
 160
 161         /**
 162          * Own allocated Compression Parameter Index (CPI)
 163          */
 164         uint16_t my_cpi;
 165
 166         /**
 167          * Other Compression Parameter Index (CPI), received via IPCOMP_SUPPORTED
 168          */
 169         uint16_t other_cpi;
 170
 171         /**
 172          * Data collected to create the CHILD_SA
 173          */
 174         child_sa_create_t child;
 175
 176         /**
 177          * CHILD_SA which gets established
 178          */
 179         child_sa_t *child_sa;
 180
 181         /**
 182          * successfully established the CHILD?
 183          */
 184         bool established;
 185
 186         /**
 187          * whether the CHILD_SA rekeys an existing one
 188          */
 189         bool rekey;
 190
 191         /**
 192          * whether we are retrying with another DH group
 193          */
 194         bool retry;
 195 };
 196
 197 /**
 198  * Schedule a retry if creating the CHILD_SA temporary failed
 199  */
 200 static void schedule_delayed_retry(private_child_create_t *this)
 201 {
 202         child_create_t *task;
 203         uint32_t retry;
 204
 205         retry = RETRY_INTERVAL - (random() % RETRY_JITTER);
 206
 207         task = child_create_create(this->ike_sa,
 208                                                            this->config->get_ref(this->config), FALSE,
 209                                                            this->packet_tsi, this->packet_tsr);
 210         task->use_reqid(task, this->child.reqid);
 211         task->use_marks(task, this->child.mark_in, this->child.mark_out);
 212         task->use_if_ids(task, this->child.if_id_in, this->child.if_id_out);
 213
 214         DBG1(DBG_IKE, "creating CHILD_SA failed, trying again in %d seconds",
 215                  retry);
 216         this->ike_sa->queue_task_delayed(this->ike_sa, (task_t*)task, retry);
 217 }
 218
 219 /**
 220  * get the nonce from a message
 221  */
 222 static status_t get_nonce(message_t *message, chunk_t *nonce)
 223 {
 224         nonce_payload_t *payload;
 225
 226         payload = (nonce_payload_t*)message->get_payload(message, PLV2_NONCE);
 227         if (payload == NULL)
 228         {
 229                 return FAILED;
 230         }
 231         *nonce = payload->get_nonce(payload);
 232         return NEED_MORE;
 233 }
 234
 235 /**
 236  * generate a new nonce to include in a CREATE_CHILD_SA message
 237  */
 238 static bool generate_nonce(private_child_create_t *this)
 239 {
 240         this->nonceg = this->keymat->keymat.create_nonce_gen(&this->keymat->keymat);
 241         if (!this->nonceg)
 242         {
 243                 DBG1(DBG_IKE, "no nonce generator found to create nonce");
 244                 return FALSE;
 245         }
 246         if (!this->nonceg->allocate_nonce(this->nonceg, NONCE_SIZE,
 247                                                                           &this->my_nonce))
 248         {
 249                 DBG1(DBG_IKE, "nonce allocation failed");
 250                 return FALSE;
 251         }
 252         return TRUE;
 253 }
 254
 255 /**
 256  * Check a list of traffic selectors if any selector belongs to host
 257  */
 258 static bool ts_list_is_host(linked_list_t *list, host_t *host)
 259 {
 260         traffic_selector_t *ts;
 261         bool is_host = TRUE;
 262         enumerator_t *enumerator = list->create_enumerator(list);
 263
 264         while (is_host && enumerator->enumerate(enumerator, (void**)&ts))
 265         {
 266                 is_host = is_host && ts->is_host(ts, host);
 267         }
 268         enumerator->destroy(enumerator);
 269         return is_host;
 270 }
 271
 272 /**
 273  * Allocate local SPI
 274  */
 275 static bool allocate_spi(private_child_create_t *this)
 276 {
 277         proposal_t *proposal;
 278
 279         if (this->initiator)
 280         {
 281                 this->proto = PROTO_ESP;
 282                 /* we just get a SPI for the first protocol. TODO: If we ever support
 283                  * proposal lists with mixed protocols, we'd need multiple SPIs */
 284                 if (this->proposals->get_first(this->proposals,
 285                                                                            (void**)&proposal) == SUCCESS)
 286                 {
 287                         this->proto = proposal->get_protocol(proposal);
 288                 }
 289         }
 290         else
 291         {
 292                 this->proto = this->proposal->get_protocol(this->proposal);
 293         }
 294         this->my_spi = this->child_sa->alloc_spi(this->child_sa, this->proto);
 295         return this->my_spi != 0;
 296 }
 297
 298 /**
 299  * Update the proposals with the allocated SPIs as initiator and check the DH
 300  * group and promote it if necessary
 301  */
 302 static bool update_and_check_proposals(private_child_create_t *this)
 303 {
 304         enumerator_t *enumerator;
 305         proposal_t *proposal;
 306         linked_list_t *other_dh_groups;
 307         bool found = FALSE;
 308
 309         other_dh_groups = linked_list_create();
 310         enumerator = this->proposals->create_enumerator(this->proposals);
 311         while (enumerator->enumerate(enumerator, &proposal))
 312         {
 313                 proposal->set_spi(proposal, this->my_spi);
 314
 315                 /* move the selected DH group to the front, if any */
 316                 if (this->dh_group != MODP_NONE)
 317                 {       /* proposals that don't contain the selected group are
 318                          * moved to the back */
 319                         if (!proposal->promote_dh_group(proposal, this->dh_group))
 320                         {
 321                                 this->proposals->remove_at(this->proposals, enumerator);
 322                                 other_dh_groups->insert_last(other_dh_groups, proposal);
 323                         }
 324                         else
 325                         {
 326                                 found = TRUE;
 327                         }
 328                 }
 329         }
 330         enumerator->destroy(enumerator);
 331         enumerator = other_dh_groups->create_enumerator(other_dh_groups);
 332         while (enumerator->enumerate(enumerator, (void**)&proposal))
 333         {       /* no need to remove from the list as we destroy it anyway*/
 334                 this->proposals->insert_last(this->proposals, proposal);
 335         }
 336         enumerator->destroy(enumerator);
 337         other_dh_groups->destroy(other_dh_groups);
 338
 339         return this->dh_group == MODP_NONE || found;
 340 }
 341
 342 /**
 343  * Schedule inactivity timeout for CHILD_SA with reqid, if enabled
 344  */
 345 static void schedule_inactivity_timeout(private_child_create_t *this)
 346 {
 347         uint32_t timeout, id;
 348         bool close_ike;
 349
 350         timeout = this->config->get_inactivity(this->config);
 351         if (timeout)
 352         {
 353                 close_ike = lib->settings->get_bool(lib->settings,
 354                                                                         "%s.inactivity_close_ike", FALSE, lib->ns);
 355                 id = this->child_sa->get_unique_id(this->child_sa);
 356                 lib->scheduler->schedule_job(lib->scheduler, (job_t*)
 357                                                 inactivity_job_create(id, timeout, close_ike), timeout);
 358         }
 359 }
 360
 361 /**
 362  * Check if we have a an address pool configured
 363  */
 364 static bool have_pool(ike_sa_t *ike_sa)
 365 {
 366         enumerator_t *enumerator;
 367         peer_cfg_t *peer_cfg;
 368         char *pool;
 369         bool found = FALSE;
 370
 371         peer_cfg = ike_sa->get_peer_cfg(ike_sa);
 372         if (peer_cfg)
 373         {
 374                 enumerator = peer_cfg->create_pool_enumerator(peer_cfg);
 375                 if (enumerator->enumerate(enumerator, &pool))
 376                 {
 377                         found = TRUE;
 378                 }
 379                 enumerator->destroy(enumerator);
 380         }
 381         return found;
 382 }
 383
 384 /**
 385  * Get hosts to use for dynamic traffic selectors
 386  */
 387 static linked_list_t *get_dynamic_hosts(ike_sa_t *ike_sa, bool local)
 388 {
 389         enumerator_t *enumerator;
 390         linked_list_t *list;
 391         host_t *host;
 392
 393         list = linked_list_create();
 394         enumerator = ike_sa->create_virtual_ip_enumerator(ike_sa, local);
 395         while (enumerator->enumerate(enumerator, &host))
 396         {
 397                 list->insert_last(list, host);
 398         }
 399         enumerator->destroy(enumerator);
 400
 401         if (list->get_count(list) == 0)
 402         {       /* no virtual IPs assigned */
 403                 if (local)
 404                 {
 405                         host = ike_sa->get_my_host(ike_sa);
 406                         list->insert_last(list, host);
 407                 }
 408                 else if (!have_pool(ike_sa))
 409                 {       /* use host only if we don't have a pool configured */
 410                         host = ike_sa->get_other_host(ike_sa);
 411                         list->insert_last(list, host);
 412                 }
 413         }
 414         return list;
 415 }
 416
 417 /**
 418  * Substitute any host address with NATed address in traffic selector
 419  */
 420 static linked_list_t* get_transport_nat_ts(private_child_create_t *this,
 421                                                                                    bool local, linked_list_t *in)
 422 {
 423         enumerator_t *enumerator;
 424         linked_list_t *out;
 425         traffic_selector_t *ts;
 426         host_t *ike, *first = NULL;
 427         uint8_t mask;
 428
 429         if (local)
 430         {
 431                 ike = this->ike_sa->get_my_host(this->ike_sa);
 432         }
 433         else
 434         {
 435                 ike = this->ike_sa->get_other_host(this->ike_sa);
 436         }
 437
 438         out = linked_list_create();
 439
 440         enumerator = in->create_enumerator(in);
 441         while (enumerator->enumerate(enumerator, &ts))
 442         {
 443                 /* require that all selectors match the first "host" selector */
 444                 if (ts->is_host(ts, first))
 445                 {
 446                         if (!first)
 447                         {
 448                                 ts->to_subnet(ts, &first, &mask);
 449                         }
 450                         ts = ts->clone(ts);
 451                         ts->set_address(ts, ike);
 452                         out->insert_last(out, ts);
 453                 }
 454         }
 455         enumerator->destroy(enumerator);
 456         DESTROY_IF(first);
 457
 458         return out;
 459 }
 460
 461 /**
 462  * Narrow received traffic selectors with configuration
 463  */
 464 static linked_list_t* narrow_ts(private_child_create_t *this, bool local,
 465                                                                 linked_list_t *in)
 466 {
 467         linked_list_t *hosts, *nat, *ts;
 468         ike_condition_t cond;
 469
 470         cond = local ? COND_NAT_HERE : COND_NAT_THERE;
 471         hosts = get_dynamic_hosts(this->ike_sa, local);
 472
 473         if (this->mode == MODE_TRANSPORT &&
 474                 this->ike_sa->has_condition(this->ike_sa, cond))
 475         {
 476                 nat = get_transport_nat_ts(this, local, in);
 477                 ts = this->config->get_traffic_selectors(this->config, local, nat,
 478                                                                                                  hosts, TRUE);
 479                 nat->destroy_offset(nat, offsetof(traffic_selector_t, destroy));
 480         }
 481         else
 482         {
 483                 ts = this->config->get_traffic_selectors(this->config, local, in,
 484                                                                                                  hosts, TRUE);
 485         }
 486
 487         hosts->destroy(hosts);
 488
 489         return ts;
 490 }
 491
 492 /**
 493  * Check if requested mode is acceptable
 494  */
 495 static bool check_mode(private_child_create_t *this, host_t *i, host_t *r)
 496 {
 497         switch (this->mode)
 498         {
 499                 case MODE_TRANSPORT:
 500                         if (!this->config->has_option(this->config, OPT_PROXY_MODE) &&
 501                                    (!ts_list_is_host(this->tsi, i) ||
 502                                         !ts_list_is_host(this->tsr, r))
 503                            )
 504                         {
 505                                 DBG1(DBG_IKE, "not using transport mode, not host-to-host");
 506                                 return FALSE;
 507                         }
 508                         if (this->config->get_mode(this->config) != MODE_TRANSPORT)
 509                         {
 510                                 return FALSE;
 511                         }
 512                         break;
 513                 case MODE_BEET:
 514                         if (!ts_list_is_host(this->tsi, NULL) ||
 515                                 !ts_list_is_host(this->tsr, NULL))
 516                         {
 517                                 DBG1(DBG_IKE, "not using BEET mode, not host-to-host");
 518                                 return FALSE;
 519                         }
 520                         if (this->config->get_mode(this->config) != MODE_BEET)
 521                         {
 522                                 return FALSE;
 523                         }
 524                         break;
 525                 default:
 526                         break;
 527         }
 528         return TRUE;
 529 }
 530
 531 /**
 532  * Install a CHILD_SA for usage, return value:
 533  * - FAILED: no acceptable proposal
 534  * - INVALID_ARG: diffie hellman group unacceptable
 535  * - NOT_FOUND: TS unacceptable
 536  */
 537 static status_t select_and_install(private_child_create_t *this,
 538                                                                    bool no_dh, bool ike_auth)
 539 {
 540         status_t status, status_i, status_o;
 541         child_sa_outbound_state_t out_state;
 542         chunk_t nonce_i, nonce_r;
 543         chunk_t encr_i = chunk_empty, encr_r = chunk_empty;
 544         chunk_t integ_i = chunk_empty, integ_r = chunk_empty;
 545         linked_list_t *my_ts, *other_ts;
 546         host_t *me, *other;
 547         proposal_selection_flag_t flags = 0;
 548
 549         if (this->proposals == NULL)
 550         {
 551                 DBG1(DBG_IKE, "SA payload missing in message");
 552                 return FAILED;
 553         }
 554         if (this->tsi == NULL || this->tsr == NULL)
 555         {
 556                 DBG1(DBG_IKE, "TS payloads missing in message");
 557                 return NOT_FOUND;
 558         }
 559
 560         me = this->ike_sa->get_my_host(this->ike_sa);
 561         other = this->ike_sa->get_other_host(this->ike_sa);
 562
 563         if (no_dh)
 564         {
 565                 flags |= PROPOSAL_SKIP_DH;
 566         }
 567         if (!this->ike_sa->supports_extension(this->ike_sa, EXT_STRONGSWAN) &&
 568                 !lib->settings->get_bool(lib->settings, "%s.accept_private_algs",
 569                                                                  FALSE, lib->ns))
 570         {
 571                 flags |= PROPOSAL_SKIP_PRIVATE;
 572         }
 573         if (!lib->settings->get_bool(lib->settings,
 574                                                         "%s.prefer_configured_proposals", TRUE, lib->ns))
 575         {
 576                 flags |= PROPOSAL_PREFER_SUPPLIED;
 577         }
 578         this->proposal = this->config->select_proposal(this->config,
 579                                                                                                    this->proposals, flags);
 580         if (this->proposal == NULL)
 581         {
 582                 DBG1(DBG_IKE, "no acceptable proposal found");
 583                 charon->bus->alert(charon->bus, ALERT_PROPOSAL_MISMATCH_CHILD,
 584                                                    this->proposals);
 585                 return FAILED;
 586         }
 587         this->other_spi = this->proposal->get_spi(this->proposal);
 588
 589         if (!this->initiator)
 590         {
 591                 if (!allocate_spi(this))
 592                 {
 593                         /* responder has no SPI allocated yet */
 594                         DBG1(DBG_IKE, "allocating SPI failed");
 595                         return FAILED;
 596                 }
 597                 this->proposal->set_spi(this->proposal, this->my_spi);
 598         }
 599         this->child_sa->set_proposal(this->child_sa, this->proposal);
 600
 601         if (!this->proposal->has_dh_group(this->proposal, this->dh_group))
 602         {
 603                 uint16_t group;
 604
 605                 if (this->proposal->get_algorithm(this->proposal, DIFFIE_HELLMAN_GROUP,
 606                                                                                   &group, NULL))
 607                 {
 608                         DBG1(DBG_IKE, "DH group %N unacceptable, requesting %N",
 609                                  diffie_hellman_group_names, this->dh_group,
 610                                  diffie_hellman_group_names, group);
 611                         this->dh_group = group;
 612                         return INVALID_ARG;
 613                 }
 614                 /* the selected proposal does not use a DH group */
 615                 DBG1(DBG_IKE, "ignoring KE exchange, agreed on a non-PFS proposal");
 616                 DESTROY_IF(this->dh);
 617                 this->dh = NULL;
 618                 this->dh_group = MODP_NONE;
 619         }
 620
 621         if (this->initiator)
 622         {
 623                 nonce_i = this->my_nonce;
 624                 nonce_r = this->other_nonce;
 625                 my_ts = narrow_ts(this, TRUE, this->tsi);
 626                 other_ts = narrow_ts(this, FALSE, this->tsr);
 627         }
 628         else
 629         {
 630                 nonce_r = this->my_nonce;
 631                 nonce_i = this->other_nonce;
 632                 my_ts = narrow_ts(this, TRUE, this->tsr);
 633                 other_ts = narrow_ts(this, FALSE, this->tsi);
 634         }
 635
 636         if (this->initiator)
 637         {
 638                 if (ike_auth)
 639                 {
 640                         charon->bus->narrow(charon->bus, this->child_sa,
 641                                                                 NARROW_INITIATOR_POST_NOAUTH, my_ts, other_ts);
 642                 }
 643                 else
 644                 {
 645                         charon->bus->narrow(charon->bus, this->child_sa,
 646                                                                 NARROW_INITIATOR_POST_AUTH, my_ts, other_ts);
 647                 }
 648         }
 649         else
 650         {
 651                 charon->bus->narrow(charon->bus, this->child_sa,
 652                                                         NARROW_RESPONDER, my_ts, other_ts);
 653         }
 654
 655         if (my_ts->get_count(my_ts) == 0 || other_ts->get_count(other_ts) == 0)
 656         {
 657                 charon->bus->alert(charon->bus, ALERT_TS_MISMATCH, this->tsi, this->tsr);
 658                 my_ts->destroy_offset(my_ts, offsetof(traffic_selector_t, destroy));
 659                 other_ts->destroy_offset(other_ts, offsetof(traffic_selector_t, destroy));
 660                 DBG1(DBG_IKE, "no acceptable traffic selectors found");
 661                 return NOT_FOUND;
 662         }
 663
 664         this->tsr->destroy_offset(this->tsr, offsetof(traffic_selector_t, destroy));
 665         this->tsi->destroy_offset(this->tsi, offsetof(traffic_selector_t, destroy));
 666         if (this->initiator)
 667         {
 668                 this->tsi = my_ts;
 669                 this->tsr = other_ts;
 670
 671                 if (!check_mode(this, me, other))
 672                 {
 673                         DBG1(DBG_IKE, "%N mode requested by responder is unacceptable",
 674                                  ipsec_mode_names, this->mode);
 675                         return FAILED;
 676                 }
 677         }
 678         else
 679         {
 680                 this->tsr = my_ts;
 681                 this->tsi = other_ts;
 682
 683                 if (!check_mode(this, other, me))
 684                 {
 685                         this->mode = MODE_TUNNEL;
 686                 }
 687         }
 688
 689         if (!this->initiator)
 690         {
 691                 /* use a copy of the traffic selectors, as the POST hook should not
 692                  * change payloads */
 693                 my_ts = this->tsr->clone_offset(this->tsr,
 694                                                                                 offsetof(traffic_selector_t, clone));
 695                 other_ts = this->tsi->clone_offset(this->tsi,
 696                                                                                 offsetof(traffic_selector_t, clone));
 697                 charon->bus->narrow(charon->bus, this->child_sa,
 698                                                         NARROW_RESPONDER_POST, my_ts, other_ts);
 699
 700                 if (my_ts->get_count(my_ts) == 0 ||     other_ts->get_count(other_ts) == 0)
 701                 {
 702                         my_ts->destroy_offset(my_ts,
 703                                                                   offsetof(traffic_selector_t, destroy));
 704                         other_ts->destroy_offset(other_ts,
 705                                                                   offsetof(traffic_selector_t, destroy));
 706                         return NOT_FOUND;
 707                 }
 708         }
 709
 710         this->child_sa->set_policies(this->child_sa, my_ts, other_ts);
 711         if (!this->initiator)
 712         {
 713                 my_ts->destroy_offset(my_ts,
 714                                                           offsetof(traffic_selector_t, destroy));
 715                 other_ts->destroy_offset(other_ts,
 716                                                           offsetof(traffic_selector_t, destroy));
 717         }
 718
 719         this->child_sa->set_state(this->child_sa, CHILD_INSTALLING);
 720         this->child_sa->set_ipcomp(this->child_sa, this->ipcomp);
 721         this->child_sa->set_mode(this->child_sa, this->mode);
 722         this->child_sa->set_protocol(this->child_sa,
 723                                                                  this->proposal->get_protocol(this->proposal));
 724
 725         if (this->my_cpi == 0 || this->other_cpi == 0 || this->ipcomp == IPCOMP_NONE)
 726         {
 727                 this->my_cpi = this->other_cpi = 0;
 728                 this->ipcomp = IPCOMP_NONE;
 729         }
 730         status_i = status_o = FAILED;
 731         if (this->keymat->derive_child_keys(this->keymat, this->proposal,
 732                         this->dh, nonce_i, nonce_r, &encr_i, &integ_i, &encr_r, &integ_r))
 733         {
 734                 if (this->initiator)
 735                 {
 736                         status_i = this->child_sa->install(this->child_sa, encr_r, integ_r,
 737                                                         this->my_spi, this->my_cpi, this->initiator,
 738                                                         TRUE, this->tfcv3);
 739                 }
 740                 else
 741                 {
 742                         status_i = this->child_sa->install(this->child_sa, encr_i, integ_i,
 743                                                         this->my_spi, this->my_cpi, this->initiator,
 744                                                         TRUE, this->tfcv3);
 745                 }
 746                 if (this->rekey)
 747                 {       /* during rekeyings we install the outbound SA and/or policies
 748                          * separately: as responder when we receive the delete for the old
 749                          * SA, as initiator pretty much immediately in the ike-rekey task,
 750                          * unless there was a rekey collision that we lost */
 751                         if (this->initiator)
 752                         {
 753                                 status_o = this->child_sa->register_outbound(this->child_sa,
 754                                                         encr_i, integ_i, this->other_spi, this->other_cpi,
 755                                                         this->tfcv3);
 756                         }
 757                         else
 758                         {
 759                                 status_o = this->child_sa->register_outbound(this->child_sa,
 760                                                         encr_r, integ_r, this->other_spi, this->other_cpi,
 761                                                         this->tfcv3);
 762                         }
 763                 }
 764                 else if (this->initiator)
 765                 {
 766                         status_o = this->child_sa->install(this->child_sa, encr_i, integ_i,
 767                                                         this->other_spi, this->other_cpi, this->initiator,
 768                                                         FALSE, this->tfcv3);
 769                 }
 770                 else
 771                 {
 772                         status_o = this->child_sa->install(this->child_sa, encr_r, integ_r,
 773                                                         this->other_spi, this->other_cpi, this->initiator,
 774                                                         FALSE, this->tfcv3);
 775                 }
 776         }
 777
 778         if (status_i != SUCCESS || status_o != SUCCESS)
 779         {
 780                 DBG1(DBG_IKE, "unable to install %s%s%sIPsec SA (SAD) in kernel",
 781                         (status_i != SUCCESS) ? "inbound " : "",
 782                         (status_i != SUCCESS && status_o != SUCCESS) ? "and ": "",
 783                         (status_o != SUCCESS) ? "outbound " : "");
 784                 charon->bus->alert(charon->bus, ALERT_INSTALL_CHILD_SA_FAILED,
 785                                                    this->child_sa);
 786                 status = FAILED;
 787         }
 788         else
 789         {
 790                 status = this->child_sa->install_policies(this->child_sa);
 791
 792                 if (status != SUCCESS)
 793                 {
 794                         DBG1(DBG_IKE, "unable to install IPsec policies (SPD) in kernel");
 795                         charon->bus->alert(charon->bus, ALERT_INSTALL_CHILD_POLICY_FAILED,
 796                                                            this->child_sa);
 797                         status = NOT_FOUND;
 798                 }
 799                 else
 800                 {
 801                         charon->bus->child_derived_keys(charon->bus, this->child_sa,
 802                                                                                         this->initiator, encr_i, encr_r,
 803                                                                                         integ_i, integ_r);
 804                 }
 805         }
 806         chunk_clear(&integ_i);
 807         chunk_clear(&integ_r);
 808         chunk_clear(&encr_i);
 809         chunk_clear(&encr_r);
 810
 811         if (status != SUCCESS)
 812         {
 813                 return status;
 814         }
 815
 816         charon->bus->child_keys(charon->bus, this->child_sa, this->initiator,
 817                                                         this->dh, nonce_i, nonce_r);
 818
 819         my_ts = linked_list_create_from_enumerator(
 820                                 this->child_sa->create_ts_enumerator(this->child_sa, TRUE));
 821         other_ts = linked_list_create_from_enumerator(
 822                                 this->child_sa->create_ts_enumerator(this->child_sa, FALSE));
 823         out_state = this->child_sa->get_outbound_state(this->child_sa);
 824
 825         DBG0(DBG_IKE, "%sCHILD_SA %s{%d} established "
 826                  "with SPIs %.8x_i %.8x_o and TS %#R === %#R",
 827                  (out_state == CHILD_OUTBOUND_INSTALLED) ? "" : "inbound ",
 828                  this->child_sa->get_name(this->child_sa),
 829                  this->child_sa->get_unique_id(this->child_sa),
 830                  ntohl(this->child_sa->get_spi(this->child_sa, TRUE)),
 831                  ntohl(this->child_sa->get_spi(this->child_sa, FALSE)),
 832                  my_ts, other_ts);
 833
 834         my_ts->destroy(my_ts);
 835         other_ts->destroy(other_ts);
 836
 837         this->child_sa->set_state(this->child_sa, CHILD_INSTALLED);
 838         this->ike_sa->add_child_sa(this->ike_sa, this->child_sa);
 839         this->established = TRUE;
 840
 841         schedule_inactivity_timeout(this);
 842         return SUCCESS;
 843 }
 844
 845 /**
 846  * build the payloads for the message
 847  */
 848 static bool build_payloads(private_child_create_t *this, message_t *message)
 849 {
 850         sa_payload_t *sa_payload;
 851         nonce_payload_t *nonce_payload;
 852         ke_payload_t *ke_payload;
 853         ts_payload_t *ts_payload;
 854         kernel_feature_t features;
 855
 856         /* add SA payload */
 857         if (this->initiator)
 858         {
 859                 sa_payload = sa_payload_create_from_proposals_v2(this->proposals);
 860         }
 861         else
 862         {
 863                 sa_payload = sa_payload_create_from_proposal_v2(this->proposal);
 864         }
 865         message->add_payload(message, (payload_t*)sa_payload);
 866
 867         /* add nonce payload if not in IKE_AUTH */
 868         if (message->get_exchange_type(message) == CREATE_CHILD_SA)
 869         {
 870                 nonce_payload = nonce_payload_create(PLV2_NONCE);
 871                 nonce_payload->set_nonce(nonce_payload, this->my_nonce);
 872                 message->add_payload(message, (payload_t*)nonce_payload);
 873         }
 874
 875         /* diffie hellman exchange, if PFS enabled */
 876         if (this->dh)
 877         {
 878                 ke_payload = ke_payload_create_from_diffie_hellman(PLV2_KEY_EXCHANGE,
 879                                                                                                                    this->dh);
 880                 if (!ke_payload)
 881                 {
 882                         DBG1(DBG_IKE, "creating KE payload failed");
 883                         return FALSE;
 884                 }
 885                 message->add_payload(message, (payload_t*)ke_payload);
 886         }
 887
 888         /* add TSi/TSr payloads */
 889         ts_payload = ts_payload_create_from_traffic_selectors(TRUE, this->tsi);
 890         message->add_payload(message, (payload_t*)ts_payload);
 891         ts_payload = ts_payload_create_from_traffic_selectors(FALSE, this->tsr);
 892         message->add_payload(message, (payload_t*)ts_payload);
 893
 894         /* add a notify if we are not in tunnel mode */
 895         switch (this->mode)
 896         {
 897                 case MODE_TRANSPORT:
 898                         message->add_notify(message, FALSE, USE_TRANSPORT_MODE, chunk_empty);
 899                         break;
 900                 case MODE_BEET:
 901                         message->add_notify(message, FALSE, USE_BEET_MODE, chunk_empty);
 902                         break;
 903                 default:
 904                         break;
 905         }
 906
 907         features = charon->kernel->get_features(charon->kernel);
 908         if (!(features & KERNEL_ESP_V3_TFC))
 909         {
 910                 message->add_notify(message, FALSE, ESP_TFC_PADDING_NOT_SUPPORTED,
 911                                                         chunk_empty);
 912         }
 913         return TRUE;
 914 }
 915
 916 /**
 917  * Adds an IPCOMP_SUPPORTED notify to the message, allocating a CPI
 918  */
 919 static void add_ipcomp_notify(private_child_create_t *this,
 920                                                                   message_t *message, uint8_t ipcomp)
 921 {
 922         this->my_cpi = this->child_sa->alloc_cpi(this->child_sa);
 923         if (this->my_cpi)
 924         {
 925                 this->ipcomp = ipcomp;
 926                 message->add_notify(message, FALSE, IPCOMP_SUPPORTED,
 927                                                         chunk_cata("cc", chunk_from_thing(this->my_cpi),
 928                                                                            chunk_from_thing(ipcomp)));
 929         }
 930         else
 931         {
 932                 DBG1(DBG_IKE, "unable to allocate a CPI from kernel, IPComp disabled");
 933         }
 934 }
 935
 936 /**
 937  * handle a received notify payload
 938  */
 939 static void handle_notify(private_child_create_t *this, notify_payload_t *notify)
 940 {
 941         switch (notify->get_notify_type(notify))
 942         {
 943                 case USE_TRANSPORT_MODE:
 944                         this->mode = MODE_TRANSPORT;
 945                         break;
 946                 case USE_BEET_MODE:
 947                         if (this->ike_sa->supports_extension(this->ike_sa, EXT_STRONGSWAN))
 948                         {       /* handle private use notify only if we know its meaning */
 949                                 this->mode = MODE_BEET;
 950                         }
 951                         else
 952                         {
 953                                 DBG1(DBG_IKE, "received a notify strongSwan uses for BEET "
 954                                          "mode, but peer implementation unknown, skipped");
 955                         }
 956                         break;
 957                 case IPCOMP_SUPPORTED:
 958                 {
 959                         ipcomp_transform_t ipcomp;
 960                         uint16_t cpi;
 961                         chunk_t data;
 962
 963                         data = notify->get_notification_data(notify);
 964                         cpi = *(uint16_t*)data.ptr;
 965                         ipcomp = (ipcomp_transform_t)(*(data.ptr + 2));
 966                         switch (ipcomp)
 967                         {
 968                                 case IPCOMP_DEFLATE:
 969                                         this->other_cpi = cpi;
 970                                         this->ipcomp_received = ipcomp;
 971                                         break;
 972                                 case IPCOMP_LZS:
 973                                 case IPCOMP_LZJH:
 974                                 default:
 975                                         DBG1(DBG_IKE, "received IPCOMP_SUPPORTED notify with a "
 976                                                  "transform ID we don't support %N",
 977                                                  ipcomp_transform_names, ipcomp);
 978                                         break;
 979                         }
 980                         break;
 981                 }
 982                 case ESP_TFC_PADDING_NOT_SUPPORTED:
 983                         DBG1(DBG_IKE, "received %N, not using ESPv3 TFC padding",
 984                                  notify_type_names, notify->get_notify_type(notify));
 985                         this->tfcv3 = FALSE;
 986                         break;
 987                 default:
 988                         break;
 989         }
 990 }
 991
 992 /**
 993  * Read payloads from message
 994  */
 995 static void process_payloads(private_child_create_t *this, message_t *message)
 996 {
 997         enumerator_t *enumerator;
 998         payload_t *payload;
 999         sa_payload_t *sa_payload;
1000         ke_payload_t *ke_payload;
1001         ts_payload_t *ts_payload;
1002
1003         /* defaults to TUNNEL mode */
1004         this->mode = MODE_TUNNEL;
1005
1006         enumerator = message->create_payload_enumerator(message);
1007         while (enumerator->enumerate(enumerator, &payload))
1008         {
1009                 switch (payload->get_type(payload))
1010                 {
1011                         case PLV2_SECURITY_ASSOCIATION:
1012                                 sa_payload = (sa_payload_t*)payload;
1013                                 this->proposals = sa_payload->get_proposals(sa_payload);
1014                                 break;
1015                         case PLV2_KEY_EXCHANGE:
1016                                 ke_payload = (ke_payload_t*)payload;
1017                                 if (!this->initiator)
1018                                 {
1019                                         this->dh_group = ke_payload->get_dh_group_number(ke_payload);
1020                                         this->dh = this->keymat->keymat.create_dh(
1021                                                                                 &this->keymat->keymat, this->dh_group);
1022                                 }
1023                                 else if (this->dh)
1024                                 {
1025                                         this->dh_failed = this->dh->get_dh_group(this->dh) !=
1026                                                                         ke_payload->get_dh_group_number(ke_payload);
1027                                 }
1028                                 if (this->dh && !this->dh_failed)
1029                                 {
1030                                         this->dh_failed = !this->dh->set_other_public_value(this->dh,
1031                                                                 ke_payload->get_key_exchange_data(ke_payload));
1032                                 }
1033                                 break;
1034                         case PLV2_TS_INITIATOR:
1035                                 ts_payload = (ts_payload_t*)payload;
1036                                 this->tsi = ts_payload->get_traffic_selectors(ts_payload);
1037                                 break;
1038                         case PLV2_TS_RESPONDER:
1039                                 ts_payload = (ts_payload_t*)payload;
1040                                 this->tsr = ts_payload->get_traffic_selectors(ts_payload);
1041                                 break;
1042                         case PLV2_NOTIFY:
1043                                 handle_notify(this, (notify_payload_t*)payload);
1044                                 break;
1045                         default:
1046                                 break;
1047                 }
1048         }
1049         enumerator->destroy(enumerator);
1050 }
1051
1052 /**
1053  * Check if we should defer the creation of this CHILD_SA until after the
1054  * IKE_SA has been established childless.
1055  */
1056 static status_t defer_child_sa(private_child_create_t *this)
1057 {
1058         ike_cfg_t *ike_cfg;
1059
1060         ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
1061
1062         if (this->ike_sa->supports_extension(this->ike_sa, EXT_IKE_CHILDLESS))
1063         {
1064                 if (ike_cfg->childless(ike_cfg) == CHILDLESS_FORCE)
1065                 {
1066                         return NEED_MORE;
1067                 }
1068         }
1069         else if (ike_cfg->childless(ike_cfg) == CHILDLESS_FORCE)
1070         {
1071                 DBG1(DBG_IKE, "peer does not support childless IKE_SA initiation");
1072                 return DESTROY_ME;
1073         }
1074         return NOT_SUPPORTED;
1075 }
1076
1077 METHOD(task_t, build_i, status_t,
1078         private_child_create_t *this, message_t *message)
1079 {
1080         enumerator_t *enumerator;
1081         host_t *vip;
1082         peer_cfg_t *peer_cfg;
1083         linked_list_t *list;
1084
1085         switch (message->get_exchange_type(message))
1086         {
1087                 case IKE_SA_INIT:
1088                         return get_nonce(message, &this->my_nonce);
1089                 case CREATE_CHILD_SA:
1090                         if (!generate_nonce(this))
1091                         {
1092                                 message->add_notify(message, FALSE, NO_PROPOSAL_CHOSEN,
1093                                                                         chunk_empty);
1094                                 return SUCCESS;
1095                         }
1096                         if (!this->retry && this->dh_group == MODP_NONE)
1097                         {       /* during a rekeying the group might already be set */
1098                                 this->dh_group = this->config->get_dh_group(this->config);
1099                         }
1100                         break;
1101                 case IKE_AUTH:
1102                         if (message->get_message_id(message) != 1)
1103                         {
1104                                 /* send only in the first request, not in subsequent rounds */
1105                                 return NEED_MORE;
1106                         }
1107                         switch (defer_child_sa(this))
1108                         {
1109                                 case DESTROY_ME:
1110                                         /* config mismatch */
1111                                         return DESTROY_ME;
1112                                 case NEED_MORE:
1113                                         /* defer until after IKE_SA has been established */
1114                                         chunk_free(&this->my_nonce);
1115                                         return NEED_MORE;
1116                                 default:
1117                                         /* just continue to establish the CHILD_SA */
1118                                         break;
1119                         }
1120                         break;
1121                 default:
1122                         break;
1123         }
1124
1125         /* check if we want a virtual IP, but don't have one */
1126         list = linked_list_create();
1127         peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
1128         if (!this->rekey)
1129         {
1130                 enumerator = peer_cfg->create_virtual_ip_enumerator(peer_cfg);
1131                 while (enumerator->enumerate(enumerator, &vip))
1132                 {
1133                         /* propose a 0.0.0.0/0 or ::/0 subnet when we use virtual ip */
1134                         vip = host_create_any(vip->get_family(vip));
1135                         list->insert_last(list, vip);
1136                 }
1137                 enumerator->destroy(enumerator);
1138         }
1139         if (list->get_count(list))
1140         {
1141                 this->tsi = this->config->get_traffic_selectors(this->config,
1142                                                                                                                 TRUE, NULL, list, TRUE);
1143                 list->destroy_offset(list, offsetof(host_t, destroy));
1144         }
1145         else
1146         {       /* no virtual IPs configured */
1147                 list->destroy(list);
1148                 list = get_dynamic_hosts(this->ike_sa, TRUE);
1149                 this->tsi = this->config->get_traffic_selectors(this->config,
1150                                                                                                                 TRUE, NULL, list, TRUE);
1151                 list->destroy(list);
1152         }
1153         list = get_dynamic_hosts(this->ike_sa, FALSE);
1154         this->tsr = this->config->get_traffic_selectors(this->config,
1155                                                                                                         FALSE, NULL, list, TRUE);
1156         list->destroy(list);
1157
1158         if (this->packet_tsi)
1159         {
1160                 this->tsi->insert_first(this->tsi,
1161                                                                 this->packet_tsi->clone(this->packet_tsi));
1162         }
1163         if (this->packet_tsr)
1164         {
1165                 this->tsr->insert_first(this->tsr,
1166                                                                 this->packet_tsr->clone(this->packet_tsr));
1167         }
1168         this->proposals = this->config->get_proposals(this->config,
1169                                                                                                   this->dh_group == MODP_NONE);
1170         this->mode = this->config->get_mode(this->config);
1171
1172         this->child.if_id_in_def = this->ike_sa->get_if_id(this->ike_sa, TRUE);
1173         this->child.if_id_out_def = this->ike_sa->get_if_id(this->ike_sa, FALSE);
1174         this->child.encap = this->ike_sa->has_condition(this->ike_sa, COND_NAT_ANY);
1175         this->child_sa = child_sa_create(this->ike_sa->get_my_host(this->ike_sa),
1176                                                                          this->ike_sa->get_other_host(this->ike_sa),
1177                                                                          this->config, &this->child);
1178
1179         if (this->child.reqid)
1180         {
1181                 DBG0(DBG_IKE, "establishing CHILD_SA %s{%d} reqid %d",
1182                          this->child_sa->get_name(this->child_sa),
1183                          this->child_sa->get_unique_id(this->child_sa), this->child.reqid);
1184         }
1185         else
1186         {
1187                 DBG0(DBG_IKE, "establishing CHILD_SA %s{%d}",
1188                          this->child_sa->get_name(this->child_sa),
1189                          this->child_sa->get_unique_id(this->child_sa));
1190         }
1191
1192         if (!allocate_spi(this))
1193         {
1194                 DBG1(DBG_IKE, "unable to allocate SPIs from kernel");
1195                 return FAILED;
1196         }
1197
1198         if (!update_and_check_proposals(this))
1199         {
1200                 DBG1(DBG_IKE, "requested DH group %N not contained in any of our "
1201                          "proposals",
1202                          diffie_hellman_group_names, this->dh_group);
1203                 return FAILED;
1204         }
1205
1206         if (this->dh_group != MODP_NONE)
1207         {
1208                 this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
1209                                                                                                   this->dh_group);
1210         }
1211
1212         if (this->config->has_option(this->config, OPT_IPCOMP))
1213         {
1214                 /* IPCOMP_DEFLATE is the only transform we support at the moment */
1215                 add_ipcomp_notify(this, message, IPCOMP_DEFLATE);
1216         }
1217
1218         if (message->get_exchange_type(message) == IKE_AUTH)
1219         {
1220                 charon->bus->narrow(charon->bus, this->child_sa,
1221                                                         NARROW_INITIATOR_PRE_NOAUTH, this->tsi, this->tsr);
1222         }
1223         else
1224         {
1225                 charon->bus->narrow(charon->bus, this->child_sa,
1226                                                         NARROW_INITIATOR_PRE_AUTH, this->tsi, this->tsr);
1227         }
1228
1229         if (!build_payloads(this, message))
1230         {
1231                 return FAILED;
1232         }
1233
1234         this->tsi->destroy_offset(this->tsi, offsetof(traffic_selector_t, destroy));
1235         this->tsr->destroy_offset(this->tsr, offsetof(traffic_selector_t, destroy));
1236         this->proposals->destroy_offset(this->proposals, offsetof(proposal_t, destroy));
1237         this->tsi = NULL;
1238         this->tsr = NULL;
1239         this->proposals = NULL;
1240
1241         return NEED_MORE;
1242 }
1243
1244 METHOD(task_t, process_r, status_t,
1245         private_child_create_t *this, message_t *message)
1246 {
1247         switch (message->get_exchange_type(message))
1248         {
1249                 case IKE_SA_INIT:
1250                         return get_nonce(message, &this->other_nonce);
1251                 case CREATE_CHILD_SA:
1252                         get_nonce(message, &this->other_nonce);
1253                         break;
1254                 case IKE_AUTH:
1255                         if (message->get_message_id(message) != 1)
1256                         {
1257                                 /* only handle first AUTH payload, not additional rounds */
1258                                 return NEED_MORE;
1259                         }
1260                 default:
1261                         break;
1262         }
1263
1264         process_payloads(this, message);
1265
1266         return NEED_MORE;
1267 }
1268
1269 /**
1270  * handle CHILD_SA setup failure
1271  */
1272 static void handle_child_sa_failure(private_child_create_t *this,
1273                                                                         message_t *message)
1274 {
1275         bool is_first;
1276
1277         is_first = message->get_exchange_type(message) == IKE_AUTH;
1278         if (is_first &&
1279                 lib->settings->get_bool(lib->settings,
1280                                                                 "%s.close_ike_on_child_failure", FALSE, lib->ns))
1281         {
1282                 /* we delay the delete for 100ms, as the IKE_AUTH response must arrive
1283                  * first */
1284                 DBG1(DBG_IKE, "closing IKE_SA due CHILD_SA setup failure");
1285                 lib->scheduler->schedule_job_ms(lib->scheduler, (job_t*)
1286                         delete_ike_sa_job_create(this->ike_sa->get_id(this->ike_sa), TRUE),
1287                         100);
1288         }
1289         else
1290         {
1291                 DBG1(DBG_IKE, "failed to establish CHILD_SA, keeping IKE_SA");
1292                 charon->bus->alert(charon->bus, ALERT_KEEP_ON_CHILD_SA_FAILURE,
1293                                                    is_first);
1294         }
1295 }
1296
1297 /**
1298  * Substitute transport mode NAT selectors, if applicable
1299  */
1300 static linked_list_t* get_ts_if_nat_transport(private_child_create_t *this,
1301                                                                                           bool local, linked_list_t *in)
1302 {
1303         linked_list_t *out = NULL;
1304         ike_condition_t cond;
1305
1306         if (this->mode == MODE_TRANSPORT)
1307         {
1308                 cond = local ? COND_NAT_HERE : COND_NAT_THERE;
1309                 if (this->ike_sa->has_condition(this->ike_sa, cond))
1310                 {
1311                         out = get_transport_nat_ts(this, local, in);
1312                         if (out->get_count(out) == 0)
1313                         {
1314                                 out->destroy(out);
1315                                 out = NULL;
1316                         }
1317                 }
1318         }
1319         return out;
1320 }
1321
1322 /**
1323  * Select a matching CHILD config as responder
1324  */
1325 static child_cfg_t* select_child_cfg(private_child_create_t *this)
1326 {
1327         peer_cfg_t *peer_cfg;
1328         child_cfg_t *child_cfg = NULL;;
1329
1330         peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
1331         if (peer_cfg && this->tsi && this->tsr)
1332         {
1333                 linked_list_t *listr, *listi, *tsr, *tsi;
1334
1335                 tsr = get_ts_if_nat_transport(this, TRUE, this->tsr);
1336                 tsi = get_ts_if_nat_transport(this, FALSE, this->tsi);
1337
1338                 listr = get_dynamic_hosts(this->ike_sa, TRUE);
1339                 listi = get_dynamic_hosts(this->ike_sa, FALSE);
1340                 child_cfg = peer_cfg->select_child_cfg(peer_cfg,
1341                                                                                         tsr ?: this->tsr, tsi ?: this->tsi,
1342                                                                                         listr, listi);
1343                 if ((tsi || tsr) && child_cfg &&
1344                         child_cfg->get_mode(child_cfg) != MODE_TRANSPORT)
1345                 {
1346                         /* found a CHILD config, but it doesn't use transport mode */
1347                         child_cfg->destroy(child_cfg);
1348                         child_cfg = NULL;
1349                 }
1350                 if (!child_cfg && (tsi || tsr))
1351                 {
1352                         /* no match for the substituted NAT selectors, try it without */
1353                         child_cfg = peer_cfg->select_child_cfg(peer_cfg,
1354                                                                                         this->tsr, this->tsi, listr, listi);
1355                 }
1356                 listr->destroy(listr);
1357                 listi->destroy(listi);
1358                 DESTROY_OFFSET_IF(tsi, offsetof(traffic_selector_t, destroy));
1359                 DESTROY_OFFSET_IF(tsr, offsetof(traffic_selector_t, destroy));
1360         }
1361
1362         return child_cfg;
1363 }
1364
1365 /**
1366  * Check how to handle a possibly childless IKE_SA
1367  */
1368 static status_t handle_childless(private_child_create_t *this)
1369 {
1370         ike_cfg_t *ike_cfg;
1371
1372         ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
1373
1374         if (!this->proposals && !this->tsi && !this->tsr)
1375         {
1376                 /* looks like a childless IKE_SA, check if we allow it */
1377                 if (ike_cfg->childless(ike_cfg) == CHILDLESS_NEVER)
1378                 {
1379                         /* we don't allow childless initiation */
1380                         DBG1(DBG_IKE, "peer tried to initiate a childless IKE_SA");
1381                         return INVALID_STATE;
1382                 }
1383                 return SUCCESS;
1384         }
1385
1386         /* the peer apparently wants to create a regular IKE_SA */
1387         if (ike_cfg->childless(ike_cfg) == CHILDLESS_FORCE)
1388         {
1389                 /* reject it if we only allow childless initiation */
1390                 DBG1(DBG_IKE, "peer did not initiate a childless IKE_SA");
1391                 return INVALID_STATE;
1392         }
1393         return NOT_SUPPORTED;
1394 }
1395
1396 METHOD(task_t, build_r, status_t,
1397         private_child_create_t *this, message_t *message)
1398 {
1399         payload_t *payload;
1400         enumerator_t *enumerator;
1401         bool no_dh = TRUE, ike_auth = FALSE;
1402
1403         switch (message->get_exchange_type(message))
1404         {
1405                 case IKE_SA_INIT:
1406                         return get_nonce(message, &this->my_nonce);
1407                 case CREATE_CHILD_SA:
1408                         if (!generate_nonce(this))
1409                         {
1410                                 message->add_notify(message, FALSE, NO_PROPOSAL_CHOSEN,
1411                                                                         chunk_empty);
1412                                 return SUCCESS;
1413                         }
1414                         if (this->dh_failed)
1415                         {
1416                                 DBG1(DBG_IKE, "applying DH public value failed");
1417                                 message->add_notify(message, FALSE, NO_PROPOSAL_CHOSEN,
1418                                                                         chunk_empty);
1419                                 return SUCCESS;
1420                         }
1421                         no_dh = FALSE;
1422                         break;
1423                 case IKE_AUTH:
1424                         if (this->ike_sa->get_state(this->ike_sa) != IKE_ESTABLISHED)
1425                         {       /* wait until all authentication round completed */
1426                                 return NEED_MORE;
1427                         }
1428                         if (this->ike_sa->has_condition(this->ike_sa, COND_REDIRECTED))
1429                         {       /* no CHILD_SA is created for redirected SAs */
1430                                 return SUCCESS;
1431                         }
1432                         switch (handle_childless(this))
1433                         {
1434                                 case SUCCESS:
1435                                         /* no CHILD_SA built */
1436                                         return SUCCESS;
1437                                 case INVALID_STATE:
1438                                         message->add_notify(message, FALSE, INVALID_SYNTAX,
1439                                                                                 chunk_empty);
1440                                         return FAILED;
1441                                 default:
1442                                         /* continue with regular initiation */
1443                                         break;
1444                         }
1445                         ike_auth = TRUE;
1446                 default:
1447                         break;
1448         }
1449
1450         if (this->ike_sa->get_state(this->ike_sa) == IKE_REKEYING)
1451         {
1452                 DBG1(DBG_IKE, "unable to create CHILD_SA while rekeying IKE_SA");
1453                 message->add_notify(message, TRUE, TEMPORARY_FAILURE, chunk_empty);
1454                 return SUCCESS;
1455         }
1456         if (this->ike_sa->get_state(this->ike_sa) == IKE_DELETING)
1457         {
1458                 DBG1(DBG_IKE, "unable to create CHILD_SA while deleting IKE_SA");
1459                 message->add_notify(message, TRUE, TEMPORARY_FAILURE, chunk_empty);
1460                 return SUCCESS;
1461         }
1462
1463         if (this->config == NULL)
1464         {
1465                 this->config = select_child_cfg(this);
1466         }
1467         if (this->config == NULL)
1468         {
1469                 DBG1(DBG_IKE, "traffic selectors %#R === %#R unacceptable",
1470                          this->tsr, this->tsi);
1471                 charon->bus->alert(charon->bus, ALERT_TS_MISMATCH, this->tsi, this->tsr);
1472                 message->add_notify(message, FALSE, TS_UNACCEPTABLE, chunk_empty);
1473                 handle_child_sa_failure(this, message);
1474                 return SUCCESS;
1475         }
1476
1477         /* check if ike_config_t included non-critical error notifies */
1478         enumerator = message->create_payload_enumerator(message);
1479         while (enumerator->enumerate(enumerator, &payload))
1480         {
1481                 if (payload->get_type(payload) == PLV2_NOTIFY)
1482                 {
1483                         notify_payload_t *notify = (notify_payload_t*)payload;
1484
1485                         switch (notify->get_notify_type(notify))
1486                         {
1487                                 case INTERNAL_ADDRESS_FAILURE:
1488                                 case FAILED_CP_REQUIRED:
1489                                 {
1490                                         DBG1(DBG_IKE,"configuration payload negotiation "
1491                                                  "failed, no CHILD_SA built");
1492                                         enumerator->destroy(enumerator);
1493                                         handle_child_sa_failure(this, message);
1494                                         return SUCCESS;
1495                                 }
1496                                 default:
1497                                         break;
1498                         }
1499                 }
1500         }
1501         enumerator->destroy(enumerator);
1502
1503         this->child.if_id_in_def = this->ike_sa->get_if_id(this->ike_sa, TRUE);
1504         this->child.if_id_out_def = this->ike_sa->get_if_id(this->ike_sa, FALSE);
1505         this->child.encap = this->ike_sa->has_condition(this->ike_sa, COND_NAT_ANY);
1506         this->child_sa = child_sa_create(this->ike_sa->get_my_host(this->ike_sa),
1507                                                                          this->ike_sa->get_other_host(this->ike_sa),
1508                                                                          this->config, &this->child);
1509
1510         if (this->ipcomp_received != IPCOMP_NONE)
1511         {
1512                 if (this->config->has_option(this->config, OPT_IPCOMP))
1513                 {
1514                         add_ipcomp_notify(this, message, this->ipcomp_received);
1515                 }
1516                 else
1517                 {
1518                         DBG1(DBG_IKE, "received %N notify but IPComp is disabled, ignoring",
1519                                  notify_type_names, IPCOMP_SUPPORTED);
1520                 }
1521         }
1522
1523         switch (select_and_install(this, no_dh, ike_auth))
1524         {
1525                 case SUCCESS:
1526                         break;
1527                 case NOT_FOUND:
1528                         message->add_notify(message, FALSE, TS_UNACCEPTABLE, chunk_empty);
1529                         handle_child_sa_failure(this, message);
1530                         return SUCCESS;
1531                 case INVALID_ARG:
1532                 {
1533                         uint16_t group = htons(this->dh_group);
1534                         message->add_notify(message, FALSE, INVALID_KE_PAYLOAD,
1535                                                                 chunk_from_thing(group));
1536                         return SUCCESS;
1537                 }
1538                 case FAILED:
1539                 default:
1540                         message->add_notify(message, FALSE, NO_PROPOSAL_CHOSEN, chunk_empty);
1541                         handle_child_sa_failure(this, message);
1542                         return SUCCESS;
1543         }
1544
1545         if (!build_payloads(this, message))
1546         {
1547                 message->add_notify(message, FALSE, NO_PROPOSAL_CHOSEN, chunk_empty);
1548                 handle_child_sa_failure(this, message);
1549                 return SUCCESS;
1550         }
1551
1552         if (!this->rekey)
1553         {       /* invoke the child_up() hook if we are not rekeying */
1554                 charon->bus->child_updown(charon->bus, this->child_sa, TRUE);
1555         }
1556         return SUCCESS;
1557 }
1558
1559 /**
1560  * Raise alerts for received notify errors
1561  */
1562 static void raise_alerts(private_child_create_t *this, notify_type_t type)
1563 {
1564         linked_list_t *list;
1565
1566         switch (type)
1567         {
1568                 case NO_PROPOSAL_CHOSEN:
1569                         list = this->config->get_proposals(this->config, FALSE);
1570                         charon->bus->alert(charon->bus, ALERT_PROPOSAL_MISMATCH_CHILD, list);
1571                         list->destroy_offset(list, offsetof(proposal_t, destroy));
1572                         break;
1573                 default:
1574                         break;
1575         }
1576 }
1577
1578 METHOD(task_t, build_i_delete, status_t,
1579         private_child_create_t *this, message_t *message)
1580 {
1581         message->set_exchange_type(message, INFORMATIONAL);
1582         if (this->my_spi && this->proto)
1583         {
1584                 delete_payload_t *del;
1585
1586                 del = delete_payload_create(PLV2_DELETE, this->proto);
1587                 del->add_spi(del, this->my_spi);
1588                 message->add_payload(message, (payload_t*)del);
1589
1590                 DBG1(DBG_IKE, "sending DELETE for %N CHILD_SA with SPI %.8x",
1591                          protocol_id_names, this->proto, ntohl(this->my_spi));
1592         }
1593         return NEED_MORE;
1594 }
1595
1596 /**
1597  * Change task to delete the failed CHILD_SA as initiator
1598  */
1599 static status_t delete_failed_sa(private_child_create_t *this)
1600 {
1601         if (this->my_spi && this->proto)
1602         {
1603                 this->public.task.build = _build_i_delete;
1604                 this->public.task.process = (void*)return_success;
1605                 return NEED_MORE;
1606         }
1607         return SUCCESS;
1608 }
1609
1610 METHOD(task_t, process_i, status_t,
1611         private_child_create_t *this, message_t *message)
1612 {
1613         enumerator_t *enumerator;
1614         payload_t *payload;
1615         bool no_dh = TRUE, ike_auth = FALSE;
1616
1617         switch (message->get_exchange_type(message))
1618         {
1619                 case IKE_SA_INIT:
1620                         return get_nonce(message, &this->other_nonce);
1621                 case CREATE_CHILD_SA:
1622                         get_nonce(message, &this->other_nonce);
1623                         no_dh = FALSE;
1624                         break;
1625                 case IKE_AUTH:
1626                         if (this->ike_sa->get_state(this->ike_sa) != IKE_ESTABLISHED)
1627                         {       /* wait until all authentication round completed */
1628                                 return NEED_MORE;
1629                         }
1630                         if (defer_child_sa(this) == NEED_MORE)
1631                         {       /* defer until after IKE_SA has been established */
1632                                 chunk_free(&this->other_nonce);
1633                                 return NEED_MORE;
1634                         }
1635                         ike_auth = TRUE;
1636                 default:
1637                         break;
1638         }
1639
1640         /* check for erroneous notifies */
1641         enumerator = message->create_payload_enumerator(message);
1642         while (enumerator->enumerate(enumerator, &payload))
1643         {
1644                 if (payload->get_type(payload) == PLV2_NOTIFY)
1645                 {
1646                         notify_payload_t *notify = (notify_payload_t*)payload;
1647                         notify_type_t type = notify->get_notify_type(notify);
1648
1649                         switch (type)
1650                         {
1651                                 /* handle notify errors related to CHILD_SA only */
1652                                 case NO_PROPOSAL_CHOSEN:
1653                                 case SINGLE_PAIR_REQUIRED:
1654                                 case NO_ADDITIONAL_SAS:
1655                                 case INTERNAL_ADDRESS_FAILURE:
1656                                 case FAILED_CP_REQUIRED:
1657                                 case TS_UNACCEPTABLE:
1658                                 case INVALID_SELECTORS:
1659                                 {
1660                                         DBG1(DBG_IKE, "received %N notify, no CHILD_SA built",
1661                                                  notify_type_names, type);
1662                                         enumerator->destroy(enumerator);
1663                                         raise_alerts(this, type);
1664                                         handle_child_sa_failure(this, message);
1665                                         /* an error in CHILD_SA creation is not critical */
1666                                         return SUCCESS;
1667                                 }
1668                                 case TEMPORARY_FAILURE:
1669                                 {
1670                                         DBG1(DBG_IKE, "received %N notify, will retry later",
1671                                                  notify_type_names, type);
1672                                         enumerator->destroy(enumerator);
1673                                         if (!this->rekey)
1674                                         {       /* the rekey task will retry itself if necessary */
1675                                                 schedule_delayed_retry(this);
1676                                         }
1677                                         return SUCCESS;
1678                                 }
1679                                 case INVALID_KE_PAYLOAD:
1680                                 {
1681                                         chunk_t data;
1682                                         uint16_t group = MODP_NONE;
1683
1684                                         data = notify->get_notification_data(notify);
1685                                         if (data.len == sizeof(group))
1686                                         {
1687                                                 memcpy(&group, data.ptr, data.len);
1688                                                 group = ntohs(group);
1689                                         }
1690                                         if (this->retry)
1691                                         {
1692                                                 DBG1(DBG_IKE, "already retried with DH group %N, "
1693                                                          "ignore requested %N", diffie_hellman_group_names,
1694                                                          this->dh_group, diffie_hellman_group_names, group);
1695                                                 handle_child_sa_failure(this, message);
1696                                                 /* an error in CHILD_SA creation is not critical */
1697                                                 return SUCCESS;
1698                                         }
1699                                         DBG1(DBG_IKE, "peer didn't accept DH group %N, "
1700                                                  "it requested %N", diffie_hellman_group_names,
1701                                                  this->dh_group, diffie_hellman_group_names, group);
1702                                         this->retry = TRUE;
1703                                         this->dh_group = group;
1704                                         this->child_sa->set_state(this->child_sa, CHILD_RETRYING);
1705                                         this->public.task.migrate(&this->public.task, this->ike_sa);
1706                                         enumerator->destroy(enumerator);
1707                                         return NEED_MORE;
1708                                 }
1709                                 default:
1710                                 {
1711                                         if (message->get_exchange_type(message) == CREATE_CHILD_SA)
1712                                         {       /* handle notifies if not handled in IKE_AUTH */
1713                                                 if (type <= 16383)
1714                                                 {
1715                                                         DBG1(DBG_IKE, "received %N notify error",
1716                                                                  notify_type_names, type);
1717                                                         enumerator->destroy(enumerator);
1718                                                         return SUCCESS;
1719                                                 }
1720                                                 DBG2(DBG_IKE, "received %N notify",
1721                                                          notify_type_names, type);
1722                                         }
1723                                         break;
1724                                 }
1725                         }
1726                 }
1727         }
1728         enumerator->destroy(enumerator);
1729
1730         process_payloads(this, message);
1731
1732         if (this->ipcomp == IPCOMP_NONE && this->ipcomp_received != IPCOMP_NONE)
1733         {
1734                 DBG1(DBG_IKE, "received an IPCOMP_SUPPORTED notify without requesting"
1735                          " one, no CHILD_SA built");
1736                 handle_child_sa_failure(this, message);
1737                 return delete_failed_sa(this);
1738         }
1739         else if (this->ipcomp != IPCOMP_NONE && this->ipcomp_received == IPCOMP_NONE)
1740         {
1741                 DBG1(DBG_IKE, "peer didn't accept our proposed IPComp transforms, "
1742                          "IPComp is disabled");
1743                 this->ipcomp = IPCOMP_NONE;
1744         }
1745         else if (this->ipcomp != IPCOMP_NONE && this->ipcomp != this->ipcomp_received)
1746         {
1747                 DBG1(DBG_IKE, "received an IPCOMP_SUPPORTED notify we didn't propose, "
1748                          "no CHILD_SA built");
1749                 handle_child_sa_failure(this, message);
1750                 return delete_failed_sa(this);
1751         }
1752
1753         if (this->dh_failed)
1754         {
1755                 DBG1(DBG_IKE, "applying DH public value failed");
1756                 handle_child_sa_failure(this, message);
1757                 return delete_failed_sa(this);
1758         }
1759
1760         if (select_and_install(this, no_dh, ike_auth) == SUCCESS)
1761         {
1762                 if (!this->rekey)
1763                 {       /* invoke the child_up() hook if we are not rekeying */
1764                         charon->bus->child_updown(charon->bus, this->child_sa, TRUE);
1765                 }
1766         }
1767         else
1768         {
1769                 handle_child_sa_failure(this, message);
1770                 return delete_failed_sa(this);
1771         }
1772         return SUCCESS;
1773 }
1774
1775 METHOD(child_create_t, use_reqid, void,
1776         private_child_create_t *this, uint32_t reqid)
1777 {
1778         this->child.reqid = reqid;
1779 }
1780
1781 METHOD(child_create_t, use_marks, void,
1782         private_child_create_t *this, uint32_t in, uint32_t out)
1783 {
1784         this->child.mark_in = in;
1785         this->child.mark_out = out;
1786 }
1787
1788 METHOD(child_create_t, use_if_ids, void,
1789         private_child_create_t *this, uint32_t in, uint32_t out)
1790 {
1791         this->child.if_id_in = in;
1792         this->child.if_id_out = out;
1793 }
1794
1795 METHOD(child_create_t, use_dh_group, void,
1796         private_child_create_t *this, diffie_hellman_group_t dh_group)
1797 {
1798         this->dh_group = dh_group;
1799 }
1800
1801 METHOD(child_create_t, get_child, child_sa_t*,
1802         private_child_create_t *this)
1803 {
1804         return this->child_sa;
1805 }
1806
1807 METHOD(child_create_t, set_config, void,
1808         private_child_create_t *this, child_cfg_t *cfg)
1809 {
1810         DESTROY_IF(this->config);
1811         this->config = cfg;
1812 }
1813
1814 METHOD(child_create_t, get_lower_nonce, chunk_t,
1815         private_child_create_t *this)
1816 {
1817         if (memcmp(this->my_nonce.ptr, this->other_nonce.ptr,
1818                            min(this->my_nonce.len, this->other_nonce.len)) < 0)
1819         {
1820                 return this->my_nonce;
1821         }
1822         else
1823         {
1824                 return this->other_nonce;
1825         }
1826 }
1827
1828 METHOD(task_t, get_type, task_type_t,
1829         private_child_create_t *this)
1830 {
1831         return TASK_CHILD_CREATE;
1832 }
1833
1834 METHOD(task_t, migrate, void,
1835         private_child_create_t *this, ike_sa_t *ike_sa)
1836 {
1837         chunk_free(&this->my_nonce);
1838         chunk_free(&this->other_nonce);
1839         if (this->tsr)
1840         {
1841                 this->tsr->destroy_offset(this->tsr, offsetof(traffic_selector_t, destroy));
1842         }
1843         if (this->tsi)
1844         {
1845                 this->tsi->destroy_offset(this->tsi, offsetof(traffic_selector_t, destroy));
1846         }
1847         DESTROY_IF(this->child_sa);
1848         DESTROY_IF(this->proposal);
1849         DESTROY_IF(this->nonceg);
1850         DESTROY_IF(this->dh);
1851         this->dh_failed = FALSE;
1852         if (this->proposals)
1853         {
1854                 this->proposals->destroy_offset(this->proposals, offsetof(proposal_t, destroy));
1855         }
1856
1857         this->ike_sa = ike_sa;
1858         this->keymat = (keymat_v2_t*)ike_sa->get_keymat(ike_sa);
1859         this->proposal = NULL;
1860         this->proposals = NULL;
1861         this->tsi = NULL;
1862         this->tsr = NULL;
1863         this->dh = NULL;
1864         this->nonceg = NULL;
1865         this->child_sa = NULL;
1866         this->mode = MODE_TUNNEL;
1867         this->ipcomp = IPCOMP_NONE;
1868         this->ipcomp_received = IPCOMP_NONE;
1869         this->other_cpi = 0;
1870         this->established = FALSE;
1871         this->child = (child_sa_create_t){};
1872 }
1873
1874 METHOD(task_t, destroy, void,
1875         private_child_create_t *this)
1876 {
1877         chunk_free(&this->my_nonce);
1878         chunk_free(&this->other_nonce);
1879         if (this->tsr)
1880         {
1881                 this->tsr->destroy_offset(this->tsr, offsetof(traffic_selector_t, destroy));
1882         }
1883         if (this->tsi)
1884         {
1885                 this->tsi->destroy_offset(this->tsi, offsetof(traffic_selector_t, destroy));
1886         }
1887         if (!this->established)
1888         {
1889                 DESTROY_IF(this->child_sa);
1890         }
1891         DESTROY_IF(this->packet_tsi);
1892         DESTROY_IF(this->packet_tsr);
1893         DESTROY_IF(this->proposal);
1894         DESTROY_IF(this->dh);
1895         if (this->proposals)
1896         {
1897                 this->proposals->destroy_offset(this->proposals, offsetof(proposal_t, destroy));
1898         }
1899         DESTROY_IF(this->config);
1900         DESTROY_IF(this->nonceg);
1901         free(this);
1902 }
1903
1904 /*
1905  * Described in header.
1906  */
1907 child_create_t *child_create_create(ike_sa_t *ike_sa,
1908                                                         child_cfg_t *config, bool rekey,
1909                                                         traffic_selector_t *tsi, traffic_selector_t *tsr)
1910 {
1911         private_child_create_t *this;
1912
1913         INIT(this,
1914                 .public = {
1915                         .get_child = _get_child,
1916                         .set_config = _set_config,
1917                         .get_lower_nonce = _get_lower_nonce,
1918                         .use_reqid = _use_reqid,
1919                         .use_marks = _use_marks,
1920                         .use_if_ids = _use_if_ids,
1921                         .use_dh_group = _use_dh_group,
1922                         .task = {
1923                                 .get_type = _get_type,
1924                                 .migrate = _migrate,
1925                                 .destroy = _destroy,
1926                         },
1927                 },
1928                 .ike_sa = ike_sa,
1929                 .config = config,
1930                 .packet_tsi = tsi ? tsi->clone(tsi) : NULL,
1931                 .packet_tsr = tsr ? tsr->clone(tsr) : NULL,
1932                 .dh_group = MODP_NONE,
1933                 .keymat = (keymat_v2_t*)ike_sa->get_keymat(ike_sa),
1934                 .mode = MODE_TUNNEL,
1935                 .tfcv3 = TRUE,
1936                 .ipcomp = IPCOMP_NONE,
1937                 .ipcomp_received = IPCOMP_NONE,
1938                 .rekey = rekey,
1939                 .retry = FALSE,
1940         );
1941
1942         if (config)
1943         {
1944                 this->public.task.build = _build_i;
1945                 this->public.task.process = _process_i;
1946                 this->initiator = TRUE;
1947         }
1948         else
1949         {
1950                 this->public.task.build = _build_r;
1951                 this->public.task.process = _process_r;
1952                 this->initiator = FALSE;
1953         }
1954         return &this->public;
1955 }