Comment chiffrer les octets à l'aide du TPM (Trusted Platform Module)

Question

Comment chiffrer des octets à l'aide du module TPM d'une machine?

CryptProtectData

Windows fournit une API (relativement) simple pour chiffrer un blob à l'aide de l'API CryptProtectData, que nous pouvons encapsuler une fonction facile à utiliser:

public Byte[] ProtectBytes(Byte[] plaintext)
{
   //...
}

Les détails de ProtectBytes sont moins importants que l'idée que vous pouvez l'utiliser assez facilement:

• voici les octets que je veux chiffrés par une clé secrète contenue dans le System
• rends-moi le blob crypté

Le retour blob est un non documenté ^{documentation} structure contenant tout le nécessaire pour décrypter et renvoyer les données d'origine (algorithme de hachage, algorithme de chiffrement, sel, signature HMAC, etc.).

Pour être complet, voici l'exemple d'implémentation de pseudocode de ProtectBytes qui utilise le Crypt API pour protéger les octets:

public Byte[] ProtectBytes(Byte[] plaintext)
{
   //Setup our n-byte plaintext blob
   DATA_BLOB dataIn;
   dataIn.cbData = plaintext.Length;
   dataIn.pbData = Addr(plaintext[0]);

   DATA_BLOB dataOut;

   //dataOut = EncryptedFormOf(dataIn)
   BOOL bRes = CryptProtectData(
         dataIn,
         null,     //data description (optional PWideChar)
         null,     //optional entropy (PDATA_BLOB)
         null,     //reserved
         null,     //Prompt struct
         CRYPTPROTECT_UI_FORBIDDEN || CRYPTPROTECT_LOCAL_MACHINE,
         ref dataOut);
   if (!bRes) then
   {
      DWORD le = GetLastError();
      throw new Win32Error(le, "Error calling CryptProtectData");
   }

   //Copy ciphertext from dataOut blob into an actual array
   bytes[] result;
   SetLength(result, dataOut.cbData);
   CopyMemory(dataOut.pbData, Addr(result[0]), dataOut.cbData);

   //When you have finished using the DATA_BLOB structure, free its pbData member by calling the LocalFree function
   LocalFree(HANDLE(dataOut.pbData)); //LocalFree takes a handle, not a pointer. But that's what the SDK says.
}

Comment faire de même avec le TPM?

Le code ci-dessus est utile pour crypter les données de la machine locale uniquement. Les données sont cryptées en utilisant le compte System comme générateur de clé ( les détails, bien qu'intéressants, n'ont pas d'importance ). Le résultat final est que je peux chiffrer des données (par exemple, une clé principale de chiffrement de disque dur) qui ne peuvent être déchiffrées que par la machine locale.

Il est maintenant temps d'aller plus loin. Je souhaite chiffrer certaines données (par exemple, une clé principale de chiffrement du disque dur) qui ne peuvent être déchiffrées que par le module de plateforme sécurisée local. En d'autres termes, je veux remplacer l'environnement d'exécution de confiance de Qualcomm ( TEE ) dans le diagramme ci-dessous pour Android, par le TPM dans Windows:

Remarque : Je me rends compte que le TPM ne fait pas de signature de données (ou si c'est le cas, il ne garantit pas que la signature des mêmes données donnera la même sortie binaire à chaque fois). C'est pourquoi je serais prêt à remplacer "Signature RSA" par "cryptage d'un blob 256 bits avec une clé liée au matériel".

Alors où est le code?

Le problème est que la programmation TPM est complètement non documentée sur MSDN . Aucune API n'est disponible pour effectuer des opérations. Au lieu de cela, vous devez vous trouver une copie de Trusted Computing Group Software Stack (aka TSS) , déterminer quelles commandes envoyer au TPM, avec les charges utiles, dans quel ordre, et appeler Fenêtre fonction Tbsip_Submit_Command pour soumettre directement les commandes:

TBS_RESULT Tbsip_Submit_Command(
  _In_     TBS_HCONTEXT hContext,
  _In_     TBS_COMMAND_LOCALITY Locality,
  _In_     TBS_COMMAND_PRIORITY Priority,
  _In_     const PCBYTE *pabCommand,
  _In_     UINT32 cbCommand,
  _Out_    PBYTE *pabResult,
  _Inout_  UINT32 *pcbOutput
);

Windows n'a pas d'API de niveau supérieur pour effectuer des actions.

C'est l'équivalent moral d'essayer de créer un fichier texte en émettant des commandes d'E/S SATA sur votre disque dur.

Pourquoi ne pas simplement utiliser des pantalons

Le Trusted Computing Group (TCG) a défini sa propre API: Pile logicielle TCB (TSS) . Une implémentation de cette API a été créée par certaines personnes et s'appelle TrouSerS . Un gars alors a porté ce projet sur Windows .

Le problème avec ce code est qu'il n'est pas portable dans le monde Windows. Par exemple, vous ne pouvez pas l'utiliser depuis Delphi, vous ne pouvez pas l'utiliser depuis C #. Cela demande:

• OpenSSL
• pThread

Je veux juste que le code crypte quelque chose avec mon TPM.

Le CryptProtectData ci-dessus ne nécessite rien d'autre que ce qu'il y a dans le corps de la fonction.

Quel est le code équivalent pour crypter les données à l'aide du TPM? Comme d'autres l'ont remarqué, vous devez probablement consulter les trois manuels du TPM et construire vous-même les blobs . Cela implique probablement le TPM_seal commande. Bien que je pense que je ne veux pas sceller les données, je pense que je veux lier il:

Liaison - crypte les données à l'aide de la clé de liaison TPM, une clé RSA unique issue d'une clé de stockage. Scellage - crypte les données d'une manière similaire à la liaison, mais spécifie en outre un état dans lequel le TPM doit être pour que les données soient décryptées (non scellées )

J'essaie de lire les trois volumes requis afin de trouver les 20 lignes de code dont j'ai besoin:

• Partie 1 - Principes de conception
• Partie 2 - Structures du TPM
• Partie 3 - Commandes

Mais j'ai non idée de ce que je lis. S'il y avait une sorte de tutoriel ou d'exemples, je pourrais avoir une photo. Mais je suis complètement perdu.

Nous demandons donc à Stackoverflow

De la même manière, j'ai pu fournir:

Byte[] ProtectBytes_Crypt(Byte[] plaintext)
{
   //...
   CryptProtectData(...); 
   //...
}

quelqu'un peut-il fournir l'équivalent correspondant:

Byte[] ProtectBytes_TPM(Byte[] plaintext)
{
   //...
   Tbsip_Submit_Command(...);
   Tbsip_Submit_Command(...);
   Tbsip_Submit_Command(...);
   //...snip...
   Tbsip_Submit_Command(...);
   //...
}

cela fait la même chose, sauf qu'une clé verrouillée dans System LSA, est verrouillée dans le TPM?

Début de la recherche

Je ne sais pas exactement ce que bind signifie. Mais en regardant TPM Main - Part 3 Commands - Specification Version 1.2, il est fait mention de bind :

10,3 TPM_UnBind

TPM_UnBind prend le blob de données résultant d'une commande Tspi_Data_Bind et le déchiffre pour l'exporter vers l'utilisateur. L'appelant doit autoriser l'utilisation de la clé qui déchiffrera le blob entrant. TPM_UnBind fonctionne bloc par bloc et n'a aucune notion de relation entre un bloc et un autre.

Ce qui prête à confusion est là est non Tspi_Data_Bind commande.

Effort de recherche

Il est horrible de constater que personne n'a jamais pris la peine de documenter le TPM ou son fonctionnement. C'est comme s'ils passaient tout leur temps à trouver ce cool chose pour jouer avec, mais ne voulaient pas faire face à l'étape douloureuse de le rendre utilisable = pour quelque chose.

À partir du livre gratuit (maintenant) Guide pratique de TPM 2.0: utilisation du module de plateforme sécurisée dans la nouvelle ère de la sécurité =:

Chapitre 3 - Tutoriel rapide sur TPM 2.0

Le module de plateforme sécurisée a accès à une clé privée auto-générée, il peut donc chiffrer les clés avec une clé publique, puis stocker le blob résultant sur le disque dur. De cette façon, le module de plateforme sécurisée peut conserver un nombre pratiquement illimité de clés à disposition mais ne pas gaspiller un stockage interne précieux. Les clés stockées sur le disque dur peuvent être effacées, mais elles peuvent également être sauvegardées, ce qui semblait aux concepteurs un compromis acceptable.

Comment chiffrer une clé avec la clé publique du TPM?

Chapitre 4 - Applications existantes qui utilisent des TPM

Applications qui devraient utiliser le module de plateforme sécurisée mais ne le font pas

Au cours des dernières années, le nombre d'applications Web a augmenté. Parmi eux, la sauvegarde et le stockage sur le Web. Un grand nombre d'entreprises proposent désormais de tels services, mais à notre connaissance, aucun des clients de ces services ne laisse l'utilisateur verrouiller la clé du service de sauvegarde sur un TPM. Si cela était fait, ce serait certainement bien si la clé TPM elle-même était sauvegardée en la dupliquant sur plusieurs machines. Cela semble être une opportunité pour les développeurs.

Comment un développeur verrouille-t-il une clé du TPM?

Chapitre 9 - Hiérarchies

CAS D'UTILISATION: STOCKAGE DES MOTS DE PASSE DE CONNEXION

Un fichier de mot de passe typique stocke des hachages salés de mots de passe. La vérification consiste à saler et hacher un mot de passe fourni et à le comparer à la valeur stockée. Étant donné que le calcul n'inclut pas de secret, il fait l'objet d'une attaque hors ligne sur le fichier de mots de passe.

Ce cas d'utilisation utilise une clé HMAC générée par TPM. Le fichier de mots de passe stocke un HMAC du mot de passe salé. La vérification consiste à saler et à HMACer le mot de passe fourni et à le comparer à la valeur stockée. Étant donné qu'un attaquant hors ligne n'a pas la clé HMAC, l'attaquant ne peut pas monter d'attaque en effectuant le calcul.

Cela pourrait fonctionner. Si le TPM a une clé HMAC secrète et que seul mon TPM connaît la clé HMAC, je pourrais remplacer "Sign (aka TPM encrypt with its private key)" par "HMAC". Mais ensuite, dans la ligne suivante, il s'inverse complètement:

TPM2_Create, spécifiant une clé HMAC

Ce n'est pas un secret TPM si je dois spécifier la clé HMAC. Le fait que la clé HMAC ne soit pas secrète est logique lorsque vous réalisez que c'est le chapitre sur les utilitaires cryptographiques fourni par le TPM. Plutôt que d'avoir à écrire vous-même SHA2, AES, HMAC ou RSA, vous pouvez réutiliser ce que le module de plateforme sécurisée contient déjà.

Chapitre 10 - Clés

En tant que dispositif de sécurité, la capacité d'une application à utiliser des clés tout en les conservant en sécurité dans un périphérique matériel est la plus grande force du TPM. Le module de plateforme sécurisée peut à la fois générer et importer des clés générées en externe. Il prend en charge les clés asymétriques et symétriques.

Excellent! Comment faites-vous!?

Générateur de clé

On peut dire que la plus grande force du TPM est sa capacité à générer une clé cryptographique et à protéger son secret à l'intérieur d'une frontière matérielle. Le générateur de clés est basé sur le propre générateur de nombres aléatoires du TPM et ne repose pas sur des sources externes de caractère aléatoire. Il élimine ainsi les faiblesses basées sur des logiciels faibles avec une source d'entropie insuffisante.

Est-ce que le TPM a la capacité de générer des clés cryptographiques et de protéger ses secrets dans une limite matérielle? En est-il ainsi, comment?

Chapitre 12 - Registres de configuration de plate-forme

PCR pour autorisation

CAS D'UTILISATION: SCELLER UNE CLÉ DE CRYPTAGE DE DISQUE DUR POUR ÉTAT DE LA PLATEFORME

Les applications de chiffrement de disque complet sont beaucoup plus sécurisées si un module de plateforme sécurisée protège la clé de chiffrement que si elle est stockée sur le même disque, protégé uniquement par un mot de passe. Tout d'abord, le matériel TPM dispose d'une protection anti-martelage (voir le chapitre 8 pour une description détaillée de la protection contre les attaques par dictionnaire TPM), ce qui rend impossible une attaque par force brute sur le mot de passe. Une clé protégée uniquement par un logiciel est beaucoup plus vulnérable à un mot de passe faible. Deuxièmement, une clé logicielle stockée sur le disque est beaucoup plus facile à voler. Prenez le disque (ou une sauvegarde du disque) et vous obtenez la clé. Lorsqu'un TPM détient la clé, la plate-forme entière, ou au moins le disque et la carte mère, doivent être volés.

Le scellement permet à la clé d'être protégée non seulement par un mot de passe mais par une politique. Une politique typique verrouille la clé des valeurs de PCR (l'état du logiciel) en cours au moment de la fermeture. Cela suppose que l'état au premier démarrage n'est pas compromis. Tout malware préinstallé présent au premier démarrage serait mesuré dans les PCR, et donc la clé serait scellée à un état logiciel compromis. Une entreprise moins fiable peut avoir une image disque standard et sceller les PCR représentant cette image. Ces valeurs de PCR seraient précalculées sur une plate-forme vraisemblablement plus fiable. Une entreprise encore plus sophistiquée utiliserait TPM2_PolicyAuthorize et fournirait plusieurs tickets autorisant un ensemble de valeurs PCR approuvées. Voir le chapitre 14 pour une description détaillée de l'autorisation de politique et de son application pour résoudre le problème de PCRbrittleness.

Bien qu'un mot de passe puisse également protéger la clé, il existe un gain de sécurité même sans mot de passe de clé TPM. Un attaquant pourrait démarrer la plateforme sans fournir de mot de passe TPMkey mais ne pourrait pas se connecter sans le nom d'utilisateur et le mot de passe du système d'exploitation. La sécurité OS protège les données. L'attaquant pourrait démarrer un autre système d'exploitation, par exemple à partir d'un DVD en direct ou d'une clé USB plutôt que depuis le disque dur, pour contourner la sécurité de connexion au système d'exploitation. Cependant, cette configuration de démarrage et ce logiciel différents changeraient les valeurs de PCR. Parce que ces nouveaux PCR ne correspondraient pas aux valeurs scellées, le TPM ne libérerait pas la clé de déchiffrement et le disque dur ne pourrait pas être déchiffré.

Excellent! C'est exactement le cas d'utilisation que je souhaite. C'est également le cas d'utilisation pour lequel Microsoft utilise le TPM. Comment fait-on ça!?

J'ai donc lu l'intégralité de ce livre et il n'a rien apporté d'utile. Ce qui est assez impressionnant car c'est 375 pages. Vous vous demandez ce que contenait le livre - et en y repensant, je n'en ai aucune idée.

Nous abandonnons donc le guide définitif de programmation du TPM et nous nous tournons plutôt vers une documentation de Microsoft:

À partir de Microsoft TPM Platform Crypto-Provider Toolkit . Il mentionne exactement ce que je veux faire:

La clé d'approbation ou EK

L'EK est conçu pour fournir un identifiant cryptographique fiable pour la plate-forme. Une entreprise peut gérer une base de données des clés de validation appartenant aux TPM de tous les PC de son entreprise, ou un contrôleur de matrice de centre de données peut avoir une base de données des TPM dans toutes les lames. Sous Windows, vous pouvez utiliser le fournisseur NCrypt décrit dans la section "Platform Crypto Provider dans Windows 8" pour lire la partie publique de l'EK.

Quelque part à l'intérieur du TPM se trouve une clé privée RSA. Cette clé est enfermée là-dedans - pour ne jamais être vue par le monde extérieur. Je veux que le TPM signe quelque chose avec sa clé privée (c'est-à-dire le crypter avec sa clé privée).

Je veux donc le plus basique opération qui puisse exister:

Chiffrez quelque chose avec votre clé privée. Je ne demande même pas (encore) des trucs plus compliqués:

• "scellage" il basé sur l'état de la PCR
• créer une clé et la stocker dans une mémoire volatile ou non volatile
• créer une clé symétrique et essayer de la charger dans le TPM

Je demande l'opération la plus élémentaire qu'un TPM puisse faire. Pourquoi est-il impossible d'obtenir des informations sur la façon de procéder?

Je peux obtenir des données aléatoires

Je suppose que j'étais un peu complaisant quand j'ai dit que la signature RSA était la chose la plus fondamentale que le TPM puisse faire. La chose la plus la plus élémentaire que le TPM peut être invité à faire est de me donner des octets aléatoires. Que J'ai trouvé comment faire:

public Byte[] GetRandomBytesTPM(int desiredBytes)
{
   //The maximum random number size is limited to 4,096 bytes per call
   Byte[] result = new Byte[desiredBytes];

   BCRYPT_ALG_HANDLE hAlgorithm;

   BCryptOpenAlgorithmProvider(
         out hAlgorithm,
         BCRYPT_RNG_ALGORITHM, //AlgorithmID: "RNG"
         MS_PLATFORM_CRYPTO_PROVIDER, //Implementation: "Microsoft Platform Crypto Provider" i.e. the TPM
         0 //Flags
   );
   try
   {                
      BCryptGenRandom(hAlgorithm, @result[0], desiredBytes, 0);
   }
   finally
   {
      BCryptCloseAlgorithmProvider(hAlgorithm);
   }

   return result;
}

The Fancy Thing

Je me rends compte que le volume de personnes utilisant le TPM est très faible. C'est pourquoi personne sur Stackoverflow n'a de réponse. Je ne peux donc pas vraiment être trop gourmand pour trouver une solution à mon problème commun. Mais la chose que je voudrais vraiment vouloir faire est de "sceller" quelques données:

• présenter au TPM quelques données (par exemple 32 octets de matériel clé)
• avoir le TPM crypter les données, renvoyant une structure blob opaque
• demander plus tard au TPM de déchiffrer le blob
• le déchiffrement ne fonctionnera que si les registres PCR du TPM sont les mêmes que lors du chiffrement.

En d'autres termes:

Byte[] ProtectBytes_TPM(Byte[] plaintext, Boolean sealToPcr)
{
   //...
}

Byte[] UnprotectBytes_TPM(Byte[] protectedBlob)
{
   //...
}

Cryptography Next Gen (Cng, alias BCrypt) prend en charge TPM

L'API de cryptographie d'origine dans Windows était connue sous le nom d'API Crypto.

Depuis Windows Vista, l'API Crypto a été remplacée par API Cryptography: Next Generation (connu en interne sous le nom BestCrypt, abrégé BCrypt, à ne pas confondre avec l'algorithme de hachage de mot de passe ).

Windows est livré avec deux BCrypt fournisseurs:

• Fournisseur primitif Microsoft (MS_PRIMITIVE_PROVIDER) par défaut : implémentation logicielle par défaut de toutes les primitives (hachage, chiffrement symétrique, signatures numériques, etc.)
• Fournisseur de cryptographie Microsoft Platform (MS_PLATFORM_CRYPTO_PROVIDER): Fournisseur qui fournit un accès TPM

Le fournisseur Platform Crypto n'est pas documenté sur MSDN, mais dispose de la documentation d'un site Microsoft Research 2012:

Boîte à outils Crypto-Provider de la plateforme TPM

Le fournisseur et la boîte à outils de la plateforme TPM Crypto contiennent des exemples de code, des utilitaires et de la documentation pour l'utilisation des fonctionnalités liées au TPM dans Windows 8. Les sous-systèmes décrits incluent le fournisseur de cryptage de la plateforme Crypto-Next-Gen (CNG) soutenu par TPM, et comment les fournisseurs de services d'attestation peut utiliser les nouvelles fonctionnalités de Windows. Les systèmes basés sur TPM1.2 et TPM2.0 sont pris en charge.

Il semble que l'intention de Microsoft soit de faire apparaître la fonctionnalité de cryptographie TPM avec le fournisseur de cryptographie de la plateforme Microsoft du Cryptography NG API.

Cryptage à clé publique à l'aide de Microsoft BCrypt

Étant donné que:

• je veux effectuer un chiffrement asymétrique RSA (en utilisant le TPM)
• Microsoft BestCrypt prend en charge le chiffrement asymétrique RSA
• Microsoft BestCrypt dispose d'un fournisseur TPM

un moyen d'aller de l'avant pourrait être de comprendre comment effectuer la signature numérique à l'aide de l'API Microsoft Cryptography Next Gen .

Ma prochaine étape sera de trouver le code pour effectuer le chiffrement dans BCrypt, avec une clé publique RSA, en utilisant le fournisseur standard (MS_PRIMITIVE_PROVIDER). Par exemple.:

• modulus: 0xDC 67 FA F4 9E F2 72 1D 45 2C B4 80 79 06 A0 94 27 50 8209 DD 67 CE 57 B8 6C 4A 4F 40 9F D2 D1 69 FB 995D 85 0C 07 A1 F9 47 1B 56 16 6E F6 7F B9 CF 2A 58 36 37 99 29 AA 4F A8 12 E8 4F C7 82 2B 9D 72 2A 9C DE 6F C2 EE 12 6D CF F0 F2 B8 C4 DD 7C 5C 1A C8 17 51 A9 AC DF 08 22 04 9D 2B D7 F9 4B 09 DE 9A EB 5C 51 1A D8 F8 F9 56 9E F8 FB 37 9B 3F D3 74 65 24 0D FF 34 75 57 A4 F5 BF 55
• publicExponent: 65537

Avec ce code fonctionnant, je peux être en mesure de passer à l'aide du fournisseur TPM (MS_PLATFORM_CRYPTO_PROVIDER).

22/02/2016: Et avec Apple étant obligé d'aider à déchiffrer les données des utilisateurs, il y a un intérêt renouvelé pour faire en sorte que le TPM effectue la tâche la plus simple pour laquelle il a été inventé - chiffrer quelque chose.

C'est à peu près l'équivalent de tous ceux qui possèdent une voiture, mais personne ne sait comment en démarrer une. Il peut faire des choses vraiment utiles et cool, si seulement nous pouvions passer Étape 1 .

Lecture bonus

• Android - Cryptage - Stockage de la clé cryptée
• Explorations Android - Revisiter Android
• Secrets DPAPI. Analyse de sécurité et récupération de données dans DPAPI (Partie 1)

Answer 1

Apprêt

Tout ce qui suit concerne TPM 1.2. Gardez à l'esprit que Microsoft nécessite un TPM 2.0 pour toutes les futures versions de Windows. La génération 2.0 est fondamentalement différente de la génération 1.2

Il n'y a pas de solution sur une seule ligne en raison des principes de conception du TPM. Considérez le TPM comme un microcontrôleur aux ressources limitées. Son objectif principal de conception était d'être bon marché tout en étant sécurisé. Le TPM a donc été arraché de toute logique qui n'était pas nécessaire pour une opération sécurisée. Ainsi, un TPM ne fonctionne que si vous avez au moins un logiciel plus ou moins gros , émettant beaucoup de commandes dans le bon ordre. Et ces séquences de commandes peuvent devenir très complexes. C'est pourquoi TCG a spécifié le TSS avec une API bien définie. Si vous souhaitez suivre la méthode Java, il existe même un niveau élevé API Java . Je ne connais pas de projet similaire pour C #/.net

Développement

Dans votre cas, je vous suggère de regarder le logiciel TPM d'IBM.

• page du projet
• Télécharger le package complet

Dans le package, vous trouverez 3 composants très utiles:

• un émulateur TPM logiciel
• une bibliothèque tpm légère
• quelques utilitaires de ligne de commande de base

Vous n'avez pas nécessairement besoin de l'émulateur TPM logiciel, vous pouvez également vous connecter au TPM HW de la machine. Cependant, vous pouvez intercepter les commandes émises et consulter les réponses, apprenant ainsi comment elles sont assemblées et comment elles correspondent à la spécification de commande.

Haut niveau

Conditions préalables:

1. TPM est activé
2. Le pilote TPM est chargé
3. vous avez pris possession du TPM

Pour sceller un blob, vous devez procéder comme suit:

1. créer une clé
2. stocker le key-blob quelque part
3. assurez-vous que la clé est chargée dans le module de plateforme sécurisée
4. sceller le blob

Pour desceller, vous devez:

1. obtenir le key-blob
2. charger la clé dans le TPM
3. desceller la goutte scellée

Vous pouvez stocker le key-blob dans votre structure de données que vous utilisez pour stocker les octets protégés.

La plupart des commandes TPM dont vous avez besoin sont autorisées. Par conséquent, vous devez établir des sessions d'autorisation si nécessaire. AFAIR ce sont principalement des sessions du RAFEO.

Commandes TPM

Actuellement, je ne peux pas exécuter de version de débogage, je ne peux donc pas vous fournir la séquence exacte. Considérez donc ceci comme une liste non ordonnée de commandes que vous devrez utiliser:

• TPM_OSAP
• TPM_CreateWrapKey
• TPM_LoadKey2
• TPM_Seal

Si vous souhaitez également lire les valeurs de PCR actuelles:

• TPM_PCRRead

Answer 2

Clés approuvées et cryptées

Les clés de confiance et cryptées sont deux nouveaux types de clés ajoutés au service de porte-clés du noyau existant. Ces deux nouveaux types sont des clés symétriques de longueur variable, et dans les deux cas, toutes les clés sont créées dans le noyau, et l'espace utilisateur voit, stocke et charge uniquement les objets blob chiffrés. Les clés de confiance nécessitent la disponibilité d'une puce TPM (Trusted Platform Module) pour une plus grande sécurité, tandis que les clés cryptées peuvent être utilisées sur n'importe quel système. Tous les blobs de niveau utilisateur sont affichés et chargés en hexa ascii pour plus de commodité et leur intégrité est vérifiée.

Les clés de confiance utilisent un module de plateforme sécurisée à la fois pour générer et pour sceller les clés. Les clés sont scellées sous une clé RSA 2048 bits dans le TPM, et facultativement scellées aux valeurs de PCR (mesure d'intégrité) spécifiées, et uniquement descellées par le TPM, si les PCR et les vérifications d'intégrité des blobs correspondent. Une clé de confiance chargée peut être mise à jour avec de nouvelles (futures) valeurs de PCR, de sorte que les clés sont facilement migrées vers de nouvelles valeurs pcr, comme lorsque le noyau et les initramfs sont mis à jour. La même clé peut avoir de nombreux blobs enregistrés sous différentes valeurs de PCR, de sorte que plusieurs démarrages sont facilement pris en charge.

Par défaut, les clés de confiance sont scellées sous le SRK, qui a la valeur d'autorisation par défaut (20 zéros). Cela peut être réglé au moment de la prise en charge avec l'utilitaire du pantalon: tpm_takeownership -u -z.

Usage:
    keyctl add trusted name "new keylen [options]" ring
    keyctl add trusted name "load hex_blob [pcrlock=pcrnum]" ring
    keyctl update key "update [options]"
    keyctl print keyid

    options:
    keyhandle= ascii hex value of sealing key default 0x40000000 (SRK)
    keyauth=   ascii hex auth for sealing key default 0x00...i
        (40 ascii zeros)
    blobauth=  ascii hex auth for sealed data default 0x00...
        (40 ascii zeros)
    blobauth=  ascii hex auth for sealed data default 0x00...
        (40 ascii zeros)
    pcrinfo=   ascii hex of PCR_INFO or PCR_INFO_LONG (no default)
    pcrlock=   pcr number to be extended to "lock" blob
    migratable= 0|1 indicating permission to reseal to new PCR values,
                default 1 (resealing allowed)

keyctl print renvoie une copie hexadécimale ascii de la clé scellée, au format TPM_STORED_DATA standard. La longueur de clé pour les nouvelles clés est toujours en octets. Les clés de confiance peuvent être de 32 à 128 octets (256 à 1 024 bits), la limite supérieure est de tenir dans la longueur de clé SRK (RSA) à 2048 bits, avec toute la structure/remplissage nécessaire.

Les clés chiffrées ne dépendent pas d'un module de plateforme sécurisée et sont plus rapides, car elles utilisent AES pour le chiffrement/déchiffrement. Les nouvelles clés sont créées à partir de nombres aléatoires générés par le noyau et sont chiffrées/déchiffrées à l'aide d'une clé "maître" spécifiée. La clé "principale" peut être de type clé de confiance ou clé d'utilisateur. Le principal inconvénient des clés cryptées est que si elles ne sont pas enracinées dans une clé de confiance, elles ne sont aussi sécurisées que la clé utilisateur les cryptant. La clé d'utilisateur principale doit donc être chargée de la manière la plus sécurisée possible, de préférence au début du démarrage.

La partie déchiffrée des clés chiffrées peut contenir soit une simple clé symétrique, soit une structure plus complexe. Le format de la structure la plus complexe est spécifique à l'application, identifié par "format".

Usage:
    keyctl add encrypted name "new [format] key-type:master-key-name keylen"
        ring
    keyctl add encrypted name "load hex_blob" ring
    keyctl update keyid "update key-type:master-key-name"

format:= 'default | ecryptfs'
key-type:= 'trusted' | 'user'

Exemples d'utilisation de clés sécurisées et chiffrées

Créez et enregistrez une clé de confiance nommée "kmk" d'une longueur de 32 octets:

$ keyctl add trusted kmk "new 32" @u
440502848

$ keyctl show
Session Keyring
       -3 --alswrv    500   500  keyring: _ses
 97833714 --alswrv    500    -1   \_ keyring: _uid.500
440502848 --alswrv    500   500       \_ trusted: kmk

$ keyctl print 440502848
0101000000000000000001005d01b7e3f4a6be5709930f3b70a743cbb42e0cc95e18e915
3f60da455bbf1144ad12e4f92b452f966929f6105fd29ca28e4d4d5a031d068478bacb0b
27351119f822911b0a11ba3d3498ba6a32e50dac7f32894dd890eb9ad578e4e292c83722
a52e56a097e6a68b3f56f7a52ece0cdccba1eb62cad7d817f6dc58898b3ac15f36026fec
d568bd4a706cb60bb37be6d8f1240661199d640b66fb0fe3b079f97f450b9ef9c22c6d5d
dd379f0facd1cd020281dfa3c70ba21a3fa6fc2471dc6d13ecf8298b946f65345faa5ef0
f1f8fff03ad0acb083725535636addb08d73dedb9832da198081e5deae84bfaf0409c22b
e4a8aea2b607ec96931e6f4d4fe563ba

$ keyctl pipe 440502848 > kmk.blob

Chargez une clé de confiance à partir du blob enregistré:

$ keyctl add trusted kmk "load `cat kmk.blob`" @u
268728824

$ keyctl print 268728824
0101000000000000000001005d01b7e3f4a6be5709930f3b70a743cbb42e0cc95e18e915
3f60da455bbf1144ad12e4f92b452f966929f6105fd29ca28e4d4d5a031d068478bacb0b
27351119f822911b0a11ba3d3498ba6a32e50dac7f32894dd890eb9ad578e4e292c83722
a52e56a097e6a68b3f56f7a52ece0cdccba1eb62cad7d817f6dc58898b3ac15f36026fec
d568bd4a706cb60bb37be6d8f1240661199d640b66fb0fe3b079f97f450b9ef9c22c6d5d
dd379f0facd1cd020281dfa3c70ba21a3fa6fc2471dc6d13ecf8298b946f65345faa5ef0
f1f8fff03ad0acb083725535636addb08d73dedb9832da198081e5deae84bfaf0409c22b
e4a8aea2b607ec96931e6f4d4fe563ba

Rescellez une clé de confiance sous de nouvelles valeurs pcr:

$ keyctl update 268728824 "update pcrinfo=`cat pcr.blob`"
$ keyctl print 268728824
010100000000002c0002800093c35a09b70fff26e7a98ae786c641e678ec6ffb6b46d805
77c8a6377aed9d3219c6dfec4b23ffe3000001005d37d472ac8a44023fbb3d18583a4f73
d3a076c0858f6f1dcaa39ea0f119911ff03f5406df4f7f27f41da8d7194f45c9f4e00f2e
df449f266253aa3f52e55c53de147773e00f0f9aca86c64d94c95382265968c354c5eab4
9638c5ae99c89de1e0997242edfb0b501744e11ff9762dfd951cffd93227cc513384e7e6
e782c29435c7ec2edafaa2f4c1fe6e7a781b59549ff5296371b42133777dcc5b8b971610
94bc67ede19e43ddb9dc2baacad374a36feaf0314d700af0a65c164b7082401740e489c9
7ef6a24defe4846104209bf0c3eced7fa1a672ed5b125fc9d8cd88b476a658a4434644ef
df8ae9a178e9f83ba9f08d10fa47e4226b98b0702f06b3b8

Le consommateur initial de clés de confiance est EVM, qui a besoin au démarrage d'une clé symétrique de haute qualité pour la protection HMAC des métadonnées de fichier. L'utilisation d'une clé de confiance offre de solides garanties que la clé EVM n'a pas été compromise par un problème au niveau de l'utilisateur et, lorsqu'elle est scellée à des valeurs PCR d'amorçage spécifiques, protège contre les attaques de démarrage et hors ligne. Créez et enregistrez une clé chiffrée "evm" en utilisant la clé de confiance ci-dessus "kmk":

option 1: omettre "format"

$ keyctl add encrypted evm "new trusted:kmk 32" @u
159771175

option 2: définir explicitement "format" comme "par défaut"

$ keyctl add encrypted evm "new default trusted:kmk 32" @u
159771175

$ keyctl print 159771175
default trusted:kmk 32 2375725ad57798846a9bbd240de8906f006e66c03af53b1b3
82dbbc55be2a44616e4959430436dc4f2a7a9659aa60bb4652aeb2120f149ed197c564e0
24717c64 5972dcb82ab2dde83376d82b2e3c09ffc

$ keyctl pipe 159771175 > evm.blob

Chargez une clé chiffrée "evm" à partir du blob enregistré:

$ keyctl add encrypted evm "load `cat evm.blob`" @u
831684262

$ keyctl print 831684262
default trusted:kmk 32 2375725ad57798846a9bbd240de8906f006e66c03af53b1b3
82dbbc55be2a44616e4959430436dc4f2a7a9659aa60bb4652aeb2120f149ed197c564e0
24717c64 5972dcb82ab2dde83376d82b2e3c09ffc

D'autres utilisations des clés sécurisées et chiffrées, comme le chiffrement des disques et des fichiers, sont prévues. En particulier, le nouveau format "ecryptfs" a été défini afin d'utiliser des clés chiffrées pour monter un système de fichiers eCryptfs. Plus de détails sur l'utilisation peuvent être trouvés dans le fichier 'Documentation/security/keys-ecryptfs.txt'.

Answer 3

Quand ça dit

spécification de la clé HMAC

cela ne signifie PAS fournir la clé HMAC - cela signifie "pointez sur la clé HMAC que vous souhaitez utiliser".

Les TPM peuvent utiliser un nombre pratiquement illimité de clés HMAC, comme indiqué dans le livre. Vous devez indiquer au TPM lequel utiliser.