/*

 * OpenConnect (SSL + DTLS) VPN client

 *

 * Copyright © 2012 Free Software Foundation.

 * Copyright © 2008-2012 Intel Corporation.

 * Copyright © 2015-2016 Red Hat, Inc.

 *

 * Author: David Woodhouse <dwmw2@infradead.org>

 * Author: Nikos Mavrogiannopoulos

 *

 * GnuTLS is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public License

 * as published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>

 *

 */

/*

 * TPM code based on client-tpm.c from

 * Carolin Latze <latze@angry-red-pla.net> and Tobias Soder

 */

#include <config.h>

#include <gnutls/gnutls.h>

#include <gnutls/abstract.h>

#include <gnutls/tpm.h>

#include "gnutls_int.h"

#ifdef HAVE_TROUSERS

#include "errors.h"

#include <pkcs11_int.h>

#include <x509/common.h>

#include <x509_b64.h>

#include <random.h>

#include <pin.h>

#include <c-ctype.h>

#include <dlfcn.h>

#include <trousers/tss.h>

#include <trousers/trousers.h>

typedef char *(*Trspi_Error_Layer_func)(TSS_RESULT);

typedef char *(*Trspi_Error_String_func)(TSS_RESULT);

typedef TSS_RESULT (*Trspi_Error_Code_func)(TSS_RESULT);

typedef TSS_RESULT (*Tspi_Context_CloseObject_func)(TSS_HCONTEXT, TSS_HOBJECT);

typedef TSS_RESULT (*Tspi_Context_Close_func)(TSS_HCONTEXT);

typedef TSS_RESULT (*Tspi_Context_CreateObject_func)(TSS_HCONTEXT, TSS_FLAG, TSS_FLAG, TSS_HOBJECT*);

typedef TSS_RESULT (*Tspi_Context_FreeMemory_func)(TSS_HCONTEXT, BYTE*);

typedef TSS_RESULT (*Tspi_Context_GetTpmObject_func)(TSS_HCONTEXT, TSS_HTPM*);

typedef TSS_RESULT (*Tspi_Context_LoadKeyByUUID_func)(TSS_HCONTEXT, TSS_FLAG, TSS_UUID, TSS_HKEY*);

typedef TSS_RESULT (*Tspi_Context_RegisterKey_func)(TSS_HCONTEXT, TSS_HKEY, TSS_FLAG, TSS_UUID, TSS_FLAG, TSS_UUID);

typedef TSS_RESULT (*Tspi_Context_UnregisterKey_func)(TSS_HCONTEXT, TSS_FLAG, TSS_UUID, TSS_HKEY*);

typedef TSS_RESULT (*Tspi_Key_CreateKey_func)(TSS_HKEY, TSS_HKEY, TSS_HPCRS);

typedef TSS_RESULT (*Tspi_Hash_SetHashValue_func)(TSS_HHASH, UINT32, BYTE*);

typedef TSS_RESULT (*Tspi_Hash_Sign_func)(TSS_HHASH, TSS_HKEY, UINT32*, BYTE**);

typedef TSS_RESULT (*Tspi_Policy_SetSecret_func)(TSS_HPOLICY, TSS_FLAG, UINT32, BYTE*);

typedef TSS_RESULT (*Tspi_Context_Create_func)(TSS_HCONTEXT*);

typedef TSS_RESULT (*Tspi_Context_Connect_func)(TSS_HCONTEXT, TSS_UNICODE*);

typedef TSS_RESULT (*Tspi_GetPolicyObject_func)(TSS_HOBJECT, TSS_FLAG, TSS_HPOLICY*);

typedef TSS_RESULT (*Tspi_DecodeBER_TssBlob_func)(UINT32, BYTE*, UINT32*, UINT32*, BYTE*);

typedef TSS_RESULT (*Tspi_Context_LoadKeyByBlob_func)(TSS_HCONTEXT, TSS_HKEY, UINT32, BYTE*, TSS_HKEY*);

typedef TSS_RESULT (*Tspi_Policy_AssignToObject_func)(TSS_HPOLICY, TSS_HOBJECT);

typedef TSS_RESULT (*Tspi_GetAttribData_func)(TSS_HOBJECT, TSS_FLAG, TSS_FLAG, UINT32*, BYTE**);

typedef TSS_RESULT (*Tspi_GetAttribUint32_func)(TSS_HOBJECT, TSS_FLAG, TSS_FLAG, UINT32*);

typedef TSS_RESULT (*Tspi_TPM_StirRandom_func)(TSS_HTPM, UINT32, BYTE*);

typedef TSS_RESULT (*Tspi_SetAttribUint32_func)(TSS_HOBJECT, TSS_FLAG, TSS_FLAG, UINT32);

typedef TSS_RESULT (*Tspi_EncodeDER_TssBlob_func)(UINT32, BYTE*, UINT32, UINT32*, BYTE*);

typedef TSS_RESULT (*Tspi_Context_GetRegisteredKeysByUUID2_func)(TSS_HCONTEXT, TSS_FLAG, TSS_UUID*, UINT32*, TSS_KM_KEYINFO2**);

static Tspi_Context_CloseObject_func pTspi_Context_CloseObject;

static Tspi_Context_Close_func pTspi_Context_Close;

static Tspi_Context_CreateObject_func pTspi_Context_CreateObject;

static Tspi_Context_FreeMemory_func pTspi_Context_FreeMemory;

static Tspi_Context_GetTpmObject_func pTspi_Context_GetTpmObject;

static Tspi_Context_LoadKeyByUUID_func pTspi_Context_LoadKeyByUUID;

static Tspi_Context_RegisterKey_func pTspi_Context_RegisterKey;

static Tspi_Context_UnregisterKey_func pTspi_Context_UnregisterKey;

static Tspi_Key_CreateKey_func pTspi_Key_CreateKey;

static Tspi_Hash_SetHashValue_func pTspi_Hash_SetHashValue;

static Tspi_Hash_Sign_func pTspi_Hash_Sign;

static Tspi_Policy_SetSecret_func pTspi_Policy_SetSecret;

static Tspi_Context_Create_func pTspi_Context_Create;

static Tspi_Context_Connect_func pTspi_Context_Connect;

static Tspi_GetPolicyObject_func pTspi_GetPolicyObject;

static Tspi_DecodeBER_TssBlob_func pTspi_DecodeBER_TssBlob;

static Tspi_Context_LoadKeyByBlob_func pTspi_Context_LoadKeyByBlob;

static Tspi_Policy_AssignToObject_func pTspi_Policy_AssignToObject;

static Tspi_GetAttribData_func pTspi_GetAttribData;

static Tspi_GetAttribUint32_func pTspi_GetAttribUint32;

static Tspi_Context_GetTpmObject_func pTspi_Context_GetTpmObject;

static Tspi_TPM_StirRandom_func pTspi_TPM_StirRandom;

static Tspi_SetAttribUint32_func pTspi_SetAttribUint32;

static Tspi_EncodeDER_TssBlob_func pTspi_EncodeDER_TssBlob;

static Tspi_Context_GetRegisteredKeysByUUID2_func pTspi_Context_GetRegisteredKeysByUUID2;

static Trspi_Error_Layer_func pTrspi_Error_Layer;

static Trspi_Error_String_func pTrspi_Error_String;

static Trspi_Error_Code_func pTrspi_Error_Code;

static void *tpm_dl = NULL;

#define _DLSYM(dl, sym) \

	p##sym = dlsym(dl, #sym); \

	if (p##sym == NULL) { \

		dlclose(dl); \

		dl = NULL; \

		return -1; \

	}

static int check_init(void)

{

	if (tpm_dl == NULL) {

		tpm_dl = dlopen(TROUSERS_LIB, RTLD_LAZY);

		if (tpm_dl == NULL) {

			_gnutls_debug_log("couldn't open %s\n", TROUSERS_LIB);

			return -1;

		}

		_DLSYM(tpm_dl,Tspi_Context_CloseObject);

		_DLSYM(tpm_dl,Tspi_Context_Close);

		_DLSYM(tpm_dl,Tspi_Context_CreateObject);

		_DLSYM(tpm_dl,Tspi_Context_FreeMemory);

		_DLSYM(tpm_dl,Tspi_Context_GetTpmObject);

		_DLSYM(tpm_dl,Tspi_Context_LoadKeyByUUID);

		_DLSYM(tpm_dl,Tspi_Context_RegisterKey);

		_DLSYM(tpm_dl,Tspi_Context_UnregisterKey);

		_DLSYM(tpm_dl,Tspi_Key_CreateKey);

		_DLSYM(tpm_dl,Tspi_Hash_SetHashValue);

		_DLSYM(tpm_dl,Tspi_Hash_Sign);

		_DLSYM(tpm_dl,Tspi_Policy_SetSecret);

		_DLSYM(tpm_dl,Tspi_Context_Create);

		_DLSYM(tpm_dl,Tspi_Context_Connect);

		_DLSYM(tpm_dl,Tspi_GetPolicyObject);

		_DLSYM(tpm_dl,Tspi_DecodeBER_TssBlob);

		_DLSYM(tpm_dl,Tspi_Context_LoadKeyByBlob);

		_DLSYM(tpm_dl,Tspi_Policy_AssignToObject);

		_DLSYM(tpm_dl,Tspi_GetAttribData);

		_DLSYM(tpm_dl,Tspi_GetAttribUint32);

		_DLSYM(tpm_dl,Tspi_Context_GetTpmObject);

		_DLSYM(tpm_dl,Tspi_TPM_StirRandom);

		_DLSYM(tpm_dl,Tspi_SetAttribUint32);

		_DLSYM(tpm_dl,Tspi_EncodeDER_TssBlob);

		_DLSYM(tpm_dl,Tspi_Context_GetRegisteredKeysByUUID2);

		_DLSYM(tpm_dl,Trspi_Error_Layer);

		_DLSYM(tpm_dl,Trspi_Error_String);

		_DLSYM(tpm_dl,Trspi_Error_Code);

	}

	return 0;

}

#define CHECK_INIT \

		if (check_init() < 0) return gnutls_assert_val(GNUTLS_E_TPM_NO_LIB)

#define CHECK_INIT_VOID \

		if (check_init() < 0) return

void _gnutls_tpm_global_deinit(void)

{

	if (tpm_dl) {

		dlclose(tpm_dl);

		tpm_dl = NULL;

	}

}

struct tpm_ctx_st {

	TSS_HCONTEXT tpm_ctx;

	TSS_HKEY tpm_key;

	TSS_HPOLICY tpm_key_policy;

	TSS_HKEY srk;

	TSS_HPOLICY srk_policy;

};

struct tpm_key_list_st {

	UINT32 size;

	TSS_KM_KEYINFO2 *ki;

	TSS_HCONTEXT tpm_ctx;

};

static void tpm_close_session(struct tpm_ctx_st *s);

static int import_tpm_key(gnutls_privkey_t pkey,

			  const gnutls_datum_t * fdata,

			  gnutls_tpmkey_fmt_t format,

			  TSS_UUID * uuid,

			  TSS_FLAG storage_type,

			  const char *srk_password,

			  const char *key_password);

static int encode_tpmkey_url(char **url, const TSS_UUID * uuid,

			     TSS_FLAG storage);

/* TPM URL format: (draft-mavrogiannopoulos-tpmuri-01)

 *

 * tpmkey:file=/path/to/file

 * tpmkey:uuid=7f468c16-cb7f-11e1-824d-b3a4f4b20343;storage=user

 * tpmkey:uuid=7f468c16-cb7f-11e1-824d-b3a4f4b20343;storage=system

 *

 */

static int tss_err_pwd(TSS_RESULT err, int pwd_error)

{

	_gnutls_debug_log("TPM (%s) error: %s (%x)\n",

			  pTrspi_Error_Layer(err), pTrspi_Error_String(err),

			  (unsigned int) pTrspi_Error_Code(err));

	switch (ERROR_LAYER(err)) {

	case TSS_LAYER_TPM:

		switch (ERROR_CODE(err)) {

		case TPM_E_AUTHFAIL:

			return pwd_error;

		case TPM_E_NOSRK:

			return GNUTLS_E_TPM_UNINITIALIZED;

		default:

			return gnutls_assert_val(GNUTLS_E_TPM_ERROR);

		}

	case TSS_LAYER_TCS:

	case TSS_LAYER_TSP:

		switch (ERROR_CODE(err)) {

		case TSS_E_COMM_FAILURE:

		case TSS_E_NO_CONNECTION:

		case TSS_E_CONNECTION_FAILED:

		case TSS_E_CONNECTION_BROKEN:

			return GNUTLS_E_TPM_SESSION_ERROR;

		case TSS_E_PS_KEY_NOTFOUND:

			return GNUTLS_E_TPM_KEY_NOT_FOUND;

		default:

			return gnutls_assert_val(GNUTLS_E_TPM_ERROR);

		}

	default:

		return gnutls_assert_val(GNUTLS_E_TPM_ERROR);

	}

}

#define tss_err(x) tss_err_pwd(x, GNUTLS_E_TPM_SRK_PASSWORD_ERROR)

#define tss_err_key(x) tss_err_pwd(x, GNUTLS_E_TPM_KEY_PASSWORD_ERROR)

static void tpm_deinit_fn(gnutls_privkey_t key, void *_s)

{

	struct tpm_ctx_st *s = _s;

	pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key_policy);

	pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key);

	tpm_close_session(s);

	gnutls_free(s);

}

static int

tpm_sign_fn(gnutls_privkey_t key, void *_s,

	    const gnutls_datum_t * data, gnutls_datum_t * sig)

{

	struct tpm_ctx_st *s = _s;

	TSS_HHASH hash;

	int err;

	_gnutls_debug_log("TPM sign function called for %u bytes.\n",

			  data->size);

	err =

	    pTspi_Context_CreateObject(s->tpm_ctx,

				      TSS_OBJECT_TYPE_HASH, TSS_HASH_OTHER,

				      &hash);

	if (err) {

		gnutls_assert();

		_gnutls_debug_log("Failed to create TPM hash object: %s\n",

				  pTrspi_Error_String(err));

		return GNUTLS_E_PK_SIGN_FAILED;

	}

	err = pTspi_Hash_SetHashValue(hash, data->size, data->data);

	if (err) {

		gnutls_assert();

		_gnutls_debug_log

		    ("Failed to set value in TPM hash object: %s\n",

		     pTrspi_Error_String(err));

		pTspi_Context_CloseObject(s->tpm_ctx, hash);

		return GNUTLS_E_PK_SIGN_FAILED;

	}

	err = pTspi_Hash_Sign(hash, s->tpm_key, &sig->size, &sig->data);

	pTspi_Context_CloseObject(s->tpm_ctx, hash);

	if (err) {

		if (s->tpm_key_policy || err != TPM_E_AUTHFAIL)

			_gnutls_debug_log

			    ("TPM hash signature failed: %s\n",

			     pTrspi_Error_String(err));

		if (err == TPM_E_AUTHFAIL)

			return GNUTLS_E_TPM_KEY_PASSWORD_ERROR;

		else

			return GNUTLS_E_PK_SIGN_FAILED;

	}

	return 0;

}

static const unsigned char nullpass[20];

static const gnutls_datum_t nulldata = { (void *) nullpass, 20 };

const TSS_UUID srk_uuid = TSS_UUID_SRK;

static int tpm_pin(struct pin_info_st *pin_info, const TSS_UUID * uuid,

		   TSS_FLAG storage, char *pin, unsigned int pin_size,

		   unsigned int attempts)

{

	unsigned int flags = 0;

	const char *label;

	char *url = NULL;

	int ret;

	if (attempts > 0)

		flags |= GNUTLS_PIN_WRONG;

	if (uuid) {

		if (memcmp(uuid, &srk_uuid, sizeof(TSS_UUID)) == 0) {

			label = "SRK";

			ret = encode_tpmkey_url(&url, uuid, storage);

			if (ret < 0)

				return gnutls_assert_val(ret);

		} else {

			label = "TPM";

			ret = encode_tpmkey_url(&url, uuid, storage);

			if (ret < 0)

				return gnutls_assert_val(ret);

		}

	} else

		label = "unknown";

	ret = _gnutls_retrieve_pin(pin_info, url, label, flags, pin, pin_size);

	if (ret < 0) {

		gnutls_assert();

		goto cleanup;

	}

	ret = 0;

      cleanup:

	gnutls_free(url);

	return ret;

}

static TSS_RESULT myTspi_Policy_SetSecret(TSS_HPOLICY hPolicy,

					  UINT32 ulSecretLength,

					  BYTE * rgbSecret)

{

	if (rgbSecret == NULL) {

		/* Well known NULL key */

		return pTspi_Policy_SetSecret(hPolicy,

					     TSS_SECRET_MODE_SHA1,

					     sizeof(nullpass),

					     (BYTE *) nullpass);

	} else {		/* key is given */

		return pTspi_Policy_SetSecret(hPolicy,

					     TSS_SECRET_MODE_PLAIN,

					     ulSecretLength, rgbSecret);

	}

}

#define SAFE_LEN(x) (x==NULL?0:strlen(x))

static int tpm_open_session(struct tpm_ctx_st *s, const char *_srk_password, unsigned allow_invalid_pass)

{

	int err, ret;

	char *password = NULL;

	err = pTspi_Context_Create(&s->tpm_ctx);

	if (err) {

		gnutls_assert();

		return tss_err(err);

	}

	if (_srk_password != NULL) {

		gnutls_datum_t pout;

		ret = _gnutls_utf8_password_normalize(_srk_password, strlen(_srk_password), &pout, allow_invalid_pass);

		if (ret < 0) {

			gnutls_assert();

			goto out_tspi_ctx;

		}

		password = (char*)pout.data;

	}

	err = pTspi_Context_Connect(s->tpm_ctx, NULL);

	if (err) {

		gnutls_assert();

		ret = tss_err(err);

		goto out_tspi_ctx;

	}

	err =

	    pTspi_Context_LoadKeyByUUID(s->tpm_ctx, TSS_PS_TYPE_SYSTEM,

				       srk_uuid, &s->srk);

	if (err) {

		gnutls_assert();

		ret = tss_err(err);

		goto out_tspi_ctx;

	}

	err =

	    pTspi_GetPolicyObject(s->srk, TSS_POLICY_USAGE, &s->srk_policy);

	if (err) {

		gnutls_assert();

		ret = tss_err(err);

		goto out_srk;

	}

	err = myTspi_Policy_SetSecret(s->srk_policy,

				      SAFE_LEN(password),

				      (BYTE *) password);

	if (err) {

		gnutls_assert();

		ret = tss_err(err);

		goto out_srkpol;

	}

	gnutls_free(password);

	return 0;

      out_srkpol:

	pTspi_Context_CloseObject(s->tpm_ctx, s->srk_policy);

	s->srk_policy = 0;

      out_srk:

	pTspi_Context_CloseObject(s->tpm_ctx, s->srk);

	s->srk = 0;

      out_tspi_ctx:

	pTspi_Context_Close(s->tpm_ctx);

	s->tpm_ctx = 0;

	gnutls_free(password);

	return ret;

}

static void tpm_close_session(struct tpm_ctx_st *s)

{

	pTspi_Context_CloseObject(s->tpm_ctx, s->srk_policy);

	s->srk_policy = 0;

	pTspi_Context_CloseObject(s->tpm_ctx, s->srk);

	s->srk = 0;

	pTspi_Context_Close(s->tpm_ctx);

	s->tpm_ctx = 0;

}

static int

import_tpm_key_cb(gnutls_privkey_t pkey, const gnutls_datum_t * fdata,

		  gnutls_tpmkey_fmt_t format, TSS_UUID * uuid,

		  TSS_FLAG storage, const char *srk_password,

		  const char *key_password)

{

	unsigned int attempts = 0;

	char pin1[GNUTLS_PKCS11_MAX_PIN_LEN];

	char pin2[GNUTLS_PKCS11_MAX_PIN_LEN];

	int ret, ret2;

	do {

		ret =

		    import_tpm_key(pkey, fdata, format, uuid, storage,

				   srk_password, key_password);

		if (attempts > 3)

			break;

		if (ret == GNUTLS_E_TPM_SRK_PASSWORD_ERROR) {

			ret2 =

			    tpm_pin(&pkey->pin, &srk_uuid, storage, pin1,

				    sizeof(pin1), attempts++);

			if (ret2 < 0) {

				gnutls_assert();

				return GNUTLS_E_TPM_SRK_PASSWORD_ERROR;

			}

			srk_password = pin1;

		}

		if (ret == GNUTLS_E_TPM_KEY_PASSWORD_ERROR) {

			ret2 =

			    tpm_pin(&pkey->pin, uuid, storage, pin2,

				    sizeof(pin2), attempts++);

			if (ret2 < 0) {

				gnutls_assert();

				return GNUTLS_E_TPM_KEY_PASSWORD_ERROR;

			}

			key_password = pin2;

		}

	}

	while (ret == GNUTLS_E_TPM_KEY_PASSWORD_ERROR

	       || ret == GNUTLS_E_TPM_SRK_PASSWORD_ERROR);

	if (ret < 0)

		gnutls_assert();

	return ret;

}

static int load_key(TSS_HCONTEXT tpm_ctx, TSS_HKEY srk,

		    const gnutls_datum_t * fdata,

		    gnutls_tpmkey_fmt_t format, TSS_HKEY * tpm_key)

{

	int ret, err;

	gnutls_datum_t asn1 = { NULL, 0 };

	if (format == GNUTLS_TPMKEY_FMT_CTK_PEM) {

		gnutls_datum_t td;

		ret =

		    gnutls_pem_base64_decode2("TSS KEY BLOB", fdata,

					      &asn1);

		if (ret) {

			gnutls_assert();

			_gnutls_debug_log

			    ("Error decoding TSS key blob: %s\n",

			     gnutls_strerror(ret));

			return ret;

		}

		ret =

		    _gnutls_x509_decode_string(ASN1_ETYPE_OCTET_STRING,

					       asn1.data, asn1.size, &td, 0);

		if (ret < 0) {

			gnutls_assert();

			goto cleanup;

		}

		gnutls_free(asn1.data);

		asn1.data = td.data;

		asn1.size = td.size;

	} else {		/* DER */

		UINT32 tint2;

		UINT32 type;

		asn1.size = fdata->size;

		asn1.data = gnutls_malloc(asn1.size);

		if (asn1.data == NULL) {

			gnutls_assert();

			return GNUTLS_E_MEMORY_ERROR;

		}

		tint2 = asn1.size;

		err =

		    pTspi_DecodeBER_TssBlob(fdata->size, fdata->data, &type,

					   &tint2, asn1.data);

		if (err != 0) {

			gnutls_assert();

			ret = tss_err(err);

			goto cleanup;

		}

		asn1.size = tint2;

	}

	/* ... we get it here instead. */

	err = pTspi_Context_LoadKeyByBlob(tpm_ctx, srk,

					 asn1.size, asn1.data, tpm_key);

	if (err != 0) {

		gnutls_assert();

		ret = tss_err(err);

		goto cleanup;

	}

	ret = 0;

      cleanup:

	gnutls_free(asn1.data);

	return ret;

}

static int

import_tpm_key(gnutls_privkey_t pkey,

	       const gnutls_datum_t * fdata,

	       gnutls_tpmkey_fmt_t format,

	       TSS_UUID * uuid,

	       TSS_FLAG storage,

	       const char *srk_password, const char *_key_password)

{

	int err, ret;

	struct tpm_ctx_st *s;

	gnutls_datum_t tmp_sig;

	char *key_password = NULL;

	uint32_t authusage;

	s = gnutls_malloc(sizeof(*s));

	if (s == NULL) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	if (_key_password != NULL) {

		gnutls_datum_t pout;

		ret = _gnutls_utf8_password_normalize(_key_password, strlen(_key_password), &pout, 1);

		if (ret < 0) {

			gnutls_assert();

			goto out_ctx;

		}

		key_password = (char*)pout.data;

	}

	/* normalization of srk_password happens in tpm_open_session() */

	ret = tpm_open_session(s, srk_password, 1);

	if (ret < 0) {

		gnutls_assert();

		goto out_ctx;

	}

	if (fdata != NULL) {

		ret =

		    load_key(s->tpm_ctx, s->srk, fdata, format,

			     &s->tpm_key);

		if (ret < 0) {

			gnutls_assert();

			goto out_session;

		}

	} else if (uuid) {

		err =

		    pTspi_Context_LoadKeyByUUID(s->tpm_ctx, storage,

					       *uuid, &s->tpm_key);

		if (err) {

			gnutls_assert();

			ret = tss_err(err);

			goto out_session;

		}

	} else {

		gnutls_assert();

		ret = GNUTLS_E_INVALID_REQUEST;

		goto out_session;

	}

	err = pTspi_GetAttribUint32(s->tpm_key, TSS_TSPATTRIB_KEY_INFO,

				    TSS_TSPATTRIB_KEYINFO_AUTHUSAGE,

				    &authusage);

	if (err) {

		gnutls_assert();

		ret = tss_err(err);

		goto out_session;

	}

	if (authusage) {

		if (!_key_password) {

			ret = GNUTLS_E_TPM_KEY_PASSWORD_ERROR;

			goto out_session;

		}

		err = pTspi_Context_CreateObject(s->tpm_ctx,

						 TSS_OBJECT_TYPE_POLICY,

						 TSS_POLICY_USAGE,

						 &s->tpm_key_policy);

		if (err) {

			gnutls_assert();

			ret = tss_err(err);

			goto out_key;

		}

		err = pTspi_Policy_AssignToObject(s->tpm_key_policy,

						       s->tpm_key);

		if (err) {

			gnutls_assert();

			ret = tss_err(err);

			goto out_key_policy;

		}

		err = myTspi_Policy_SetSecret(s->tpm_key_policy,

					      SAFE_LEN(key_password),

					      (void *) key_password);

		if (err) {

			gnutls_assert();

			ret = tss_err_key(err);

			goto out_key_policy;

		}

	}

	ret =

	    gnutls_privkey_import_ext2(pkey, GNUTLS_PK_RSA, s,

				       tpm_sign_fn, NULL, tpm_deinit_fn,

				       0);

	if (ret < 0) {

		gnutls_assert();

		goto out_session;

	}

	ret =

	    gnutls_privkey_sign_data(pkey, GNUTLS_DIG_SHA1, 0, &nulldata,

				     &tmp_sig);

	if (ret < 0) {

		gnutls_assert();

		goto out_session;

	}

	gnutls_free(key_password);

	return 0;

      out_key_policy:

	pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key_policy);

	s->tpm_key_policy = 0;

      out_key:

	pTspi_Context_CloseObject(s->tpm_ctx, s->tpm_key);

	s->tpm_key = 0;

      out_session:

	_gnutls_privkey_cleanup(pkey);

	tpm_close_session(s);

      out_ctx:

	gnutls_free(s);

	gnutls_free(key_password);

	return ret;

}

/**

 * gnutls_privkey_import_tpm_raw:

 * @pkey: The private key

 * @fdata: The TPM key to be imported

 * @format: The format of the private key

 * @srk_password: The password for the SRK key (optional)

 * @key_password: A password for the key (optional)

 * @flags: should be zero

 *

 * This function will import the given private key to the abstract

 * #gnutls_privkey_t type. 

 *

 * With respect to passwords the same as in gnutls_privkey_import_tpm_url() apply.

 *

 * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a

 *   negative error value.

 *

 * Since: 3.1.0

 *

 **/

int

gnutls_privkey_import_tpm_raw(gnutls_privkey_t pkey,

			      const gnutls_datum_t * fdata,

			      gnutls_tpmkey_fmt_t format,

			      const char *srk_password,

			      const char *key_password, unsigned int flags)

{

	CHECK_INIT;

	if (flags & GNUTLS_PRIVKEY_DISABLE_CALLBACKS)

		return import_tpm_key(pkey, fdata, format, NULL, 0,

				      srk_password, key_password);

	else

		return import_tpm_key_cb(pkey, fdata, format, NULL, 0,

					 srk_password, key_password);

}

struct tpmkey_url_st {

	char *filename;

	TSS_UUID uuid;

	TSS_FLAG storage;

	unsigned int uuid_set;

};

static void clear_tpmkey_url(struct tpmkey_url_st *s)

{

	gnutls_free(s->filename);

	memset(s, 0, sizeof(*s));

}

static int

unescape_string(char *output, const char *input, size_t * size,

		char terminator)

{

	gnutls_buffer_st str;

	int ret = 0;

	char *p;

	int len;

	_gnutls_buffer_init(&str);

	/* find terminator */

	p = strchr(input, terminator);

	if (p != NULL)

		len = p - input;

	else

		len = strlen(input);

	ret = _gnutls_buffer_append_data(&str, input, len);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	ret = _gnutls_buffer_unescape(&str);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	ret = _gnutls_buffer_append_data(&str, "", 1);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	ret = _gnutls_buffer_pop_data(&str, output, str.length);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	_gnutls_buffer_clear(&str);

	return ret;

}

#define UUID_SIZE 16

static int randomize_uuid(TSS_UUID * uuid)

{

	uint8_t raw_uuid[16];

	int ret;

	ret = gnutls_rnd(GNUTLS_RND_NONCE, raw_uuid, sizeof(raw_uuid));

	if (ret < 0)

		return gnutls_assert_val(ret);

	/* mark it as random uuid */

	raw_uuid[6] &= 0x0f;

	raw_uuid[6] |= 0x40;

	raw_uuid[8] &= 0x0f;

	raw_uuid[8] |= 0x80;

	memcpy(&uuid->ulTimeLow, raw_uuid, 4);

	memcpy(&uuid->usTimeMid, &raw_uuid[4], 2);

	memcpy(&uuid->usTimeHigh, &raw_uuid[6], 2);

	uuid->bClockSeqHigh = raw_uuid[8];

	uuid->bClockSeqLow = raw_uuid[9];

	memcpy(&uuid->rgbNode, &raw_uuid[10], 6);

	return 0;

}

static int encode_tpmkey_url(char **url, const TSS_UUID * uuid,

			     TSS_FLAG storage)

{

	uint8_t u1[UUID_SIZE];

	gnutls_buffer_st buf;

	gnutls_datum_t dret;

	int ret;

	_gnutls_buffer_init(&buf;;

	memcpy(u1, &uuid->ulTimeLow, 4);

	memcpy(&u1[4], &uuid->usTimeMid, 2);

	memcpy(&u1[6], &uuid->usTimeHigh, 2);

	u1[8] = uuid->bClockSeqHigh;

	u1[9] = uuid->bClockSeqLow;

	memcpy(&u1[10], uuid->rgbNode, 6);

	ret = _gnutls_buffer_append_str(&buf, "tpmkey:uuid=");

	if (ret < 0) {

		gnutls_assert();

		goto cleanup;

	}

	ret =

	    _gnutls_buffer_append_printf(&buf,

					 "%.2x%.2x%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x",

					 (unsigned int) u1[0],

					 (unsigned int) u1[1],

					 (unsigned int) u1[2],

					 (unsigned int) u1[3],

					 (unsigned int) u1[4],

					 (unsigned int) u1[5],

					 (unsigned int) u1[6],

					 (unsigned int) u1[7],

					 (unsigned int) u1[8],

					 (unsigned int) u1[9],

					 (unsigned int) u1[10],

					 (unsigned int) u1[11],

					 (unsigned int) u1[12],

					 (unsigned int) u1[13],

					 (unsigned int) u1[14],

					 (unsigned int) u1[15]);