tpm: tpm1: rewrite tpm1_get_random() using tpm_buf structure (7aee9c52) · Commits · 戴 / test

drivers/char/tpm/tpm-interface.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -600,7 +600,7 @@ EXPORT_SYMBOL_GPL(tpm_pm_resume);
	* @out: destination buffer for the random bytes		* @out: destination buffer for the random bytes
	* @max: the max number of bytes to write to @out		* @max: the max number of bytes to write to @out
	*		*
	* Return: same as with tpm_transmit_cmd()		* Return: number of random bytes read or a negative error value.
	*/		*/
	int tpm_get_random(struct tpm_chip chip, u8 out, size_t max)		int tpm_get_random(struct tpm_chip chip, u8 out, size_t max)
	{		{

drivers/char/tpm/tpm.h

+0 −11

Original line number	Original line	Diff line number	Diff line
	@@ -396,20 +396,9 @@ struct tpm_pcrread_in {
	* compiler warnings about stack frame size. */		* compiler warnings about stack frame size. */
	#define TPM_MAX_RNG_DATA 128		#define TPM_MAX_RNG_DATA 128

	struct tpm_getrandom_out {
	__be32 rng_data_len;
	u8 rng_data[TPM_MAX_RNG_DATA];
	} __packed;

	struct tpm_getrandom_in {
	__be32 num_bytes;
	} __packed;

	typedef union {		typedef union {
	struct tpm_pcrread_in pcrread_in;		struct tpm_pcrread_in pcrread_in;
	struct tpm_pcrread_out pcrread_out;		struct tpm_pcrread_out pcrread_out;
	struct tpm_getrandom_in getrandom_in;
	struct tpm_getrandom_out getrandom_out;
	} tpm_cmd_params;		} tpm_cmd_params;

	struct tpm_cmd_t {		struct tpm_cmd_t {

drivers/char/tpm/tpm1-cmd.c

+48 −36

Original line number	Original line	Diff line number	Diff line
	@@ -505,58 +505,70 @@ ssize_t tpm1_getcap(struct tpm_chip chip, u32 subcap_id, cap_t cap,
	EXPORT_SYMBOL_GPL(tpm1_getcap);		EXPORT_SYMBOL_GPL(tpm1_getcap);

	#define TPM_ORD_GET_RANDOM 70		#define TPM_ORD_GET_RANDOM 70
	#define TPM_GETRANDOM_RESULT_SIZE 18		struct tpm1_get_random_out {
	static const struct tpm_input_header tpm_getrandom_header = {		__be32 rng_data_len;
	.tag = cpu_to_be16(TPM_TAG_RQU_COMMAND),		u8 rng_data[TPM_MAX_RNG_DATA];
	.length = cpu_to_be32(14),		} __packed;
	.ordinal = cpu_to_be32(TPM_ORD_GET_RANDOM)
	};

	int tpm1_get_random(struct tpm_chip chip, u8 out, size_t max)		/**
			* tpm1_get_random() - get random bytes from the TPM's RNG
			* @chip: a &struct tpm_chip instance
			* @dest: destination buffer for the random bytes
			* @max: the maximum number of bytes to write to @dest
			*
			* Return:
			* * number of bytes read
			* * -errno or a TPM return code otherwise
			*/
			int tpm1_get_random(struct tpm_chip chip, u8 dest, size_t max)
	{		{
	struct tpm_cmd_t tpm_cmd;		struct tpm1_get_random_out *out;
	u32 recd;
	u32 num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA);		u32 num_bytes = min_t(u32, max, TPM_MAX_RNG_DATA);
	u32 rlength;		struct tpm_buf buf;
	int err, total = 0, retries = 5;		u32 total = 0;
	u8 *dest = out;		int retries = 5;
			u32 recd;
			int rc;

	if (!out \|\| !num_bytes \|\| max > TPM_MAX_RNG_DATA)		rc = tpm_buf_init(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
	return -EINVAL;		if (rc)
			return rc;

	do {		do {
	tpm_cmd.header.in = tpm_getrandom_header;		tpm_buf_append_u32(&buf, num_bytes);
	tpm_cmd.params.getrandom_in.num_bytes = cpu_to_be32(num_bytes);

	err = tpm_transmit_cmd(chip, NULL, &tpm_cmd,
	TPM_GETRANDOM_RESULT_SIZE + num_bytes,
	offsetof(struct tpm_getrandom_out,
	rng_data),
	0, "attempting get random");
	if (err)
	break;

	recd = be32_to_cpu(tpm_cmd.params.getrandom_out.rng_data_len);		rc = tpm_transmit_cmd(chip, NULL, buf.data, PAGE_SIZE,
			sizeof(out->rng_data_len), 0,
			"attempting get random");
			if (rc)
			goto out;

			out = (struct tpm1_get_random_out *)&buf.data[TPM_HEADER_SIZE];

			recd = be32_to_cpu(out->rng_data_len);
	if (recd > num_bytes) {		if (recd > num_bytes) {
	total = -EFAULT;		rc = -EFAULT;
	break;		goto out;
	}		}

	rlength = be32_to_cpu(tpm_cmd.header.out.length);		if (tpm_buf_length(&buf) < TPM_HEADER_SIZE +
	if (rlength < TPM_HEADER_SIZE +		sizeof(out->rng_data_len) + recd) {
	offsetof(struct tpm_getrandom_out, rng_data) +		rc = -EFAULT;
	recd) {		goto out;
	total = -EFAULT;
	break;
	}		}
	memcpy(dest, tpm_cmd.params.getrandom_out.rng_data, recd);		memcpy(dest, out->rng_data, recd);

	dest += recd;		dest += recd;
	total += recd;		total += recd;
	num_bytes -= recd;		num_bytes -= recd;
	} while (retries-- && (size_t)total < max);

	return total ? total : -EIO;		tpm_buf_reset(&buf, TPM_TAG_RQU_COMMAND, TPM_ORD_GET_RANDOM);
			} while (retries-- && total < max);

			rc = total ? (int)total : -EIO;
			out:
			tpm_buf_destroy(&buf);
			return rc;
	}		}

	#define TPM_ORDINAL_PCRREAD 21		#define TPM_ORDINAL_PCRREAD 21

Admin message