Imported Upstream version 5.0.1

26 files changed, 6800 insertions, 0 deletions

diff --git a/src/libcharon/sa/ikev1/tasks/aggressive_mode.c b/src/libcharon/sa/ikev1/tasks/aggressive_mode.c
new file mode 100644
index 000000000..954dea880
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/aggressive_mode.c
@@ -0,0 +1,714 @@
+/*
+ * Copyright (C) 2012 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * Copyright (C) 2012 Martin Willi
+ * Copyright (C) 2012 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "aggressive_mode.h"
+
+#include <string.h>
+
+#include <daemon.h>
+#include <sa/ikev1/phase1.h>
+#include <encoding/payloads/sa_payload.h>
+#include <encoding/payloads/id_payload.h>
+#include <encoding/payloads/hash_payload.h>
+#include <sa/ikev1/tasks/xauth.h>
+#include <sa/ikev1/tasks/mode_config.h>
+#include <sa/ikev1/tasks/informational.h>
+#include <sa/ikev1/tasks/isakmp_delete.h>
+#include <processing/jobs/adopt_children_job.h>
+
+typedef struct private_aggressive_mode_t private_aggressive_mode_t;
+
+/**
+ * Private members of a aggressive_mode_t task.
+ */
+struct private_aggressive_mode_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	aggressive_mode_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * Common phase 1 helper class
+	 */
+	phase1_t *ph1;
+
+	/**
+	 * IKE config to establish
+	 */
+	ike_cfg_t *ike_cfg;
+
+	/**
+	 * Peer config to use
+	 */
+	peer_cfg_t *peer_cfg;
+
+	/**
+	 * selected IKE proposal
+	 */
+	proposal_t *proposal;
+
+	/**
+	 * Negotiated SA lifetime
+	 */
+	u_int32_t lifetime;
+
+	/**
+	 * Negotiated authentication method
+	 */
+	auth_method_t method;
+
+	/**
+	 * Encoded ID payload, without fixed header
+	 */
+	chunk_t id_data;
+
+	/** states of aggressive mode */
+	enum {
+		AM_INIT,
+		AM_AUTH,
+	} state;
+};
+
+/**
+ * Set IKE_SA to established state
+ */
+static bool establish(private_aggressive_mode_t *this)
+{
+	if (!charon->bus->authorize(charon->bus, TRUE))
+	{
+		DBG1(DBG_IKE, "final authorization hook forbids IKE_SA, cancelling");
+		return FALSE;
+	}
+
+	DBG0(DBG_IKE, "IKE_SA %s[%d] established between %H[%Y]...%H[%Y]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa),
+		 this->ike_sa->get_my_host(this->ike_sa),
+		 this->ike_sa->get_my_id(this->ike_sa),
+		 this->ike_sa->get_other_host(this->ike_sa),
+		 this->ike_sa->get_other_id(this->ike_sa));
+
+	this->ike_sa->set_state(this->ike_sa, IKE_ESTABLISHED);
+	charon->bus->ike_updown(charon->bus, this->ike_sa, TRUE);
+
+	return TRUE;
+}
+
+/**
+ * Check for notify errors, return TRUE if error found
+ */
+static bool has_notify_errors(private_aggressive_mode_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	bool err = FALSE;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == NOTIFY_V1)
+		{
+			notify_payload_t *notify;
+			notify_type_t type;
+
+			notify = (notify_payload_t*)payload;
+			type = notify->get_notify_type(notify);
+			if (type < 16384)
+			{
+				DBG1(DBG_IKE, "received %N error notify",
+					 notify_type_names, type);
+				err = TRUE;
+			}
+			else
+			{
+				DBG1(DBG_IKE, "received %N notify", notify_type_names, type);
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return err;
+}
+
+/**
+ * Queue a task sending a notify in an INFORMATIONAL exchange
+ */
+static status_t send_notify(private_aggressive_mode_t *this, notify_type_t type)
+{
+	notify_payload_t *notify;
+	ike_sa_id_t *ike_sa_id;
+	u_int64_t spi_i, spi_r;
+	chunk_t spi;
+
+	notify = notify_payload_create_from_protocol_and_type(NOTIFY_V1,
+														  PROTO_IKE, type);
+	ike_sa_id = this->ike_sa->get_id(this->ike_sa);
+	spi_i = ike_sa_id->get_initiator_spi(ike_sa_id);
+	spi_r = ike_sa_id->get_responder_spi(ike_sa_id);
+	spi = chunk_cata("cc", chunk_from_thing(spi_i), chunk_from_thing(spi_r));
+	notify->set_spi_data(notify, spi);
+
+	this->ike_sa->queue_task(this->ike_sa,
+						(task_t*)informational_create(this->ike_sa, notify));
+	/* cancel all active/passive tasks in favour of informational */
+	this->ike_sa->flush_queue(this->ike_sa,
+					this->initiator ? TASK_QUEUE_ACTIVE : TASK_QUEUE_PASSIVE);
+	return ALREADY_DONE;
+}
+
+/**
+ * Queue a delete task if authentication failed as initiator
+ */
+static status_t send_delete(private_aggressive_mode_t *this)
+{
+	this->ike_sa->queue_task(this->ike_sa,
+						(task_t*)isakmp_delete_create(this->ike_sa, TRUE));
+	/* cancel all active tasks in favour of informational */
+	this->ike_sa->flush_queue(this->ike_sa,
+					this->initiator ? TASK_QUEUE_ACTIVE : TASK_QUEUE_PASSIVE);
+	return ALREADY_DONE;
+}
+
+METHOD(task_t, build_i, status_t,
+	private_aggressive_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case AM_INIT:
+		{
+			sa_payload_t *sa_payload;
+			id_payload_t *id_payload;
+			linked_list_t *proposals;
+			identification_t *id;
+			packet_t *packet;
+			u_int16_t group;
+
+			DBG0(DBG_IKE, "initiating Aggressive Mode IKE_SA %s[%d] to %H",
+				 this->ike_sa->get_name(this->ike_sa),
+				 this->ike_sa->get_unique_id(this->ike_sa),
+				 this->ike_sa->get_other_host(this->ike_sa));
+			this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
+
+			this->ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
+			this->peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+			this->peer_cfg->get_ref(this->peer_cfg);
+
+			this->method = this->ph1->get_auth_method(this->ph1, this->peer_cfg);
+			if (this->method == AUTH_NONE)
+			{
+				DBG1(DBG_CFG, "configuration uses unsupported authentication");
+				return FAILED;
+			}
+			this->lifetime = this->peer_cfg->get_reauth_time(this->peer_cfg,
+															 FALSE);
+			if (!this->lifetime)
+			{	/* fall back to rekey time of no rekey time configured */
+				this->lifetime = this->peer_cfg->get_rekey_time(this->peer_cfg,
+																 FALSE);
+			}
+			this->lifetime += this->peer_cfg->get_over_time(this->peer_cfg);
+			proposals = this->ike_cfg->get_proposals(this->ike_cfg);
+			sa_payload = sa_payload_create_from_proposals_v1(proposals,
+						this->lifetime, 0, this->method, MODE_NONE, FALSE, 0);
+			proposals->destroy_offset(proposals, offsetof(proposal_t, destroy));
+
+			message->add_payload(message, &sa_payload->payload_interface);
+
+			group = this->ike_cfg->get_dh_group(this->ike_cfg);
+			if (group == MODP_NONE)
+			{
+				DBG1(DBG_IKE, "DH group selection failed");
+				return FAILED;
+			}
+			if (!this->ph1->create_dh(this->ph1, group))
+			{
+				DBG1(DBG_IKE, "DH group %N not supported",
+					 diffie_hellman_group_names, group);
+				return FAILED;
+			}
+			if (!this->ph1->add_nonce_ke(this->ph1, message))
+			{
+				return FAILED;
+			}
+			id = this->ph1->get_id(this->ph1, this->peer_cfg, TRUE);
+			if (!id)
+			{
+				DBG1(DBG_CFG, "own identity not known");
+				return FAILED;
+			}
+			this->ike_sa->set_my_id(this->ike_sa, id->clone(id));
+			id_payload = id_payload_create_from_identification(ID_V1, id);
+			this->id_data = id_payload->get_encoded(id_payload);
+			message->add_payload(message, &id_payload->payload_interface);
+
+			/* pregenerate message to store SA payload */
+			if (this->ike_sa->generate_message(this->ike_sa, message,
+											   &packet) != SUCCESS)
+			{
+				DBG1(DBG_IKE, "pregenerating SA payload failed");
+				return FAILED;
+			}
+			packet->destroy(packet);
+			if (!this->ph1->save_sa_payload(this->ph1, message))
+			{
+				DBG1(DBG_IKE, "SA payload invalid");
+				return FAILED;
+			}
+			this->state = AM_AUTH;
+			return NEED_MORE;
+		}
+		case AM_AUTH:
+		{
+			if (!this->ph1->build_auth(this->ph1, this->method, message,
+									   this->id_data))
+			{
+				this->id_data = chunk_empty;
+				return send_notify(this, AUTHENTICATION_FAILED);
+			}
+			this->id_data = chunk_empty;
+
+			switch (this->method)
+			{
+				case AUTH_XAUTH_INIT_PSK:
+				case AUTH_XAUTH_INIT_RSA:
+				case AUTH_HYBRID_INIT_RSA:
+					/* wait for XAUTH request */
+					break;
+				case AUTH_XAUTH_RESP_PSK:
+				case AUTH_XAUTH_RESP_RSA:
+				case AUTH_HYBRID_RESP_RSA:
+					this->ike_sa->queue_task(this->ike_sa,
+									(task_t*)xauth_create(this->ike_sa, TRUE));
+					return SUCCESS;
+				default:
+					if (charon->ike_sa_manager->check_uniqueness(
+								charon->ike_sa_manager, this->ike_sa, FALSE))
+					{
+						DBG1(DBG_IKE, "cancelling Aggressive Mode due to "
+							 "uniqueness policy");
+						return send_notify(this, AUTHENTICATION_FAILED);
+					}
+					if (!establish(this))
+					{
+						return send_notify(this, AUTHENTICATION_FAILED);
+					}
+					break;
+			}
+			if (this->ph1->has_virtual_ip(this->ph1, this->peer_cfg))
+			{
+				this->ike_sa->queue_task(this->ike_sa,
+							(task_t*)mode_config_create(this->ike_sa, TRUE));
+			}
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_r, status_t,
+	private_aggressive_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case AM_INIT:
+		{
+			sa_payload_t *sa_payload;
+			id_payload_t *id_payload;
+			identification_t *id;
+			linked_list_t *list;
+			u_int16_t group;
+
+			this->ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
+			DBG0(DBG_IKE, "%H is initiating a Aggressive Mode IKE_SA",
+				 message->get_source(message));
+			this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
+
+			this->ike_sa->update_hosts(this->ike_sa,
+									   message->get_destination(message),
+									   message->get_source(message), TRUE);
+
+			sa_payload = (sa_payload_t*)message->get_payload(message,
+													SECURITY_ASSOCIATION_V1);
+			if (!sa_payload)
+			{
+				DBG1(DBG_IKE, "SA payload missing");
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			if (!this->ph1->save_sa_payload(this->ph1, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+
+			list = sa_payload->get_proposals(sa_payload);
+			this->proposal = this->ike_cfg->select_proposal(this->ike_cfg,
+															list, FALSE);
+			list->destroy_offset(list, offsetof(proposal_t, destroy));
+			if (!this->proposal)
+			{
+				DBG1(DBG_IKE, "no proposal found");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->ike_sa->set_proposal(this->ike_sa, this->proposal);
+
+			this->method = sa_payload->get_auth_method(sa_payload);
+			this->lifetime = sa_payload->get_lifetime(sa_payload);
+
+			switch (this->method)
+			{
+				case AUTH_XAUTH_INIT_PSK:
+				case AUTH_XAUTH_RESP_PSK:
+				case AUTH_PSK:
+					if (!lib->settings->get_bool(lib->settings, "%s.i_dont_care"
+						"_about_security_and_use_aggressive_mode_psk",
+						FALSE, charon->name))
+					{
+						DBG1(DBG_IKE, "Aggressive Mode PSK disabled for "
+							 "security reasons");
+						return send_notify(this, AUTHENTICATION_FAILED);
+					}
+					break;
+				default:
+					break;
+			}
+
+			if (!this->proposal->get_algorithm(this->proposal,
+										DIFFIE_HELLMAN_GROUP, &group, NULL))
+			{
+				DBG1(DBG_IKE, "DH group selection failed");
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->ph1->create_dh(this->ph1, group))
+			{
+				DBG1(DBG_IKE, "negotiated DH group not supported");
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->ph1->get_nonce_ke(this->ph1, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+
+			id_payload = (id_payload_t*)message->get_payload(message, ID_V1);
+			if (!id_payload)
+			{
+				DBG1(DBG_IKE, "IDii payload missing");
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+
+			id = id_payload->get_identification(id_payload);
+			this->id_data = id_payload->get_encoded(id_payload);
+			this->ike_sa->set_other_id(this->ike_sa, id);
+			this->peer_cfg = this->ph1->select_config(this->ph1,
+													  this->method, TRUE, id);
+			if (!this->peer_cfg)
+			{
+				return send_notify(this, AUTHENTICATION_FAILED);
+			}
+			this->ike_sa->set_peer_cfg(this->ike_sa, this->peer_cfg);
+
+			this->state = AM_AUTH;
+			if (has_notify_errors(this, message))
+			{
+				return FAILED;
+			}
+			return NEED_MORE;
+		}
+		case AM_AUTH:
+		{
+			while (TRUE)
+			{
+				if (this->ph1->verify_auth(this->ph1, this->method, message,
+										   this->id_data))
+				{
+					break;
+				}
+				this->peer_cfg->destroy(this->peer_cfg);
+				this->peer_cfg = this->ph1->select_config(this->ph1,
+													this->method, TRUE, NULL);
+				if (!this->peer_cfg)
+				{
+					this->id_data = chunk_empty;
+					return send_delete(this);
+				}
+				this->ike_sa->set_peer_cfg(this->ike_sa, this->peer_cfg);
+			}
+			this->id_data = chunk_empty;
+
+			if (!charon->bus->authorize(charon->bus, FALSE))
+			{
+				DBG1(DBG_IKE, "Aggressive Mode authorization hook forbids "
+					 "IKE_SA, cancelling");
+				return send_delete(this);
+			}
+
+			switch (this->method)
+			{
+				case AUTH_XAUTH_INIT_PSK:
+				case AUTH_XAUTH_INIT_RSA:
+				case AUTH_HYBRID_INIT_RSA:
+					this->ike_sa->queue_task(this->ike_sa,
+									(task_t*)xauth_create(this->ike_sa, TRUE));
+					return SUCCESS;
+				case AUTH_XAUTH_RESP_PSK:
+				case AUTH_XAUTH_RESP_RSA:
+				case AUTH_HYBRID_RESP_RSA:
+					/* wait for XAUTH request */
+					break;
+				default:
+					if (charon->ike_sa_manager->check_uniqueness(
+								charon->ike_sa_manager, this->ike_sa, FALSE))
+					{
+						DBG1(DBG_IKE, "cancelling Aggressive Mode due to "
+							 "uniqueness policy");
+						return send_delete(this);
+					}
+					if (!establish(this))
+					{
+						return send_delete(this);
+					}
+					lib->processor->queue_job(lib->processor, (job_t*)
+									adopt_children_job_create(
+										this->ike_sa->get_id(this->ike_sa)));
+					break;
+			}
+			if (!this->ph1->has_pool(this->ph1, this->peer_cfg) &&
+				this->ph1->has_virtual_ip(this->ph1, this->peer_cfg))
+			{
+				this->ike_sa->queue_task(this->ike_sa,
+							(task_t*)mode_config_create(this->ike_sa, TRUE));
+			}
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, build_r, status_t,
+	private_aggressive_mode_t *this, message_t *message)
+{
+	if (this->state == AM_AUTH)
+	{
+		sa_payload_t *sa_payload;
+		id_payload_t *id_payload;
+		identification_t *id;
+
+		sa_payload = sa_payload_create_from_proposal_v1(this->proposal,
+						this->lifetime, 0, this->method, MODE_NONE, FALSE, 0);
+		message->add_payload(message, &sa_payload->payload_interface);
+
+		if (!this->ph1->add_nonce_ke(this->ph1, message))
+		{
+			return send_notify(this, INVALID_KEY_INFORMATION);
+		}
+		if (!this->ph1->create_hasher(this->ph1))
+		{
+			return send_notify(this, NO_PROPOSAL_CHOSEN);
+		}
+		if (!this->ph1->derive_keys(this->ph1, this->peer_cfg, this->method))
+		{
+			return send_notify(this, INVALID_KEY_INFORMATION);
+		}
+
+		id = this->ph1->get_id(this->ph1, this->peer_cfg, TRUE);
+		if (!id)
+		{
+			DBG1(DBG_CFG, "own identity not known");
+			return send_notify(this, INVALID_ID_INFORMATION);
+		}
+		this->ike_sa->set_my_id(this->ike_sa, id->clone(id));
+
+		id_payload = id_payload_create_from_identification(ID_V1, id);
+		message->add_payload(message, &id_payload->payload_interface);
+
+		if (!this->ph1->build_auth(this->ph1, this->method, message,
+								   id_payload->get_encoded(id_payload)))
+		{
+			return send_notify(this, AUTHENTICATION_FAILED);
+		}
+		return NEED_MORE;
+	}
+	return FAILED;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_aggressive_mode_t *this, message_t *message)
+{
+	if (this->state == AM_AUTH)
+	{
+		auth_method_t method;
+		sa_payload_t *sa_payload;
+		id_payload_t *id_payload;
+		identification_t *id, *cid;
+		linked_list_t *list;
+		u_int32_t lifetime;
+
+		sa_payload = (sa_payload_t*)message->get_payload(message,
+												SECURITY_ASSOCIATION_V1);
+		if (!sa_payload)
+		{
+			DBG1(DBG_IKE, "SA payload missing");
+			return send_notify(this, INVALID_PAYLOAD_TYPE);
+		}
+		list = sa_payload->get_proposals(sa_payload);
+		this->proposal = this->ike_cfg->select_proposal(this->ike_cfg,
+														list, FALSE);
+		list->destroy_offset(list, offsetof(proposal_t, destroy));
+		if (!this->proposal)
+		{
+			DBG1(DBG_IKE, "no proposal found");
+			return send_notify(this, NO_PROPOSAL_CHOSEN);
+		}
+		this->ike_sa->set_proposal(this->ike_sa, this->proposal);
+
+		lifetime = sa_payload->get_lifetime(sa_payload);
+		if (lifetime != this->lifetime)
+		{
+			DBG1(DBG_IKE, "received lifetime %us does not match configured "
+				 "lifetime %us", lifetime, this->lifetime);
+		}
+		this->lifetime = lifetime;
+		method = sa_payload->get_auth_method(sa_payload);
+		if (method != this->method)
+		{
+			DBG1(DBG_IKE, "received %N authentication, but configured %N, "
+				 "continue with configured", auth_method_names, method,
+				 auth_method_names, this->method);
+		}
+		if (!this->ph1->get_nonce_ke(this->ph1, message))
+		{
+			return send_notify(this, INVALID_PAYLOAD_TYPE);
+		}
+		if (!this->ph1->create_hasher(this->ph1))
+		{
+			return send_notify(this, NO_PROPOSAL_CHOSEN);
+		}
+
+		id_payload = (id_payload_t*)message->get_payload(message, ID_V1);
+		if (!id_payload)
+		{
+			DBG1(DBG_IKE, "IDir payload missing");
+			return send_delete(this);
+		}
+		id = id_payload->get_identification(id_payload);
+		cid = this->ph1->get_id(this->ph1, this->peer_cfg, FALSE);
+		if (cid && !id->matches(id, cid))
+		{
+			DBG1(DBG_IKE, "IDir '%Y' does not match to '%Y'", id, cid);
+			id->destroy(id);
+			return send_notify(this, INVALID_ID_INFORMATION);
+		}
+		this->ike_sa->set_other_id(this->ike_sa, id);
+
+		if (!this->ph1->derive_keys(this->ph1, this->peer_cfg, this->method))
+		{
+			return send_notify(this, INVALID_KEY_INFORMATION);
+		}
+		if (!this->ph1->verify_auth(this->ph1, this->method, message,
+									id_payload->get_encoded(id_payload)))
+		{
+			return send_notify(this, AUTHENTICATION_FAILED);
+		}
+		if (!charon->bus->authorize(charon->bus, FALSE))
+		{
+			DBG1(DBG_IKE, "Aggressive Mode authorization hook forbids IKE_SA, "
+				 "cancelling");
+			return send_notify(this, AUTHENTICATION_FAILED);
+		}
+
+		return NEED_MORE;
+	}
+	return FAILED;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_aggressive_mode_t *this)
+{
+	return TASK_AGGRESSIVE_MODE;
+}
+
+METHOD(task_t, migrate, void,
+	private_aggressive_mode_t *this, ike_sa_t *ike_sa)
+{
+	DESTROY_IF(this->peer_cfg);
+	DESTROY_IF(this->proposal);
+	this->ph1->destroy(this->ph1);
+	chunk_free(&this->id_data);
+
+	this->ike_sa = ike_sa;
+	this->state = AM_INIT;
+	this->peer_cfg = NULL;
+	this->proposal = NULL;
+	this->ph1 = phase1_create(ike_sa, this->initiator);
+}
+
+METHOD(task_t, destroy, void,
+	private_aggressive_mode_t *this)
+{
+	DESTROY_IF(this->peer_cfg);
+	DESTROY_IF(this->proposal);
+	this->ph1->destroy(this->ph1);
+	chunk_free(&this->id_data);
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+aggressive_mode_t *aggressive_mode_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_aggressive_mode_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.ph1 = phase1_create(ike_sa, initiator),
+		.initiator = initiator,
+		.state = AM_INIT,
+	);
+
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/aggressive_mode.h b/src/libcharon/sa/ikev1/tasks/aggressive_mode.h
new file mode 100644
index 000000000..d0666f41c
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/aggressive_mode.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2012 Martin Willi
+ * Copyright (C) 2012 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup aggressive_mode aggressive_mode
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef AGGRESSIVE_MODE_H_
+#define AGGRESSIVE_MODE_H_
+
+typedef struct aggressive_mode_t aggressive_mode_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * IKEv1 aggressive mode, establishes an IKE_SA without identity protection.
+ */
+struct aggressive_mode_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new AGGRESSIVE_MODE task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if task initiated locally
+ * @return				task to handle by the task_manager
+ */
+aggressive_mode_t *aggressive_mode_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** AGGRESSIVE_MODE_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/informational.c b/src/libcharon/sa/ikev1/tasks/informational.c
new file mode 100644
index 000000000..bda1d2afb
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/informational.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "informational.h"
+
+#include <daemon.h>
+#include <sa/ikev1/tasks/isakmp_delete.h>
+#include <sa/ikev1/tasks/quick_delete.h>
+
+#include <encoding/payloads/delete_payload.h>
+
+typedef struct private_informational_t private_informational_t;
+
+/**
+ * Private members of a informational_t task.
+ */
+struct private_informational_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	informational_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Notify payload to send
+	 */
+	notify_payload_t *notify;
+
+	/**
+	 * Delete subtask
+	 */
+	task_t *del;
+};
+
+/**
+ * Cancel active quick mode after receiving an error
+ */
+static void cancel_quick_mode(private_informational_t *this)
+{
+	enumerator_t *enumerator;
+	task_t *task;
+
+	enumerator = this->ike_sa->create_task_enumerator(this->ike_sa,
+													  TASK_QUEUE_ACTIVE);
+	while (enumerator->enumerate(enumerator, &task))
+	{
+		if (task->get_type(task) == TASK_QUICK_MODE)
+		{
+			this->ike_sa->flush_queue(this->ike_sa, TASK_QUEUE_ACTIVE);
+			break;
+		}
+	}
+	enumerator->destroy(enumerator);
+}
+
+METHOD(task_t, build_i, status_t,
+	private_informational_t *this, message_t *message)
+{
+	message->add_payload(message, &this->notify->payload_interface);
+	this->notify = NULL;
+	return SUCCESS;
+}
+
+METHOD(task_t, process_r, status_t,
+	private_informational_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	delete_payload_t *delete;
+	notify_payload_t *notify;
+	notify_type_t type;
+	payload_t *payload;
+	status_t status = SUCCESS;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		switch (payload->get_type(payload))
+		{
+			case NOTIFY_V1:
+				notify = (notify_payload_t*)payload;
+				type = notify->get_notify_type(notify);
+
+				if (type == INITIAL_CONTACT_IKEV1)
+				{
+					this->ike_sa->set_condition(this->ike_sa,
+												COND_INIT_CONTACT_SEEN, TRUE);
+				}
+				else if (type == UNITY_LOAD_BALANCE)
+				{
+					host_t *redirect, *me;
+					chunk_t data;
+
+					data = notify->get_notification_data(notify);
+					redirect = host_create_from_chunk(AF_INET, data,
+													  IKEV2_UDP_PORT);
+					if (redirect)
+					{	/* treat the redirect as reauthentication */
+						DBG1(DBG_IKE, "received %N notify. redirected to %H",
+							 notify_type_names, type, redirect);
+						/* Cisco boxes reject the first message from 4500 */
+						me = this->ike_sa->get_my_host(this->ike_sa);
+						me->set_port(me, charon->socket->get_port(
+														charon->socket, FALSE));
+						this->ike_sa->set_other_host(this->ike_sa, redirect);
+						this->ike_sa->reauth(this->ike_sa);
+						enumerator->destroy(enumerator);
+						return DESTROY_ME;
+					}
+					else
+					{
+						DBG1(DBG_IKE, "received %N notify, invalid address");
+					}
+				}
+				else if (type < 16384)
+				{
+					DBG1(DBG_IKE, "received %N error notify",
+						 notify_type_names, type);
+					if (this->ike_sa->get_state(this->ike_sa) == IKE_CONNECTING)
+					{	/* only critical during main mode */
+						status = FAILED;
+					}
+					switch (type)
+					{
+						case INVALID_ID_INFORMATION:
+						case NO_PROPOSAL_CHOSEN:
+							cancel_quick_mode(this);
+							break;
+						default:
+							break;
+					}
+					break;
+				}
+				else
+				{
+					DBG1(DBG_IKE, "received %N notify",
+						 notify_type_names, type);
+				}
+				continue;
+			case DELETE_V1:
+				if (!this->del)
+				{
+					delete = (delete_payload_t*)payload;
+					if (delete->get_protocol_id(delete) == PROTO_IKE)
+					{
+						this->del = (task_t*)isakmp_delete_create(this->ike_sa,
+																  FALSE);
+					}
+					else
+					{
+						this->del = (task_t*)quick_delete_create(this->ike_sa,
+												PROTO_NONE, 0, FALSE, FALSE);
+					}
+				}
+				break;
+			default:
+				continue;
+		}
+		break;
+	}
+	enumerator->destroy(enumerator);
+
+	if (this->del && status == SUCCESS)
+	{
+		return this->del->process(this->del, message);
+	}
+	return status;
+}
+
+METHOD(task_t, build_r, status_t,
+	private_informational_t *this, message_t *message)
+{
+	if (this->del)
+	{
+		return this->del->build(this->del, message);
+	}
+	return FAILED;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_informational_t *this, message_t *message)
+{
+	return FAILED;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_informational_t *this)
+{
+	return TASK_INFORMATIONAL;
+}
+
+METHOD(task_t, migrate, void,
+	private_informational_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+}
+
+METHOD(task_t, destroy, void,
+	private_informational_t *this)
+{
+	DESTROY_IF(this->notify);
+	DESTROY_IF(this->del);
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+informational_t *informational_create(ike_sa_t *ike_sa, notify_payload_t *notify)
+{
+	private_informational_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.notify = notify,
+	);
+
+	if (notify)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/informational.h b/src/libcharon/sa/ikev1/tasks/informational.h
new file mode 100644
index 000000000..52938ffbc
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/informational.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup informational informational
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef INFORMATIONAL_H_
+#define INFORMATIONAL_H_
+
+typedef struct informational_t informational_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+#include <encoding/payloads/notify_payload.h>
+
+/**
+ * IKEv1 informational exchange, negotiates errors.
+ */
+struct informational_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new informational task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param notify		notify to send as initiator, NULL if responder
+ * @return				task to handle by the task_manager
+ */
+informational_t *informational_create(ike_sa_t *ike_sa, notify_payload_t *notify);
+
+#endif /** INFORMATIONAL_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_cert_post.c b/src/libcharon/sa/ikev1/tasks/isakmp_cert_post.c
new file mode 100644
index 000000000..edad3b2fa
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_cert_post.c
@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "isakmp_cert_post.h"
+
+#include <daemon.h>
+#include <sa/ike_sa.h>
+#include <encoding/payloads/cert_payload.h>
+#include <encoding/payloads/certreq_payload.h>
+#include <encoding/payloads/auth_payload.h>
+#include <encoding/payloads/sa_payload.h>
+#include <credentials/certificates/x509.h>
+
+
+typedef struct private_isakmp_cert_post_t private_isakmp_cert_post_t;
+
+/**
+ * Private members of a isakmp_cert_post_t task.
+ */
+struct private_isakmp_cert_post_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	isakmp_cert_post_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * States of ike cert pre
+	 */
+	enum {
+		CR_SA,
+		CR_KE,
+		CR_AUTH,
+	} state;
+};
+
+/**
+ * Check if we actually use certificates for authentication
+ */
+static bool use_certs(private_isakmp_cert_post_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	bool use = FALSE;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == SECURITY_ASSOCIATION_V1)
+		{
+			sa_payload_t *sa_payload = (sa_payload_t*)payload;
+
+			switch (sa_payload->get_auth_method(sa_payload))
+			{
+				case AUTH_RSA:
+				case AUTH_ECDSA_256:
+				case AUTH_ECDSA_384:
+				case AUTH_ECDSA_521:
+				case AUTH_XAUTH_INIT_RSA:
+				case AUTH_XAUTH_RESP_RSA:
+				case AUTH_HYBRID_INIT_RSA:
+				case AUTH_HYBRID_RESP_RSA:
+					use = TRUE;
+					break;
+				default:
+					break;
+			}
+			break;
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return use;
+}
+
+/**
+ * Add certificates to message
+ */
+static void build_certs(private_isakmp_cert_post_t *this, message_t *message)
+{
+	peer_cfg_t *peer_cfg;
+
+	peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+	if (!peer_cfg)
+	{
+		return;
+	}
+
+	switch (peer_cfg->get_cert_policy(peer_cfg))
+	{
+		case CERT_NEVER_SEND:
+			break;
+		case CERT_SEND_IF_ASKED:
+			if (!this->ike_sa->has_condition(this->ike_sa, COND_CERTREQ_SEEN))
+			{
+				break;
+			}
+			/* FALL */
+		case CERT_ALWAYS_SEND:
+		{
+			cert_payload_t *payload;
+			enumerator_t *enumerator;
+			certificate_t *cert;
+			auth_rule_t type;
+			auth_cfg_t *auth;
+
+			auth = this->ike_sa->get_auth_cfg(this->ike_sa, TRUE);
+			cert = auth->get(auth, AUTH_RULE_SUBJECT_CERT);
+			if (!cert)
+			{
+				break;
+			}
+			payload = cert_payload_create_from_cert(CERTIFICATE_V1, cert);
+			if (!payload)
+			{
+				break;
+			}
+			DBG1(DBG_IKE, "sending end entity cert \"%Y\"",
+				 cert->get_subject(cert));
+			message->add_payload(message, (payload_t*)payload);
+
+			enumerator = auth->create_enumerator(auth);
+			while (enumerator->enumerate(enumerator, &type, &cert))
+			{
+				if (type == AUTH_RULE_IM_CERT)
+				{
+					payload = cert_payload_create_from_cert(CERTIFICATE_V1, cert);
+					if (payload)
+					{
+						DBG1(DBG_IKE, "sending issuer cert \"%Y\"",
+							 cert->get_subject(cert));
+						message->add_payload(message, (payload_t*)payload);
+					}
+				}
+			}
+			enumerator->destroy(enumerator);
+		}
+	}
+}
+
+METHOD(task_t, build_i, status_t,
+	private_isakmp_cert_post_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+			if (this->state == CR_AUTH)
+			{
+				build_certs(this, message);
+				return SUCCESS;
+			}
+			return NEED_MORE;
+		case AGGRESSIVE:
+			if (this->state == CR_AUTH)
+			{
+				build_certs(this, message);
+				return SUCCESS;
+			}
+			return NEED_MORE;
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_r, status_t,
+	private_isakmp_cert_post_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+		{
+			switch (this->state)
+			{
+				case CR_SA:
+					if (!use_certs(this, message))
+					{
+						return SUCCESS;
+					}
+					return NEED_MORE;
+				case CR_KE:
+					return NEED_MORE;
+				case CR_AUTH:
+					return NEED_MORE;
+				default:
+					return FAILED;
+			}
+		}
+		case AGGRESSIVE:
+		{
+			switch (this->state)
+			{
+				case CR_SA:
+					if (!use_certs(this, message))
+					{
+						return SUCCESS;
+					}
+					return NEED_MORE;
+				case CR_AUTH:
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, build_r, status_t,
+	private_isakmp_cert_post_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+			switch (this->state)
+			{
+				case CR_SA:
+					this->state = CR_KE;
+					return NEED_MORE;
+				case CR_KE:
+					this->state = CR_AUTH;
+					return NEED_MORE;
+				case CR_AUTH:
+					build_certs(this, message);
+					return SUCCESS;
+			}
+		case AGGRESSIVE:
+			switch (this->state)
+			{
+				case CR_SA:
+					build_certs(this, message);
+					this->state = CR_AUTH;
+					return NEED_MORE;
+				case CR_AUTH:
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_i, status_t,
+	private_isakmp_cert_post_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+		{
+			switch (this->state)
+			{
+				case CR_SA:
+					if (!use_certs(this, message))
+					{
+						return SUCCESS;
+					}
+					this->state = CR_KE;
+					return NEED_MORE;
+				case CR_KE:
+					this->state = CR_AUTH;
+					return NEED_MORE;
+				case CR_AUTH:
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+			break;
+		}
+		case AGGRESSIVE:
+		{
+			if (this->state == CR_SA)
+			{
+				if (!use_certs(this, message))
+				{
+					return SUCCESS;
+				}
+				this->state = CR_AUTH;
+				return NEED_MORE;
+			}
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_isakmp_cert_post_t *this)
+{
+	return TASK_ISAKMP_CERT_POST;
+}
+
+METHOD(task_t, migrate, void,
+	private_isakmp_cert_post_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+	this->state = CR_SA;
+}
+
+METHOD(task_t, destroy, void,
+	private_isakmp_cert_post_t *this)
+{
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+isakmp_cert_post_t *isakmp_cert_post_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_isakmp_cert_post_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.initiator = initiator,
+		.state = CR_SA,
+	);
+	if (initiator)
+	{
+		this->public.task.process = _process_i;
+		this->public.task.build = _build_i;
+	}
+	else
+	{
+		this->public.task.process = _process_r;
+		this->public.task.build = _build_r;
+	}
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_cert_post.h b/src/libcharon/sa/ikev1/tasks/isakmp_cert_post.h
new file mode 100644
index 000000000..3a155cb68
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_cert_post.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup isakmp_cert_post isakmp_cert_post
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef ISAKMP_CERT_POST_H_
+#define ISAKMP_CERT_POST_H_
+
+typedef struct isakmp_cert_post_t isakmp_cert_post_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * ISAKMP_CERT_POST, IKEv1 certificate processing after authentication.
+ */
+struct isakmp_cert_post_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new isakmp_cert_post task.
+ *
+ * The initiator parameter means the original initiator, not the initiator
+ * of the certificate request.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if task is the original initiator
+ * @return				isakmp_cert_post task to handle by the task_manager
+ */
+isakmp_cert_post_t *isakmp_cert_post_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** ISAKMP_CERT_POST_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_cert_pre.c b/src/libcharon/sa/ikev1/tasks/isakmp_cert_pre.c
new file mode 100644
index 000000000..d48484f09
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_cert_pre.c
@@ -0,0 +1,578 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "isakmp_cert_pre.h"
+
+#include <daemon.h>
+#include <sa/ike_sa.h>
+#include <encoding/payloads/cert_payload.h>
+#include <encoding/payloads/sa_payload.h>
+#include <encoding/payloads/certreq_payload.h>
+#include <credentials/certificates/x509.h>
+
+
+typedef struct private_isakmp_cert_pre_t private_isakmp_cert_pre_t;
+
+/**
+ * Private members of a isakmp_cert_pre_t task.
+ */
+struct private_isakmp_cert_pre_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	isakmp_cert_pre_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * Send certificate requests?
+	 */
+	bool send_req;
+
+	/** next message we expect */
+	enum {
+		CR_SA,
+		CR_KE,
+		CR_AUTH,
+	} state;
+};
+
+/**
+ * Find the CA certificate for a given certreq payload
+ */
+static certificate_t* find_certificate(private_isakmp_cert_pre_t *this,
+									   certreq_payload_t *certreq)
+{
+	identification_t *id;
+	certificate_t *cert;
+
+	if (certreq->get_cert_type(certreq) != CERT_X509)
+	{
+		DBG1(DBG_IKE, "%N CERTREQ not supported - ignored",
+			 certificate_type_names, certreq->get_cert_type(certreq));
+		return NULL;
+	}
+	id = certreq->get_dn(certreq);
+	if (!id)
+	{
+		DBG1(DBG_IKE, "ignoring certificate request without data",
+			 certificate_type_names, certreq->get_cert_type(certreq));
+		return NULL;
+	}
+	cert = lib->credmgr->get_cert(lib->credmgr, CERT_X509, KEY_ANY, id, TRUE);
+	if (cert)
+	{
+		DBG1(DBG_IKE, "received cert request for '%Y'",
+			 cert->get_subject(cert));
+	}
+	else
+	{
+		DBG1(DBG_IKE, "received cert request for unknown ca '%Y'", id);
+	}
+	id->destroy(id);
+
+	return cert;
+}
+
+/**
+ * read certificate requests
+ */
+static void process_certreqs(private_isakmp_cert_pre_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	auth_cfg_t *auth;
+
+	auth = this->ike_sa->get_auth_cfg(this->ike_sa, TRUE);
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		switch (payload->get_type(payload))
+		{
+			case CERTIFICATE_REQUEST_V1:
+			{
+				certificate_t *cert;
+
+				this->ike_sa->set_condition(this->ike_sa,
+											COND_CERTREQ_SEEN, TRUE);
+				cert = find_certificate(this, (certreq_payload_t*)payload);
+				if (cert)
+				{
+					auth->add(auth, AUTH_RULE_CA_CERT, cert);
+				}
+				break;
+			}
+			default:
+				break;
+		}
+	}
+	enumerator->destroy(enumerator);
+}
+
+/**
+ * Import receuved certificates
+ */
+static void process_certs(private_isakmp_cert_pre_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	auth_cfg_t *auth;
+	bool first = TRUE;
+
+	auth = this->ike_sa->get_auth_cfg(this->ike_sa, FALSE);
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == CERTIFICATE_V1)
+		{
+			cert_payload_t *cert_payload;
+			cert_encoding_t encoding;
+			certificate_t *cert;
+
+			cert_payload = (cert_payload_t*)payload;
+			encoding = cert_payload->get_cert_encoding(cert_payload);
+
+			switch (encoding)
+			{
+				case ENC_X509_SIGNATURE:
+				{
+					cert = cert_payload->get_cert(cert_payload);
+					if (cert)
+					{
+						if (first)
+						{	/* the first is an end entity certificate */
+							DBG1(DBG_IKE, "received end entity cert \"%Y\"",
+								 cert->get_subject(cert));
+							auth->add(auth, AUTH_HELPER_SUBJECT_CERT, cert);
+							first = FALSE;
+						}
+						else
+						{
+							DBG1(DBG_IKE, "received issuer cert \"%Y\"",
+								 cert->get_subject(cert));
+							auth->add(auth, AUTH_HELPER_IM_CERT, cert);
+						}
+					}
+					break;
+				}
+				case ENC_CRL:
+					cert = cert_payload->get_cert(cert_payload);
+					if (cert)
+					{
+						DBG1(DBG_IKE, "received CRL \"%Y\"",
+							 cert->get_subject(cert));
+						auth->add(auth, AUTH_HELPER_REVOCATION_CERT, cert);
+					}
+					break;
+				case ENC_PKCS7_WRAPPED_X509:
+				case ENC_PGP:
+				case ENC_DNS_SIGNED_KEY:
+				case ENC_KERBEROS_TOKEN:
+				case ENC_ARL:
+				case ENC_SPKI:
+				case ENC_X509_ATTRIBUTE:
+				case ENC_RAW_RSA_KEY:
+				case ENC_X509_HASH_AND_URL_BUNDLE:
+				case ENC_OCSP_CONTENT:
+				default:
+					DBG1(DBG_ENC, "certificate encoding %N not supported",
+						 cert_encoding_names, encoding);
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+}
+
+/**
+ * Add the subject of a CA certificate a message
+ */
+static void add_certreq(private_isakmp_cert_pre_t *this, message_t *message,
+						certificate_t *cert)
+{
+	if (cert->get_type(cert) == CERT_X509)
+	{
+		x509_t *x509 = (x509_t*)cert;
+
+		if (x509->get_flags(x509) & X509_CA)
+		{
+			DBG1(DBG_IKE, "sending cert request for \"%Y\"",
+				 cert->get_subject(cert));
+			message->add_payload(message, (payload_t*)
+							certreq_payload_create_dn(cert->get_subject(cert)));
+		}
+	}
+}
+
+/**
+ * Add auth_cfg's CA certificates to the certificate request
+ */
+static void add_certreqs(private_isakmp_cert_pre_t *this,
+						 auth_cfg_t *auth, message_t *message)
+{
+	enumerator_t *enumerator;
+	auth_rule_t type;
+	void *value;
+
+	enumerator = auth->create_enumerator(auth);
+	while (enumerator->enumerate(enumerator, &type, &value))
+	{
+		switch (type)
+		{
+			case AUTH_RULE_CA_CERT:
+				add_certreq(this, message, (certificate_t*)value);
+				break;
+			default:
+				break;
+		}
+	}
+	enumerator->destroy(enumerator);
+}
+
+/**
+ * Build certificate requests
+ */
+static void build_certreqs(private_isakmp_cert_pre_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	ike_cfg_t *ike_cfg;
+	peer_cfg_t *peer_cfg;
+	certificate_t *cert;
+	auth_cfg_t *auth;
+
+	ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
+	if (!ike_cfg->send_certreq(ike_cfg))
+	{
+		return;
+	}
+	/* check if we require a specific CA for that peer */
+	peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+	if (peer_cfg)
+	{
+		enumerator = peer_cfg->create_auth_cfg_enumerator(peer_cfg, FALSE);
+		if (enumerator->enumerate(enumerator, &auth))
+		{
+			add_certreqs(this, auth, message);
+		}
+		enumerator->destroy(enumerator);
+	}
+	if (!message->get_payload(message, CERTIFICATE_REQUEST_V1))
+	{
+		/* otherwise add all trusted CA certificates */
+		enumerator = lib->credmgr->create_cert_enumerator(lib->credmgr,
+												CERT_ANY, KEY_ANY, NULL, TRUE);
+		while (enumerator->enumerate(enumerator, &cert))
+		{
+			add_certreq(this, message, cert);
+		}
+		enumerator->destroy(enumerator);
+	}
+}
+
+/**
+ * Check if we actually use certificates for authentication
+ */
+static bool use_certs(private_isakmp_cert_pre_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	bool use = FALSE;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == SECURITY_ASSOCIATION_V1)
+		{
+			sa_payload_t *sa_payload = (sa_payload_t*)payload;
+
+			switch (sa_payload->get_auth_method(sa_payload))
+			{
+				case AUTH_HYBRID_INIT_RSA:
+				case AUTH_HYBRID_RESP_RSA:
+					if (!this->initiator)
+					{
+						this->send_req = FALSE;
+					}
+					/* FALL */
+				case AUTH_RSA:
+				case AUTH_ECDSA_256:
+				case AUTH_ECDSA_384:
+				case AUTH_ECDSA_521:
+				case AUTH_XAUTH_INIT_RSA:
+				case AUTH_XAUTH_RESP_RSA:
+					use = TRUE;
+					break;
+				default:
+					break;
+			}
+			break;
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return use;
+}
+
+/**
+ * Check if we should send a certificate request
+ */
+static bool send_certreq(private_isakmp_cert_pre_t *this)
+{
+	enumerator_t *enumerator;
+	peer_cfg_t *peer_cfg;
+	auth_cfg_t *auth;
+	bool req = FALSE;
+	auth_class_t class;
+
+	peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+	if (peer_cfg)
+	{
+		enumerator = peer_cfg->create_auth_cfg_enumerator(peer_cfg, FALSE);
+		if (enumerator->enumerate(enumerator, &auth))
+		{
+			class = (intptr_t)auth->get(auth, AUTH_RULE_AUTH_CLASS);
+			if (class == AUTH_CLASS_PUBKEY)
+			{
+				req = TRUE;
+			}
+		}
+		enumerator->destroy(enumerator);
+	}
+	return req;
+}
+
+METHOD(task_t, build_i, status_t,
+	private_isakmp_cert_pre_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+			if (this->state == CR_AUTH)
+			{
+				build_certreqs(this, message);
+			}
+			return NEED_MORE;
+		case AGGRESSIVE:
+			if (this->state == CR_SA)
+			{
+				if (send_certreq(this))
+				{
+					build_certreqs(this, message);
+				}
+			}
+			return NEED_MORE;
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_r, status_t,
+	private_isakmp_cert_pre_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+		{
+			switch (this->state)
+			{
+				case CR_SA:
+					if (!use_certs(this, message))
+					{
+						return SUCCESS;
+					}
+					return NEED_MORE;
+				case CR_KE:
+					process_certreqs(this, message);
+					return NEED_MORE;
+				case CR_AUTH:
+					process_certreqs(this, message);
+					process_certs(this, message);
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+		}
+		case AGGRESSIVE:
+		{
+			switch (this->state)
+			{
+				case CR_SA:
+					if (!use_certs(this, message))
+					{
+						return SUCCESS;
+					}
+					process_certreqs(this, message);
+					return NEED_MORE;
+				case CR_AUTH:
+					process_certs(this, message);
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, build_r, status_t,
+	private_isakmp_cert_pre_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+			switch (this->state)
+			{
+				case CR_SA:
+					this->state = CR_KE;
+					return NEED_MORE;
+				case CR_KE:
+					if (this->send_req)
+					{
+						build_certreqs(this, message);
+					}
+					this->state = CR_AUTH;
+					return NEED_MORE;
+				case CR_AUTH:
+					return NEED_MORE;
+				default:
+					return FAILED;
+			}
+		case AGGRESSIVE:
+			switch (this->state)
+			{
+				case CR_SA:
+					if (this->send_req)
+					{
+						build_certreqs(this, message);
+					}
+					this->state = CR_AUTH;
+					return NEED_MORE;
+				case CR_AUTH:
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_i, status_t,
+	private_isakmp_cert_pre_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+		{
+			switch (this->state)
+			{
+				case CR_SA:
+					if (!use_certs(this, message))
+					{
+						return SUCCESS;
+					}
+					this->state = CR_KE;
+					return NEED_MORE;
+				case CR_KE:
+					process_certreqs(this, message);
+					this->state = CR_AUTH;
+					return NEED_MORE;
+				case CR_AUTH:
+					process_certs(this, message);
+					return SUCCESS;
+				default:
+					return FAILED;
+			}
+			break;
+		}
+		case AGGRESSIVE:
+		{
+			if (!use_certs(this, message))
+			{
+				return SUCCESS;
+			}
+			process_certreqs(this, message);
+			process_certs(this, message);
+			this->state = CR_AUTH;
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_isakmp_cert_pre_t *this)
+{
+	return TASK_ISAKMP_CERT_PRE;
+}
+
+METHOD(task_t, migrate, void,
+	private_isakmp_cert_pre_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+	this->state = CR_SA;
+	this->send_req = TRUE;
+}
+
+METHOD(task_t, destroy, void,
+	private_isakmp_cert_pre_t *this)
+{
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+isakmp_cert_pre_t *isakmp_cert_pre_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_isakmp_cert_pre_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.initiator = initiator,
+		.state = CR_SA,
+		.send_req = TRUE,
+	);
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_cert_pre.h b/src/libcharon/sa/ikev1/tasks/isakmp_cert_pre.h
new file mode 100644
index 000000000..8e1a94b97
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_cert_pre.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup isakmp_cert_pre isakmp_cert_pre
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef ISAKMP_CERT_PRE_H_
+#define ISAKMP_CERT_PRE_H_
+
+typedef struct isakmp_cert_pre_t isakmp_cert_pre_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * ISAKMP_CERT_PRE task, IKEv1 certificate processing before authentication.
+ */
+struct isakmp_cert_pre_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new ISAKMP_CERT_PRE task.
+ *
+ * The initiator parameter means the original initiator, not the initiator
+ * of the certificate request.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if task is the original initiator
+ * @return				isakmp_cert_pre task to handle by the task_manager
+ */
+isakmp_cert_pre_t *isakmp_cert_pre_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** ISAKMP_CERT_PRE_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_delete.c b/src/libcharon/sa/ikev1/tasks/isakmp_delete.c
new file mode 100644
index 000000000..0640d13b1
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_delete.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "isakmp_delete.h"
+
+#include <daemon.h>
+#include <encoding/payloads/delete_payload.h>
+
+typedef struct private_isakmp_delete_t private_isakmp_delete_t;
+
+/**
+ * Private members of a isakmp_delete_t task.
+ */
+struct private_isakmp_delete_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	isakmp_delete_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+};
+
+METHOD(task_t, build_i, status_t,
+	private_isakmp_delete_t *this, message_t *message)
+{
+	delete_payload_t *delete_payload;
+	ike_sa_id_t *id;
+
+	DBG0(DBG_IKE, "deleting IKE_SA %s[%d] between %H[%Y]...%H[%Y]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa),
+		 this->ike_sa->get_my_host(this->ike_sa),
+		 this->ike_sa->get_my_id(this->ike_sa),
+		 this->ike_sa->get_other_host(this->ike_sa),
+		 this->ike_sa->get_other_id(this->ike_sa));
+
+	delete_payload = delete_payload_create(DELETE_V1, PROTO_IKE);
+	id = this->ike_sa->get_id(this->ike_sa);
+	delete_payload->set_ike_spi(delete_payload, id->get_initiator_spi(id),
+								id->get_responder_spi(id));
+	message->add_payload(message, (payload_t*)delete_payload);
+
+	DBG1(DBG_IKE, "sending DELETE for IKE_SA %s[%d]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa));
+
+	this->ike_sa->set_state(this->ike_sa, IKE_DELETING);
+	charon->bus->ike_updown(charon->bus, this->ike_sa, FALSE);
+	return SUCCESS;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_isakmp_delete_t *this, message_t *message)
+{
+	return FAILED;
+}
+
+METHOD(task_t, process_r, status_t,
+	private_isakmp_delete_t *this, message_t *message)
+{
+	DBG1(DBG_IKE, "received DELETE for IKE_SA %s[%d]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa));
+	DBG0(DBG_IKE, "deleting IKE_SA %s[%d] between %H[%Y]...%H[%Y]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa),
+		 this->ike_sa->get_my_host(this->ike_sa),
+		 this->ike_sa->get_my_id(this->ike_sa),
+		 this->ike_sa->get_other_host(this->ike_sa),
+		 this->ike_sa->get_other_id(this->ike_sa));
+
+	this->ike_sa->set_state(this->ike_sa, IKE_DELETING);
+	charon->bus->ike_updown(charon->bus, this->ike_sa, FALSE);
+	return DESTROY_ME;
+}
+
+METHOD(task_t, build_r, status_t,
+	private_isakmp_delete_t *this, message_t *message)
+{
+	return FAILED;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_isakmp_delete_t *this)
+{
+	return TASK_ISAKMP_DELETE;
+}
+
+METHOD(task_t, migrate, void,
+	private_isakmp_delete_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+}
+
+METHOD(task_t, destroy, void,
+	private_isakmp_delete_t *this)
+{
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+isakmp_delete_t *isakmp_delete_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_isakmp_delete_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+	);
+
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_delete.h b/src/libcharon/sa/ikev1/tasks/isakmp_delete.h
new file mode 100644
index 000000000..1a7a62207
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_delete.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup isakmp_delete isakmp_delete
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef ISAKMP_DELETE_H_
+#define ISAKMP_DELETE_H_
+
+typedef struct isakmp_delete_t isakmp_delete_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * Task of type ISAKMP_DELETE, delete an IKEv1 IKE_SA.
+ */
+struct isakmp_delete_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new isakmp_delete task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if we initiate the delete
+ * @return				isakmp_delete task to handle by the task_manager
+ */
+isakmp_delete_t *isakmp_delete_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** ISAKMP_DELETE_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_dpd.c b/src/libcharon/sa/ikev1/tasks/isakmp_dpd.c
new file mode 100644
index 000000000..a3395a043
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_dpd.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "isakmp_dpd.h"
+
+#include <daemon.h>
+#include <encoding/payloads/notify_payload.h>
+
+typedef struct private_isakmp_dpd_t private_isakmp_dpd_t;
+
+/**
+ * Private members of a isakmp_dpd_t task.
+ */
+struct private_isakmp_dpd_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	isakmp_dpd_t public;
+
+	/**
+	 * Sequence number.
+	 */
+	u_int32_t seqnr;
+
+	/**
+	 * DPD notify type
+	 */
+	notify_type_t type;
+
+	/**
+	 * IKE SA we are serving.
+	 */
+	ike_sa_t *ike_sa;
+};
+
+METHOD(task_t, build, status_t,
+	private_isakmp_dpd_t *this, message_t *message)
+{
+	notify_payload_t *notify;
+	ike_sa_id_t *ike_sa_id;
+	u_int64_t spi_i, spi_r;
+	u_int32_t seqnr;
+	chunk_t spi;
+
+	notify = notify_payload_create_from_protocol_and_type(NOTIFY_V1,
+														  PROTO_IKE, this->type);
+	seqnr = htonl(this->seqnr);
+	ike_sa_id = this->ike_sa->get_id(this->ike_sa);
+	spi_i = ike_sa_id->get_initiator_spi(ike_sa_id);
+	spi_r = ike_sa_id->get_responder_spi(ike_sa_id);
+	spi = chunk_cata("cc", chunk_from_thing(spi_i), chunk_from_thing(spi_r));
+
+	notify->set_spi_data(notify, spi);
+	notify->set_notification_data(notify, chunk_from_thing(seqnr));
+
+	message->add_payload(message, (payload_t*)notify);
+
+	return SUCCESS;
+}
+
+METHOD(task_t, process, status_t,
+	private_isakmp_dpd_t *this, message_t *message)
+{
+	/* done in task manager */
+	return FAILED;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_isakmp_dpd_t *this)
+{
+	return TASK_ISAKMP_DPD;
+}
+
+METHOD(task_t, migrate, void,
+	private_isakmp_dpd_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+}
+
+METHOD(task_t, destroy, void,
+	private_isakmp_dpd_t *this)
+{
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+isakmp_dpd_t *isakmp_dpd_create(ike_sa_t *ike_sa, notify_type_t type,
+								u_int32_t seqnr)
+{
+	private_isakmp_dpd_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.build = _build,
+				.process = _process,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.seqnr = seqnr,
+		.type = type,
+	);
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_dpd.h b/src/libcharon/sa/ikev1/tasks/isakmp_dpd.h
new file mode 100644
index 000000000..06a0175eb
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_dpd.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2012 Martin Willi
+ * Copyright (C) 2012 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup isakmp_dpd isakmp_dpd
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef ISAKMP_DPD_H_
+#define ISAKMP_DPD_H_
+
+typedef struct isakmp_dpd_t isakmp_dpd_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * IKEv1 dead peer detection task.
+ */
+struct isakmp_dpd_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new ISAKMP_DPD task.
+ *
+ * @param ike_sa		associated IKE_SA
+ * @param type			DPD notify to use, DPD_R_U_THERE | DPD_R_U_THERE_ACK
+ * @param seqnr			DPD sequence number to use/expect
+ * @return				ISAKMP_DPD task to handle by the task_manager
+ */
+isakmp_dpd_t *isakmp_dpd_create(ike_sa_t *ike_sa, notify_type_t type,
+								u_int32_t seqnr);
+
+#endif /** ISAKMP_DPD_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_natd.c b/src/libcharon/sa/ikev1/tasks/isakmp_natd.c
new file mode 100644
index 000000000..50bf1612d
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_natd.c
@@ -0,0 +1,456 @@
+/*
+ * Copyright (C) 2006-2011 Tobias Brunner,
+ * Copyright (C) 2006-2007 Martin Willi
+ * Copyright (C) 2006 Daniel Roethlisberger
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "isakmp_natd.h"
+
+#include <string.h>
+
+#include <hydra.h>
+#include <daemon.h>
+#include <sa/ikev1/keymat_v1.h>
+#include <config/peer_cfg.h>
+#include <crypto/hashers/hasher.h>
+#include <encoding/payloads/hash_payload.h>
+
+typedef struct private_isakmp_natd_t private_isakmp_natd_t;
+
+/**
+ * Private members of a ike_natt_t task.
+ */
+struct private_isakmp_natd_t {
+
+	/**
+	 * Public interface.
+	 */
+	isakmp_natd_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * Keymat derivation (from SA)
+	 */
+	keymat_v1_t *keymat;
+
+	/**
+	 * Did we process any NAT detection payloads for a source address?
+	 */
+	bool src_seen;
+
+	/**
+	 * Did we process any NAT detection payloads for a destination address?
+	 */
+	bool dst_seen;
+
+	/**
+	 * Have we found a matching source address NAT hash?
+	 */
+	bool src_matched;
+
+	/**
+	 * Have we found a matching destination address NAT hash?
+	 */
+	bool dst_matched;
+};
+
+/**
+ * Build NAT detection hash for a host.
+ */
+static chunk_t generate_natd_hash(private_isakmp_natd_t *this,
+								  ike_sa_id_t *ike_sa_id, host_t *host)
+{
+	hasher_t *hasher;
+	chunk_t natd_chunk, natd_hash;
+	u_int64_t spi_i, spi_r;
+	u_int16_t port;
+
+	hasher = this->keymat->get_hasher(this->keymat);
+	if (!hasher)
+	{
+		DBG1(DBG_IKE, "no hasher available to build NAT-D payload");
+		return chunk_empty;
+	}
+
+	spi_i = ike_sa_id->get_initiator_spi(ike_sa_id);
+	spi_r = ike_sa_id->get_responder_spi(ike_sa_id);
+	port = htons(host->get_port(host));
+
+	/*  natd_hash = HASH(CKY-I | CKY-R | IP | Port) */
+	natd_chunk = chunk_cata("cccc", chunk_from_thing(spi_i),
+						    chunk_from_thing(spi_r), host->get_address(host),
+						    chunk_from_thing(port));
+	if (!hasher->allocate_hash(hasher, natd_chunk, &natd_hash))
+	{
+		DBG1(DBG_IKE, "creating NAT-D payload hash failed");
+		return chunk_empty;
+	}
+	DBG3(DBG_IKE, "natd_chunk %B", &natd_chunk);
+	DBG3(DBG_IKE, "natd_hash %B", &natd_hash);
+
+	return natd_hash;
+}
+
+/**
+ * Build a faked NAT-D payload to enforce UDP encapsulation.
+ */
+static chunk_t generate_natd_hash_faked(private_isakmp_natd_t *this)
+{
+	hasher_t *hasher;
+	chunk_t chunk;
+	rng_t *rng;
+
+	hasher = this->keymat->get_hasher(this->keymat);
+	if (!hasher)
+	{
+		DBG1(DBG_IKE, "no hasher available to build NAT-D payload");
+		return chunk_empty;
+	}
+	rng = lib->crypto->create_rng(lib->crypto, RNG_WEAK);
+	if (!rng ||
+		!rng->allocate_bytes(rng, hasher->get_hash_size(hasher), &chunk))
+	{
+		DBG1(DBG_IKE, "unable to get random bytes for NAT-D fake");
+		DESTROY_IF(rng);
+		return chunk_empty;
+	}
+	rng->destroy(rng);
+	return chunk;
+}
+
+/**
+ * Build a NAT-D payload.
+ */
+static hash_payload_t *build_natd_payload(private_isakmp_natd_t *this, bool src,
+										  host_t *host)
+{
+	hash_payload_t *payload;
+	ike_cfg_t *config;
+	chunk_t hash;
+
+	config = this->ike_sa->get_ike_cfg(this->ike_sa);
+	if (src && config->force_encap(config))
+	{
+		hash = generate_natd_hash_faked(this);
+	}
+	else
+	{
+		ike_sa_id_t *ike_sa_id = this->ike_sa->get_id(this->ike_sa);
+		hash = generate_natd_hash(this, ike_sa_id, host);
+	}
+	if (!hash.len)
+	{
+		return NULL;
+	}
+	payload = hash_payload_create(NAT_D_V1);
+	payload->set_hash(payload, hash);
+	chunk_free(&hash);
+	return payload;
+}
+
+/**
+ * Add NAT-D payloads to the message.
+ */
+static void add_natd_payloads(private_isakmp_natd_t *this, message_t *message)
+{
+	hash_payload_t *payload;
+	host_t *host;
+
+	/* destination has to be added first */
+	host = message->get_destination(message);
+	payload = build_natd_payload(this, FALSE, host);
+	if (payload)
+	{
+		message->add_payload(message, (payload_t*)payload);
+	}
+
+	/* source is added second, compared with IKEv2 we always know the source,
+	 * as these payloads are added in the second Phase 1 exchange or the
+	 * response to the first */
+	host = message->get_source(message);
+	payload = build_natd_payload(this, TRUE, host);
+	if (payload)
+	{
+		message->add_payload(message, (payload_t*)payload);
+	}
+}
+
+/**
+ * Read NAT-D payloads from message and evaluate them.
+ */
+static void process_payloads(private_isakmp_natd_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	hash_payload_t *hash_payload;
+	chunk_t hash, src_hash, dst_hash;
+	ike_sa_id_t *ike_sa_id;
+	host_t *me, *other;
+	ike_cfg_t *config;
+
+	/* precompute hashes for incoming NAT-D comparison */
+	ike_sa_id = message->get_ike_sa_id(message);
+	me = message->get_destination(message);
+	other = message->get_source(message);
+	dst_hash = generate_natd_hash(this, ike_sa_id, me);
+	src_hash = generate_natd_hash(this, ike_sa_id, other);
+
+	DBG3(DBG_IKE, "precalculated src_hash %B", &src_hash);
+	DBG3(DBG_IKE, "precalculated dst_hash %B", &dst_hash);
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) != NAT_D_V1)
+		{
+			continue;
+		}
+		hash_payload = (hash_payload_t*)payload;
+		if (!this->dst_seen)
+		{	/* the first NAT-D payload contains the destination hash */
+			this->dst_seen = TRUE;
+			hash = hash_payload->get_hash(hash_payload);
+			DBG3(DBG_IKE, "received dst_hash %B", &hash);
+			if (chunk_equals(hash, dst_hash))
+			{
+				this->dst_matched = TRUE;
+			}
+			continue;
+		}
+		/* the other NAT-D payloads contain source hashes */
+		this->src_seen = TRUE;
+		if (!this->src_matched)
+		{
+			hash = hash_payload->get_hash(hash_payload);
+			DBG3(DBG_IKE, "received src_hash %B", &hash);
+			if (chunk_equals(hash, src_hash))
+			{
+				this->src_matched = TRUE;
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	chunk_free(&src_hash);
+	chunk_free(&dst_hash);
+
+	if (this->src_seen && this->dst_seen)
+	{
+		this->ike_sa->set_condition(this->ike_sa, COND_NAT_HERE,
+									!this->dst_matched);
+		this->ike_sa->set_condition(this->ike_sa, COND_NAT_THERE,
+									!this->src_matched);
+		config = this->ike_sa->get_ike_cfg(this->ike_sa);
+		if (this->dst_matched && this->src_matched &&
+			config->force_encap(config))
+		{
+			this->ike_sa->set_condition(this->ike_sa, COND_NAT_FAKE, TRUE);
+		}
+	}
+}
+
+METHOD(task_t, build_i, status_t,
+	private_isakmp_natd_t *this, message_t *message)
+{
+	status_t result = NEED_MORE;
+
+	switch (message->get_exchange_type(message))
+	{
+		case AGGRESSIVE:
+		{	/* add NAT-D payloads to the second request, already processed
+			 * those by the responder contained in the first response */
+			result = SUCCESS;
+			/* fall */
+		}
+		case ID_PROT:
+		{	/* add NAT-D payloads to the second request, need to process
+			 * those by the responder contained in the second response */
+			if (message->get_payload(message, SECURITY_ASSOCIATION_V1))
+			{	/* wait for the second exchange */
+				return NEED_MORE;
+			}
+			add_natd_payloads(this, message);
+			return result;
+		}
+		default:
+			break;
+	}
+	return SUCCESS;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_isakmp_natd_t *this, message_t *message)
+{
+	status_t result = NEED_MORE;
+
+	if (!this->ike_sa->supports_extension(this->ike_sa, EXT_NATT))
+	{	/* we didn't receive VIDs inidcating support for NAT-T */
+		return SUCCESS;
+	}
+
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+		{	/* process NAT-D payloads in the second response, added them in the
+			 * second request already, so we're done afterwards */
+			if (message->get_payload(message, SECURITY_ASSOCIATION_V1))
+			{	/* wait for the second exchange */
+				return NEED_MORE;
+			}
+			result = SUCCESS;
+			/* fall */
+		}
+		case AGGRESSIVE:
+		{	/* process NAT-D payloads in the first response, add them in the
+			 * following second request */
+			process_payloads(this, message);
+
+			if (this->ike_sa->has_condition(this->ike_sa, COND_NAT_ANY))
+			{
+				this->ike_sa->float_ports(this->ike_sa);
+			}
+			return result;
+		}
+		default:
+			break;
+	}
+	return SUCCESS;
+}
+
+METHOD(task_t, process_r, status_t,
+	private_isakmp_natd_t *this, message_t *message)
+{
+	status_t result = NEED_MORE;
+
+	if (!this->ike_sa->supports_extension(this->ike_sa, EXT_NATT))
+	{	/* we didn't receive VIDs indicating NAT-T support */
+		return SUCCESS;
+	}
+
+	switch (message->get_exchange_type(message))
+	{
+		case AGGRESSIVE:
+		{	/* proccess NAT-D payloads in the second request, already added ours
+			 * in the first response */
+			result = SUCCESS;
+			/* fall */
+		}
+		case ID_PROT:
+		{	/* process NAT-D payloads in the second request, need to add ours
+			 * to the second response */
+			if (message->get_payload(message, SECURITY_ASSOCIATION_V1))
+			{	/* wait for the second exchange */
+				return NEED_MORE;
+			}
+			process_payloads(this, message);
+			return result;
+		}
+		default:
+			break;
+	}
+	return SUCCESS;
+}
+
+METHOD(task_t, build_r, status_t,
+	private_isakmp_natd_t *this, message_t *message)
+{
+	switch (message->get_exchange_type(message))
+	{
+		case ID_PROT:
+		{	/* add NAT-D payloads to second response, already processed those
+			 * contained in the second request */
+			if (message->get_payload(message, SECURITY_ASSOCIATION_V1))
+			{	/* wait for the second exchange */
+				return NEED_MORE;
+			}
+			add_natd_payloads(this, message);
+			return SUCCESS;
+		}
+		case AGGRESSIVE:
+		{	/* add NAT-D payloads to the first response, process those contained
+			 * in the following second request */
+			add_natd_payloads(this, message);
+			return NEED_MORE;
+		}
+		default:
+			break;
+	}
+	return SUCCESS;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_isakmp_natd_t *this)
+{
+	return TASK_ISAKMP_NATD;
+}
+
+METHOD(task_t, migrate, void,
+	private_isakmp_natd_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+	this->keymat = (keymat_v1_t*)ike_sa->get_keymat(ike_sa);
+	this->src_seen = FALSE;
+	this->dst_seen = FALSE;
+	this->src_matched = FALSE;
+	this->dst_matched = FALSE;
+}
+
+METHOD(task_t, destroy, void,
+	private_isakmp_natd_t *this)
+{
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+isakmp_natd_t *isakmp_natd_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_isakmp_natd_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.keymat = (keymat_v1_t*)ike_sa->get_keymat(ike_sa),
+		.initiator = initiator,
+	);
+
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_natd.h b/src/libcharon/sa/ikev1/tasks/isakmp_natd.h
new file mode 100644
index 000000000..63947fc73
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_natd.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2011 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup isakmp_natd isakmp_natd
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef ISAKMP_NATD_H_
+#define ISAKMP_NATD_H_
+
+typedef struct isakmp_natd_t isakmp_natd_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * Task of type ISAKMP_NATD, detects NAT situation in IKEv1 Phase 1.
+ */
+struct isakmp_natd_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new ISAKMP_NATD task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if task is the original initiator
+ * @return				isakmp_natd task to handle by the task_manager
+ */
+isakmp_natd_t *isakmp_natd_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** ISAKMP_NATD_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_vendor.c b/src/libcharon/sa/ikev1/tasks/isakmp_vendor.c
new file mode 100644
index 000000000..4fd0ef39b
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_vendor.c
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2009 Martin Willi
+ * Hochschule fuer Technik Rapperswil
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "isakmp_vendor.h"
+
+#include <daemon.h>
+#include <encoding/payloads/vendor_id_payload.h>
+
+typedef struct private_isakmp_vendor_t private_isakmp_vendor_t;
+
+/**
+ * Private data of an isakmp_vendor_t object.
+ */
+struct private_isakmp_vendor_t {
+
+	/**
+	 * Public isakmp_vendor_t interface.
+	 */
+	isakmp_vendor_t public;
+
+	/**
+	 * Associated IKE_SA
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the inititator of this task
+	 */
+	bool initiator;
+};
+
+/**
+ * IKEv1 Vendor ID database
+ */
+static struct {
+	/* Description */
+	char *desc;
+	/* extension flag negotiated with vendor ID, if any */
+	ike_extension_t extension;
+	/* send yourself? */
+	bool send;
+	/* length of vendor ID string */
+	int len;
+	/* vendor ID string */
+	char *id;
+} vendor_ids[] = {
+
+	/* strongSwan MD5("strongSwan") */
+	{ "strongSwan", EXT_STRONGSWAN, FALSE, 16,
+	  "\x88\x2f\xe5\x6d\x6f\xd2\x0d\xbc\x22\x51\x61\x3b\x2e\xbe\x5b\xeb"},
+
+	/* XAuth, MD5("draft-ietf-ipsra-isakmp-xauth-06.txt") */
+	{ "XAuth", EXT_XAUTH, TRUE, 8,
+	  "\x09\x00\x26\x89\xdf\xd6\xb7\x12"},
+
+	/* NAT-Traversal, MD5("RFC 3947") */
+	{ "NAT-T (RFC 3947)", EXT_NATT, TRUE, 16,
+	  "\x4a\x13\x1c\x81\x07\x03\x58\x45\x5c\x57\x28\xf2\x0e\x95\x45\x2f"},
+
+	/* Dead peer detection, RFC 3706 */
+	{ "DPD", EXT_DPD, TRUE, 16,
+	  "\xaf\xca\xd7\x13\x68\xa1\xf1\xc9\x6b\x86\x96\xfc\x77\x57\x01\x00"},
+
+	{ "draft-stenberg-ipsec-nat-traversal-01", 0, FALSE, 16,
+	  "\x27\xba\xb5\xdc\x01\xea\x07\x60\xea\x4e\x31\x90\xac\x27\xc0\xd0"},
+
+	{ "draft-stenberg-ipsec-nat-traversal-02", 0, FALSE, 16,
+	  "\x61\x05\xc4\x22\xe7\x68\x47\xe4\x3f\x96\x84\x80\x12\x92\xae\xcd"},
+
+	{ "draft-ietf-ipsec-nat-t-ike", 0, FALSE, 16,
+	  "\x4d\xf3\x79\x28\xe9\xfc\x4f\xd1\xb3\x26\x21\x70\xd5\x15\xc6\x62"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-00", 0, FALSE, 16,
+	  "\x44\x85\x15\x2d\x18\xb6\xbb\xcd\x0b\xe8\xa8\x46\x95\x79\xdd\xcc"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-02", 0, FALSE, 16,
+	  "\xcd\x60\x46\x43\x35\xdf\x21\xf8\x7c\xfd\xb2\xfc\x68\xb6\xa4\x48"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-02\\n", 0, FALSE, 16,
+	  "\x90\xcb\x80\x91\x3e\xbb\x69\x6e\x08\x63\x81\xb5\xec\x42\x7b\x1f"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-03", 0, FALSE, 16,
+	  "\x7d\x94\x19\xa6\x53\x10\xca\x6f\x2c\x17\x9d\x92\x15\x52\x9d\x56"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-04", 0, FALSE, 16,
+	  "\x99\x09\xb6\x4e\xed\x93\x7c\x65\x73\xde\x52\xac\xe9\x52\xfa\x6b"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-05", 0, FALSE, 16,
+	  "\x80\xd0\xbb\x3d\xef\x54\x56\x5e\xe8\x46\x45\xd4\xc8\x5c\xe3\xee"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-06", 0, FALSE, 16,
+	  "\x4d\x1e\x0e\x13\x6d\xea\xfa\x34\xc4\xf3\xea\x9f\x02\xec\x72\x85"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-07", 0, FALSE, 16,
+	  "\x43\x9b\x59\xf8\xba\x67\x6c\x4c\x77\x37\xae\x22\xea\xb8\xf5\x82"},
+
+	{ "draft-ietf-ipsec-nat-t-ike-08", 0, FALSE, 16,
+	  "\x8f\x8d\x83\x82\x6d\x24\x6b\x6f\xc7\xa8\xa6\xa4\x28\xc1\x1d\xe8"},
+
+	{ "Cisco Unity", EXT_CISCO_UNITY, FALSE, 16,
+	  "\x12\xf5\xf2\x8c\x45\x71\x68\xa9\x70\x2d\x9f\xe2\x74\xcc\x01\x00"},
+};
+
+METHOD(task_t, build, status_t,
+	private_isakmp_vendor_t *this, message_t *message)
+{
+	vendor_id_payload_t *vid_payload;
+	bool strongswan, cisco_unity;
+	int i;
+
+	strongswan = lib->settings->get_bool(lib->settings,
+									"%s.send_vendor_id", FALSE, charon->name);
+	cisco_unity = lib->settings->get_bool(lib->settings,
+									"%s.cisco_unity", FALSE, charon->name);
+	for (i = 0; i < countof(vendor_ids); i++)
+	{
+		if (vendor_ids[i].send ||
+		   (vendor_ids[i].extension == EXT_STRONGSWAN && strongswan) ||
+		   (vendor_ids[i].extension == EXT_CISCO_UNITY && cisco_unity))
+		{
+			vid_payload = vendor_id_payload_create_data(VENDOR_ID_V1,
+				chunk_clone(chunk_create(vendor_ids[i].id, vendor_ids[i].len)));
+			message->add_payload(message, &vid_payload->payload_interface);
+		}
+	}
+	return this->initiator ? NEED_MORE : SUCCESS;
+}
+
+METHOD(task_t, process, status_t,
+	private_isakmp_vendor_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	int i;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == VENDOR_ID_V1)
+		{
+			vendor_id_payload_t *vid;
+			bool found = FALSE;
+			chunk_t data;
+
+			vid = (vendor_id_payload_t*)payload;
+			data = vid->get_data(vid);
+
+			for (i = 0; i < countof(vendor_ids); i++)
+			{
+				if (chunk_equals(data, chunk_create(vendor_ids[i].id,
+													vendor_ids[i].len)))
+				{
+					DBG1(DBG_IKE, "received %s vendor ID", vendor_ids[i].desc);
+					if (vendor_ids[i].extension)
+					{
+						this->ike_sa->enable_extension(this->ike_sa,
+													   vendor_ids[i].extension);
+					}
+					found = TRUE;
+				}
+			}
+			if (!found)
+			{
+				DBG1(DBG_ENC, "received unknown vendor ID: %#B", &data);
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return this->initiator ? SUCCESS : NEED_MORE;
+}
+
+METHOD(task_t, migrate, void,
+	private_isakmp_vendor_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_isakmp_vendor_t *this)
+{
+	return TASK_ISAKMP_VENDOR;
+}
+
+METHOD(task_t, destroy, void,
+	private_isakmp_vendor_t *this)
+{
+	free(this);
+}
+
+/**
+ * See header
+ */
+isakmp_vendor_t *isakmp_vendor_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_isakmp_vendor_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.build = _build,
+				.process = _process,
+				.migrate = _migrate,
+				.get_type = _get_type,
+				.destroy = _destroy,
+			},
+		},
+		.initiator = initiator,
+		.ike_sa = ike_sa,
+	);
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/isakmp_vendor.h b/src/libcharon/sa/ikev1/tasks/isakmp_vendor.h
new file mode 100644
index 000000000..91891085b
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/isakmp_vendor.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup isakmp_vendor isakmp_vendor
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef ISAKMP_VENDOR_H_
+#define ISAKMP_VENDOR_H_
+
+typedef struct isakmp_vendor_t isakmp_vendor_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * Vendor ID processing task for IKEv1.
+ */
+struct isakmp_vendor_t {
+
+	/**
+	 * Implements task interface.
+	 */
+	task_t task;
+};
+
+/**
+ * Create a isakmp_vendor instance.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if task is the original initiator
+ */
+isakmp_vendor_t *isakmp_vendor_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** ISAKMP_VENDOR_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/main_mode.c b/src/libcharon/sa/ikev1/tasks/main_mode.c
new file mode 100644
index 000000000..9ccf9abf5
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/main_mode.c
@@ -0,0 +1,735 @@
+/*
+ * Copyright (C) 2011-2012 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "main_mode.h"
+
+#include <string.h>
+
+#include <daemon.h>
+#include <sa/ikev1/phase1.h>
+#include <encoding/payloads/sa_payload.h>
+#include <encoding/payloads/id_payload.h>
+#include <encoding/payloads/hash_payload.h>
+#include <sa/ikev1/tasks/xauth.h>
+#include <sa/ikev1/tasks/mode_config.h>
+#include <sa/ikev1/tasks/informational.h>
+#include <sa/ikev1/tasks/isakmp_delete.h>
+#include <processing/jobs/adopt_children_job.h>
+
+typedef struct private_main_mode_t private_main_mode_t;
+
+/**
+ * Private members of a main_mode_t task.
+ */
+struct private_main_mode_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	main_mode_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * Common phase 1 helper class
+	 */
+	phase1_t *ph1;
+
+	/**
+	 * IKE config to establish
+	 */
+	ike_cfg_t *ike_cfg;
+
+	/**
+	 * Peer config to use
+	 */
+	peer_cfg_t *peer_cfg;
+
+	/**
+	 * selected IKE proposal
+	 */
+	proposal_t *proposal;
+
+	/**
+	 * Negotiated SA lifetime
+	 */
+	u_int32_t lifetime;
+
+	/**
+	 * Negotiated authentication method
+	 */
+	auth_method_t method;
+
+	/** states of main mode */
+	enum {
+		MM_INIT,
+		MM_SA,
+		MM_KE,
+		MM_AUTH,
+	} state;
+};
+
+/**
+ * Set IKE_SA to established state
+ */
+static bool establish(private_main_mode_t *this)
+{
+	if (!charon->bus->authorize(charon->bus, TRUE))
+	{
+		DBG1(DBG_IKE, "final authorization hook forbids IKE_SA, cancelling");
+		return FALSE;
+	}
+
+	DBG0(DBG_IKE, "IKE_SA %s[%d] established between %H[%Y]...%H[%Y]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa),
+		 this->ike_sa->get_my_host(this->ike_sa),
+		 this->ike_sa->get_my_id(this->ike_sa),
+		 this->ike_sa->get_other_host(this->ike_sa),
+		 this->ike_sa->get_other_id(this->ike_sa));
+
+	this->ike_sa->set_state(this->ike_sa, IKE_ESTABLISHED);
+	charon->bus->ike_updown(charon->bus, this->ike_sa, TRUE);
+
+	return TRUE;
+}
+
+/**
+ * Check for notify errors, return TRUE if error found
+ */
+static bool has_notify_errors(private_main_mode_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	bool err = FALSE;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == NOTIFY_V1)
+		{
+			notify_payload_t *notify;
+			notify_type_t type;
+
+			notify = (notify_payload_t*)payload;
+			type = notify->get_notify_type(notify);
+			if (type < 16384)
+			{
+				DBG1(DBG_IKE, "received %N error notify",
+					 notify_type_names, type);
+				err = TRUE;
+			}
+			else if (type == INITIAL_CONTACT_IKEV1)
+			{
+				if (!this->initiator && this->state == MM_AUTH)
+				{
+					/* If authenticated and received INITIAL_CONTACT,
+					 * delete any existing IKE_SAs with that peer.
+					 * The delete takes place when the SA is checked in due
+					 * to other id not known until the 3rd message.*/
+					this->ike_sa->set_condition(this->ike_sa,
+												COND_INIT_CONTACT_SEEN, TRUE);
+				}
+			}
+			else
+			{
+				DBG1(DBG_IKE, "received %N notify", notify_type_names, type);
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return err;
+}
+
+/**
+ * Queue a task sending a notify in an INFORMATIONAL exchange
+ */
+static status_t send_notify(private_main_mode_t *this, notify_type_t type)
+{
+	notify_payload_t *notify;
+	ike_sa_id_t *ike_sa_id;
+	u_int64_t spi_i, spi_r;
+	chunk_t spi;
+
+	notify = notify_payload_create_from_protocol_and_type(NOTIFY_V1,
+														  PROTO_IKE, type);
+	ike_sa_id = this->ike_sa->get_id(this->ike_sa);
+	spi_i = ike_sa_id->get_initiator_spi(ike_sa_id);
+	spi_r = ike_sa_id->get_responder_spi(ike_sa_id);
+	spi = chunk_cata("cc", chunk_from_thing(spi_i), chunk_from_thing(spi_r));
+	notify->set_spi_data(notify, spi);
+
+	this->ike_sa->queue_task(this->ike_sa,
+						(task_t*)informational_create(this->ike_sa, notify));
+	/* cancel all active/passive tasks in favour of informational */
+	this->ike_sa->flush_queue(this->ike_sa,
+					this->initiator ? TASK_QUEUE_ACTIVE : TASK_QUEUE_PASSIVE);
+	return ALREADY_DONE;
+}
+
+/**
+ * Queue a delete task if authentication failed as initiator
+ */
+static status_t send_delete(private_main_mode_t *this)
+{
+	this->ike_sa->queue_task(this->ike_sa,
+						(task_t*)isakmp_delete_create(this->ike_sa, TRUE));
+	/* cancel all active tasks in favour of informational */
+	this->ike_sa->flush_queue(this->ike_sa,
+					this->initiator ? TASK_QUEUE_ACTIVE : TASK_QUEUE_PASSIVE);
+	return ALREADY_DONE;
+}
+
+METHOD(task_t, build_i, status_t,
+	private_main_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case MM_INIT:
+		{
+			sa_payload_t *sa_payload;
+			linked_list_t *proposals;
+			packet_t *packet;
+
+			DBG0(DBG_IKE, "initiating Main Mode IKE_SA %s[%d] to %H",
+				 this->ike_sa->get_name(this->ike_sa),
+				 this->ike_sa->get_unique_id(this->ike_sa),
+				 this->ike_sa->get_other_host(this->ike_sa));
+			this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
+
+			this->ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
+			this->peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+			this->peer_cfg->get_ref(this->peer_cfg);
+
+			this->method = this->ph1->get_auth_method(this->ph1, this->peer_cfg);
+			if (this->method == AUTH_NONE)
+			{
+				DBG1(DBG_CFG, "configuration uses unsupported authentication");
+				return FAILED;
+			}
+			this->lifetime = this->peer_cfg->get_reauth_time(this->peer_cfg,
+															 FALSE);
+			if (!this->lifetime)
+			{	/* fall back to rekey time of no rekey time configured */
+				this->lifetime = this->peer_cfg->get_rekey_time(this->peer_cfg,
+																 FALSE);
+			}
+			this->lifetime += this->peer_cfg->get_over_time(this->peer_cfg);
+			proposals = this->ike_cfg->get_proposals(this->ike_cfg);
+			sa_payload = sa_payload_create_from_proposals_v1(proposals,
+						this->lifetime, 0, this->method, MODE_NONE, FALSE, 0);
+			proposals->destroy_offset(proposals, offsetof(proposal_t, destroy));
+
+			message->add_payload(message, &sa_payload->payload_interface);
+
+			/* pregenerate message to store SA payload */
+			if (this->ike_sa->generate_message(this->ike_sa, message,
+											   &packet) != SUCCESS)
+			{
+				DBG1(DBG_IKE, "pregenerating SA payload failed");
+				return FAILED;
+			}
+			packet->destroy(packet);
+			if (!this->ph1->save_sa_payload(this->ph1, message))
+			{
+				return FAILED;
+			}
+
+			this->state = MM_SA;
+			return NEED_MORE;
+		}
+		case MM_SA:
+		{
+			u_int16_t group;
+
+			if (!this->ph1->create_hasher(this->ph1))
+			{
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			if (!this->proposal->get_algorithm(this->proposal,
+										DIFFIE_HELLMAN_GROUP, &group, NULL))
+			{
+				DBG1(DBG_IKE, "DH group selection failed");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			if (!this->ph1->create_dh(this->ph1, group))
+			{
+				DBG1(DBG_IKE, "negotiated DH group not supported");
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->ph1->add_nonce_ke(this->ph1, message))
+			{
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			this->state = MM_KE;
+			return NEED_MORE;
+		}
+		case MM_KE:
+		{
+			id_payload_t *id_payload;
+			identification_t *id;
+
+			id = this->ph1->get_id(this->ph1, this->peer_cfg, TRUE);
+			if (!id)
+			{
+				DBG1(DBG_CFG, "own identity not known");
+				return send_notify(this, INVALID_ID_INFORMATION);
+			}
+			this->ike_sa->set_my_id(this->ike_sa, id->clone(id));
+			id_payload = id_payload_create_from_identification(ID_V1, id);
+			message->add_payload(message, &id_payload->payload_interface);
+
+			if (!this->ph1->build_auth(this->ph1, this->method, message,
+									   id_payload->get_encoded(id_payload)))
+			{
+				return send_notify(this, AUTHENTICATION_FAILED);
+			}
+
+			this->state = MM_AUTH;
+			return NEED_MORE;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_r, status_t,
+	private_main_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case MM_INIT:
+		{
+			linked_list_t *list;
+			sa_payload_t *sa_payload;
+			bool private;
+
+			this->ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
+			DBG0(DBG_IKE, "%H is initiating a Main Mode IKE_SA",
+				 message->get_source(message));
+			this->ike_sa->set_state(this->ike_sa, IKE_CONNECTING);
+
+			this->ike_sa->update_hosts(this->ike_sa,
+									   message->get_destination(message),
+									   message->get_source(message), TRUE);
+
+			sa_payload = (sa_payload_t*)message->get_payload(message,
+													SECURITY_ASSOCIATION_V1);
+			if (!sa_payload)
+			{
+				DBG1(DBG_IKE, "SA payload missing");
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			if (!this->ph1->save_sa_payload(this->ph1, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+
+			list = sa_payload->get_proposals(sa_payload);
+			private = this->ike_sa->supports_extension(this->ike_sa,
+														   EXT_STRONGSWAN);
+			this->proposal = this->ike_cfg->select_proposal(this->ike_cfg,
+															list, private);
+			list->destroy_offset(list, offsetof(proposal_t, destroy));
+			if (!this->proposal)
+			{
+				DBG1(DBG_IKE, "no proposal found");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->ike_sa->set_proposal(this->ike_sa, this->proposal);
+
+			this->method = sa_payload->get_auth_method(sa_payload);
+			this->lifetime = sa_payload->get_lifetime(sa_payload);
+
+			this->state = MM_SA;
+			return NEED_MORE;
+		}
+		case MM_SA:
+		{
+			u_int16_t group;
+
+			if (!this->ph1->create_hasher(this->ph1))
+			{
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->proposal->get_algorithm(this->proposal,
+										DIFFIE_HELLMAN_GROUP, &group, NULL))
+			{
+				DBG1(DBG_IKE, "DH group selection failed");
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->ph1->create_dh(this->ph1, group))
+			{
+				DBG1(DBG_IKE, "negotiated DH group not supported");
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->ph1->get_nonce_ke(this->ph1, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			this->state = MM_KE;
+			return NEED_MORE;
+		}
+		case MM_KE:
+		{
+			id_payload_t *id_payload;
+			identification_t *id;
+
+			id_payload = (id_payload_t*)message->get_payload(message, ID_V1);
+			if (!id_payload)
+			{
+				DBG1(DBG_IKE, "IDii payload missing");
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			id = id_payload->get_identification(id_payload);
+			this->ike_sa->set_other_id(this->ike_sa, id);
+
+			while (TRUE)
+			{
+				DESTROY_IF(this->peer_cfg);
+				this->peer_cfg = this->ph1->select_config(this->ph1,
+													this->method, FALSE, id);
+				if (!this->peer_cfg)
+				{
+					return send_notify(this, AUTHENTICATION_FAILED);
+				}
+				this->ike_sa->set_peer_cfg(this->ike_sa, this->peer_cfg);
+
+				if (this->ph1->verify_auth(this->ph1, this->method, message,
+										   id_payload->get_encoded(id_payload)))
+				{
+					break;
+				}
+			}
+
+			if (!charon->bus->authorize(charon->bus, FALSE))
+			{
+				DBG1(DBG_IKE, "Main Mode authorization hook forbids IKE_SA, "
+					 "cancelling");
+				return send_notify(this, AUTHENTICATION_FAILED);
+			}
+
+			this->state = MM_AUTH;
+			if (has_notify_errors(this, message))
+			{
+				return FAILED;
+			}
+			return NEED_MORE;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, build_r, status_t,
+	private_main_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case MM_SA:
+		{
+			sa_payload_t *sa_payload;
+
+			sa_payload = sa_payload_create_from_proposal_v1(this->proposal,
+						this->lifetime, 0, this->method, MODE_NONE, FALSE, 0);
+			message->add_payload(message, &sa_payload->payload_interface);
+
+			return NEED_MORE;
+		}
+		case MM_KE:
+		{
+			if (!this->ph1->add_nonce_ke(this->ph1, message))
+			{
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!this->ph1->derive_keys(this->ph1, this->peer_cfg, this->method))
+			{
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			return NEED_MORE;
+		}
+		case MM_AUTH:
+		{
+			id_payload_t *id_payload;
+			identification_t *id;
+
+			id = this->ph1->get_id(this->ph1, this->peer_cfg, TRUE);
+			if (!id)
+			{
+				DBG1(DBG_CFG, "own identity not known");
+				return send_notify(this, INVALID_ID_INFORMATION);
+			}
+			this->ike_sa->set_my_id(this->ike_sa, id->clone(id));
+
+			id_payload = id_payload_create_from_identification(ID_V1, id);
+			message->add_payload(message, &id_payload->payload_interface);
+
+			if (!this->ph1->build_auth(this->ph1, this->method, message,
+									   id_payload->get_encoded(id_payload)))
+			{
+				return send_notify(this, AUTHENTICATION_FAILED);
+			}
+
+			switch (this->method)
+			{
+				case AUTH_XAUTH_INIT_PSK:
+				case AUTH_XAUTH_INIT_RSA:
+				case AUTH_HYBRID_INIT_RSA:
+					this->ike_sa->queue_task(this->ike_sa,
+									(task_t*)xauth_create(this->ike_sa, TRUE));
+					return SUCCESS;
+				case AUTH_XAUTH_RESP_PSK:
+				case AUTH_XAUTH_RESP_RSA:
+				case AUTH_HYBRID_RESP_RSA:
+					/* wait for XAUTH request */
+					break;
+				default:
+					if (charon->ike_sa_manager->check_uniqueness(
+								charon->ike_sa_manager, this->ike_sa, FALSE))
+					{
+						DBG1(DBG_IKE, "cancelling Main Mode due to uniqueness "
+							 "policy");
+						return send_notify(this, AUTHENTICATION_FAILED);
+					}
+					if (!establish(this))
+					{
+						return send_notify(this, AUTHENTICATION_FAILED);
+					}
+					lib->processor->queue_job(lib->processor, (job_t*)
+									adopt_children_job_create(
+										this->ike_sa->get_id(this->ike_sa)));
+					break;
+			}
+			if (!this->ph1->has_pool(this->ph1, this->peer_cfg) &&
+				this->ph1->has_virtual_ip(this->ph1, this->peer_cfg))
+			{
+				this->ike_sa->queue_task(this->ike_sa,
+							(task_t*)mode_config_create(this->ike_sa, TRUE));
+			}
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_i, status_t,
+	private_main_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case MM_SA:
+		{
+			linked_list_t *list;
+			sa_payload_t *sa_payload;
+			auth_method_t method;
+			u_int32_t lifetime;
+			bool private;
+
+			sa_payload = (sa_payload_t*)message->get_payload(message,
+													SECURITY_ASSOCIATION_V1);
+			if (!sa_payload)
+			{
+				DBG1(DBG_IKE, "SA payload missing");
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			list = sa_payload->get_proposals(sa_payload);
+			private = this->ike_sa->supports_extension(this->ike_sa,
+														   EXT_STRONGSWAN);
+			this->proposal = this->ike_cfg->select_proposal(this->ike_cfg,
+															list, private);
+			list->destroy_offset(list, offsetof(proposal_t, destroy));
+			if (!this->proposal)
+			{
+				DBG1(DBG_IKE, "no proposal found");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->ike_sa->set_proposal(this->ike_sa, this->proposal);
+
+			lifetime = sa_payload->get_lifetime(sa_payload);
+			if (lifetime != this->lifetime)
+			{
+				DBG1(DBG_IKE, "received lifetime %us does not match configured "
+					 "lifetime %us", lifetime, this->lifetime);
+			}
+			this->lifetime = lifetime;
+			method = sa_payload->get_auth_method(sa_payload);
+			if (method != this->method)
+			{
+				DBG1(DBG_IKE, "received %N authentication, but configured %N, "
+					 "continue with configured", auth_method_names, method,
+					 auth_method_names, this->method);
+			}
+			return NEED_MORE;
+		}
+		case MM_KE:
+		{
+			if (!this->ph1->get_nonce_ke(this->ph1, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			if (!this->ph1->derive_keys(this->ph1, this->peer_cfg, this->method))
+			{
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			return NEED_MORE;
+		}
+		case MM_AUTH:
+		{
+			id_payload_t *id_payload;
+			identification_t *id, *cid;
+
+			id_payload = (id_payload_t*)message->get_payload(message, ID_V1);
+			if (!id_payload)
+			{
+				DBG1(DBG_IKE, "IDir payload missing");
+				return send_delete(this);
+			}
+			id = id_payload->get_identification(id_payload);
+			cid = this->ph1->get_id(this->ph1, this->peer_cfg, FALSE);
+			if (cid && !id->matches(id, cid))
+			{
+				DBG1(DBG_IKE, "IDir '%Y' does not match to '%Y'", id, cid);
+				id->destroy(id);
+				return send_delete(this);
+			}
+			this->ike_sa->set_other_id(this->ike_sa, id);
+
+			if (!this->ph1->verify_auth(this->ph1, this->method, message,
+										id_payload->get_encoded(id_payload)))
+			{
+				return send_delete(this);
+			}
+			if (!charon->bus->authorize(charon->bus, FALSE))
+			{
+				DBG1(DBG_IKE, "Main Mode authorization hook forbids IKE_SA, "
+					 "cancelling");
+				return send_delete(this);
+			}
+
+			switch (this->method)
+			{
+				case AUTH_XAUTH_INIT_PSK:
+				case AUTH_XAUTH_INIT_RSA:
+				case AUTH_HYBRID_INIT_RSA:
+					/* wait for XAUTH request */
+					break;
+				case AUTH_XAUTH_RESP_PSK:
+				case AUTH_XAUTH_RESP_RSA:
+				case AUTH_HYBRID_RESP_RSA:
+					this->ike_sa->queue_task(this->ike_sa,
+									(task_t*)xauth_create(this->ike_sa, TRUE));
+					return SUCCESS;
+				default:
+					if (charon->ike_sa_manager->check_uniqueness(
+								charon->ike_sa_manager, this->ike_sa, FALSE))
+					{
+						DBG1(DBG_IKE, "cancelling Main Mode due to uniqueness "
+							 "policy");
+						return send_delete(this);
+					}
+					if (!establish(this))
+					{
+						return send_delete(this);
+					}
+					break;
+			}
+			if (this->ph1->has_virtual_ip(this->ph1, this->peer_cfg))
+			{
+				this->ike_sa->queue_task(this->ike_sa,
+							(task_t*)mode_config_create(this->ike_sa, TRUE));
+			}
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_main_mode_t *this)
+{
+	return TASK_MAIN_MODE;
+}
+
+METHOD(task_t, migrate, void,
+	private_main_mode_t *this, ike_sa_t *ike_sa)
+{
+	DESTROY_IF(this->peer_cfg);
+	DESTROY_IF(this->proposal);
+	this->ph1->destroy(this->ph1);
+
+	this->ike_sa = ike_sa;
+	this->state = MM_INIT;
+	this->peer_cfg = NULL;
+	this->proposal = NULL;
+	this->ph1 = phase1_create(ike_sa, this->initiator);
+}
+
+METHOD(task_t, destroy, void,
+	private_main_mode_t *this)
+{
+	DESTROY_IF(this->peer_cfg);
+	DESTROY_IF(this->proposal);
+	this->ph1->destroy(this->ph1);
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+main_mode_t *main_mode_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_main_mode_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.ph1 = phase1_create(ike_sa, initiator),
+		.initiator = initiator,
+		.state = MM_INIT,
+	);
+
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/main_mode.h b/src/libcharon/sa/ikev1/tasks/main_mode.h
new file mode 100644
index 000000000..141701f75
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/main_mode.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup main_mode main_mode
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef MAIN_MODE_H_
+#define MAIN_MODE_H_
+
+typedef struct main_mode_t main_mode_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * IKEv1 main mode, establishes a mainmode including authentication.
+ */
+struct main_mode_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new main_mode task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE if task initiated locally
+ * @return				task to handle by the task_manager
+ */
+main_mode_t *main_mode_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** MAIN_MODE_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/mode_config.c b/src/libcharon/sa/ikev1/tasks/mode_config.c
new file mode 100644
index 000000000..ce897727a
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/mode_config.c
@@ -0,0 +1,459 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "mode_config.h"
+
+#include <daemon.h>
+#include <hydra.h>
+#include <encoding/payloads/cp_payload.h>
+
+typedef struct private_mode_config_t private_mode_config_t;
+
+/**
+ * Private members of a mode_config_t task.
+ */
+struct private_mode_config_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	mode_config_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * Received list of virtual IPs, host_t*
+	 */
+	linked_list_t *vips;
+
+	/**
+	 * list of attributes requested and its handler, entry_t
+	 */
+	linked_list_t *requested;
+
+	/**
+	 * Identifier to include in response
+	 */
+	u_int16_t identifier;
+};
+
+/**
+ * Entry for a requested attribute and the requesting handler
+ */
+typedef struct {
+	/** attribute requested */
+	configuration_attribute_type_t type;
+	/** handler requesting this attribute */
+	attribute_handler_t *handler;
+} entry_t;
+
+/**
+ * build INTERNAL_IPV4/6_ADDRESS attribute from virtual ip
+ */
+static configuration_attribute_t *build_vip(host_t *vip)
+{
+	configuration_attribute_type_t type;
+	chunk_t chunk, prefix;
+
+	if (vip->get_family(vip) == AF_INET)
+	{
+		type = INTERNAL_IP4_ADDRESS;
+		if (vip->is_anyaddr(vip))
+		{
+			chunk = chunk_empty;
+		}
+		else
+		{
+			chunk = vip->get_address(vip);
+		}
+	}
+	else
+	{
+		type = INTERNAL_IP6_ADDRESS;
+		if (vip->is_anyaddr(vip))
+		{
+			chunk = chunk_empty;
+		}
+		else
+		{
+			prefix = chunk_alloca(1);
+			*prefix.ptr = 64;
+			chunk = vip->get_address(vip);
+			chunk = chunk_cata("cc", chunk, prefix);
+		}
+	}
+	return configuration_attribute_create_chunk(CONFIGURATION_ATTRIBUTE_V1,
+												type, chunk);
+}
+
+/**
+ * Handle a received attribute as initiator
+ */
+static void handle_attribute(private_mode_config_t *this,
+							 configuration_attribute_t *ca)
+{
+	attribute_handler_t *handler = NULL;
+	enumerator_t *enumerator;
+	entry_t *entry;
+
+	/* find the handler which requested this attribute */
+	enumerator = this->requested->create_enumerator(this->requested);
+	while (enumerator->enumerate(enumerator, &entry))
+	{
+		if (entry->type == ca->get_type(ca))
+		{
+			handler = entry->handler;
+			this->requested->remove_at(this->requested, enumerator);
+			free(entry);
+			break;
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	/* and pass it to the handle function */
+	handler = hydra->attributes->handle(hydra->attributes,
+							this->ike_sa->get_other_id(this->ike_sa), handler,
+							ca->get_type(ca), ca->get_chunk(ca));
+	if (handler)
+	{
+		this->ike_sa->add_configuration_attribute(this->ike_sa,
+				handler, ca->get_type(ca), ca->get_chunk(ca));
+	}
+}
+
+/**
+ * process a single configuration attribute
+ */
+static void process_attribute(private_mode_config_t *this,
+							  configuration_attribute_t *ca)
+{
+	host_t *ip;
+	chunk_t addr;
+	int family = AF_INET6;
+
+	switch (ca->get_type(ca))
+	{
+		case INTERNAL_IP4_ADDRESS:
+			family = AF_INET;
+			/* fall */
+		case INTERNAL_IP6_ADDRESS:
+		{
+			addr = ca->get_chunk(ca);
+			if (addr.len == 0)
+			{
+				ip = host_create_any(family);
+			}
+			else
+			{
+				/* skip prefix byte in IPv6 payload*/
+				if (family == AF_INET6)
+				{
+					addr.len--;
+				}
+				ip = host_create_from_chunk(family, addr, 0);
+			}
+			if (ip)
+			{
+				this->vips->insert_last(this->vips, ip);
+			}
+			break;
+		}
+		default:
+		{
+			if (this->initiator)
+			{
+				handle_attribute(this, ca);
+			}
+		}
+	}
+}
+
+/**
+ * Scan for configuration payloads and attributes
+ */
+static void process_payloads(private_mode_config_t *this, message_t *message)
+{
+	enumerator_t *enumerator, *attributes;
+	payload_t *payload;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == CONFIGURATION_V1)
+		{
+			cp_payload_t *cp = (cp_payload_t*)payload;
+			configuration_attribute_t *ca;
+
+			switch (cp->get_type(cp))
+			{
+				case CFG_REQUEST:
+					this->identifier = cp->get_identifier(cp);
+					/* FALL */
+				case CFG_REPLY:
+					attributes = cp->create_attribute_enumerator(cp);
+					while (attributes->enumerate(attributes, &ca))
+					{
+						DBG2(DBG_IKE, "processing %N attribute",
+							 configuration_attribute_type_names, ca->get_type(ca));
+						process_attribute(this, ca);
+					}
+					attributes->destroy(attributes);
+					break;
+				default:
+					DBG1(DBG_IKE, "ignoring %N config payload",
+						 config_type_names, cp->get_type(cp));
+					break;
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+}
+
+METHOD(task_t, build_i, status_t,
+	private_mode_config_t *this, message_t *message)
+{
+	cp_payload_t *cp;
+	enumerator_t *enumerator;
+	attribute_handler_t *handler;
+	peer_cfg_t *config;
+	configuration_attribute_type_t type;
+	chunk_t data;
+	linked_list_t *vips;
+	host_t *host;
+
+	cp = cp_payload_create_type(CONFIGURATION_V1, CFG_REQUEST);
+
+	vips = linked_list_create();
+
+	/* reuse virtual IP if we already have one */
+	enumerator = this->ike_sa->create_virtual_ip_enumerator(this->ike_sa, TRUE);
+	while (enumerator->enumerate(enumerator, &host))
+	{
+		vips->insert_last(vips, host);
+	}
+	enumerator->destroy(enumerator);
+
+	if (vips->get_count(vips) == 0)
+	{
+		config = this->ike_sa->get_peer_cfg(this->ike_sa);
+		enumerator = config->create_virtual_ip_enumerator(config);
+		while (enumerator->enumerate(enumerator, &host))
+		{
+			vips->insert_last(vips, host);
+		}
+		enumerator->destroy(enumerator);
+	}
+
+	if (vips->get_count(vips))
+	{
+		enumerator = vips->create_enumerator(vips);
+		while (enumerator->enumerate(enumerator, &host))
+		{
+			cp->add_attribute(cp, build_vip(host));
+		}
+		enumerator->destroy(enumerator);
+	}
+
+	enumerator = hydra->attributes->create_initiator_enumerator(
+								hydra->attributes,
+								this->ike_sa->get_other_id(this->ike_sa), vips);
+	while (enumerator->enumerate(enumerator, &handler, &type, &data))
+	{
+		entry_t *entry;
+
+		DBG2(DBG_IKE, "building %N attribute",
+			 configuration_attribute_type_names, type);
+		cp->add_attribute(cp,
+				configuration_attribute_create_chunk(CONFIGURATION_ATTRIBUTE_V1,
+													 type, data));
+		INIT(entry,
+			.type = type,
+			.handler = handler,
+		);
+		this->requested->insert_last(this->requested, entry);
+	}
+	enumerator->destroy(enumerator);
+
+	vips->destroy(vips);
+
+	message->add_payload(message, (payload_t*)cp);
+
+	return NEED_MORE;
+}
+
+METHOD(task_t, process_r, status_t,
+	private_mode_config_t *this, message_t *message)
+{
+	process_payloads(this, message);
+	return NEED_MORE;
+}
+
+METHOD(task_t, build_r, status_t,
+	private_mode_config_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	configuration_attribute_type_t type;
+	chunk_t value;
+	cp_payload_t *cp;
+	peer_cfg_t *config;
+	identification_t *id;
+	linked_list_t *vips, *pools;
+	host_t *requested;
+
+	cp = cp_payload_create_type(CONFIGURATION_V1, CFG_REPLY);
+
+	id = this->ike_sa->get_other_eap_id(this->ike_sa);
+	config = this->ike_sa->get_peer_cfg(this->ike_sa);
+	vips = linked_list_create();
+	pools = linked_list_create_from_enumerator(
+									config->create_pool_enumerator(config));
+
+	this->ike_sa->clear_virtual_ips(this->ike_sa, FALSE);
+
+	enumerator = this->vips->create_enumerator(this->vips);
+	while (enumerator->enumerate(enumerator, &requested))
+	{
+		host_t *found = NULL;
+
+		/* query all pools until we get an address */
+		DBG1(DBG_IKE, "peer requested virtual IP %H", requested);
+
+		found = hydra->attributes->acquire_address(hydra->attributes,
+												   pools, id, requested);
+		if (found)
+		{
+			DBG1(DBG_IKE, "assigning virtual IP %H to peer '%Y'", found, id);
+			this->ike_sa->add_virtual_ip(this->ike_sa, FALSE, found);
+			cp->add_attribute(cp, build_vip(found));
+			vips->insert_last(vips, found);
+		}
+		else
+		{
+			DBG1(DBG_IKE, "no virtual IP found for %H requested by '%Y'",
+				 requested, id);
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	/* query registered providers for additional attributes to include */
+	enumerator = hydra->attributes->create_responder_enumerator(
+											hydra->attributes, pools, id, vips);
+	while (enumerator->enumerate(enumerator, &type, &value))
+	{
+		DBG2(DBG_IKE, "building %N attribute",
+			 configuration_attribute_type_names, type);
+		cp->add_attribute(cp,
+			configuration_attribute_create_chunk(CONFIGURATION_ATTRIBUTE_V1,
+												 type, value));
+	}
+	enumerator->destroy(enumerator);
+	vips->destroy_offset(vips, offsetof(host_t, destroy));
+	pools->destroy(pools);
+
+	cp->set_identifier(cp, this->identifier);
+	message->add_payload(message, (payload_t*)cp);
+
+	return SUCCESS;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_mode_config_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	host_t *host;
+
+	process_payloads(this, message);
+
+	this->ike_sa->clear_virtual_ips(this->ike_sa, TRUE);
+
+	enumerator = this->vips->create_enumerator(this->vips);
+	while (enumerator->enumerate(enumerator, &host))
+	{
+		if (!host->is_anyaddr(host))
+		{
+			this->ike_sa->add_virtual_ip(this->ike_sa, TRUE, host);
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return SUCCESS;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_mode_config_t *this)
+{
+	return TASK_MODE_CONFIG;
+}
+
+METHOD(task_t, migrate, void,
+	private_mode_config_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+	this->vips->destroy_offset(this->vips, offsetof(host_t, destroy));
+	this->vips = linked_list_create();
+	this->requested->destroy_function(this->requested, free);
+	this->requested = linked_list_create();
+}
+
+METHOD(task_t, destroy, void,
+	private_mode_config_t *this)
+{
+	this->vips->destroy_offset(this->vips, offsetof(host_t, destroy));
+	this->requested->destroy_function(this->requested, free);
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+mode_config_t *mode_config_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_mode_config_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.initiator = initiator,
+		.ike_sa = ike_sa,
+		.requested = linked_list_create(),
+		.vips = linked_list_create(),
+	);
+
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/mode_config.h b/src/libcharon/sa/ikev1/tasks/mode_config.h
new file mode 100644
index 000000000..462bee374
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/mode_config.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup mode_config mode_config
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef MODE_CONFIG_H_
+#define MODE_CONFIG_H_
+
+typedef struct mode_config_t mode_config_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * Task of type TASK_MODE_COFNIG, IKEv1 configuration attribute exchange.
+ */
+struct mode_config_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new mode_config task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE for initiator
+ * @return				mode_config task to handle by the task_manager
+ */
+mode_config_t *mode_config_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** MODE_CONFIG_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/quick_delete.c b/src/libcharon/sa/ikev1/tasks/quick_delete.c
new file mode 100644
index 000000000..db48bc58e
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/quick_delete.c
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "quick_delete.h"
+
+#include <daemon.h>
+#include <encoding/payloads/delete_payload.h>
+
+typedef struct private_quick_delete_t private_quick_delete_t;
+
+/**
+ * Private members of a quick_delete_t task.
+ */
+struct private_quick_delete_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	quick_delete_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * Protocol of CHILD_SA to delete
+	 */
+	protocol_id_t protocol;
+
+	/**
+	 * Inbound SPI of CHILD_SA to delete
+	 */
+	u_int32_t spi;
+
+	/**
+	 * Send delete even if SA does not exist
+	 */
+	bool force;
+
+	/**
+	 * SA already expired?
+	 */
+	bool expired;
+};
+
+/**
+ * Delete the specified CHILD_SA, if found
+ */
+static bool delete_child(private_quick_delete_t *this,
+						 protocol_id_t protocol, u_int32_t spi)
+{
+	u_int64_t bytes_in, bytes_out;
+	child_sa_t *child_sa;
+	bool rekeyed;
+
+	child_sa = this->ike_sa->get_child_sa(this->ike_sa, protocol, spi, TRUE);
+	if (!child_sa)
+	{	/* fallback and check for outbound SA */
+		child_sa = this->ike_sa->get_child_sa(this->ike_sa, protocol, spi, FALSE);
+		if (!child_sa)
+		{
+			return FALSE;
+		}
+		this->spi = spi = child_sa->get_spi(child_sa, TRUE);
+	}
+
+	rekeyed = child_sa->get_state(child_sa) == CHILD_REKEYING;
+	child_sa->set_state(child_sa, CHILD_DELETING);
+
+	if (this->expired)
+	{
+		DBG0(DBG_IKE, "closing expired CHILD_SA %s{%d} "
+			 "with SPIs %.8x_i %.8x_o and TS %#R=== %#R",
+			 child_sa->get_name(child_sa), child_sa->get_reqid(child_sa),
+			 ntohl(child_sa->get_spi(child_sa, TRUE)),
+			 ntohl(child_sa->get_spi(child_sa, FALSE)),
+			 child_sa->get_traffic_selectors(child_sa, TRUE),
+			 child_sa->get_traffic_selectors(child_sa, FALSE));
+	}
+	else
+	{
+		child_sa->get_usestats(child_sa, TRUE, NULL, &bytes_in);
+		child_sa->get_usestats(child_sa, FALSE, NULL, &bytes_out);
+
+		DBG0(DBG_IKE, "closing CHILD_SA %s{%d} with SPIs "
+			 "%.8x_i (%llu bytes) %.8x_o (%llu bytes) and TS %#R=== %#R",
+			 child_sa->get_name(child_sa), child_sa->get_reqid(child_sa),
+			 ntohl(child_sa->get_spi(child_sa, TRUE)), bytes_in,
+			 ntohl(child_sa->get_spi(child_sa, FALSE)), bytes_out,
+			 child_sa->get_traffic_selectors(child_sa, TRUE),
+			 child_sa->get_traffic_selectors(child_sa, FALSE));
+	}
+
+	if (!rekeyed)
+	{
+		charon->bus->child_updown(charon->bus, child_sa, FALSE);
+	}
+
+	this->ike_sa->destroy_child_sa(this->ike_sa, protocol, spi);
+
+	/* TODO-IKEv1: handle close action? */
+
+	return TRUE;
+}
+
+METHOD(task_t, build_i, status_t,
+	private_quick_delete_t *this, message_t *message)
+{
+	if (delete_child(this, this->protocol, this->spi) || this->force)
+	{
+		delete_payload_t *delete_payload;
+
+		DBG1(DBG_IKE, "sending DELETE for %N CHILD_SA with SPI %.8x",
+			 protocol_id_names, this->protocol, ntohl(this->spi));
+
+		delete_payload = delete_payload_create(DELETE_V1, PROTO_ESP);
+		delete_payload->add_spi(delete_payload, this->spi);
+		message->add_payload(message, &delete_payload->payload_interface);
+
+		return SUCCESS;
+	}
+	this->ike_sa->flush_queue(this->ike_sa, TASK_QUEUE_ACTIVE);
+	return ALREADY_DONE;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_quick_delete_t *this, message_t *message)
+{
+	return FAILED;
+}
+
+METHOD(task_t, process_r, status_t,
+	private_quick_delete_t *this, message_t *message)
+{
+	enumerator_t *payloads, *spis;
+	payload_t *payload;
+	delete_payload_t *delete_payload;
+	protocol_id_t protocol;
+	u_int32_t spi;
+
+	payloads = message->create_payload_enumerator(message);
+	while (payloads->enumerate(payloads, &payload))
+	{
+		if (payload->get_type(payload) == DELETE_V1)
+		{
+			delete_payload = (delete_payload_t*)payload;
+			protocol = delete_payload->get_protocol_id(delete_payload);
+			if (protocol != PROTO_ESP && protocol != PROTO_AH)
+			{
+				continue;
+			}
+			spis = delete_payload->create_spi_enumerator(delete_payload);
+			while (spis->enumerate(spis, &spi))
+			{
+				DBG1(DBG_IKE, "received DELETE for %N CHILD_SA with SPI %.8x",
+					 protocol_id_names, protocol, ntohl(spi));
+				if (!delete_child(this, protocol, spi))
+				{
+					DBG1(DBG_IKE, "CHILD_SA not found, ignored");
+					continue;
+				}
+			}
+			spis->destroy(spis);
+		}
+	}
+	payloads->destroy(payloads);
+
+	return SUCCESS;
+}
+
+METHOD(task_t, build_r, status_t,
+	private_quick_delete_t *this, message_t *message)
+{
+	return FAILED;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_quick_delete_t *this)
+{
+	return TASK_QUICK_DELETE;
+}
+
+METHOD(task_t, migrate, void,
+	private_quick_delete_t *this, ike_sa_t *ike_sa)
+{
+	this->ike_sa = ike_sa;
+}
+
+METHOD(task_t, destroy, void,
+	private_quick_delete_t *this)
+{
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+quick_delete_t *quick_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
+									u_int32_t spi, bool force, bool expired)
+{
+	private_quick_delete_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.ike_sa = ike_sa,
+		.protocol = protocol,
+		.spi = spi,
+		.force = force,
+		.expired = expired,
+	);
+
+	if (protocol != PROTO_NONE)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/quick_delete.h b/src/libcharon/sa/ikev1/tasks/quick_delete.h
new file mode 100644
index 000000000..4df30c8fe
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/quick_delete.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup quick_delete quick_delete
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef QUICK_DELETE_H_
+#define QUICK_DELETE_H_
+
+typedef struct quick_delete_t quick_delete_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+#include <sa/child_sa.h>
+
+/**
+ * Task of type QUICK_DELETE, delete an IKEv1 quick mode SA.
+ */
+struct quick_delete_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new quick_delete task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param protocol		protocol of CHILD_SA to delete, PROTO_NONE as responder
+ * @param spi			inbound SPI of CHILD_SA to delete
+ * @param force			send delete even if SA does not exist
+ * @param expired		TRUE if SA already expired
+ * @return				quick_delete task to handle by the task_manager
+ */
+quick_delete_t *quick_delete_create(ike_sa_t *ike_sa, protocol_id_t protocol,
+									u_int32_t spi, bool force, bool expired);
+
+#endif /** QUICK_DELETE_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/quick_mode.c b/src/libcharon/sa/ikev1/tasks/quick_mode.c
new file mode 100644
index 000000000..82a7238c3
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/quick_mode.c
@@ -0,0 +1,1273 @@
+/*
+ * Copyright (C) 2012 Tobias Brunner
+ * Hochschule fuer Technik Rapperswil
+ *
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "quick_mode.h"
+
+#include <string.h>
+
+#include <daemon.h>
+#include <sa/ikev1/keymat_v1.h>
+#include <encoding/payloads/sa_payload.h>
+#include <encoding/payloads/nonce_payload.h>
+#include <encoding/payloads/ke_payload.h>
+#include <encoding/payloads/id_payload.h>
+#include <encoding/payloads/payload.h>
+#include <sa/ikev1/tasks/informational.h>
+#include <sa/ikev1/tasks/quick_delete.h>
+#include <processing/jobs/inactivity_job.h>
+
+typedef struct private_quick_mode_t private_quick_mode_t;
+
+/**
+ * Private members of a quick_mode_t task.
+ */
+struct private_quick_mode_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	quick_mode_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * TRUE if we are initiating quick mode
+	 */
+	bool initiator;
+
+	/**
+	 * Traffic selector of initiator
+	 */
+	traffic_selector_t *tsi;
+
+	/**
+	 * Traffic selector of responder
+	 */
+	traffic_selector_t *tsr;
+
+	/**
+	 * Initiators nonce
+	 */
+	chunk_t nonce_i;
+
+	/**
+	 * Responder nonce
+	 */
+	chunk_t nonce_r;
+
+	/**
+	 * Initiators ESP SPI
+	 */
+	u_int32_t spi_i;
+
+	/**
+	 * Responder ESP SPI
+	 */
+	u_int32_t spi_r;
+
+	/**
+	 * Initiators IPComp CPI
+	 */
+	u_int16_t cpi_i;
+
+	/**
+	 * Responders IPComp CPI
+	 */
+	u_int16_t cpi_r;
+
+	/**
+	 * selected CHILD_SA proposal
+	 */
+	proposal_t *proposal;
+
+	/**
+	 * Config of CHILD_SA to establish
+	 */
+	child_cfg_t *config;
+
+	/**
+	 * CHILD_SA we are about to establish
+	 */
+	child_sa_t *child_sa;
+
+	/**
+	 * IKEv1 keymat
+	 */
+	keymat_v1_t *keymat;
+
+	/**
+	 * DH exchange, when PFS is in use
+	 */
+	diffie_hellman_t *dh;
+
+	/**
+	 * Negotiated lifetime of new SA
+	 */
+	u_int32_t lifetime;
+
+	/**
+	 * Negotaited lifebytes of new SA
+	 */
+	u_int64_t lifebytes;
+
+	/**
+	 * Reqid to use, 0 for auto-allocate
+	 */
+	u_int32_t reqid;
+
+	/**
+	 * SPI of SA we rekey
+	 */
+	u_int32_t rekey;
+
+	/**
+	 * Negotiated mode, tunnel or transport
+	 */
+	ipsec_mode_t mode;
+
+	/**
+	 * Use UDP encapsulation
+	 */
+	bool udp;
+
+	/** states of quick mode */
+	enum {
+		QM_INIT,
+		QM_NEGOTIATED,
+	} state;
+};
+
+/**
+ * Schedule inactivity timeout for CHILD_SA with reqid, if enabled
+ */
+static void schedule_inactivity_timeout(private_quick_mode_t *this)
+{
+	u_int32_t timeout;
+	bool close_ike;
+
+	timeout = this->config->get_inactivity(this->config);
+	if (timeout)
+	{
+		close_ike = lib->settings->get_bool(lib->settings,
+								"%s.inactivity_close_ike", FALSE, charon->name);
+		lib->scheduler->schedule_job(lib->scheduler, (job_t*)
+				inactivity_job_create(this->child_sa->get_reqid(this->child_sa),
+									  timeout, close_ike), timeout);
+	}
+}
+
+/**
+ * Check if we have a an address pool configured
+ */
+static bool have_pool(ike_sa_t *ike_sa)
+{
+	enumerator_t *enumerator;
+	peer_cfg_t *peer_cfg;
+	char *pool;
+	bool found = FALSE;
+
+	peer_cfg = ike_sa->get_peer_cfg(ike_sa);
+	if (peer_cfg)
+	{
+		enumerator = peer_cfg->create_pool_enumerator(peer_cfg);
+		if (enumerator->enumerate(enumerator, &pool))
+		{
+			found = TRUE;
+		}
+		enumerator->destroy(enumerator);
+	}
+	return found;
+}
+
+/**
+ * Get hosts to use for dynamic traffic selectors
+ */
+static linked_list_t *get_dynamic_hosts(ike_sa_t *ike_sa, bool local)
+{
+	enumerator_t *enumerator;
+	linked_list_t *list;
+	host_t *host;
+
+	list = linked_list_create();
+	enumerator = ike_sa->create_virtual_ip_enumerator(ike_sa, local);
+	while (enumerator->enumerate(enumerator, &host))
+	{
+		list->insert_last(list, host);
+	}
+	enumerator->destroy(enumerator);
+
+	if (list->get_count(list) == 0)
+	{	/* no virtual IPs assigned */
+		if (local)
+		{
+			host = ike_sa->get_my_host(ike_sa);
+			list->insert_last(list, host);
+		}
+		else if (!have_pool(ike_sa))
+		{	/* use host only if we don't have a pool configured */
+			host = ike_sa->get_other_host(ike_sa);
+			list->insert_last(list, host);
+		}
+	}
+	return list;
+}
+
+/**
+ * Install negotiated CHILD_SA
+ */
+static bool install(private_quick_mode_t *this)
+{
+	status_t status, status_i, status_o;
+	chunk_t encr_i, encr_r, integ_i, integ_r;
+	linked_list_t *tsi, *tsr;
+	child_sa_t *old = NULL;
+
+	this->child_sa->set_proposal(this->child_sa, this->proposal);
+	this->child_sa->set_state(this->child_sa, CHILD_INSTALLING);
+	this->child_sa->set_mode(this->child_sa, this->mode);
+
+	if (this->cpi_i && this->cpi_r)
+	{	/* DEFLATE is the only transform we currently support */
+		this->child_sa->set_ipcomp(this->child_sa, IPCOMP_DEFLATE);
+	}
+	else
+	{
+		this->cpi_i = this->cpi_r = 0;
+	}
+
+	this->child_sa->set_protocol(this->child_sa,
+								 this->proposal->get_protocol(this->proposal));
+
+	status_i = status_o = FAILED;
+	encr_i = encr_r = integ_i = integ_r = chunk_empty;
+	tsi = linked_list_create_with_items(this->tsi->clone(this->tsi), NULL);
+	tsr = linked_list_create_with_items(this->tsr->clone(this->tsr), NULL);
+	if (this->initiator)
+	{
+		charon->bus->narrow(charon->bus, this->child_sa,
+							NARROW_INITIATOR_POST_AUTH, tsi, tsr);
+	}
+	else
+	{
+		charon->bus->narrow(charon->bus, this->child_sa,
+							NARROW_RESPONDER_POST, tsr, tsi);
+	}
+	if (tsi->get_count(tsi) == 0 || tsr->get_count(tsr) == 0)
+	{
+		tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+		tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+		DBG1(DBG_IKE, "no acceptable traffic selectors found");
+		return FALSE;
+	}
+
+	if (this->keymat->derive_child_keys(this->keymat, this->proposal, this->dh,
+						this->spi_i, this->spi_r, this->nonce_i, this->nonce_r,
+						&encr_i, &integ_i, &encr_r, &integ_r))
+	{
+		if (this->initiator)
+		{
+			status_i = this->child_sa->install(this->child_sa, encr_r, integ_r,
+							this->spi_i, this->cpi_i, TRUE, FALSE, tsi, tsr);
+			status_o = this->child_sa->install(this->child_sa, encr_i, integ_i,
+							this->spi_r, this->cpi_r, FALSE, FALSE, tsi, tsr);
+		}
+		else
+		{
+			status_i = this->child_sa->install(this->child_sa, encr_i, integ_i,
+							this->spi_r, this->cpi_r, TRUE, FALSE, tsr, tsi);
+			status_o = this->child_sa->install(this->child_sa, encr_r, integ_r,
+							this->spi_i, this->cpi_i, FALSE, FALSE, tsr, tsi);
+		}
+	}
+	chunk_clear(&integ_i);
+	chunk_clear(&integ_r);
+	chunk_clear(&encr_i);
+	chunk_clear(&encr_r);
+
+	if (status_i != SUCCESS || status_o != SUCCESS)
+	{
+		DBG1(DBG_IKE, "unable to install %s%s%sIPsec SA (SAD) in kernel",
+			(status_i != SUCCESS) ? "inbound " : "",
+			(status_i != SUCCESS && status_o != SUCCESS) ? "and ": "",
+			(status_o != SUCCESS) ? "outbound " : "");
+		tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+		tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+		return FALSE;
+	}
+
+	if (this->initiator)
+	{
+		status = this->child_sa->add_policies(this->child_sa, tsi, tsr);
+	}
+	else
+	{
+		status = this->child_sa->add_policies(this->child_sa, tsr, tsi);
+	}
+	tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+	tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+	if (status != SUCCESS)
+	{
+		DBG1(DBG_IKE, "unable to install IPsec policies (SPD) in kernel");
+		return FALSE;
+	}
+
+	charon->bus->child_keys(charon->bus, this->child_sa, this->initiator,
+							this->dh, this->nonce_i, this->nonce_r);
+
+	/* add to IKE_SA, and remove from task */
+	this->child_sa->set_state(this->child_sa, CHILD_INSTALLED);
+	this->ike_sa->add_child_sa(this->ike_sa, this->child_sa);
+
+	DBG0(DBG_IKE, "CHILD_SA %s{%d} established "
+		 "with SPIs %.8x_i %.8x_o and TS %#R=== %#R",
+		 this->child_sa->get_name(this->child_sa),
+		 this->child_sa->get_reqid(this->child_sa),
+		 ntohl(this->child_sa->get_spi(this->child_sa, TRUE)),
+		 ntohl(this->child_sa->get_spi(this->child_sa, FALSE)),
+		 this->child_sa->get_traffic_selectors(this->child_sa, TRUE),
+		 this->child_sa->get_traffic_selectors(this->child_sa, FALSE));
+
+	if (this->rekey)
+	{
+		old = this->ike_sa->get_child_sa(this->ike_sa,
+								this->proposal->get_protocol(this->proposal),
+								this->rekey, TRUE);
+	}
+	if (old)
+	{
+		charon->bus->child_rekey(charon->bus, old, this->child_sa);
+	}
+	else
+	{
+		charon->bus->child_updown(charon->bus, this->child_sa, TRUE);
+	}
+	if (!this->rekey)
+	{
+		schedule_inactivity_timeout(this);
+	}
+	this->child_sa = NULL;
+	return TRUE;
+}
+
+/**
+ * Generate and add NONCE
+ */
+static bool add_nonce(private_quick_mode_t *this, chunk_t *nonce,
+					  message_t *message)
+{
+	nonce_payload_t *nonce_payload;
+	nonce_gen_t *nonceg;
+
+	nonceg = this->keymat->keymat.create_nonce_gen(&this->keymat->keymat);
+	if (!nonceg)
+	{
+		DBG1(DBG_IKE, "no nonce generator found to create nonce");
+		return FALSE;
+	}
+	if (!nonceg->allocate_nonce(nonceg, NONCE_SIZE, nonce))
+	{
+		DBG1(DBG_IKE, "nonce allocation failed");
+		nonceg->destroy(nonceg);
+		return FALSE;
+	}
+	nonceg->destroy(nonceg);
+
+	nonce_payload = nonce_payload_create(NONCE_V1);
+	nonce_payload->set_nonce(nonce_payload, *nonce);
+	message->add_payload(message, &nonce_payload->payload_interface);
+
+	return TRUE;
+}
+
+/**
+ * Extract nonce from NONCE payload
+ */
+static bool get_nonce(private_quick_mode_t *this, chunk_t *nonce,
+					  message_t *message)
+{
+	nonce_payload_t *nonce_payload;
+
+	nonce_payload = (nonce_payload_t*)message->get_payload(message, NONCE_V1);
+	if (!nonce_payload)
+	{
+		DBG1(DBG_IKE, "NONCE payload missing in message");
+		return FALSE;
+	}
+	*nonce = nonce_payload->get_nonce(nonce_payload);
+
+	return TRUE;
+}
+
+/**
+ * Add KE payload to message
+ */
+static void add_ke(private_quick_mode_t *this, message_t *message)
+{
+	ke_payload_t *ke_payload;
+
+	ke_payload = ke_payload_create_from_diffie_hellman(KEY_EXCHANGE_V1, this->dh);
+	message->add_payload(message, &ke_payload->payload_interface);
+}
+
+/**
+ * Get DH value from a KE payload
+ */
+static bool get_ke(private_quick_mode_t *this, message_t *message)
+{
+	ke_payload_t *ke_payload;
+
+	ke_payload = (ke_payload_t*)message->get_payload(message, KEY_EXCHANGE_V1);
+	if (!ke_payload)
+	{
+		DBG1(DBG_IKE, "KE payload missing");
+		return FALSE;
+	}
+	this->dh->set_other_public_value(this->dh,
+								ke_payload->get_key_exchange_data(ke_payload));
+	return TRUE;
+}
+
+/**
+ * Select a traffic selector from configuration
+ */
+static traffic_selector_t* select_ts(private_quick_mode_t *this, bool local,
+									 linked_list_t *supplied)
+{
+	traffic_selector_t *ts;
+	linked_list_t *list, *hosts;
+
+	hosts = get_dynamic_hosts(this->ike_sa, local);
+	list = this->config->get_traffic_selectors(this->config,
+											   local, supplied, hosts);
+	hosts->destroy(hosts);
+	if (list->get_first(list, (void**)&ts) == SUCCESS)
+	{
+		ts = ts->clone(ts);
+	}
+	else
+	{
+		DBG1(DBG_IKE, "%s traffic selector missing in configuration",
+			 local ? "local" : "local");
+		ts = NULL;
+	}
+	list->destroy_offset(list, offsetof(traffic_selector_t, destroy));
+	return ts;
+}
+
+/**
+ * Add selected traffic selectors to message
+ */
+static void add_ts(private_quick_mode_t *this, message_t *message)
+{
+	id_payload_t *id_payload;
+	host_t *hsi, *hsr;
+
+	if (this->initiator)
+	{
+		hsi = this->ike_sa->get_my_host(this->ike_sa);
+		hsr = this->ike_sa->get_other_host(this->ike_sa);
+	}
+	else
+	{
+		hsr = this->ike_sa->get_my_host(this->ike_sa);
+		hsi = this->ike_sa->get_other_host(this->ike_sa);
+	}
+	/* add ID payload only if negotiating non host2host tunnels */
+	if (!this->tsi->is_host(this->tsi, hsi) ||
+		!this->tsr->is_host(this->tsr, hsr) ||
+		this->tsi->get_protocol(this->tsi) ||
+		this->tsr->get_protocol(this->tsr) ||
+		this->tsi->get_from_port(this->tsi) ||
+		this->tsr->get_from_port(this->tsr) ||
+		this->tsi->get_to_port(this->tsi) != 65535 ||
+		this->tsr->get_to_port(this->tsr) != 65535)
+	{
+		id_payload = id_payload_create_from_ts(this->tsi);
+		message->add_payload(message, &id_payload->payload_interface);
+		id_payload = id_payload_create_from_ts(this->tsr);
+		message->add_payload(message, &id_payload->payload_interface);
+	}
+}
+
+/**
+ * Get traffic selectors from received message
+ */
+static bool get_ts(private_quick_mode_t *this, message_t *message)
+{
+	traffic_selector_t *tsi = NULL, *tsr = NULL;
+	enumerator_t *enumerator;
+	id_payload_t *id_payload;
+	payload_t *payload;
+	host_t *hsi, *hsr;
+	bool first = TRUE;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == ID_V1)
+		{
+			id_payload = (id_payload_t*)payload;
+
+			if (first)
+			{
+				tsi = id_payload->get_ts(id_payload);
+				first = FALSE;
+			}
+			else
+			{
+				tsr = id_payload->get_ts(id_payload);
+				break;
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	/* create host2host selectors if ID payloads missing */
+	if (this->initiator)
+	{
+		hsi = this->ike_sa->get_my_host(this->ike_sa);
+		hsr = this->ike_sa->get_other_host(this->ike_sa);
+	}
+	else
+	{
+		hsr = this->ike_sa->get_my_host(this->ike_sa);
+		hsi = this->ike_sa->get_other_host(this->ike_sa);
+	}
+	if (!tsi)
+	{
+		tsi = traffic_selector_create_from_subnet(hsi->clone(hsi),
+							hsi->get_family(hsi) == AF_INET ? 32 : 128, 0, 0);
+	}
+	if (!tsr)
+	{
+		tsr = traffic_selector_create_from_subnet(hsr->clone(hsr),
+							hsr->get_family(hsr) == AF_INET ? 32 : 128, 0, 0);
+	}
+	if (!this->initiator && this->mode == MODE_TRANSPORT && this->udp &&
+	   (!tsi->is_host(tsi, hsi) || !tsr->is_host(tsr, hsr)))
+	{	/* change TS in case of a NAT in transport mode */
+		DBG2(DBG_IKE, "changing received traffic selectors %R=== %R due to NAT",
+			 tsi, tsr);
+		tsi->set_address(tsi, hsi);
+		tsr->set_address(tsr, hsr);
+	}
+
+	if (this->initiator)
+	{
+		/* check if peer selection valid */
+		if (!tsr->is_contained_in(tsr, this->tsr) ||
+			!tsi->is_contained_in(tsi, this->tsi))
+		{
+			DBG1(DBG_IKE, "peer selected invalid traffic selectors: ",
+				 "%R for %R, %R for %R", tsi, this->tsi, tsr, this->tsr);
+			tsi->destroy(tsi);
+			tsr->destroy(tsr);
+			return FALSE;
+		}
+		this->tsi->destroy(this->tsi);
+		this->tsr->destroy(this->tsr);
+		this->tsi = tsi;
+		this->tsr = tsr;
+	}
+	else
+	{
+		this->tsi = tsi;
+		this->tsr = tsr;
+	}
+	return TRUE;
+}
+
+/**
+ * Add NAT-OA payloads
+ */
+static void add_nat_oa_payloads(private_quick_mode_t *this, message_t *message)
+{
+	identification_t *id;
+	id_payload_t *nat_oa;
+	host_t *src, *dst;
+
+	src = message->get_source(message);
+	dst = message->get_destination(message);
+
+	src = this->initiator ? src : dst;
+	dst = this->initiator ? dst : src;
+
+	/* first NAT-OA is the initiator's address */
+	id = identification_create_from_sockaddr(src->get_sockaddr(src));
+	nat_oa = id_payload_create_from_identification(NAT_OA_V1, id);
+	message->add_payload(message, (payload_t*)nat_oa);
+	id->destroy(id);
+
+	/* second NAT-OA is that of the responder */
+	id = identification_create_from_sockaddr(dst->get_sockaddr(dst));
+	nat_oa = id_payload_create_from_identification(NAT_OA_V1, id);
+	message->add_payload(message, (payload_t*)nat_oa);
+	id->destroy(id);
+}
+
+/**
+ * Look up lifetimes
+ */
+static void get_lifetimes(private_quick_mode_t *this)
+{
+	lifetime_cfg_t *lft;
+
+	lft = this->config->get_lifetime(this->config);
+	if (lft->time.life)
+	{
+		this->lifetime = lft->time.life;
+	}
+	else if (lft->bytes.life)
+	{
+		this->lifebytes = lft->bytes.life;
+	}
+	free(lft);
+}
+
+/**
+ * Check and apply lifetimes
+ */
+static void apply_lifetimes(private_quick_mode_t *this, sa_payload_t *sa_payload)
+{
+	u_int32_t lifetime;
+	u_int64_t lifebytes;
+
+	lifetime = sa_payload->get_lifetime(sa_payload);
+	lifebytes = sa_payload->get_lifebytes(sa_payload);
+	if (this->lifetime != lifetime)
+	{
+		DBG1(DBG_IKE, "received %us lifetime, configured %us",
+			 lifetime, this->lifetime);
+		this->lifetime = lifetime;
+	}
+	if (this->lifebytes != lifebytes)
+	{
+		DBG1(DBG_IKE, "received %llu lifebytes, configured %llu",
+			 lifebytes, this->lifebytes);
+		this->lifebytes = lifebytes;
+	}
+}
+
+/**
+ * Set the task ready to build notify error message
+ */
+static status_t send_notify(private_quick_mode_t *this, notify_type_t type)
+{
+	notify_payload_t *notify;
+
+	notify = notify_payload_create_from_protocol_and_type(NOTIFY_V1,
+														  PROTO_ESP, type);
+	notify->set_spi(notify, this->spi_i);
+
+	this->ike_sa->queue_task(this->ike_sa,
+						(task_t*)informational_create(this->ike_sa, notify));
+	/* cancel all active/passive tasks in favour of informational */
+	this->ike_sa->flush_queue(this->ike_sa,
+					this->initiator ? TASK_QUEUE_ACTIVE : TASK_QUEUE_PASSIVE);
+	return ALREADY_DONE;
+}
+
+METHOD(task_t, build_i, status_t,
+	private_quick_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case QM_INIT:
+		{
+			enumerator_t *enumerator;
+			sa_payload_t *sa_payload;
+			linked_list_t *list, *tsi, *tsr;
+			proposal_t *proposal;
+			diffie_hellman_group_t group;
+
+			this->udp = this->ike_sa->has_condition(this->ike_sa, COND_NAT_ANY);
+			this->mode = this->config->get_mode(this->config);
+			this->child_sa = child_sa_create(
+									this->ike_sa->get_my_host(this->ike_sa),
+									this->ike_sa->get_other_host(this->ike_sa),
+									this->config, this->reqid, this->udp);
+
+			if (this->udp && this->mode == MODE_TRANSPORT)
+			{
+				/* TODO-IKEv1: disable NAT-T for TRANSPORT mode by default? */
+				add_nat_oa_payloads(this, message);
+			}
+
+			if (this->config->use_ipcomp(this->config))
+			{
+				if (this->udp)
+				{
+					DBG1(DBG_IKE, "IPComp is not supported if either peer is "
+						 "natted, IPComp disabled");
+				}
+				else
+				{
+					this->cpi_i = this->child_sa->alloc_cpi(this->child_sa);
+					if (!this->cpi_i)
+					{
+						DBG1(DBG_IKE, "unable to allocate a CPI from kernel, "
+							 "IPComp disabled");
+					}
+				}
+			}
+
+			this->spi_i = this->child_sa->alloc_spi(this->child_sa, PROTO_ESP);
+			if (!this->spi_i)
+			{
+				DBG1(DBG_IKE, "allocating SPI from kernel failed");
+				return FAILED;
+			}
+
+			list = this->config->get_proposals(this->config, FALSE);
+			enumerator = list->create_enumerator(list);
+			while (enumerator->enumerate(enumerator, &proposal))
+			{
+				proposal->set_spi(proposal, this->spi_i);
+			}
+			enumerator->destroy(enumerator);
+
+			get_lifetimes(this);
+			sa_payload = sa_payload_create_from_proposals_v1(list,
+								this->lifetime, this->lifebytes, AUTH_NONE,
+								this->mode, this->udp, this->cpi_i);
+			list->destroy_offset(list, offsetof(proposal_t, destroy));
+			message->add_payload(message, &sa_payload->payload_interface);
+
+			if (!add_nonce(this, &this->nonce_i, message))
+			{
+				return FAILED;
+			}
+
+			group = this->config->get_dh_group(this->config);
+			if (group != MODP_NONE)
+			{
+				this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
+														  group);
+				if (!this->dh)
+				{
+					DBG1(DBG_IKE, "configured DH group %N not supported",
+						 diffie_hellman_group_names, group);
+					return FAILED;
+				}
+				add_ke(this, message);
+			}
+			if (!this->tsi)
+			{
+				this->tsi = select_ts(this, TRUE, NULL);
+			}
+			if (!this->tsr)
+			{
+				this->tsr = select_ts(this, FALSE, NULL);
+			}
+			tsi = linked_list_create_with_items(this->tsi, NULL);
+			tsr = linked_list_create_with_items(this->tsr, NULL);
+			this->tsi = this->tsr = NULL;
+			charon->bus->narrow(charon->bus, this->child_sa,
+								NARROW_INITIATOR_PRE_AUTH, tsi, tsr);
+			tsi->remove_first(tsi, (void**)&this->tsi);
+			tsr->remove_first(tsr, (void**)&this->tsr);
+			tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+			tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+			if (!this->tsi || !this->tsr)
+			{
+				return FAILED;
+			}
+			add_ts(this, message);
+			return NEED_MORE;
+		}
+		case QM_NEGOTIATED:
+		{
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+/**
+ * Check for notify errors, return TRUE if error found
+ */
+static bool has_notify_errors(private_quick_mode_t *this, message_t *message)
+{
+	enumerator_t *enumerator;
+	payload_t *payload;
+	bool err = FALSE;
+
+	enumerator = message->create_payload_enumerator(message);
+	while (enumerator->enumerate(enumerator, &payload))
+	{
+		if (payload->get_type(payload) == NOTIFY_V1)
+		{
+			notify_payload_t *notify;
+			notify_type_t type;
+
+			notify = (notify_payload_t*)payload;
+			type = notify->get_notify_type(notify);
+			if (type < 16384)
+			{
+
+				DBG1(DBG_IKE, "received %N error notify",
+					 notify_type_names, type);
+				err = TRUE;
+			}
+			else
+			{
+				DBG1(DBG_IKE, "received %N notify", notify_type_names, type);
+			}
+		}
+	}
+	enumerator->destroy(enumerator);
+
+	return err;
+}
+
+/**
+ * Check if this is a rekey for an existing CHILD_SA, reuse reqid if so
+ */
+static void check_for_rekeyed_child(private_quick_mode_t *this)
+{
+	enumerator_t *enumerator, *policies;
+	traffic_selector_t *local, *remote;
+	child_sa_t *child_sa;
+
+	enumerator = this->ike_sa->create_child_sa_enumerator(this->ike_sa);
+	while (this->reqid == 0 && enumerator->enumerate(enumerator, &child_sa))
+	{
+		if (child_sa->get_state(child_sa) == CHILD_INSTALLED &&
+			streq(child_sa->get_name(child_sa),
+				  this->config->get_name(this->config)))
+		{
+			policies = child_sa->create_policy_enumerator(child_sa);
+			if (policies->enumerate(policies, &local, &remote))
+			{
+				if (local->equals(local, this->tsr) &&
+					remote->equals(remote, this->tsi) &&
+					this->proposal->equals(this->proposal,
+										   child_sa->get_proposal(child_sa)))
+				{
+					this->reqid = child_sa->get_reqid(child_sa);
+					this->rekey = child_sa->get_spi(child_sa, TRUE);
+					child_sa->set_state(child_sa, CHILD_REKEYING);
+					DBG1(DBG_IKE, "detected rekeying of CHILD_SA %s{%u}",
+						 child_sa->get_name(child_sa), this->reqid);
+				}
+			}
+			policies->destroy(policies);
+		}
+	}
+	enumerator->destroy(enumerator);
+}
+
+METHOD(task_t, process_r, status_t,
+	private_quick_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case QM_INIT:
+		{
+			sa_payload_t *sa_payload;
+			linked_list_t *tsi, *tsr, *hostsi, *hostsr, *list = NULL;
+			peer_cfg_t *peer_cfg;
+			u_int16_t group;
+			bool private;
+
+			sa_payload = (sa_payload_t*)message->get_payload(message,
+													SECURITY_ASSOCIATION_V1);
+			if (!sa_payload)
+			{
+				DBG1(DBG_IKE, "sa payload missing");
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+
+			this->mode = sa_payload->get_encap_mode(sa_payload, &this->udp);
+
+			if (!get_ts(this, message))
+			{
+				return FAILED;
+			}
+			peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+			tsi = linked_list_create_with_items(this->tsi, NULL);
+			tsr = linked_list_create_with_items(this->tsr, NULL);
+			this->tsi = this->tsr = NULL;
+			hostsi = get_dynamic_hosts(this->ike_sa, FALSE);
+			hostsr = get_dynamic_hosts(this->ike_sa, TRUE);
+			this->config = peer_cfg->select_child_cfg(peer_cfg, tsr, tsi,
+													  hostsr, hostsi);
+			hostsi->destroy(hostsi);
+			hostsr->destroy(hostsr);
+			if (this->config)
+			{
+				this->tsi = select_ts(this, FALSE, tsi);
+				this->tsr = select_ts(this, TRUE, tsr);
+			}
+			tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+			tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+			if (!this->config || !this->tsi || !this->tsr)
+			{
+				DBG1(DBG_IKE, "no matching CHILD_SA config found");
+				return send_notify(this, INVALID_ID_INFORMATION);
+			}
+
+			if (this->config->use_ipcomp(this->config))
+			{
+				if (this->ike_sa->has_condition(this->ike_sa, COND_NAT_ANY))
+				{
+					DBG1(DBG_IKE, "IPComp is not supported if either peer is "
+						 "natted, IPComp disabled");
+				}
+				else
+				{
+					list = sa_payload->get_ipcomp_proposals(sa_payload,
+															&this->cpi_i);
+					if (!list->get_count(list))
+					{
+						DBG1(DBG_IKE, "expected IPComp proposal but peer did "
+							 "not send one, IPComp disabled");
+						this->cpi_i = 0;
+					}
+				}
+			}
+			if (!list || !list->get_count(list))
+			{
+				DESTROY_IF(list);
+				list = sa_payload->get_proposals(sa_payload);
+			}
+			private = this->ike_sa->supports_extension(this->ike_sa,
+													   EXT_STRONGSWAN);
+			this->proposal = this->config->select_proposal(this->config,
+														   list, FALSE, private);
+			list->destroy_offset(list, offsetof(proposal_t, destroy));
+
+			get_lifetimes(this);
+			apply_lifetimes(this, sa_payload);
+
+			if (!this->proposal)
+			{
+				DBG1(DBG_IKE, "no matching proposal found, sending %N",
+					 notify_type_names, NO_PROPOSAL_CHOSEN);
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->spi_i = this->proposal->get_spi(this->proposal);
+
+			if (!get_nonce(this, &this->nonce_i, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+
+			if (this->proposal->get_algorithm(this->proposal,
+										DIFFIE_HELLMAN_GROUP, &group, NULL))
+			{
+				this->dh = this->keymat->keymat.create_dh(&this->keymat->keymat,
+														  group);
+				if (!this->dh)
+				{
+					DBG1(DBG_IKE, "negotiated DH group %N not supported",
+						 diffie_hellman_group_names, group);
+					return send_notify(this, INVALID_KEY_INFORMATION);
+				}
+				if (!get_ke(this, message))
+				{
+					return send_notify(this, INVALID_PAYLOAD_TYPE);
+				}
+			}
+
+			check_for_rekeyed_child(this);
+
+			this->child_sa = child_sa_create(
+									this->ike_sa->get_my_host(this->ike_sa),
+									this->ike_sa->get_other_host(this->ike_sa),
+									this->config, this->reqid, this->udp);
+
+			tsi = linked_list_create_with_items(this->tsi, NULL);
+			tsr = linked_list_create_with_items(this->tsr, NULL);
+			this->tsi = this->tsr = NULL;
+			charon->bus->narrow(charon->bus, this->child_sa,
+								NARROW_RESPONDER, tsr, tsi);
+			if (tsi->remove_first(tsi, (void**)&this->tsi) != SUCCESS ||
+				tsr->remove_first(tsr, (void**)&this->tsr) != SUCCESS)
+			{
+				tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+				tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+				return send_notify(this, INVALID_ID_INFORMATION);
+			}
+			tsi->destroy_offset(tsi, offsetof(traffic_selector_t, destroy));
+			tsr->destroy_offset(tsr, offsetof(traffic_selector_t, destroy));
+
+			return NEED_MORE;
+		}
+		case QM_NEGOTIATED:
+		{
+			if (message->get_exchange_type(message) == INFORMATIONAL_V1 ||
+				has_notify_errors(this, message))
+			{
+				return SUCCESS;
+			}
+			if (!install(this))
+			{
+				ike_sa_t *ike_sa = this->ike_sa;
+				task_t *task;
+
+				task = (task_t*)quick_delete_create(this->ike_sa,
+								this->proposal->get_protocol(this->proposal),
+								this->spi_i, TRUE, TRUE);
+				/* flush_queue() destroys the current task */
+				ike_sa->flush_queue(ike_sa, TASK_QUEUE_PASSIVE);
+				ike_sa->queue_task(ike_sa, task);
+				return ALREADY_DONE;
+			}
+			return SUCCESS;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, build_r, status_t,
+	private_quick_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case QM_INIT:
+		{
+			sa_payload_t *sa_payload;
+
+			this->spi_r = this->child_sa->alloc_spi(this->child_sa, PROTO_ESP);
+			if (!this->spi_r)
+			{
+				DBG1(DBG_IKE, "allocating SPI from kernel failed");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->proposal->set_spi(this->proposal, this->spi_r);
+
+			if (this->cpi_i)
+			{
+				this->cpi_r = this->child_sa->alloc_cpi(this->child_sa);
+				if (!this->cpi_r)
+				{
+					DBG1(DBG_IKE, "unable to allocate a CPI from "
+						 "kernel, IPComp disabled");
+					return send_notify(this, NO_PROPOSAL_CHOSEN);
+				}
+			}
+
+			if (this->udp && this->mode == MODE_TRANSPORT)
+			{
+				/* TODO-IKEv1: disable NAT-T for TRANSPORT mode by default? */
+				add_nat_oa_payloads(this, message);
+			}
+
+			sa_payload = sa_payload_create_from_proposal_v1(this->proposal,
+								this->lifetime, this->lifebytes, AUTH_NONE,
+								this->mode, this->udp, this->cpi_r);
+			message->add_payload(message, &sa_payload->payload_interface);
+
+			if (!add_nonce(this, &this->nonce_r, message))
+			{
+				return FAILED;
+			}
+			if (this->dh)
+			{
+				add_ke(this, message);
+			}
+
+			add_ts(this, message);
+
+			this->state = QM_NEGOTIATED;
+			return NEED_MORE;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, process_i, status_t,
+	private_quick_mode_t *this, message_t *message)
+{
+	switch (this->state)
+	{
+		case QM_INIT:
+		{
+			sa_payload_t *sa_payload;
+			linked_list_t *list = NULL;
+			bool private;
+
+			sa_payload = (sa_payload_t*)message->get_payload(message,
+													SECURITY_ASSOCIATION_V1);
+			if (!sa_payload)
+			{
+				DBG1(DBG_IKE, "sa payload missing");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			if (this->cpi_i)
+			{
+				list = sa_payload->get_ipcomp_proposals(sa_payload,
+														&this->cpi_r);
+				if (!list->get_count(list))
+				{
+					DBG1(DBG_IKE, "peer did not acccept our IPComp proposal, "
+						 "IPComp disabled");
+					this->cpi_i = 0;
+				}
+			}
+			if (!list || !list->get_count(list))
+			{
+				DESTROY_IF(list);
+				list = sa_payload->get_proposals(sa_payload);
+			}
+			private = this->ike_sa->supports_extension(this->ike_sa,
+													   EXT_STRONGSWAN);
+			this->proposal = this->config->select_proposal(this->config,
+														   list, FALSE, private);
+			list->destroy_offset(list, offsetof(proposal_t, destroy));
+			if (!this->proposal)
+			{
+				DBG1(DBG_IKE, "no matching proposal found");
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->spi_r = this->proposal->get_spi(this->proposal);
+
+			apply_lifetimes(this, sa_payload);
+
+			if (!get_nonce(this, &this->nonce_r, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			if (this->dh && !get_ke(this, message))
+			{
+				return send_notify(this, INVALID_KEY_INFORMATION);
+			}
+			if (!get_ts(this, message))
+			{
+				return send_notify(this, INVALID_PAYLOAD_TYPE);
+			}
+			if (!install(this))
+			{
+				return send_notify(this, NO_PROPOSAL_CHOSEN);
+			}
+			this->state = QM_NEGOTIATED;
+			return NEED_MORE;
+		}
+		default:
+			return FAILED;
+	}
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_quick_mode_t *this)
+{
+	return TASK_QUICK_MODE;
+}
+
+METHOD(quick_mode_t, use_reqid, void,
+	private_quick_mode_t *this, u_int32_t reqid)
+{
+	this->reqid = reqid;
+}
+
+METHOD(quick_mode_t, rekey, void,
+	private_quick_mode_t *this, u_int32_t spi)
+{
+	this->rekey = spi;
+}
+
+METHOD(task_t, migrate, void,
+	private_quick_mode_t *this, ike_sa_t *ike_sa)
+{
+	chunk_free(&this->nonce_i);
+	chunk_free(&this->nonce_r);
+	DESTROY_IF(this->tsi);
+	DESTROY_IF(this->tsr);
+	DESTROY_IF(this->proposal);
+	DESTROY_IF(this->child_sa);
+	DESTROY_IF(this->dh);
+
+	this->ike_sa = ike_sa;
+	this->keymat = (keymat_v1_t*)ike_sa->get_keymat(ike_sa);
+	this->state = QM_INIT;
+	this->tsi = NULL;
+	this->tsr = NULL;
+	this->proposal = NULL;
+	this->child_sa = NULL;
+	this->dh = NULL;
+	this->spi_i = 0;
+	this->spi_r = 0;
+
+	if (!this->initiator)
+	{
+		DESTROY_IF(this->config);
+		this->config = NULL;
+	}
+}
+
+METHOD(task_t, destroy, void,
+	private_quick_mode_t *this)
+{
+	chunk_free(&this->nonce_i);
+	chunk_free(&this->nonce_r);
+	DESTROY_IF(this->tsi);
+	DESTROY_IF(this->tsr);
+	DESTROY_IF(this->proposal);
+	DESTROY_IF(this->child_sa);
+	DESTROY_IF(this->config);
+	DESTROY_IF(this->dh);
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+quick_mode_t *quick_mode_create(ike_sa_t *ike_sa, child_cfg_t *config,
+							traffic_selector_t *tsi, traffic_selector_t *tsr)
+{
+	private_quick_mode_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+			.use_reqid = _use_reqid,
+			.rekey = _rekey,
+		},
+		.ike_sa = ike_sa,
+		.initiator = config != NULL,
+		.config = config,
+		.keymat = (keymat_v1_t*)ike_sa->get_keymat(ike_sa),
+		.state = QM_INIT,
+		.tsi = tsi ? tsi->clone(tsi) : NULL,
+		.tsr = tsr ? tsr->clone(tsr) : NULL,
+	);
+
+	if (config)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/quick_mode.h b/src/libcharon/sa/ikev1/tasks/quick_mode.h
new file mode 100644
index 000000000..0b80cb836
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/quick_mode.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup quick_mode quick_mode
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef QUICK_MODE_H_
+#define QUICK_MODE_H_
+
+typedef struct quick_mode_t quick_mode_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * IKEv1 quick mode, establishes a CHILD_SA in IKEv1.
+ */
+struct quick_mode_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+
+	/**
+	 * Use a specific reqid to install this CHILD_SA.
+	 *
+	 * @param reqid			reqid to use
+	 */
+	void (*use_reqid)(quick_mode_t *this, u_int32_t reqid);
+
+	/**
+	 * Set the SPI of the old SA, if rekeying.
+	 *
+	 * @param spi			spi of SA to rekey
+	 */
+	void (*rekey)(quick_mode_t *this, u_int32_t spi);
+};
+
+/**
+ * Create a new quick_mode task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param config		child_cfg if task initiator, NULL if responder
+ * @param tsi			source of triggering packet, or NULL
+ * @param tsr			destination of triggering packet, or NULL
+ * @return				task to handle by the task_manager
+ */
+quick_mode_t *quick_mode_create(ike_sa_t *ike_sa, child_cfg_t *config,
+							traffic_selector_t *tsi, traffic_selector_t *tsr);
+
+#endif /** QUICK_MODE_H_ @}*/
diff --git a/src/libcharon/sa/ikev1/tasks/xauth.c b/src/libcharon/sa/ikev1/tasks/xauth.c
new file mode 100644
index 000000000..10bea5636
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/xauth.c
@@ -0,0 +1,551 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+#include "xauth.h"
+
+#include <daemon.h>
+#include <hydra.h>
+#include <encoding/payloads/cp_payload.h>
+#include <processing/jobs/adopt_children_job.h>
+
+typedef struct private_xauth_t private_xauth_t;
+
+/**
+ * Status types exchanged
+ */
+typedef enum {
+	XAUTH_FAILED = 0,
+	XAUTH_OK = 1,
+} xauth_status_t;
+
+/**
+ * Private members of a xauth_t task.
+ */
+struct private_xauth_t {
+
+	/**
+	 * Public methods and task_t interface.
+	 */
+	xauth_t public;
+
+	/**
+	 * Assigned IKE_SA.
+	 */
+	ike_sa_t *ike_sa;
+
+	/**
+	 * Are we the XAUTH initiator?
+	 */
+	bool initiator;
+
+	/**
+	 * XAuth backend to use
+	 */
+	xauth_method_t *xauth;
+
+	/**
+	 * XAuth username
+	 */
+	identification_t *user;
+
+	/**
+	 * Generated configuration payload
+	 */
+	cp_payload_t *cp;
+
+	/**
+	 * received identifier
+	 */
+	u_int16_t identifier;
+
+	/**
+	 * status of Xauth exchange
+	 */
+	xauth_status_t status;
+};
+
+/**
+ * Load XAuth backend
+ */
+static xauth_method_t *load_method(private_xauth_t* this)
+{
+	identification_t *server, *peer;
+	enumerator_t *enumerator;
+	xauth_method_t *xauth;
+	xauth_role_t role;
+	peer_cfg_t *peer_cfg;
+	auth_cfg_t *auth;
+	char *name;
+
+	if (this->initiator)
+	{
+		server = this->ike_sa->get_my_id(this->ike_sa);
+		peer = this->ike_sa->get_other_id(this->ike_sa);
+		role = XAUTH_SERVER;
+	}
+	else
+	{
+		peer = this->ike_sa->get_my_id(this->ike_sa);
+		server = this->ike_sa->get_other_id(this->ike_sa);
+		role = XAUTH_PEER;
+	}
+	peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
+	enumerator = peer_cfg->create_auth_cfg_enumerator(peer_cfg, !this->initiator);
+	if (!enumerator->enumerate(enumerator, &auth) ||
+		(uintptr_t)auth->get(auth, AUTH_RULE_AUTH_CLASS) != AUTH_CLASS_XAUTH)
+	{
+		if (!enumerator->enumerate(enumerator, &auth) ||
+			(uintptr_t)auth->get(auth, AUTH_RULE_AUTH_CLASS) != AUTH_CLASS_XAUTH)
+		{
+			DBG1(DBG_CFG, "no XAuth authentication round found");
+			enumerator->destroy(enumerator);
+			return NULL;
+		}
+	}
+	name = auth->get(auth, AUTH_RULE_XAUTH_BACKEND);
+	this->user = auth->get(auth, AUTH_RULE_XAUTH_IDENTITY);
+	enumerator->destroy(enumerator);
+	if (!this->initiator && this->user)
+	{	/* use XAUTH username, if configured */
+		peer = this->user;
+	}
+	xauth = charon->xauth->create_instance(charon->xauth, name, role,
+										   server, peer);
+	if (!xauth)
+	{
+		if (name)
+		{
+			DBG1(DBG_CFG, "no XAuth method found named '%s'", name);
+		}
+		else
+		{
+			DBG1(DBG_CFG, "no XAuth method found");
+		}
+	}
+	return xauth;
+}
+
+/**
+ * Check if XAuth connection is allowed to succeed
+ */
+static bool allowed(private_xauth_t *this)
+{
+	if (charon->ike_sa_manager->check_uniqueness(charon->ike_sa_manager,
+												 this->ike_sa, FALSE))
+	{
+		DBG1(DBG_IKE, "cancelling XAuth due to uniqueness policy");
+		return FALSE;
+	}
+	if (!charon->bus->authorize(charon->bus, FALSE))
+	{
+		DBG1(DBG_IKE, "XAuth authorization hook forbids IKE_SA, cancelling");
+		return FALSE;
+	}
+	if (!charon->bus->authorize(charon->bus, TRUE))
+	{
+		DBG1(DBG_IKE, "final authorization hook forbids IKE_SA, cancelling");
+		return FALSE;
+	}
+	return TRUE;
+}
+
+/**
+ * Set IKE_SA to established state
+ */
+static bool establish(private_xauth_t *this)
+{
+	DBG0(DBG_IKE, "IKE_SA %s[%d] established between %H[%Y]...%H[%Y]",
+		 this->ike_sa->get_name(this->ike_sa),
+		 this->ike_sa->get_unique_id(this->ike_sa),
+		 this->ike_sa->get_my_host(this->ike_sa),
+		 this->ike_sa->get_my_id(this->ike_sa),
+		 this->ike_sa->get_other_host(this->ike_sa),
+		 this->ike_sa->get_other_id(this->ike_sa));
+
+	this->ike_sa->set_state(this->ike_sa, IKE_ESTABLISHED);
+	charon->bus->ike_updown(charon->bus, this->ike_sa, TRUE);
+
+	return TRUE;
+}
+
+/**
+ * Check if we are compliant to a given peer config
+ */
+static bool is_compliant(private_xauth_t *this, peer_cfg_t *peer_cfg, bool log)
+{
+	bool complies = TRUE;
+	enumerator_t *e1, *e2;
+	auth_cfg_t *c1, *c2;
+
+	e1 = peer_cfg->create_auth_cfg_enumerator(peer_cfg, FALSE);
+	e2 = this->ike_sa->create_auth_cfg_enumerator(this->ike_sa, FALSE);
+	while (e1->enumerate(e1, &c1))
+	{
+		if (!e2->enumerate(e2, &c2) || !c2->complies(c2, c1, log))
+		{
+			complies = FALSE;
+			break;
+		}
+	}
+	e1->destroy(e1);
+	e2->destroy(e2);
+
+	return complies;
+}
+
+/**
+ * Check if we are compliant to current config, switch to another if not
+ */
+static bool select_compliant_config(private_xauth_t *this)
+{
+	peer_cfg_t *peer_cfg = NULL, *old, *current;
+	identification_t *my_id, *other_id;
+	host_t *my_host, *other_host;
+	enumerator_t *enumerator;
+	bool aggressive;
+
+	old = this->ike_sa->get_peer_cfg(this->ike_sa);
+	if (is_compliant(this, old, TRUE))
+	{	/* current config is fine */
+		return TRUE;
+	}
+	DBG1(DBG_CFG, "selected peer config '%s' inacceptable",
+		 old->get_name(old));
+	aggressive = old->use_aggressive(old);
+
+	my_host = this->ike_sa->get_my_host(this->ike_sa);
+	other_host = this->ike_sa->get_other_host(this->ike_sa);
+	my_id = this->ike_sa->get_my_id(this->ike_sa);
+	other_id = this->ike_sa->get_other_id(this->ike_sa);
+	enumerator = charon->backends->create_peer_cfg_enumerator(charon->backends,
+								my_host, other_host, my_id, other_id, IKEV1);
+	while (enumerator->enumerate(enumerator, &current))
+	{
+		if (!current->equals(current, old) &&
+			current->use_aggressive(current) == aggressive &&
+			is_compliant(this, current, FALSE))
+		{
+			peer_cfg = current;
+			break;
+		}
+	}
+	if (peer_cfg)
+	{
+		DBG1(DBG_CFG, "switching to peer config '%s'",
+			 peer_cfg->get_name(peer_cfg));
+		this->ike_sa->set_peer_cfg(this->ike_sa, peer_cfg);
+	}
+	else
+	{
+		DBG1(DBG_CFG, "no alternative config found");
+	}
+	enumerator->destroy(enumerator);
+
+	return peer_cfg != NULL;
+}
+
+/**
+ * Create auth config after successful authentication
+ */
+static bool add_auth_cfg(private_xauth_t *this, identification_t *id, bool local)
+{
+	auth_cfg_t *auth;
+
+	auth = auth_cfg_create();
+	auth->add(auth, AUTH_RULE_AUTH_CLASS, AUTH_CLASS_XAUTH);
+	auth->add(auth, AUTH_RULE_XAUTH_IDENTITY, id->clone(id));
+	auth->merge(auth, this->ike_sa->get_auth_cfg(this->ike_sa, local), FALSE);
+	this->ike_sa->add_auth_cfg(this->ike_sa, local, auth);
+
+	return select_compliant_config(this);
+}
+
+METHOD(task_t, build_i_status, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	cp_payload_t *cp;
+
+	cp = cp_payload_create_type(CONFIGURATION_V1, CFG_SET);
+	cp->add_attribute(cp,
+			configuration_attribute_create_value(XAUTH_STATUS, this->status));
+
+	message->add_payload(message, (payload_t *)cp);
+
+	return NEED_MORE;
+}
+
+METHOD(task_t, build_i, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	if (!this->xauth)
+	{
+		cp_payload_t *cp;
+
+		this->xauth = load_method(this);
+		if (!this->xauth)
+		{
+			return FAILED;
+		}
+		if (this->xauth->initiate(this->xauth, &cp) != NEED_MORE)
+		{
+			return FAILED;
+		}
+		message->add_payload(message, (payload_t *)cp);
+		return NEED_MORE;
+	}
+
+	if (this->cp)
+	{	/* send previously generated payload */
+		message->add_payload(message, (payload_t *)this->cp);
+		this->cp = NULL;
+		return NEED_MORE;
+	}
+	return FAILED;
+}
+
+METHOD(task_t, build_r_ack, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	cp_payload_t *cp;
+
+	cp = cp_payload_create_type(CONFIGURATION_V1, CFG_ACK);
+	cp->set_identifier(cp, this->identifier);
+	cp->add_attribute(cp,
+			configuration_attribute_create_chunk(
+					CONFIGURATION_ATTRIBUTE_V1, XAUTH_STATUS, chunk_empty));
+
+	message->add_payload(message, (payload_t *)cp);
+
+	if (this->status == XAUTH_OK && allowed(this) && establish(this))
+	{
+		return SUCCESS;
+	}
+	return FAILED;
+}
+
+METHOD(task_t, process_r, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	cp_payload_t *cp;
+
+	if (!this->xauth)
+	{
+		this->xauth = load_method(this);
+		if (!this->xauth)
+		{	/* send empty reply */
+			return NEED_MORE;
+		}
+	}
+	cp = (cp_payload_t*)message->get_payload(message, CONFIGURATION_V1);
+	if (!cp)
+	{
+		DBG1(DBG_IKE, "configuration payload missing in XAuth request");
+		return FAILED;
+	}
+	if (cp->get_type(cp) == CFG_REQUEST)
+	{
+		switch (this->xauth->process(this->xauth, cp, &this->cp))
+		{
+			case NEED_MORE:
+				return NEED_MORE;
+			case SUCCESS:
+			case FAILED:
+			default:
+				break;
+		}
+		this->cp = NULL;
+		return NEED_MORE;
+	}
+	if (cp->get_type(cp) == CFG_SET)
+	{
+		configuration_attribute_t *attribute;
+		enumerator_t *enumerator;
+
+		enumerator = cp->create_attribute_enumerator(cp);
+		while (enumerator->enumerate(enumerator, &attribute))
+		{
+			if (attribute->get_type(attribute) == XAUTH_STATUS)
+			{
+				this->status = attribute->get_value(attribute);
+			}
+		}
+		enumerator->destroy(enumerator);
+		if (this->status == XAUTH_OK &&
+			add_auth_cfg(this, this->xauth->get_identity(this->xauth), TRUE))
+		{
+			DBG1(DBG_IKE, "XAuth authentication of '%Y' (myself) successful",
+				 this->xauth->get_identity(this->xauth));
+		}
+		else
+		{
+			DBG1(DBG_IKE, "XAuth authentication of '%Y' (myself) failed",
+				 this->xauth->get_identity(this->xauth));
+		}
+	}
+	this->identifier = cp->get_identifier(cp);
+	this->public.task.build = _build_r_ack;
+	return NEED_MORE;
+}
+
+METHOD(task_t, build_r, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	if (!this->cp)
+	{	/* send empty reply if building data failed */
+		this->cp = cp_payload_create_type(CONFIGURATION_V1, CFG_REPLY);
+	}
+	message->add_payload(message, (payload_t *)this->cp);
+	this->cp = NULL;
+	return NEED_MORE;
+}
+
+METHOD(task_t, process_i_status, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	cp_payload_t *cp;
+
+	cp = (cp_payload_t*)message->get_payload(message, CONFIGURATION_V1);
+	if (!cp || cp->get_type(cp) != CFG_ACK)
+	{
+		DBG1(DBG_IKE, "received invalid XAUTH status response");
+		return FAILED;
+	}
+	if (this->status != XAUTH_OK)
+	{
+		DBG1(DBG_IKE, "destroying IKE_SA after failed XAuth authentication");
+		return FAILED;
+	}
+	if (!establish(this))
+	{
+		return FAILED;
+	}
+	this->ike_sa->set_condition(this->ike_sa, COND_XAUTH_AUTHENTICATED, TRUE);
+	lib->processor->queue_job(lib->processor, (job_t*)
+				adopt_children_job_create(this->ike_sa->get_id(this->ike_sa)));
+	return SUCCESS;
+}
+
+METHOD(task_t, process_i, status_t,
+	private_xauth_t *this, message_t *message)
+{
+	identification_t *id;
+	cp_payload_t *cp;
+
+	cp = (cp_payload_t*)message->get_payload(message, CONFIGURATION_V1);
+	if (!cp)
+	{
+		DBG1(DBG_IKE, "configuration payload missing in XAuth response");
+		return FAILED;
+	}
+	switch (this->xauth->process(this->xauth, cp, &this->cp))
+	{
+		case NEED_MORE:
+			return NEED_MORE;
+		case SUCCESS:
+			id = this->xauth->get_identity(this->xauth);
+			if (this->user && !id->matches(id, this->user))
+			{
+				DBG1(DBG_IKE, "XAuth username '%Y' does not match to "
+					 "configured username '%Y'", id, this->user);
+				break;
+			}
+			DBG1(DBG_IKE, "XAuth authentication of '%Y' successful", id);
+			if (add_auth_cfg(this, id, FALSE) && allowed(this))
+			{
+				this->status = XAUTH_OK;
+			}
+			break;
+		case FAILED:
+			DBG1(DBG_IKE, "XAuth authentication of '%Y' failed",
+				 this->xauth->get_identity(this->xauth));
+			break;
+		default:
+			return FAILED;
+	}
+	this->public.task.build = _build_i_status;
+	this->public.task.process = _process_i_status;
+	return NEED_MORE;
+}
+
+METHOD(task_t, get_type, task_type_t,
+	private_xauth_t *this)
+{
+	return TASK_XAUTH;
+}
+
+METHOD(task_t, migrate, void,
+	private_xauth_t *this, ike_sa_t *ike_sa)
+{
+	DESTROY_IF(this->xauth);
+	DESTROY_IF(this->cp);
+
+	this->ike_sa = ike_sa;
+	this->xauth = NULL;
+	this->cp = NULL;
+	this->user = NULL;
+	this->status = XAUTH_FAILED;
+
+	if (this->initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+}
+
+METHOD(task_t, destroy, void,
+	private_xauth_t *this)
+{
+	DESTROY_IF(this->xauth);
+	DESTROY_IF(this->cp);
+	free(this);
+}
+
+/*
+ * Described in header.
+ */
+xauth_t *xauth_create(ike_sa_t *ike_sa, bool initiator)
+{
+	private_xauth_t *this;
+
+	INIT(this,
+		.public = {
+			.task = {
+				.get_type = _get_type,
+				.migrate = _migrate,
+				.destroy = _destroy,
+			},
+		},
+		.initiator = initiator,
+		.ike_sa = ike_sa,
+		.status = XAUTH_FAILED,
+	);
+
+	if (initiator)
+	{
+		this->public.task.build = _build_i;
+		this->public.task.process = _process_i;
+	}
+	else
+	{
+		this->public.task.build = _build_r;
+		this->public.task.process = _process_r;
+	}
+	return &this->public;
+}
diff --git a/src/libcharon/sa/ikev1/tasks/xauth.h b/src/libcharon/sa/ikev1/tasks/xauth.h
new file mode 100644
index 000000000..303eb31ce
--- /dev/null
+++ b/src/libcharon/sa/ikev1/tasks/xauth.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2011 Martin Willi
+ * Copyright (C) 2011 revosec AG
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ */
+
+/**
+ * @defgroup xauth_t xauth
+ * @{ @ingroup tasks_v1
+ */
+
+#ifndef XAUTH_H_
+#define XAUTH_H_
+
+typedef struct xauth_t xauth_t;
+
+#include <library.h>
+#include <sa/ike_sa.h>
+#include <sa/task.h>
+
+/**
+ * Task of type TASK_XAUTH, additional authentication after main/aggressive mode.
+ */
+struct xauth_t {
+
+	/**
+	 * Implements the task_t interface
+	 */
+	task_t task;
+};
+
+/**
+ * Create a new xauth task.
+ *
+ * @param ike_sa		IKE_SA this task works for
+ * @param initiator		TRUE for initiator
+ * @return				xauth task to handle by the task_manager
+ */
+xauth_t *xauth_create(ike_sa_t *ike_sa, bool initiator);
+
+#endif /** XAUTH_H_ @}*/