Permet le packaging et le dépackaging sécurisés de clés au moyen d'un chiffrement de clé symétrique.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 16126e8d9692ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Permet le packaging et le dépackaging sécurisés de clés au moyen d'un chiffrement de clé symétrique.
Le contexte SymmetricKeyWrapperCtx sert au packaging et dépackaging cryptographiques de clés au moyen d'algorithmes symétriques. Avant l'exécution de Wrap ou UnwrapSymmetricKey, le contexte doit être configuré via SetKey avec une clé de chiffrement de clé (KEK) compatible [SWS_CRYPT_24018]. Toutes les opérations présupposent les autorisations d'utilisation correspondantes des objets de clé impliqués et signalent les erreurs via ara::core::Result avec une sémantique de rollback [SWS_CRYPT_24014]. L'interface est sûre vis-à-vis des exceptions et est spécifiée comme thread-safe pour le fonctionnement concurrent.
Contexte
La classe SymmetricKeyWrapperCtx définit l'interface standardisée pour les algorithmes d'enveloppement de clé symétriques (Key Wrapping) au sein d'AUTOSAR Adaptive Platform. Sa responsabilité centrale réside dans la protection cryptographique de clés lors de l'export ainsi que lors de la restauration de clés packagées pour l'usage interne. Ici, la classe interagit principalement avec des clés de chiffrement de clé (Key Encryption Keys, KEK), qui sont fournies soit sous forme d'objet de clé volatile de type SymmetricKey, soit de manière persistante via un KeySlot[SWS_CRYPT_24018], [SWS_CRYPT_50034]. Lors du packaging, le contexte accepte un CryptoObject générique [SWS_CRYPT_24014], tandis que l'opération de dépackaging génère et renvoie un nouvel objet SymmetricKey prêt à l'emploi [SWS_CRYPT_24016].
Cycle de vie
Les instances de SymmetricKeyWrapperCtx sont gérées via le pointeur intelligent typé Sptr (un alias pour std::shared_ptr<SymmetricKeyWrapperCtx>) [SWS_CRYPT_24001]. La création effective d'objets devrait avoir lieu via une fabrique de fournisseurs compétente, car la classe représente une interface abstraite avec des méthodes purement virtuelles. Question Q-7b9a1007da43ddcd (ouverte) L'ensemble des fonctions membres de l'interface sont spécifiées comme sûres vis-à-vis des exceptions (exception safe) et thread-safe, ce qui permet une utilisation sécurisée dans des composants logiciels concurrents [SWS_CRYPT_24014], [SWS_CRYPT_24016].
Au cours de son cycle de vie, le contexte traverse deux phases essentielles : immédiatement après l'instanciation, il se trouve dans un état non initialisé. Durant cette phase, les opérations cryptographiques ainsi que les calculs de tampon échouent avec l'erreur kUninitializedContext[SWS_CRYPT_50035], [SWS_CRYPT_24014]. Ce n'est que par l'appel réussi de SetKey avec une KEK ou un KeySlot compatible que le contexte passe à l'état opérationnel, dans lequel des clés peuvent être packagées ou dépackagées en toute sécurité [SWS_CRYPT_24018], [SWS_CRYPT_50034].
Parcours d'utilisation
Le déroulement standard pour le packaging d'une clé exige une séquence coordonnée de configuration, de vérification de tampon et d'exécution. L'application configure d'abord le contexte via SetKey avec l'objet KEK souhaité [SWS_CRYPT_24018] ou lie un KeySlot correspondant [SWS_CRYPT_50034]. Dans un deuxième temps, l'application détermine via GetRequiredWrappedKeyBufferSize la taille maximale de tampon de sortie requise pour l'objet cible à packager [SWS_CRYPT_50035]. Après qu'une zone de mémoire dimensionnée en conséquence (ReadWriteMemRegion) a été fournie, l'appel de Wrap a lieu, lequel écrit les données de clé sérialisées et chiffrées dans le tampon et renvoie le nombre exact d'octets [SWS_CRYPT_24014].
Pour le processus complémentaire de dépackaging, l'application transmet à UnwrapSymmetricKey, après la configuration au moyen de SetKey, le tampon d'entrée contenant les données enveloppées [SWS_CRYPT_24016]. À cette occasion, l'identifiant d'algorithme cible (targetAlgId) ainsi que les drapeaux d'utilisation autorisés (allowedUsage) pour la nouvelle clé symétrique à générer doivent être explicitement définis [SWS_CRYPT_24016].
Scénarios d'erreur
Les méthodes de la classe signalent les erreurs via le type de retour ara::core::Result avec une sémantique de rollback. Parmi les scénarios d'erreur centraux figurent :
Initialisation manquante : si GetRequiredWrappedKeyBufferSize, Wrap ou UnwrapSymmetricKey sont appelés avant une affectation réussie de clé, ils renvoient ara::crypto::CryptoErrc::kUninitializedContext[SWS_CRYPT_50035], [SWS_CRYPT_24014], [SWS_CRYPT_24016].
Violation de droits d'utilisation : lors de la définition de la KEK, celle-ci doit posséder au moins l'autorisation kAllowKeyWrapping ou kAllowKeyUnwrapping, faute de quoi SetKey échoue avec ara::crypto::CryptoErrc::kUsageViolation[SWS_CRYPT_24018]. Pour Wrap, l'absence de kAllowKeyWrapping sur la KEK ou l'absence de kAllowSecuredExport sur l'objet à packager conduit également à kUsageViolation[SWS_CRYPT_24014]. Lors du dépackaging, il est vérifié si la KEK autorise kAllowKeyUnwrapping[SWS_CRYPT_24016].
Incompatibilités et erreurs de tampon : si le tampon cible pour Wrap est trop petit, ara::crypto::CryptoErrc::kInsufficientCapacity est signalé [SWS_CRYPT_24014]. Des formats de clé erronés ou des types incompatibles entraînent ara::crypto::CryptoErrc::kInvalidArgument[SWS_CRYPT_24014], [SWS_CRYPT_24016]. Si le contexte ne prend en charge que des emplacements ou uniquement des objets de clé, SetKey signale l'erreur kUnsupported[SWS_CRYPT_24018], [SWS_CRYPT_50034].
Conflits de ressources et emplacements vides : si l'opération accède à une ressource occupée, ara::crypto::CryptoErrc::kBusyResource est renvoyé ; si le KeySlot référencé est vide, cela résulte en ara::crypto::CryptoErrc::kEmptyKeySlot[SWS_CRYPT_24014], [SWS_CRYPT_24016].
Ce guide a été généré par une IA et s'appuie exclusivement sur la spécification AUTOSAR.
Configure the context to use the provided key as key encryption key.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : d0a83598653dProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation et sémantique
La fonction membre synchrone SetKey configure une instance de ara::crypto::cryp::SymmetricKeyWrapperCtx de manière à ce que l'objet transmis SymmetricKey::Sptr soit utilisé comme Key Encryption Key (KEK) pour les opérations de clé ultérieures [SWS_CRYPT_24018]. La fonction est spécifiée en tant que méthode virtuelle pure avec noexcept et renvoie un ara::core::Result<void> vide si l'assignation a réussi [SWS_CRYPT_24018].
Gestion des erreurs et rollback
Si une erreur survient lors de la configuration, une sémantique de rollback obligatoire s'applique, de sorte que l'état du contexte reste inchangé [SWS_CRYPT_24018]. Les causes d'erreur possibles sont représentées par des codes d'erreur issus de ara::crypto::CryptoErrc :
kIncompatibleObject : l'objet clé transmis est incompatible avec le contexte symétrique [SWS_CRYPT_24018].
kUsageViolation : l'utilisation autorisée de la clé n'inclut ni kAllowKeyWrapping ni kAllowKeyUnwrapping[SWS_CRYPT_24018].
kUnsupported : l'implémentation du contexte prend exclusivement en charge la définition d'une clé via un KeySlot[SWS_CRYPT_24018].
Concurrence et interaction
La méthode est spécifiée comme thread-safe et sûre vis-à-vis des exceptions (exception safe) [SWS_CRYPT_24018]. Si les clés sont gérées via des emplacements ou si le contexte prend exclusivement en charge les KeySlots, la surcharge alternative SetKey avec KeySlot::Sptr existe pour le même contexte de wrapper [SWS_CRYPT_50034]. Celle-ci configure le contexte pour charger la clé stockée dans l'emplacement au moment de l'exécution du key wrapping [SWS_CRYPT_50034].
Cette note d'utilisation est basée sur la spécification AUTOSAR Adaptive Platform Release R25-11.
Configure the context to use the key stored in the provided KeySlot at the time the key wrapping is performed.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 30d79040bb46Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode virtuelle SetKey configure le contexte ara::crypto::cryp::SymmetricKeyWrapperCtx afin que la clé stockée dans le KeySlot fourni soit utilisée dès que le key-wrapping est exécuté [SWS_CRYPT_50034]. L'appel attend comme paramètre keySlot un KeySlot::Sptr qui contient une clé symétrique [SWS_CRYPT_50034]. La fonction est appelée de manière synchrone, est déclarée avec noexcept et renvoie un ara::core::Result<void>[SWS_CRYPT_50034].
Gestion des erreurs
En cas d'erreur, la méthode garantit une sémantique de rollback et renvoie l'un des résultats d'erreur suivants [SWS_CRYPT_50034] :
ara::crypto::CryptoErrc::kIncompatibleObject : Le keySlot transmis est incompatible avec ce contexte [SWS_CRYPT_50034].
ara::crypto::CryptoErrc::kUnsupported : Le contexte prend exclusivement en charge la définition d'un SymmetricKey direct [SWS_CRYPT_50034].
concurrence
L'opération est thread-safe (thread-safe) et offre une sécurité garantie vis-à-vis des exceptions (exception safe) [SWS_CRYPT_50034].
Interaction
L'interface constitue au sein de SymmetricKeyWrapperCtx le pendant basé sur les slots de la surcharge SetKey avec SymmetricKey::Sptr, qui lie une clé directement en tant que clé de chiffrement de clé (KEK) [SWS_CRYPT_24018]. Des fonctions de configuration analogues basées sur les slots sont également utilisées dans des contextes cryptographiques apparentés tels que KeyDerivationFunctionCtx[SWS_CRYPT_50010], KeyEncapsulatorPublicCtx[SWS_CRYPT_50012], VerifierPublicCtx[SWS_CRYPT_50018], MessageAuthnCodeCtx[SWS_CRYPT_50026] et SignerPrivateCtx[SWS_CRYPT_50036].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification d'AUTOSAR Adaptive R25-11.
Unwrap a wrapped key using the previously set key encryption key and return an SymmetricKey.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : fe87df5f5eaeProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode UnwrapSymmetricKey de l'interface ara::crypto::cryp::SymmetricKeyWrapperCtx déchiffre une clé enveloppée en utilisant la clé de chiffrement de clé (KEK) préalablement définie et renvoie un nouvel objet SymmetricKey[SWS_CRYPT_24016]. En tant que paramètres, la fonction synchrone reçoit le tampon d'entrée contenant les données de clé protégées (wrappedKey), l'identifiant d'algorithme pour la clé cible (targetAlgId) ainsi que des indicateurs binaires pour ses types de transformations autorisés (allowedUsage) [SWS_CRYPT_24016].
La valeur de retour ara::core::Result<SymmetricKey::Sptr> contient, en cas d'exécution réussie, un pointeur intelligent vers la clé générée ou signale une erreur avec une sémantique de rollback [SWS_CRYPT_24016]. Les causes possibles d'erreur sont :
InvalidArgument : Les données de clé transmises dans wrappedKey ne peuvent pas être désenveloppées, par exemple en raison d'un format non valide ou d'une taille de tampon incorrecte [SWS_CRYPT_24016].
ara::crypto::CryptoErrc::kUninitializedContext : Le contexte de wrapper n'a pas encore été initialisé avec une KEK appropriée [SWS_CRYPT_24016].
ara::crypto::CryptoErrc::kUsageViolation : Les restrictions d'utilisation de la KEK interdisent le désenveloppement (absence de kAllowKeyUnwrapping) [SWS_CRYPT_24016].
ara::crypto::CryptoErrc::kUnknownIdentifier : La valeur transmise pour targetAlgId n'est pas connue ou n'est pas prise en charge [SWS_CRYPT_24016].
ara::crypto::CryptoErrc::kIncompatibleArguments : Les indicateurs allowedUsage spécifiés sont incompatibles avec targetAlgId ou avec le type de clé [SWS_CRYPT_24016].
ara::crypto::CryptoErrc::kBusyResource : Une ressource système requise pour l'opération est actuellement occupée [SWS_CRYPT_24016].
ara::crypto::CryptoErrc::kEmptyKeySlot : Un KeySlot configuré pour l'opération est vide [SWS_CRYPT_24016].
La méthode est déclarée comme const ainsi que noexcept, garantit la sécurité vis-à-vis des exceptions et est thread-safe pour les appels concurrents selon la spécification [SWS_CRYPT_24016].
Ce texte a été rédigé par une IA et sert de guide d'orientation. Seule la spécification fait foi.
Wrap the provided key using the previously set key encryption key.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 8e6ff8198c9dProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode Wrap de la classe ara::crypto::cryp::SymmetricKeyWrapperCtx (fichier d'en-tête ara/crypto/cryp/symmetric_key_wrapper_ctx.h) enveloppe une clé fournie en utilisant la clé de chiffrement de clé (Key Encryption Key) [SWS_CRYPT_24014] préalablement définie.
La fonction synchrone attend les paramètres suivants [SWS_CRYPT_24014] :
key (CryptoObject::Sptr) : La clé à envelopper.
wrappedKey (ReadWriteMemRegion) : Un tampon de sortie dans lequel la clé enveloppée est écrite.
Comme valeur de retour, l'opération fournit un ara::core::Result<std::size_t> qui, en cas de succès, contient le nombre d'octets de la clé enveloppée écrits dans le tampon [SWS_CRYPT_24014].
Traitement des erreurs et sémantique
La méthode est définie comme exception safe et implémente une sémantique stricte de rollback en cas d'erreur [SWS_CRYPT_24014]. Les états d'erreur suivants peuvent être signalés [SWS_CRYPT_24014] :
InvalidArgument : L'objet clé ne peut pas être enveloppé (par ex. en raison d'une taille non valide ou d'un type incorrect).
ara::crypto::CryptoErrc::kUninitializedContext : Le contexte n'a pas encore été initialisé avec une valeur de clé.
ara::crypto::CryptoErrc::kUsageViolation : L'utilisation autorisée de la KEK n'inclut pas kAllowKeyWrapping ou celle de l'objet n'inclut pas kAllowSecuredExport.
ara::crypto::CryptoErrc::kInsufficientCapacity : Le tampon de sortie wrappedKey est trop petit.
ara::crypto::CryptoErrc::kBusyResource : Une ressource requise est occupée.
ara::crypto::CryptoErrc::kEmptyKeySlot : Un KeySlot configuré est actuellement vide.
Concurrence et restrictions
L'interface est spécifiée comme thread-safe[SWS_CRYPT_24014]. La condition préalable à l'exécution est un contexte préalablement initialisé ainsi que des attributs d'utilisation appropriés pour les clés concernées [SWS_CRYPT_24014].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification d'AUTOSAR Adaptive R25-11.
rollback_semantics if the allowed usage of the KEK does not include kAllowKey Wrapping or the allowed usage of the object does not include k AllowSecuredExport
gemini-3.8-flash-low· 2026-10-13 · Original allemand