From nobody Sun Feb 8 14:20:22 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D1BE4C46CA1 for ; Mon, 18 Sep 2023 16:00:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229757AbjIRQBC (ORCPT ); Mon, 18 Sep 2023 12:01:02 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58804 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229436AbjIRQBA (ORCPT ); Mon, 18 Sep 2023 12:01:00 -0400 Received: from mail-lj1-x22c.google.com (mail-lj1-x22c.google.com [IPv6:2a00:1450:4864:20::22c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2554E3C16 for ; Mon, 18 Sep 2023 09:00:03 -0700 (PDT) Received: by mail-lj1-x22c.google.com with SMTP id 38308e7fff4ca-2bff7d81b5eso30208231fa.0 for ; Mon, 18 Sep 2023 09:00:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sigma-star.at; s=google; t=1695052547; x=1695657347; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=PomBX+56H7vrYuyW5mK+RISliEIE/fWMnEIx5++eWoM=; b=WEbIE0C9qULl20uVjDLe4eQxf4Y50Md9Xhblj9r7MVywL0+W33CJbeLBfdP8X/42jQ c6nYrQUdHhZcW6z8wqCSEeiO6GIdx5lAF5R92I+m8l4DCtB5ZVea5Bb4qMIpo5Jw4B3+ rjsROo9GGK3k/EZx6vc2I01OthiBSscovQ+VyHFKdGSxKOt58RIqGOloua+bfslD+nig /T7ruBytpstiIxr4yInnVmuM/31rWs2SLO5hkIUrG/Nyk76rsSTlQPR4lkKEwarevQ8J Znr3rW6QfmzCdgAREOrPkxNwTrfgb3cr/D4FShsA8YOkR8qjLKRnQO+G+Tt0/4N9/VhH xJPg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1695052547; x=1695657347; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=PomBX+56H7vrYuyW5mK+RISliEIE/fWMnEIx5++eWoM=; b=n0KVc9gekATI+Uu0+sEQOkLnJu3Rzr1sO0KI/zjpftJfcgvmxOvt9ir3QSMPtVDuwI DE20bN1b5yMGmA7VlgqU2WHZIriAp2EhKzNj8Ru9Awst0Sby8rXRglED9X/PJ1PZsOH5 ycImAZWyFgGoYLeWNry/6trs9PDKQ/Q5GENv3iX3X0WBpPNBFS37lqOu0htx5nJvt39L 8iui6hRLAART1uChGDzwpb8YWNOl7R7xKdJe0otCfLTGTLcVqthvSvBqj4d6xCizBZYC pMiCOkcVWJtjROEPsiMUnWNlRUUaBfYqzJqVpqz3vmQC6rYba/815u6VemWRbZI+vjFo b/Vg== X-Gm-Message-State: AOJu0YxERg5mjMvOyrWFSy60dKrcKCbx2b6Hrp/ETfLza6eeY0jTKc/F D5Z5B/FpLJLiCznInC3kDsgEeV5olNy14P9+t/z6Gw== X-Google-Smtp-Source: AGHT+IE7PudVFRyVTSCFUj5G+MB8048X5oL3dmIhNpgsFEidEOg0vjf8zvgHSO8ppzPINT/Im8PoZw== X-Received: by 2002:a17:906:3158:b0:9ad:c763:c3fd with SMTP id e24-20020a170906315800b009adc763c3fdmr7616048eje.28.1695046717137; Mon, 18 Sep 2023 07:18:37 -0700 (PDT) Received: from localhost ([82.150.214.1]) by smtp.gmail.com with UTF8SMTPSA id jg36-20020a170907972400b009adc743340fsm5470921ejc.197.2023.09.18.07.18.35 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Sep 2023 07:18:36 -0700 (PDT) From: David Gstir To: Mimi Zohar , James Bottomley , Jarkko Sakkinen , Herbert Xu , "David S. Miller" Cc: David Gstir , Shawn Guo , Jonathan Corbet , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team , Ahmad Fatoum , sigma star Kernel Team , David Howells , Li Yang , Paul Moore , James Morris , "Serge E. Hallyn" , "Paul E. McKenney" , Randy Dunlap , Catalin Marinas , "Rafael J. Wysocki" , Tejun Heo , "Steven Rostedt (Google)" , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-integrity@vger.kernel.org, keyrings@vger.kernel.org, linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-security-module@vger.kernel.org, Richard Weinberger , David Oberhollenzer Subject: [PATCH v3 1/3] crypto: mxs-dcp: Add support for hardware provided keys Date: Mon, 18 Sep 2023 16:18:23 +0200 Message-ID: <20230918141826.8139-2-david@sigma-star.at> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20230918141826.8139-1-david@sigma-star.at> References: <20230918141826.8139-1-david@sigma-star.at> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" DCP is capable to performing AES with hardware-bound keys. These keys are not stored in main memory and are therefore not directly accessible by the operating system. So instead of feeding the key into DCP, we need to place a reference to such a key before initiating the crypto operation. Keys are referenced by a one byte identifiers. DCP supports 6 different keys: 4 slots in the secure memory area, a one time programmable key which can be burnt via on-chip fuses and an unique device key. Using these keys is restricted to in-kernel users that use them as building block for other crypto tools such as trusted keys. Allowing userspace (e.g. via AF_ALG) to use these keys to crypt or decrypt data is a security risk, because there is no access control mechanism. Co-developed-by: Richard Weinberger Signed-off-by: Richard Weinberger Co-developed-by: David Oberhollenzer Signed-off-by: David Oberhollenzer Signed-off-by: David Gstir --- drivers/crypto/mxs-dcp.c | 104 ++++++++++++++++++++++++++++++++++----- include/soc/fsl/dcp.h | 17 +++++++ 2 files changed, 110 insertions(+), 11 deletions(-) create mode 100644 include/soc/fsl/dcp.h diff --git a/drivers/crypto/mxs-dcp.c b/drivers/crypto/mxs-dcp.c index f6b7bce0e656..2dc664fb2faf 100644 --- a/drivers/crypto/mxs-dcp.c +++ b/drivers/crypto/mxs-dcp.c @@ -15,6 +15,7 @@ #include #include #include +#include =20 #include #include @@ -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; }; =20 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) =20 +#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 =3D global_sdcp; struct dcp_dma_desc *desc =3D &sdcp->coh->desc[actx->chan]; struct dcp_aes_req_ctx *rctx =3D skcipher_request_ctx(req); + bool key_referenced =3D actx->key_referenced; int ret; =20 - key_phys =3D dma_map_single(sdcp->dev, sdcp->coh->aes_key, - 2 * AES_KEYSIZE_128, DMA_TO_DEVICE); - ret =3D dma_mapping_error(sdcp->dev, key_phys); - if (ret) - return ret; + if (!key_referenced) { + key_phys =3D dma_map_single(sdcp->dev, sdcp->coh->aes_key, + 2 * AES_KEYSIZE_128, DMA_TO_DEVICE); + ret =3D dma_mapping_error(sdcp->dev, key_phys); + if (ret) + return ret; + } =20 src_phys =3D 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; =20 - /* Payload contains the key. */ - desc->control0 |=3D MXS_DCP_CONTROL0_PAYLOAD_KEY; + if (key_referenced) + /* Set OTP key bit to select the key via KEY_SELECT. */ + desc->control0 |=3D MXS_DCP_CONTROL0_OTP_KEY; + else + /* Payload contains the key. */ + desc->control0 |=3D MXS_DCP_CONTROL0_PAYLOAD_KEY; =20 if (rctx->enc) desc->control0 |=3D MXS_DCP_CONTROL0_CIPHER_ENCRYPT; @@ -270,6 +282,9 @@ static int mxs_dcp_run_aes(struct dcp_async_ctx *actx, else desc->control1 |=3D MXS_DCP_CONTROL1_CIPHER_MODE_CBC; =20 + if (key_referenced) + desc->control1 |=3D sdcp->coh->aes_key[0] << MXS_DCP_CONTROL1_KEY_SELECT= _SHIFT; + desc->next_cmd_addr =3D 0; desc->source =3D src_phys; desc->destination =3D dst_phys; @@ -284,9 +299,9 @@ static int mxs_dcp_run_aes(struct dcp_async_ctx *actx, 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; } =20 @@ -453,7 +468,7 @@ static int mxs_dcp_aes_enqueue(struct skcipher_request = *req, int enc, int ecb) struct dcp_aes_req_ctx *rctx =3D skcipher_request_ctx(req); int ret; =20 - if (unlikely(actx->key_len !=3D AES_KEYSIZE_128)) + if (unlikely(actx->key_len !=3D AES_KEYSIZE_128 && !actx->key_referenced)) return mxs_dcp_block_fallback(req, enc); =20 rctx->enc =3D enc; @@ -500,6 +515,7 @@ static int mxs_dcp_aes_setkey(struct crypto_skcipher *t= fm, const u8 *key, * there can still be an operation in progress. */ actx->key_len =3D len; + actx->key_referenced =3D false; if (len =3D=3D 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); } =20 +static int mxs_dcp_aes_setrefkey(struct crypto_skcipher *tfm, const u8 *ke= y, + unsigned int len) +{ + struct dcp_async_ctx *actx =3D crypto_skcipher_ctx(tfm); + + if (len !=3D 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 =3D len; + actx->key_referenced =3D true; + break; + default: + return -EINVAL; + } + + return 0; +} + static int mxs_dcp_aes_fallback_init_tfm(struct crypto_skcipher *tfm) { const char *name =3D crypto_tfm_alg_name(crypto_skcipher_tfm(tfm)); @@ -539,6 +581,13 @@ static void mxs_dcp_aes_fallback_exit_tfm(struct crypt= o_skcipher *tfm) crypto_free_skcipher(actx->fallback); } =20 +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[] =3D { .ivsize =3D AES_BLOCK_SIZE, .init =3D mxs_dcp_aes_fallback_init_tfm, .exit =3D mxs_dcp_aes_fallback_exit_tfm, + }, { + .base.cra_name =3D "ecb(paes)", + .base.cra_driver_name =3D "ecb-paes-dcp", + .base.cra_priority =3D 401, + .base.cra_alignmask =3D 15, + .base.cra_flags =3D CRYPTO_ALG_ASYNC | CRYPTO_ALG_INTERNAL, + .base.cra_blocksize =3D AES_BLOCK_SIZE, + .base.cra_ctxsize =3D sizeof(struct dcp_async_ctx), + .base.cra_module =3D THIS_MODULE, + + .min_keysize =3D DCP_PAES_KEYSIZE, + .max_keysize =3D DCP_PAES_KEYSIZE, + .setkey =3D mxs_dcp_aes_setrefkey, + .encrypt =3D mxs_dcp_aes_ecb_encrypt, + .decrypt =3D mxs_dcp_aes_ecb_decrypt, + .init =3D mxs_dcp_paes_init_tfm, + }, { + .base.cra_name =3D "cbc(paes)", + .base.cra_driver_name =3D "cbc-paes-dcp", + .base.cra_priority =3D 401, + .base.cra_alignmask =3D 15, + .base.cra_flags =3D CRYPTO_ALG_ASYNC | CRYPTO_ALG_INTERNAL, + .base.cra_blocksize =3D AES_BLOCK_SIZE, + .base.cra_ctxsize =3D sizeof(struct dcp_async_ctx), + .base.cra_module =3D THIS_MODULE, + + .min_keysize =3D DCP_PAES_KEYSIZE, + .max_keysize =3D DCP_PAES_KEYSIZE, + .setkey =3D mxs_dcp_aes_setrefkey, + .encrypt =3D mxs_dcp_aes_cbc_encrypt, + .decrypt =3D mxs_dcp_aes_cbc_decrypt, + .ivsize =3D AES_BLOCK_SIZE, + .init =3D mxs_dcp_paes_init_tfm, }, }; =20 diff --git a/include/soc/fsl/dcp.h b/include/soc/fsl/dcp.h new file mode 100644 index 000000000000..cda89e260c46 --- /dev/null +++ b/include/soc/fsl/dcp.h @@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2021 sigma star gmbh + */ + +#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 */ --=20 2.35.3 From nobody Sun Feb 8 14:20:22 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D032ACD13DA for ; Mon, 18 Sep 2023 15:49:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229772AbjIRPt4 (ORCPT ); Mon, 18 Sep 2023 11:49:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48848 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229909AbjIRPts (ORCPT ); Mon, 18 Sep 2023 11:49:48 -0400 Received: from mail-lj1-x22e.google.com (mail-lj1-x22e.google.com [IPv6:2a00:1450:4864:20::22e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 70965CF4 for ; Mon, 18 Sep 2023 08:48:14 -0700 (PDT) Received: by mail-lj1-x22e.google.com with SMTP id 38308e7fff4ca-2bffe2840adso24549691fa.2 for ; Mon, 18 Sep 2023 08:48:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sigma-star.at; s=google; t=1695051881; x=1695656681; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=G9BlGz3qCp3ihQBmoP998iBDhoGBlremsEFBMozEXZI=; b=qtdRwKAYbMwV0vJmnj3SoP5TzAYlJwOmO0hacPq2SKkRg1xucjfKXmE0qPivbA//FI J3lsdLbjrWfcaR0yybkY/sR+dfqQN43izFaUdp/WQE+i2qa7qGdMyA2YkujH51I1F4pb rIyX93bs1eVIlh1T2ZYyfKRcWwa/OxBSIzSut43TJWUTHI2Je/sD9lkZXQQgsWZCirJz 2oI18m5TXSNHlY/ok81GYUjI+d+TQCEly02A8a6wxR7XLbY4vTenRbmqzvRnJMPVqknu vrDBWYV6WspKHACs6S2hPCxEpqdrH+eUWaUAlcXiNi5YHrgRUvq1BWtD/SoEYJoWwDso PKNg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1695051881; x=1695656681; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=G9BlGz3qCp3ihQBmoP998iBDhoGBlremsEFBMozEXZI=; b=OOrGHrJOeZV6n0TQs6AkbSMjL3DYU+RtEXYSK+TZ9lxgZztSCNonU3HS+BJ7ic+rXH Ve+vxmxfqhzidRCPs3QZkC/m/PpPJyw3reijYQNUBKtsmLWHFPThiWWbcJDYh5M6MsEj yb5pGTlMPaYwCLKSHHE2D/B3dge8WYjyzIXsvj838pvx5QO9NnmYQzHo9GRjoQ024JlH RvJ7tyk617OxKJNBGeokcFueEN09xqmPgTO4AmYj5rvKbEeuO6NFEKUe1s1weILssz1W /eH09n+rfXRV+7dtS5hLdpSOzBsG4vBWT2PFTxXl+Wv6mU//4GHO9FnK01dBKGjaP11w 1bfQ== X-Gm-Message-State: AOJu0YzzFIvZq90lN15CJmZy4rDjvXbznm5r0dKVgwCQvcTwfFofkD25 G2vrJkXOFZdQ+1aMmtYmkVPXlRCXcwBP9F4fUnd44A== X-Google-Smtp-Source: AGHT+IFTq04S1U7+RcR39a+EsEzdR1VMXAgYk0b87qrajRa9J5KYAAO+8WT10iy3a/xq7soTWQam4w== X-Received: by 2002:a17:906:101b:b0:99b:4ed4:5527 with SMTP id 27-20020a170906101b00b0099b4ed45527mr7642795ejm.25.1695046720138; Mon, 18 Sep 2023 07:18:40 -0700 (PDT) Received: from localhost ([82.150.214.1]) by smtp.gmail.com with UTF8SMTPSA id i13-20020a170906114d00b00992afee724bsm6408405eja.76.2023.09.18.07.18.38 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Sep 2023 07:18:39 -0700 (PDT) From: David Gstir To: Mimi Zohar , James Bottomley , Jarkko Sakkinen , Herbert Xu , "David S. Miller" Cc: David Gstir , Shawn Guo , Jonathan Corbet , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team , Ahmad Fatoum , sigma star Kernel Team , David Howells , Li Yang , Paul Moore , James Morris , "Serge E. Hallyn" , "Paul E. McKenney" , Randy Dunlap , Catalin Marinas , "Rafael J. Wysocki" , Tejun Heo , "Steven Rostedt (Google)" , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-integrity@vger.kernel.org, keyrings@vger.kernel.org, linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-security-module@vger.kernel.org, Richard Weinberger , David Oberhollenzer Subject: [PATCH v3 2/3] KEYS: trusted: Introduce support for NXP DCP-based trusted keys Date: Mon, 18 Sep 2023 16:18:24 +0200 Message-ID: <20230918141826.8139-3-david@sigma-star.at> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20230918141826.8139-1-david@sigma-star.at> References: <20230918141826.8139-1-david@sigma-star.at> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" DCP (Data Co-Processor) is the little brother of NXP's CAAM IP. Beside of accelerated crypto operations, it also offers support for hardware-bound keys. Using this feature it is possible to implement a blob mechanism just like CAAM offers. Unlike on CAAM, constructing and parsing the blob has to happen in software. We chose the following format for the blob: /* * 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 AES_BLOCK_SIZE is attached at the end of = it. * * The total size of a DCP BLOB is sizeof(struct dcp_blob_fmt) + @payload_l= en + * AES_BLOCK_SIZE. */ struct dcp_blob_fmt { __u8 fmt_version; __u8 blob_key[AES_KEYSIZE_128]; __u8 nonce[AES_KEYSIZE_128]; __le32 payload_len; __u8 payload[]; } __packed; @payload is the key provided by trusted_key_ops->seal(). By default the UNIQUE device key is used, it is also possible to use the OTP key. While the UNIQUE device key should be unique it is not entirely clear whether this is the case due to unclear documentation. If someone wants to be sure they can burn their own unique key into the OTP fuse and set the use_otp_key module parameter. Co-developed-by: Richard Weinberger Signed-off-by: Richard Weinberger Co-developed-by: David Oberhollenzer Signed-off-by: David Oberhollenzer Signed-off-by: David Gstir --- .../admin-guide/kernel-parameters.txt | 13 + MAINTAINERS | 9 + include/keys/trusted_dcp.h | 11 + security/keys/trusted-keys/Kconfig | 9 +- security/keys/trusted-keys/Makefile | 2 + security/keys/trusted-keys/trusted_core.c | 6 +- security/keys/trusted-keys/trusted_dcp.c | 311 ++++++++++++++++++ 7 files changed, 359 insertions(+), 2 deletions(-) create mode 100644 include/keys/trusted_dcp.h create mode 100644 security/keys/trusted-keys/trusted_dcp.c diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentatio= n/admin-guide/kernel-parameters.txt index 0a1731a0f0ef..c11eda8b38e0 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -6566,6 +6566,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 @@ -6581,6 +6582,18 @@ If not specified, "default" is used. In this case, the RNG's choice is left to each individual trust source. =20 + trusted.dcp_use_otp_key + This is intended to be used in combination with + trusted.source=3Ddcp 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=3Ddcp and will disable the check if all + the blob key is zero'ed. This is helpful for situations where + having this key zero'ed is acceptable. E.g. in testing + scenarios. + tsc=3D Disable clocksource stability checks for TSC. Format: [x86] reliable: mark tsc clocksource as reliable, this diff --git a/MAINTAINERS b/MAINTAINERS index 90f13281d297..988d01226131 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -11647,6 +11647,15 @@ S: Maintained F: include/keys/trusted_caam.h F: security/keys/trusted-keys/trusted_caam.c =20 +KEYS-TRUSTED-DCP +M: David Gstir +R: sigma star Kernel Team +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 L: linux-integrity@vger.kernel.org diff --git a/include/keys/trusted_dcp.h b/include/keys/trusted_dcp.h new file mode 100644 index 000000000000..9aaa42075b40 --- /dev/null +++ b/include/keys/trusted_dcp.h @@ -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 diff --git a/security/keys/trusted-keys/Kconfig b/security/keys/trusted-key= s/Kconfig index dbfdd8536468..c6b80b7e5c78 100644 --- a/security/keys/trusted-keys/Kconfig +++ b/security/keys/trusted-keys/Kconfig @@ -33,6 +33,13 @@ config TRUSTED_KEYS_CAAM Enable use of NXP's Cryptographic Accelerator and Assurance Module (CAAM) as trusted key backend. =20 -if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE && !TRUSTED_KEYS_CAAM +config TRUSTED_KEYS_DCP + bool "DCP-based trusted keys" + depends on CRYPTO_DEV_MXS_DCP >=3D TRUSTED_KEYS + default y + help + Enable use of NXP's DCP (Data Co-Processor) as trusted key backend. + +if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE && !TRUSTED_KEYS_CAAM && !TRUSTE= D_KEYS_DCP comment "No trust source selected!" endif diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-ke= ys/Makefile index 735aa0bc08ef..f0f3b27f688b 100644 --- a/security/keys/trusted-keys/Makefile +++ b/security/keys/trusted-keys/Makefile @@ -14,3 +14,5 @@ trusted-$(CONFIG_TRUSTED_KEYS_TPM) +=3D tpm2key.asn1.o trusted-$(CONFIG_TRUSTED_KEYS_TEE) +=3D trusted_tee.o =20 trusted-$(CONFIG_TRUSTED_KEYS_CAAM) +=3D trusted_caam.o + +trusted-$(CONFIG_TRUSTED_KEYS_DCP) +=3D trusted_dcp.o diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trus= ted-keys/trusted_core.c index c6fc50d67214..8af0988be850 100644 --- a/security/keys/trusted-keys/trusted_core.c +++ b/security/keys/trusted-keys/trusted_core.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -30,7 +31,7 @@ MODULE_PARM_DESC(rng, "Select trusted key RNG"); =20 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 dc= p)"); =20 static const struct trusted_key_source trusted_key_sources[] =3D { #if defined(CONFIG_TRUSTED_KEYS_TPM) @@ -42,6 +43,9 @@ static const struct trusted_key_source trusted_key_source= s[] =3D { #if defined(CONFIG_TRUSTED_KEYS_CAAM) { "caam", &trusted_key_caam_ops }, #endif +#if defined(CONFIG_TRUSTED_KEYS_DCP) + { "dcp", &dcp_trusted_key_ops }, +#endif }; =20 DEFINE_STATIC_CALL_NULL(trusted_key_init, *trusted_key_sources[0].ops->ini= t); diff --git a/security/keys/trusted-keys/trusted_dcp.c b/security/keys/trust= ed-keys/trusted_dcp.c new file mode 100644 index 000000000000..8d19b92fe976 --- /dev/null +++ b/security/keys/trusted-keys/trusted_dcp.c @@ -0,0 +1,311 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2021 sigma star gmbh + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DCP_BLOB_VERSION 1 +#define DCP_BLOB_AUTHLEN 16 + +/** + * 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 seali= ng"); + +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 zer= o'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 is_encrypt) +{ + int res =3D 0; + struct skcipher_request *req =3D NULL; + DECLARE_CRYPTO_WAIT(wait); + struct scatterlist src_sg, dst_sg; + struct crypto_skcipher *tfm; + u8 paes_key[DCP_PAES_KEYSIZE]; + + if (use_otp_key) + paes_key[0] =3D DCP_PAES_KEY_OTP; + else + paes_key[0] =3D DCP_PAES_KEY_UNIQUE; + + tfm =3D crypto_alloc_skcipher("ecb-paes-dcp", CRYPTO_ALG_INTERNAL, + CRYPTO_ALG_INTERNAL); + if (IS_ERR(tfm)) { + res =3D PTR_ERR(tfm); + pr_err("Unable to request DCP pAES-ECB cipher: %i\n", res); + tfm =3D NULL; + goto out; + } + + req =3D skcipher_request_alloc(tfm, GFP_NOFS); + if (!req) { + res =3D -ENOMEM; + goto out; + } + + skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG | + CRYPTO_TFM_REQ_MAY_SLEEP, + crypto_req_done, &wait); + res =3D 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 (is_encrypt) + res =3D crypto_wait_req(crypto_skcipher_encrypt(req), &wait); + else + res =3D 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 is_encrypt) +{ + struct aead_request *aead_req =3D NULL; + struct scatterlist src_sg, dst_sg; + struct crypto_aead *aead; + int ret; + + aead =3D crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC); + if (IS_ERR(aead)) { + ret =3D PTR_ERR(aead); + pr_err("Unable to request AES-GCM cipher: %i\n", ret); + goto out; + } + + ret =3D 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 =3D aead_request_alloc(aead, GFP_KERNEL); + if (!aead_req) { + ret =3D -ENOMEM; + goto free_aead; + } + + sg_init_one(&src_sg, in, len); + if (is_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 =3D -EINVAL; + goto free_req; + } + + if (is_encrypt) + ret =3D crypto_aead_encrypt(aead_req); + else + ret =3D 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 =3D (struct dcp_blob_fmt *)p->blob; + int blen, ret; + + blen =3D calc_blob_len(p->key_len); + if (blen > MAX_BLOB_SIZE) + return -E2BIG; + + b->fmt_version =3D DCP_BLOB_VERSION; + get_random_bytes(b->nonce, AES_KEYSIZE_128); + get_random_bytes(b->blob_key, AES_KEYSIZE_128); + + ret =3D 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 =3D encrypt_blob_key(b->blob_key); + if (ret) { + pr_err("Unable to encrypt blob key: %i\n", ret); + return ret; + } + + b->payload_len =3D get_unaligned_le32(&p->key_len); + p->blob_len =3D blen; + return 0; +} + +static int trusted_dcp_unseal(struct trusted_key_payload *p, char *datablo= b) +{ + struct dcp_blob_fmt *b =3D (struct dcp_blob_fmt *)p->blob; + int blen, ret; + + if (b->fmt_version !=3D DCP_BLOB_VERSION) { + pr_err("DCP blob has bad version: %i, expected %i\n", + b->fmt_version, DCP_BLOB_VERSION); + ret =3D -EINVAL; + goto out; + } + + p->key_len =3D le32_to_cpu(b->payload_len); + blen =3D calc_blob_len(p->key_len); + if (blen !=3D p->blob_len) { + pr_err("DCP blob has bad length: %i !=3D %i\n", blen, + p->blob_len); + ret =3D -EINVAL; + goto out; + } + + ret =3D decrypt_blob_key(b->blob_key); + if (ret) { + pr_err("Unable to decrypt blob key: %i\n", ret); + goto out; + } + + ret =3D 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 =3D 0; +out: + return ret; +} + +static int test_for_zero_key(void) +{ + static const u8 bad[] =3D {0x9a, 0xda, 0xe0, 0x54, 0xf6, 0x3d, 0xfa, 0xff, + 0x5e, 0xa1, 0x8e, 0x45, 0xed, 0xf6, 0xea, 0x6f}; + void *buf =3D NULL; + int ret =3D 0; + + if (skip_zk_test) + goto out; + + buf =3D kmalloc(AES_BLOCK_SIZE, GFP_KERNEL); + if (!buf) { + ret =3D -ENOMEM; + goto out; + } + + memset(buf, 0x55, AES_BLOCK_SIZE); + + ret =3D do_dcp_crypto(buf, buf, true); + if (ret) + goto out; + + if (memcmp(buf, bad, AES_BLOCK_SIZE) =3D=3D 0) { + pr_err("Device neither in secure nor trusted mode!\n"); + ret =3D -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 =3D test_for_zero_key(); + if (ret) { + pr_err("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 =3D { + .exit =3D trusted_dcp_exit, + .init =3D trusted_dcp_init, + .seal =3D trusted_dcp_seal, + .unseal =3D trusted_dcp_unseal, + .migratable =3D 0, +}; --=20 2.35.3 From nobody Sun Feb 8 14:20:22 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0808DCD37B0 for ; Mon, 18 Sep 2023 17:10:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231247AbjIRRKb (ORCPT ); Mon, 18 Sep 2023 13:10:31 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43030 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230476AbjIRRK3 (ORCPT ); Mon, 18 Sep 2023 13:10:29 -0400 Received: from mail-ed1-x52d.google.com (mail-ed1-x52d.google.com [IPv6:2a00:1450:4864:20::52d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5E0B393 for ; Mon, 18 Sep 2023 10:10:20 -0700 (PDT) Received: by mail-ed1-x52d.google.com with SMTP id 4fb4d7f45d1cf-532addba879so195195a12.0 for ; Mon, 18 Sep 2023 10:10:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sigma-star.at; s=google; t=1695057018; x=1695661818; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=+qntkmutwprS+2oQeQzgmaP97TAaIsTbzLeg5qvDo3I=; b=A7PzIX1ha/XLiSxe6mtZWfCVuFxL5e1sZ4fZQSvUXHkIlkktCpnFmIuf8V3Z7GFf2g eeDtWSB1RRwrZsQC+hjKnctsFccDCS3ZQHVk6CpH/8cr+NkeWc+K5/EbggOCQ3VnlxyP 9xom1T2j1eS9gfRxXw3YzJcjMBkmOGjBMbcJTzmDESOI+KlYjo9YOKGADIAB2h+HcApI /nZaJTz2LnYd9vcau6Fr3V+NWTR4DmjBmgL5Nc93OC0l35ubw9W3OsDx5WRuUTxl6iwG Apd/vnGjKPkOEP+Kl7IvUlRDAq1kQfGOR6AZZTeubPAKjskbGRprL5og+3NaJRK4jOxU t0HA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1695057018; x=1695661818; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=+qntkmutwprS+2oQeQzgmaP97TAaIsTbzLeg5qvDo3I=; b=nqZOhNAF/mG8Dub0oKfxxl2y+eqj/Ibt5ck7u8sbyShk/WXAxujX8pA/kRK0/QmDDl E0VUUpsM/7hVcU0Ba+TRWbDAMIVtZI5TZcssVpsFl95aW2taIXugiFHH0ZQoNfCwkgUi maVn0q3t2OzfPDsdQau7DdLKJERYxsZ3zf57HyZwpdTBXJEu+AurgVfCE6BP/w1zuhui imq5lC3C6K3r6mnsBB8rmxomJQiFl2INguZfLC9Rp2NecdIkKEZiG9rux744bdVRvokf mscJZZd4T+xuY/XnM5cL+EQBsU/7k5StoD9kF5s9xlZlMKesU+Mgjt/vpluQ2bGSchcz ZTQA== X-Gm-Message-State: AOJu0YzLtos6dvdEKZsr9IejkvDrv8JBWnSLlb8TeYfeqmpFZemmu4Tm xFMnh0TsNs5s4l8dJlPRgMHs19oiy165ubZ0QgqN9g== X-Google-Smtp-Source: AGHT+IG2rNuc/qU7cun35uIs/6xu+f6PNjQcCosf7tlGzspNosTVVLVBRGNxbIq/UI3P0ddJC/NsSA== X-Received: by 2002:a17:907:3e91:b0:9aa:206d:b052 with SMTP id hs17-20020a1709073e9100b009aa206db052mr17366327ejc.27.1695046722736; Mon, 18 Sep 2023 07:18:42 -0700 (PDT) Received: from localhost ([82.150.214.1]) by smtp.gmail.com with UTF8SMTPSA id g24-20020a170906199800b0099364d9f0e9sm6530301ejd.102.2023.09.18.07.18.40 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Sep 2023 07:18:42 -0700 (PDT) From: David Gstir To: Mimi Zohar , James Bottomley , Jarkko Sakkinen , Herbert Xu , "David S. Miller" Cc: David Gstir , Shawn Guo , Jonathan Corbet , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team , Ahmad Fatoum , sigma star Kernel Team , David Howells , Li Yang , Paul Moore , James Morris , "Serge E. Hallyn" , "Paul E. McKenney" , Randy Dunlap , Catalin Marinas , "Rafael J. Wysocki" , Tejun Heo , "Steven Rostedt (Google)" , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, linux-integrity@vger.kernel.org, keyrings@vger.kernel.org, linux-crypto@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-security-module@vger.kernel.org, Richard Weinberger , David Oberhollenzer Subject: [PATCH v3 3/3] doc: trusted-encrypted: add DCP as new trust source Date: Mon, 18 Sep 2023 16:18:25 +0200 Message-ID: <20230918141826.8139-4-david@sigma-star.at> X-Mailer: git-send-email 2.42.0 In-Reply-To: <20230918141826.8139-1-david@sigma-star.at> References: <20230918141826.8139-1-david@sigma-star.at> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Update the documentation for trusted and encrypted KEYS with DCP as new trust source: - Describe security properties of DCP trust source - Describe key usage - Document blob format Co-developed-by: Richard Weinberger Signed-off-by: Richard Weinberger Co-developed-by: David Oberhollenzer Signed-off-by: David Oberhollenzer Signed-off-by: David Gstir --- .../security/keys/trusted-encrypted.rst | 85 +++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentat= ion/security/keys/trusted-encrypted.rst index 9bc9db8ec651..4452070afbe9 100644 --- a/Documentation/security/keys/trusted-encrypted.rst +++ b/Documentation/security/keys/trusted-encrypted.rst @@ -42,6 +42,14 @@ safe. randomly generated and fused into each SoC at manufacturing time. Otherwise, a common fixed test key is used instead. =20 + (4) DCP (Data Co-Processor: crypto accelerator of various i.MX SoCs) + + Rooted to a one-time programmable key (OTP) that is generally bur= nt + in the on-chip fuses and is accessible to the DCP encryption engi= ne 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 selecti= ng + the OTP key can be done via a module parameter (dcp_use_otp_key). + * Execution isolation =20 (1) TPM @@ -57,6 +65,12 @@ safe. =20 Fixed set of operations running in isolated execution environment. =20 + (4) DCP + + Fixed set of cryptographic operations running in isolated executi= on + 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 =20 (1) TPM @@ -79,6 +93,11 @@ safe. Relies on the High Assurance Boot (HAB) mechanism of NXP SoCs for platform integrity. =20 + (4) DCP + + Relies on Secure/Trusted boot process (called HAB by vendor) for + platform integrity. + * Interfaces and APIs =20 (1) TPM @@ -94,6 +113,11 @@ safe. =20 Interface is specific to silicon vendor. =20 + (4) DCP + + Vendor-specific API that is implemented as part of the DCP crypto= driver in + ``drivers/crypto/mxs-dcp.c``. + * Threat model =20 The strength and appropriateness of a particular trust source for a g= iven @@ -129,6 +153,13 @@ selected trust source: CAAM HWRNG, enable CRYPTO_DEV_FSL_CAAM_RNG_API and ensure the device is probed. =20 + * DCP (Data Co-Processor: crypto accelerator of various i.MX SoCs) + + The DCP hardware device itself does not provide a dedicated RNG inter= face, + 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 en= abled + to back the kernel RNG. + Users may override this by specifying ``trusted.rng=3Dkernel`` on the kern= el command-line to override the used RNG with the kernel's random number pool. =20 @@ -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). =20 +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 fo= rmat +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 -------------------- =20 @@ -426,3 +470,44 @@ 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 +--------------- + +The Data Co-Processor (DCP) provides hardware-bound AES keys using its +AES encryption engine only. It does not provide direct key sealing/unseali= ng. +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 12= 8-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 A= ES +encryption engine with AES-128-ECB. The encrypted BEK, generated nonce, +BEK-encrypted payload and authentication tag make up the blob format toget= her +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 AES_BLOCK_SIZE is attached at the en= d of it. + * + * The total size of a DCP BLOB is sizeof(struct dcp_blob_fmt) + @payl= oad_len + + * AES_BLOCK_SIZE. + */ + struct dcp_blob_fmt { + __u8 fmt_version; + __u8 blob_key[AES_KEYSIZE_128]; + __u8 nonce[AES_KEYSIZE_128]; + __le32 payload_len; + __u8 payload[]; + } __packed; --=20 2.35.3