security/keys/trusted-keys/trusted_tpm2.c - third_party/kernel - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (C) 2004 IBM Corporation
  * Copyright (C) 2014 Intel Corporation
  */

 #include <linux/string.h>
 #include <linux/err.h>
 #include <linux/tpm.h>
 #include <linux/tpm_command.h>

 #include <keys/trusted-type.h>
 #include <keys/trusted_tpm.h>

 static struct tpm2_hash tpm2_hash_map[] = {
 	{HASH_ALGO_SHA1, TPM_ALG_SHA1},
 	{HASH_ALGO_SHA256, TPM_ALG_SHA256},
 	{HASH_ALGO_SHA384, TPM_ALG_SHA384},
 	{HASH_ALGO_SHA512, TPM_ALG_SHA512},
 	{HASH_ALGO_SM3_256, TPM_ALG_SM3_256},
 };

 /**
  * tpm_buf_append_auth() - append TPMS_AUTH_COMMAND to the buffer.
  *
  * @buf: an allocated tpm_buf instance
  * @session_handle: session handle
  * @nonce: the session nonce, may be NULL if not used
  * @nonce_len: the session nonce length, may be 0 if not used
  * @attributes: the session attributes
  * @hmac: the session HMAC or password, may be NULL if not used
  * @hmac_len: the session HMAC or password length, maybe 0 if not used
  */
 static void tpm2_buf_append_auth(struct tpm_buf *buf, u32 session_handle,
 				 const u8 *nonce, u16 nonce_len,
 				 u8 attributes,
 				 const u8 *hmac, u16 hmac_len)
 {
 	tpm_buf_append_u32(buf, 9 + nonce_len + hmac_len);
 	tpm_buf_append_u32(buf, session_handle);
 	tpm_buf_append_u16(buf, nonce_len);

 	if (nonce && nonce_len)
 		tpm_buf_append(buf, nonce, nonce_len);

 	tpm_buf_append_u8(buf, attributes);
 	tpm_buf_append_u16(buf, hmac_len);

 	if (hmac && hmac_len)
 		tpm_buf_append(buf, hmac, hmac_len);
 }

 /**
  * tpm2_seal_trusted() - seal the payload of a trusted key
  *
  * @chip: TPM chip to use
  * @payload: the key data in clear and encrypted form
  * @options: authentication values and other options
  *
  * Return: < 0 on error and 0 on success.
  */
 int tpm2_seal_trusted(struct tpm_chip *chip,
 		      struct trusted_key_payload *payload,
 		      struct trusted_key_options *options)
 {
 	unsigned int blob_len;
 	struct tpm_buf buf;
 	u32 hash;
 	int i;
 	int rc;

 	for (i = 0; i < ARRAY_SIZE(tpm2_hash_map); i++) {
 		if (options->hash == tpm2_hash_map[i].crypto_id) {
 			hash = tpm2_hash_map[i].tpm_id;
 			break;
 		}
 	}

 	if (i == ARRAY_SIZE(tpm2_hash_map))
 		return -EINVAL;

 	rc = tpm_try_get_ops(chip);
 	if (rc)
 		return rc;

 	rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_CREATE);
 	if (rc) {
 		tpm_put_ops(chip);
 		return rc;
 	}

 	tpm_buf_append_u32(&buf, options->keyhandle);
 	tpm2_buf_append_auth(&buf, TPM2_RS_PW,
 			     NULL /* nonce */, 0,
 			     0 /* session_attributes */,
 			     options->keyauth /* hmac */,
 			     TPM_DIGEST_SIZE);

 	/* sensitive */
 	tpm_buf_append_u16(&buf, 4 + options->blobauth_len + payload->key_len + 1);

 	tpm_buf_append_u16(&buf, options->blobauth_len);
 	if (options->blobauth_len)
 		tpm_buf_append(&buf, options->blobauth, options->blobauth_len);

 	tpm_buf_append_u16(&buf, payload->key_len + 1);
 	tpm_buf_append(&buf, payload->key, payload->key_len);
 	tpm_buf_append_u8(&buf, payload->migratable);

 	/* public */
 	tpm_buf_append_u16(&buf, 14 + options->policydigest_len);
 	tpm_buf_append_u16(&buf, TPM_ALG_KEYEDHASH);
 	tpm_buf_append_u16(&buf, hash);

 	/* policy */
 	if (options->policydigest_len) {
 		tpm_buf_append_u32(&buf, 0);
 		tpm_buf_append_u16(&buf, options->policydigest_len);
 		tpm_buf_append(&buf, options->policydigest,
 			       options->policydigest_len);
 	} else {
 		tpm_buf_append_u32(&buf, TPM2_OA_USER_WITH_AUTH);
 		tpm_buf_append_u16(&buf, 0);
 	}

 	/* public parameters */
 	tpm_buf_append_u16(&buf, TPM_ALG_NULL);
 	tpm_buf_append_u16(&buf, 0);

 	/* outside info */
 	tpm_buf_append_u16(&buf, 0);

 	/* creation PCR */
 	tpm_buf_append_u32(&buf, 0);

 	if (buf.flags & TPM_BUF_OVERFLOW) {
 		rc = -E2BIG;
 		goto out;
 	}

 	rc = tpm_transmit_cmd(chip, &buf, 4, "sealing data");
 	if (rc)
 		goto out;

 	blob_len = be32_to_cpup((__be32 *) &buf.data[TPM_HEADER_SIZE]);
 	if (blob_len > MAX_BLOB_SIZE) {
 		rc = -E2BIG;
 		goto out;
 	}
 	if (tpm_buf_length(&buf) < TPM_HEADER_SIZE + 4 + blob_len) {
 		rc = -EFAULT;
 		goto out;
 	}

 	memcpy(payload->blob, &buf.data[TPM_HEADER_SIZE + 4], blob_len);
 	payload->blob_len = blob_len;

 out:
 	tpm_buf_destroy(&buf);

 	if (rc > 0) {
 		if (tpm2_rc_value(rc) == TPM2_RC_HASH)
 			rc = -EINVAL;
 		else
 			rc = -EPERM;
 	}

 	tpm_put_ops(chip);
 	return rc;
 }

 /**
  * tpm2_load_cmd() - execute a TPM2_Load command
  *
  * @chip: TPM chip to use
  * @payload: the key data in clear and encrypted form
  * @options: authentication values and other options
  * @blob_handle: returned blob handle
  *
  * Return: 0 on success.
  *        -E2BIG on wrong payload size.
  *        -EPERM on tpm error status.
  *        < 0 error from tpm_send.
  */
 static int tpm2_load_cmd(struct tpm_chip *chip,
 			 struct trusted_key_payload *payload,
 			 struct trusted_key_options *options,
 			 u32 *blob_handle)
 {
 	struct tpm_buf buf;
 	unsigned int private_len;
 	unsigned int public_len;
 	unsigned int blob_len;
 	int rc;

 	private_len = be16_to_cpup((__be16 *) &payload->blob[0]);
 	if (private_len > (payload->blob_len - 2))
 		return -E2BIG;

 	public_len = be16_to_cpup((__be16 *) &payload->blob[2 + private_len]);
 	blob_len = private_len + public_len + 4;
 	if (blob_len > payload->blob_len)
 		return -E2BIG;

 	rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_LOAD);
 	if (rc)
 		return rc;

 	tpm_buf_append_u32(&buf, options->keyhandle);
 	tpm2_buf_append_auth(&buf, TPM2_RS_PW,
 			     NULL /* nonce */, 0,
 			     0 /* session_attributes */,
 			     options->keyauth /* hmac */,
 			     TPM_DIGEST_SIZE);

 	tpm_buf_append(&buf, payload->blob, blob_len);

 	if (buf.flags & TPM_BUF_OVERFLOW) {
 		rc = -E2BIG;
 		goto out;
 	}

 	rc = tpm_transmit_cmd(chip, &buf, 4, "loading blob");
 	if (!rc)
 		*blob_handle = be32_to_cpup(
 			(__be32 *) &buf.data[TPM_HEADER_SIZE]);

 out:
 	tpm_buf_destroy(&buf);

 	if (rc > 0)
 		rc = -EPERM;

 	return rc;
 }

 /**
  * tpm2_unseal_cmd() - execute a TPM2_Unload command
  *
  * @chip: TPM chip to use
  * @payload: the key data in clear and encrypted form
  * @options: authentication values and other options
  * @blob_handle: blob handle
  *
  * Return: 0 on success
  *         -EPERM on tpm error status
  *         < 0 error from tpm_send
  */
 static int tpm2_unseal_cmd(struct tpm_chip *chip,
 			   struct trusted_key_payload *payload,
 			   struct trusted_key_options *options,
 			   u32 blob_handle)
 {
 	struct tpm_buf buf;
 	u16 data_len;
 	u8 *data;
 	int rc;

 	rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_UNSEAL);
 	if (rc)
 		return rc;

 	tpm_buf_append_u32(&buf, blob_handle);
 	tpm2_buf_append_auth(&buf,
 			     options->policyhandle ?
 			     options->policyhandle : TPM2_RS_PW,
 			     NULL /* nonce */, 0,
 			     TPM2_SA_CONTINUE_SESSION,
 			     options->blobauth /* hmac */,
 			     options->blobauth_len);

 	rc = tpm_transmit_cmd(chip, &buf, 6, "unsealing");
 	if (rc > 0)
 		rc = -EPERM;

 	if (!rc) {
 		data_len = be16_to_cpup(
 			(__be16 *) &buf.data[TPM_HEADER_SIZE + 4]);
 		if (data_len < MIN_KEY_SIZE ||  data_len > MAX_KEY_SIZE + 1) {
 			rc = -EFAULT;
 			goto out;
 		}

 		if (tpm_buf_length(&buf) < TPM_HEADER_SIZE + 6 + data_len) {
 			rc = -EFAULT;
 			goto out;
 		}
 		data = &buf.data[TPM_HEADER_SIZE + 6];

 		memcpy(payload->key, data, data_len - 1);
 		payload->key_len = data_len - 1;
 		payload->migratable = data[data_len - 1];
 	}

 out:
 	tpm_buf_destroy(&buf);
 	return rc;
 }

 /**
  * tpm2_unseal_trusted() - unseal the payload of a trusted key
  *
  * @chip: TPM chip to use
  * @payload: the key data in clear and encrypted form
  * @options: authentication values and other options
  *
  * Return: Same as with tpm_send.
  */
 int tpm2_unseal_trusted(struct tpm_chip *chip,
 			struct trusted_key_payload *payload,
 			struct trusted_key_options *options)
 {
 	u32 blob_handle;
 	int rc;

 	rc = tpm_try_get_ops(chip);
 	if (rc)
 		return rc;

 	rc = tpm2_load_cmd(chip, payload, options, &blob_handle);
 	if (rc)
 		goto out;

 	rc = tpm2_unseal_cmd(chip, payload, options, blob_handle);
 	tpm2_flush_context(chip, blob_handle);

 out:
 	tpm_put_ops(chip);

 	return rc;
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright (C) 2004 IBM Corporation
	* Copyright (C) 2014 Intel Corporation
	*/

	#include <linux/string.h>
	#include <linux/err.h>
	#include <linux/tpm.h>
	#include <linux/tpm_command.h>

	#include <keys/trusted-type.h>
	#include <keys/trusted_tpm.h>

	static struct tpm2_hash tpm2_hash_map[] = {
	{HASH_ALGO_SHA1, TPM_ALG_SHA1},
	{HASH_ALGO_SHA256, TPM_ALG_SHA256},
	{HASH_ALGO_SHA384, TPM_ALG_SHA384},
	{HASH_ALGO_SHA512, TPM_ALG_SHA512},
	{HASH_ALGO_SM3_256, TPM_ALG_SM3_256},
	};

	/**
	* tpm_buf_append_auth() - append TPMS_AUTH_COMMAND to the buffer.
	*
	* @buf: an allocated tpm_buf instance
	* @session_handle: session handle
	* @nonce: the session nonce, may be NULL if not used
	* @nonce_len: the session nonce length, may be 0 if not used
	* @attributes: the session attributes
	* @hmac: the session HMAC or password, may be NULL if not used
	* @hmac_len: the session HMAC or password length, maybe 0 if not used
	*/
	static void tpm2_buf_append_auth(struct tpm_buf *buf, u32 session_handle,
	const u8 *nonce, u16 nonce_len,
	u8 attributes,
	const u8 *hmac, u16 hmac_len)
	{
	tpm_buf_append_u32(buf, 9 + nonce_len + hmac_len);
	tpm_buf_append_u32(buf, session_handle);
	tpm_buf_append_u16(buf, nonce_len);

	if (nonce && nonce_len)
	tpm_buf_append(buf, nonce, nonce_len);

	tpm_buf_append_u8(buf, attributes);
	tpm_buf_append_u16(buf, hmac_len);

	if (hmac && hmac_len)
	tpm_buf_append(buf, hmac, hmac_len);
	}

	/**
	* tpm2_seal_trusted() - seal the payload of a trusted key
	*
	* @chip: TPM chip to use
	* @payload: the key data in clear and encrypted form
	* @options: authentication values and other options
	*
	* Return: < 0 on error and 0 on success.
	*/
	int tpm2_seal_trusted(struct tpm_chip *chip,
	struct trusted_key_payload *payload,
	struct trusted_key_options *options)
	{
	unsigned int blob_len;
	struct tpm_buf buf;
	u32 hash;
	int i;
	int rc;

	for (i = 0; i < ARRAY_SIZE(tpm2_hash_map); i++) {
	if (options->hash == tpm2_hash_map[i].crypto_id) {
	hash = tpm2_hash_map[i].tpm_id;
	break;
	}
	}

	if (i == ARRAY_SIZE(tpm2_hash_map))
	return -EINVAL;

	rc = tpm_try_get_ops(chip);
	if (rc)
	return rc;

	rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_CREATE);
	if (rc) {
	tpm_put_ops(chip);
	return rc;
	}

	tpm_buf_append_u32(&buf, options->keyhandle);
	tpm2_buf_append_auth(&buf, TPM2_RS_PW,
	NULL /* nonce */, 0,
	0 /* session_attributes */,
	options->keyauth /* hmac */,
	TPM_DIGEST_SIZE);

	/* sensitive */
	tpm_buf_append_u16(&buf, 4 + options->blobauth_len + payload->key_len + 1);

	tpm_buf_append_u16(&buf, options->blobauth_len);
	if (options->blobauth_len)
	tpm_buf_append(&buf, options->blobauth, options->blobauth_len);

	tpm_buf_append_u16(&buf, payload->key_len + 1);
	tpm_buf_append(&buf, payload->key, payload->key_len);
	tpm_buf_append_u8(&buf, payload->migratable);

	/* public */
	tpm_buf_append_u16(&buf, 14 + options->policydigest_len);
	tpm_buf_append_u16(&buf, TPM_ALG_KEYEDHASH);
	tpm_buf_append_u16(&buf, hash);

	/* policy */
	if (options->policydigest_len) {
	tpm_buf_append_u32(&buf, 0);
	tpm_buf_append_u16(&buf, options->policydigest_len);
	tpm_buf_append(&buf, options->policydigest,
	options->policydigest_len);
	} else {
	tpm_buf_append_u32(&buf, TPM2_OA_USER_WITH_AUTH);
	tpm_buf_append_u16(&buf, 0);
	}

	/* public parameters */
	tpm_buf_append_u16(&buf, TPM_ALG_NULL);
	tpm_buf_append_u16(&buf, 0);

	/* outside info */
	tpm_buf_append_u16(&buf, 0);

	/* creation PCR */
	tpm_buf_append_u32(&buf, 0);

	if (buf.flags & TPM_BUF_OVERFLOW) {
	rc = -E2BIG;
	goto out;
	}

	rc = tpm_transmit_cmd(chip, &buf, 4, "sealing data");
	if (rc)
	goto out;

	blob_len = be32_to_cpup((__be32 *) &buf.data[TPM_HEADER_SIZE]);
	if (blob_len > MAX_BLOB_SIZE) {
	rc = -E2BIG;
	goto out;
	}
	if (tpm_buf_length(&buf) < TPM_HEADER_SIZE + 4 + blob_len) {
	rc = -EFAULT;
	goto out;
	}

	memcpy(payload->blob, &buf.data[TPM_HEADER_SIZE + 4], blob_len);
	payload->blob_len = blob_len;

	out:
	tpm_buf_destroy(&buf);

	if (rc > 0) {
	if (tpm2_rc_value(rc) == TPM2_RC_HASH)
	rc = -EINVAL;
	else
	rc = -EPERM;
	}

	tpm_put_ops(chip);
	return rc;
	}

	/**
	* tpm2_load_cmd() - execute a TPM2_Load command
	*
	* @chip: TPM chip to use
	* @payload: the key data in clear and encrypted form
	* @options: authentication values and other options
	* @blob_handle: returned blob handle
	*
	* Return: 0 on success.
	* -E2BIG on wrong payload size.
	* -EPERM on tpm error status.
	* < 0 error from tpm_send.
	*/
	static int tpm2_load_cmd(struct tpm_chip *chip,
	struct trusted_key_payload *payload,
	struct trusted_key_options *options,
	u32 *blob_handle)
	{
	struct tpm_buf buf;
	unsigned int private_len;
	unsigned int public_len;
	unsigned int blob_len;
	int rc;

	private_len = be16_to_cpup((__be16 *) &payload->blob[0]);
	if (private_len > (payload->blob_len - 2))
	return -E2BIG;

	public_len = be16_to_cpup((__be16 *) &payload->blob[2 + private_len]);
	blob_len = private_len + public_len + 4;
	if (blob_len > payload->blob_len)
	return -E2BIG;

	rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_LOAD);
	if (rc)
	return rc;

	tpm_buf_append_u32(&buf, options->keyhandle);
	tpm2_buf_append_auth(&buf, TPM2_RS_PW,
	NULL /* nonce */, 0,
	0 /* session_attributes */,
	options->keyauth /* hmac */,
	TPM_DIGEST_SIZE);

	tpm_buf_append(&buf, payload->blob, blob_len);

	if (buf.flags & TPM_BUF_OVERFLOW) {
	rc = -E2BIG;
	goto out;
	}

	rc = tpm_transmit_cmd(chip, &buf, 4, "loading blob");
	if (!rc)
	*blob_handle = be32_to_cpup(
	(__be32 *) &buf.data[TPM_HEADER_SIZE]);

	out:
	tpm_buf_destroy(&buf);

	if (rc > 0)
	rc = -EPERM;

	return rc;
	}

	/**
	* tpm2_unseal_cmd() - execute a TPM2_Unload command
	*
	* @chip: TPM chip to use
	* @payload: the key data in clear and encrypted form
	* @options: authentication values and other options
	* @blob_handle: blob handle
	*
	* Return: 0 on success
	* -EPERM on tpm error status
	* < 0 error from tpm_send
	*/
	static int tpm2_unseal_cmd(struct tpm_chip *chip,
	struct trusted_key_payload *payload,
	struct trusted_key_options *options,
	u32 blob_handle)
	{
	struct tpm_buf buf;
	u16 data_len;
	u8 *data;
	int rc;

	rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_UNSEAL);
	if (rc)
	return rc;

	tpm_buf_append_u32(&buf, blob_handle);
	tpm2_buf_append_auth(&buf,
	options->policyhandle ?
	options->policyhandle : TPM2_RS_PW,
	NULL /* nonce */, 0,
	TPM2_SA_CONTINUE_SESSION,
	options->blobauth /* hmac */,
	options->blobauth_len);

	rc = tpm_transmit_cmd(chip, &buf, 6, "unsealing");
	if (rc > 0)
	rc = -EPERM;

	if (!rc) {
	data_len = be16_to_cpup(
	(__be16 *) &buf.data[TPM_HEADER_SIZE + 4]);
	if (data_len < MIN_KEY_SIZE \|\| data_len > MAX_KEY_SIZE + 1) {
	rc = -EFAULT;
	goto out;
	}

	if (tpm_buf_length(&buf) < TPM_HEADER_SIZE + 6 + data_len) {
	rc = -EFAULT;
	goto out;
	}
	data = &buf.data[TPM_HEADER_SIZE + 6];

	memcpy(payload->key, data, data_len - 1);
	payload->key_len = data_len - 1;
	payload->migratable = data[data_len - 1];
	}

	out:
	tpm_buf_destroy(&buf);
	return rc;
	}

	/**
	* tpm2_unseal_trusted() - unseal the payload of a trusted key
	*
	* @chip: TPM chip to use
	* @payload: the key data in clear and encrypted form
	* @options: authentication values and other options
	*
	* Return: Same as with tpm_send.
	*/
	int tpm2_unseal_trusted(struct tpm_chip *chip,
	struct trusted_key_payload *payload,
	struct trusted_key_options *options)
	{
	u32 blob_handle;
	int rc;

	rc = tpm_try_get_ops(chip);
	if (rc)
	return rc;

	rc = tpm2_load_cmd(chip, payload, options, &blob_handle);
	if (rc)
	goto out;

	rc = tpm2_unseal_cmd(chip, payload, options, blob_handle);
	tpm2_flush_context(chip, blob_handle);

	out:
	tpm_put_ops(chip);

	return rc;
	}