Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1440 insertions, 0 deletions

diff --git a/auth/kerberos/gssapi_helper.c b/auth/kerberos/gssapi_helper.c
new file mode 100644
index 0000000..52c953c
--- /dev/null
+++ b/auth/kerberos/gssapi_helper.c
@@ -0,0 +1,398 @@
+/*
+   Unix SMB/CIFS implementation.
+   GSSAPI helper functions
+
+   Copyright (C) Stefan Metzmacher 2008,2015
+
+   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 3 of the License, or
+   (at your option) any later version.
+
+   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.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "system/gssapi.h"
+#include "auth/kerberos/pac_utils.h"
+#include "auth/kerberos/gssapi_helper.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_AUTH
+
+size_t gssapi_get_sig_size(gss_ctx_id_t gssapi_context,
+			   const gss_OID mech,
+			   uint32_t gss_want_flags,
+			   size_t data_size)
+{
+	TALLOC_CTX *frame = talloc_stackframe();
+	size_t sig_size = 0;
+
+	if (gss_want_flags & GSS_C_CONF_FLAG) {
+		OM_uint32 min_stat, maj_stat;
+		bool want_sealing = true;
+		int sealed = 0;
+		gss_iov_buffer_desc iov[2];
+
+		if (!(gss_want_flags & GSS_C_DCE_STYLE)) {
+			TALLOC_FREE(frame);
+			return 0;
+		}
+
+		/*
+		 * gss_wrap_iov_length() only needs the type and length
+		 */
+		iov[0].type = GSS_IOV_BUFFER_TYPE_HEADER;
+		iov[0].buffer.value = NULL;
+		iov[0].buffer.length = 0;
+		iov[1].type = GSS_IOV_BUFFER_TYPE_DATA;
+		iov[1].buffer.value = NULL;
+		iov[1].buffer.length = data_size;
+
+		maj_stat = gss_wrap_iov_length(&min_stat,
+					       gssapi_context,
+					       want_sealing,
+					       GSS_C_QOP_DEFAULT,
+					       &sealed,
+					       iov, ARRAY_SIZE(iov));
+		if (maj_stat) {
+			DEBUG(0, ("gss_wrap_iov_length failed with [%s]\n",
+				  gssapi_error_string(frame,
+						      maj_stat,
+						      min_stat,
+						      mech)));
+			TALLOC_FREE(frame);
+			return 0;
+		}
+
+		sig_size = iov[0].buffer.length;
+	} else if (gss_want_flags & GSS_C_INTEG_FLAG) {
+		NTSTATUS status;
+		uint32_t keytype;
+
+		status = gssapi_get_session_key(frame,
+						gssapi_context,
+						NULL, &keytype);
+		if (!NT_STATUS_IS_OK(status)) {
+			TALLOC_FREE(frame);
+			return 0;
+		}
+
+		switch (keytype) {
+		case ENCTYPE_DES_CBC_MD5:
+		case ENCTYPE_DES_CBC_CRC:
+		case ENCTYPE_ARCFOUR_HMAC:
+		case ENCTYPE_ARCFOUR_HMAC_EXP:
+			sig_size = 37;
+			break;
+		default:
+			sig_size = 28;
+			break;
+		}
+	}
+
+	TALLOC_FREE(frame);
+	return sig_size;
+}
+
+NTSTATUS gssapi_seal_packet(gss_ctx_id_t gssapi_context,
+			    const gss_OID mech,
+			    bool hdr_signing, size_t sig_size,
+			    uint8_t *data, size_t length,
+			    const uint8_t *whole_pdu, size_t pdu_length,
+			    TALLOC_CTX *mem_ctx,
+			    DATA_BLOB *sig)
+{
+	OM_uint32 maj_stat, min_stat;
+	gss_iov_buffer_desc iov[4];
+	int req_seal = 1;
+	int sealed = 0;
+	const uint8_t *pre_sign_ptr = NULL;
+	size_t pre_sign_len = 0;
+	const uint8_t *post_sign_ptr = NULL;
+	size_t post_sign_len = 0;
+
+	if (hdr_signing) {
+		const uint8_t *de = data + length;
+		const uint8_t *we = whole_pdu + pdu_length;
+
+		if (data < whole_pdu) {
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+
+		if (de > we) {
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+
+		pre_sign_len = data - whole_pdu;
+		if (pre_sign_len > 0) {
+			pre_sign_ptr = whole_pdu;
+		}
+		post_sign_len = we - de;
+		if (post_sign_len > 0) {
+			post_sign_ptr = de;
+		}
+	}
+
+	sig->length = sig_size;
+	if (sig->length == 0) {
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	sig->data = talloc_zero_array(mem_ctx, uint8_t, sig->length);
+	if (sig->data == NULL) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	iov[0].type          = GSS_IOV_BUFFER_TYPE_HEADER;
+	iov[0].buffer.length = sig->length;
+	iov[0].buffer.value  = sig->data;
+
+	if (pre_sign_ptr != NULL) {
+		iov[1].type = GSS_IOV_BUFFER_TYPE_SIGN_ONLY;
+		iov[1].buffer.length = pre_sign_len;
+		iov[1].buffer.value = discard_const(pre_sign_ptr);
+	} else {
+		iov[1].type = GSS_IOV_BUFFER_TYPE_EMPTY;
+		iov[1].buffer.length = 0;
+		iov[1].buffer.value = NULL;
+	}
+
+	/* data is encrypted in place, which is ok */
+	iov[2].type          = GSS_IOV_BUFFER_TYPE_DATA;
+	iov[2].buffer.length = length;
+	iov[2].buffer.value  = data;
+
+	if (post_sign_ptr != NULL) {
+		iov[3].type = GSS_IOV_BUFFER_TYPE_SIGN_ONLY;
+		iov[3].buffer.length = post_sign_len;
+		iov[3].buffer.value = discard_const(post_sign_ptr);
+	} else {
+		iov[3].type = GSS_IOV_BUFFER_TYPE_EMPTY;
+		iov[3].buffer.length = 0;
+		iov[3].buffer.value = NULL;
+	}
+
+	maj_stat = gss_wrap_iov(&min_stat,
+				gssapi_context,
+				req_seal,
+				GSS_C_QOP_DEFAULT,
+				&sealed,
+				iov, ARRAY_SIZE(iov));
+	if (GSS_ERROR(maj_stat)) {
+		char *error_string = gssapi_error_string(mem_ctx,
+							 maj_stat,
+							 min_stat,
+							 mech);
+		DEBUG(1, ("gss_wrap_iov failed: %s\n", error_string));
+		talloc_free(error_string);
+		data_blob_free(sig);
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	if (req_seal == 1 && sealed == 0) {
+		DEBUG(0, ("gss_wrap_iov says data was not sealed!\n"));
+		data_blob_free(sig);
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	dump_data_pw("gssapi_seal_packet: sig\n", sig->data, sig->length);
+	dump_data_pw("gssapi_seal_packet: sealed\n", data, length);
+
+	DEBUG(10, ("Sealed %d bytes, and got %d bytes header/signature.\n",
+		   (int)iov[2].buffer.length, (int)iov[0].buffer.length));
+
+	return NT_STATUS_OK;
+}
+
+NTSTATUS gssapi_unseal_packet(gss_ctx_id_t gssapi_context,
+			      const gss_OID mech,
+			      bool hdr_signing,
+			      uint8_t *data, size_t length,
+			      const uint8_t *whole_pdu, size_t pdu_length,
+			      const DATA_BLOB *sig)
+{
+	OM_uint32 maj_stat, min_stat;
+	gss_iov_buffer_desc iov[4];
+	gss_qop_t qop_state;
+	int sealed = 0;
+	const uint8_t *pre_sign_ptr = NULL;
+	size_t pre_sign_len = 0;
+	const uint8_t *post_sign_ptr = NULL;
+	size_t post_sign_len = 0;
+
+	if (hdr_signing) {
+		const uint8_t *de = data + length;
+		const uint8_t *we = whole_pdu + pdu_length;
+
+		if (data < whole_pdu) {
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+
+		if (de > we) {
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+
+		pre_sign_len = data - whole_pdu;
+		if (pre_sign_len > 0) {
+			pre_sign_ptr = whole_pdu;
+		}
+		post_sign_len = we - de;
+		if (post_sign_len > 0) {
+			post_sign_ptr = de;
+		}
+	}
+
+	dump_data_pw("gssapi_unseal_packet: sig\n", sig->data, sig->length);
+	dump_data_pw("gssapi_unseal_packet: sealed\n", data, length);
+
+	iov[0].type          = GSS_IOV_BUFFER_TYPE_HEADER;
+	iov[0].buffer.length = sig->length;
+	iov[0].buffer.value  = sig->data;
+
+	if (pre_sign_ptr != NULL) {
+		iov[1].type = GSS_IOV_BUFFER_TYPE_SIGN_ONLY;
+		iov[1].buffer.length = pre_sign_len;
+		iov[1].buffer.value = discard_const(pre_sign_ptr);
+	} else {
+		iov[1].type = GSS_IOV_BUFFER_TYPE_EMPTY;
+		iov[1].buffer.length = 0;
+		iov[1].buffer.value = NULL;
+	}
+
+	/* data is encrypted in place, which is ok */
+	iov[2].type          = GSS_IOV_BUFFER_TYPE_DATA;
+	iov[2].buffer.length = length;
+	iov[2].buffer.value  = data;
+
+	if (post_sign_ptr != NULL) {
+		iov[3].type = GSS_IOV_BUFFER_TYPE_SIGN_ONLY;
+		iov[3].buffer.length = post_sign_len;
+		iov[3].buffer.value = discard_const(post_sign_ptr);
+	} else {
+		iov[3].type = GSS_IOV_BUFFER_TYPE_EMPTY;
+		iov[3].buffer.length = 0;
+		iov[3].buffer.value = NULL;
+	}
+
+	maj_stat = gss_unwrap_iov(&min_stat,
+				  gssapi_context,
+				  &sealed,
+				  &qop_state,
+				  iov, ARRAY_SIZE(iov));
+	if (GSS_ERROR(maj_stat)) {
+		char *error_string = gssapi_error_string(NULL,
+							 maj_stat,
+							 min_stat,
+							 mech);
+		DEBUG(1, ("gss_unwrap_iov failed: %s\n", error_string));
+		talloc_free(error_string);
+
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	if (sealed == 0) {
+		DEBUG(0, ("gss_unwrap_iov says data was not sealed!\n"));
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	DEBUG(10, ("Unsealed %d bytes, with %d bytes header/signature.\n",
+		   (int)iov[2].buffer.length, (int)iov[0].buffer.length));
+
+	return NT_STATUS_OK;
+}
+
+NTSTATUS gssapi_sign_packet(gss_ctx_id_t gssapi_context,
+			    const gss_OID mech,
+			    bool hdr_signing,
+			    const uint8_t *data, size_t length,
+			    const uint8_t *whole_pdu, size_t pdu_length,
+			    TALLOC_CTX *mem_ctx,
+			    DATA_BLOB *sig)
+{
+	OM_uint32 maj_stat, min_stat;
+	gss_buffer_desc input_token, output_token;
+
+	if (hdr_signing) {
+		input_token.length = pdu_length;
+		input_token.value = discard_const_p(uint8_t *, whole_pdu);
+	} else {
+		input_token.length = length;
+		input_token.value = discard_const_p(uint8_t *, data);
+	}
+
+	maj_stat = gss_get_mic(&min_stat,
+			       gssapi_context,
+			       GSS_C_QOP_DEFAULT,
+			       &input_token,
+			       &output_token);
+	if (GSS_ERROR(maj_stat)) {
+		char *error_string = gssapi_error_string(mem_ctx,
+							 maj_stat,
+							 min_stat,
+							 mech);
+		DEBUG(1, ("GSS GetMic failed: %s\n", error_string));
+		talloc_free(error_string);
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	*sig = data_blob_talloc(mem_ctx, (uint8_t *)output_token.value, output_token.length);
+	gss_release_buffer(&min_stat, &output_token);
+	if (sig->data == NULL) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	dump_data_pw("gssapi_sign_packet: sig\n", sig->data, sig->length);
+
+	return NT_STATUS_OK;
+}
+
+NTSTATUS gssapi_check_packet(gss_ctx_id_t gssapi_context,
+			     const gss_OID mech,
+			     bool hdr_signing,
+			     const uint8_t *data, size_t length,
+			     const uint8_t *whole_pdu, size_t pdu_length,
+			     const DATA_BLOB *sig)
+{
+	OM_uint32 maj_stat, min_stat;
+	gss_buffer_desc input_token;
+	gss_buffer_desc input_message;
+	gss_qop_t qop_state;
+
+	dump_data_pw("gssapi_check_packet: sig\n", sig->data, sig->length);
+
+	if (hdr_signing) {
+		input_message.length = pdu_length;
+		input_message.value = discard_const(whole_pdu);
+	} else {
+		input_message.length = length;
+		input_message.value = discard_const(data);
+	}
+
+	input_token.length = sig->length;
+	input_token.value = sig->data;
+
+	maj_stat = gss_verify_mic(&min_stat,
+				  gssapi_context,
+				  &input_message,
+				  &input_token,
+				  &qop_state);
+	if (GSS_ERROR(maj_stat)) {
+		char *error_string = gssapi_error_string(NULL,
+							 maj_stat,
+							 min_stat,
+							 mech);
+		DEBUG(1, ("GSS VerifyMic failed: %s\n", error_string));
+		talloc_free(error_string);
+
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+	return NT_STATUS_OK;
+}
diff --git a/auth/kerberos/gssapi_helper.h b/auth/kerberos/gssapi_helper.h
new file mode 100644
index 0000000..f40adf1
--- /dev/null
+++ b/auth/kerberos/gssapi_helper.h
@@ -0,0 +1,55 @@
+/*
+   Unix SMB/CIFS implementation.
+   GSSAPI helper functions
+
+   Copyright (C) Stefan Metzmacher 2008,2015
+
+   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 3 of the License, or
+   (at your option) any later version.
+
+   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.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef AUTH_KERBEROS_GSSAPI_HELPER_H
+#define AUTH_KERBEROS_GSSAPI_HELPER_H 1
+
+size_t gssapi_get_sig_size(gss_ctx_id_t gssapi_context,
+			   const gss_OID mech,
+			   uint32_t gss_want_flags,
+			   size_t data_size);
+NTSTATUS gssapi_seal_packet(gss_ctx_id_t gssapi_context,
+			    const gss_OID mech,
+			    bool hdr_signing, size_t sig_size,
+			    uint8_t *data, size_t length,
+			    const uint8_t *whole_pdu, size_t pdu_length,
+			    TALLOC_CTX *mem_ctx,
+			    DATA_BLOB *sig);
+NTSTATUS gssapi_unseal_packet(gss_ctx_id_t gssapi_context,
+			      const gss_OID mech,
+			      bool hdr_signing,
+			      uint8_t *data, size_t length,
+			      const uint8_t *whole_pdu, size_t pdu_length,
+			      const DATA_BLOB *sig);
+NTSTATUS gssapi_sign_packet(gss_ctx_id_t gssapi_context,
+			    const gss_OID mech,
+			    bool hdr_signing,
+			    const uint8_t *data, size_t length,
+			    const uint8_t *whole_pdu, size_t pdu_length,
+			    TALLOC_CTX *mem_ctx,
+			    DATA_BLOB *sig);
+NTSTATUS gssapi_check_packet(gss_ctx_id_t gssapi_context,
+			     const gss_OID mech,
+			     bool hdr_signing,
+			     const uint8_t *data, size_t length,
+			     const uint8_t *whole_pdu, size_t pdu_length,
+			     const DATA_BLOB *sig);
+
+#endif /* AUTH_KERBEROS_GSSAPI_HELPER_H */
diff --git a/auth/kerberos/gssapi_pac.c b/auth/kerberos/gssapi_pac.c
new file mode 100644
index 0000000..4ad7873
--- /dev/null
+++ b/auth/kerberos/gssapi_pac.c
@@ -0,0 +1,348 @@
+/*
+   Unix SMB/CIFS implementation.
+   kerberos authorization data (PAC) utility library
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2011
+   Copyright (C) Simo Sorce 2010.
+
+   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 3 of the License, or
+   (at your option) any later version.
+
+   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.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_AUTH
+
+#ifdef HAVE_KRB5
+
+#include "auth/kerberos/pac_utils.h"
+
+#if 0
+/* FIXME - need proper configure/waf test
+ * to determine if gss_mech_krb5 and friends
+ * exist. JRA.
+ */
+/*
+ * These are not exported by Solaris -lkrb5
+ * Maybe move to libreplace somewhere?
+ */
+static const gss_OID_desc krb5_gss_oid_array[] = {
+	/* this is the official, rfc-specified OID */
+	{ 9, "\052\206\110\206\367\022\001\002\002" },
+	/* this is the pre-RFC mech OID */
+	{ 5, "\053\005\001\005\002" },
+	/* this is the unofficial, incorrect mech OID emitted by MS */
+	{ 9, "\052\206\110\202\367\022\001\002\002" },
+	{ 0, 0 }
+};
+
+const gss_OID_desc * const gss_mech_krb5              = krb5_gss_oid_array+0;
+const gss_OID_desc * const gss_mech_krb5_old          = krb5_gss_oid_array+1;
+const gss_OID_desc * const gss_mech_krb5_wrong        = krb5_gss_oid_array+2;
+#endif
+
+#ifndef GSS_KRB5_INQ_SSPI_SESSION_KEY_OID
+#define GSS_KRB5_INQ_SSPI_SESSION_KEY_OID_LENGTH 11
+#define GSS_KRB5_INQ_SSPI_SESSION_KEY_OID "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02\x05\x05"
+#endif
+
+gss_OID_desc gse_sesskey_inq_oid = {
+	GSS_KRB5_INQ_SSPI_SESSION_KEY_OID_LENGTH,
+	discard_const(GSS_KRB5_INQ_SSPI_SESSION_KEY_OID)
+};
+
+#ifndef GSS_KRB5_SESSION_KEY_ENCTYPE_OID
+#define GSS_KRB5_SESSION_KEY_ENCTYPE_OID_LENGTH 10
+#define GSS_KRB5_SESSION_KEY_ENCTYPE_OID  "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02\x04"
+#endif
+
+gss_OID_desc gse_sesskeytype_oid = {
+	GSS_KRB5_SESSION_KEY_ENCTYPE_OID_LENGTH,
+	discard_const(GSS_KRB5_SESSION_KEY_ENCTYPE_OID)
+};
+
+/* The Heimdal OID for getting the PAC */
+#define EXTRACT_PAC_AUTHZ_DATA_FROM_SEC_CONTEXT_OID_LENGTH 8
+/*					                EXTRACTION OID		   AUTHZ ID */
+#define EXTRACT_PAC_AUTHZ_DATA_FROM_SEC_CONTEXT_OID "\x2a\x85\x70\x2b\x0d\x03" "\x81\x00"
+
+NTSTATUS gssapi_obtain_pac_blob(TALLOC_CTX *mem_ctx,
+				gss_ctx_id_t gssapi_context,
+				gss_name_t gss_client_name,
+				DATA_BLOB *pac_blob)
+{
+	NTSTATUS status;
+	OM_uint32 gss_maj, gss_min;
+#ifdef HAVE_GSS_GET_NAME_ATTRIBUTE
+/*
+ * gss_get_name_attribute() in MIT krb5 1.10.0 can return uninitialized pac_display_buffer
+ * and later gss_release_buffer() will crash on attempting to release it.
+ *
+ * So always initialize the buffer descriptors.
+ *
+ * See following links for more details:
+ * http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=658514
+ * http://krbdev.mit.edu/rt/Ticket/Display.html?user=guest&pass=guest&id=7087
+ */
+	gss_buffer_desc pac_buffer = {
+		.value = NULL,
+		.length = 0
+	};
+	gss_buffer_desc pac_display_buffer = {
+		.value = NULL,
+		.length = 0
+	};
+	gss_buffer_desc pac_name = {
+		.value = discard_const("urn:mspac:"),
+		.length = sizeof("urn:mspac:")-1
+	};
+	int more = -1;
+	int authenticated = false;
+	int complete = false;
+
+	gss_maj = gss_get_name_attribute(
+		&gss_min, gss_client_name, &pac_name,
+		&authenticated, &complete,
+		&pac_buffer, &pac_display_buffer, &more);
+
+	if (gss_maj != 0) {
+		gss_OID oid = discard_const(gss_mech_krb5);
+		DBG_NOTICE("obtaining PAC via GSSAPI gss_get_name_attribute "
+			   "failed: %s\n", gssapi_error_string(mem_ctx,
+							       gss_maj, gss_min,
+							       oid));
+		return NT_STATUS_ACCESS_DENIED;
+	} else if (authenticated && complete) {
+		/* The PAC blob is returned directly */
+		*pac_blob = data_blob_talloc(mem_ctx, pac_buffer.value,
+					    pac_buffer.length);
+
+		if (!pac_blob->data) {
+			status = NT_STATUS_NO_MEMORY;
+		} else {
+			status = NT_STATUS_OK;
+		}
+
+		gss_release_buffer(&gss_min, &pac_buffer);
+		gss_release_buffer(&gss_min, &pac_display_buffer);
+		return status;
+	} else {
+		DEBUG(0, ("obtaining PAC via GSSAPI failed: authenticated: %s, complete: %s, more: %s\n",
+			  authenticated ? "true" : "false",
+			  complete ? "true" : "false",
+			  more ? "true" : "false"));
+		return NT_STATUS_ACCESS_DENIED;
+	}
+
+#elif defined(HAVE_GSS_INQUIRE_SEC_CONTEXT_BY_OID)
+	gss_OID_desc pac_data_oid = {
+		.elements = discard_const(EXTRACT_PAC_AUTHZ_DATA_FROM_SEC_CONTEXT_OID),
+		.length = EXTRACT_PAC_AUTHZ_DATA_FROM_SEC_CONTEXT_OID_LENGTH
+	};
+
+	gss_buffer_set_t set = GSS_C_NO_BUFFER_SET;
+
+	/* If we didn't have the routine to get a verified, validated
+	 * PAC (supplied only by MIT at the time of writing), then try
+	 * with the Heimdal OID (fetches the PAC directly and always
+	 * validates) */
+	gss_maj = gss_inquire_sec_context_by_oid(
+				&gss_min, gssapi_context,
+				&pac_data_oid, &set);
+
+	/* First check for the error MIT gives for an unknown OID */
+	if (gss_maj == GSS_S_UNAVAILABLE) {
+		DEBUG(1, ("unable to obtain a PAC against this GSSAPI library.  "
+			  "GSSAPI secured connections are available only with Heimdal or MIT Kerberos >= 1.8\n"));
+	} else if (gss_maj != 0) {
+		DEBUG(2, ("obtaining PAC via GSSAPI gss_inquire_sec_context_by_oid (Heimdal OID) failed: %s\n",
+			  gssapi_error_string(mem_ctx, gss_maj, gss_min, gss_mech_krb5)));
+	} else {
+		if (set == GSS_C_NO_BUFFER_SET) {
+			DEBUG(0, ("gss_inquire_sec_context_by_oid returned unknown "
+				  "data in results.\n"));
+			return NT_STATUS_INTERNAL_ERROR;
+		}
+
+		/* The PAC blob is returned directly */
+		*pac_blob = data_blob_talloc(mem_ctx, set->elements[0].value,
+					    set->elements[0].length);
+		if (!pac_blob->data) {
+			status = NT_STATUS_NO_MEMORY;
+		} else {
+			status = NT_STATUS_OK;
+		}
+
+		gss_maj = gss_release_buffer_set(&gss_min, &set);
+		return status;
+	}
+#else
+	DEBUG(1, ("unable to obtain a PAC against this GSSAPI library.  "
+		  "GSSAPI secured connections are available only with Heimdal or MIT Kerberos >= 1.8\n"));
+#endif
+	return NT_STATUS_ACCESS_DENIED;
+}
+
+NTSTATUS gssapi_get_session_key(TALLOC_CTX *mem_ctx,
+				gss_ctx_id_t gssapi_context,
+				DATA_BLOB *session_key, 
+				uint32_t *keytype)
+{
+	OM_uint32 gss_min, gss_maj;
+	gss_buffer_set_t set = GSS_C_NO_BUFFER_SET;
+
+	gss_maj = gss_inquire_sec_context_by_oid(
+				&gss_min, gssapi_context,
+				&gse_sesskey_inq_oid, &set);
+	if (gss_maj) {
+		DEBUG(0, ("gss_inquire_sec_context_by_oid failed [%s]\n",
+			  gssapi_error_string(mem_ctx,
+					      gss_maj,
+					      gss_min,
+					      discard_const_p(struct gss_OID_desc_struct,
+							      gss_mech_krb5))));
+		return NT_STATUS_NO_USER_SESSION_KEY;
+	}
+
+	if ((set == GSS_C_NO_BUFFER_SET) ||
+	    (set->count == 0)) {
+#ifdef HAVE_GSSKRB5_GET_SUBKEY
+		krb5_keyblock *subkey;
+		gss_maj = gsskrb5_get_subkey(&gss_min,
+					     gssapi_context,
+					     &subkey);
+		if (gss_maj != 0) {
+			DEBUG(1, ("NO session key for this mech\n"));
+			return NT_STATUS_NO_USER_SESSION_KEY;
+		}
+		if (session_key) {
+			*session_key = data_blob_talloc(mem_ctx,
+							KRB5_KEY_DATA(subkey), KRB5_KEY_LENGTH(subkey));
+		}
+		if (keytype) {
+			*keytype = KRB5_KEY_TYPE(subkey);
+		}
+		krb5_free_keyblock(NULL /* should be krb5_context */, subkey);
+		return NT_STATUS_OK;
+#else
+		DEBUG(0, ("gss_inquire_sec_context_by_oid didn't return any session key (and no alternative method available)\n"));
+		return NT_STATUS_NO_USER_SESSION_KEY;
+#endif
+	}
+
+	if (session_key) {
+		*session_key = data_blob_talloc(mem_ctx, set->elements[0].value,
+						set->elements[0].length);
+	}
+
+	if (keytype) {
+		int diflen, i;
+		const uint8_t *p;
+
+		*keytype = 0;
+		if (set->count < 2) {
+
+#ifdef HAVE_GSSKRB5_GET_SUBKEY
+			krb5_keyblock *subkey;
+			gss_maj = gsskrb5_get_subkey(&gss_min,
+						     gssapi_context,
+						     &subkey);
+			if (gss_maj == 0) {
+				*keytype = KRB5_KEY_TYPE(subkey);
+				krb5_free_keyblock(NULL /* should be krb5_context */, subkey);
+			}
+#endif
+			gss_release_buffer_set(&gss_min, &set);
+	
+			return NT_STATUS_OK;
+
+		} else if (memcmp(set->elements[1].value,
+				  gse_sesskeytype_oid.elements,
+				  gse_sesskeytype_oid.length) != 0) {
+			/* Perhaps a non-krb5 session key */
+			gss_release_buffer_set(&gss_min, &set);
+			return NT_STATUS_OK;
+		}
+		p = (const uint8_t *)set->elements[1].value + gse_sesskeytype_oid.length;
+		diflen = set->elements[1].length - gse_sesskeytype_oid.length;
+		if (diflen <= 0) {
+			gss_release_buffer_set(&gss_min, &set);
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+		for (i = 0; i < diflen; i++) {
+			*keytype = (*keytype << 7) | (p[i] & 0x7f);
+			if (i + 1 != diflen && (p[i] & 0x80) == 0) {
+				gss_release_buffer_set(&gss_min, &set);
+				return NT_STATUS_INVALID_PARAMETER;
+			}
+		}
+	}
+
+	gss_release_buffer_set(&gss_min, &set);
+	return NT_STATUS_OK;
+}
+
+
+char *gssapi_error_string(TALLOC_CTX *mem_ctx,
+			  OM_uint32 maj_stat, OM_uint32 min_stat,
+			  const gss_OID mech)
+{
+	OM_uint32 disp_min_stat, disp_maj_stat;
+	gss_buffer_desc maj_error_message;
+	gss_buffer_desc min_error_message;
+	char *maj_error_string, *min_error_string;
+	OM_uint32 msg_ctx = 0;
+
+	char *ret;
+
+	maj_error_message.value = NULL;
+	min_error_message.value = NULL;
+	maj_error_message.length = 0;
+	min_error_message.length = 0;
+
+	disp_maj_stat = gss_display_status(&disp_min_stat, maj_stat,
+					   GSS_C_GSS_CODE, mech,
+					   &msg_ctx, &maj_error_message);
+	if (disp_maj_stat != 0) {
+		maj_error_message.value = NULL;
+		maj_error_message.length = 0;
+	}
+	disp_maj_stat = gss_display_status(&disp_min_stat, min_stat,
+					   GSS_C_MECH_CODE, mech,
+					   &msg_ctx, &min_error_message);
+	if (disp_maj_stat != 0) {
+		min_error_message.value = NULL;
+		min_error_message.length = 0;
+	}
+
+	maj_error_string = talloc_strndup(mem_ctx,
+					  (char *)maj_error_message.value,
+					  maj_error_message.length);
+
+	min_error_string = talloc_strndup(mem_ctx,
+					  (char *)min_error_message.value,
+					  min_error_message.length);
+
+	ret = talloc_asprintf(mem_ctx, "%s: %s",
+				maj_error_string, min_error_string);
+
+	talloc_free(maj_error_string);
+	talloc_free(min_error_string);
+
+	gss_release_buffer(&disp_min_stat, &maj_error_message);
+	gss_release_buffer(&disp_min_stat, &min_error_message);
+
+	return ret;
+}
+
+#endif /* HAVE_KRB5 */
diff --git a/auth/kerberos/kerberos_pac.c b/auth/kerberos/kerberos_pac.c
new file mode 100644
index 0000000..ae4557b
--- /dev/null
+++ b/auth/kerberos/kerberos_pac.c
@@ -0,0 +1,554 @@
+/*
+   Unix SMB/CIFS implementation.
+   kerberos authorization data (PAC) utility library
+   Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
+   Copyright (C) Andrew Tridgell 2001
+   Copyright (C) Luke Howard 2002-2003
+   Copyright (C) Stefan Metzmacher 2004-2005
+   Copyright (C) Guenther Deschner 2005,2007,2008
+
+   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 3 of the License, or
+   (at your option) any later version.
+
+   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.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_AUTH
+
+#ifdef HAVE_KRB5
+
+#include "librpc/gen_ndr/ndr_krb5pac.h"
+#include "librpc/gen_ndr/auth.h"
+#include "auth/common_auth.h"
+#include "auth/kerberos/pac_utils.h"
+
+krb5_error_code check_pac_checksum(DATA_BLOB pac_data,
+					  struct PAC_SIGNATURE_DATA *sig,
+					  krb5_context context,
+					  const krb5_keyblock *keyblock)
+{
+	krb5_error_code ret;
+	krb5_checksum cksum;
+	krb5_keyusage usage = 0;
+	krb5_boolean checksum_valid = false;
+	krb5_data input;
+
+	switch (sig->type) {
+	case CKSUMTYPE_HMAC_MD5:
+		/* ignores the key type */
+		break;
+	case CKSUMTYPE_HMAC_SHA1_96_AES_256:
+		if (KRB5_KEY_TYPE(keyblock) != ENCTYPE_AES256_CTS_HMAC_SHA1_96) {
+			return EINVAL;
+		}
+		/* ok */
+		break;
+	case CKSUMTYPE_HMAC_SHA1_96_AES_128:
+		if (KRB5_KEY_TYPE(keyblock) != ENCTYPE_AES128_CTS_HMAC_SHA1_96) {
+			return EINVAL;
+		}
+		/* ok */
+		break;
+	default:
+		DEBUG(2,("check_pac_checksum: Checksum Type %"PRIu32" is not supported\n",
+			sig->type));
+		return EINVAL;
+	}
+
+#ifdef HAVE_CHECKSUM_IN_KRB5_CHECKSUM /* Heimdal */
+	cksum.cksumtype	= (krb5_cksumtype)sig->type;
+	cksum.checksum.length	= sig->signature.length;
+	cksum.checksum.data	= sig->signature.data;
+#else /* MIT */
+	cksum.checksum_type	= (krb5_cksumtype)sig->type;
+	cksum.length		= sig->signature.length;
+	cksum.contents		= sig->signature.data;
+#endif
+
+#ifdef HAVE_KRB5_KU_OTHER_CKSUM /* Heimdal */
+	usage = KRB5_KU_OTHER_CKSUM;
+#elif defined(HAVE_KRB5_KEYUSAGE_APP_DATA_CKSUM) /* MIT */
+	usage = KRB5_KEYUSAGE_APP_DATA_CKSUM;
+#else
+#error UNKNOWN_KRB5_KEYUSAGE
+#endif
+
+	input.data = (char *)pac_data.data;
+	input.length = pac_data.length;
+
+	ret = krb5_c_verify_checksum(context,
+				     keyblock,
+				     usage,
+				     &input,
+				     &cksum,
+				     &checksum_valid);
+	if (!checksum_valid) {
+		ret = KRB5KRB_AP_ERR_BAD_INTEGRITY;
+	}
+	if (ret){
+		DEBUG(2,("check_pac_checksum: PAC Verification failed: %s (%d)\n",
+			error_message(ret), ret));
+		return ret;
+	}
+
+	return ret;
+}
+
+/**
+* @brief Decode a blob containing a NDR encoded PAC structure
+*
+* @param mem_ctx	  - The memory context
+* @param pac_data_blob	  - The data blob containing the NDR encoded data
+* @param context	  - The Kerberos Context
+* @param service_keyblock - The Service Key used to verify the checksum
+* @param client_principal - The client principal
+* @param tgs_authtime     - The ticket timestamp
+* @param pac_data_out	  - [out] The decoded PAC
+*
+* @return - A NTSTATUS error code
+*/
+NTSTATUS kerberos_decode_pac(TALLOC_CTX *mem_ctx,
+			     DATA_BLOB pac_data_blob,
+			     krb5_context context,
+			     const krb5_keyblock *krbtgt_keyblock,
+			     const krb5_keyblock *service_keyblock,
+			     krb5_const_principal client_principal,
+			     time_t tgs_authtime,
+			     struct PAC_DATA **pac_data_out)
+{
+	NTSTATUS status;
+	enum ndr_err_code ndr_err;
+	krb5_error_code ret;
+	DATA_BLOB modified_pac_blob;
+
+	NTTIME tgs_authtime_nttime;
+	int i;
+
+	struct PAC_SIGNATURE_DATA *srv_sig_ptr = NULL;
+	struct PAC_SIGNATURE_DATA *kdc_sig_ptr = NULL;
+	struct PAC_SIGNATURE_DATA *srv_sig_wipe = NULL;
+	struct PAC_SIGNATURE_DATA *kdc_sig_wipe = NULL;
+	struct PAC_LOGON_NAME *logon_name = NULL;
+	struct PAC_LOGON_INFO *logon_info = NULL;
+	struct PAC_DATA *pac_data = NULL;
+	struct PAC_DATA_RAW *pac_data_raw = NULL;
+
+	DATA_BLOB *srv_sig_blob = NULL;
+	DATA_BLOB *kdc_sig_blob = NULL;
+
+	bool bool_ret;
+
+	TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+	if (!tmp_ctx) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	if (pac_data_out) {
+		*pac_data_out = NULL;
+	}
+
+	pac_data = talloc(tmp_ctx, struct PAC_DATA);
+	pac_data_raw = talloc(tmp_ctx, struct PAC_DATA_RAW);
+	kdc_sig_wipe = talloc(tmp_ctx, struct PAC_SIGNATURE_DATA);
+	srv_sig_wipe = talloc(tmp_ctx, struct PAC_SIGNATURE_DATA);
+	if (!pac_data_raw || !pac_data || !kdc_sig_wipe || !srv_sig_wipe) {
+		talloc_free(tmp_ctx);
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	ndr_err = ndr_pull_struct_blob(&pac_data_blob, pac_data, pac_data,
+		       (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't parse the PAC: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	if (pac_data->num_buffers < 4) {
+		/* we need logon_info, service_key and kdc_key */
+		DEBUG(0,("less than 4 PAC buffers\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	ndr_err = ndr_pull_struct_blob(
+				&pac_data_blob, pac_data_raw, pac_data_raw,
+				(ndr_pull_flags_fn_t)ndr_pull_PAC_DATA_RAW);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't parse the PAC: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	if (pac_data_raw->num_buffers < 4) {
+		/* we need logon_info, service_key and kdc_key */
+		DEBUG(0,("less than 4 PAC buffers\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	if (pac_data->num_buffers != pac_data_raw->num_buffers) {
+		/* we need logon_info, service_key and kdc_key */
+		DEBUG(0, ("misparse! PAC_DATA has %d buffers while "
+			  "PAC_DATA_RAW has %d\n", pac_data->num_buffers,
+			  pac_data_raw->num_buffers));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	for (i=0; i < pac_data->num_buffers; i++) {
+		struct PAC_BUFFER *data_buf = &pac_data->buffers[i];
+		struct PAC_BUFFER_RAW *raw_buf = &pac_data_raw->buffers[i];
+
+		if (data_buf->type != raw_buf->type) {
+			DEBUG(0, ("misparse! PAC_DATA buffer %d has type "
+				  "%d while PAC_DATA_RAW has %d\n", i,
+				  data_buf->type, raw_buf->type));
+			talloc_free(tmp_ctx);
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+		switch (data_buf->type) {
+		case PAC_TYPE_LOGON_INFO:
+			if (!data_buf->info) {
+				break;
+			}
+			logon_info = data_buf->info->logon_info.info;
+			break;
+		case PAC_TYPE_SRV_CHECKSUM:
+			if (!data_buf->info) {
+				break;
+			}
+			srv_sig_ptr = &data_buf->info->srv_cksum;
+			srv_sig_blob = &raw_buf->info->remaining;
+			break;
+		case PAC_TYPE_KDC_CHECKSUM:
+			if (!data_buf->info) {
+				break;
+			}
+			kdc_sig_ptr = &data_buf->info->kdc_cksum;
+			kdc_sig_blob = &raw_buf->info->remaining;
+			break;
+		case PAC_TYPE_LOGON_NAME:
+			logon_name = &data_buf->info->logon_name;
+			break;
+		default:
+			break;
+		}
+	}
+
+	if (!logon_info) {
+		DEBUG(0,("PAC no logon_info\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	if (!logon_name) {
+		DEBUG(0,("PAC no logon_name\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	if (!srv_sig_ptr || !srv_sig_blob) {
+		DEBUG(0,("PAC no srv_key\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	if (!kdc_sig_ptr || !kdc_sig_blob) {
+		DEBUG(0,("PAC no kdc_key\n"));
+		talloc_free(tmp_ctx);
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	/* Find and zero out the signatures,
+	 * as required by the signing algorithm */
+
+	/* We find the data blobs above,
+	 * now we parse them to get at the exact portion we should zero */
+	ndr_err = ndr_pull_struct_blob(
+			kdc_sig_blob, kdc_sig_wipe, kdc_sig_wipe,
+			(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't parse the KDC signature: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	ndr_err = ndr_pull_struct_blob(
+			srv_sig_blob, srv_sig_wipe, srv_sig_wipe,
+			(ndr_pull_flags_fn_t)ndr_pull_PAC_SIGNATURE_DATA);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't parse the SRV signature: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	/* Now zero the decoded structure */
+	memset(kdc_sig_wipe->signature.data,
+		'\0', kdc_sig_wipe->signature.length);
+	memset(srv_sig_wipe->signature.data,
+		'\0', srv_sig_wipe->signature.length);
+
+	/* and re-encode, back into the same place it came from */
+	ndr_err = ndr_push_struct_blob(
+			kdc_sig_blob, pac_data_raw, kdc_sig_wipe,
+			(ndr_push_flags_fn_t)ndr_push_PAC_SIGNATURE_DATA);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't repack the KDC signature: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+	ndr_err = ndr_push_struct_blob(
+			srv_sig_blob, pac_data_raw, srv_sig_wipe,
+			(ndr_push_flags_fn_t)ndr_push_PAC_SIGNATURE_DATA);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't repack the SRV signature: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	/* push out the whole structure, but now with zero'ed signatures */
+	ndr_err = ndr_push_struct_blob(
+			&modified_pac_blob, pac_data_raw, pac_data_raw,
+			(ndr_push_flags_fn_t)ndr_push_PAC_DATA_RAW);
+	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+		status = ndr_map_error2ntstatus(ndr_err);
+		DEBUG(0,("can't repack the RAW PAC: %s\n",
+			nt_errstr(status)));
+		talloc_free(tmp_ctx);
+		return status;
+	}
+
+	if (service_keyblock) {
+		/* verify by service_key */
+		ret = check_pac_checksum(modified_pac_blob, srv_sig_ptr,
+					 context,
+					 service_keyblock);
+		if (ret) {
+			DEBUG(5, ("PAC Decode: Failed to verify the service "
+				  "signature: %s\n", error_message(ret)));
+			return NT_STATUS_ACCESS_DENIED;
+		}
+
+		if (krbtgt_keyblock) {
+			/* verify the service key checksum by krbtgt_key */
+			ret = check_pac_checksum(srv_sig_ptr->signature, kdc_sig_ptr,
+						 context, krbtgt_keyblock);
+			if (ret) {
+				DEBUG(1, ("PAC Decode: Failed to verify the KDC signature: %s\n",
+					  smb_get_krb5_error_message(context, ret, tmp_ctx)));
+				talloc_free(tmp_ctx);
+				return NT_STATUS_ACCESS_DENIED;
+			}
+		}
+	}
+
+	if (tgs_authtime) {
+		/* Convert to NT time, so as not to lose accuracy in comparison */
+		unix_to_nt_time(&tgs_authtime_nttime, tgs_authtime);
+
+		if (tgs_authtime_nttime != logon_name->logon_time) {
+			DEBUG(2, ("PAC Decode: "
+				  "Logon time mismatch between ticket and PAC!\n"));
+			DEBUG(2, ("PAC Decode: PAC: %s\n",
+				  nt_time_string(tmp_ctx, logon_name->logon_time)));
+			DEBUG(2, ("PAC Decode: Ticket: %s\n",
+				  nt_time_string(tmp_ctx, tgs_authtime_nttime)));
+			talloc_free(tmp_ctx);
+			return NT_STATUS_ACCESS_DENIED;
+		}
+	}
+
+	if (client_principal) {
+		char *client_principal_string;
+		ret = krb5_unparse_name_flags(context, client_principal,
+					      KRB5_PRINCIPAL_UNPARSE_NO_REALM|KRB5_PRINCIPAL_UNPARSE_DISPLAY,
+					      &client_principal_string);
+		if (ret) {
+			DEBUG(2, ("Could not unparse name from ticket to match with name from PAC: [%s]:%s\n",
+				  logon_name->account_name, error_message(ret)));
+			talloc_free(tmp_ctx);
+			return NT_STATUS_INVALID_PARAMETER;
+		}
+
+		bool_ret = strcmp(client_principal_string, logon_name->account_name) == 0;
+
+		if (!bool_ret) {
+			DEBUG(2, ("Name in PAC [%s] does not match principal name "
+				  "in ticket [%s]\n",
+				  logon_name->account_name,
+				  client_principal_string));
+			SAFE_FREE(client_principal_string);
+			talloc_free(tmp_ctx);
+			return NT_STATUS_ACCESS_DENIED;
+		}
+		SAFE_FREE(client_principal_string);
+
+	}
+
+	DEBUG(3,("Found account name from PAC: %s [%s]\n",
+		 logon_info->info3.base.account_name.string,
+		 logon_info->info3.base.full_name.string));
+
+	DEBUG(10,("Successfully validated Kerberos PAC\n"));
+
+	if (DEBUGLEVEL >= 10) {
+		const char *s;
+		s = NDR_PRINT_STRUCT_STRING(tmp_ctx, PAC_DATA, pac_data);
+		if (s) {
+			DEBUGADD(10,("%s\n", s));
+		}
+	}
+
+	if (pac_data_out) {
+		*pac_data_out = talloc_steal(mem_ctx, pac_data);
+	}
+
+	return NT_STATUS_OK;
+}
+
+NTSTATUS kerberos_pac_logon_info(TALLOC_CTX *mem_ctx,
+				 DATA_BLOB blob,
+				 krb5_context context,
+				 const krb5_keyblock *krbtgt_keyblock,
+				 const krb5_keyblock *service_keyblock,
+				 krb5_const_principal client_principal,
+				 time_t tgs_authtime,
+				 struct PAC_LOGON_INFO **logon_info)
+{
+	NTSTATUS nt_status;
+	struct PAC_DATA *pac_data;
+	int i;
+	nt_status = kerberos_decode_pac(mem_ctx,
+					blob,
+					context,
+					krbtgt_keyblock,
+					service_keyblock,
+					client_principal,
+					tgs_authtime,
+					&pac_data);
+	if (!NT_STATUS_IS_OK(nt_status)) {
+		return nt_status;
+	}
+
+	*logon_info = NULL;
+	for (i=0; i < pac_data->num_buffers; i++) {
+		if (pac_data->buffers[i].type != PAC_TYPE_LOGON_INFO) {
+			continue;
+		}
+		*logon_info = pac_data->buffers[i].info->logon_info.info;
+	}
+	if (!*logon_info) {
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS auth4_context_fetch_PAC_DATA_CTR(
+				struct auth4_context *auth_ctx,
+				TALLOC_CTX *mem_ctx,
+				struct smb_krb5_context *smb_krb5_context,
+				DATA_BLOB *pac_blob,
+				const char *princ_name,
+				const struct tsocket_address *remote_address,
+				uint32_t session_info_flags,
+				struct auth_session_info **session_info)
+{
+	struct PAC_DATA_CTR *pac_data_ctr = NULL;
+	NTSTATUS status;
+
+	if (pac_blob == NULL) {
+		return NT_STATUS_NO_IMPERSONATION_TOKEN;
+	}
+
+	pac_data_ctr = talloc_zero(mem_ctx, struct PAC_DATA_CTR);
+	if (pac_data_ctr == NULL) {
+		status = NT_STATUS_NO_MEMORY;
+		goto fail;
+	}
+
+	status = kerberos_decode_pac(pac_data_ctr,
+				     *pac_blob,
+				     NULL,
+				     NULL,
+				     NULL,
+				     NULL,
+				     0,
+				     &pac_data_ctr->pac_data);
+	if (!NT_STATUS_IS_OK(status)) {
+		goto fail;
+	}
+
+	pac_data_ctr->pac_blob = data_blob_talloc(pac_data_ctr,
+						  pac_blob->data,
+						  pac_blob->length);
+	if (pac_data_ctr->pac_blob.length != pac_blob->length) {
+		status = NT_STATUS_NO_MEMORY;
+		goto fail;
+	}
+
+	*session_info = talloc_zero(mem_ctx, struct auth_session_info);
+	if (*session_info == NULL) {
+		status = NT_STATUS_NO_MEMORY;
+		goto fail;
+	}
+
+	TALLOC_FREE(auth_ctx->private_data);
+	auth_ctx->private_data = talloc_move(auth_ctx, &pac_data_ctr);
+
+	return NT_STATUS_OK;
+
+fail:
+	TALLOC_FREE(pac_data_ctr);
+
+	return status;
+}
+
+struct auth4_context *auth4_context_for_PAC_DATA_CTR(TALLOC_CTX *mem_ctx)
+{
+	struct auth4_context *auth_ctx = NULL;
+
+	auth_ctx = talloc_zero(mem_ctx, struct auth4_context);
+	if (auth_ctx == NULL) {
+		return NULL;
+	}
+	auth_ctx->generate_session_info_pac = auth4_context_fetch_PAC_DATA_CTR;
+
+	return auth_ctx;
+}
+
+struct PAC_DATA_CTR *auth4_context_get_PAC_DATA_CTR(struct auth4_context *auth_ctx,
+						    TALLOC_CTX *mem_ctx)
+{
+	struct PAC_DATA_CTR *p = NULL;
+	SMB_ASSERT(auth_ctx->generate_session_info_pac == auth4_context_fetch_PAC_DATA_CTR);
+	p = talloc_get_type_abort(auth_ctx->private_data, struct PAC_DATA_CTR);
+	auth_ctx->private_data = NULL;
+	return talloc_move(mem_ctx, &p);
+}
+
+#endif
diff --git a/auth/kerberos/pac_utils.h b/auth/kerberos/pac_utils.h
new file mode 100644
index 0000000..36fd60c
--- /dev/null
+++ b/auth/kerberos/pac_utils.h
@@ -0,0 +1,81 @@
+/*
+   Unix SMB/CIFS implementation.
+   kerberos authorization data (PAC) utility library
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2011
+   Copyright (C) Simo Sorce 2010-2012
+
+   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 3 of the License, or
+   (at your option) any later version.
+
+   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.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PAC_UTILS_H
+#define _PAC_UTILS_H
+
+#ifdef HAVE_KRB5
+
+#include "lib/krb5_wrap/krb5_samba.h"
+#include "lib/krb5_wrap/gss_samba.h"
+
+struct PAC_SIGNATURE_DATA;
+struct PAC_DATA;
+struct PAC_LOGON_INFO;
+
+krb5_error_code check_pac_checksum(DATA_BLOB pac_data,
+				   struct PAC_SIGNATURE_DATA *sig,
+				   krb5_context context,
+				   const krb5_keyblock *keyblock);
+
+NTSTATUS kerberos_decode_pac(TALLOC_CTX *mem_ctx,
+			     DATA_BLOB pac_data_blob,
+			     krb5_context context,
+			     const krb5_keyblock *krbtgt_keyblock,
+			     const krb5_keyblock *service_keyblock,
+			     krb5_const_principal client_principal,
+			     time_t tgs_authtime,
+			     struct PAC_DATA **pac_data_out);
+
+NTSTATUS kerberos_pac_logon_info(TALLOC_CTX *mem_ctx,
+				 DATA_BLOB blob,
+				 krb5_context context,
+				 const krb5_keyblock *krbtgt_keyblock,
+				 const krb5_keyblock *service_keyblock,
+				 krb5_const_principal client_principal,
+				 time_t tgs_authtime,
+				 struct PAC_LOGON_INFO **logon_info);
+
+struct PAC_DATA;
+struct PAC_DATA_CTR {
+	DATA_BLOB pac_blob;
+	struct PAC_DATA *pac_data;
+};
+
+struct auth4_context *auth4_context_for_PAC_DATA_CTR(TALLOC_CTX *mem_ctx);
+struct PAC_DATA_CTR *auth4_context_get_PAC_DATA_CTR(struct auth4_context *auth_ctx,
+						    TALLOC_CTX *mem_ctx);
+
+NTSTATUS gssapi_obtain_pac_blob(TALLOC_CTX *mem_ctx,
+				gss_ctx_id_t gssapi_context,
+				gss_name_t gss_client_name,
+				DATA_BLOB *pac_data);
+NTSTATUS gssapi_get_session_key(TALLOC_CTX *mem_ctx,
+				gss_ctx_id_t gssapi_context,
+				DATA_BLOB *session_key,
+				uint32_t *keytype);
+
+/* not the best place here, need to move to a more generic gssapi
+ * wrapper later */
+char *gssapi_error_string(TALLOC_CTX *mem_ctx,
+			  OM_uint32 maj_stat, OM_uint32 min_stat,
+			  const gss_OID mech);
+#endif /* HAVE_KRB5 */
+#endif /* _PAC_UTILS_H */
diff --git a/auth/kerberos/wscript_build b/auth/kerberos/wscript_build
new file mode 100644
index 0000000..bf8b05c
--- /dev/null
+++ b/auth/kerberos/wscript_build
@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+bld.SAMBA_SUBSYSTEM('KRB5_PAC',
+                    source='gssapi_pac.c kerberos_pac.c gssapi_helper.c',
+                    deps='gssapi ndr-krb5pac krb5samba')