Support for wrapped inline encryption keys on Qualcomm SoCs
Subsystems (9)
Eric Biggers
maintainerv13 cover Support for wrapped inline encryption keys on Qualcomm SoCs
Add support for hardware-wrapped inline encryption keys to the Qualcomm ICE (Inline Crypto Engine) and UFS (Universal Flash Storage) drivers.
I'd like these patches to be taken through the scsi tree for 6.16. But the Qualcomm / msm tree would be okay too if that is preferred.
The block layer framework for this feature was merged in 6.15; refer to the "Hardware-wrapped keys" section of Documentation/block/inline-encryption.rst. This patchset wires it up for the newer Qualcomm SoCs, such as SM8650, which have a HWKM (Hardware Key Manager) and support the SCM calls needed to easily use it.
Tested on the SM8650 HDK with xfstests, specifically generic/368 and generic/369, in combination with the required fscrypt patch
https://lore.kernel.org/r/[email protected]
which I plan to apply separately.
Changed in v13:
- Rebased onto latest upstream
- Resent just the remaining driver patches
For changes in v12 and earlier, see
https://lore.kernel.org/r/[email protected]
Eric Biggers (2):
soc: qcom: ice: make qcom_ice_program_key() take struct blk_crypto_key
ufs: qcom: add support for wrapped keys
Gaurav Kashyap (1):
soc: qcom: ice: add HWKM support to the ICE driver
drivers/mmc/host/sdhci-msm.c | 16 +- drivers/soc/qcom/ice.c | 350 ++++++++++++++++++++++++++++++++--- drivers/ufs/host/ufs-qcom.c | 57 ++++-- include/soc/qcom/ice.h | 34 ++-- 4 files changed, 396 insertions(+), 61 deletions(-)
base-commit: a52a3c18cdf369a713aca7593332bbb998c71d96
Signature · 1 line
2.49.0
Eric Biggers
maintainerPATCH v13 1/3 soc: qcom: ice: make qcom_ice_program_key() take struct blk_crypto_key
From: Eric Biggers <[email protected]>
qcom_ice_program_key() currently accepts the key as an array of bytes, algorithm ID, key size enum, and data unit size. However both callers have a struct blk_crypto_key which contains all that information. Thus they both have similar code that converts the blk_crypto_key into the form that qcom_ice_program_key() wants. Once wrapped key support is added, the key type would need to be added to the arguments too.
Therefore, this patch changes qcom_ice_program_key() to take in all this information as a struct blk_crypto_key directly. The calling code is updated accordingly. This ends up being much simpler, and it makes the key type be passed down automatically once wrapped key support is added.
Based on a patch by Gaurav Kashyap <[email protected]> that replaced the byte array argument only. This patch makes the blk_crypto_key replace other arguments like the algorithm ID too, ensuring that there remains only one source of truth.
--- drivers/mmc/host/sdhci-msm.c | 11 +---------- drivers/soc/qcom/ice.c | 23 ++++++++++++----------- drivers/ufs/host/ufs-qcom.c | 11 +---------- include/soc/qcom/ice.h | 22 +++------------------- 4 files changed, 17 insertions(+), 50 deletions(-)
drivers/mmc/host/sdhci-msm.c +1 -10
@@ -1960,20 +1960,11 @@ static int sdhci_msm_ice_keyslot_program(struct blk_crypto_profile *profile, unsigned int slot) {struct sdhci_msm_host *msm_host =sdhci_msm_host_from_crypto_profile (profile); -/* Only AES-256-XTS has been tested so far. */ -if (key->crypto_cfg.crypto_mode !=BLK_ENCRYPTION_MODE_AES_256_XTS ) -return -EOPNOTSUPP ; - -return qcom_ice_program_key (msm_host->ice, -QCOM_ICE_CRYPTO_ALG_AES_XTS , -QCOM_ICE_CRYPTO_KEY_SIZE_256 , - key->bytes, - key->crypto_cfg.data_unit_size /512 , - slot); +return qcom_ice_program_key (msm_host->ice, slot, key); }static int sdhci_msm_ice_keyslot_evict (struct blk_crypto_profile *profile,const struct blk_crypto_key *key,unsigned int slot)
drivers/soc/qcom/ice.c +12 -11
@@ -160,41 +160,42 @@ int qcom_ice_suspend(struct qcom_ice *ice)return 0 ; }EXPORT_SYMBOL_GPL (qcom_ice_suspend); -int qcom_ice_program_key (struct qcom_ice *ice, -u8 algorithm_id,u8 key_size, -const u8 crypto_key[],u8 data_unit_size, -int slot) +int qcom_ice_program_key (struct qcom_ice *ice,unsigned int slot, +const struct blk_crypto_key *blk_key) {struct device *dev = ice->dev;union {u8 bytes[AES_256_XTS_KEY_SIZE ];u32 words[AES_256_XTS_KEY_SIZE /sizeof (u32)]; } key;int i;int err;/* Only AES-256-XTS has been tested so far. */ -if (algorithm_id !=QCOM_ICE_CRYPTO_ALG_AES_XTS || - key_size !=QCOM_ICE_CRYPTO_KEY_SIZE_256 ) { -dev_err_ratelimited (dev, -"Unhandled crypto capability; algorithm_id=%d, key_size=%d\n" , - algorithm_id, key_size); +if (blk_key->crypto_cfg.crypto_mode != +BLK_ENCRYPTION_MODE_AES_256_XTS ) { +dev_err_ratelimited (dev,"Unsupported crypto mode: %d\n" , + blk_key->crypto_cfg.crypto_mode);return -EINVAL ; } -memcpy (key.bytes, crypto_key,AES_256_XTS_KEY_SIZE ); +if (blk_key->size !=AES_256_XTS_KEY_SIZE ) { +dev_err_ratelimited (dev,"Incorrect key size\n" ); +return -EINVAL ; + } +memcpy (key.bytes, blk_key->bytes,AES_256_XTS_KEY_SIZE );/* The SCM call requires that the key words are encoded in big endian */ for (i =0 ; i <ARRAY_SIZE (key.words); i++)__cpu_to_be32s (&key.words[i]); err =qcom_scm_ice_set_key (slot, key.bytes,AES_256_XTS_KEY_SIZE ,QCOM_SCM_ICE_CIPHER_AES_256_XTS , - data_unit_size); + blk_key->crypto_cfg.data_unit_size /512 );memzero_explicit (&key,sizeof (key));return err; }
drivers/ufs/host/ufs-qcom.c +1 -10
@@ -215,21 +215,12 @@ static int ufs_qcom_ice_keyslot_program(struct blk_crypto_profile *profile, {struct ufs_hba *hba =ufs_hba_from_crypto_profile (profile);struct ufs_qcom_host *host =ufshcd_get_variant (hba);int err; -/* Only AES-256-XTS has been tested so far. */ -if (key->crypto_cfg.crypto_mode !=BLK_ENCRYPTION_MODE_AES_256_XTS ) -return -EOPNOTSUPP ; -ufshcd_hold (hba); - err =qcom_ice_program_key (host->ice, -QCOM_ICE_CRYPTO_ALG_AES_XTS , -QCOM_ICE_CRYPTO_KEY_SIZE_256 , - key->bytes, - key->crypto_cfg.data_unit_size /512 , - slot); + err =qcom_ice_program_key (host->ice, slot, key);ufshcd_release (hba);return err; } static int ufs_qcom_ice_keyslot_evict(struct blk_crypto_profile *profile,
include/soc/qcom/ice.h +3 -19
@@ -4,35 +4,19 @@*/ #ifndef __QCOM_ICE_H__#define __QCOM_ICE_H__ +#include <linux/blk-crypto.h> #include <linux/types.h> struct qcom_ice ; -enum qcom_ice_crypto_key_size { -QCOM_ICE_CRYPTO_KEY_SIZE_INVALID =0x0 , -QCOM_ICE_CRYPTO_KEY_SIZE_128 =0x1 , -QCOM_ICE_CRYPTO_KEY_SIZE_192 =0x2 , -QCOM_ICE_CRYPTO_KEY_SIZE_256 =0x3 , -QCOM_ICE_CRYPTO_KEY_SIZE_512 =0x4 , -}; - -enum qcom_ice_crypto_alg { -QCOM_ICE_CRYPTO_ALG_AES_XTS =0x0 , -QCOM_ICE_CRYPTO_ALG_BITLOCKER_AES_CBC =0x1 , -QCOM_ICE_CRYPTO_ALG_AES_ECB =0x2 , -QCOM_ICE_CRYPTO_ALG_ESSIV_AES_CBC =0x3 , -}; -int qcom_ice_enable (struct qcom_ice *ice);int qcom_ice_resume (struct qcom_ice *ice);int qcom_ice_suspend (struct qcom_ice *ice); -int qcom_ice_program_key (struct qcom_ice *ice, -u8 algorithm_id,u8 key_size, -const u8 crypto_key[],u8 data_unit_size, -int slot); +int qcom_ice_program_key (struct qcom_ice *ice,unsigned int slot, +const struct blk_crypto_key *blk_key);int qcom_ice_evict_key (struct qcom_ice *ice,int slot);struct qcom_ice *devm_of_qcom_ice_get (struct device *dev);#endif /* __QCOM_ICE_H__ */
Signature · 1 line
2.49.0
Eric Biggers
maintainerPATCH v13 2/3 soc: qcom: ice: add HWKM support to the ICE driver
In reply to Eric BiggersFrom: Gaurav Kashyap <[email protected]>
Qualcomm's Inline Crypto Engine (ICE) version 3.2 and later includes a key management hardware block called the Hardware Key Manager (HWKM). Add support for HWKM to the ICE driver. HWKM provides hardware-wrapped key support where the ICE (storage) keys are not exposed to software and instead are protected in hardware. Later patches will wire up this feature to ufs-qcom and sdhci-msm using the support added in this patch.
HWKM and legacy mode are currently mutually exclusive. The selection of which mode to use has to be made before the storage driver(s) registers any inline encryption capable disk(s) with the block layer (i.e., generally at boot time) so that the appropriate crypto capabilities can be advertised to upper layers. Therefore, make the ICE driver select HWKM mode when the all of the following are true:
- The new module parameter qcom_ice.use_wrapped_keys=1 is specified.
- HWKM is present and is at least v2, i.e. ICE is v3.2.1 or later.
- The SCM calls needed to fully use HWKM are supported by TrustZone.
[EB: merged related patches; fixed the module parameter to work
correctly; dropped unnecessary support for HWKM v1; fixed error handling; improved log messages, comments, and commit message; fixed naming; merged enable and init functions; and other cleanups]
--- drivers/mmc/host/sdhci-msm.c | 5 + drivers/soc/qcom/ice.c | 327 +++++++++++++++++++++++++++++++++-- drivers/ufs/host/ufs-qcom.c | 5 + include/soc/qcom/ice.h | 12 ++ 4 files changed, 339 insertions(+), 10 deletions(-)
drivers/mmc/host/sdhci-msm.c +5 -0
@@ -1880,10 +1880,15 @@ static int sdhci_msm_ice_init(struct sdhci_msm_host *msm_host, }if (IS_ERR_OR_NULL (ice))return PTR_ERR_OR_ZERO (ice); +if (qcom_ice_get_supported_key_type (ice) !=BLK_CRYPTO_KEY_TYPE_RAW ) { +dev_warn (dev,"Wrapped keys not supported. Disabling inline encryption support.\n" ); +return 0 ; + } + msm_host->ice = ice;/* Initialize the blk_crypto_profile */ caps.reg_val =cpu_to_le32 (cqhci_readl (cq_host,CQHCI_CCAP ));
drivers/soc/qcom/ice.c +317 -10
431 lines not on this page · raw message
drivers/ufs/host/ufs-qcom.c +5 -0
@@ -154,10 +154,15 @@ static int ufs_qcom_ice_init(struct ufs_qcom_host *host) }if (IS_ERR_OR_NULL (ice))return PTR_ERR_OR_ZERO (ice); +if (qcom_ice_get_supported_key_type (ice) !=BLK_CRYPTO_KEY_TYPE_RAW ) { +dev_warn (dev,"Wrapped keys not supported. Disabling inline encryption support.\n" ); +return 0 ; + } + host->ice = ice;/* Initialize the blk_crypto_profile */ caps.reg_val =cpu_to_le32 (ufshcd_readl (hba,REG_UFS_CCAP ));
include/soc/qcom/ice.h +12 -0
@@ -15,8 +15,20 @@ int qcom_ice_enable(struct qcom_ice *ice);int qcom_ice_resume (struct qcom_ice *ice);int qcom_ice_suspend (struct qcom_ice *ice);int qcom_ice_program_key (struct qcom_ice *ice,unsigned int slot,const struct blk_crypto_key *blk_key);int qcom_ice_evict_key (struct qcom_ice *ice,int slot); +enum blk_crypto_key_type qcom_ice_get_supported_key_type (struct qcom_ice *ice); +int qcom_ice_derive_sw_secret (struct qcom_ice *ice, +const u8 *eph_key,size_t eph_key_size, +u8 sw_secret[BLK_CRYPTO_SW_SECRET_SIZE ]); +int qcom_ice_generate_key (struct qcom_ice *ice, +u8 lt_key[BLK_CRYPTO_MAX_HW_WRAPPED_KEY_SIZE ]); +int qcom_ice_prepare_key (struct qcom_ice *ice, +const u8 *lt_key,size_t lt_key_size, +u8 eph_key[BLK_CRYPTO_MAX_HW_WRAPPED_KEY_SIZE ]); +int qcom_ice_import_key (struct qcom_ice *ice, +const u8 *raw_key,size_t raw_key_size, +u8 lt_key[BLK_CRYPTO_MAX_HW_WRAPPED_KEY_SIZE ]);struct qcom_ice *devm_of_qcom_ice_get (struct device *dev);#endif /* __QCOM_ICE_H__ */
Signature · 1 line
2.49.0
Eric Biggers
maintainerPATCH v13 3/3 ufs: qcom: add support for wrapped keys
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Wire up the wrapped key support for ufs-qcom by implementing the needed methods in struct blk_crypto_ll_ops and setting the appropriate flag in blk_crypto_profile::key_types_supported.
For more information about this feature and how to use it, refer to the sections about hardware-wrapped keys in Documentation/block/inline-encryption.rst and Documentation/filesystems/fscrypt.rst.
Based on patches by Gaurav Kashyap <[email protected]>. Reworked to use the custom crypto profile support.
--- drivers/ufs/host/ufs-qcom.c | 51 ++++++++++++++++++++++++++++++++----- 1 file changed, 45 insertions(+), 6 deletions(-)
drivers/ufs/host/ufs-qcom.c +45 -6
@@ -154,15 +154,10 @@ static int ufs_qcom_ice_init(struct ufs_qcom_host *host) }if (IS_ERR_OR_NULL (ice))return PTR_ERR_OR_ZERO (ice); -if (qcom_ice_get_supported_key_type (ice) !=BLK_CRYPTO_KEY_TYPE_RAW ) { -dev_warn (dev,"Wrapped keys not supported. Disabling inline encryption support.\n" ); -return 0 ; - } - host->ice = ice;/* Initialize the blk_crypto_profile */ caps.reg_val =cpu_to_le32 (ufshcd_readl (hba,REG_UFS_CCAP ));
@@ -172,11 +167,11 @@ static int ufs_qcom_ice_init(struct ufs_qcom_host *host)if (err)return err; profile->ll_ops = ufs_qcom_crypto_ops; profile->max_dun_bytes_supported =8 ; - profile->key_types_supported =BLK_CRYPTO_KEY_TYPE_RAW ; + profile->key_types_supported =qcom_ice_get_supported_key_type (ice); profile->dev = dev;/* * Currently this driver only supports AES-256-XTS. All known versions * of ICE support it, but to be safe make sure it is really declared in
@@ -240,13 +235,57 @@ static int ufs_qcom_ice_keyslot_evict(struct blk_crypto_profile *profile, err =qcom_ice_evict_key (host->ice, slot);ufshcd_release (hba);return err; } +static int ufs_qcom_ice_derive_sw_secret (struct blk_crypto_profile *profile, +const u8 *eph_key,size_t eph_key_size, +u8 sw_secret[BLK_CRYPTO_SW_SECRET_SIZE ]) +{ +struct ufs_hba *hba =ufs_hba_from_crypto_profile (profile); +struct ufs_qcom_host *host =ufshcd_get_variant (hba); + +return qcom_ice_derive_sw_secret (host->ice, eph_key, eph_key_size, + sw_secret); +} + +static int ufs_qcom_ice_import_key (struct blk_crypto_profile *profile, +const u8 *raw_key,size_t raw_key_size, +u8 lt_key[BLK_CRYPTO_MAX_HW_WRAPPED_KEY_SIZE ]) +{ +struct ufs_hba *hba =ufs_hba_from_crypto_profile (profile); +struct ufs_qcom_host *host =ufshcd_get_variant (hba); + +return qcom_ice_import_key (host->ice, raw_key, raw_key_size, lt_key); +} + +static int ufs_qcom_ice_generate_key (struct blk_crypto_profile *profile, +u8 lt_key[BLK_CRYPTO_MAX_HW_WRAPPED_KEY_SIZE ]) +{ +struct ufs_hba *hba =ufs_hba_from_crypto_profile (profile); +struct ufs_qcom_host *host =ufshcd_get_variant (hba); + +return qcom_ice_generate_key (host->ice, lt_key); +} + +static int ufs_qcom_ice_prepare_key (struct blk_crypto_profile *profile, +const u8 *lt_key,size_t lt_key_size, +u8 eph_key[BLK_CRYPTO_MAX_HW_WRAPPED_KEY_SIZE ]) +{ +struct ufs_hba *hba =ufs_hba_from_crypto_profile (profile); +struct ufs_qcom_host *host =ufshcd_get_variant (hba); + +return qcom_ice_prepare_key (host->ice, lt_key, lt_key_size, eph_key); +} +static const struct blk_crypto_ll_ops ufs_qcom_crypto_ops = { .keyslot_program = ufs_qcom_ice_keyslot_program, .keyslot_evict = ufs_qcom_ice_keyslot_evict, + .derive_sw_secret = ufs_qcom_ice_derive_sw_secret, + .import_key = ufs_qcom_ice_import_key, + .generate_key = ufs_qcom_ice_generate_key, + .prepare_key = ufs_qcom_ice_prepare_key, };#else static inline void ufs_qcom_ice_enable (struct ufs_qcom_host *host)
Signature · 1 line
2.49.0
Re: [PATCH v13 1/3] soc: qcom: ice: make qcom_ice_program_key() take struct blk_crypto_key
In reply to Eric BiggersQuoted 19 lines · Eric Biggers
From: Eric Biggers <[email protected]>
qcom_ice_program_key()currently accepts the key as an array of bytes, algorithm ID, key size enum, and data unit size. However both callers have a structblk_crypto_keywhich contains all that information. Thus they both have similar code that converts theblk_crypto_keyinto the form thatqcom_ice_program_key()wants. Once wrapped key support is added, the key type would need to be added to the arguments too.Therefore, this patch changes
qcom_ice_program_key()to take in all this information as a structblk_crypto_keydirectly. The calling code is updated accordingly. This ends up being much simpler, and it makes the key type be passed down automatically once wrapped key support is added.Based on a patch by Gaurav Kashyap <[email protected]> that replaced the byte array argument only. This patch makes the
blk_crypto_keyreplace other arguments like the algorithm ID too, ensuring that there remains only one source of truth.
Quoted 4 lines
Signed-off-by Eric Biggers <[email protected]>---
Konrad
Quoted 29 lines · Eric Biggers
Add support for hardware-wrapped inline encryption keys to the Qualcomm ICE (Inline Crypto Engine) and UFS (Universal Flash Storage) drivers.
I'd like these patches to be taken through the scsi tree for 6.16. But the Qualcomm / msm tree would be okay too if that is preferred.
The block layer framework for this feature was merged in 6.15; refer to the "Hardware-wrapped keys" section of
Documentation/block/inline-encryption.rst. This patchset wires it up for the newer Qualcomm SoCs, such as SM8650, which have a HWKM (Hardware Key Manager) and support the SCM calls needed to easily use it.Tested on the SM8650 HDK with xfstests, specifically generic/368 and generic/369, in combination with the required fscrypt patch
https://lore.kernel.org/r/[email protected]
which I plan to apply separately.Changed in v13:
- Rebased onto latest upstream
- Resent just the remaining driver patchesFor changes in v12 and earlier, see
https://lore.kernel.org/r/[email protected]Eric Biggers (2):
soc: qcom: ice: makeqcom_ice_program_key()take structblk_crypto_key
ufs: qcom: add support for wrapped keys
Quoted 9 lines
Gaurav Kashyap (1):
soc: qcom: ice: add HWKM support to the ICE driverdrivers/mmc/host/sdhci-msm.c | 16 +- drivers/soc/qcom/ice.c | 350 ++++++++++++++++++++++++++++++++--- drivers/ufs/host/ufs-qcom.c | 57 ++++-- include/soc/qcom/ice.h | 34 ++-- 4 files changed, 396 insertions(+), 61 deletions(-)
For the series and MMC parts:
Kind regards
Uffe
Martin K. Petersen
AppliedEric,
Quoted 5 lines
Add support for hardware-wrapped inline encryption keys to the Qualcomm ICE (Inline Crypto Engine) and UFS (Universal Flash Storage) drivers.
I'd like these patches to be taken through the scsi tree for 6.16.
Applied to 6.16/scsi-staging, thanks!
Signature · 1 line
Martin K. Petersen