From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5EBF21AF4E4; Mon, 9 Sep 2024 11:23:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725881033; cv=none; b=aAQnIIIJZzudhpLL1BrY2wHeUFhITBw4JqxxO1z79R1A/C8IHC77QS2poP3Vcuvh2FQW8T3clhbxTfHfU5vxZtkHQIAi1Z4zwS45rRiPyR9RCGPUWvlae8KkGB4BuclkORdG0Myvttx5clDh8Cy0xK+rwi5TYmlWzvNXKNwZUYI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1725881033; c=relaxed/simple; bh=AQzT3bAV2JDDv98lxn2LYC9mXTmymBsjkG6LCRpyPxU=; h=Message-ID:Date:MIME-Version:Subject:To:Cc:References:From: In-Reply-To:Content-Type; b=gVZttwQ8tMcHh9fKPkulXvK/6ruxXE/VKglyyEKUkAr85jIpNTU1klaEgQDyGt9z/wMCzEE0SEzab4AJA4M44M45T/3IMwMUXxR0RYaoaWvokRBYvsCnpPwwv+iSo/EqPCYeZymUTMZ7GjDdSNtFTGtgK8QOTjqs+vQU507MhaQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=fIxa7MfC; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="fIxa7MfC" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 23E05C4CEC5; Mon, 9 Sep 2024 11:23:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1725881032; bh=AQzT3bAV2JDDv98lxn2LYC9mXTmymBsjkG6LCRpyPxU=; h=Date:Subject:To:Cc:References:From:In-Reply-To:From; b=fIxa7MfCpT2NrhKQOzTCEcsR2Jj//3XNpMa32fzJWiV2Se2PY0rkOeaEEQI9zn5Cd bVsbJiFRXl6JbG9+j1hSknxLqbm5Igqm0wLyebgDU+ilL1yFpOEshwYSpF8xphZ0fO pNrGlj1uDMqDVJ2+SwefLeb3jg3dR9LLurP23ztS+FGFZfkneaPXMHZPiagCedVUCM Bex8xTF362cqZPzzT3DONjUW0lcaPkrjok9ogTrD3B9FWo2oEKB49ixdHuLsEY61OU Z3O+NUB4VeUdkFz666hVip30pCIEHrNJ0BJcP3eQLCGXlwkvY65VmEio0tued3SUtz dyippi+O8W0Kg== Message-ID: Date: Mon, 9 Sep 2024 13:23:38 +0200 Precedence: bulk X-Mailing-List: linux-fsdevel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v6 06/17] firmware: qcom: scm: add a call for deriving the software secret To: Bartosz Golaszewski , Jens Axboe , Jonathan Corbet , Alasdair Kergon , Mike Snitzer , Mikulas Patocka , Adrian Hunter , Asutosh Das , Ritesh Harjani , Ulf Hansson , Alim Akhtar , Avri Altman , Bart Van Assche , "James E.J. Bottomley" , "Martin K. Petersen" , Eric Biggers , "Theodore Y. Ts'o" , Jaegeuk Kim , Alexander Viro , Christian Brauner , Jan Kara , Bjorn Andersson , Konrad Dybcio , Manivannan Sadhasivam , Dmitry Baryshkov , Gaurav Kashyap , Neil Armstrong Cc: linux-block@vger.kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, dm-devel@lists.linux.dev, linux-mmc@vger.kernel.org, linux-scsi@vger.kernel.org, linux-fscrypt@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-arm-msm@vger.kernel.org, Bartosz Golaszewski References: <20240906-wrapped-keys-v6-0-d59e61bc0cb4@linaro.org> <20240906-wrapped-keys-v6-6-d59e61bc0cb4@linaro.org> Content-Language: en-US From: Konrad Dybcio In-Reply-To: <20240906-wrapped-keys-v6-6-d59e61bc0cb4@linaro.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 6.09.2024 8:07 PM, Bartosz Golaszewski wrote: > From: Gaurav Kashyap > > Inline storage encryption may require deriving a software secret from > storage keys added to the kernel. > > For raw keys, this can be directly done in the kernel as keys are not > encrypted in memory. > > However, hardware wrapped keys can only be unwrapped by the HW wrapping > entity. In case of Qualcomm's wrapped key solution, this is done by the > Hardware Key Manager (HWKM) from Trustzone. > > Add a new SCM call which provides a hook to the software secret crypto > profile API provided by the block layer. > > Tested-by: Neil Armstrong > Signed-off-by: Gaurav Kashyap > Reviewed-by: Dmitry Baryshkov > Signed-off-by: Bartosz Golaszewski > --- > drivers/firmware/qcom/qcom_scm.c | 65 ++++++++++++++++++++++++++++++++++ > drivers/firmware/qcom/qcom_scm.h | 1 + > include/linux/firmware/qcom/qcom_scm.h | 2 ++ > 3 files changed, 68 insertions(+) > > diff --git a/drivers/firmware/qcom/qcom_scm.c b/drivers/firmware/qcom/qcom_scm.c > index 10986cb11ec0..ad3f9e9ed35d 100644 > --- a/drivers/firmware/qcom/qcom_scm.c > +++ b/drivers/firmware/qcom/qcom_scm.c > @@ -1252,6 +1252,71 @@ int qcom_scm_ice_set_key(u32 index, const u8 *key, u32 key_size, > } > EXPORT_SYMBOL_GPL(qcom_scm_ice_set_key); > > +/** > + * qcom_scm_derive_sw_secret() - Derive software secret from wrapped key > + * @wkey: the hardware wrapped key inaccessible to software > + * @wkey_size: size of the wrapped key > + * @sw_secret: the secret to be derived which is exactly the secret size > + * @sw_secret_size: size of the sw_secret > + * > + * Derive a software secret from a hardware wrapped key for software crypto > + * operations. > + * For wrapped keys, the key needs to be unwrapped, in order to derive a > + * software secret, which can be done in the hardware from a secure execution > + * environment. > + * > + * For more information on sw secret, please refer to "Hardware-wrapped keys" > + * section of Documentation/block/inline-encryption.rst. > + * > + * Return: 0 on success; -errno on failure. > + */ > +int qcom_scm_derive_sw_secret(const u8 *wkey, size_t wkey_size, > + u8 *sw_secret, size_t sw_secret_size) > +{ > + struct qcom_scm_desc desc = { > + .svc = QCOM_SCM_SVC_ES, > + .cmd = QCOM_SCM_ES_DERIVE_SW_SECRET, > + .arginfo = QCOM_SCM_ARGS(4, QCOM_SCM_RW, > + QCOM_SCM_VAL, QCOM_SCM_RW, > + QCOM_SCM_VAL), > + .args[1] = wkey_size, > + .args[3] = sw_secret_size, > + .owner = ARM_SMCCC_OWNER_SIP, > + }; > + > + int ret; > + > + void *wkey_buf __free(qcom_tzmem) = qcom_tzmem_alloc(__scm->mempool, > + wkey_size, > + GFP_KERNEL); > + if (!wkey_buf) > + return -ENOMEM; > + > + void *secret_buf __free(qcom_tzmem) = qcom_tzmem_alloc(__scm->mempool, > + sw_secret_size, > + GFP_KERNEL); > + if (!secret_buf) { > + ret = -ENOMEM; > + goto out_free_wrapped; > + } > + > + memcpy(wkey_buf, wkey, wkey_size); > + desc.args[0] = qcom_tzmem_to_phys(wkey_buf); > + desc.args[2] = qcom_tzmem_to_phys(secret_buf); > + > + ret = qcom_scm_call(__scm->dev, &desc, NULL); > + if (!ret) > + memcpy(sw_secret, secret_buf, sw_secret_size); > + > + memzero_explicit(secret_buf, sw_secret_size); > + > +out_free_wrapped: Is there a reason to zero out the buffer that's being zero-allocated? Konrad > + memzero_explicit(wkey_buf, wkey_size);