DEENESPTFRRUARHIKOZHNL

classe ara::crypto::cryp::KeyEncapsulatorPublicCtx

[SWS_CRYPT_21800] Upstream: RS_CRYPTO_02104, RS_CRYPTO_02209

class KeyEncapsulatorPublicCtx :                public CryptoContext {...};

Asymmetric Key Encapsulation Mechanism (KEM) Public key Context interface.

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Forwarding-Header#include "ara/crypto/crypto_fwd.h"
Scopenamespace ara::crypto::cryp
Basisklasse(n)CryptoContext

Guide utilisateurGÉNÉRÉ PAR IA

Encapsule des clés symétriques de manière asymétrique via des clés publiques ou les génère au cours du processus d'encapsulation.
GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : f00bc8643d8f Provenance Questions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Encapsule des clés symétriques de manière asymétrique via des clés publiques ou les génère au cours du processus d'encapsulation.

L'interface ara::crypto::cryp::KeyEncapsulatorPublicCtx permet des mécanismes d'encapsulation de clés asymétriques (KEM) afin d'emballer des clés symétriques pour un échange sécurisé ou de les générer à nouveau directement lors de l'encapsulation ([SWS_CRYPT_50011]). Avant l'exécution, le contexte doit être initialisé via SetKey avec une clé publique ou un emplacement et la taille de tampon de sortie requise doit être déterminée ([SWS_CRYPT_21815]). Les contraintes essentielles sont les drapeaux d'utilisation de clé requis tels que kAllowKeyWrapping ainsi que la totale sécurité des threads de toutes les opérations.

Contexte

L'interface ara::crypto::cryp::KeyEncapsulatorPublicCtx définit le contexte asymétrique pour les mécanismes d'encapsulation de clés (Key Encapsulation Mechanisms, KEM) à l'aide d'une clé publique. Au sein de l'architecture cryptographique d'AUTOSAR Adaptive, la classe sert à l'échange sécurisé de clés et au transport de clés. Elle reçoit une clé asymétrique publique soit pour encapsuler une clé symétrique existante ([SWS_CRYPT_21813]), soit pour générer et fournir une nouvelle clé symétrique lors de l'encapsulation ([SWS_CRYPT_50011]). La base de clé peut alors être rattachée en tant qu'objet de clé direct PublicKey ([SWS_CRYPT_21815]) ou via un emplacement persistant KeySlot ([SWS_CRYPT_50012]).

diag_kem_kontext Anwendung Anwendung KeyEncapsulatorPublicCtx KeyEncapsulatorPublicCtx Anwendung->KeyEncapsulatorPublicCtx SymmetricKey SymmetricKey KeyEncapsulatorPublicCtx->SymmetricKey PublicKey PublicKey PublicKey->KeyEncapsulatorPublicCtx KeySlot KeySlot KeySlot->KeyEncapsulatorPublicCtx

Diagramme de contexte : intégration du KeyEncapsulatorPublicCtx entre l'application, les sources de clés et les clés cibles. Sources : [SWS_CRYPT_21813], [SWS_CRYPT_21815], [SWS_CRYPT_50011], [SWS_CRYPT_50012]

Cycle de vie

Les instances de KeyEncapsulatorPublicCtx sont gérées via le smart pointer typé KeyEncapsulatorPublicCtx::Sptr, qui est défini comme std::shared_ptr<KeyEncapsulatorPublicCtx> ([SWS_CRYPT_21801]). La création effective de l'objet devrait s'effectuer via une fabrique de fournisseur sous-jacente de la plateforme, étant donné que la classe constitue une interface purement virtuelle. Question Q-3551020e7b9c0f0c (ouverte)

Après sa création, le contexte se trouve dans un état d'initialisation incomplète. Tant qu'aucune clé publique n'a été assignée au contexte, les appels de calcul de taille de tampon ([SWS_CRYPT_50013]) ainsi que les opérations d'encapsulation ([SWS_CRYPT_21813], [SWS_CRYPT_50011]) échouent avec l'erreur CryptoErrc::kUninitializedContext. L'état opérationnel est établi par configuration via SetKey avec PublicKey::Sptr ([SWS_CRYPT_21815]) ou KeySlot::Sptr ([SWS_CRYPT_50012]). Lors de l'assignation d'un KeySlot, la clé publique contenue ne devrait être lue dynamiquement qu'au moment de l'exécution effective de l'encapsulation. Question Q-ea760070f05941d2 (ouverte) Toutes les méthodes du contexte sont, conformément à la spécification, thread-safe et garantissent la sécurité vis-à-vis des exceptions ([SWS_CRYPT_21813], [SWS_CRYPT_50011], [SWS_CRYPT_50013], [SWS_CRYPT_21815], [SWS_CRYPT_50012]).

Parcours d'utilisation

L'application pratique du contexte suit un ordre défini comprenant la liaison de la clé, le dimensionnement du tampon et l'exécution de l'encapsulation :

  • Liaison de la clé : l'application initialise le contexte via SetKey soit avec un PublicKey chargé ([SWS_CRYPT_21815]), soit avec un KeySlot ([SWS_CRYPT_50012]).
  • Dimensionnement du tampon : avant la mise à disposition du tampon de sortie, l'application détermine la taille de sortie maximale requise en octets via GetRequiredOutputBufferSize(algId) ([SWS_CRYPT_50013]) pour l'algorithme symétrique cible prévu et réserve une ReadWriteMemRegion correspondante.
  • Exécution de l'encapsulation : selon l'usage visé, l'application choisit l'une des deux variantes d'encapsulation :
    • Mise à disposition d'une clé existante : Encapsulate(key, encapsulatedKey) encapsule le SymmetricKey transmis et renvoie le nombre d'octets écrits ([SWS_CRYPT_21813]).
    • Génération autonome : Encapsulate(algId, allowedUsage, encapsulatedKey) génère une nouvelle clé symétrique selon les drapeaux d'utilisation requis et renvoie une paire constituée de la taille en octets et du nouveau SymmetricKey::Sptr ([SWS_CRYPT_50011]).
Déroulement de l'encapsulation de cléApplicationKeyEncapsulatorPublicCtxUse Case: Configuration de la clé d'encapsulationSetKey(key / keySlot)Result<void>Use Case: Vérification de la taille de tamponGetRequiredOutputBufferSize(algId)Result<std::size_t>Use Case: KapselungaltClé existanteEncapsulate(key, memRegion)Result<std::size_t>Une nouvelle clé est généréeEncapsulate(algId, usage, memRegion)Result<std::pair<std::size_t, SymmetricKey::Sptr>>

Diagramme de séquence : séquence d'appels typique de l'assignation de clé à l'encapsulation de clé en passant par le calcul du tampon. Sources : [SWS_CRYPT_21813], [SWS_CRYPT_21815], [SWS_CRYPT_50011], [SWS_CRYPT_50013]

Scénarios d'erreur

Les méthodes de KeyEncapsulatorPublicCtx signalent les erreurs via ara::core::Result avec des valeurs issues de ara::crypto::CryptoErrc et garantissent une sémantique de rollback en cas d'erreur. Les situations d'erreur principales comprennent :

  • CryptoErrc::kUninitializedContext : survient lorsque GetRequiredOutputBufferSize ([SWS_CRYPT_50013]) ou Encapsulate ([SWS_CRYPT_21813], [SWS_CRYPT_50011]) est appelé sans configuration préalable réussie au moyen de SetKey.
  • CryptoErrc::kUsageViolation : signale des utilisations de clé non autorisées. Cela se produit lorsque le drapeau kAllowKeyWrapping manque à la clé d'encapsulation ([SWS_CRYPT_21815], [SWS_CRYPT_21813], [SWS_CRYPT_50011]) ou lorsque la clé symétrique à encapsuler n'est pas autorisée pour l'export sécurisé via kAllowSecuredExport ([SWS_CRYPT_21813]).
  • CryptoErrc::kIncompatibleObject : indique qu'une clé ou un emplacement transmis n'est pas compatible avec l'algorithme du contexte ([SWS_CRYPT_21815], [SWS_CRYPT_50012], [SWS_CRYPT_21813]).
  • CryptoErrc::kInsufficientCapacity et CryptoErrc::kInvalidInputSize : sont déclenchés si la ReadWriteMemRegion fournie ne présente pas la capacité de tampon requise ou si la taille d'entrée de la clé n'est pas prise en charge ([SWS_CRYPT_21813], [SWS_CRYPT_50011]).
  • CryptoErrc::kEmptyKeySlot et CryptoErrc::kBusyResource : surviennent lorsqu'un KeySlot lié via SetKey est vide au moment de l'exécution de l'encapsulation ou qu'une ressource matérielle impliquée est occupée ([SWS_CRYPT_21813], [SWS_CRYPT_50011]).
  • CryptoErrc::kUnsupported : est renvoyé lorsque l'implémentation du contexte prend en charge soit exclusivement des objets de clé plutôt que des emplacements ([SWS_CRYPT_50012]) soit inversement ([SWS_CRYPT_21815]), ou bien lorsque la définition de clés externes ou la génération autonome de clés n'est pas prise en charge dans le contexte ([SWS_CRYPT_21813], [SWS_CRYPT_50011]).

Ce guide repose exclusivement sur les spécifications de l'AUTOSAR Adaptive Platform Release R25-11.

Carte des membres

Méthodes

3
EncapsulateGetRequiredOutputBufferSizeSetKey

Alias de type

1
Sptr

Diagramme de classes

Hohle Dreieckspfeile = Vererbung (zeigt zur Basisklasse); Klicken öffnet die jeweilige Klassenseite.

G nara__crypto__cryp__KeyEncapsulatorPublicCtx699 KeyEncapsulatorPublicCtx + Encapsulate() + GetRequiredOutputBufferSize() + SetKey() nara__crypto__cryp__CryptoContext85 CryptoContext nara__crypto__cryp__KeyEncapsulatorPublicCtx699->nara__crypto__cryp__CryptoContext85

Vue détaillée

Sélectionnez une entrée dans le plan.

Méthodes

Encapsulate fonction 2

Encapsulate the provided symmetric key.

Surcharges Encapsulate 2
virtual ara::core::Result< std::size_t > Encapsulate (Symmetric Key::Sptr key, ReadWriteMemRegion encapsulatedKey) const noexcept=0; SWS_CRYPT_21813
virtual ara::core::Result< std::pair< std::size_t, SymmetricKey::Sptr > > Encapsulate (AlgId algId, AllowedUsageFlags allowedUsage, Read WriteMemRegion encapsulatedKey) const noexcept=0; SWS_CRYPT_50011
GetRequiredOutputBufferSize fonction

Calculate the maximum required size of the output buffer depending on the input size in the current state of the context.

virtual ara::core::Result< std::size_t > GetRequiredOutputBufferSize (AlgId algId) const noexcept;
SetKey fonction 2

Configure the context to use the provided key as encapsulation key.

Surcharges SetKey 2
virtual ara::core::Result< void > SetKey (PublicKey::Sptr key) noexcept=0; SWS_CRYPT_21815
virtual ara::core::Result< void > SetKey (KeySlot::Sptr keySlot) noexcept=0; SWS_CRYPT_50012

Alias de type

Sptr alias de type

Smart pointer of the interface.

using Sptr = std::shared_ptr<KeyEncapsulatorPublicCtx>;

Documentation des méthodes

fonction Encapsulate [SWS_CRYPT_21813] Upstream: RS_CRYPTO_02102, RS_CRYPTO_02108, RS_CRYPTO_02115

virtual ara::core::Result< std::size_t > Encapsulate (Symmetric Key::Sptr key, ReadWriteMemRegion encapsulatedKey) const noexcept=0;

Encapsulate the provided symmetric key.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 998c7d355307 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

La méthode synchrone Encapsulate encapsule une clé symétrique transmise (key) et écrit le résultat dans le tampon de sortie encapsulatedKey [SWS_CRYPT_21813]. En cas d'exécution réussie, elle renvoie via ara::core::Result<std::size_t> la taille en octets de la clé encapsulée [SWS_CRYPT_21813].

En cas d'erreur, un code d'erreur correspondant est renvoyé avec une sémantique de rollback [SWS_CRYPT_21813]. Les causes d'erreur pertinentes sont :

  • UninitializedContext : le contexte n'a pas été initialisé avec une valeur de clé publique [SWS_CRYPT_21813].
  • ara::crypto::CryptoErrc::kUsageViolation : le drapeau d'utilisation kAllowKeyWrapping manque à la clé d'encapsulation ou kAllowSecuredExport manque à la clé à encapsuler [SWS_CRYPT_21813].
  • ara::crypto::CryptoErrc::kIncompatibleObject ou CryptoErrc::kInvalidInputSize : l'objet clé est incompatible ou la taille de clé n'est pas prise en charge par le contexte [SWS_CRYPT_21813].
  • CryptoErrc::kUnsupported : le contexte ne prend pas en charge l'encapsulation de clés fournies, car il les génère lui-même pendant l'encapsulation [SWS_CRYPT_21813].
  • ara::crypto::CryptoErrc::kInsufficientCapacity : le tampon encapsulatedKey est dimensionné trop petit [SWS_CRYPT_21813].
  • ara::crypto::CryptoErrc::kBusyResource ou ara::crypto::CryptoErrc::kEmptyKeySlot : une ressource est occupée ou un KeySlot configuré est vide [SWS_CRYPT_21813].

L'opération est déclarée comme const, noexcept et spécifiée comme thread-safe et exception safe [SWS_CRYPT_21813].

En interaction avec le module, cette fonction se distingue de la surcharge alternative [SWS_CRYPT_50011], qui ne reçoit pas de clé existante mais génère dynamiquement à nouveau la clé symétrique et la renvoie conjointement avec le résultat de l'encapsulation [SWS_CRYPT_50011].

Note d'utilisation générée automatiquement sur la base d'AUTOSAR R25-11.

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Scopeclass ara::crypto::cryp::KeyEncapsulatorPublicCtx
Exception-Sicherheitexception safe
Thread-Sicherheitthread-safe CryptoErrc::k rollback_semantics

Parameter (in)

ParameterBeschreibung
keythe symmetric key to be encapsulated

Parameter (out)

ParameterBeschreibung
encapsulatedKeyan output buffer the encapsulated key is written to

Rückgabewert

TypBeschreibung
ara::core::Result<std::size_t >a result containing the size of the encapsulated key or an error

Fehler

FehlercodeBeschreibung
UninitializedContextif the context was not initialized by a public key value
ara::crypto::CryptoErrc::kUsageViolationrollback_semantics if the allowed usage of the encapsulation key does not include k AllowKeyWrapping or if the allowed usage of the encapsulated key does not include kAllowSecuredExport
ara::crypto::CryptoErrc::kIncompatibleObjectrollback_semantics if the provided encapsulated key object is incompatible with this context
CryptoErrc::kInvalidInputSizerollback_semantics if this context does not support the size of the encapsulated key
CryptoErrc::kUnsupportedrollback_semantics if this context does not support setting the encapsulated key, because it generates the key during encapsulation
ara::crypto::CryptoErrc::kInsufficientCapacityrollback_semantics if the output buffer is too small
ara::crypto::CryptoErrc::kBusyResourcerollback_semantics a required resource is busy
ara::crypto::CryptoErrc::kEmptyKeySlotrollback_semantics if a KeySlot was configured that is currently is empty
ara::crypto::CryptoErrc::kUsageViolationrollback_semantics if the allowed usage of the key does not include kAllowKeyWrapping

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/SWS_CRYPT_21813
Status
valid/unmigrated
Version
AUTOSAR/AP/record/SWS_CRYPT_21813@rel:R25-11#11843d41
Content hash
11843d41
Source
https://www.autosar.org/fileadmin/standards/R25-11/AP/AUTOSAR_AP_SWS_Cryptography.pdf#nameddest=SWS_CRYPT_21813
Status: valid/unmigrated Version: rel:R25-11#5f08acc8 Versionshistorie & Revisions (1 transition, 8 revision)
Current State
valid/unmigrated
Reason
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
Campaign
2026-08-13-status-backfill
Active Version
AUTOSAR/AP/record/SWS_CRYPT_21813@rel:R25-11#5f08acc8
Point-in-Time History:
Recorded Revisions (8):
  • R25-11rel:R25-11#b3c8ad102026-09-30
  • R19-11rel:R19-11#5df6f2a12026-10-14
  • R20-11rel:R20-11#bc53d66f2026-10-14
  • R21-11rel:R21-11#a093fad52026-10-14
  • R22-11rel:R22-11#9a52ca012026-10-14
  • R23-11rel:R23-11#dadd77c62026-10-14
  • R24-11rel:R24-11#2cf84d842026-10-14
  • R25-11rel:R25-11#5f08acc82026-10-14 active
DateActorTransitionReason / RationaleCampaign
2026-08-13toolnone → valid/unmigratedmechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record2026-08-13-status-backfill

fonction Encapsulate [SWS_CRYPT_50011] Upstream: RS_CRYPTO_02102, RS_CRYPTO_02108, RS_CRYPTO_02115

virtual ara::core::Result< std::pair< std::size_t, SymmetricKey::Sptr > > Encapsulate (AlgId algId, AllowedUsageFlags allowedUsage, Read WriteMemRegion encapsulatedKey) const noexcept=0;

Generate new a symmetric key and encapsulate it. Optionally store the generated key.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 68e8fc3273e7 Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation et sémantique

La méthode synchrone Encapsulate génère en interne une nouvelle clé symétrique et l'encapsule à l'aide du contexte [SWS_CRYPT_50011]. L'algorithme cible algId ainsi que les indicateurs d'utilisation autorisés allowedUsage pour la clé générée sont spécifiés en tant que paramètres d'entrée [SWS_CRYPT_50011]. Le chiffré de la clé est écrit dans le tampon de sortie encapsulatedKey [SWS_CRYPT_50011]. En cas de succès, la valeur de retour encapsule une paire constituée de la taille réelle en octets de la clé encapsulée et d'un pointeur intelligent vers l'objet clé généré (std::pair<std::size_t, SymmetricKey::Sptr>) au sein d'un ara::core::Result [SWS_CRYPT_50011].

Gestion des erreurs et sécurisation

En cas d'erreur, les valeurs de retour possèdent principalement une sémantique de rollback [SWS_CRYPT_50011]. Les causes d'erreur possibles comprennent :

  • UninitializedContext : le contexte n'a pas été initialisé au préalable avec une clé publique [SWS_CRYPT_50011].
  • CryptoErrc::kUsageViolation : l'indicateur kAllowKeyWrapping manque à la clé d'encapsulation ou kAllowSecuredExport manque à la clé cible [SWS_CRYPT_50011].
  • CryptoErrc::kInsufficientCapacity : le tampon de sortie encapsulatedKey n'offre pas une capacité suffisante [SWS_CRYPT_50011].
  • CryptoErrc::kUnknownIdentifier ou CryptoErrc::kUnsupported : la algId est inconnue ou la génération pendant l'encapsulation n'est pas prise en charge [SWS_CRYPT_50011].
  • CryptoErrc::kEmptyKeySlot ou CryptoErrc::kBusyResource : un KeySlot configuré est vide ou une ressource requise est occupée [SWS_CRYPT_50011].

Concurrence et interaction

L'opération est spécifiée comme const, noexcept, thread-safe et exception-safe [SWS_CRYPT_50011]. Par comparaison avec la surcharge [SWS_CRYPT_21813], à laquelle une clé existante est transmise et qui ne retourne que la taille de celle-ci, cette méthode effectue la génération de clé et l'encapsulation en une seule étape conjointe [SWS_CRYPT_50011].

Ce texte a été rédigé par une IA sur la base de la spécification.

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Scopeclass ara::crypto::cryp::KeyEncapsulatorPublicCtx
Exception-Sicherheitexception safe
Thread-Sicherheitthread-safe CryptoErrc::k rollback_semantics

Parameter (in)

ParameterBeschreibung
algIdthe identifier of the target symmetric crypto algorithm
allowedUsagethe flags that define a list of allowed transformations’ types in which the target key can be used

Parameter (out)

ParameterBeschreibung
encapsulatedKeyan output buffer the encapsulated key is written to

Rückgabewert

TypBeschreibung
ara::core::Result<std::pair< std::size_t, SymmetricKey::Sptr > >a result containing a pair of the size of the encapsulated key and the generated symmetric key or an error

Fehler

FehlercodeBeschreibung
UninitializedContextif the context was not initialized by a public key value
ara::crypto::CryptoErrc::kUsageViolationrollback_semantics if the allowed usage of the encapsulation key does not include k AllowKeyWrapping or if the allowed usage of the encapsulated key does not include kAllowSecuredExport
CryptoErrc::kInvalidInputSizerollback_semantics if this context does not support the size of the encapsulated key
CryptoErrc::kUnsupportedrollback_semantics if this context does not support generating the encapsulated key during encapsulation
ara::crypto::CryptoErrc::kUnknownIdentifierrollback_semantics if algId has an unsupported value
ara::crypto::CryptoErrc::kInsufficientCapacityrollback_semantics if the output buffer is too small
ara::crypto::CryptoErrc::kBusyResourcerollback_semantics a required resource is busy
ara::crypto::CryptoErrc::kEmptyKeySlotrollback_semantics if a KeySlot was configured via SetKey that is currently is empty
ara::crypto::CryptoErrc::kUsageViolationrollback_semantics if the allowed usage of the key does not include kAllowKeyWrapping

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/SWS_CRYPT_50011
Status
valid/unmigrated
Version
AUTOSAR/AP/record/SWS_CRYPT_50011@rel:R25-11#cdc2ccc7
Content hash
cdc2ccc7
Source
https://www.autosar.org/fileadmin/standards/R25-11/AP/AUTOSAR_AP_SWS_Cryptography.pdf#nameddest=SWS_CRYPT_50011
Status: valid/unmigrated Version: rel:R25-11#7f7fdb0c Versionshistorie & Revisions (1 transition)
Current State
valid/unmigrated
Reason
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
Campaign
2026-08-13-status-backfill
Active Version
AUTOSAR/AP/record/SWS_CRYPT_50011@rel:R25-11#7f7fdb0c
Point-in-Time History:
DateActorTransitionReason / RationaleCampaign
2026-08-13toolnone → valid/unmigratedmechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record2026-08-13-status-backfill

fonction GetRequiredOutputBufferSize [SWS_CRYPT_50013] Upstream: RS_CRYPTO_02302

virtual ara::core::Result< std::size_t > GetRequiredOutputBufferSize (AlgId algId) const noexcept;

Calculate the maximum required size of the output buffer depending on the input size in the current state of the context.

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Scopeclass ara::crypto::cryp::KeyEncapsulatorPublicCtx
Exception-Sicherheitexception safe
Thread-Sicherheitthread-safe

Parameter (in)

ParameterBeschreibung
algIdthe algId of the key to encapsulate

Rückgabewert

TypBeschreibung
ara::core::Result<std::size_t >a result containing the required capacity of the output buffer in bytes or an error

Fehler

FehlercodeBeschreibung
ara::crypto::CryptoErrc::kUninitializedContextrollback_semantics if the context was not initialized by deploying a key

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/SWS_CRYPT_50013
Status
valid/unmigrated
Version
AUTOSAR/AP/record/SWS_CRYPT_50013@rel:R25-11#81b06feb
Content hash
81b06feb
Source
https://www.autosar.org/fileadmin/standards/R25-11/AP/AUTOSAR_AP_SWS_Cryptography.pdf#nameddest=SWS_CRYPT_50013
Status: valid/unmigrated Version: rel:R25-11#8834a17a Versionshistorie & Revisions (1 transition)
Current State
valid/unmigrated
Reason
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
Campaign
2026-08-13-status-backfill
Active Version
AUTOSAR/AP/record/SWS_CRYPT_50013@rel:R25-11#8834a17a
Point-in-Time History:
DateActorTransitionReason / RationaleCampaign
2026-08-13toolnone → valid/unmigratedmechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record2026-08-13-status-backfill

fonction SetKey [SWS_CRYPT_21815] Upstream: RS_CRYPTO_02001, RS_CRYPTO_02003

virtual ara::core::Result< void > SetKey (PublicKey::Sptr key) noexcept=0;

Configure the context to use the provided key as encapsulation key.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 4803853a1afa Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand

Utilisation

La méthode SetKey configure l'instance de ara::crypto::cryp::KeyEncapsulatorPublicCtx de manière à ce que l'objet de clé transmis soit utilisé comme clé d'encapsulation [SWS_CRYPT_21815]. key de type PublicKey::Sptr sert de paramètre [SWS_CRYPT_21815]. L'appel s'effectue de manière synchrone et fournit comme valeur de retour un ara::core::Result<void> qui est vide en cas de succès ou transporte un code d'erreur [SWS_CRYPT_21815].

Gestion des erreurs

En cas d'erreur, tous les codes d'erreur signalés possèdent une sémantique de rollback [SWS_CRYPT_21815] :

  • ara::crypto::CryptoErrc::kIncompatibleObject : l'objet de clé fourni est incompatible avec le contexte [SWS_CRYPT_21815].
  • ara::crypto::CryptoErrc::kUsageViolation : l'utilisation autorisée de la clé n'inclut pas l'indicateur kAllowKeyWrapping [SWS_CRYPT_21815].
  • ara::crypto::CryptoErrc::kUnsupported : le contexte prend exclusivement en charge la définition d'une clé via un KeySlot [SWS_CRYPT_21815].

Concurrence et restrictions

La fonction est spécifiée comme thread-safe et exception safe avec une garantie noexcept [SWS_CRYPT_21815].

Interaction

La configuration de la clé prépare le contexte pour l'encapsulation de clé, qui est exécutée via la méthode Encapsulate [SWS_CRYPT_50011]. Si le contexte ne prend pas en charge l'assignation directe de clé ou si la clé doit être obtenue depuis une zone de mémoire, la surcharge de SetKey avec un KeySlot::Sptr est disponible comme alternative [SWS_CRYPT_50012].

Cette note d'utilisation a été générée par une IA et est basée sur les spécifications de la version R25-11.

Guide de l'implémenteur à venir (complexité I2)

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Scopeclass ara::crypto::cryp::KeyEncapsulatorPublicCtx
Exception-Sicherheitexception safe
Thread-Sicherheitthread-safe

Parameter (in)

ParameterBeschreibung
keythe key encapsulation key

Rückgabewert

TypBeschreibung
ara::core::Result< void >An empty result or an error

Fehler

FehlercodeBeschreibung
ara::crypto::CryptoErrc::kIncompatibleObjectrollback_semantics if the provided key object is incompatible with this context
ara::crypto::CryptoErrc::kUsageViolationrollback_semantics if the allowed usage of the key does not include kAllowKeyWrapping
ara::crypto::CryptoErrc::kUnsupportedrollback_semantics if the context only supports setting a KeySlot

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/SWS_CRYPT_21815
Status
valid/unmigrated
Version
AUTOSAR/AP/record/SWS_CRYPT_21815@rel:R25-11#51bfc3d6
Content hash
51bfc3d6
Source
https://www.autosar.org/fileadmin/standards/R25-11/AP/AUTOSAR_AP_SWS_Cryptography.pdf#nameddest=SWS_CRYPT_21815
Status: valid/unmigrated Version: rel:R25-11#135664c1 Versionshistorie & Revisions (1 transition, 7 revision)
Current State
valid/unmigrated
Reason
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
Campaign
2026-08-13-status-backfill
Active Version
AUTOSAR/AP/record/SWS_CRYPT_21815@rel:R25-11#135664c1
Point-in-Time History:
Recorded Revisions (7):
  • R25-11rel:R25-11#97afebd22026-09-30
  • R20-11rel:R20-11#3e034d832026-10-14
  • R21-11rel:R21-11#14e868c82026-10-14
  • R22-11rel:R22-11#c056496f2026-10-14
  • R23-11rel:R23-11#4a9295802026-10-14
  • R24-11rel:R24-11#6638cae22026-10-14
  • R25-11rel:R25-11#135664c12026-10-14 active
DateActorTransitionReason / RationaleCampaign
2026-08-13toolnone → valid/unmigratedmechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record2026-08-13-status-backfill

fonction SetKey [SWS_CRYPT_50012] Upstream: RS_CRYPTO_02001, RS_CRYPTO_02003

virtual ara::core::Result< void > SetKey (KeySlot::Sptr keySlot) noexcept=0;

Configure the context to use the key stored in the provided KeySlot at the time the key encapsulation is performed.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : c951ff682a31 Provenance Questions 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::KeyEncapsulatorPublicCtx configure le contexte de manière à utiliser la clé publique stockée dans un emplacement de clé transmis (KeySlot) au moment de l'encapsulation de clé [SWS_CRYPT_50012].

Utilisation

L'appel s'effectue de manière synchrone et est spécifié comme noexcept ainsi que exception safe [SWS_CRYPT_50012]. Le paramètre utilisé est keySlot de type KeySlot::Sptr, qui doit contenir une clé publique [SWS_CRYPT_50012]. La valeur de retour est un ara::core::Result<void>, qui ne contient aucune valeur en cas de succès [SWS_CRYPT_50012].

Gestion des erreurs

En cas d'erreur, un code d'erreur avec une sémantique de rollback est renvoyé [SWS_CRYPT_50012] :

  • ara::crypto::CryptoErrc::kIncompatibleObject : Le keySlot transmis est incompatible avec ce contexte [SWS_CRYPT_50012].
  • ara::crypto::CryptoErrc::kUnsupported : le contexte prend exclusivement en charge la définition d'un objet PublicKey [SWS_CRYPT_50012].

Concurrence et interaction

La fonction est définie comme thread-safe [SWS_CRYPT_50012]. En plus de l'assignation via un emplacement de clé, il existe une surcharge alternative pour la transmission directe d'un PublicKey::Sptr [SWS_CRYPT_21815]. La clé configurée est utilisée dès que l'encapsulation de clé est effectuée via Encapsulate [SWS_CRYPT_50011]. En ce qui concerne l'ordonnancement, SetKey devrait devoir être exécuté avant l'appel de Encapsulate pour que le contexte soit initialisé. Question Q-769923d4fb9a3d1e (ouverte)

Cette note d'utilisation a été générée automatiquement sur la base de la spécification d'AUTOSAR Adaptive R25-11.

Guide de l'implémenteur à venir (complexité I2)

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Scopeclass ara::crypto::cryp::KeyEncapsulatorPublicCtx
Exception-Sicherheitexception safe
Thread-Sicherheitthread-safe

Parameter (in)

ParameterBeschreibung
keySlota keyslot containing a public key

Rückgabewert

TypBeschreibung
ara::core::Result< void >An empty result or an error

Fehler

FehlercodeBeschreibung
ara::crypto::CryptoErrc::kIncompatibleObjectrollback_semantics if the provided keySlot is incompatible with this context
ara::crypto::CryptoErrc::kUnsupportedrollback_semantics if the context only supports setting a PublicKey

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/SWS_CRYPT_50012
Status
valid/unmigrated
Version
AUTOSAR/AP/record/SWS_CRYPT_50012@rel:R25-11#9aaa0567
Content hash
9aaa0567
Source
https://www.autosar.org/fileadmin/standards/R25-11/AP/AUTOSAR_AP_SWS_Cryptography.pdf#nameddest=SWS_CRYPT_50012
Status: valid/unmigrated Version: rel:R25-11#b5e332fa Versionshistorie & Revisions (1 transition)
Current State
valid/unmigrated
Reason
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
Campaign
2026-08-13-status-backfill
Active Version
AUTOSAR/AP/record/SWS_CRYPT_50012@rel:R25-11#b5e332fa
Point-in-Time History:
DateActorTransitionReason / RationaleCampaign
2026-08-13toolnone → valid/unmigratedmechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record2026-08-13-status-backfill

Documentation des alias de type

alias de type Sptr [SWS_CRYPT_21801] Upstream: RS_CRYPTO_02209

using Sptr = std::shared_ptr<KeyEncapsulatorPublicCtx>;

Smart pointer of the interface.

Header-Datei#include "ara/crypto/cryp/key_encapsulator_public_ctx.h"
Scopeclass ara::crypto::cryp::KeyEncapsulatorPublicCtx
SymbolSptr

Request a governed re-review of this record. The record is not changed immediately.

Record
AUTOSAR/AP/record/SWS_CRYPT_21801
Status
valid/unmigrated
Version
AUTOSAR/AP/record/SWS_CRYPT_21801@rel:R25-11#8049f1ba
Content hash
8049f1ba
Source
https://www.autosar.org/fileadmin/standards/R25-11/AP/AUTOSAR_AP_SWS_Cryptography.pdf#nameddest=SWS_CRYPT_21801
Status: valid/unmigrated Version: rel:R25-11#6c7506e9 Versionshistorie & Revisions (1 transition, 8 revision)
Current State
valid/unmigrated
Reason
mechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record
Campaign
2026-08-13-status-backfill
Active Version
AUTOSAR/AP/record/SWS_CRYPT_21801@rel:R25-11#6c7506e9
Point-in-Time History:
Recorded Revisions (8):
  • R25-11rel:R25-11#d5df06eb2026-09-30
  • R19-11rel:R19-11#3a23dd282026-10-14
  • R20-11rel:R20-11#b2bfbd8b2026-10-14
  • R21-11rel:R21-11#b2bfbd8b2026-10-14
  • R22-11rel:R22-11#1b749d9b2026-10-14
  • R23-11rel:R23-11#7bb57d5b2026-10-14
  • R24-11rel:R24-11#7bb57d5b2026-10-14
  • R25-11rel:R25-11#6c7506e92026-10-14 active
DateActorTransitionReason / RationaleCampaign
2026-08-13toolnone → valid/unmigratedmechanically backfilled by migriere_status_backfill.py -- no per-field curation history exists yet for this record2026-08-13-status-backfill