classe ara::crypto::cryp::KeyDecapsulatorPrivateCtx

L'interface ara::crypto::cryp::KeyDecapsulatorPrivateCtx sert à la décapsulation asymétrique de données de clé (Key Encapsulation Mechanism, KEM) pour la génération de clés cibles symétriques [SWS_CRYPT_21412]. Avant la décapsulation, le contexte doit obligatoirement être initialisé via SetKey avec une clé privée ou un emplacement de stockage de clé adapté [SWS_CRYPT_21413]. Ensuite, la méthode Decapsulate transforme les données encapsulées en une nouvelle instance de clé symétrique de manière thread-safe et sûre vis-à-vis des exceptions [SWS_CRYPT_21412]. Tous les appels d'interface garantissent une sémantique stricte de rollback en cas d'erreur.

plus ›

Contexte

La classe ara::crypto::cryp::KeyDecapsulatorPrivateCtx constitue l'interface standardisée pour les mécanismes de décapsulation de clé asymétrique (Key Encapsulation Mechanism, KEM) basés sur des clés privées. En tant que contexte cryptographique spécialisé, elle hérite de CryptoContext et sert à décapsuler des données de clé encapsulées préalablement transmises en utilisant une clé privée asymétrique, et à les transformer en un nouvel objet de clé symétrique (SymmetricKey) [SWS_CRYPT_21412].

Au moins trois composants participent à l'opération de décapsulation : l'application demandeuse, le contexte de décapsulation lui-même ainsi que les sources de clés sous la forme d'un PrivateKey [SWS_CRYPT_21413] ou d'un emplacement de stockage référencé via KeySlot [SWS_CRYPT_50083]. Après une décapsulation réussie, le contexte met à disposition l'objet de clé symétrique généré sous forme de pointeur intelligent [SWS_CRYPT_21412].

Diagramme de contexte : intégration du contexte de décapsulation entre la mise à disposition de la clé et la génération de la clé cible. Sources : [SWS_CRYPT_21412], [SWS_CRYPT_21413], [SWS_CRYPT_50083]

Cycle de vie

Le contexte est généralement référencé et partagé via l'alias de type KeyDecapsulatorPrivateCtx::Sptr en tant que std::shared_ptr [SWS_CRYPT_21401]. Comme l'interface définit des fonctions membres purement virtuelles, l'instanciation de l'objet concret s'effectue probablement via une fabrique cryptographique de niveau supérieur (interprétation). Question Q-870e12aabbad8472 (ouverte) La destruction et le nettoyage des ressources sont couplés au cycle de vie du pointeur intelligent.

Au début, le contexte se trouve dans un état non initialisé dans lequel aucune clé de décapsulation n'est encore assignée. Un appel direct de Decapsulate échoue dans cet état avec l'erreur UninitializedContext [SWS_CRYPT_21412]. Ce n'est que par l'appel réussi de l'une des deux méthodes surchargées SetKey que le contexte passe à l'état opérationnel [SWS_CRYPT_21413], [SWS_CRYPT_50083]. Si un KeySlot est assigné, la clé privée qu'il contient n'est sollicitée de manière dynamique qu'au moment de la décapsulation effective ; les modifications apportées au contenu du slot ont donc probablement un impact immédiat sur les futurs appels de décapsulation (interprétation). Question Q-0b0dfc1fd3ebbc6f (ouverte)

En ce qui concerne la concurrence et la tolérance aux pannes, toutes les méthodes sont spécifiées comme thread-safe (thread-safe) et sûres vis-à-vis des exceptions (exception safe) [SWS_CRYPT_21412], [SWS_CRYPT_21413], [SWS_CRYPT_50083]. La méthode de transformation Decapsulate étant déclarée comme const, plusieurs threads peuvent déclencher des décapsulations en parallèle sur le même contexte configuré [SWS_CRYPT_21412].

Parcours d'utilisation

Le déroulement régulier de la décapsulation d'une clé de session se divise en deux phases successives :

1. Configuration de la clé de décapsulation : l'application configure le contexte via SetKey, soit en transmettant un PrivateKey::Sptr [SWS_CRYPT_21413], soit en enregistrant un KeySlot::Sptr [SWS_CRYPT_50083]. Le résultat est un ara::core::Result<void>, dont l'état doit être vérifié avant l'étape suivante.
2. Exécution de la décapsulation : l'application appelle Decapsulate et transmet les données de tampon de la clé encapsulée (ReadOnlyMemRegion encapsulatedKey), l'identifiant d'algorithme de la clé cible (AlgId algId) ainsi que ses modes d'utilisation autorisés (AllowedUsageFlags allowedUsage) [SWS_CRYPT_21412].
3. Traitement du résultat : en cas de transformation réussie, la fonction renvoie un ara::core::Result<SymmetricKey::Sptr> grâce auquel la nouvelle clé symétrique est immédiatement utilisable pour les opérations cryptographiques ultérieures [SWS_CRYPT_21412].

Diagramme de séquence : déroulement typique de la configuration de clé et de la décapsulation d'une clé cible. Sources : [SWS_CRYPT_21412], [SWS_CRYPT_21413], [SWS_CRYPT_50083]

Scénarios d'erreur

Toutes les opérations renvoient les états d'erreur via ara::core::Result et garantissent une sémantique stricte de rollback (rollback_semantics), ce qui permet au contexte de rester dans un état valide en cas d'échecs [SWS_CRYPT_21412], [SWS_CRYPT_21413], [SWS_CRYPT_50083].

Dans le cadre de la configuration de clé via SetKey, les erreurs suivantes peuvent survenir :

• CryptoErrc::kIncompatibleObject : L'objet PrivateKey transmis ou le KeySlot est incompatible avec le contexte [SWS_CRYPT_21413], [SWS_CRYPT_50083].
• CryptoErrc::kUsageViolation : Les indicateurs d'autorisation de la clé privée ne contiennent pas le droit de décapsulation (kAllowKeyUnwrapping) [SWS_CRYPT_21413].
• CryptoErrc::kUnsupported : L'implémentation du contexte ne prend en charge que l'autre variante de configuration respective (par ex. liaison exclusive via KeySlot ou exclusivement via PrivateKey) [SWS_CRYPT_21413], [SWS_CRYPT_50083].

Lors de l'appel de Decapsulate, les causes d'erreur suivantes sont spécifiées :

• UninitializedContext : Aucune clé n'a été préalablement attribuée au contexte [SWS_CRYPT_21412].
• CryptoErrc::kInvalidArgument : Le format de données du tampon transmis encapsulatedKey n'est pas valide [SWS_CRYPT_21412].
• CryptoErrc::kUnknownIdentifier : L'identifiant algId transmis n'est pas pris en charge [SWS_CRYPT_21412].
• CryptoErrc::kIncompatibleArguments : Soit les autorisations cibles allowedUsage ne correspondent pas à algId ou au type de clé, soit algId est incompatible avec les données KEM dans encapsulatedKey [SWS_CRYPT_21412].
• CryptoErrc::kUsageViolation : Les règles d'utilisation de la clé configurée n'autorisent pas la décapsulation (kAllowKeyUnwrapping manquant) [SWS_CRYPT_21412].
• CryptoErrc::kEmptyKeySlot : Un KeySlot préalablement lié via SetKey ne contient aucune clé au moment de l'exécution [SWS_CRYPT_21412].
• CryptoErrc::kBusyResource : Une ressource système requise pour le calcul cryptographique est temporairement occupée [SWS_CRYPT_21412].