From patchwork Sun Dec 8 05:07:39 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278085 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 5A2AA930 for ; Sun, 8 Dec 2019 05:07:41 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 33D2020663 for ; Sun, 8 Dec 2019 05:07:41 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="td4L18ub"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="td4L18ub" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFHl (ORCPT ); Sun, 8 Dec 2019 00:07:41 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:57906 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFHk (ORCPT ); Sun, 8 Dec 2019 00:07:40 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id 8DC298EE111; Sat, 7 Dec 2019 21:07:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781660; bh=jxHUM77eqJO5qfEFU52k7jSyyIBkY1ic8+uFx5h04xY=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=td4L18ubp5k2lVynxVvoP5s2g8iXhcb5uJrZgdCiCE+c+E7MjJdZIIODRYUsFUE58 VZRdqB1TVgOJ2CRfgViJRvcFqvl0X/o/S2U3RyHU2KUj8K8kkcjBwDPD0CIkBH6KCR am8ZDoRovVItt7NL4T0TtiBQKi2e1R69597ozuwU= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ZiMFNXracJ7I; Sat, 7 Dec 2019 21:07:40 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id 2DD318EE109; Sat, 7 Dec 2019 21:07:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781660; bh=jxHUM77eqJO5qfEFU52k7jSyyIBkY1ic8+uFx5h04xY=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=td4L18ubp5k2lVynxVvoP5s2g8iXhcb5uJrZgdCiCE+c+E7MjJdZIIODRYUsFUE58 VZRdqB1TVgOJ2CRfgViJRvcFqvl0X/o/S2U3RyHU2KUj8K8kkcjBwDPD0CIkBH6KCR am8ZDoRovVItt7NL4T0TtiBQKi2e1R69597ozuwU= Message-ID: <1575781659.14069.9.camel@HansenPartnership.com> Subject: [PATCH 1/8] security: keys: trusted: flush the key handle after use From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:07:39 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org The trusted keys code currently loads a blob into the TPM and unseals on the handle. However, it never flushes the handle meaning that volatile contexts build up until the TPM becomes unusable. Fix this by flushing the handle after the unseal. Signed-off-by: James Bottomley --- drivers/char/tpm/tpm.h | 1 - drivers/char/tpm/tpm2-cmd.c | 1 + include/linux/tpm.h | 1 + security/keys/trusted-keys/trusted_tpm2.c | 1 + 4 files changed, 3 insertions(+), 1 deletion(-) diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h index b9e1547be6b5..5620747da0cf 100644 --- a/drivers/char/tpm/tpm.h +++ b/drivers/char/tpm/tpm.h @@ -218,7 +218,6 @@ int tpm2_pcr_read(struct tpm_chip *chip, u32 pcr_idx, int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, struct tpm_digest *digests); int tpm2_get_random(struct tpm_chip *chip, u8 *dest, size_t max); -void tpm2_flush_context(struct tpm_chip *chip, u32 handle); ssize_t tpm2_get_tpm_pt(struct tpm_chip *chip, u32 property_id, u32 *value, const char *desc); diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c index fdb457704aa7..b87592f4a6c7 100644 --- a/drivers/char/tpm/tpm2-cmd.c +++ b/drivers/char/tpm/tpm2-cmd.c @@ -362,6 +362,7 @@ void tpm2_flush_context(struct tpm_chip *chip, u32 handle) tpm_transmit_cmd(chip, &buf, 0, "flushing context"); tpm_buf_destroy(&buf); } +EXPORT_SYMBOL(tpm2_flush_context); struct tpm2_get_cap_out { u8 more_data; diff --git a/include/linux/tpm.h b/include/linux/tpm.h index 0d6e949ba315..03e9b184411b 100644 --- a/include/linux/tpm.h +++ b/include/linux/tpm.h @@ -403,6 +403,7 @@ extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, extern int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen); extern int tpm_get_random(struct tpm_chip *chip, u8 *data, size_t max); extern struct tpm_chip *tpm_default_chip(void); +void tpm2_flush_context(struct tpm_chip *chip, u32 handle); #else static inline int tpm_is_tpm2(struct tpm_chip *chip) { diff --git a/security/keys/trusted-keys/trusted_tpm2.c b/security/keys/trusted-keys/trusted_tpm2.c index a9810ac2776f..08ec7f48f01d 100644 --- a/security/keys/trusted-keys/trusted_tpm2.c +++ b/security/keys/trusted-keys/trusted_tpm2.c @@ -309,6 +309,7 @@ int tpm2_unseal_trusted(struct tpm_chip *chip, return rc; rc = tpm2_unseal_cmd(chip, payload, options, blob_handle); + tpm2_flush_context(chip, blob_handle); return rc; } From patchwork Sun Dec 8 05:08:26 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278087 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 4A3C81575 for ; Sun, 8 Dec 2019 05:08:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 1ED86206DB for ; Sun, 8 Dec 2019 05:08:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="rwxNCvFX"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="rwxNCvFX" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFI1 (ORCPT ); Sun, 8 Dec 2019 00:08:27 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:57936 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFI1 (ORCPT ); Sun, 8 Dec 2019 00:08:27 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id 571498EE111; Sat, 7 Dec 2019 21:08:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781707; bh=d8XmJLHG2KvR8/wFOzE43Ab6rHOw76OKGKMT856owok=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=rwxNCvFXoVWJEZ6PdAUm2ahsmAivgNVTa2Qvsebh9tIMangdbUcNXfQ6AtR+ri61p lJLc4dhBJSIa1QI12GgEsvWGtL1kyvLI6OwYrdN0IMNmf02yAXqCQamPqLsv5Tf3V3 LyEGwZdj7m8+btiFE44l0e+lYti1+ozKS90HKBmw= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id YF4fGu__LjVP; Sat, 7 Dec 2019 21:08:27 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id E65E48EE109; Sat, 7 Dec 2019 21:08:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781707; bh=d8XmJLHG2KvR8/wFOzE43Ab6rHOw76OKGKMT856owok=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=rwxNCvFXoVWJEZ6PdAUm2ahsmAivgNVTa2Qvsebh9tIMangdbUcNXfQ6AtR+ri61p lJLc4dhBJSIa1QI12GgEsvWGtL1kyvLI6OwYrdN0IMNmf02yAXqCQamPqLsv5Tf3V3 LyEGwZdj7m8+btiFE44l0e+lYti1+ozKS90HKBmw= Message-ID: <1575781706.14069.10.camel@HansenPartnership.com> Subject: [PATCH 2/8] lib: add asn.1 encoder From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:08:26 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org We have a need in the TPM trusted keys to return the ASN.1 form of the TPM key blob so it can be operated on by tools outside of the kernel. To do that, we have to be able to read and write the key format. The current ASN.1 decoder does fine for reading, but we need pieces of an ASN.1 encoder to return the key blob. The current implementation only encodes the ASN.1 bits we actually need. Signed-off-by: James Bottomley --- include/linux/asn1_encoder.h | 21 +++++ lib/Makefile | 2 +- lib/asn1_encoder.c | 201 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 223 insertions(+), 1 deletion(-) create mode 100644 include/linux/asn1_encoder.h create mode 100644 lib/asn1_encoder.c diff --git a/include/linux/asn1_encoder.h b/include/linux/asn1_encoder.h new file mode 100644 index 000000000000..0e908d748c8e --- /dev/null +++ b/include/linux/asn1_encoder.h @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +#ifndef _LINUX_ASN1_ENCODER_H +#define _LINUX_ASN1_ENCODER_H + +#include +#include +#include + +#define asn1_oid_len(oid) (sizeof(oid)/sizeof(u32)) +void asn1_encode_integer(unsigned char **_data, u64 integer); +void asn1_encode_oid(unsigned char **_data, u32 oid[], int oid_len); +void asn1_encode_tag(unsigned char **data, u32 tag, + const unsigned char *string, u32 len); +void asn1_encode_octet_string(unsigned char **data, const unsigned char *string, + u32 len); +void asn1_encode_sequence(unsigned char **data, const unsigned char *seq, + u32 len); +void asn1_encode_boolean(unsigned char **data, bool val); + +#endif diff --git a/lib/Makefile b/lib/Makefile index c2f0e2a4e4e8..515b35f92c3c 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -233,7 +233,7 @@ obj-$(CONFIG_INTERVAL_TREE_TEST) += interval_tree_test.o obj-$(CONFIG_PERCPU_TEST) += percpu_test.o -obj-$(CONFIG_ASN1) += asn1_decoder.o +obj-$(CONFIG_ASN1) += asn1_decoder.o asn1_encoder.o obj-$(CONFIG_FONT_SUPPORT) += fonts/ diff --git a/lib/asn1_encoder.c b/lib/asn1_encoder.c new file mode 100644 index 000000000000..2a3b96761344 --- /dev/null +++ b/lib/asn1_encoder.c @@ -0,0 +1,201 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Simple encoder primitives for ASN.1 BER/DER/CER + * + * Copyright (C) 2019 James.Bottomley@HansenPartnership.com + */ + +#include +#include +#include +#include + +/** + * asn1_encode_integer - encode positive integer to ASN.1 + * @_data: pointer to the pointer to the data + * @integer: integer to be encoded + * + * This is a simplified encoder: since we know the integer is + * positive we don't have to bother with twos complement and since we + * know the largest integer is a u64, we know the max length is 8. + */ +void asn1_encode_integer(unsigned char **_data, u64 integer) +{ + unsigned char *data = *_data, *d = &data[2]; + int i; + bool found = false; + + data[0] = _tag(UNIV, PRIM, INT); + if (integer == 0) { + *d++ = 0; + goto out; + } + for (i = sizeof(integer); i > 0 ; i--) { + int byte = integer >> (8*(i-1)); + + if (!found && byte == 0) + continue; + found = true; + if (byte & 0x80) + *d++ = 0; + *d++ = byte; + } + out: + data[1] = d - data - 2; + *_data = d; +} +EXPORT_SYMBOL(asn1_encode_integer); + +/* calculate the base 128 digit values setting the top bit of the first octet */ +static void asn1_encode_oid_digit(unsigned char **_data, u32 oid) +{ + int start = 7 + 7 + 7 + 7; + unsigned char *data = *_data; + + /* quick case */ + if (oid == 0) { + *data++ = 0x80; + goto out; + } + + while (oid >> start == 0) + start -= 7; + + while (start > 0) { + u8 byte; + + byte = oid >> start; + oid = oid - (byte << start); + start -= 7; + byte |= 0x80; + *data++ = byte; + } + *data++ = oid; + + out: + *_data = data; +} + +/** + * asn1_encode_oid - encode an oid to ASN.1 + * @_data: position to begin encoding at + * @oid: array of oids + * @oid_len: length of oid array + * + * this encodes an OID up to ASN.1 when presented as an array of OID values + */ +void asn1_encode_oid(unsigned char **_data, u32 oid[], int oid_len) +{ + unsigned char *data = *_data; + unsigned char *d = data + 2; + int i; + + if (WARN(oid_len < 2, "OID must have at least two elements")) + return; + if (WARN(oid_len > 32, "OID is too large")) + return; + + data[0] = _tag(UNIV, PRIM, OID); + *d++ = oid[0] * 40 + oid[1]; + for (i = 2; i < oid_len; i++) + asn1_encode_oid_digit(&d, oid[i]); + data[1] = d - data - 2; + *_data = d; +} +EXPORT_SYMBOL(asn1_encode_oid); + +static void asn1_encode_definite_length(unsigned char **data, u32 len) +{ + if (len <= 0x7f) { + *((*data)++) = len; + return; + } + if (len <= 0xff) { + *((*data)++) = 0x81; + *((*data)++) = len & 0xff; + return; + } + if (len <= 0xffff) { + *((*data)++) = 0x82; + *((*data)++) = (len >> 8) & 0xff; + *((*data)++) = len & 0xff; + return; + } + + if (WARN(len > 0xffffff, "ASN.1 length can't be > 0xffffff")) + return; + + *((*data)++) = 0x83; + *((*data)++) = (len >> 16) & 0xff; + *((*data)++) = (len >> 8) & 0xff; + *((*data)++) = len & 0xff; +} + +/** + * asn1_encode_tag - add a tag for optional or explicit value + * @data: pointer to place tag at + * @tag: tag to be placed + * @string: the data to be tagged + * @len: the length of the data to be tagged + * + * Note this currently only handles short form tags < 31 + */ +void asn1_encode_tag(unsigned char **data, u32 tag, + const unsigned char *string, u32 len) +{ + if (WARN(tag > 30, "ASN.1 tag can't be > 30")) + return; + + *((*data)++) = _tagn(CONT, CONS, tag); + asn1_encode_definite_length(data, len); + memcpy(*data, string, len); + *data += len; +} +EXPORT_SYMBOL(asn1_encode_tag); + +/** + * asn1_encode_octet_string - encode an ASN.1 OCTET STRING + * @data: pointer to encode at + * @string: string to be encoded + * @len: length of string + * + * Note ASN.1 octet strings may contain zeros, so the length is obligatory. + */ +void asn1_encode_octet_string(unsigned char **data, const unsigned char *string, + u32 len) +{ + *((*data)++) = _tag(UNIV, PRIM, OTS); + asn1_encode_definite_length(data, len); + memcpy(*data, string, len); + *data += len; +} +EXPORT_SYMBOL(asn1_encode_octet_string); + +/** + * asn1_encode_sequence - wrap a byte stream in an ASN.1 SEQUENCE + * @data: pointer to encode at + * @seq: data to be encoded as a sequence + * @len: length of the data to be encoded as a sequence + */ +void asn1_encode_sequence(unsigned char **data, const unsigned char *seq, + u32 len) +{ + *((*data)++) = _tag(UNIV, CONS, SEQ); + asn1_encode_definite_length(data, len); + memcpy(*data, seq, len); + *data += len; +} +EXPORT_SYMBOL(asn1_encode_sequence); + +/** + * asn1_encode_boolean - encode a boolean value to ASN.1 + * @data: pointer to encode at + * @val: the boolean true/false value + */ +void asn1_encode_boolean(unsigned char **data, bool val) +{ + *((*data)++) = _tag(UNIV, PRIM, BOOL); + asn1_encode_definite_length(data, 1); + *((*data)++) = val ? 1 : 0; +} +EXPORT_SYMBOL(asn1_encode_boolean); From patchwork Sun Dec 8 05:09:06 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278089 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id DDB021575 for ; Sun, 8 Dec 2019 05:09:07 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id B9A4F206DB for ; Sun, 8 Dec 2019 05:09:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="Bm9pjvmm"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="sfkT7AZr" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725306AbfLHFJH (ORCPT ); Sun, 8 Dec 2019 00:09:07 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:57964 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725268AbfLHFJH (ORCPT ); Sun, 8 Dec 2019 00:09:07 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id 24A818EE111; Sat, 7 Dec 2019 21:09:07 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781747; bh=4FmAxKQz7ECJGSh7N2RP7M0+Pg0ss+HhRBx0TU9I6GY=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=Bm9pjvmmz6wg/E0iezCLlx9qk21tRiYnMImnW8ayUTbmk8eVshsX+EHJMYP1LPREo /yfhHx0npoUUeUTLSqVDXH+3caTtBnyA8do56gOUmivSkReIXBWW8OrSLuoZo6dKdz q3U3VYrHtvs7KTr2asfPZ1DrI6IAXbT5+8o5ukIU= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id WpH-3atotCnY; Sat, 7 Dec 2019 21:09:06 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id A73B28EE109; Sat, 7 Dec 2019 21:09:06 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781746; bh=4FmAxKQz7ECJGSh7N2RP7M0+Pg0ss+HhRBx0TU9I6GY=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=sfkT7AZr+OVB3Oh9mDKNAbv3N0g+cVMx1oviyc2OjWAw1/fo1c4mgAmgvGLlVseV3 +d/KdFflHLHY9zrmScYEo0qjhMRfiYobM+1nflU1kBzLlDEaKggrTBNVUwyaR26qpR 1OgVvRUZn+tUJ1Cp4jAkFnOrbUQJywJdDYidZplg= Message-ID: <1575781746.14069.11.camel@HansenPartnership.com> Subject: [PATCH 3/8] oid_registry: Add TCG defined OIDS for TPM keys From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:09:06 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org The TCG has defined an OID prefix "2.23.133.10.1" for the various TPM key uses. We've defined three of the available numbers: 2.23.133.10.1.3 TPM Loadable key. This is an asymmetric key (Usually RSA2048 or Elliptic Curve) which can be imported by a TPM2_Load() operation. 2.23.133.10.1.4 TPM Importable Key. This is an asymmetric key (Usually RSA2048 or Elliptic Curve) which can be imported by a TPM2_Import() operation. Both loadable and importable keys are specific to a given TPM, the difference is that a loadable key is wrapped with the symmetric secret, so must have been created by the TPM itself. An importable key is wrapped with a DH shared secret, and may be created without access to the TPM provided you know the public part of the parent key. 2.23.133.10.1.5 TPM Sealed Data. This is a set of data (up to 128 bytes) which is sealed by the TPM. It usually represents a symmetric key and must be unsealed before use. Signed-off-by: James Bottomley --- include/linux/oid_registry.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/linux/oid_registry.h b/include/linux/oid_registry.h index 657d6bf2c064..a4cee888f9b0 100644 --- a/include/linux/oid_registry.h +++ b/include/linux/oid_registry.h @@ -107,6 +107,11 @@ enum OID { OID_gostTC26Sign512B, /* 1.2.643.7.1.2.1.2.2 */ OID_gostTC26Sign512C, /* 1.2.643.7.1.2.1.2.3 */ + /* TCG defined OIDS for TPM based keys */ + OID_TPMLoadableKey, /* 2.23.133.10.1.3 */ + OID_TPMImporableKey, /* 2.23.133.10.1.4 */ + OID_TPMSealedData, /* 2.23.133.10.1.5 */ + OID__NR }; From patchwork Sun Dec 8 05:10:31 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278091 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 0B7491575 for ; Sun, 8 Dec 2019 05:10:33 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C197D206D6 for ; Sun, 8 Dec 2019 05:10:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="v34Kn/Da"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="MyllRyI0" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFKc (ORCPT ); Sun, 8 Dec 2019 00:10:32 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:58006 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFKc (ORCPT ); Sun, 8 Dec 2019 00:10:32 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id 038978EE111; Sat, 7 Dec 2019 21:10:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781832; bh=/rTl1L/VN7aIxSXMhw1XCI6oGGa1VCCqGdKgokJbQTM=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=v34Kn/Daw0U0Yx1Qn4yrIKN6aT20pzBCwe6Hdo/DJCmR3GBsKeFQEXtueyAzac76T B3HwU3HbPhEugmS0YLbDuhG1kjxXHjzUwq6zZlqDR9BntwrLUjxGu70uJgOqMmZx5J hwLQk8nu+Yi9HX46OtpzP5Nao+DE0KC3Q580+A9U= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id UTBSLjDzTCqB; Sat, 7 Dec 2019 21:10:31 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id 9A7C98EE109; Sat, 7 Dec 2019 21:10:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781831; bh=/rTl1L/VN7aIxSXMhw1XCI6oGGa1VCCqGdKgokJbQTM=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=MyllRyI0iQ40eDeRVOU9O4mwFDk4YioAHwHiR18DJFXPAVkL+uCfY+ygC67nNY+Uv hxoKgGaesOcbODz56o92VsBgjUiM5TImAT2obmT+5XvUchThfBUwrs0/ly9R3fL65t YTc45aevEqjwC/Lo8eESJs5z/1sEpAEx+fmvbNig= Message-ID: <1575781831.14069.13.camel@HansenPartnership.com> Subject: [PATCH 4/8] security: keys: trusted: use ASN.1 tpm2 key format for the blobs From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:10:31 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org Modify the tpm2 key format blob output to export and import in the ASN.1 form for tpm2 sealed object keys. For compatibility with prior trusted keys, the importer will also accept two tpm2b quantities representing the public and private parts of the key. However, the export via keyctl pipe will only output the ASN.1 format. The benefit of the ASN.1 format is that it's a standard and thus the exported key can be used by userspace tools. The format includes policy specifications, thus it gets us out of having to construct policy handles in userspace and the format includes the parent meaning you don't have to keep passing it in each time. This patch only implements basic handling for the ASN.1 format, so keys with passwords but no policy. Signed-off-by: James Bottomley --- security/keys/trusted-keys/Makefile | 2 +- security/keys/trusted-keys/tpm2key.asn1 | 23 ++++ security/keys/trusted-keys/trusted_tpm1.c | 2 +- security/keys/trusted-keys/trusted_tpm2.c | 170 +++++++++++++++++++++++++++++- 4 files changed, 190 insertions(+), 7 deletions(-) create mode 100644 security/keys/trusted-keys/tpm2key.asn1 diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-keys/Makefile index 7b73cebbb378..e0198641eff2 100644 --- a/security/keys/trusted-keys/Makefile +++ b/security/keys/trusted-keys/Makefile @@ -5,4 +5,4 @@ obj-$(CONFIG_TRUSTED_KEYS) += trusted.o trusted-y += trusted_tpm1.o -trusted-y += trusted_tpm2.o +trusted-y += trusted_tpm2.o tpm2key.asn1.o diff --git a/security/keys/trusted-keys/tpm2key.asn1 b/security/keys/trusted-keys/tpm2key.asn1 new file mode 100644 index 000000000000..1851b7c80f08 --- /dev/null +++ b/security/keys/trusted-keys/tpm2key.asn1 @@ -0,0 +1,23 @@ +--- +--- Note: This isn't quite the definition in the standard +--- However, the Linux asn.1 parser doesn't understand +--- [2] EXPLICIT SEQUENCE OF OPTIONAL +--- So there's an extra intermediate TPMPolicySequence +--- definition to work around this + +TPMKey ::= SEQUENCE { + type OBJECT IDENTIFIER ({tpmkey_type}), + emptyAuth [0] EXPLICIT BOOLEAN OPTIONAL, + policy [1] EXPLICIT TPMPolicySequence OPTIONAL, + secret [2] EXPLICIT OCTET STRING OPTIONAL, + parent INTEGER ({tpmkey_parent}), + pubkey OCTET STRING ({tpmkey_pub}), + privkey OCTET STRING ({tpmkey_priv}) + } + +TPMPolicySequence ::= SEQUENCE OF TPMPolicy + +TPMPolicy ::= SEQUENCE { + commandCode [0] EXPLICIT INTEGER, + commandPolicy [1] EXPLICIT OCTET STRING + } diff --git a/security/keys/trusted-keys/trusted_tpm1.c b/security/keys/trusted-keys/trusted_tpm1.c index d2c5ec1e040b..d744a0d1cb89 100644 --- a/security/keys/trusted-keys/trusted_tpm1.c +++ b/security/keys/trusted-keys/trusted_tpm1.c @@ -991,7 +991,7 @@ static int trusted_instantiate(struct key *key, goto out; } - if (!options->keyhandle) { + if (!options->keyhandle && !tpm2) { ret = -EINVAL; goto out; } diff --git a/security/keys/trusted-keys/trusted_tpm2.c b/security/keys/trusted-keys/trusted_tpm2.c index 08ec7f48f01d..4efc7b64d1cd 100644 --- a/security/keys/trusted-keys/trusted_tpm2.c +++ b/security/keys/trusted-keys/trusted_tpm2.c @@ -4,6 +4,8 @@ * Copyright (C) 2014 Intel Corporation */ +#include +#include #include #include #include @@ -12,6 +14,10 @@ #include #include +#include + +#include "tpm2key.asn1.h" + static struct tpm2_hash tpm2_hash_map[] = { {HASH_ALGO_SHA1, TPM_ALG_SHA1}, {HASH_ALGO_SHA256, TPM_ALG_SHA256}, @@ -20,6 +26,141 @@ static struct tpm2_hash tpm2_hash_map[] = { {HASH_ALGO_SM3_256, TPM_ALG_SM3_256}, }; +static u32 tpm2key_oid[] = { 2,23,133,10,1,5 }; + +static int tpm2_key_encode(struct trusted_key_payload *payload, + struct trusted_key_options *options, + u8 *src, u32 len) +{ + u8 *scratch = kmalloc(PAGE_SIZE, GFP_KERNEL); + u8 *work = scratch, *work1; + u8 *priv, *pub; + u16 priv_len, pub_len; + + priv_len = get_unaligned_be16(src); + src += 2; + priv = src; + src += priv_len; + pub_len = get_unaligned_be16(src); + src += 2; + pub = src; + + if (!scratch) + return -ENOMEM; + + asn1_encode_oid(&work, tpm2key_oid, asn1_oid_len(tpm2key_oid)); + if (options->blobauth[0] == 0) { + unsigned char bool[3], *w = bool; + /* tag 0 is emptyAuth */ + asn1_encode_boolean(&w, true); + asn1_encode_tag(&work, 0, bool, w - bool); + } + asn1_encode_integer(&work, options->keyhandle); + asn1_encode_octet_string(&work, pub, pub_len); + asn1_encode_octet_string(&work, priv, priv_len); + + work1 = payload->blob; + asn1_encode_sequence(&work1, scratch, work - scratch); + + return work1 - payload->blob; +} + +struct tpm2key_context { + u32 parent; + const u8 *pub; + u32 pub_len; + const u8 *priv; + u32 priv_len; +}; + +static int tpm2_key_decode(struct trusted_key_payload *payload, + struct trusted_key_options *options, + u8 **buf) +{ + int ret; + struct tpm2key_context ctx; + u8 *blob; + + ret = asn1_ber_decoder(&tpm2key_decoder, &ctx, payload->blob, + payload->blob_len); + if (ret < 0) + return ret; + + if (ctx.priv_len + ctx.pub_len > MAX_BLOB_SIZE) + return -EINVAL; + + blob = kmalloc(ctx.priv_len + ctx.pub_len + 4, GFP_KERNEL); + if (!blob) + return -ENOMEM; + + *buf = blob; + options->keyhandle = ctx.parent; + put_unaligned_be16(ctx.priv_len, blob); + blob += 2; + memcpy(blob, ctx.priv, ctx.priv_len); + blob += ctx.priv_len; + put_unaligned_be16(ctx.pub_len, blob); + blob += 2; + memcpy(blob, ctx.pub, ctx.pub_len); + + return 0; +} + +int tpmkey_parent(void *context, size_t hdrlen, + unsigned char tag, + const void *value, size_t vlen) +{ + struct tpm2key_context *ctx = context; + const u8 *v = value; + int i; + + ctx->parent = 0; + for (i = 0; i < vlen; i++) { + ctx->parent <<= 8; + ctx->parent |= v[i]; + } + return 0; +} + +int tpmkey_type(void *context, size_t hdrlen, + unsigned char tag, + const void *value, size_t vlen) +{ + enum OID oid = look_up_OID(value, vlen); + + if (oid != OID_TPMSealedData) { + char buffer[50]; + + sprint_oid(value, vlen, buffer, sizeof(buffer)); + pr_debug("OID is \"%s\" which is not TPMSealedData\n", + buffer); + return -EINVAL; + } + return 0; +} + +int tpmkey_pub(void *context, size_t hdrlen, + unsigned char tag, + const void *value, size_t vlen) +{ + struct tpm2key_context *ctx = context; + + ctx->pub = value; + ctx->pub_len = vlen; + return 0; +} + +int tpmkey_priv(void *context, size_t hdrlen, + unsigned char tag, + const void *value, size_t vlen) +{ + struct tpm2key_context *ctx = context; + + ctx->priv = value; + ctx->priv_len = vlen; + return 0; +} + /** * tpm_buf_append_auth() - append TPMS_AUTH_COMMAND to the buffer. * @@ -79,6 +220,9 @@ int tpm2_seal_trusted(struct tpm_chip *chip, if (i == ARRAY_SIZE(tpm2_hash_map)) return -EINVAL; + if (!options->keyhandle) + return -EINVAL; + rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_CREATE); if (rc) return rc; @@ -144,8 +288,10 @@ int tpm2_seal_trusted(struct tpm_chip *chip, goto out; } - memcpy(payload->blob, &buf.data[TPM_HEADER_SIZE + 4], blob_len); - payload->blob_len = blob_len; + payload->blob_len = + tpm2_key_encode(payload, options, + &buf.data[TPM_HEADER_SIZE + 4], + blob_len); out: tpm_buf_destroy(&buf); @@ -156,6 +302,8 @@ int tpm2_seal_trusted(struct tpm_chip *chip, else rc = -EPERM; } + if (payload->blob_len < 0) + return payload->blob_len; return rc; } @@ -182,13 +330,23 @@ static int tpm2_load_cmd(struct tpm_chip *chip, unsigned int private_len; unsigned int public_len; unsigned int blob_len; + u8 *blob; int rc; - private_len = be16_to_cpup((__be16 *) &payload->blob[0]); + rc = tpm2_key_decode(payload, options, &blob); + if (rc) + /* old form */ + blob = payload->blob; + + /* new format carries keyhandle but old format doesn't */ + if (!options->keyhandle) + return -EINVAL; + + private_len = be16_to_cpup((__be16 *) &blob[0]); if (private_len > (payload->blob_len - 2)) return -E2BIG; - public_len = be16_to_cpup((__be16 *) &payload->blob[2 + private_len]); + public_len = be16_to_cpup((__be16 *) &blob[2 + private_len]); blob_len = private_len + public_len + 4; if (blob_len > payload->blob_len) return -E2BIG; @@ -204,7 +362,7 @@ static int tpm2_load_cmd(struct tpm_chip *chip, options->keyauth /* hmac */, TPM_DIGEST_SIZE); - tpm_buf_append(&buf, payload->blob, blob_len); + tpm_buf_append(&buf, blob, blob_len); if (buf.flags & TPM_BUF_OVERFLOW) { rc = -E2BIG; @@ -217,6 +375,8 @@ static int tpm2_load_cmd(struct tpm_chip *chip, (__be32 *) &buf.data[TPM_HEADER_SIZE]); out: + if (blob != payload->blob) + kfree(blob); tpm_buf_destroy(&buf); if (rc > 0) From patchwork Sun Dec 8 05:11:28 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278093 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 826866C1 for ; Sun, 8 Dec 2019 05:11:30 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 54C25206D6 for ; Sun, 8 Dec 2019 05:11:30 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="ViEeZXV2"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="ViEeZXV2" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFLa (ORCPT ); Sun, 8 Dec 2019 00:11:30 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:58038 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFL3 (ORCPT ); Sun, 8 Dec 2019 00:11:29 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id A2E738EE111; Sat, 7 Dec 2019 21:11:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781889; bh=6P7ulO5kUsgANrqJX1Zkal2IAEF/3e1/uo3ekquTFIc=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=ViEeZXV27vC3GT3MLyFGdw3Sod/ik32VKF5/rTvDKW7zfPA2AVGE80ABh6s4dDXD+ xOjxnfX+OzX7g9s+lojAv/kE3Eaw892TgUs74qj3JXJaJAM3jpq0/9R2OyFJEBCUEF 6wCAPLTZDwmXiqga8RqjXtFhEAoBl0/ZAbSUAjS0= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id JlHvqPh5zn16; Sat, 7 Dec 2019 21:11:29 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id 325CB8EE109; Sat, 7 Dec 2019 21:11:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781889; bh=6P7ulO5kUsgANrqJX1Zkal2IAEF/3e1/uo3ekquTFIc=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=ViEeZXV27vC3GT3MLyFGdw3Sod/ik32VKF5/rTvDKW7zfPA2AVGE80ABh6s4dDXD+ xOjxnfX+OzX7g9s+lojAv/kE3Eaw892TgUs74qj3JXJaJAM3jpq0/9R2OyFJEBCUEF 6wCAPLTZDwmXiqga8RqjXtFhEAoBl0/ZAbSUAjS0= Message-ID: <1575781888.14069.14.camel@HansenPartnership.com> Subject: [PATCH 5/8] security: keys: trusted: Make sealed key properly interoperable From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:11:28 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org The current implementation appends a migratable flag to the end of a key, meaning the format isn't exactly interoperable because the using party needs to know to strip this extra byte. However, all other consumers of TPM sealed blobs expect the unseal to return exactly the key. Since TPM2 keys have a key property flag that corresponds to migratable, use that flag instead and make the actual key the only sealed quantity. This is secure because the key properties are bound to a hash in the private part, so if they're altered the key won't load. Backwards compatibility is implemented by detecting whether we're loading a new format key or not and correctly setting migratable from the last byte of old format keys. Signed-off-by: James Bottomley --- include/keys/trusted-type.h | 1 + include/linux/tpm.h | 2 ++ security/keys/trusted-keys/trusted_tpm2.c | 57 ++++++++++++++++++++++--------- 3 files changed, 44 insertions(+), 16 deletions(-) diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h index a94c03a61d8f..4728e13aada8 100644 --- a/include/keys/trusted-type.h +++ b/include/keys/trusted-type.h @@ -22,6 +22,7 @@ struct trusted_key_payload { unsigned int key_len; unsigned int blob_len; unsigned char migratable; + unsigned char old_format; unsigned char key[MAX_KEY_SIZE + 1]; unsigned char blob[MAX_BLOB_SIZE]; }; diff --git a/include/linux/tpm.h b/include/linux/tpm.h index 03e9b184411b..cd46ab27baa5 100644 --- a/include/linux/tpm.h +++ b/include/linux/tpm.h @@ -297,6 +297,8 @@ struct tpm_buf { }; enum tpm2_object_attributes { + TPM2_OA_FIXED_TPM = BIT(1), + TPM2_OA_FIXED_PARENT = BIT(4), TPM2_OA_USER_WITH_AUTH = BIT(6), }; diff --git a/security/keys/trusted-keys/trusted_tpm2.c b/security/keys/trusted-keys/trusted_tpm2.c index 4efc7b64d1cd..a34ab6f90f76 100644 --- a/security/keys/trusted-keys/trusted_tpm2.c +++ b/security/keys/trusted-keys/trusted_tpm2.c @@ -207,6 +207,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip, unsigned int blob_len; struct tpm_buf buf; u32 hash; + u32 flags; int i; int rc; @@ -235,29 +236,30 @@ int tpm2_seal_trusted(struct tpm_chip *chip, TPM_DIGEST_SIZE); /* sensitive */ - tpm_buf_append_u16(&buf, 4 + TPM_DIGEST_SIZE + payload->key_len + 1); + tpm_buf_append_u16(&buf, 4 + TPM_DIGEST_SIZE + payload->key_len); tpm_buf_append_u16(&buf, TPM_DIGEST_SIZE); tpm_buf_append(&buf, options->blobauth, TPM_DIGEST_SIZE); - tpm_buf_append_u16(&buf, payload->key_len + 1); + tpm_buf_append_u16(&buf, payload->key_len); 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); + /* key properties */ + flags = 0; + flags |= options->policydigest_len ? 0 : TPM2_OA_USER_WITH_AUTH; + flags |= payload->migratable ? (TPM2_OA_FIXED_TPM | + TPM2_OA_FIXED_PARENT) : 0; + tpm_buf_append_u32(&buf, flags); + /* policy */ - if (options->policydigest_len) { - tpm_buf_append_u32(&buf, 0); - tpm_buf_append_u16(&buf, options->policydigest_len); + tpm_buf_append_u16(&buf, options->policydigest_len); + if (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); @@ -330,13 +332,16 @@ static int tpm2_load_cmd(struct tpm_chip *chip, unsigned int private_len; unsigned int public_len; unsigned int blob_len; - u8 *blob; + u8 *blob, *pub; int rc; + u32 attrs; rc = tpm2_key_decode(payload, options, &blob); - if (rc) + if (rc) { /* old form */ blob = payload->blob; + payload->old_format = 1; + } /* new format carries keyhandle but old format doesn't */ if (!options->keyhandle) @@ -347,6 +352,16 @@ static int tpm2_load_cmd(struct tpm_chip *chip, return -E2BIG; public_len = be16_to_cpup((__be16 *) &blob[2 + private_len]); + + pub = blob + 2 + private_len + 2; + /* key attributes are always at offset 4 */ + attrs = get_unaligned_be32(pub + 4); + if ((attrs & (TPM2_OA_FIXED_TPM | TPM2_OA_FIXED_PARENT)) == + (TPM2_OA_FIXED_TPM | TPM2_OA_FIXED_PARENT)) + payload->migratable = 0; + else + payload->migratable = 1; + blob_len = private_len + public_len + 4; if (blob_len > payload->blob_len) return -E2BIG; @@ -427,7 +442,7 @@ static int tpm2_unseal_cmd(struct tpm_chip *chip, 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) { + if (data_len < MIN_KEY_SIZE || data_len > MAX_KEY_SIZE) { rc = -EFAULT; goto out; } @@ -438,9 +453,19 @@ static int tpm2_unseal_cmd(struct tpm_chip *chip, } 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]; + if (payload->old_format) { + /* migratable flag is at the end of the key */ + memcpy(payload->key, data, data_len - 1); + payload->key_len = data_len - 1; + payload->migratable = data[data_len - 1]; + } else { + /* + * migratable flag already collected from key + * attributes + */ + memcpy(payload->key, data, data_len); + payload->key_len = data_len; + } } out: From patchwork Sun Dec 8 05:12:37 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278095 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id CCA336C1 for ; Sun, 8 Dec 2019 05:12:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8C933206DB for ; Sun, 8 Dec 2019 05:12:39 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="MZhZEG34"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="MZhZEG34" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFMj (ORCPT ); Sun, 8 Dec 2019 00:12:39 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:58072 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFMj (ORCPT ); Sun, 8 Dec 2019 00:12:39 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id 8E6AE8EE111; Sat, 7 Dec 2019 21:12:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781958; bh=wO3PsZtGP32b3ZbgtK2QYbIQSOdMgCW/gsMm295FZY0=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=MZhZEG34YIdMbH5kL3bXHltlxeBHvnWhVKSfJwkUXVD0CSKCcYh6mFpXT5UZSX+38 5W6wTm3RWXesFbOhBNE43Cq8ex8iZTV26cxSRAqqt6LvWnMgaQewiU1eZbGHhfxD0l Vwn8JB83gh2x/F5cNVZrKZqTmUtCUb0AqbxNWi+Y= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id y3HKkWumlbNj; Sat, 7 Dec 2019 21:12:38 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id 1F6148EE109; Sat, 7 Dec 2019 21:12:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575781958; bh=wO3PsZtGP32b3ZbgtK2QYbIQSOdMgCW/gsMm295FZY0=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=MZhZEG34YIdMbH5kL3bXHltlxeBHvnWhVKSfJwkUXVD0CSKCcYh6mFpXT5UZSX+38 5W6wTm3RWXesFbOhBNE43Cq8ex8iZTV26cxSRAqqt6LvWnMgaQewiU1eZbGHhfxD0l Vwn8JB83gh2x/F5cNVZrKZqTmUtCUb0AqbxNWi+Y= Message-ID: <1575781957.14069.16.camel@HansenPartnership.com> Subject: [PATCH 6/8] security: keys: trusted: add PCR policy to TPM2 keys From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:12:37 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org This commit adds the ability to specify a PCR lock policy to TPM2 keys. There is a complexity in that the creator of the key must chose either to use a PCR lock policy or to use authentication. At the current time they can't use both due to a complexity with the way authentication works when policy registers are in use. The way to construct a pcrinfo statement for a key is simply to use the TPMS_PCR_SELECT structure to specify the PCRs and follow this by a hash of all their values in order of ascending PCR number. For simplicity, we require the policy name hash and the hash used for the PCRs to be the same. Thus to construct a policy around the value of the resettable PCR 16 using the sha1 bank, first reset the pcr to zero giving a hash of all zeros as: 6768033e216468247bd031a0a2d9876d79818f8f Then the TPMS_PCR_SELECT value for PCR 16 is 03000001 So create a new 32 byte key with a policy policy locking the key to this value of PCR 16 with a parent key of 81000001 would be: keyctl new 32 keyhandle=0x81000001 hash=sha1 pcrinfo=030000016768033e216468247bd031a0a2d9876d79818f8f" @u Signed-off-by: James Bottomley --- Documentation/security/keys/trusted-encrypted.rst | 25 +- include/keys/trusted-type.h | 5 +- include/linux/tpm.h | 5 + security/keys/Kconfig | 2 + security/keys/trusted-keys/Makefile | 2 +- security/keys/trusted-keys/tpm2-policy.c | 344 ++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.h | 30 ++ security/keys/trusted-keys/tpm2key.asn1 | 4 +- security/keys/trusted-keys/trusted_tpm1.c | 32 +- security/keys/trusted-keys/trusted_tpm2.c | 77 ++++- 10 files changed, 478 insertions(+), 48 deletions(-) create mode 100644 security/keys/trusted-keys/tpm2-policy.c create mode 100644 security/keys/trusted-keys/tpm2-policy.h diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentation/security/keys/trusted-encrypted.rst index 50ac8bcd6970..1a3ca84ad3cd 100644 --- a/Documentation/security/keys/trusted-encrypted.rst +++ b/Documentation/security/keys/trusted-encrypted.rst @@ -60,19 +60,16 @@ Usage:: (40 ascii zeros) blobauth= ascii hex auth for sealed data default 0x00... (40 ascii zeros) - pcrinfo= ascii hex of PCR_INFO or PCR_INFO_LONG (no default) + pcrinfo= ascii hex of PCR_INFO or PCR_INFO_LONG (no + default) on TPM 1.2 and a TPMS_PCR_SELECTION + coupled with a hash of all the selected PCRs on + TPM 2.0 using the selected hash. pcrlock= pcr number to be extended to "lock" blob migratable= 0|1 indicating permission to reseal to new PCR values, default 1 (resealing allowed) hash= hash algorithm name as a string. For TPM 1.x the only allowed value is sha1. For TPM 2.x the allowed values are sha1, sha256, sha384, sha512 and sm3-256. - policydigest= digest for the authorization policy. must be calculated - with the same hash algorithm as specified by the 'hash=' - option. - policyhandle= handle to an authorization policy session that defines the - same policy and with the same hash algorithm as was used to - seal the key. "keyctl print" returns an ascii hex copy of the sealed key, which is in standard TPM_STORED_DATA format. The key length for new keys are always in bytes. @@ -151,6 +148,20 @@ Load a trusted key from the saved blob:: f1f8fff03ad0acb083725535636addb08d73dedb9832da198081e5deae84bfaf0409c22b e4a8aea2b607ec96931e6f4d4fe563ba +Create a trusted key on TPM 2.0 using an all zero value of PCR16 and +using the NV storage root 81000001 as the parent:: + + $ keyctl add trusted kmk "new 32 keyhandle=0x81000001 hash=sha1 pcrinfo=030000016768033e216468247bd031a0a2d9876d79818f8f" @u + +Note the TPMS_PCR_SELECT value for PCR 16 is 03000001 because all +current TPMs have 24 PCRs, so the initial 03 says there are three +following bytes of selection and then because the bytes are big +endian, 16 is bit zero of byte 2. the hash is the sha1 sum of all +zeros (the value of PCR 16):: + + $ dd if=/dev/zero bs=1 count=20 2>/dev/null|sha1sum + 6768033e216468247bd031a0a2d9876d79818f8f + Reseal a trusted key under new pcr values:: $ keyctl update 268728824 "update pcrinfo=`cat pcr.blob`" diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h index 4728e13aada8..fc9c13802c06 100644 --- a/include/keys/trusted-type.h +++ b/include/keys/trusted-type.h @@ -14,9 +14,11 @@ #define MIN_KEY_SIZE 32 #define MAX_KEY_SIZE 128 #define MAX_BLOB_SIZE 512 -#define MAX_PCRINFO_SIZE 64 +#define MAX_PCRINFO_SIZE 128 #define MAX_DIGEST_SIZE 64 +#define TPM2_MAX_POLICIES 16 + struct trusted_key_payload { struct rcu_head rcu; unsigned int key_len; @@ -25,6 +27,7 @@ struct trusted_key_payload { unsigned char old_format; unsigned char key[MAX_KEY_SIZE + 1]; unsigned char blob[MAX_BLOB_SIZE]; + struct tpm2_policies *policies; }; struct trusted_key_options { diff --git a/include/linux/tpm.h b/include/linux/tpm.h index cd46ab27baa5..e32e9728adce 100644 --- a/include/linux/tpm.h +++ b/include/linux/tpm.h @@ -222,10 +222,14 @@ enum tpm2_command_codes { TPM2_CC_CONTEXT_LOAD = 0x0161, TPM2_CC_CONTEXT_SAVE = 0x0162, TPM2_CC_FLUSH_CONTEXT = 0x0165, + TPM2_CC_POLICY_AUTHVALUE = 0x016B, + TPM2_CC_POLICY_COUNTER_TIMER = 0x016D, + TPM2_CC_START_AUTH_SESS = 0x0176, TPM2_CC_VERIFY_SIGNATURE = 0x0177, TPM2_CC_GET_CAPABILITY = 0x017A, TPM2_CC_GET_RANDOM = 0x017B, TPM2_CC_PCR_READ = 0x017E, + TPM2_CC_POLICY_PCR = 0x017F, TPM2_CC_PCR_EXTEND = 0x0182, TPM2_CC_EVENT_SEQUENCE_COMPLETE = 0x0185, TPM2_CC_HASH_SEQUENCE_START = 0x0186, @@ -234,6 +238,7 @@ enum tpm2_command_codes { }; enum tpm2_permanent_handles { + TPM2_RH_NULL = 0x40000007, TPM2_RS_PW = 0x40000009, }; diff --git a/security/keys/Kconfig b/security/keys/Kconfig index dd313438fecf..6c2f2c22b284 100644 --- a/security/keys/Kconfig +++ b/security/keys/Kconfig @@ -80,6 +80,8 @@ config TRUSTED_KEYS select CRYPTO select CRYPTO_HMAC select CRYPTO_SHA1 + select CRYPTO_SHA256 + select CRYPTO_SHA512 select CRYPTO_HASH_INFO help This option provides support for creating, sealing, and unsealing diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-keys/Makefile index e0198641eff2..194febacf362 100644 --- a/security/keys/trusted-keys/Makefile +++ b/security/keys/trusted-keys/Makefile @@ -5,4 +5,4 @@ obj-$(CONFIG_TRUSTED_KEYS) += trusted.o trusted-y += trusted_tpm1.o -trusted-y += trusted_tpm2.o tpm2key.asn1.o +trusted-y += trusted_tpm2.o tpm2key.asn1.o tpm2-policy.o diff --git a/security/keys/trusted-keys/tpm2-policy.c b/security/keys/trusted-keys/tpm2-policy.c new file mode 100644 index 000000000000..ae83636ece37 --- /dev/null +++ b/security/keys/trusted-keys/tpm2-policy.c @@ -0,0 +1,344 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2019 James.Bottomley@HansenPartnership.com + */ + +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include +#include + +#include "tpm2key.asn1.h" +#include "tpm2-policy.h" + +int tpmkey_code(void *context, size_t hdrlen, + unsigned char tag, + const void *value, size_t vlen) +{ + struct tpm2key_context *ctx = context; + u32 code = 0; + const u8 *v = value; + int i; + + for (i = 0; i < vlen; i++) { + code <<= 8; + code |= v[i]; + } + + ctx->policy_code[ctx->policy_count] = code; + + return 0; +} + +int tpmkey_policy(void *context, size_t hdrlen, + unsigned char tag, + const void *value, size_t vlen) +{ + struct tpm2key_context *ctx = context; + + ctx->policies[ctx->policy_count] = value; + ctx->policy_len[ctx->policy_count++] = vlen; + + return 0; +} + +/* we only support a limited number of policy statement so + * make sure we don't have anything we can't support + */ +static int tpm2_validate_policy(struct tpm2_policies *pols) +{ + int i; + + if (pols->count == 0) + return 0; + + for (i = 0; i < pols->count; i++) { + switch (pols->code[i]) { + case TPM2_CC_POLICY_COUNTER_TIMER: + case TPM2_CC_POLICY_PCR: + case TPM2_CC_POLICY_AUTHVALUE: + break; + default: + printk(KERN_INFO "tpm2 policy 0x%x is unsupported", + pols->code[i]); + return -EINVAL; + } + } + return 0; +} + +/** + * tpmkey_process_policy - collect the policty from the context + * @ctx: the context to collect from + * @payload: the payload structure to place it in + * + * THis function sizes the policy statements and allocates space + * within the payload to receive them before copying them over. It + * should be used after the ber decoder has completed successfully + */ +int tpmkey_policy_process(struct tpm2key_context *ctx, + struct trusted_key_payload *payload) +{ + int tot_len = 0; + u8 *buf; + int i, ret, len = 0; + struct tpm2_policies *pols; + + if (ctx->policy_count == 0) + return 0; + + for (i = 0; i < ctx->policy_count; i++) + tot_len += ctx->policy_len[i]; + tot_len += sizeof(*pols); + + pols = kmalloc(tot_len, GFP_KERNEL); + if (!pols) + return -ENOMEM; + + payload->policies = pols; + buf = (u8 *)(pols + 1); + + for (i = 0; i < ctx->policy_count; i++) { + pols->policies[i] = &buf[len]; + pols->len[i] = ctx->policy_len[i]; + pols->code[i] = ctx->policy_code[i]; + if (pols->len[i]) + memcpy(pols->policies[i], ctx->policies[i], + ctx->policy_len[i]); + len += ctx->policy_len[i]; + } + pols->count = ctx->policy_count; + + ret = tpm2_validate_policy(pols); + if (ret) { + kfree(pols); + payload->policies = NULL; + } + + /* capture the hash and size */ + + /* the hash is the second algorithm */ + pols->hash = get_unaligned_be16(&ctx->pub[2]); + /* and the digest appears after the attributes */ + pols->hash_size = get_unaligned_be16(&ctx->pub[8]); + + return ret; +} + +int tpm2_generate_policy_digest(struct tpm2_policies *pols, + u32 hash, u8 *policydigest, u32 *plen) +{ + int i; + struct crypto_shash *tfm; + int rc; + + if (pols->count == 0) + return 0; + + tfm = crypto_alloc_shash(hash_algo_name[hash], 0, 0); + if (IS_ERR(tfm)) + return PTR_ERR(tfm); + + rc = crypto_shash_digestsize(tfm); + if (WARN(rc > MAX_DIGEST_SIZE, + "BUG: trusted key code has alg %s with digest too large (%d)", + hash_algo_name[hash], rc)) { + rc = -EINVAL; + goto err; + } + pols->hash = hash; + pols->hash_size = rc; + *plen = rc; + + /* policy digests always start out all zeros */ + memset(policydigest, 0, rc); + + for (i = 0; i < pols->count; i++) { + u8 *policy = pols->policies[i]; + int len = pols->len[i]; + u32 cmd = pols->code[i]; + u8 digest[MAX_DIGEST_SIZE]; + u8 code[4]; + SHASH_DESC_ON_STACK(sdesc, tfm); + + sdesc->tfm = tfm; + rc = crypto_shash_init(sdesc); + if (rc) + goto err; + + /* first hash the previous digest */ + crypto_shash_update(sdesc, policydigest, *plen); + /* then hash the command code */ + put_unaligned_be32(cmd, code); + crypto_shash_update(sdesc, code, 4); + + /* commands that need special handling */ + if (cmd == TPM2_CC_POLICY_COUNTER_TIMER) { + SHASH_DESC_ON_STACK(sdesc1, tfm); + + sdesc1->tfm = tfm; + + /* counter timer policies are double hashed */ + crypto_shash_digest(sdesc1, policy, len, + digest); + policy = digest; + len = *plen; + } + crypto_shash_update(sdesc, policy, len); + /* now output the intermediate to the policydigest */ + crypto_shash_final(sdesc, policydigest); + + } + rc = 0; + + err: + crypto_free_shash(tfm); + return rc; +} + +int tpm2_encode_policy(struct tpm2_policies *pols, u8 **data, u32 *len) +{ + u8 *buf = kmalloc(2 * PAGE_SIZE, GFP_KERNEL); + u8 *work = buf + PAGE_SIZE, *ptr; + int i; + + if (!buf) + return -ENOMEM; + + for (i = 0; i < pols->count; i++) { + u8 *seq_len, *tag_len; + u32 cmd = pols->code[i]; + int l; + + /* + * cheat a bit here: we know a policy is < 128 bytes, + * so the sequence and cons tags will only be two + * bytes long + */ + *work++ = _tag(UNIV, CONS, SEQ); + seq_len = work++; + *work++ = _tagn(CONT, CONS, 0); + tag_len = work++; + asn1_encode_integer(&work, cmd); + *tag_len = work - tag_len - 1; + *work++ = _tagn(CONT, CONS, 1); + tag_len = work++; + asn1_encode_octet_string(&work, pols->policies[i], + pols->len[i]); + *tag_len = work - tag_len - 1; + l = work - seq_len - 1; + /* our assumption about policy length failed */ + if (WARN(l > 127, + "policy is too long: %d but must be < 128", l)) { + kfree(buf); + return -EINVAL; + } + *seq_len = l; + } + ptr = buf; + asn1_encode_sequence(&ptr, buf + PAGE_SIZE, work - buf - PAGE_SIZE); + *data = buf; + *len = ptr - buf; + + return 0; +} + +int tpm2_start_policy_session(struct tpm_chip *chip, u16 hash, u32 *handle) +{ + struct tpm_buf buf; + int rc; + int i; + + rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, TPM2_CC_START_AUTH_SESS); + if (rc) + return rc; + + /* NULL salt key handle */ + tpm_buf_append_u32(&buf, TPM2_RH_NULL); + /* NULL bind key handle */ + tpm_buf_append_u32(&buf, TPM2_RH_NULL); + /* empty nonce caller */ + tpm_buf_append_u16(&buf, 20); + for (i = 0; i < 20; i++) + tpm_buf_append_u8(&buf, 0); + /* empty auth */ + tpm_buf_append_u16(&buf, 0); + /* session type policy */ + tpm_buf_append_u8(&buf, 0x01); + + /* symmetric encryption parameters */ + /* symmetric algorithm */ + tpm_buf_append_u16(&buf, TPM_ALG_NULL); + /* hash algorithm for session */ + tpm_buf_append_u16(&buf, hash); + + rc = tpm_send(chip, buf.data, tpm_buf_length(&buf)); + if (rc) + goto out; + + *handle = get_unaligned_be32(buf.data + TPM_HEADER_SIZE); + out: + tpm_buf_destroy(&buf); + + return rc <= 0 ? rc : -EPERM; +} + +int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols, + u32 *handle) +{ + int i, rc; + const char *failure; + + rc = tpm2_start_policy_session(chip, pols->hash, handle); + if (rc) + return rc; + + for (i = 0; i < pols->count; i++) { + u32 cmd = pols->code[i]; + struct tpm_buf buf; + + rc = tpm_buf_init(&buf, TPM2_ST_NO_SESSIONS, cmd); + if (rc) + return rc; + + tpm_buf_append_u32(&buf, *handle); + + switch (cmd) { + case TPM2_CC_POLICY_PCR: + failure = "PCR"; + /* + * for reasons best known to the TCG we have + * to reverse the two arguments to send to the + * policy command + */ + tpm_buf_append_u16(&buf, pols->hash_size); + tpm_buf_append(&buf, pols->policies[i] + pols->len[i] - + pols->hash_size, pols->hash_size); + tpm_buf_append(&buf, pols->policies[i], + pols->len[i] - pols->hash_size); + break; + default: + failure = "unknown policy"; + break; + } + rc = tpm_send(chip, buf.data, tpm_buf_length(&buf)); + tpm_buf_destroy(&buf); + if (rc) { + printk(KERN_NOTICE "TPM policy %s failed, rc=%d\n", + failure, rc); + tpm2_flush_context(chip, *handle); + *handle = 0; + return -EPERM; + } + } + return 0; +} diff --git a/security/keys/trusted-keys/tpm2-policy.h b/security/keys/trusted-keys/tpm2-policy.h new file mode 100644 index 000000000000..152c948743f3 --- /dev/null +++ b/security/keys/trusted-keys/tpm2-policy.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ + +struct tpm2key_context { + u32 parent; + const u8 *pub; + u32 pub_len; + const u8 *priv; + u32 priv_len; + const u8 *policies[TPM2_MAX_POLICIES]; + u32 policy_code[TPM2_MAX_POLICIES]; + u16 policy_len[TPM2_MAX_POLICIES]; + u8 policy_count; +}; + +struct tpm2_policies { + u32 code[TPM2_MAX_POLICIES]; + u8 *policies[TPM2_MAX_POLICIES]; + u16 len[TPM2_MAX_POLICIES]; + u8 count; + u16 hash; + u16 hash_size; +}; + +int tpmkey_policy_process(struct tpm2key_context *ctx, + struct trusted_key_payload *payload); +int tpm2_generate_policy_digest(struct tpm2_policies *pols, u32 hash, + u8 *policydigest, u32 *plen); +int tpm2_encode_policy(struct tpm2_policies *pols, u8 **data, u32 *len); +int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols, + u32 *handle); diff --git a/security/keys/trusted-keys/tpm2key.asn1 b/security/keys/trusted-keys/tpm2key.asn1 index 1851b7c80f08..f930fd812db3 100644 --- a/security/keys/trusted-keys/tpm2key.asn1 +++ b/security/keys/trusted-keys/tpm2key.asn1 @@ -18,6 +18,6 @@ TPMKey ::= SEQUENCE { TPMPolicySequence ::= SEQUENCE OF TPMPolicy TPMPolicy ::= SEQUENCE { - commandCode [0] EXPLICIT INTEGER, - commandPolicy [1] EXPLICIT OCTET STRING + commandCode [0] EXPLICIT INTEGER ({tpmkey_code}), + commandPolicy [1] EXPLICIT OCTET STRING ({tpmkey_policy}) } diff --git a/security/keys/trusted-keys/trusted_tpm1.c b/security/keys/trusted-keys/trusted_tpm1.c index d744a0d1cb89..6290e611b632 100644 --- a/security/keys/trusted-keys/trusted_tpm1.c +++ b/security/keys/trusted-keys/trusted_tpm1.c @@ -707,8 +707,6 @@ enum { Opt_keyhandle, Opt_keyauth, Opt_blobauth, Opt_pcrinfo, Opt_pcrlock, Opt_migratable, Opt_hash, - Opt_policydigest, - Opt_policyhandle, }; static const match_table_t key_tokens = { @@ -722,8 +720,6 @@ static const match_table_t key_tokens = { {Opt_pcrlock, "pcrlock=%s"}, {Opt_migratable, "migratable=%s"}, {Opt_hash, "hash=%s"}, - {Opt_policydigest, "policydigest=%s"}, - {Opt_policyhandle, "policyhandle=%s"}, {Opt_err, NULL} }; @@ -738,7 +734,6 @@ static int getoptions(char *c, struct trusted_key_payload *pay, unsigned long handle; unsigned long lock; unsigned long token_mask = 0; - unsigned int digest_len; int i; int tpm2; @@ -801,8 +796,6 @@ static int getoptions(char *c, struct trusted_key_payload *pay, opt->pcrlock = lock; break; case Opt_hash: - if (test_bit(Opt_policydigest, &token_mask)) - return -EINVAL; for (i = 0; i < HASH_ALGO__LAST; i++) { if (!strcmp(args[0].from, hash_algo_name[i])) { opt->hash = i; @@ -816,24 +809,6 @@ static int getoptions(char *c, struct trusted_key_payload *pay, return -EINVAL; } break; - case Opt_policydigest: - digest_len = hash_digest_size[opt->hash]; - if (!tpm2 || strlen(args[0].from) != (2 * digest_len)) - return -EINVAL; - res = hex2bin(opt->policydigest, args[0].from, - digest_len); - if (res < 0) - return -EINVAL; - opt->policydigest_len = digest_len; - break; - case Opt_policyhandle: - if (!tpm2) - return -EINVAL; - res = kstrtoul(args[0].from, 16, &handle); - if (res < 0) - return -EINVAL; - opt->policyhandle = handle; - break; default: return -EINVAL; } @@ -1045,6 +1020,7 @@ static void trusted_rcu_free(struct rcu_head *rcu) struct trusted_key_payload *p; p = container_of(rcu, struct trusted_key_payload, rcu); + kzfree(p->policies); kzfree(p); } @@ -1164,7 +1140,11 @@ static long trusted_read(const struct key *key, char __user *buffer, */ static void trusted_destroy(struct key *key) { - kzfree(key->payload.data[0]); + struct trusted_key_payload *p; + + p = key->payload.data[0]; + kzfree(p->policies); + kzfree(p); } struct key_type key_type_trusted = { diff --git a/security/keys/trusted-keys/trusted_tpm2.c b/security/keys/trusted-keys/trusted_tpm2.c index a34ab6f90f76..6d0d427bc5c5 100644 --- a/security/keys/trusted-keys/trusted_tpm2.c +++ b/security/keys/trusted-keys/trusted_tpm2.c @@ -17,6 +17,7 @@ #include #include "tpm2key.asn1.h" +#include "tpm2-policy.h" static struct tpm2_hash tpm2_hash_map[] = { {HASH_ALGO_SHA1, TPM_ALG_SHA1}, @@ -55,6 +56,20 @@ static int tpm2_key_encode(struct trusted_key_payload *payload, asn1_encode_boolean(&w, true); asn1_encode_tag(&work, 0, bool, w - bool); } + if (payload->policies) { + u8 *encoded_pols; + u32 encoded_pol_len; + int ret; + + ret = tpm2_encode_policy(payload->policies, &encoded_pols, + &encoded_pol_len); + + if (!ret) { + asn1_encode_tag(&work, 1, encoded_pols, + encoded_pol_len); + kfree(encoded_pols); + } + } asn1_encode_integer(&work, options->keyhandle); asn1_encode_octet_string(&work, pub, pub_len); asn1_encode_octet_string(&work, priv, priv_len); @@ -65,14 +80,6 @@ static int tpm2_key_encode(struct trusted_key_payload *payload, return work1 - payload->blob; } -struct tpm2key_context { - u32 parent; - const u8 *pub; - u32 pub_len; - const u8 *priv; - u32 priv_len; -}; - static int tpm2_key_decode(struct trusted_key_payload *payload, struct trusted_key_options *options, u8 **buf) @@ -81,6 +88,8 @@ static int tpm2_key_decode(struct trusted_key_payload *payload, struct tpm2key_context ctx; u8 *blob; + memset(&ctx, 0, sizeof(ctx)); + ret = asn1_ber_decoder(&tpm2key_decoder, &ctx, payload->blob, payload->blob_len); if (ret < 0) @@ -93,6 +102,12 @@ static int tpm2_key_decode(struct trusted_key_payload *payload, if (!blob) return -ENOMEM; + ret = tpmkey_policy_process(&ctx, payload); + if (ret) { + kfree(blob); + return ret; + } + *buf = blob; options->keyhandle = ctx.parent; put_unaligned_be16(ctx.priv_len, blob); @@ -224,6 +239,37 @@ int tpm2_seal_trusted(struct tpm_chip *chip, if (!options->keyhandle) return -EINVAL; + if (options->pcrinfo_len != 0) { + struct tpm2_policies *pols; + static u8 *scratch; + /* 4 array len, 2 hash alg */ + const int len = 4 + 2 + options->pcrinfo_len; + + pols = kmalloc(sizeof(*pols) + len, GFP_KERNEL); + if (!pols) + return -ENOMEM; + + pols->count = 1; + pols->len[0] = len; + scratch = (u8 *)(pols + 1); + pols->policies[0] = scratch; + pols->code[0] = TPM2_CC_POLICY_PCR; + + put_unaligned_be32(1, &scratch[0]); + put_unaligned_be16(hash, &scratch[4]); + memcpy(&scratch[6], options->pcrinfo, options->pcrinfo_len); + payload->policies = pols; + } + + if (payload->policies) { + rc = tpm2_generate_policy_digest(payload->policies, + options->hash, + options->policydigest, + &options->policydigest_len); + if (rc) + return rc; + } + rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_CREATE); if (rc) return rc; @@ -421,21 +467,30 @@ static int tpm2_unseal_cmd(struct tpm_chip *chip, u16 data_len; u8 *data; int rc; + u32 policyhandle = 0; rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_UNSEAL); if (rc) return rc; + if (payload->policies) { + rc = tpm2_get_policy_session(chip, payload->policies, + &policyhandle); + if (rc) + return rc; + } + tpm_buf_append_u32(&buf, blob_handle); tpm2_buf_append_auth(&buf, - options->policyhandle ? - options->policyhandle : TPM2_RS_PW, + policyhandle ? + policyhandle : TPM2_RS_PW, NULL /* nonce */, 0, TPM2_SA_CONTINUE_SESSION, options->blobauth /* hmac */, - TPM_DIGEST_SIZE); + policyhandle ? 0 : TPM_DIGEST_SIZE); rc = tpm_send(chip, buf.data, tpm_buf_length(&buf)); + tpm2_flush_context(chip, policyhandle); if (rc > 0) rc = -EPERM; From patchwork Sun Dec 8 05:13:20 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278097 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 78CEC6C1 for ; Sun, 8 Dec 2019 05:13:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 56178206DB for ; Sun, 8 Dec 2019 05:13:22 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="B8gVmQlv"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="B8gVmQlv" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFNW (ORCPT ); Sun, 8 Dec 2019 00:13:22 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:58100 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFNV (ORCPT ); Sun, 8 Dec 2019 00:13:21 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id 984C48EE111; Sat, 7 Dec 2019 21:13:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575782001; bh=9bVoBmJ6mY3uKdITKe8NDCfHjhounPrY1rA6LnkCDj0=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=B8gVmQlv1vL+1K/VyUUBJBH4RmE4CUEYfnYdjU03dwV5iGpz9oXkPW0CBDezgFYLL T7kK+/tEZPWClK1eS/Zdr8HrEIqbg1KW96hNctqagAYciZuCaOyYSLpoE1aeUJBZpV bNpMLmSqKlzTACtUj7BwUP4Nuamtlpn9Ol1kKV1s= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 5LC46jPbcZvk; Sat, 7 Dec 2019 21:13:21 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id 35AA08EE109; Sat, 7 Dec 2019 21:13:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575782001; bh=9bVoBmJ6mY3uKdITKe8NDCfHjhounPrY1rA6LnkCDj0=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=B8gVmQlv1vL+1K/VyUUBJBH4RmE4CUEYfnYdjU03dwV5iGpz9oXkPW0CBDezgFYLL T7kK+/tEZPWClK1eS/Zdr8HrEIqbg1KW96hNctqagAYciZuCaOyYSLpoE1aeUJBZpV bNpMLmSqKlzTACtUj7BwUP4Nuamtlpn9Ol1kKV1s= Message-ID: <1575782000.14069.17.camel@HansenPartnership.com> Subject: [PATCH 7/8] security: keys: trusted: add ability to specify arbitrary policy From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:13:20 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org This patch adds a policy= argument to key creation. The policy is the standard tss policymaker format and each separate policy line must have a newline after it. Thus to construct a policy requiring authorized value and pcr 16 locking using a sha256 hash, the policy (policy.txt) file would be two lines: 0000017F00000001000B03000001303095B49BE85E381E5B20E557E46363EF55B0F43B132C2D8E3DE9AC436656F2 0000016b This can be inserted into the key with keyctl add trusted kmk "new 32 policy=`cat policy.txt` keyhandle=0x81000001 hash=sha256" @u Note that although a few policies work like this, most require special handling which must be added to the kernel policy construction routine. Signed-off-by: James Bottomley --- Documentation/security/keys/trusted-encrypted.rst | 16 ++++++++ security/keys/trusted-keys/tpm2-policy.c | 46 +++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.h | 1 + security/keys/trusted-keys/trusted_tpm1.c | 14 ++++++- 4 files changed, 76 insertions(+), 1 deletion(-) diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentation/security/keys/trusted-encrypted.rst index 1a3ca84ad3cd..ade1a9dc8367 100644 --- a/Documentation/security/keys/trusted-encrypted.rst +++ b/Documentation/security/keys/trusted-encrypted.rst @@ -70,6 +70,9 @@ Usage:: hash= hash algorithm name as a string. For TPM 1.x the only allowed value is sha1. For TPM 2.x the allowed values are sha1, sha256, sha384, sha512 and sm3-256. + policy= specify an arbitrary set of policies. These must + be in policymaker format with each separate + policy line newline terminated. "keyctl print" returns an ascii hex copy of the sealed key, which is in standard TPM_STORED_DATA format. The key length for new keys are always in bytes. @@ -162,6 +165,19 @@ zeros (the value of PCR 16):: $ dd if=/dev/zero bs=1 count=20 2>/dev/null|sha1sum 6768033e216468247bd031a0a2d9876d79818f8f +You can also specify arbitrary policy in policymaker format, so a two +value policy (the pcr example above and authvalue) would look like +this in policymaker format:: + + 0000017F000000010004030000016768033e216468247bd031a0a2d9876d79818f8f + 0000016b + +This can be placed in a file (say policy.txt) and then added to the key as:: + + $ keyctl add trusted kmk "new 32 keyhandle=0x81000001 hash=sha1 policy=`cat policy.txt`" @u + +The newlines in the file policy.txt will be automatically processed. + Reseal a trusted key under new pcr values:: $ keyctl update 268728824 "update pcrinfo=`cat pcr.blob`" diff --git a/security/keys/trusted-keys/tpm2-policy.c b/security/keys/trusted-keys/tpm2-policy.c index ae83636ece37..4f8549219055 100644 --- a/security/keys/trusted-keys/tpm2-policy.c +++ b/security/keys/trusted-keys/tpm2-policy.c @@ -342,3 +342,49 @@ int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols, } return 0; } + +int tpm2_parse_policies(struct tpm2_policies **ppols, char *str) +{ + struct tpm2_policies *pols; + char *p; + u8 *ptr; + int i = 0, left = PAGE_SIZE, res; + + pols = kmalloc(left, GFP_KERNEL); + if (!pols) + return -ENOMEM; + + ptr = (u8 *)(pols + 1); + left -= ptr - (u8 *)pols; + + while ((p = strsep(&str, "\n"))) { + if (*p == '\0' || *p == '\n') + continue; + pols->len[i] = strlen(p)/2; + if (pols->len[i] > left) { + res = -E2BIG; + goto err; + } + res = hex2bin(ptr, p, pols->len[i]); + if (res) + goto err; + /* get command code and skip past */ + pols->code[i] = get_unaligned_be32(ptr); + pols->policies[i] = ptr + 4; + ptr += pols->len[i]; + left -= pols->len[i]; + pols->len[i] -= 4; + /* + * FIXME: this does leave the code embedded in dead + * regions of the memory, but it's easier than + * hexdumping to a temporary or copying over + */ + i++; + } + pols->count = i; + *ppols = pols; + return 0; + err: + kfree(pols); + return res; +} diff --git a/security/keys/trusted-keys/tpm2-policy.h b/security/keys/trusted-keys/tpm2-policy.h index 152c948743f3..cb804a544ced 100644 --- a/security/keys/trusted-keys/tpm2-policy.h +++ b/security/keys/trusted-keys/tpm2-policy.h @@ -28,3 +28,4 @@ int tpm2_generate_policy_digest(struct tpm2_policies *pols, u32 hash, int tpm2_encode_policy(struct tpm2_policies *pols, u8 **data, u32 *len); int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols, u32 *handle); +int tpm2_parse_policies(struct tpm2_policies **ppols, char *str); diff --git a/security/keys/trusted-keys/trusted_tpm1.c b/security/keys/trusted-keys/trusted_tpm1.c index 6290e611b632..ba05c75c3170 100644 --- a/security/keys/trusted-keys/trusted_tpm1.c +++ b/security/keys/trusted-keys/trusted_tpm1.c @@ -29,6 +29,8 @@ #include +#include "tpm2-policy.h" + static const char hmac_alg[] = "hmac(sha1)"; static const char hash_alg[] = "sha1"; static struct tpm_chip *chip; @@ -706,7 +708,7 @@ enum { Opt_new, Opt_load, Opt_update, Opt_keyhandle, Opt_keyauth, Opt_blobauth, Opt_pcrinfo, Opt_pcrlock, Opt_migratable, - Opt_hash, + Opt_hash, Opt_policy, }; static const match_table_t key_tokens = { @@ -720,6 +722,7 @@ static const match_table_t key_tokens = { {Opt_pcrlock, "pcrlock=%s"}, {Opt_migratable, "migratable=%s"}, {Opt_hash, "hash=%s"}, + {Opt_policy, "policy=%s"}, {Opt_err, NULL} }; @@ -809,6 +812,15 @@ static int getoptions(char *c, struct trusted_key_payload *pay, return -EINVAL; } break; + case Opt_policy: + if (pay->policies) + return -EINVAL; + if (!tpm2) + return -EINVAL; + res = tpm2_parse_policies(&pay->policies, args[0].from); + if (res) + return res; + break; default: return -EINVAL; } From patchwork Sun Dec 8 05:14:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: James Bottomley X-Patchwork-Id: 11278099 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id B8A796C1 for ; Sun, 8 Dec 2019 05:14:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8C630206DB for ; Sun, 8 Dec 2019 05:14:06 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="nM+gz3bj"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=hansenpartnership.com header.i=@hansenpartnership.com header.b="nM+gz3bj" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725268AbfLHFOG (ORCPT ); Sun, 8 Dec 2019 00:14:06 -0500 Received: from bedivere.hansenpartnership.com ([66.63.167.143]:58132 "EHLO bedivere.hansenpartnership.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725263AbfLHFOG (ORCPT ); Sun, 8 Dec 2019 00:14:06 -0500 Received: from localhost (localhost [127.0.0.1]) by bedivere.hansenpartnership.com (Postfix) with ESMTP id CCAB58EE111; Sat, 7 Dec 2019 21:14:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575782045; bh=2gvhvXWGa4bcA8svhyiWJv2SvClez4V4TGBJM8tq5Ro=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=nM+gz3bj/Bnchkb9IvnO5Bxj1VH0RfGlAxsO8jTSsScJfOsXoEtDGIrowwCFzLJvQ deQzDN4SESCdL5xRTXm1rtqGB2I8v9+EHVqAgWsMk0UcaRpxkwVGn9sl7HlPImhfbm xuTx/PQurGDC3edAJ/Kth43lQxZRa6PKwQwlm+NQ= Received: from bedivere.hansenpartnership.com ([127.0.0.1]) by localhost (bedivere.hansenpartnership.com [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id i4CvEn_NYOCt; Sat, 7 Dec 2019 21:14:05 -0800 (PST) Received: from jarvis.lan (unknown [50.35.76.230]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by bedivere.hansenpartnership.com (Postfix) with ESMTPSA id 696B58EE109; Sat, 7 Dec 2019 21:14:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=hansenpartnership.com; s=20151216; t=1575782045; bh=2gvhvXWGa4bcA8svhyiWJv2SvClez4V4TGBJM8tq5Ro=; h=Subject:From:To:Cc:Date:In-Reply-To:References:From; b=nM+gz3bj/Bnchkb9IvnO5Bxj1VH0RfGlAxsO8jTSsScJfOsXoEtDGIrowwCFzLJvQ deQzDN4SESCdL5xRTXm1rtqGB2I8v9+EHVqAgWsMk0UcaRpxkwVGn9sl7HlPImhfbm xuTx/PQurGDC3edAJ/Kth43lQxZRa6PKwQwlm+NQ= Message-ID: <1575782044.14069.18.camel@HansenPartnership.com> Subject: [PATCH 8/8] security: keys: trusted: implement counter/timer policy From: James Bottomley To: linux-integrity@vger.kernel.org Cc: Mimi Zohar , Jarkko Sakkinen Date: Sat, 07 Dec 2019 21:14:04 -0800 In-Reply-To: <1575781600.14069.8.camel@HansenPartnership.com> References: <1575781600.14069.8.camel@HansenPartnership.com> X-Mailer: Evolution 3.26.6 Mime-Version: 1.0 Sender: linux-integrity-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org This is actually a generic policy allowing a range of comparisons against any value set in the TPM Clock, which includes things like the reset count, a monotonic millisecond count and the restart count. The most useful comparison is against the millisecond count for expiring keys. However, you have to remember that currently Linux doesn't try to sync the epoch timer with the TPM, so the expiration is actually measured in how long the TPM itself has been powered on ... the TPM timer doesn't count while the system is powered down. The millisecond counter is a u64 quantity found at offset 8 in the timer structure, and the <= comparision operand is 9, so a policy set to expire after the TPM has been up for 100 seconds would look like 0000016d00000000000f424000080009 Where 0x16d is the counter timer policy code and 0xf4240 is 100 000 in hex. Signed-off-by: James Bottomley --- Documentation/security/keys/trusted-encrypted.rst | 29 +++++++++++++++++++++++ security/keys/trusted-keys/tpm2-policy.c | 19 +++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentation/security/keys/trusted-encrypted.rst index ade1a9dc8367..52d8bd8bef65 100644 --- a/Documentation/security/keys/trusted-encrypted.rst +++ b/Documentation/security/keys/trusted-encrypted.rst @@ -235,3 +235,32 @@ about the usage can be found in the file Another new format 'enc32' has been defined in order to support encrypted keys with payload size of 32 bytes. This will initially be used for nvdimm security but may expand to other usages that require 32 bytes payload. + +Appendix +-------- + +TPM 2.0 Policies +---------------- + +The current TPM supports PCR lock policies as documented above and +CounterTimer policies which can be used to create expiring keys. One +caveat with expiring keys is that the TPM millisecond counter does not +update while a system is powered off and Linux does not sync the TPM +millisecond count with its internal clock, so the best you can expire +in is in terms of how long any given TPM has been powered on. (FIXME: +Linux should simply update the millisecond clock to the current number +of seconds past the epoch on boot). + +A CounterTimer policy is expressed in terms of length and offset +against the TPM clock structure (TPMS_TIME_INFO), which looks like the +packed structure:: + + struct tpms_time_info { + u64 uptime; /* time in ms since last start or reset */ + u64 clock; /* cumulative uptime in ms */ + u32 resetcount; /* numer of times the TPM has been reset */ + u32 restartcount; /* number of times the TPM has been restarted */ + u8 safe /* time was safely loaded from NVRam */ + }; + +The usual comparison for expiring keys is against clock, at offset 8. diff --git a/security/keys/trusted-keys/tpm2-policy.c b/security/keys/trusted-keys/tpm2-policy.c index 4f8549219055..4baa445e7859 100644 --- a/security/keys/trusted-keys/tpm2-policy.c +++ b/security/keys/trusted-keys/tpm2-policy.c @@ -326,6 +326,25 @@ int tpm2_get_policy_session(struct tpm_chip *chip, struct tpm2_policies *pols, tpm_buf_append(&buf, pols->policies[i], pols->len[i] - pols->hash_size); break; + case TPM2_CC_POLICY_COUNTER_TIMER: { + /* + * the format of this is the last two u16 + * quantities are the offset and operation + * respectively. The rest is operandB which + * must be zero padded in a hash digest + */ + u16 opb_len = pols->len[i] - 4; + + if (opb_len > pols->hash_size) + return -EINVAL; + + tpm_buf_append_u16(&buf, opb_len); + tpm_buf_append(&buf, pols->policies[i], opb_len); + /* offset and operand*/ + tpm_buf_append(&buf, pols->policies[i] + opb_len, 4); + failure = "Counter Timer"; + break; + } default: failure = "unknown policy"; break;