Sert à dépaqueter et importer de manière sécurisée des clés et des données cryptographiques protégées au sein d'une application.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : a42cd9e6f52bProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Sert à dépaqueter et importer de manière sécurisée des clés et des données cryptographiques protégées au sein d'une application.
L'interface permet le dépaquetage et l'importation sécurisés de données et de clés cryptographiques protégées à l'aide d'une clé de transport configurée [SWS_CRYPT_50205]. Le matériel de clé dépaqueté peut soit être écrit directement dans un emplacement de clé persistant, soit être chargé en mémoire sous forme typée en tant qu'objet de clé [SWS_CRYPT_50207]. Toutes les méthodes fonctionnent de manière thread-safe et suivent une sémantique d'erreur stricte avec annulation (rollback), tandis que Reset garantit l'effacement sans résidu des tampons internes [SWS_CRYPT_50212].
Contexte
L'interface ara::crypto::cryp::ProtectedKeyImportCtx fournit un contexte cryptographique permettant d'importer et de dépaqueter de manière sécurisée des structures de données protégées, telles que du matériel de clé secret, dans le système. Le contexte agit comme intermédiaire entre une application demandeuse, un mécanisme de protection basé sur une clé de transport et les structures cibles de la cryptographie AUTOSAR. Les paquets de données sérialisés entrants sont authentifiés, déchiffrés et analysés par le contexte [SWS_CRYPT_50207]. Comme sources pour la clé de transport requise, on utilise soit des objets de clé symétrique autonomes [SWS_CRYPT_50205], soit des emplacements de clé d'un magasin de clés [SWS_CRYPT_50206]. En tant que puits, les objets de clé dépaquetés peuvent être directement transmis à l'application appelante ou être immédiatement sérialisés dans un emplacement de clé accessible en écriture [SWS_CRYPT_50207].
Cycle de vie
Pour un accès partagé, le contexte est généralement géré via le type de pointeur intelligent fourni Sptr[SWS_CRYPT_50085] ; les instances devraient alors être fournies par un composant pilote crypto compétent. Avant le traitement effectif, le contexte se trouve dans un état initial non configuré dans lequel aucune clé de transport n'est encore assignée. L'assignation d'une clé de transport s'effectue via la méthode SetKey, ce qui fait passer le contexte à l'état opérationnel [SWS_CRYPT_50205][SWS_CRYPT_50206]. Question Q-3517b24b5eec4529 (ouverte)
Après l'exécution réussie de l'opération Import, le contexte conserve les données dépaquetées et les métadonnées dans des tampons internes, de sorte que le type d'objet puisse être identifié et que les objets de clé puissent être lus [SWS_CRYPT_50207][SWS_CRYPT_50208]. La méthode Reset permet de rétablir le contexte dans son état initial : tous les tampons internes contenant des données précédemment importées sont entièrement purgés et la clé de transport enregistrée est supprimée [SWS_CRYPT_50212]. Toutes les méthodes d'interface sont spécifiées comme étant sûres vis-à-vis des exceptions et thread-safe, ce qui permet de maîtriser les accès concurrents provenant de plusieurs contextes d'exécution [SWS_CRYPT_50207].
Le déroulement régulier commence par la configuration de la clé de transport. Pour cela, l'application appelle SetKey soit avec un SymmetricKey::Sptr[SWS_CRYPT_50205], soit avec un KeySlot::Sptr[SWS_CRYPT_50206]. À l'étape suivante, la méthode Import est exécutée, à laquelle le paquet de données sérialisé est transmis sous forme de ReadOnlyMemRegion[SWS_CRYPT_50207]. Si la clé doit être stockée de façon persistante, il est possible de transmettre directement en option un WriteableKeySlot::Sptr dans lequel le matériel dépaqueté est écrit [SWS_CRYPT_50207].
Si aucun slot cible n'a été spécifié ou si la clé doit être utilisée de manière volatile, l'application détermine la catégorie du dernier objet importé via GetCryptoObjectType[SWS_CRYPT_50208]. En fonction de ce type, l'application appelle la méthode de récupération appropriée : GetPrivateKey pour les clés privées [SWS_CRYPT_50209], GetPublicKey pour les clés publiques [SWS_CRYPT_50211] ou GetSymmetricKey pour le matériel de clé symétrique [SWS_CRYPT_50210]. Si le protocole d'importation utilisé requiert un retour à l'expéditeur – comme par exemple avec les blocs de contrôle M4 et M5 d'une séquence SHE-LoadKey –, celui-ci peut être écrit dans un tampon fourni via GetResponse[SWS_CRYPT_41020]. Après l'achèvement de la séquence de traitement, un appel à Reset replace le contexte dans son état initial [SWS_CRYPT_50212].
Si une erreur survient pendant un appel de méthode, une sémantique stricte de rollback s'applique, préservant l'état antérieur à l'appel. Lors de la configuration via SetKey, l'appel échoue avec CryptoErrc::kUsageViolation si l'indicateur d'utilisation de la clé ne contient pas l'autorisation kAllowKeyUnwrapping[SWS_CRYPT_50205][SWS_CRYPT_50206]. Si l'objet clé ou le slot référencé n'est fondamentalement pas utilisable comme clé de transport, CryptoErrc::kIncompatibleObject est signalé [SWS_CRYPT_50205][SWS_CRYPT_50206].
Lors de l'appel de Import, des écarts de taille des données d'entrée entraînent CryptoErrc::kInvalidInputSize et des violations de format entraînent CryptoErrc::kInvalidArgument[SWS_CRYPT_50207]. Si le contrôle d'intégrité ou d'authenticité de la couche de protection échoue (par exemple en raison d'un message authentication code non valide ou d'une signature erronée), l'appel renvoie CryptoErrc::kAuthTagNotValid[SWS_CRYPT_50207]. Si le composant cryptographique est temporairement occupé, cela est signalé via CryptoErrc::kBusyResource[SWS_CRYPT_50207].
La condition préalable à la lecture de clés importées est l'exécution réussie de Import ; sinon, GetPrivateKey, GetPublicKey et GetSymmetricKey répondent par CryptoErrc::kProcessingNotFinished[SWS_CRYPT_50209][SWS_CRYPT_50210][SWS_CRYPT_50211]. Si le type de clé demandé ne correspond pas à l'objet effectivement déballé ou si aucun objet n'a encore été importé, les méthodes de récupération l'acquittent avec CryptoErrc::kNoSuchValue[SWS_CRYPT_50208][SWS_CRYPT_50209][SWS_CRYPT_50210][SWS_CRYPT_50211]. Si le tampon de sortie n'offre pas une capacité suffisante lors de GetResponse, cela se traduit par CryptoErrc::kInsufficientCapacity[SWS_CRYPT_41020]. Si l'implémentation concrète ne prend pas en charge une sous-fonction (par exemple certains types de clés ou la réinitialisation), CryptoErrc::kUnsupported est renvoyé de manière uniforme [SWS_CRYPT_50205][SWS_CRYPT_50208][SWS_CRYPT_50212].
Ce guide de classe est basé sur la spécification AUTOSAR Adaptive Platform Release R25-11.
The interface shall write the response of the CryptoProvider to the last invocation of Import into the provided output buffer. E.g., this interface could return M4/M5 of a SHE LoadKey operation.
virtual ara::core::Result< std::size_t > GetResponse (ReadWriteMem Region responseBuffer) const noexcept=0; DIRECTION NOT responseBuffer -- DEFINED
The interface shall unwrap the protected data provided, parse the content, and make the parsed content (key-material and meta-data) available for retrieval by the application. If optionally a Key Slot is specified, the unwrapped key material shall be directly serialized into the KeySlot.
The interface shall restore the context to its initial state by ensuring that no key-import-key is set and all previously imported data is deleted from the ProtectedKeyImportCtx’s internal buffers.
The interface shall return a shared pointer to the unwrapped PrivateKey.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 569ddfa8ee2aProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode GetPrivateKey de la classe ara::crypto::cryp::ProtectedKeyImportCtx (fournie via l'en-tête #include "ara/crypto/cryp/protected_key_import_ctx.h") sert à récupérer un shared pointer vers une clé privée (PrivateKey::Sptr) préalablement importée et dépaquetée ([SWS_CRYPT_50209]). L'interface ne comporte aucun paramètre d'entrée et renvoie le résultat de manière synchrone sous forme de ara::core::Result<PrivateKey::Sptr> ([SWS_CRYPT_50209]).
Des règles contraignantes s'appliquent à l'exécution concernant l'ordre, la concurrence et la sécurité vis-à-vis des exceptions : la méthode est spécifiée comme thread-safe ainsi que exception safe et déclarée avec noexcept ([SWS_CRYPT_50209]). Une condition préalable obligatoire pour une récupération réussie est qu'une opération d'importation ait préalablement été exécutée avec succès au sein du contexte ([SWS_CRYPT_50209]).
Si une erreur survient lors de la mise à disposition, une sémantique de rollback s'applique à toutes les situations d'erreur ([SWS_CRYPT_50209]). Le Result renvoyé contient dans ce cas l'un des codes d'erreur spécifiques suivants :
ara::crypto::CryptoErrc::kProcessingNotFinished : l'étape d'importation précédente n'a pas encore été exécutée avec succès ([SWS_CRYPT_50209]).
ara::crypto::CryptoErrc::kNoSuchValue : le dernier CryptoObject importé n'est pas une clé privée ([SWS_CRYPT_50209]).
ara::crypto::CryptoErrc::kUnsupported : le contexte ne prend fondamentalement pas en charge l'importation de clés privées ([SWS_CRYPT_50209]).
Cette note d'utilisation a été générée par une IA sur la base de la spécification AUTOSAR R25-11.
The interface shall return a shared pointer to the unwrapped PublicKey.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : b41e5e96382cProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode GetPublicKey de la classe ara::crypto::cryp::ProtectedKeyImportCtx sert à récupérer de manière synchrone un pointeur vers une clé publique préalablement importée et déballée ([SWS_CRYPT_50211]). La fonction n'accepte aucun paramètre de transmission et renvoie le résultat avec sécurité de typage sous forme de ara::core::Result<PublicKey::Sptr> ([SWS_CRYPT_50211]).
Avant l'appel, une opération d'importation doit s'être achevée avec succès ; sinon, l'appel échoue et renvoie le code d'erreur ara::crypto::CryptoErrc::kProcessingNotFinished ([SWS_CRYPT_50211]). Si le dernier objet cryptographique importé n'était pas une clé publique, cela se traduit par l'erreur ara::crypto::CryptoErrc::kNoSuchValue ([SWS_CRYPT_50211]). Si le contexte d'importation concret ne prend pas du tout en charge l'introduction de clés publiques, ara::crypto::CryptoErrc::kUnsupported est signalé ([SWS_CRYPT_50211]). Pour toutes les erreurs spécifiées, l'interface garantit une sémantique de rollback ([SWS_CRYPT_50211]).
En matière de concurrence et de sécurité vis-à-vis des erreurs, la méthode est spécifiée comme thread-safe ainsi qu'exception-safe et ne lève aucune exception C++ (noexcept) ([SWS_CRYPT_50211]).
Sur le plan fonctionnel, ce mécanisme d'importation se distingue d'autres interfaces : alors qu'un objet protégé est déballé ici, la fonction de même nom sur ara::crypto::cryp::PrivateKey ([SWS_CRYPT_22511]) fournit la clé publique d'une clé privée existante, laquelle a par exemple été générée auparavant au moyen de GeneratePrivateKey ([SWS_CRYPT_20722]).
Ce texte a été généré par une IA sur la base des prescriptions de la spécification.
virtual ara::core::Result< std::size_t > GetResponse (ReadWriteMem Region responseBuffer) const noexcept=0; DIRECTION NOT responseBuffer -- DEFINED
The interface shall write the response of the CryptoProvider to the last invocation of Import into the provided output buffer. E.g., this interface could return M4/M5 of a SHE LoadKey operation.
The interface shall return a shared pointer to the unwrapped SymmetricKey.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : cefc876d47dbProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode GetSymmetricKey de la classe ara::crypto::cryp::ProtectedKeyImportCtx renvoie un shared pointer vers une clé symétrique dépaquetée (SymmetricKey::Sptr) [SWS_CRYPT_50210]. L'appel s'effectue de manière synchrone, est déclaré comme const ainsi que noexcept et ne prend aucun paramètre [SWS_CRYPT_50210].
Pour que la récupération réussisse, certaines préconditions et séquences doivent être respectées [SWS_CRYPT_50210] :
Une opération d'importation doit avoir été préalablement terminée avec succès ; sinon, l'appel échoue avec le code d'erreur ara::crypto::CryptoErrc::kProcessingNotFinished[SWS_CRYPT_50210].
Si le dernier objet cryptographique importé n'est pas une clé symétrique, la méthode renvoie ara::crypto::CryptoErrc::kNoSuchValue[SWS_CRYPT_50210].
Si le contexte d'importation sélectionné ne prend généralement pas en charge l'importation de clés symétriques, l'erreur ara::crypto::CryptoErrc::kUnsupported est signalée [SWS_CRYPT_50210].
En ce qui concerne la sécurité d'exécution, l'interface est spécifiée comme thread-safe et exception-safe [SWS_CRYPT_50210]. Tous les cas d'erreur définis offrent une sémantique de rollback, de sorte que l'état du contexte reste inchangé en cas d'erreur [SWS_CRYPT_50210].
Ce texte a été généré par une IA sur la base de la spécification AUTOSAR R25-11.
The interface shall unwrap the protected data provided, parse the content, and make the parsed content (key-material and meta-data) available for retrieval by the application. If optionally a Key Slot is specified, the unwrapped key material shall be directly serialized into the KeySlot.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 89f9277cd6aaProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode synchrone Import de la classe ara::crypto::cryp::ProtectedKeyImportCtx déballe les données de clé protégées de la zone de mémoire serialized ([SWS_CRYPT_50207]). Elle analyse le contenu des données et met à disposition le matériel de clé extrait ainsi que les métadonnées pour la récupération ultérieure. Si un WriteableKeySlot est optionnellement transmis, le matériel de clé est directement sérialisé dans ce slot ([SWS_CRYPT_50207]). Interprétation : si aucun keySlot n'est transmis, le matériel de clé ne subsiste vraisemblablement que dans l'état du contexte d'importation. Question Q-130f11475af1bb33 (ouverte)
Gestion des erreurs
La fonction renvoie un ara::core::Result<void>. Si l'opération échoue, une sémantique de rollback s'applique pour tous les codes d'erreur ([SWS_CRYPT_50207]) :
ara::crypto::CryptoErrc::kInvalidInputSize : la taille d'entrée de serialized est inattendue ([SWS_CRYPT_50207]).
ara::crypto::CryptoErrc::kInvalidArgument : les données sérialisées ne correspondent pas au format attendu ([SWS_CRYPT_50207]).
ara::crypto::CryptoErrc::kAuthTagNotValid : la vérification d'authentification (MAC ou signature) échoue ([SWS_CRYPT_50207]).
ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut pas être exécutée temporairement ([SWS_CRYPT_50207]).
Concurrence et interaction
La méthode est sûre du point de vue des threads et sûre face aux exceptions (noexcept) ([SWS_CRYPT_50207]). Après un appel réussi, l'objet de clé déballé peut être récupéré depuis le contexte via GetPrivateKey ([SWS_CRYPT_50209]), GetSymmetricKey ([SWS_CRYPT_50210]) ou GetPublicKey ([SWS_CRYPT_50211]). Si le protocole sous-jacent exige un retour à l'expéditeur, GetResponse ([SWS_CRYPT_41020]) fournit la réponse du fournisseur cryptographique. Pour les formats de clés non protégés, les méthodes ImportPublicKey ([SWS_CRYPT_20732]), ImportSymmetricKey ([SWS_CRYPT_50014]) et ImportPrivateKey ([SWS_CRYPT_50132]) de la classe de fabrique CryptoProvider servent d'alternative.
Ce texte a été généré par une IA sur la base de la spécification AUTOSAR R25-11.
The interface shall restore the context to its initial state by ensuring that no key-import-key is set and all previously imported data is deleted from the ProtectedKeyImportCtx’s internal buffers.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 21bf97fcdbf3Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode Reset réinitialise l'instance de ara::crypto::cryp::ProtectedKeyImportCtx à son état initial [SWS_CRYPT_50212]. Ce faisant, l'interface s'assure qu'aucune Key-Import-Key (KIK) n'est plus définie et que toutes les données préalablement importées sont entièrement effacées des tampons internes du contexte [SWS_CRYPT_50212].
L'appel s'effectue de manière synchrone et est classé, conformément à la spécification, comme thread-safe ainsi que exception safe[SWS_CRYPT_50212]. La méthode déclare la signature virtual ara::core::Result<void> Reset() const noexcept = 0; et nécessite l'inclusion de l'en-tête ara/crypto/cryp/protected_key_import_ctx.h[SWS_CRYPT_50212].
Gestion des erreurs
Le résultat est renvoyé via ara::core::Result<void>[SWS_CRYPT_50212]. Si l'opération échoue, l'interface renvoie un code d'erreur :
ara::crypto::CryptoErrc::kUnsupported : survient lorsque le contexte spécifique ne prend pas en charge la réinitialisation de son état (sémantique de rollback) [SWS_CRYPT_50212].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification SWS_CRYPT_50212.
The interface shall configure the context to use the provided symmetric key as transport key.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : bb7a4eb711eaProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode SetKey de la classe ara::crypto::cryp::ProtectedKeyImportCtx configure le contexte de manière à ce que l'objet de clé symétrique transmis key (SymmetricKey::Sptr) soit utilisé comme clé de transport [SWS_CRYPT_50205]. L'appel s'effectue de manière synchrone et renvoie un ara::core::Result<void>[SWS_CRYPT_50205].
Gestion des erreurs
Si une erreur survient lors de la configuration, elle est signalée avec une sémantique de rollback, de sorte que l'état précédent du contexte reste inchangé [SWS_CRYPT_50205]. Les codes d'erreur suivants sont définis :
ara::crypto::CryptoErrc::kUnsupported : renvoyé si le contexte prend exclusivement en charge l'affectation d'un KeySlot[SWS_CRYPT_50205].
ara::crypto::CryptoErrc::kIncompatibleObject : l'objet de clé fourni ne peut pas être utilisé comme clé de transport [SWS_CRYPT_50205].
ara::crypto::CryptoErrc::kUsageViolation : les indicateurs d'utilisation de la clé ne contiennent pas le droit requis kAllowKeyUnwrapping[SWS_CRYPT_50205].
Concurrence et interaction
L'opération est spécifiée comme sûre du point de vue des threads (thread-safe) ainsi que sûre face aux exceptions (exception safe) et ne lève aucune exception (noexcept) [SWS_CRYPT_50205]. Alors que des contextes tels que SymmetricKeyWrapperCtx lient une clé pour la protection ou le wrapping [SWS_CRYPT_24018], la clé sert ici à l'importation de clés protégées. La condition d'erreur kUnsupported renvoie en outre à des architectures dans lesquelles les contextes sont alternativement configurés via un KeySlot[SWS_CRYPT_50034]. Interprétation : l'affectation de la clé de transport devrait obligatoirement devoir être achevée avant les opérations d'importation ultérieures. Question Q-f1f3eab5ab896b1b (ouverte)
Cette note d'utilisation a été générée automatiquement sur la base de la spécification AUTOSAR R25-11.
The interface shall configure the context to use the key stored in the provided KeySlot at the time the import operation is started as the transport key.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : e6e7bd1f753cProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode SetKey configure le contexte [SWS_CRYPT_50206] (ara::crypto::cryp::ProtectedKeyImportCtx) de sorte que la clé symétrique enregistrée dans le KeySlot::Sptr keySlot transmis soit utilisée comme clé de transport au moment du démarrage de l'opération d'importation. L'appel s'effectue de manière synchrone et renvoie un ara::core::Result<void>.
Gestion des erreurs
Si une erreur survient lors de la configuration, une sémantique de rollback s'applique [SWS_CRYPT_50206]. Les codes d'erreur spécifiques comprennent :
ara::crypto::CryptoErrc::kUnsupported : lorsque le contexte prend exclusivement en charge la définition d'un objet SymmetricKey direct [SWS_CRYPT_50206].
ara::crypto::CryptoErrc::kIncompatibleObject : lorsque la clé contenue dans le slot ne peut pas être utilisée comme clé de transport [SWS_CRYPT_50206].
ara::crypto::CryptoErrc::kUsageViolation : lorsque les indicateurs d'utilisation autorisés de la clé dans le KeySlot ne contiennent pas l'indicateur kAllowKeyUnwrapping[SWS_CRYPT_50206].
Concurrence et interaction
La fonction est spécifiée comme sûre face aux exceptions (exception safe) et sûre du point de vue des threads (thread-safe) [SWS_CRYPT_50206]. La clé n'est évaluée à partir du slot qu'au démarrage de l'importation suivante [SWS_CRYPT_50206]. Tandis que d'autres contextes cryptographiques tels que SymmetricKeyWrapperCtx[SWS_CRYPT_50034] ou KeyDerivationFunctionCtx[SWS_CRYPT_50010] peuvent également intégrer des slots comme source de clé, ProtectedKeyImportCtx::SetKey exige explicitement l'autorisation de déballer des clés.
Ce texte a été généré par un outil de documentation assisté par IA et ne remplace pas la consultation des spécifications officielles d'AUTOSAR.
gemini-3.8-flash-low· 2026-10-13 · Original allemand