iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Hi,

Browse Source 
This is pull request for trusted keys subsystem containing a new key
 type for the Data Co-Processor (DCP), which is an IP core built into
 many NXP SoCs such as i.mx6ull.
 
 BR, Jarkko
 -----BEGIN PGP SIGNATURE-----
 
 iJYEABYKAD4WIQRE6pSOnaBC00OEHEIaerohdGur0gUCZjzswCAcamFya2tvLnNh
 a2tpbmVuQGxpbnV4LmludGVsLmNvbQAKCRAaerohdGur0iVQAP9lxVjTKjMHQB01
 KFAXUogNU42JuJjzEiC5TaDxFPNHlAEAqVBYnPIZdP4VMF3UalVgIu/eRfvxTW/t
 klC+q7WiEwg=
 =+33z
 -----END PGP SIGNATURE-----

Merge tag 'keys-trusted-next-6.10-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd

Pull trusted keys updates from Jarkko Sakkinen:
 "This contains a new key type for the Data Co-Processor (DCP), which is
  an IP core built into many NXP SoCs such as i.mx6ull"

* tag 'keys-trusted-next-6.10-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-tpmdd:
  docs: trusted-encrypted: add DCP as new trust source
  docs: document DCP-backed trusted keys kernel params
  MAINTAINERS: add entry for DCP-based trusted keys
  KEYS: trusted: Introduce NXP DCP-backed trusted keys
  KEYS: trusted: improve scalability of trust source config
  crypto: mxs-dcp: Add support for hardware-bound keys
This commit is contained in:
Linus Torvalds 2024-05-13 10:38:13 -07:00
commit c024814828
10 changed files with 554 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Documentation/admin-guide/kernel-parameters.txt
View File

@ -6765,6 +6765,7 @@
- "tpm"
- "tee"
- "caam"
- "dcp"
If not specified then it defaults to iterating through
the trust source list starting with TPM and assigns the
first trust source as a backend which is initialized
@ -6780,6 +6781,18 @@
If not specified, "default" is used. In this case,
the RNG's choice is left to each individual trust source.
trusted.dcp_use_otp_key
This is intended to be used in combination with
trusted.source=dcp and will select the DCP OTP key
instead of the DCP UNIQUE key blob encryption.
trusted.dcp_skip_zk_test
This is intended to be used in combination with
trusted.source=dcp and will disable the check if the
blob key is all zeros. This is helpful for situations where
having this key zero'ed is acceptable. E.g. in testing
scenarios.
tsc= Disable clocksource stability checks for TSC.
Format: <string>
[x86] reliable: mark tsc clocksource as reliable, this

53
Documentation/security/keys/trusted-encrypted.rst
View File

@ -42,6 +42,14 @@ safe.
randomly generated and fused into each SoC at manufacturing time.
Otherwise, a common fixed test key is used instead.
(4) DCP (Data Co-Processor: crypto accelerator of various i.MX SoCs)
Rooted to a one-time programmable key (OTP) that is generally burnt
in the on-chip fuses and is accessible to the DCP encryption engine only.
DCP provides two keys that can be used as root of trust: the OTP key
and the UNIQUE key. Default is to use the UNIQUE key, but selecting
the OTP key can be done via a module parameter (dcp_use_otp_key).
* Execution isolation
(1) TPM
@ -57,6 +65,12 @@ safe.
Fixed set of operations running in isolated execution environment.
(4) DCP
Fixed set of cryptographic operations running in isolated execution
environment. Only basic blob key encryption is executed there.
The actual key sealing/unsealing is done on main processor/kernel space.
* Optional binding to platform integrity state
(1) TPM
@ -79,6 +93,11 @@ safe.
Relies on the High Assurance Boot (HAB) mechanism of NXP SoCs
for platform integrity.
(4) DCP
Relies on Secure/Trusted boot process (called HAB by vendor) for
platform integrity.
* Interfaces and APIs
(1) TPM
@ -94,6 +113,11 @@ safe.
Interface is specific to silicon vendor.
(4) DCP
Vendor-specific API that is implemented as part of the DCP crypto driver in
``drivers/crypto/mxs-dcp.c``.
* Threat model
The strength and appropriateness of a particular trust source for a given
@ -129,6 +153,13 @@ selected trust source:
CAAM HWRNG, enable CRYPTO_DEV_FSL_CAAM_RNG_API and ensure the device
is probed.
* DCP (Data Co-Processor: crypto accelerator of various i.MX SoCs)
The DCP hardware device itself does not provide a dedicated RNG interface,
so the kernel default RNG is used. SoCs with DCP like the i.MX6ULL do have
a dedicated hardware RNG that is independent from DCP which can be enabled
to back the kernel RNG.
Users may override this by specifying ``trusted.rng=kernel`` on the kernel
command-line to override the used RNG with the kernel's random number pool.
@ -231,6 +262,19 @@ Usage::
CAAM-specific format. The key length for new keys is always in bytes.
Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
Trusted Keys usage: DCP
-----------------------
Usage::
keyctl add trusted name "new keylen" ring
keyctl add trusted name "load hex_blob" ring
keyctl print keyid
"keyctl print" returns an ASCII hex copy of the sealed key, which is in format
specific to this DCP key-blob implementation. The key length for new keys is
always in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
Encrypted Keys usage
--------------------
@ -426,3 +470,12 @@ string length.
privkey is the binary representation of TPM2B_PUBLIC excluding the
initial TPM2B header which can be reconstructed from the ASN.1 octed
string length.
DCP Blob Format
---------------
.. kernel-doc:: security/keys/trusted-keys/trusted_dcp.c
:doc: dcp blob format
.. kernel-doc:: security/keys/trusted-keys/trusted_dcp.c
:identifiers: struct dcp_blob_fmt

9
MAINTAINERS
View File

@ -12037,6 +12037,15 @@ S: Maintained
F: include/keys/trusted_caam.h
F: security/keys/trusted-keys/trusted_caam.c
KEYS-TRUSTED-DCP
M: David Gstir <david@sigma-star.at>
R: sigma star Kernel Team <upstream+dcp@sigma-star.at>
L: linux-integrity@vger.kernel.org
L: keyrings@vger.kernel.org
S: Supported
F: include/keys/trusted_dcp.h
F: security/keys/trusted-keys/trusted_dcp.c
KEYS-TRUSTED-TEE
M: Sumit Garg <sumit.garg@linaro.org>
L: linux-integrity@vger.kernel.org

104
drivers/crypto/mxs-dcp.c
View File

@ -15,6 +15,7 @@
#include <linux/platform_device.h>
#include <linux/stmp_device.h>
#include <linux/clk.h>
#include <soc/fsl/dcp.h>
#include <crypto/aes.h>
#include <crypto/sha1.h>
@ -101,6 +102,7 @@ struct dcp_async_ctx {
struct crypto_skcipher *fallback;
unsigned int key_len;
uint8_t key[AES_KEYSIZE_128];
bool key_referenced;
};
struct dcp_aes_req_ctx {
@ -155,6 +157,7 @@ static struct dcp *global_sdcp;
#define MXS_DCP_CONTROL0_HASH_TERM (1 << 13)
#define MXS_DCP_CONTROL0_HASH_INIT (1 << 12)
#define MXS_DCP_CONTROL0_PAYLOAD_KEY (1 << 11)
#define MXS_DCP_CONTROL0_OTP_KEY (1 << 10)
#define MXS_DCP_CONTROL0_CIPHER_ENCRYPT (1 << 8)
#define MXS_DCP_CONTROL0_CIPHER_INIT (1 << 9)
#define MXS_DCP_CONTROL0_ENABLE_HASH (1 << 6)
@ -168,6 +171,8 @@ static struct dcp *global_sdcp;
#define MXS_DCP_CONTROL1_CIPHER_MODE_ECB (0 << 4)
#define MXS_DCP_CONTROL1_CIPHER_SELECT_AES128 (0 << 0)
#define MXS_DCP_CONTROL1_KEY_SELECT_SHIFT 8
static int mxs_dcp_start_dma(struct dcp_async_ctx *actx)
{
int dma_err;
@ -224,13 +229,16 @@ static int mxs_dcp_run_aes(struct dcp_async_ctx *actx,
struct dcp *sdcp = global_sdcp;
struct dcp_dma_desc *desc = &sdcp->coh->desc[actx->chan];
struct dcp_aes_req_ctx *rctx = skcipher_request_ctx(req);
bool key_referenced = actx->key_referenced;
int ret;
key_phys = dma_map_single(sdcp->dev, sdcp->coh->aes_key,
2 * AES_KEYSIZE_128, DMA_TO_DEVICE);
ret = dma_mapping_error(sdcp->dev, key_phys);
if (ret)
return ret;
if (!key_referenced) {
key_phys = dma_map_single(sdcp->dev, sdcp->coh->aes_key,
2 * AES_KEYSIZE_128, DMA_TO_DEVICE);
ret = dma_mapping_error(sdcp->dev, key_phys);
if (ret)
return ret;
}
src_phys = dma_map_single(sdcp->dev, sdcp->coh->aes_in_buf,
DCP_BUF_SZ, DMA_TO_DEVICE);
@ -255,8 +263,12 @@ static int mxs_dcp_run_aes(struct dcp_async_ctx *actx,
MXS_DCP_CONTROL0_INTERRUPT |
MXS_DCP_CONTROL0_ENABLE_CIPHER;
/* Payload contains the key. */
desc->control0 |= MXS_DCP_CONTROL0_PAYLOAD_KEY;
if (key_referenced)
/* Set OTP key bit to select the key via KEY_SELECT. */
desc->control0 |= MXS_DCP_CONTROL0_OTP_KEY;
else
/* Payload contains the key. */
desc->control0 |= MXS_DCP_CONTROL0_PAYLOAD_KEY;
if (rctx->enc)
desc->control0 |= MXS_DCP_CONTROL0_CIPHER_ENCRYPT;
@ -270,6 +282,9 @@ static int mxs_dcp_run_aes(struct dcp_async_ctx *actx,
else
desc->control1 |= MXS_DCP_CONTROL1_CIPHER_MODE_CBC;
if (key_referenced)
desc->control1 |= sdcp->coh->aes_key[0] << MXS_DCP_CONTROL1_KEY_SELECT_SHIFT;
desc->next_cmd_addr = 0;
desc->source = src_phys;
desc->destination = dst_phys;
@ -284,9 +299,9 @@ aes_done_run:
err_dst:
dma_unmap_single(sdcp->dev, src_phys, DCP_BUF_SZ, DMA_TO_DEVICE);
err_src:
dma_unmap_single(sdcp->dev, key_phys, 2 * AES_KEYSIZE_128,
DMA_TO_DEVICE);
if (!key_referenced)
dma_unmap_single(sdcp->dev, key_phys, 2 * AES_KEYSIZE_128,
DMA_TO_DEVICE);
return ret;
}
@ -453,7 +468,7 @@ static int mxs_dcp_aes_enqueue(struct skcipher_request *req, int enc, int ecb)
struct dcp_aes_req_ctx *rctx = skcipher_request_ctx(req);
int ret;
if (unlikely(actx->key_len != AES_KEYSIZE_128))
if (unlikely(actx->key_len != AES_KEYSIZE_128 && !actx->key_referenced))
return mxs_dcp_block_fallback(req, enc);
rctx->enc = enc;
@ -500,6 +515,7 @@ static int mxs_dcp_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
* there can still be an operation in progress.
*/
actx->key_len = len;
actx->key_referenced = false;
if (len == AES_KEYSIZE_128) {
memcpy(actx->key, key, len);
return 0;
@ -516,6 +532,32 @@ static int mxs_dcp_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
return crypto_skcipher_setkey(actx->fallback, key, len);
}
static int mxs_dcp_aes_setrefkey(struct crypto_skcipher *tfm, const u8 *key,
unsigned int len)
{
struct dcp_async_ctx *actx = crypto_skcipher_ctx(tfm);
if (len != DCP_PAES_KEYSIZE)
return -EINVAL;
switch (key[0]) {
case DCP_PAES_KEY_SLOT0:
case DCP_PAES_KEY_SLOT1:
case DCP_PAES_KEY_SLOT2:
case DCP_PAES_KEY_SLOT3:
case DCP_PAES_KEY_UNIQUE:
case DCP_PAES_KEY_OTP:
memcpy(actx->key, key, len);
actx->key_len = len;
actx->key_referenced = true;
break;
default:
return -EINVAL;
}
return 0;
}
static int mxs_dcp_aes_fallback_init_tfm(struct crypto_skcipher *tfm)
{
const char *name = crypto_tfm_alg_name(crypto_skcipher_tfm(tfm));
@ -539,6 +581,13 @@ static void mxs_dcp_aes_fallback_exit_tfm(struct crypto_skcipher *tfm)
crypto_free_skcipher(actx->fallback);
}
static int mxs_dcp_paes_init_tfm(struct crypto_skcipher *tfm)
{
crypto_skcipher_set_reqsize(tfm, sizeof(struct dcp_aes_req_ctx));
return 0;
}
/*
* Hashing (SHA1/SHA256)
*/
@ -889,6 +938,39 @@ static struct skcipher_alg dcp_aes_algs[] = {
.ivsize = AES_BLOCK_SIZE,
.init = mxs_dcp_aes_fallback_init_tfm,
.exit = mxs_dcp_aes_fallback_exit_tfm,
}, {
.base.cra_name = "ecb(paes)",
.base.cra_driver_name = "ecb-paes-dcp",
.base.cra_priority = 401,
.base.cra_alignmask = 15,
.base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_INTERNAL,
.base.cra_blocksize = AES_BLOCK_SIZE,
.base.cra_ctxsize = sizeof(struct dcp_async_ctx),
.base.cra_module = THIS_MODULE,
.min_keysize = DCP_PAES_KEYSIZE,
.max_keysize = DCP_PAES_KEYSIZE,
.setkey = mxs_dcp_aes_setrefkey,
.encrypt = mxs_dcp_aes_ecb_encrypt,
.decrypt = mxs_dcp_aes_ecb_decrypt,
.init = mxs_dcp_paes_init_tfm,
}, {
.base.cra_name = "cbc(paes)",
.base.cra_driver_name = "cbc-paes-dcp",
.base.cra_priority = 401,
.base.cra_alignmask = 15,
.base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_INTERNAL,
.base.cra_blocksize = AES_BLOCK_SIZE,
.base.cra_ctxsize = sizeof(struct dcp_async_ctx),
.base.cra_module = THIS_MODULE,
.min_keysize = DCP_PAES_KEYSIZE,
.max_keysize = DCP_PAES_KEYSIZE,
.setkey = mxs_dcp_aes_setrefkey,
.encrypt = mxs_dcp_aes_cbc_encrypt,
.decrypt = mxs_dcp_aes_cbc_decrypt,
.ivsize = AES_BLOCK_SIZE,
.init = mxs_dcp_paes_init_tfm,
},
};

11
include/keys/trusted_dcp.h Normal file
View File

@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (C) 2021 sigma star gmbh
*/
#ifndef TRUSTED_DCP_H
#define TRUSTED_DCP_H
extern struct trusted_key_ops dcp_trusted_key_ops;
#endif

20
include/soc/fsl/dcp.h Normal file
View File

@ -0,0 +1,20 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (C) 2021 sigma star gmbh
*
* Specifies paes key slot handles for NXP's DCP (Data Co-Processor) to be used
* with the crypto_skcipher_setkey().
*/
#ifndef MXS_DCP_H
#define MXS_DCP_H
#define DCP_PAES_KEYSIZE 1
#define DCP_PAES_KEY_SLOT0 0x00
#define DCP_PAES_KEY_SLOT1 0x01
#define DCP_PAES_KEY_SLOT2 0x02
#define DCP_PAES_KEY_SLOT3 0x03
#define DCP_PAES_KEY_UNIQUE 0xfe
#define DCP_PAES_KEY_OTP 0xff
#endif /* MXS_DCP_H */

18
security/keys/trusted-keys/Kconfig
View File

@ -1,3 +1,6 @@
config HAVE_TRUSTED_KEYS
bool
config TRUSTED_KEYS_TPM
bool "TPM-based trusted keys"
depends on TCG_TPM >= TRUSTED_KEYS
@ -9,6 +12,7 @@ config TRUSTED_KEYS_TPM
select ASN1_ENCODER
select OID_REGISTRY
select ASN1
select HAVE_TRUSTED_KEYS
help
Enable use of the Trusted Platform Module (TPM) as trusted key
backend. Trusted keys are random number symmetric keys,
@ -20,6 +24,7 @@ config TRUSTED_KEYS_TEE
bool "TEE-based trusted keys"
depends on TEE >= TRUSTED_KEYS
default y
select HAVE_TRUSTED_KEYS
help
Enable use of the Trusted Execution Environment (TEE) as trusted
key backend.
@ -29,10 +34,19 @@ config TRUSTED_KEYS_CAAM
depends on CRYPTO_DEV_FSL_CAAM_JR >= TRUSTED_KEYS
select CRYPTO_DEV_FSL_CAAM_BLOB_GEN
default y
select HAVE_TRUSTED_KEYS
help
Enable use of NXP's Cryptographic Accelerator and Assurance Module
(CAAM) as trusted key backend.
if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE && !TRUSTED_KEYS_CAAM
comment "No trust source selected!"
config TRUSTED_KEYS_DCP
bool "DCP-based trusted keys"
depends on CRYPTO_DEV_MXS_DCP >= TRUSTED_KEYS
default y
select HAVE_TRUSTED_KEYS
help
Enable use of NXP's DCP (Data Co-Processor) as trusted key backend.
if !HAVE_TRUSTED_KEYS
comment "No trust source selected!"
endif

2
security/keys/trusted-keys/Makefile
View File

@ -14,3 +14,5 @@ trusted-$(CONFIG_TRUSTED_KEYS_TPM) += tpm2key.asn1.o
trusted-$(CONFIG_TRUSTED_KEYS_TEE) += trusted_tee.o
trusted-$(CONFIG_TRUSTED_KEYS_CAAM) += trusted_caam.o
trusted-$(CONFIG_TRUSTED_KEYS_DCP) += trusted_dcp.o

6
security/keys/trusted-keys/trusted_core.c
View File

@ -10,6 +10,7 @@
#include <keys/trusted-type.h>
#include <keys/trusted_tee.h>
#include <keys/trusted_caam.h>
#include <keys/trusted_dcp.h>
#include <keys/trusted_tpm.h>
#include <linux/capability.h>
#include <linux/err.h>
@ -30,7 +31,7 @@ MODULE_PARM_DESC(rng, "Select trusted key RNG");
static char *trusted_key_source;
module_param_named(source, trusted_key_source, charp, 0);
MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee or caam)");
MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee, caam or dcp)");
static const struct trusted_key_source trusted_key_sources[] = {
#if defined(CONFIG_TRUSTED_KEYS_TPM)
@ -42,6 +43,9 @@ static const struct trusted_key_source trusted_key_sources[] = {
#if defined(CONFIG_TRUSTED_KEYS_CAAM)
{ "caam", &trusted_key_caam_ops },
#endif
#if defined(CONFIG_TRUSTED_KEYS_DCP)
{ "dcp", &dcp_trusted_key_ops },
#endif
};
DEFINE_STATIC_CALL_NULL(trusted_key_seal, *trusted_key_sources[0].ops->seal);

332
security/keys/trusted-keys/trusted_dcp.c Normal file
View File

@ -0,0 +1,332 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (C) 2021 sigma star gmbh
*/
#include <crypto/aead.h>
#include <crypto/aes.h>
#include <crypto/algapi.h>
#include <crypto/gcm.h>
#include <crypto/skcipher.h>
#include <keys/trusted-type.h>
#include <linux/key-type.h>
#include <linux/module.h>
#include <linux/printk.h>
#include <linux/random.h>
#include <linux/scatterlist.h>
#include <soc/fsl/dcp.h>
#define DCP_BLOB_VERSION 1
#define DCP_BLOB_AUTHLEN 16
/**
* DOC: dcp blob format
*
* The Data Co-Processor (DCP) provides hardware-bound AES keys using its
* AES encryption engine only. It does not provide direct key sealing/unsealing.
* To make DCP hardware encryption keys usable as trust source, we define
* our own custom format that uses a hardware-bound key to secure the sealing
* key stored in the key blob.
*
* Whenever a new trusted key using DCP is generated, we generate a random 128-bit
* blob encryption key (BEK) and 128-bit nonce. The BEK and nonce are used to
* encrypt the trusted key payload using AES-128-GCM.
*
* The BEK itself is encrypted using the hardware-bound key using the DCP's AES
* encryption engine with AES-128-ECB. The encrypted BEK, generated nonce,
* BEK-encrypted payload and authentication tag make up the blob format together
* with a version number, payload length and authentication tag.
*/
/**
* struct dcp_blob_fmt - DCP BLOB format.
*
* @fmt_version: Format version, currently being %1.
* @blob_key: Random AES 128 key which is used to encrypt @payload,
* @blob_key itself is encrypted with OTP or UNIQUE device key in
* AES-128-ECB mode by DCP.
* @nonce: Random nonce used for @payload encryption.
* @payload_len: Length of the plain text @payload.
* @payload: The payload itself, encrypted using AES-128-GCM and @blob_key,
* GCM auth tag of size DCP_BLOB_AUTHLEN is attached at the end of it.
*
* The total size of a DCP BLOB is sizeof(struct dcp_blob_fmt) + @payload_len +
* DCP_BLOB_AUTHLEN.
*/
struct dcp_blob_fmt {
__u8 fmt_version;
__u8 blob_key[AES_KEYSIZE_128];
__u8 nonce[AES_KEYSIZE_128];
__le32 payload_len;
__u8 payload[];
} __packed;
static bool use_otp_key;
module_param_named(dcp_use_otp_key, use_otp_key, bool, 0);
MODULE_PARM_DESC(dcp_use_otp_key, "Use OTP instead of UNIQUE key for sealing");
static bool skip_zk_test;
module_param_named(dcp_skip_zk_test, skip_zk_test, bool, 0);
MODULE_PARM_DESC(dcp_skip_zk_test, "Don't test whether device keys are zero'ed");
static unsigned int calc_blob_len(unsigned int payload_len)
{
return sizeof(struct dcp_blob_fmt) + payload_len + DCP_BLOB_AUTHLEN;
}
static int do_dcp_crypto(u8 *in, u8 *out, bool do_encrypt)
{
struct skcipher_request *req = NULL;
struct scatterlist src_sg, dst_sg;
struct crypto_skcipher *tfm;
u8 paes_key[DCP_PAES_KEYSIZE];
DECLARE_CRYPTO_WAIT(wait);
int res = 0;
if (use_otp_key)
paes_key[0] = DCP_PAES_KEY_OTP;
else
paes_key[0] = DCP_PAES_KEY_UNIQUE;
tfm = crypto_alloc_skcipher("ecb-paes-dcp", CRYPTO_ALG_INTERNAL,
CRYPTO_ALG_INTERNAL);
if (IS_ERR(tfm)) {
res = PTR_ERR(tfm);
tfm = NULL;
goto out;
}
req = skcipher_request_alloc(tfm, GFP_NOFS);
if (!req) {
res = -ENOMEM;
goto out;
}
skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |
CRYPTO_TFM_REQ_MAY_SLEEP,
crypto_req_done, &wait);
res = crypto_skcipher_setkey(tfm, paes_key, sizeof(paes_key));
if (res < 0)
goto out;
sg_init_one(&src_sg, in, AES_KEYSIZE_128);
sg_init_one(&dst_sg, out, AES_KEYSIZE_128);
skcipher_request_set_crypt(req, &src_sg, &dst_sg, AES_KEYSIZE_128,
NULL);
if (do_encrypt)
res = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
else
res = crypto_wait_req(crypto_skcipher_decrypt(req), &wait);
out:
skcipher_request_free(req);
crypto_free_skcipher(tfm);
return res;
}
static int do_aead_crypto(u8 *in, u8 *out, size_t len, u8 *key, u8 *nonce,
bool do_encrypt)
{
struct aead_request *aead_req = NULL;
struct scatterlist src_sg, dst_sg;
struct crypto_aead *aead;
int ret;
aead = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
if (IS_ERR(aead)) {
ret = PTR_ERR(aead);
goto out;
}
ret = crypto_aead_setauthsize(aead, DCP_BLOB_AUTHLEN);
if (ret < 0) {
pr_err("Can't set crypto auth tag len: %d\n", ret);
goto free_aead;
}
aead_req = aead_request_alloc(aead, GFP_KERNEL);
if (!aead_req) {
ret = -ENOMEM;
goto free_aead;
}
sg_init_one(&src_sg, in, len);
if (do_encrypt) {
/*
* If we encrypt our buffer has extra space for the auth tag.
*/
sg_init_one(&dst_sg, out, len + DCP_BLOB_AUTHLEN);
} else {
sg_init_one(&dst_sg, out, len);
}
aead_request_set_crypt(aead_req, &src_sg, &dst_sg, len, nonce);
aead_request_set_callback(aead_req, CRYPTO_TFM_REQ_MAY_SLEEP, NULL,
NULL);
aead_request_set_ad(aead_req, 0);
if (crypto_aead_setkey(aead, key, AES_KEYSIZE_128)) {
pr_err("Can't set crypto AEAD key\n");
ret = -EINVAL;
goto free_req;
}
if (do_encrypt)
ret = crypto_aead_encrypt(aead_req);
else
ret = crypto_aead_decrypt(aead_req);
free_req:
aead_request_free(aead_req);
free_aead:
crypto_free_aead(aead);
out:
return ret;
}
static int decrypt_blob_key(u8 *key)
{
return do_dcp_crypto(key, key, false);
}
static int encrypt_blob_key(u8 *key)
{
return do_dcp_crypto(key, key, true);
}
static int trusted_dcp_seal(struct trusted_key_payload *p, char *datablob)
{
struct dcp_blob_fmt *b = (struct dcp_blob_fmt *)p->blob;
int blen, ret;
blen = calc_blob_len(p->key_len);
if (blen > MAX_BLOB_SIZE)
return -E2BIG;
b->fmt_version = DCP_BLOB_VERSION;
get_random_bytes(b->nonce, AES_KEYSIZE_128);
get_random_bytes(b->blob_key, AES_KEYSIZE_128);
ret = do_aead_crypto(p->key, b->payload, p->key_len, b->blob_key,
b->nonce, true);
if (ret) {
pr_err("Unable to encrypt blob payload: %i\n", ret);
return ret;
}
ret = encrypt_blob_key(b->blob_key);
if (ret) {
pr_err("Unable to encrypt blob key: %i\n", ret);
return ret;
}
b->payload_len = get_unaligned_le32(&p->key_len);
p->blob_len = blen;
return 0;
}
static int trusted_dcp_unseal(struct trusted_key_payload *p, char *datablob)
{
struct dcp_blob_fmt *b = (struct dcp_blob_fmt *)p->blob;
int blen, ret;
if (b->fmt_version != DCP_BLOB_VERSION) {
pr_err("DCP blob has bad version: %i, expected %i\n",
b->fmt_version, DCP_BLOB_VERSION);
ret = -EINVAL;
goto out;
}
p->key_len = le32_to_cpu(b->payload_len);
blen = calc_blob_len(p->key_len);
if (blen != p->blob_len) {
pr_err("DCP blob has bad length: %i != %i\n", blen,
p->blob_len);
ret = -EINVAL;
goto out;
}
ret = decrypt_blob_key(b->blob_key);
if (ret) {
pr_err("Unable to decrypt blob key: %i\n", ret);
goto out;
}
ret = do_aead_crypto(b->payload, p->key, p->key_len + DCP_BLOB_AUTHLEN,
b->blob_key, b->nonce, false);
if (ret) {
pr_err("Unwrap of DCP payload failed: %i\n", ret);
goto out;
}
ret = 0;
out:
return ret;
}
static int test_for_zero_key(void)
{
/*
* Encrypting a plaintext of all 0x55 bytes will yield
* this ciphertext in case the DCP test key is used.
*/
static const u8 bad[] = {0x9a, 0xda, 0xe0, 0x54, 0xf6, 0x3d, 0xfa, 0xff,
0x5e, 0xa1, 0x8e, 0x45, 0xed, 0xf6, 0xea, 0x6f};
void *buf = NULL;
int ret = 0;
if (skip_zk_test)
goto out;
buf = kmalloc(AES_BLOCK_SIZE, GFP_KERNEL);
if (!buf) {
ret = -ENOMEM;
goto out;
}
memset(buf, 0x55, AES_BLOCK_SIZE);
ret = do_dcp_crypto(buf, buf, true);
if (ret)
goto out;
if (memcmp(buf, bad, AES_BLOCK_SIZE) == 0) {
pr_warn("Device neither in secure nor trusted mode!\n");
ret = -EINVAL;
}
out:
kfree(buf);
return ret;
}
static int trusted_dcp_init(void)
{
int ret;
if (use_otp_key)
pr_info("Using DCP OTP key\n");
ret = test_for_zero_key();
if (ret) {
pr_warn("Test for zero'ed keys failed: %i\n", ret);
return -EINVAL;
}
return register_key_type(&key_type_trusted);
}
static void trusted_dcp_exit(void)
{
unregister_key_type(&key_type_trusted);
}
struct trusted_key_ops dcp_trusted_key_ops = {
.exit = trusted_dcp_exit,
.init = trusted_dcp_init,
.seal = trusted_dcp_seal,
.unseal = trusted_dcp_unseal,
.migratable = 0,
};