Clés encapsulées dans le matériel

Comme la plupart des logiciels de chiffrement de disque et de fichier, le chiffrement de stockage d'Android repose traditionnellement sur la présence des clés de chiffrement brutes dans la mémoire système pour que le chiffrement puisse être effectué. Même lorsque le chiffrement est effectué par du matériel dédié plutôt que par un logiciel, le logiciel doit généralement toujours gérer les clés de chiffrement brutes.

En général, cela n'est pas considéré comme un problème, car les clés ne sont pas présentes. lors d'une attaque hors ligne, qui est le principal type d'attaque contre laquelle le chiffrement est destiné à protéger. Cependant, nous souhaitons fournir une protection accrue contre d'autres types d'attaques, tels que le démarrage à froid ; les attaques et les attaques en ligne qui pourraient permettre à un pirate informatique de fuir un système mémoire sans compromettre complètement l’appareil.

Pour résoudre ce problème, Android 11 a introduit la prise en charge des clés encapsulées matériellement, lorsque la prise en charge matérielle est disponible. Les clés encapsulées matériellement sont des clés de stockage qui ne sont connues que sous forme brute par le matériel dédié. Le logiciel ne voit et n'utilise ces clés que sous forme encapsulée (chiffrée). Ce matériel doit être capable de générer et d'importer les clés de stockage, les encapsuler dans des formes éphémères et à long terme, en programmant directement une sous-clé dans un moteur de chiffrement intégré renvoyant une sous-clé distincte au logiciel.

Remarque:Un moteur de chiffrement intégré (ou intégré matériel de chiffrement) fait référence au matériel qui chiffre/déchiffre les données elle est en chemin vers/depuis le périphérique de stockage. Il s'agit généralement d'un hôte UFS ou eMMC qui implémente les extensions cryptographiques définies par le gestionnaire Spécification JEDEC.

Conception

Cette section présente la conception de touches encapsulées, y compris la compatibilité matérielle requise pour cela. Cette discussion porte sur le chiffrement basé sur les fichiers (FBE), mais la solution s'applique également au chiffrement des métadonnées.

Une façon d'éviter d'avoir besoin des clés de chiffrement brutes dans la mémoire système consisterait à ne les conserve que dans les fentes d’un moteur de chiffrement intégré. Toutefois, rencontre quelques problèmes:

• Le nombre de clés de chiffrement peut dépasser le nombre d'emplacements de clés.
• Les moteurs de chiffrement intégrés ne peuvent être utilisés que pour chiffrer/déchiffrer des blocs entiers les données sur le disque. Toutefois, dans le cas de FBE, le logiciel doit toujours être capable effectuer d'autres tâches cryptographiques telles que le chiffrement des noms de fichiers et la dérivation de la clé identifiants. Le logiciel aurait toujours besoin d’accéder aux clés FBE brutes pour pouvoir pour effectuer cette autre tâche.

Pour éviter ces problèmes, les clés de stockage sont transformées en clés encapsulées matériellement, qui ne peuvent être désencapsulées et utilisées que par du matériel dédié. Cela permet de prendre en charge un nombre illimité de clés. De plus, la hiérarchie des clés est modifiée et partiellement déplacée vers ce matériel, ce qui permet de renvoyer une sous-clé au logiciel pour les tâches qui ne peuvent pas utiliser un moteur de cryptographie intégré.

Remarque : Il est techniquement possible d'implémenter des "clés encapsulées matériellement" dans le logiciel à l'aide d'un environnement d'exécution sécurisé (TEE) exécuté sur le même processeur, au lieu d'utiliser du matériel dédié. Toutefois, cette opération n'est pas recommandée pour le moment, car il n'est pas certain qu'elle offre suffisamment d'avantages en termes de sécurité pour justifier cette fonctionnalité. En particulier, cela ne protège pas contre les attaques par démarrage à froid.

Une implémentation dans le micrologiciel peut être acceptable, à condition que le matériel sur lequel le micrologiciel s'exécute soit suffisamment distinct du processeur principal.

Hiérarchie des clés

Les clés peuvent être dérivées d'autres clés à l'aide d'une fonction KDF (fonction de dérivation de clé) comme HKDF. ce qui génère une hiérarchie de clés.

Le schéma suivant illustre une hiérarchie de clés typique pour le FBE lorsque les clés encapsulées matériellement ne sont pas utilisées :

Image 1. Hiérarchie des clés FBE (standard)

La clé de classe FBE est la clé de chiffrement brute qu'Android transmet au noyau Linux pour déverrouiller un ensemble particulier de répertoires chiffrés, tels que le stockage chiffré par identifiants pour un utilisateur Android particulier. (Dans le noyau, cette clé est appelée clé maître fscrypt.) À partir de cette clé, le noyau dérive les sous-clés suivantes :

• Identifiant de clé. Il ne s'agit pas d'un chiffrement, mais d'une valeur utilisée pour identifier la clé avec laquelle un fichier ou un répertoire particulier est protégé.
• Clé de chiffrement du contenu du fichier
• Clé de chiffrement des noms de fichiers

Remarque:La procédure ci-dessus suppose l'utilisation de l'un des protocoles de chiffrement Paramètres optimisés pour une utilisation avec un moteur de chiffrement intégré (inlinecrypt_optimized ou emmc_optimized). Si l'une des valeurs suivantes ces paramètres ne sont pas utilisés, alors il y a beaucoup de contenus de fichiers et des noms de fichiers clés de chiffrement dérivées de la clé de classe FBE (une par fichier ou ), plutôt qu'un seul de chaque type.

En revanche, le schéma suivant illustre la hiérarchie des clés pour FBE quand sont utilisées:

Figure 2 : Hiérarchie des clés FBE (avec clé encapsulée matérielle)

Par rapport au cas précédent, un niveau supplémentaire a été ajouté à la hiérarchie des clés, et la clé de chiffrement du contenu du fichier a été déplacée. La racine représente toujours la clé qu'Android transmet à Linux pour déverrouiller un ensemble des répertoires chiffrés. Cependant, maintenant que cette clé est encapsulée de manière éphémère, pour être utilisé, il doit être transmis à du matériel dédié. Ce matériel doit implémenter deux interfaces utilisant une clé encapsulée de manière éphémère:

• Une interface pour dériver inline_encryption_key et directement le programmer dans un emplacement clé du moteur de chiffrement intégré. Cela permet de chiffrer/déchiffrer le contenu des fichiers sans que le logiciel n'ait accès à la clé brute. Dans les noyaux courants Android, cette interface correspond au l'opération blk_crypto_ll_ops::keyslot_program, qui doit être implémentée par le pilote de stockage.
• Une interface pour dériver et renvoyer sw_secret ("secret logiciel", également appelé "secret brut" dans certains cas), qui est la clé utilisée par Linux pour dériver les sous-clés pour tout ce qui n'est pas le chiffrement du contenu des fichiers. Dans les noyaux communs Android, cette interface correspond à l'opération blk_crypto_ll_ops::derive_sw_secret, qui doit être implémentée par le pilote de stockage.

Pour obtenir inline_encryption_key et sw_secret à partir de de stockage brute, le matériel doit utiliser un KDF sécurisé de manière cryptographique. Ce KDF respecter les bonnes pratiques en matière de cryptographie ; son niveau de sécurité doit être de d'au moins 256 bits, ce qui est suffisant pour tout algorithme utilisé ultérieurement. Il doit également utiliser un libellé, un contexte et une chaîne d'informations spécifiques à l'application distincts lors de la dérivation de chaque type de sous-clé afin de garantir que les sous-clés résultantes sont isolées de manière cryptographique, c'est-à-dire que la connaissance de l'une d'entre elles ne révèle aucune autre. Aucun étirement de clé n'est requis, car la clé de stockage brute est déjà de manière uniformément aléatoire.

Techniquement, n'importe quel fichier KDF répondant aux exigences de sécurité peut être utilisé. Toutefois, à des fins de test, il est nécessaire de réimplémenter le même KDF dans le code de test. Actuellement, un KDF a été examiné et mis en œuvre. il peut être trouvé dans le code source de vts_kernel_encryption_test. Il est recommandé que le matériel utilise ce KDF, qui utilise le NIST SP 800-108 "KDF en mode compteur" avec AES-256-CMAC comme PRF. Notez que pour être compatibles, toutes les parties de l'algorithme doivent être identiques, y compris le choix des contextes KDF et des libellés pour chaque sous-clé.

Encapsulation de clé

Pour atteindre les objectifs de sécurité des clés encapsulées dans le matériel, deux types d'encapsulation de clés sont définies:

• Encapsulation éphémère: le matériel chiffre la clé brute à l'aide d'une clé. généré de manière aléatoire à chaque démarrage et non directement exposé en dehors du matériel.
• Encapsulation à long terme: le matériel chiffre la clé brute à l'aide d'un clé unique et persistante intégrée au matériel, qui n'est pas directement exposées à l'extérieur du matériel.

Toutes les clés transmises au noyau Linux pour déverrouiller le stockage sont encapsulés de manière éphémère. Ainsi, si un pirate informatique est en mesure d'extraire clé en cours d'utilisation depuis la mémoire système, elle est non seulement inutilisable sur l'appareil, mais aussi après un redémarrage.

En même temps, Android doit toujours pouvoir stocker une version chiffrée des clés sur le disque afin qu'elles puissent être déverrouillées. Les données brutes de clés de sécurité fonctionnent à cet effet. Cependant, il est préférable de ne jamais avoir sont présentes dans la mémoire système, afin qu'elles ne puissent jamais être extraites être utilisés hors de l'appareil, même s'ils sont extraits au démarrage. C'est pourquoi le concept d'encapsulation à long terme est défini.

Remarque : Toutes les clés de chiffrement de stockage qu'Android stocke sur disque sont protégées par une couche distincte de chiffrement de clé qui associe la possibilité de déverrouiller la clé à l'état de démarrage validé de l'appareil, ainsi qu'au facteur de connaissance de l'écran de verrouillage de l'utilisateur (par exemple, le code PIN), le cas échéant. Cette couche de chiffrement de clé est indépendante du chiffrement de clé à long terme décrit ci-dessus. Par conséquent, lorsque des clés encapsulées dans le matériel sont utilisées, les clés qu'Android stocke sur le disque est encapsulé deux fois: une fois avec la clé à long terme du matériel et l'encapsulation de clé standard d'Android.

Pour prendre en charge la gestion des clés encapsulées de ces deux manières différentes, le matériel doit implémenter les interfaces suivantes:

• Interfaces permettant de générer et d'importer des clés de stockage, en les renvoyant encapsulée à long terme. Ces interfaces sont accessibles indirectement via KeyMint et ils correspondent à la balise KeyMint TAG_STORAGE_KEY. La fonctionnalité "générer" est utilisée par vold pour générer de nouvelles clés de stockage à utiliser par Android, tandis que la fonctionnalité "importer" est utilisée par vts_kernel_encryption_test pour importer des clés de test.
• Une interface permettant de convertir une clé de stockage encapsulée à long terme en clé de stockage encapsulée de manière éphémère. Cela correspond à la méthode KeyMint convertStorageKeyToEphemeral. Cette méthode est utilisée par vold et vts_kernel_encryption_test dans l'ordre pour déverrouiller l'espace de stockage.

L'algorithme d'encapsulation de clé est un détail d'implémentation, mais il doit utiliser un AEAD fort comme AES-256-GCM avec des vecteurs d'initialisation aléatoires.

Modifications logicielles requises

AOSP dispose déjà d'un framework de base pour la prise en charge des clés encapsulées dans le matériel. Ce est compatible avec les composants d'espace utilisateur tels que vold, ainsi que comme la compatibilité du noyau Linux avec blk-crypto, fscrypt et dm-default-key.

Toutefois, certaines modifications spécifiques à l'implémentation sont nécessaires.

Modifications apportées à KeyMint

L'implémentation KeyMint de l'appareil doit être modifiée afin de prendre en charge TAG_STORAGE_KEY et implémenter la convertStorageKeyToEphemeral.

Dans Keymaster, exportKey a été utilisé au lieu de convertStorageKeyToEphemeral

Modifications du noyau Linux

Le pilote du noyau Linux pour le moteur de cryptographie intégré de l'appareil doit être modifié pour prendre en charge les clés encapsulées matériellement.

Pour les noyaux android14 et supérieurs, définir BLK_CRYPTO_KEY_TYPE_HW_WRAPPED à blk_crypto_profile::key_types_supported, faire blk_crypto_ll_ops::keyslot_program et blk_crypto_ll_ops::keyslot_evict prendre en charge la programmation et l'éviction de clés encapsulées dans du matériel ; et implémenter blk_crypto_ll_ops::derive_sw_secret.

Pour les noyaux android12 et android13, définissez BLK_CRYPTO_FEATURE_WRAPPED_KEYS dans blk_keyslot_manager::features, faites en sorte que blk_ksm_ll_ops::keyslot_program et blk_ksm_ll_ops::keyslot_evict prennent en charge la programmation/l'éviction des clés encapsulées matériellement, et implémentez blk_ksm_ll_ops::derive_raw_secret.

Pour les noyaux android11, définissez BLK_CRYPTO_FEATURE_WRAPPED_KEYS dans keyslot_manager::features, faites en sorte que keyslot_mgmt_ll_ops::keyslot_program et keyslot_mgmt_ll_ops::keyslot_evict prennent en charge la programmation/l'éviction des clés encapsulées matériellement, et implémentez keyslot_mgmt_ll_ops::derive_raw_secret.

Tests

Bien que le chiffrement avec des clés encapsulées matériellement soit plus difficile à tester que le chiffrement avec des clés standards, il est toujours possible de le tester en important une clé de test et en réimplémentant la dérivation de clé effectuée par le matériel. Cette fonctionnalité est implémentée dans vts_kernel_encryption_test. Pour exécuter ce test, exécutez la commande suivante :

atest -v vts_kernel_encryption_test

Lisez le journal de test et vérifiez que les scénarios de test clés encapsulés dans le matériel (par exemple, FBEPolicyTest.TestAesInlineCryptOptimizedHwWrappedKeyPolicy et DmDefaultKeyTest.TestHwWrappedKey) n'ont pas été ignorées en raison de la compatibilité des clés encapsulées dans le matériel qui ne sont pas détectées, car les résultats des tests "réussi" dans ce cas.

Remarque : Pour que ces cas de test soient acceptés, la dérivation de clé effectuée par le matériel doit correspondre exactement à celle attendue par le test. De plus, l'utilisation d'AES-256-XTS par le moteur de cryptographie intégré doit être correcte. Autrement dit, chaque bloc de données chiffrées sur le disque doit être chiffré à l'aide de la clé et de l'IV (vecteur d'initialisation) attendus, y compris en utilisant l'endianité correcte pour la clé et l'IV, ainsi que la valeur d'incrément de l'IV correcte d'un bloc à l'autre.

Si le matériel utilise un autre fichier KDF (non recommandé), le fait de modifier le pour être compatible avec les Wi-Fi KDF requis.

Activer les touches

Une fois que la prise en charge des clés encapsulées matérielle de l'appareil fonctionne correctement, vous pouvez apportez les modifications suivantes au fichier fstab de l'appareil pour Android l'utilise pour les FBE et le chiffrement des métadonnées:

• FBE : ajoutez l'indicateur wrappedkey_v0 au paramètre fileencryption. Par exemple, utilisez fileencryption=::inlinecrypt_optimized+wrappedkey_v0. Pour pour en savoir plus, consultez les documentation.
• Chiffrement des métadonnées : ajoutez l'indicateur wrappedkey_v0 au paramètre metadata_encryption. Par exemple, utilisez metadata_encryption=:wrappedkey_v0 Pour en savoir plus, consultez la documentation sur le chiffrement des métadonnées.

Remarque:Les clés encapsulées matériellement ne peuvent être utilisées que sur des appareils et non sur un espace de stockage adoptable.