Fournit des types de base, des domaines d'erreur et des fonctions de fabrique pour les services cryptographiques et la gestion des clés.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 253d08fc1defProvenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Fournit des types de base, des domaines d'erreur et des fonctions de fabrique pour les services cryptographiques et la gestion des clés.
L'espace de noms ara::crypto fournit les types de base communs, les tampons mémoire et les fonctions de fabrique globales pour les services cryptographiques dans AUTOSAR Adaptive. Les applications créent ou obtiennent des instances de sous-systèmes telles que les fournisseurs de cryptographie et de stockage de clés de manière déterministe via des points d'entrée tels que LoadCryptoProvider[SWS_CRYPT_20099]. Toutes les opérations cryptographiques et utilisations de clés sont ici strictement contrôlées via des indicateurs d'utilisation définis ainsi que le domaine d'erreur standardisé avec CryptoErrc[SWS_CRYPT_10099]. Toutes les interfaces de fabrique présupposent un mappage de processus valide et sont conçues pour être thread-safe.
Contexte
L'espace de noms ara::crypto constitue le fondement commun et le point d'entrée central pour tous les services cryptographiques, les fonctions de gestion des clés et les opérations de certificat de l'AUTOSAR Adaptive Platform. Au lieu d'exposer les détails d'implémentation des pilotes sous-jacents ou des modules de sécurité matériels, l'espace de noms définit des interfaces standardisées et des fonctions de fabrique globales. Via ces points d'entrée, les applications demandent des instances des sous-systèmes spécialisés : le fournisseur de cryptographie générale [SWS_CRYPT_20099], le fournisseur X.509 [SWS_CRYPT_40099], les accès en lecture et en écriture aux emplacements de stockage de clés [SWS_CRYPT_50004][SWS_CRYPT_50005] ainsi que des formateurs pour la sérialisation d'objets [SWS_CRYPT_50200].
Pour une transmission sécurisée et cohérente des données, ara::crypto met à disposition des abstractions de mémoire et des systèmes de types fondamentaux. Les zones de tampon sont encapsulées avec sûreté de typage via ReadOnlyMemRegion[SWS_CRYPT_10033] pour les données d'entrée et ReadWriteMemRegion[SWS_CRYPT_10031] pour les données de sortie. Les algorithmes sont référencés de manière standardisée via AlgId[SWS_CRYPT_10014] ou AlgIdString[SWS_CRYPT_50000], et les horodatages reposent sur Timestamp[SWS_CRYPT_50003]. De plus, l'énumération CryptoObjectType[SWS_CRYPT_10016] classifie les types d'objets pouvant être déposés dans le stockage de clés, tandis que les directions de transformation telles que le chiffrement ou le déchiffrement sont prescrites par CryptoTransform[SWS_CRYPT_10019]. Les opérations sur les clés autorisées sont régies par des masques de bits de type AllowedUsageFlags[SWS_CRYPT_10015] qui couvrent notamment le chiffrement et le déchiffrement [SWS_CRYPT_13101][SWS_CRYPT_13102], les signatures [SWS_CRYPT_13103][SWS_CRYPT_13104], l'accord de clés [SWS_CRYPT_13105] et les exportations [SWS_CRYPT_40991][SWS_CRYPT_40992]. Pour la sérialisation, des identifiants de format de type FormatId[SWS_CRYPT_10701] tels que kFormatRawValueOnly[SWS_CRYPT_60017], kFormatDerEncoded[SWS_CRYPT_60018] et kFormatPemEncoded[SWS_CRYPT_60019] sont disponibles.
Diagramme de contexte : Interaction entre les instances applicatives, les points d'entrée dans ara::crypto et les objets de sous-système fournis. Sources : [SWS_CRYPT_20099], [SWS_CRYPT_40099], [SWS_CRYPT_50004], [SWS_CRYPT_50005], [SWS_CRYPT_50200].
Cycle de vie
La gestion du cycle de vie des objets cryptographiques centraux suit le patron de fabrique via des points d'entrée globaux :
Instanciation et relations de propriété : Les applications ne créent pas d'instances manuellement via des constructeurs. À la place, les fonctions de fabrique LoadCryptoProvider[SWS_CRYPT_20099], LoadKeySlot[SWS_CRYPT_50004], LoadWriteableKeySlot[SWS_CRYPT_50005], LoadX509Provider[SWS_CRYPT_40099] et LoadFormatter[SWS_CRYPT_50200] renvoient des références de propriété partagée sous forme de ara::core::Result<...::Sptr>.
Cycles de vie des singletons et des fournisseurs : la fonction LoadX509Provider fournit l'instance unique du fournisseur X.509 singleton [SWS_CRYPT_40099]. LoadCryptoProvider crée ou référence l'instance existante du fournisseur de cryptographie modélisé via un ara::core::InstanceSpecifier[SWS_CRYPT_20099].
Concurrence et destruction : toutes les fonctions de fabrique ainsi que les assistants de domaine d'erreur GetCryptoErrorDomain[SWS_CRYPT_19952] et MakeErrorCode[SWS_CRYPT_19951] sont spécifiés comme étant sûrs face aux exceptions (noexcept) et sûrs pour les threads (thread-safe). La libération des objets référencés a lieu automatiquement dès que le dernier pointeur partagé détenu expire.
Parcours d'utilisation
Un chemin d'utilisation typique pour l'exécution d'opérations cryptographiques ou la gestion de clés passe par les étapes suivantes :
Charger le fournisseur : l'application appelle LoadCryptoProvider avec un ara::core::InstanceSpecifier approprié afin d'obtenir l'accès aux opérations cryptographiques [SWS_CRYPT_20099].
Référencer le slot de clé : pour les flux basés sur des clés, l'emplacement mémoire associé est chargé : en lecture seule au moyen de LoadKeySlot[SWS_CRYPT_50004] ou avec des droits d'écriture via LoadWriteableKeySlot[SWS_CRYPT_50005].
Validation des objets et vérification des droits : avant l'exécution, l'application vérifie les types d'objets (CryptoObjectType[SWS_CRYPT_10016]) et les restrictions d'utilisation configurées (AllowedUsageFlags[SWS_CRYPT_10015]), par exemple kAllowDataEncryption[SWS_CRYPT_13101] ou kAllowDataDecryption[SWS_CRYPT_13102] en correspondance avec CryptoTransform[SWS_CRYPT_10019].
Diagramme de séquence : ordre d'appel et d'initialisation pour le chargement de fournisseurs et d'emplacements de clés avec vérification d'erreur consécutive. Sources : [SWS_CRYPT_20099], [SWS_CRYPT_50004], [SWS_CRYPT_19951].
Scénarios d'erreur
Le traitement des erreurs dans ara::crypto repose sur le domaine d'erreur global CryptoErrorDomain[SWS_CRYPT_19952], dont l'énumération CryptoErrc[SWS_CRYPT_10099] définit tous les codes d'erreur spécifiques :
Erreurs d'arguments et de tampons : des arguments non valides conduisent à kInvalidArgument, des identifiants inconnus à kUnknownIdentifier et des combinaisons de paramètres inappropriées à kIncompatibleArguments[SWS_CRYPT_10099]. Si la capacité d'une ReadWriteMemRegion[SWS_CRYPT_10031] ne suffit pas, l'interface signale kInsufficientCapacity[SWS_CRYPT_10099]. En cas de tailles d'entrée incorrectes, kInvalidInputSize survient [SWS_CRYPT_10099].
Violations d'état et de séquence : en cas d'ordre d'appel incorrect, le système signale kInvalidUsageOrder[SWS_CRYPT_10099]. Si un contexte est utilisé avant son initialisation ou qu'une étape de calcul est interrogée avant son achèvement, cela entraîne kUninitializedContext, kProcessingNotStarted ou kProcessingNotFinished[SWS_CRYPT_10099].
Violations de droits et de sécurité : des opérations contraires aux droits déclarés dans AllowedUsageFlags génèrent kUsageViolation[SWS_CRYPT_10099]. Si la vérification d'une balise d'authentification échoue, kAuthTagNotValid est déclenché [SWS_CRYPT_10099].
Erreurs de slots et de mappage : des conteneurs de clés vides ou incompatibles conduisent à kEmptyKeySlot ou kIncompatibleObject[SWS_CRYPT_10099]. Si, lors de LoadCryptoProvider, LoadKeySlot ou LoadWriteableKeySlot, le InstanceSpecifier ne pointe pas vers un PortPrototype modélisé pour le processus actuel, cela est considéré comme ProcessMappingViolation ([SWS_CRYPT_20099], [SWS_CRYPT_50004], [SWS_CRYPT_50005]).
Les instances d'erreur sont générées côté programme via la fonction utilitaire MakeErrorCode et référencent sans exception le CryptoErrorDomain[SWS_CRYPT_19951].
Ce guide se base exclusivement sur les exigences de spécification d'AUTOSAR R25-11.
KI-gestützte Gruppierung auf Basis der Records und Spezifikationsauszüge; keine Gliederung aus der AUTOSAR-Spezifikation.
Diagramme de classes
Abgerundete Rahmen = Namespace- bzw. Klassen-Scopes; hohle Dreieckspfeile = Vererbung (zeigt zur Basisklasse); graue Boxen = namespace-fremde bzw. externe Basisklassen. Klicken öffnet die jeweilige Klassen- bzw. cppreference-Seite.
This factory method shall create or return the existing instance of a specific Crypto Provider.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : b6b49fc6b39dProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction factory LoadCryptoProvider dans l'espace de noms ara::crypto sert de point d'entrée central pour créer une instance d'un fournisseur de services cryptographiques ou pour récupérer une instance déjà existante [SWS_CRYPT_20099]. L'en-tête ara/crypto/common/entry_point.h est requis pour l'intégration [SWS_CRYPT_20099].
Lors de l'appel, les propriétés de paramètres et de retour suivantes s'appliquent [SWS_CRYPT_20099] :
Paramètre d'appel : le paramètre d'entrée iSpecify (type const ara::core::InstanceSpecifier&) identifie le RPortPrototype de type CryptoProviderInterface qui est associé au processus appelant [SWS_CRYPT_20099].
Valeur de retour : en cas d'instanciation réussie, la fonction renvoie un ara::core::Result<cryp::CryptoProvider::Sptr>, qui encapsule un Shared Pointer vers l'objet provider chargé [SWS_CRYPT_20099].
Concurrence : la fonction est déclarée comme noexcept, est considérée comme exception safe et est explicitement spécifiée comme thread-safe, de sorte que les appels depuis des threads parallèles sont autorisés [SWS_CRYPT_20099].
En ce qui concerne le traitement des erreurs, la spécification ne définit aucun code d'erreur standardisé [SWS_CRYPT_20099]. Un échec de l'opération devrait toutefois être représenté sous la forme d'un état d'erreur dans le ara::core::Result renvoyé. Question Q-ad283a067489b0eb (ouverte) De plus, la violation de modélisation ProcessMappingViolation est définie : celle-ci survient lorsque le InstanceSpecifier transmis ne référence pas un PortPrototype valide pour le processus actuel qui soit typé par un CryptoProviderInterface[SWS_CRYPT_20099].
Ce texte a été généré par une IA sur la base de la spécification AUTOSAR R25-11.
ProcessMappingVio- In case InstanceSpecifier does not point to a PortPrototype typed lation by a CryptoProviderInterface modeled for the current process.
Parameter (in)
Parameter
Beschreibung
iSpecify
InstanceSpecifier of the RPortPrototype of type CryptoProvider Interface
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 1ad37ba369f0ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction LoadFormatter dans l'espace de noms ara::crypto sert de fabrique pour créer une instance de Formatter[SWS_CRYPT_50200]. La déclaration est fournie via le fichier d'en-tête ara/crypto/common/formatter.h.
Utilisation et interface : l'appel s'effectue de manière synchrone et ne requiert aucun paramètre d'entrée. En guise de valeur de retour, la fonction renvoie un ara::core::Result<ara::crypto::Formatter::Sptr> qui, en cas de succès, encapsule un pointeur partagé vers l'objet Formatter nouvellement créé [SWS_CRYPT_50200].
Gestion des erreurs : la spécification ne définit aucun code d'erreur standardisé pour LoadFormatter[SWS_CRYPT_50200]. La valeur de retour étant conçue sous forme de ara::core::Result, les erreurs spécifiques à l'implémentation lors de la création de l'objet devraient être transmises via le canal d'erreur de ce type de résultat. Question Q-dd9ac8319a9ad931 (ouverte)
Concurrence et sécurité d'exécution : la fonction est déclarée comme noexcept et spécifiée comme sûre face aux exceptions (exception safe) ainsi que sûre du point de vue des threads (thread-safe) [SWS_CRYPT_50200]. Elle peut donc être appelée en parallèle depuis différents threads sans mesures de synchronisation externes.
Cette note d'utilisation a été générée de manière automatisée et repose sur les exigences du standard AUTOSAR.
Load a read-only key slot. This factory method shall load the information associated with the specified KeySlot into a KeySlot object.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 8366de538e98Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La fonction LoadKeySlot dans l'espace de noms ara::crypto est conçue comme une méthode fabrique afin de charger un slot de clé en lecture seule (read-only key slot) [SWS_CRYPT_50004]. Lors d'un appel synchrone, la méthode charge les métadonnées et informations de clé associées au slot spécifié dans un objet KeySlot correspondant [SWS_CRYPT_50004]. Le fichier d'en-tête ara/crypto/common/entry_point.h sert à l'intégration.
Comme paramètre d'entrée, la fonction reçoit un spécificateur d'instance iSpecify de type const ara::core::InstanceSpecifier&[SWS_CRYPT_50004]. Cet identifiant doit faire référence au RPortPrototype d'un CryptoKeySlotInterface ou d'un CryptoKeySlotClientInterface identifiant de manière unique la clé à charger [SWS_CRYPT_50004].
Comme résultat, la méthode renvoie un ara::core::Result<cryp::KeySlot::Sptr> qui fournit soit un pointeur partagé vers l'objet KeySlot chargé, soit une erreur [SWS_CRYPT_50004]. La spécification ne définit aucun code d'erreur standardisé pour LoadKeySlot[SWS_CRYPT_50004]. Une ProcessMappingViolation est toutefois documentée : celle-ci survient lorsque le InstanceSpecifier transmis ne fait pas référence à un port modélisé pour le processus actuel qui soit typé par un CryptoKeySlotInterface ou un CryptoKeySlotClientInterface[SWS_CRYPT_50004].
Pour l'exécution, la fonction est déclarée comme noexcept et offre une sécurité totale vis-à-vis des exceptions (exception safe) [SWS_CRYPT_50004]. De plus, l'appel est spécifié comme sûr au regard des threads (thread-safe), de sorte qu'un accès concurrent par plusieurs threads est pris en charge [SWS_CRYPT_50004].
Cette note d'utilisation a été générée automatiquement sur la base de la spécification AUTOSAR R25-11.
ProcessMappingVio- In case InstanceSpecifier does not point to a PortPrototype typed lation by a CryptoKeySlotInterface or CryptoKeySlotClientInterface modeled for the current process.
Parameter (in)
Parameter
Beschreibung
iSpecify
instance specifier to the RPortPrototype of a CryptoKeySlot Interface or a CryptoKeySlotClientInterface that identifies the key to be loaded
Load a writeable key slot. This factory method shall load the information associated with the specified KeySlot into a WriteableKeySlot object.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 548256d68415ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction LoadWriteableKeySlot sert de méthode fabrique synchrone pour charger les informations d'un slot de clé spécifié dans un objet cryp::WriteableKeySlot[SWS_CRYPT_50005]. La fonction est définie dans l'espace de noms ara::crypto et mise à disposition via l'en-tête ara/crypto/common/entry_point.h[SWS_CRYPT_50005].
Paramètres :iSpecify (de type const ara::core::InstanceSpecifier&) fait référence au RPortPrototype d'un CryptoKeySlotInterface et identifie ainsi la clé à charger [SWS_CRYPT_50005].
Valeur de retour : un ara::core::Result<cryp::WriteableKeySlot::Sptr> qui contient soit le KeySlot chargé sous forme de pointeur partagé, soit un objet d'erreur [SWS_CRYPT_50005].
Sémantique : l'appel a lieu de manière synchrone directement lors de l'exécution [SWS_CRYPT_50005].
Gestion des erreurs et conditions limites
Aucun code d'erreur standardisé n'est spécifié pour cette fonction [SWS_CRYPT_50005]. Les conditions d'erreur survenant devraient vraisemblablement être transmises via le ara::core::Result renvoyé. Question Q-e2f8966bf78b1569 (ouverte) Une erreur d'architecture ou de configuration entraîne une ProcessMappingViolation si le InstanceSpecifier transmis ne fait pas référence à un PortPrototype modélisé pour le processus actuel qui soit typé par un CryptoKeySlotInterface[SWS_CRYPT_50005].
Concurrence et interaction
La fonction est déclarée comme sûre au regard des threads (thread-safe) et sans émission d'exceptions (exception safe) avec garantie noexcept[SWS_CRYPT_50005]. Elle répond à l'exigence cryptographique de niveau supérieur [RS_CRYPTO_02004] et constitue le point d'accès central pour mettre à disposition des slots de clé accessibles en écriture dans le processus [SWS_CRYPT_50005].
Cette note d'utilisation a été générée par une IA sur la base de la spécification AUTOSAR R25-11.
ProcessMappingVio- In case InstanceSpecifier does not point to a PortPrototype typed lation by a CryptoKeySlotInterface modeled for the current process.
Parameter (in)
Parameter
Beschreibung
iSpecify
instance specifier to the RPortPrototype of a CryptoKeySlot Interface that identifies the key to be loaded
This factory method shall create or return the existing instance of the singleton X.509 Provider.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 70f8a61e4c9eProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La fonction LoadX509Provider dans l'espace de noms ara::crypto sert de méthode factory pour créer l'instance singleton du fournisseur X.509 ou pour récupérer l'instance déjà existante [SWS_CRYPT_40099]. Pour l'appel, le fichier d'en-tête ara/crypto/common/entry_point.h doit être inclus [SWS_CRYPT_40099]. L'appel s'effectue de manière synchrone et ne prend aucun paramètre d'entrée. Comme valeur de retour, la fonction fournit un ara::core::Result<ara::crypto::x509::X509Provider::Sptr> qui met à disposition un Shared Pointer vers l'instance chargée du fournisseur X.509 [SWS_CRYPT_40099].
Gestion des erreurs
Aucun code d'erreur standardisé n'est défini dans la spécification pour LoadX509Provider[SWS_CRYPT_40099]. La fonction est déclarée avec noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CRYPT_40099]. Interprétation : le résultat étant encapsulé via le type ara::core::Result, des états d'erreur spécifiques au système lors de l'initialisation du fournisseur devraient être transmis à l'appelant via cet objet Result. Question Q-c187f4f152ccc89f (ouverte)
Concurrence et interaction
Conformément à la spécification, LoadX509Provider est classé comme thread-safe [SWS_CRYPT_40099]. L'appel peut ainsi être effectué en parallèle depuis plusieurs threads sans mesures de synchronisation supplémentaires afin d'obtenir une référence vers la même instance singleton. Sur le plan fonctionnel, la fonction met en œuvre les exigences de niveau supérieur RS_CRYPTO_02306 et RS_CRYPTO_02301[SWS_CRYPT_40099].
Ce texte a été généré par un système d'IA sur la base de la spécification.
gemini-3.8-flash-low· 2026-10-13 · Original allemand