/*

 * GnuTLS PKCS#11 support

 * Copyright (C) 2010-2014 Free Software Foundation, Inc.

 * Copyright (C) 2012-2015 Nikos Mavrogiannopoulos

 * Copyright (C) 2016-2017 Red Hat, Inc.

 * 

 * Author: Nikos Mavrogiannopoulos

 *

 * The 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 <http://www.gnu.org/licenses/>

 */

#include "gnutls_int.h"

#include <gnutls/pkcs11.h>

#include <stdio.h>

#include <string.h>

#include "errors.h"

#include <datum.h>

#include <pkcs11_int.h>

#include <gnutls/abstract.h>

#include <pk.h>

#include <x509_int.h>

#include <tls-sig.h>

#include <algorithms.h>

#include <fips.h>

#include <system-keys.h>

#include "urls.h"

#include "pkcs11_int.h"

#include <abstract_int.h>

static int

privkey_sign_prehashed(gnutls_privkey_t signer,

		       const gnutls_sign_entry_st *se,

		       const gnutls_datum_t * hash_data,

		       gnutls_datum_t * signature,

		       gnutls_x509_spki_st * params, unsigned flags);

/**

 * gnutls_privkey_get_type:

 * @key: should contain a #gnutls_privkey_t type

 *

 * This function will return the type of the private key. This is

 * actually the type of the subsystem used to set this private key.

 *

 * Returns: a member of the #gnutls_privkey_type_t enumeration on

 *   success, or a negative error code on error.

 *

 * Since: 2.12.0

 **/

gnutls_privkey_type_t gnutls_privkey_get_type(gnutls_privkey_t key)

{

	return key->type;

}

/**

 * gnutls_privkey_get_seed:

 * @key: should contain a #gnutls_privkey_t type

 * @digest: if non-NULL it will contain the digest algorithm used for key generation (if applicable)

 * @seed: where seed will be copied to

 * @seed_size: originally holds the size of @seed, will be updated with actual size

 *

 * This function will return the seed that was used to generate the

 * given private key. That function will succeed only if the key was generated

 * as a provable key.

 *

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

 *   negative error value.

 *

 * Since: 3.5.0

 **/

int gnutls_privkey_get_seed(gnutls_privkey_t key, gnutls_digest_algorithm_t *digest, void *seed, size_t *seed_size)

{

	if (key->type != GNUTLS_PRIVKEY_X509)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	return gnutls_x509_privkey_get_seed(key->key.x509, digest, seed, seed_size);

}

/**

 * gnutls_privkey_verify_seed:

 * @key: should contain a #gnutls_privkey_t type

 * @digest: it contains the digest algorithm used for key generation (if applicable)

 * @seed: the seed of the key to be checked with

 * @seed_size: holds the size of @seed

 *

 * This function will verify that the given private key was generated from

 * the provided seed.

 *

 * Returns: In case of a verification failure %GNUTLS_E_PRIVKEY_VERIFICATION_ERROR

 * is returned, and zero or positive code on success.

 *

 * Since: 3.5.0

 **/

int gnutls_privkey_verify_seed(gnutls_privkey_t key, gnutls_digest_algorithm_t digest, const void *seed, size_t seed_size)

{

	if (key->type != GNUTLS_PRIVKEY_X509)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	return gnutls_x509_privkey_verify_seed(key->key.x509, digest, seed, seed_size);

}

/**

 * gnutls_privkey_get_pk_algorithm:

 * @key: should contain a #gnutls_privkey_t type

 * @bits: If set will return the number of bits of the parameters (may be NULL)

 *

 * This function will return the public key algorithm of a private

 * key and if possible will return a number of bits that indicates

 * the security parameter of the key.

 *

 * Returns: a member of the #gnutls_pk_algorithm_t enumeration on

 *   success, or a negative error code on error.

 *

 * Since: 2.12.0

 **/

int gnutls_privkey_get_pk_algorithm(gnutls_privkey_t key, unsigned int *bits)

{

	switch (key->type) {

#ifdef ENABLE_PKCS11

	case GNUTLS_PRIVKEY_PKCS11:

		return gnutls_pkcs11_privkey_get_pk_algorithm(key->key.pkcs11,

							      bits);

#endif

	case GNUTLS_PRIVKEY_X509:

		if (bits) {

			*bits = pubkey_to_bits(&key->key.x509->params);

		}

		return gnutls_x509_privkey_get_pk_algorithm(key->key.x509);

	case GNUTLS_PRIVKEY_EXT:

		if (bits)

			*bits = 0;

		return key->pk_algorithm;

	default:

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

}

static int

privkey_to_pubkey(gnutls_pk_algorithm_t pk,

		  const gnutls_pk_params_st * priv, gnutls_pk_params_st * pub)

{

	int ret;

	pub->algo = priv->algo;

	pub->pkflags = priv->pkflags;

	pub->curve = priv->curve;

	pub->qbits = priv->qbits;

	memcpy(&pub->spki, &priv->spki, sizeof(gnutls_x509_spki_st));

	switch (pk) {

	case GNUTLS_PK_RSA_PSS:

	case GNUTLS_PK_RSA:

		pub->params[0] = _gnutls_mpi_copy(priv->params[0]);

		pub->params[1] = _gnutls_mpi_copy(priv->params[1]);

		pub->params_nr = RSA_PUBLIC_PARAMS;

		if (pub->params[0] == NULL || pub->params[1] == NULL) {

			gnutls_assert();

			ret = GNUTLS_E_MEMORY_ERROR;

			goto cleanup;

		}

		break;

	case GNUTLS_PK_DSA:

		pub->params[0] = _gnutls_mpi_copy(priv->params[0]);

		pub->params[1] = _gnutls_mpi_copy(priv->params[1]);

		pub->params[2] = _gnutls_mpi_copy(priv->params[2]);

		pub->params[3] = _gnutls_mpi_copy(priv->params[3]);

		pub->params_nr = DSA_PUBLIC_PARAMS;

		if (pub->params[0] == NULL || pub->params[1] == NULL ||

		    pub->params[2] == NULL || pub->params[3] == NULL) {

			gnutls_assert();

			ret = GNUTLS_E_MEMORY_ERROR;

			goto cleanup;

		}

		break;

	case GNUTLS_PK_ECDSA:

		pub->params[ECC_X] = _gnutls_mpi_copy(priv->params[ECC_X]);

		pub->params[ECC_Y] = _gnutls_mpi_copy(priv->params[ECC_Y]);

		pub->params_nr = ECC_PUBLIC_PARAMS;

		if (pub->params[ECC_X] == NULL || pub->params[ECC_Y] == NULL) {

			gnutls_assert();

			ret = GNUTLS_E_MEMORY_ERROR;

			goto cleanup;

		}

		break;

	case GNUTLS_PK_EDDSA_ED25519:

		ret = _gnutls_set_datum(&pub->raw_pub, priv->raw_pub.data, priv->raw_pub.size);

		if (ret < 0)

			return gnutls_assert_val(ret);

		break;

	default:

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

	return 0;

 cleanup:

	gnutls_pk_params_release(pub);

	return ret;

}

/* Returns the public key of the private key (if possible)

 */

int

_gnutls_privkey_get_mpis(gnutls_privkey_t key, gnutls_pk_params_st * params)

{

	int ret;

	switch (key->type) {

	case GNUTLS_PRIVKEY_X509:

		ret = _gnutls_pk_params_copy(params, &key->key.x509->params);

		break;

#ifdef ENABLE_PKCS11

	case GNUTLS_PRIVKEY_PKCS11: {

		gnutls_pubkey_t pubkey;

		ret = _pkcs11_privkey_get_pubkey(key->key.pkcs11, &pubkey, 0);

		if (ret < 0)

			return gnutls_assert_val(ret);

		ret = _gnutls_pubkey_get_mpis(pubkey, params);

		gnutls_pubkey_deinit(pubkey);

		break;

		}

#endif

	default:

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

	return ret;

}

int

_gnutls_privkey_get_public_mpis(gnutls_privkey_t key,

				gnutls_pk_params_st * params)

{

	int ret;

	gnutls_pk_params_st tmp1;

	gnutls_pk_params_init(&tmp1);

	ret = _gnutls_privkey_get_mpis(key, &tmp1);

	if (ret < 0)

		return gnutls_assert_val(ret);

	ret = privkey_to_pubkey(key->pk_algorithm, &tmp1, params);

	gnutls_pk_params_release(&tmp1);

	if (ret < 0)

		gnutls_assert();

	return ret;

}

/* This function retrieves default sign parameters from KEY. */

int

_gnutls_privkey_get_spki_params(gnutls_privkey_t key,

				gnutls_x509_spki_st * params)

{

	switch (key->type) {

#ifdef ENABLE_PKCS11

	case GNUTLS_PRIVKEY_PKCS11:

		break;

#endif

	case GNUTLS_PRIVKEY_EXT:

		break;

	case GNUTLS_PRIVKEY_X509:

		_gnutls_x509_privkey_get_spki_params(key->key.x509, params);

		return 0;

	default:

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

	memset(params, 0, sizeof(gnutls_x509_spki_st));

	return 0;

}

/* This function fills in PARAMS with the necessary parameters to sign

 * with PK and DIG. PARAMS must be initialized with

 * _gnutls_privkey_get_spki_params in advance.

 *

 * After calling this function the params structure will

 * be initialized even if the original SubjectPublicKeyInfo was empty.

 */

int

_gnutls_privkey_update_spki_params(gnutls_privkey_t key,

				 gnutls_pk_algorithm_t pk,

				 gnutls_digest_algorithm_t dig,

				 unsigned flags,

				 gnutls_x509_spki_st *params)

{

	unsigned salt_size = 0;

	unsigned bits = 0;

	gnutls_pk_algorithm_t key_pk;

	if (flags & GNUTLS_PRIVKEY_SIGN_FLAG_RSA_PSS) {

		if (!GNUTLS_PK_IS_RSA(pk))

			return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

		pk = GNUTLS_PK_RSA_PSS;

	}

	key_pk = gnutls_privkey_get_pk_algorithm(key, &bits);

	if ((key_pk != pk) &&

	      !(key_pk == GNUTLS_PK_RSA && pk == GNUTLS_PK_RSA_PSS)) {

		gnutls_assert();

		return GNUTLS_E_CONSTRAINT_ERROR;

	}

	if (pk == GNUTLS_PK_RSA_PSS) {

		const mac_entry_st *me;

		me = hash_to_entry(dig);

		if (unlikely(me == NULL))

			return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

		if (params->pk == GNUTLS_PK_RSA)

			salt_size = 0;

		else if (params->pk == GNUTLS_PK_RSA_PSS) {

			if (params->rsa_pss_dig != GNUTLS_DIG_UNKNOWN && dig != params->rsa_pss_dig) {

				return gnutls_assert_val(GNUTLS_E_CONSTRAINT_ERROR);

			}

			salt_size = params->salt_size;

		}

		if (flags & GNUTLS_PRIVKEY_FLAG_REPRODUCIBLE)

			params->salt_size = 0;

		else

			params->salt_size = _gnutls_find_rsa_pss_salt_size(bits, me, salt_size);

		params->rsa_pss_dig = dig;

	}

	params->pk = pk;

	return 0;

}

/**

 * gnutls_privkey_init:

 * @key: A pointer to the type to be initialized

 *

 * This function will initialize a private key object. The object can

 * be used to generate, import, and perform cryptographic operations

 * on the associated private key.

 *

 * Note that when the underlying private key is a PKCS#11 key (i.e.,

 * when imported with a PKCS#11 URI), the limitations of gnutls_pkcs11_privkey_init()

 * apply to this object as well. In versions of GnuTLS later than 3.5.11 the object

 * is protected using locks and a single %gnutls_privkey_t can be re-used

 * by many threads. However, for performance it is recommended to utilize

 * one object per key per thread.

 *

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

 *   negative error value.

 *

 * Since: 2.12.0

 **/

int gnutls_privkey_init(gnutls_privkey_t * key)

{

	FAIL_IF_LIB_ERROR;

	*key = gnutls_calloc(1, sizeof(struct gnutls_privkey_st));

	if (*key == NULL) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	return 0;

}

/**

 * gnutls_privkey_deinit:

 * @key: The key to be deinitialized

 *

 * This function will deinitialize a private key structure.

 *

 * Since: 2.12.0

 **/

void gnutls_privkey_deinit(gnutls_privkey_t key)

{

	if (key == NULL)

		return;

	if (key->flags & GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE

	    || key->flags & GNUTLS_PRIVKEY_IMPORT_COPY)

		switch (key->type) {

#ifdef ENABLE_PKCS11

		case GNUTLS_PRIVKEY_PKCS11:

			gnutls_pkcs11_privkey_deinit(key->key.pkcs11);

			break;

#endif

		case GNUTLS_PRIVKEY_X509:

			gnutls_x509_privkey_deinit(key->key.x509);

			break;

		case GNUTLS_PRIVKEY_EXT:

			if (key->key.ext.deinit_func != NULL)

				key->key.ext.deinit_func(key,

							 key->key.ext.userdata);

			break;

		default:

			break;

		}

	gnutls_free(key);

}

/* Will erase all private key information, except PIN */

void _gnutls_privkey_cleanup(gnutls_privkey_t key)

{

	memset(&key->key, 0, sizeof(key->key));

	key->type = 0;

	key->pk_algorithm = 0;

	key->flags = 0;

}

/* will fail if the private key contains an actual key.

 */

static int check_if_clean(gnutls_privkey_t key)

{

	if (key->type != 0)

		return GNUTLS_E_INVALID_REQUEST;

	return 0;

}

#ifdef ENABLE_PKCS11

/**

 * gnutls_privkey_import_pkcs11:

 * @pkey: The private key

 * @key: The private key to be imported

 * @flags: Flags for the import

 *

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

 * #gnutls_privkey_t type.

 *

 * The #gnutls_pkcs11_privkey_t object must not be deallocated

 * during the lifetime of this structure.

 *

 * @flags might be zero or one of %GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE

 * and %GNUTLS_PRIVKEY_IMPORT_COPY.

 *

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

 *   negative error value.

 *

 * Since: 2.12.0

 **/

int

gnutls_privkey_import_pkcs11(gnutls_privkey_t pkey,

			     gnutls_pkcs11_privkey_t key, unsigned int flags)

{

	int ret;

	ret = check_if_clean(pkey);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	if (flags & GNUTLS_PRIVKEY_IMPORT_COPY)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	pkey->key.pkcs11 = key;

	pkey->type = GNUTLS_PRIVKEY_PKCS11;

	pkey->pk_algorithm = gnutls_pkcs11_privkey_get_pk_algorithm(key, NULL);

	pkey->flags = flags;

	if (pkey->pin.data)

		gnutls_pkcs11_privkey_set_pin_function(key, pkey->pin.cb,

						       pkey->pin.data);

	return 0;

}

#if 0

/**

 * gnutls_privkey_import_pkcs11_url:

 * @key: A key of type #gnutls_pubkey_t

 * @url: A PKCS 11 url

 *

 * This function will import a PKCS 11 private key to a #gnutls_private_key_t

 * type.

 *

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

 *   negative error value.

 *

 * Since: 3.1.0

 **/

int gnutls_privkey_import_pkcs11_url(gnutls_privkey_t key, const char *url)

{

	int x;

}

#endif

static

int _gnutls_privkey_import_pkcs11_url(gnutls_privkey_t key, const char *url, unsigned flags)

{

	gnutls_pkcs11_privkey_t pkey;

	int ret;

	ret = gnutls_pkcs11_privkey_init(&pkey);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	if (key->pin.cb)

		gnutls_pkcs11_privkey_set_pin_function(pkey, key->pin.cb,

						       key->pin.data);

	ret = gnutls_pkcs11_privkey_import_url(pkey, url, flags);

	if (ret < 0) {

		gnutls_assert();

		goto cleanup;

	}

	ret =

	    gnutls_privkey_import_pkcs11(key, pkey,

					 GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE);

	if (ret < 0) {

		gnutls_assert();

		goto cleanup;

	}

	return 0;

 cleanup:

	gnutls_pkcs11_privkey_deinit(pkey);

	return ret;

}

/**

 * gnutls_privkey_export_pkcs11:

 * @pkey: The private key

 * @key: Location for the key to be exported.

 *

 * Converts the given abstract private key to a #gnutls_pkcs11_privkey_t

 * type. The key must be of type %GNUTLS_PRIVKEY_PKCS11. The key

 * returned in @key must be deinitialized with

 * gnutls_pkcs11_privkey_deinit().

 *

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

 *   negative error value.

 *

 * Since: 3.4.0

 */

int

gnutls_privkey_export_pkcs11(gnutls_privkey_t pkey,

			     gnutls_pkcs11_privkey_t *key)

{

	int ret;

	if (pkey->type != GNUTLS_PRIVKEY_PKCS11) {

		gnutls_assert();

		return GNUTLS_E_INVALID_REQUEST;

	}

	ret = gnutls_pkcs11_privkey_init(key);

	if (ret < 0)

		return gnutls_assert_val(ret);

	ret = gnutls_pkcs11_privkey_cpy(*key, pkey->key.pkcs11);

	if (ret < 0) {

		gnutls_pkcs11_privkey_deinit(*key);

		*key = NULL;

		return gnutls_assert_val(ret);

	}

	return 0;

}

#endif				/* ENABLE_PKCS11 */

/**

 * gnutls_privkey_import_ext:

 * @pkey: The private key

 * @pk: The public key algorithm

 * @userdata: private data to be provided to the callbacks

 * @sign_func: callback for signature operations

 * @decrypt_func: callback for decryption operations

 * @flags: Flags for the import

 *

 * This function will associate the given callbacks with the

 * #gnutls_privkey_t type. At least one of the two callbacks

 * must be non-null.

 *

 * Note that the signing function is supposed to "raw" sign data, i.e.,

 * without any hashing or preprocessing. In case of RSA the DigestInfo

 * will be provided, and the signing function is expected to do the PKCS #1

 * 1.5 padding and the exponentiation.

 *

 * See also gnutls_privkey_import_ext3().

 *

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

 *   negative error value.

 *

 * Since: 3.0

 **/

int

gnutls_privkey_import_ext(gnutls_privkey_t pkey,

			  gnutls_pk_algorithm_t pk,

			  void *userdata,

			  gnutls_privkey_sign_func sign_func,

			  gnutls_privkey_decrypt_func decrypt_func,

			  unsigned int flags)

{

	return gnutls_privkey_import_ext2(pkey, pk, userdata, sign_func,

					  decrypt_func, NULL, flags);

}

#define PK_IS_OK_FOR_EXT2(pk) \

	((pk == GNUTLS_PK_RSA) || (pk == GNUTLS_PK_ECDSA) || (pk == GNUTLS_PK_DSA))

/**

 * gnutls_privkey_import_ext2:

 * @pkey: The private key

 * @pk: The public key algorithm

 * @userdata: private data to be provided to the callbacks

 * @sign_fn: callback for signature operations

 * @decrypt_fn: callback for decryption operations

 * @deinit_fn: a deinitialization function

 * @flags: Flags for the import

 *

 * This function will associate the given callbacks with the

 * #gnutls_privkey_t type. At least one of the two callbacks

 * must be non-null. If a deinitialization function is provided

 * then flags is assumed to contain %GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE.

 *

 * Note that the signing function is supposed to "raw" sign data, i.e.,

 * without any hashing or preprocessing. In case of RSA the DigestInfo

 * will be provided, and the signing function is expected to do the PKCS #1

 * 1.5 padding and the exponentiation.

 *

 * See also gnutls_privkey_import_ext3().

 *

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

 *   negative error value.

 *

 * Since: 3.1

 **/

int

gnutls_privkey_import_ext2(gnutls_privkey_t pkey,

			   gnutls_pk_algorithm_t pk,

			   void *userdata,

			   gnutls_privkey_sign_func sign_fn,

			   gnutls_privkey_decrypt_func decrypt_fn,

			   gnutls_privkey_deinit_func deinit_fn,

			   unsigned int flags)

{

	int ret;

	ret = check_if_clean(pkey);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	if (!PK_IS_OK_FOR_EXT2(pk))

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	if (sign_fn == NULL && decrypt_fn == NULL)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	pkey->key.ext.sign_func = sign_fn;

	pkey->key.ext.decrypt_func = decrypt_fn;

	pkey->key.ext.deinit_func = deinit_fn;

	pkey->key.ext.userdata = userdata;

	pkey->type = GNUTLS_PRIVKEY_EXT;

	pkey->pk_algorithm = pk;

	pkey->flags = flags;

	/* Ensure gnutls_privkey_deinit() calls the deinit_func */

	if (deinit_fn)

		pkey->flags |= GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE;

	return 0;

}

/**

 * gnutls_privkey_import_ext3:

 * @pkey: The private key

 * @userdata: private data to be provided to the callbacks

 * @sign_fn: callback for signature operations

 * @decrypt_fn: callback for decryption operations

 * @deinit_fn: a deinitialization function

 * @info_fn: returns info about the public key algorithm (should not be %NULL)

 * @flags: Flags for the import

 *

 * This function will associate the given callbacks with the

 * #gnutls_privkey_t type. At least one of the two callbacks

 * must be non-null. If a deinitialization function is provided

 * then flags is assumed to contain %GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE.

 *

 * Note that the signing function is supposed to "raw" sign data, i.e.,

 * without any hashing or preprocessing. In case of RSA the DigestInfo

 * will be provided, and the signing function is expected to do the PKCS #1

 * 1.5 padding and the exponentiation.

 *

 * The @info_fn must provide information on the algorithms supported by

 * this private key, and should support the flags %GNUTLS_PRIVKEY_INFO_PK_ALGO and

 * %GNUTLS_PRIVKEY_INFO_SIGN_ALGO. It must return -1 on unknown flags.

 *

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

 *   negative error value.

 *

 * Since: 3.4.0

 **/

int

gnutls_privkey_import_ext3(gnutls_privkey_t pkey,

			   void *userdata,

			   gnutls_privkey_sign_func sign_fn,

			   gnutls_privkey_decrypt_func decrypt_fn,

			   gnutls_privkey_deinit_func deinit_fn,

			   gnutls_privkey_info_func info_fn,

			   unsigned int flags)

{

	int ret;

	ret = check_if_clean(pkey);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	if (sign_fn == NULL && decrypt_fn == NULL)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	if (info_fn == NULL)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	pkey->key.ext.sign_func = sign_fn;

	pkey->key.ext.decrypt_func = decrypt_fn;

	pkey->key.ext.deinit_func = deinit_fn;

	pkey->key.ext.info_func = info_fn;

	pkey->key.ext.userdata = userdata;

	pkey->type = GNUTLS_PRIVKEY_EXT;

	pkey->flags = flags;

	pkey->pk_algorithm = pkey->key.ext.info_func(pkey, GNUTLS_PRIVKEY_INFO_PK_ALGO, pkey->key.ext.userdata);

	if (!PK_IS_OK_FOR_EXT2(pkey->pk_algorithm))

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	/* Ensure gnutls_privkey_deinit() calls the deinit_func */

	if (deinit_fn)

		pkey->flags |= GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE;

	return 0;

}

/**

 * gnutls_privkey_import_ext4:

 * @pkey: The private key

 * @userdata: private data to be provided to the callbacks

 * @sign_data_fn: callback for signature operations (may be %NULL)

 * @sign_hash_fn: callback for signature operations (may be %NULL)

 * @decrypt_fn: callback for decryption operations (may be %NULL)

 * @deinit_fn: a deinitialization function

 * @info_fn: returns info about the public key algorithm (should not be %NULL)

 * @flags: Flags for the import

 *

 * This function will associate the given callbacks with the

 * #gnutls_privkey_t type. At least one of the callbacks

 * must be non-null. If a deinitialization function is provided

 * then flags is assumed to contain %GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE.

 *

 * Note that in contrast with the signing function of

 * gnutls_privkey_import_ext3(), the signing functions provided to this

 * function take explicitly the signature algorithm as parameter and

 * different functions are provided to sign the data and hashes.

 *

 * The @sign_hash_fn is to be called to sign pre-hashed data. The input

 * to the callback is the output of the hash (such as SHA256) corresponding

 * to the signature algorithm. For RSA PKCS#1 signatures, the signature

 * algorithm can be set to %GNUTLS_SIGN_RSA_RAW, and in that case the data

 * should be handled as if they were an RSA PKCS#1 DigestInfo structure.

 *

 * The @sign_data_fn is to be called to sign data. The input data will be

 * he data to be signed (and hashed), with the provided signature

 * algorithm. This function is to be used for signature algorithms like

 * Ed25519 which cannot take pre-hashed data as input.

 *

 * When both @sign_data_fn and @sign_hash_fn functions are provided they

 * must be able to operate on all the supported signature algorithms,

 * unless prohibited by the type of the algorithm (e.g., as with Ed25519).

 *

 * The @info_fn must provide information on the signature algorithms supported by

 * this private key, and should support the flags %GNUTLS_PRIVKEY_INFO_PK_ALGO and

 * %GNUTLS_PRIVKEY_INFO_HAVE_SIGN_ALGO. It must return -1 on unknown flags.

 *

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

 *   negative error value.

 *

 * Since: 3.6.0

 **/

int

gnutls_privkey_import_ext4(gnutls_privkey_t pkey,

                           void *userdata,

                           gnutls_privkey_sign_data_func sign_data_fn,

                           gnutls_privkey_sign_hash_func sign_hash_fn,

                           gnutls_privkey_decrypt_func decrypt_fn,

                           gnutls_privkey_deinit_func deinit_fn,

                           gnutls_privkey_info_func info_fn,

                           unsigned int flags)

{

	int ret;

	ret = check_if_clean(pkey);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	if (sign_data_fn == NULL && sign_hash_fn == NULL && decrypt_fn == NULL)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	if (info_fn == NULL)

		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	pkey->key.ext.sign_data_func = sign_data_fn;

	pkey->key.ext.sign_hash_func = sign_hash_fn;

	pkey->key.ext.decrypt_func = decrypt_fn;

	pkey->key.ext.deinit_func = deinit_fn;

	pkey->key.ext.info_func = info_fn;

	pkey->key.ext.userdata = userdata;

	pkey->type = GNUTLS_PRIVKEY_EXT;

	pkey->flags = flags;

	pkey->pk_algorithm = pkey->key.ext.info_func(pkey, GNUTLS_PRIVKEY_INFO_PK_ALGO, pkey->key.ext.userdata);

	/* Ensure gnutls_privkey_deinit() calls the deinit_func */

	if (deinit_fn)

		pkey->flags |= GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE;

	return 0;

}

/**

 * gnutls_privkey_import_x509:

 * @pkey: The private key

 * @key: The private key to be imported

 * @flags: Flags for the import

 *

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

 * #gnutls_privkey_t type.

 *

 * The #gnutls_x509_privkey_t object must not be deallocated

 * during the lifetime of this structure.

 *

 * @flags might be zero or one of %GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE

 * and %GNUTLS_PRIVKEY_IMPORT_COPY.

 *

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

 *   negative error value.