Dient als zentrale Factory zur Erzeugung und Verwaltung kryptografischer Kontexte, Algorithmen und Schlüsselobjekte.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 0bf253450f85Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Dient als zentrale Factory zur Erzeugung und Verwaltung kryptografischer Kontexte, Algorithmen und Schlüsselobjekte.
Die Klasse dient als zentrale Factory zur Bereitstellung kryptografischer Primitive sowie zur Erzeugung und Verwaltung von kryptografischen Schlüsseln und Kontexten ([SWS_CRYPT_20742], [SWS_CRYPT_20721]). Instanzen sind weder kopier- noch verschiebbar und werden über geteilte Zeiger verwaltet ([SWS_CRYPT_20701], [SWS_CRYPT_41005]). Fehler wie inkompatible Algorithmen oder erschöpfte Ressourcen werden typsicher über ara::core::Result zurückgegeben ([SWS_CRYPT_30098]).
Kontext
Die Klasse ara::crypto::cryp::CryptoProvider bildet die zentrale Schnittstelle zur Bereitstellung kryptografischer Operationen und Algorithmen im AUTOSAR-Adaptive-Stack. Sie bündelt als Abstraktionsschicht konkrete Implementierungen kryptografischer Primitive sowie den Zugriff auf Schlüssel und Speicherstrukturen. In einer typischen Systemarchitektur fungiert der CryptoProvider als Vermittler und Factory zwischen der Anwendungslogik, persistenten Schlüsselspeichern und spezialisierten Verarbeitungs-Kontexten. Anwendungen fordern über den Provider spezialisierte Kontexte für symmetrische Verschlüsselung ([SWS_CRYPT_20742]), asymmetrische Verschlüsselung ([SWS_CRYPT_20750], [SWS_CRYPT_20751]), digitale Signaturen ([SWS_CRYPT_20756], [SWS_CRYPT_20757]), Hashfunktionen ([SWS_CRYPT_20747]), Nachrichtenauthentifizierung ([SWS_CRYPT_20746]) oder Schlüsselaustauschverfahren ([SWS_CRYPT_20758], [SWS_CRYPT_20752]) an. Zugleich interagiert der Provider mit zugrundeliegenden Key-Slots, um gespeicherte Schlüssel zu instanziieren ([SWS_CRYPT_20762], [SWS_CRYPT_20764]).
Instanzen von CryptoProvider besitzen strikte Semantiken hinsichtlich Kopier- und Verschiebeoperationen: Sowohl der Copy-Konstruktor ([SWS_CRYPT_41005]) und der Move-Konstruktor ([SWS_CRYPT_41006]) als auch die entsprechenden Zuweisungsoperatoren ([SWS_CRYPT_30216], [SWS_CRYPT_30217]) sind explizit gelöscht (delete). Der Lebenszyklus einer Instanz wird daher üblicherweise über Referenzen oder geteilte Eigentümerschaft gesteuert, wofür der Typalias CryptoProvider::Sptr auf Basis von std::shared_ptr definiert ist ([SWS_CRYPT_20701]). Die Bereinigung erfolgt über den virtuellen Standard-Destruktor ([SWS_CRYPT_20710]). Sämtliche Schnittstellenmethoden des Providers sind als ausnahmesicher (exception safe) und threadsicher (thread-safe) spezifiziert, wodurch ein nebenläufiger Zugriff aus mehreren Threads ohne externe Synchronisation auf Provider-Ebene zulässig ist.
Nutzungspfad
Ein typischer Nutzungspfad umfasst die Schlüsselbereitstellung, die Instanziierung des passenden Kryptokontexts und die anschließende Durchführung der Transformationen. Zunächst erzeugt oder importiert die Anwendung das benötigte Schlüsselmaterial. Hierzu bietet CryptoProvider Methoden wie GenerateSymmetricKey ([SWS_CRYPT_20721]), GeneratePrivateKey ([SWS_CRYPT_20722]), ImportPublicKey ([SWS_CRYPT_20732]) oder das Laden aus einem vorhandenen Key-Slot ([SWS_CRYPT_20762], [SWS_CRYPT_20763]). Anhand des Algorithmus können Standardberechtigungen über GetDefaultAllowedUsage ermittelt werden ([SWS_CRYPT_20955]). Im nächsten Schritt erzeugt die Anwendung über die Factory-Methoden den jeweiligen Kontext, beispielsweise einen AuthCipherCtx ([SWS_CRYPT_20745]) oder einen SignerPrivateCtx ([SWS_CRYPT_20756]). Ergänzend stellt der Provider Zufallsdaten über GenerateRandomData ([SWS_CRYPT_30098]) oder einen monoton wachsenden Zählerwert über GetSecureCounter ([SWS_CRYPT_20098]) bereit. Für den gesicherten Austausch kann Schlüsselmaterial mittels ExportSecuredKey geschützt exportiert werden ([SWS_CRYPT_20728]).
Sequenzdiagramm: Ablauf zur Schlüsselgenerierung und Erzeugung eines Authenticated-Cipher-Kontexts. Quellen: [SWS_CRYPT_20721], [SWS_CRYPT_20745].
Fehlerszenarien
Methoden des CryptoProvider melden Fehler über den Rückgabetyp ara::core::Result mit Werten aus ara::crypto::CryptoErrc. Bei fehlschlagenden Operationen gilt die Rollback-Semantik. Zu den wesentlichen Fehlerszenarien gehören:
Ungültige oder inkompatible Parameter: Wird ein nicht unterstützter Algorithmus-Bezeichner übergeben, liefern Kontext- und Schlüsselerzeugungsmethoden CryptoErrc::kUnknownIdentifier ([SWS_CRYPT_20741], [SWS_CRYPT_20742], [SWS_CRYPT_20721]). Entspricht der Algorithmus nicht dem erwarteten Primitiv (z. B. asymmetrischer Algorithmus bei Hashfunktion-Anforderung) oder passen Nutzungsflags nicht zur Konfiguration, tritt CryptoErrc::kInvalidArgument bzw. CryptoErrc::kIncompatibleArguments auf ([SWS_CRYPT_20747], [SWS_CRYPT_20722], [SWS_CRYPT_50132]).
Schlüsselspeicher- und Formatfehler: Beim Laden über Key-Slots führt ein unbestückter Slot zu CryptoErrc::kEmptyKeySlot, während fremde oder falsche Schlüsseltypen CryptoErrc::kIncompatibleObject auslösen ([SWS_CRYPT_20762], [SWS_CRYPT_20764]). Fehlerhafte Serialisierungsformate führen zu CryptoErrc::kUnsupportedFormat ([SWS_CRYPT_50014], [SWS_CRYPT_20732]).
Ressourcen- und Kapazitätsengpässe: Ist der Zufallszahlengenerator temporär erschöpft oder eine Hardware-Ressource blockiert, wird CryptoErrc::kBusyResource zurückgegeben ([SWS_CRYPT_30098], [SWS_CRYPT_20721], [SWS_CRYPT_20098]). Bei unzureichend dimensionierten Zielpuffern für Identifikationsdaten oder Schlüsselexporte meldet die Schnittstelle CryptoErrc::kInsufficientCapacity ([SWS_CRYPT_50015], [SWS_CRYPT_20728]).
Nicht unterstützte Features: Werden optionale Funktionen wie Provider-Identifikation, Secure Counter oder Standard-RNG von einer konkreten Provider-Implementierung nicht unterstützt, wird der Fehler CryptoErrc::kUnsupported gemeldet ([SWS_CRYPT_50015], [SWS_CRYPT_20098], [SWS_CRYPT_30098]).
Dieser Leitfaden basiert ausschließlich auf der Schnittstellendefinition von ara::crypto::cryp::CryptoProvider für AUTOSAR R25-11.
The interface shall format the data referenced by the specified key, securely wrap this payload and serialize the secured payload into the provided output buffer. The format shall be specified implicitly by the AlgId. The formatted payload shall be wrapped according to the specified algId using the kek; if kek is not provided, ExportSecuredKey shall apply a key-encryption-key implictly defined by the algId or the default key-encryption-key of the CryptoProvider.
Generate a new public/private key pair and return the private key. The public key can be retrieved via the function PrivateKey::GetPublicKey() The allowed usage flags of the Public Key are set based on the allowed usage of the PrivateKey: • kAllowDataDecryption --> kAllowDataEncryption • kAllowSigGeneration --> kAllowSigVerification • kAllowKeyAgreement --> kAllowKeyAgreement • kAllowKeyUnwrapping --> kAllowKeyWrapping Additionally, the allowed usage: • kAllowPlaintextExport • kAllowPersist are set for the public key.
Get a CryptoProvider specific default set of allowedUsages for the provided AlgId. The returned allowedUsages shall not contain kAllowPlaintextExport, kAllowPersist and kAllowSecuredExport.
Get the current value of the secure counter of this CryptoProvider. The current counter value is guaranteed to be stricly larger than any previously returned counter value.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 11ce33c6da44Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode CreateAuthCipherCtx dient dem Erzeugen eines Kontextes für symmetrische authentifizierte Chiffrierung ([SWS_CRYPT_20745]). Sie ist als rein virtuelle Schnittstelle in der Klasse ara::crypto::cryp::CryptoProvider definiert und über die Header-Datei ara/crypto/cryp/crypto_provider.h einzubinden ([SWS_CRYPT_20745]).
Verwendung und Semantik
Als Eingabeparameter wird algId übergeben, welcher den Ziel-Kryptoalgorithmus identifiziert ([SWS_CRYPT_20745]). Die Funktion arbeitet synchron und wirft keine Exceptions (noexcept) ([SWS_CRYPT_20745]). Bei erfolgreicher Ausführung liefert sie ein ara::core::Result mit einem Smart Pointer auf die erzeugte Instanz AuthCipherCtx::Sptr zurück ([SWS_CRYPT_20745]).
Fehlerbehandlung
Im Fehlerfall wird ein entsprechender Fehlercode im ara::core::Result mit Rollback-Semantik zurückgegeben ([SWS_CRYPT_20745]):
ara::crypto::CryptoErrc::kInvalidArgument: Wenn algId keinen Algorithmus für eine symmetrische authentifizierte Stromchiffre spezifiziert ([SWS_CRYPT_20745]).
ara::crypto::CryptoErrc::kUnknownIdentifier: Wenn für algId ein nicht unterstützter Wert übergeben wurde ([SWS_CRYPT_20745]).
Nebenläufigkeit
Der Aufruf von CreateAuthCipherCtx ist threadsicher (thread-safe) und als ausnahmesicher (exception safe) spezifiziert ([SWS_CRYPT_20745]).
Dieser Text wurde automatisch generiert. Alle fachlichen Aussagen sind durch Spezifikationsbelege gestützt.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 7d14bb93ecbaHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode CreateDecryptorPrivateCtx der Schnittstelle ara::crypto::cryp::CryptoProvider dient der Erzeugung eines Kontexts für die asymmetrische Entschlüsselung unter Verwendung eines privaten Schlüssels gemäß [SWS_CRYPT_20751]. Als Eingabeparameter erwartet die Funktion algId, welcher den Bezeichner des gewünschten asymmetrischen Verschlüsselungs- bzw. Entschlüsselungsalgorithmus festlegt. Interpretation: Der Aufruf dürfte synchron ausgeführt werden, da die Signatur direkt ein ara::core::Result zurückliefert, das im Erfolgsfall einen Smart Pointer auf den erstellten Kontext (DecryptorPrivateCtx::Sptr) enthält [SWS_CRYPT_20751]. Frage Q-45d1c4a1b2133f4c (offen)
Fehlerbehandlung
Kann der Kontext nicht erzeugt werden, wird der Fehler im zurückgegebenen ara::core::Result transportiert. Falls für den Parameter algId ein nicht unterstützter Wert übergeben wurde, resultiert dies spezifisch im Fehlercode ara::crypto::CryptoErrc::kUnknownIdentifier mit Rollback-Semantik [SWS_CRYPT_20751].
Nebenläufigkeit und Einschränkungen
Die Funktion ist als noexcept definiert und gewährleistet Exception-Sicherheit (exception safe) [SWS_CRYPT_20751]. Für den gleichzeitigen Zugriff aus mehreren Threads ist die Methode als thread-safe spezifiziert [SWS_CRYPT_20751]. Da die Signatur im Header ara/crypto/cryp/crypto_provider.h als rein virtuelle Methode deklariert ist, obliegt die konkrete Ausprägung der jeweiligen Provider-Implementierung [SWS_CRYPT_20751].
Dieser Nutzungshinweis wurde automatisch generiert und basiert ausschließlich auf den Spezifikationsdaten des AUTOSAR-Adaptive-Releases R25-11.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: f47db9d84d9aHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die rein virtuelle Schnittstellenmethode CreateEncryptorPublicCtx gehört zur Klasse ara::crypto::cryp::CryptoProvider und wird über die Header-Datei ara/crypto/cryp/crypto_provider.h deklariert [SWS_CRYPT_20750]. Ihre Aufgabe besteht darin, einen neuen Kontext für asymmetrische Verschlüsselungsoperationen mit einem öffentlichen Schlüssel zu instanziieren [SWS_CRYPT_20750].
Verwendung: Der Aufruf erfolgt synchron unter Angabe des Parameters algId vom Typ AlgId, welcher den Bezeichner des gewünschten asymmetrischen Verschlüsselungs- bzw. Entschlüsselungsalgorithmus festlegt [SWS_CRYPT_20750]. Die Methode liefert das Ergebnis in einem ara::core::Result zurück, das im Erfolgsfall einen Smart Pointer vom Typ EncryptorPublicCtx::Sptr auf den erzeugten Kontext bereitstellt [SWS_CRYPT_20750].
Fehlerbehandlung: Sofern das Argument algId einen nicht unterstützten Algorithmenwert enthält, schlägt der Aufruf fehl und liefert im ara::core::Result den Fehlercode ara::crypto::CryptoErrc::kUnknownIdentifier[SWS_CRYPT_20750]. Für diesen Fehlerfall ist eine explizite Rollback-Semantik spezifiziert [SWS_CRYPT_20750].
Nebenläufigkeit und Ausnahmesicherheit: Die Schnittstelle ist als noexcept deklariert, gilt als ausnahmesicher (exception safe) und ist ausdrücklich als threadsicher (thread-safe) spezifiziert [SWS_CRYPT_20750].
Dieser Text wurde durch eine KI auf Basis der Spezifikation erstellt.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: d5d380ddf0c0Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode CreateHashFunctionCtx dient der Instanziierung eines kryptografischen Hash-Kontexts ([SWS_CRYPT_20747]). Sie wird als rein virtuelle Schnittstelle der Klasse ara::crypto::cryp::CryptoProvider über den Header ara/crypto/cryp/crypto_provider.h bereitgestellt.
Verwendung und Parameter
Der Aufruf erfolgt synchron und erwartet als Eingabeparameter algId (vom Typ AlgId), welcher den gewünschten kryptografischen Algorithmus identifiziert ([SWS_CRYPT_20747]). Als Rückgabewert liefert die Funktion ein ara::core::Result<HashFunctionCtx::Sptr>, das im Erfolgsfall einen Smart Pointer auf den erzeugten Kontext enthält.
Fehlerbehandlung
Schlägt die Erzeugung fehl, enthält das ara::core::Result einen entsprechenden Fehlercode mit Rollback-Semantik ([SWS_CRYPT_20747]):
ara::crypto::CryptoErrc::kInvalidArgument: Wird zurückgegeben, wenn die übergebene algId für einen anderen Algorithmentyp als eine Hash-Funktion spezifiziert ist ([SWS_CRYPT_20747]).
ara::crypto::CryptoErrc::kUnknownIdentifier: Tritt auf, falls für algId ein nicht unterstützter Bezeichner übergeben wurde ([SWS_CRYPT_20747]).
Nebenläufigkeit und Einschränkungen
Die Funktion ist als noexcept deklariert und als ausnahmesicher („exception safe“) spezifiziert ([SWS_CRYPT_20747]). Zudem ist der Aufruf threadsicher („thread-safe“), sodass gleichzeitige Aufrufe aus mehreren Threads auf derselben Instanz von CryptoProvider zulässig sind ([SWS_CRYPT_20747]).
Dieser Text wurde von einer KI auf Basis der Spezifikation R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: f0aaacbed75dHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode CreateKeyAgreementPrivateCtx der Klasse ara::crypto::cryp::CryptoProvider dient der Erstellung eines privaten Schlüsselkontexts für Schlüsselvereinbarungen (KeyAgreementPrivateCtx) gemäß [SWS_CRYPT_20758]. Die Deklaration wird über die Header-Datei #include "ara/crypto/cryp/crypto_provider.h" bereitgestellt.
Verwendung und Aufruf
Als Übergabeparameter erwartet die synchrone Methode den Bezeichner algId vom Typ AlgId, welcher den gewünschten Krypto-Algorithmus für das Key-Agreement spezifiziert. Als Rückgabewert liefert die Funktion ein ara::core::Result<KeyAgreementPrivateCtx::Sptr>, das im Erfolgsfall einen Smart Pointer auf die neu erzeugte Kontext-Instanz kapselt [SWS_CRYPT_20758].
Fehlerbehandlung
Schlägt die Instanziierung fehl, enthält das zurückgegebene ara::core::Result einen Fehlercode mit Rollback-Semantik [SWS_CRYPT_20758]:
ara::crypto::CryptoErrc::kInvalidArgument: Tritt auf, wenn das Argument algId einen Krypto-Algorithmus angibt, der sich von Schlüsselvereinbarungsverfahren unterscheidet.
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird zurückgegeben, falls der Bezeichner algId einen nicht unterstützten Wert aufweist.
Nebenläufigkeit und Sicherheit
Die Schnittstelle ist als noexcept deklariert und als ausnahmesicher (exception safe) definiert. Zudem ist der Aufruf als threadsicher (thread-safe) spezifiziert, sodass gleichzeitige Aufrufe auf derselben Instanz von CryptoProvider zulässig sind [SWS_CRYPT_20758].
Dieser Nutzungshinweis wurde automatisiert auf Basis der Spezifikation von AUTOSAR R25-11 generiert.
Create a key-decapsulator private context of a Key Encapsulation Mechanism (KEM).
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 29715a46f6b0Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode CreateKeyDecapsulatorPrivateCtx der Schnittstelle ara::crypto::cryp::CryptoProvider dient der Erstellung eines privaten Kontextes zur Schlüssel-Dekapselung für einen Key Encapsulation Mechanism (KEM) [SWS_CRYPT_20753]. Als Eingabeparameter erwartet sie algId vom Typ AlgId, welcher den gewünschten KEM-Kryptoalgorithmus identifiziert [SWS_CRYPT_20753]. Die Funktion arbeitet synchron und liefert das Ergebnis in einem ara::core::Result<KeyDecapsulatorPrivateCtx::Sptr> zurück, das im Erfolgsfall einen Smart Pointer auf den neu instanziierten Kontext kapselt [SWS_CRYPT_20753].
Fehlerbehandlung
Tritt bei der Kontexterzeugung ein Fehler auf, wird dieser über das ara::core::Result mit Rollback-Semantik gemeldet [SWS_CRYPT_20753]:
ara::crypto::CryptoErrc::kInvalidArgument: Das Argument algId spezifiziert einen Kryptoalgorithmus, bei dem es sich nicht um ein asymmetrisches KEM-Verfahren handelt [SWS_CRYPT_20753].
ara::crypto::CryptoErrc::kUnknownIdentifier: Das Argument algId weist einen nicht unterstützten Wert auf [SWS_CRYPT_20753].
Nebenläufigkeit und Ausführungssicherheit
Die Schnittstelle ist als noexcept deklariert und als ausnahmesicher (exception safe) spezifiziert [SWS_CRYPT_20753]. Zudem ist die Ausführung threadsicher (thread-safe) ausgelegt [SWS_CRYPT_20753].
Dieser Nutzungshinweis basiert auf der Spezifikation AUTOSAR Adaptive R25-11.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: a0b8a7f1dfa2Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode CreateKeyDerivationFunctionCtx der Klasse ara::crypto::cryp::CryptoProvider dient der Erstellung eines Ausführungskontexts für Schlüsselableitungsfunktionen ([SWS_CRYPT_20748]). Als Eingabeparameter wird der Bezeichner algId vom Typ AlgId übergeben, welcher den gewünschten kryptografischen Zielalgorithmus festlegt. Der synchrone Aufruf liefert ein ara::core::Result zurück, das bei erfolgreicher Ausführung einen Smart Pointer auf den erzeugten Kontext (KeyDerivationFunctionCtx::Sptr) bereitstellt ([SWS_CRYPT_20748]).
Tritt bei der Instanziierung ein Fehler auf, wird das Ergebnis mit einem entsprechenden Fehlercode unter Rollback-Semantik zurückgegeben ([SWS_CRYPT_20748]):
ara::crypto::CryptoErrc::kInvalidArgument: Das Argument algId spezifiziert einen kryptografischen Algorithmus, der keine Schlüsselableitungsfunktion darstellt ([SWS_CRYPT_20748]).
ara::crypto::CryptoErrc::kUnknownIdentifier: Der übergebene Bezeichner algId besitzt einen nicht unterstützten Wert ([SWS_CRYPT_20748]).
Die Schnittstelle ist als reine virtuelle Funktion deklariert, als noexcept ausgewiesen und verbindlich als thread-safe sowie exception safe eingestuft ([SWS_CRYPT_20748]). Die Einbindung erfolgt über die Header-Datei #include "ara/crypto/cryp/crypto_provider.h". Die Funktion adressiert die übergeordneten Anforderungen [RS_CRYPTO_02103] und [RS_AP_00144].
Dieser Nutzungshinweis wurde automatisiert von einer KI generiert und basiert auf den Spezifikationen der AUTOSAR-Adaptive-Plattform R25-11.
Create a key-encapsulator public context of a Key Encapsulation Mechanism (KEM).
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: efe36f596de1Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode CreateKeyEncapsulatorPublicCtx der Schnittstelle ara::crypto::cryp::CryptoProvider dient der Erstellung eines öffentlichen Kontextes für einen Key Encapsulation Mechanism (KEM) [SWS_CRYPT_20752]. Hierzu ist die Header-Datei #include "ara/crypto/cryp/crypto_provider.h" einzubinden [SWS_CRYPT_20752]. Der Aufruf erfolgt synchron: Als Eingabeparameter wird algId übergeben, welcher den Ziel-Kryptoalgorithmus des KEM spezifiziert. Bei erfolgreicher Ausführung liefert die Methode einen Smart Pointer auf den erzeugten Kontext (KeyEncapsulatorPublicCtx::Sptr), gekapselt in einem ara::core::Result, zurück [SWS_CRYPT_20752].
Fehlerbehandlung
Tritt während der Erstellung ein Fehler auf, greift eine Rollback-Semantik und das ara::core::Result enthält einen spezifischen Fehlercode aus ara::crypto::CryptoErrc[SWS_CRYPT_20752]:
ara::crypto::CryptoErrc::kInvalidArgument: Wird zurückgegeben, wenn das Argument algId einen kryptografischen Algorithmus benennt, der kein asymmetrischer KEM ist [SWS_CRYPT_20752].
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird gemeldet, falls das Argument algId einen nicht unterstützten Wert aufweist [SWS_CRYPT_20752].
Nebenläufigkeit und Sicherheit
Die Schnittstellenfunktion ist mit noexcept deklariert und als ausnahmesicher (exception safe) sowie threadsicher (thread-safe) klassifiziert [SWS_CRYPT_20752]. Sie kann somit sicher aus nebenläufigen Kontexten ohne externe Synchronisation aufgerufen werden [SWS_CRYPT_20752].
Dieser Nutzungshinweis basiert auf der Spezifikation AUTOSAR Adaptive R25-11.
Create a symmetric message authentication code context.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 9f61171ea583Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die rein virtuelle Methode CreateMessageAuthnCodeCtx der Schnittstelle ara::crypto::cryp::CryptoProvider erfordert die Header-Datei ara/crypto/cryp/crypto_provider.h und dient der synchronen Erzeugung eines Kontextes für symmetrische Message Authentication Codes [SWS_CRYPT_20746]. Als Eingabewert nimmt die Funktion den Parameter algId vom Typ AlgId entgegen, welcher den Ziel-Kryptoalgorithmus spezifiziert [SWS_CRYPT_20746]. Bei erfolgreicher Ausführung liefert die Methode ein ara::core::Result<MessageAuthnCodeCtx::Sptr> zurück, welches einen Smart-Pointer auf die neu instanziierte Kontext-Instanz kapselt [SWS_CRYPT_20746].
Fehlerbehandlung
Im Fehlerfall stellt das zurückgegebene Result-Objekt spezifische Fehlercodes mit Rollback-Semantik bereit [SWS_CRYPT_20746]:
ara::crypto::CryptoErrc::kInvalidArgument: Das Argument algId spezifiziert einen kryptografischen Algorithmus, der kein symmetrischer Message Authentication Code ist [SWS_CRYPT_20746].
ara::crypto::CryptoErrc::kUnknownIdentifier: Für das Argument algId wurde ein unbekannter oder nicht unterstützter Bezeichner übergeben [SWS_CRYPT_20746].
Nebenläufigkeit und Ausführungssicherheit
Die Schnittstelle ist mit dem Spezifizierer noexcept versehen und garantiert vollständige Ausnahmesicherheit (exception safe) [SWS_CRYPT_20746]. Des Weiteren ist die Funktion explizit als threadsicher (thread-safe) spezifiziert, sodass Aufrufe parallel und ohne externe Synchronisation aus nebenläufigen Threads erfolgen können [SWS_CRYPT_20746].
Dieser Nutzungshinweis wurde automatisiert auf Basis der Spezifikation generiert.
The interface shall create a protected key import context.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: cc2e3e31c614Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Schnittstelle CreateProtectedKeyImportCtx der Klasse ara::crypto::cryp::CryptoProvider (definiert in ara/crypto/cryp/crypto_provider.h) dient der synchronen Erstellung eines Kontextes für den geschützten Schlüsselimport ([SWS_CRYPT_50017]). Über den Eingabeparameter algId wird der Bezeichner des gewünschten Wrapping-Algorithmus übergeben ([SWS_CRYPT_50017]). Bei erfolgreicher Instanziierung liefert die Methode ein ara::core::Result zurück, das einen Smart Pointer ProtectedKeyImportCtx::Sptr auf den erzeugten Kontext bereitstellt ([SWS_CRYPT_50017]).
Fehlerbehandlung
Schlägt die Erstellung fehl, gibt die Methode im ara::core::Result einen Fehlercode mit Rollback-Semantik zurück ([SWS_CRYPT_50017]):
ara::crypto::CryptoErrc::kInvalidArgument: Tritt auf, wenn der durch algId spezifizierte Kryptoalgorithmus vom CryptoProvider nicht für das Wrapping unterstützt wird ([SWS_CRYPT_50017]).
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird gemeldet, wenn das Argument algId einen unbekannten oder nicht unterstützten Bezeichnerwert enthält ([SWS_CRYPT_50017]).
Nebenläufigkeit und Einschränkungen
Die rein virtuelle Methode ist als noexcept deklariert, bietet Exception-Sicherheit und ist explizit als threadsicher (thread-safe) spezifiziert ([SWS_CRYPT_50017]). Sie kann somit ohne externe Synchronisation parallel aus mehreren Threads aufgerufen werden ([SWS_CRYPT_50017]).
Dieser Nutzungshinweis wurde automatisiert auf Basis der Spezifikation von AUTOSAR Adaptive R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 64bbceaa10dfHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode CreateRandomGeneratorCtx dient der Erzeugung eines Kontexts für Zufallszahlengeneratoren (Random Number Generator, RNG) innerhalb der Klasse ara::crypto::cryp::CryptoProvider[SWS_CRYPT_20741].
Verwendung und Aufrufkontext
Die Funktion wird synchron aufgerufen und erfordert die Header-Datei ara/crypto/cryp/crypto_provider.h[SWS_CRYPT_20741]:
Parameter: Übergeben wird algId vom Typ AlgId, welcher den gewünschten RNG-Algorithmus identifiziert. Wird keine spezifische algId angegeben, liefert die Methode den Standard-RNG [SWS_CRYPT_20741].
Rückgabewert: Ein ara::core::Result<RandomGeneratorCtx::Sptr>, das im Erfolgsfall einen Shared Pointer auf die erzeugte Instanz von RandomGeneratorCtx enthält [SWS_CRYPT_20741].
Fehlerbehandlung
Die Methode wirft keine Exceptions (noexcept) und ist als ausnahmesicher spezifiziert [SWS_CRYPT_20741]. Schlägt die Operation fehl, liefert das ara::core::Result einen Fehlercode:
ara::crypto::CryptoErrc::kUnknownIdentifier: Tritt auf, wenn das Argument algId einen nicht unterstützten Wert aufweist (mit Rollback-Semantik) [SWS_CRYPT_20741].
Nebenläufigkeit und Einschränkungen
Die Methode ist als threadsicher (thread-safe) klassifiziert, sodass parallele Aufrufe über dieselbe Instanz des CryptoProvider zulässig sind [SWS_CRYPT_20741].
Dieser Nutzungshinweis wurde automatisch erstellt und basiert ausschließlich auf den Spezifikationsdaten von AUTOSAR Adaptive R25-11.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: b425000c991dHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode CreateSignerPrivateCtx der Klasse ara::crypto::cryp::CryptoProvider dient der Erzeugung eines Kontexts für Signaturoperationen mit einem privaten Schlüssel ([SWS_CRYPT_20756]).
Verwendung und Parameter: Der Aufruf erfordert das Einbinden der Header-Datei ara/crypto/cryp/crypto_provider.h. Über den Eingabeparameter algId wird der kryptografische Ziel-Signaturalgorithmus spezifiziert. Im Erfolgsfall liefert die Funktion über den Rückgabetyp ara::core::Result<SignerPrivateCtx::Sptr> einen Smart Pointer auf die erzeugte Kontextinstanz ([SWS_CRYPT_20756]). Interpretation: Da die Methode direkt ein ara::core::Result zurückgibt, dürfte der Aufruf synchron ausgeführt werden. Frage Q-8480f3cf5cef5f49 (offen)
Nebenläufigkeit und Sicherheit: Die Methode ist als threadsicher (thread-safe) sowie ausnahmesicher (exception safe) spezifiziert und mit noexcept deklariert ([SWS_CRYPT_20756]). Sie kann somit ohne zusätzliche Synchronisation aus nebenläufigen Kontexten aufgerufen werden.
Fehlerbehandlung: Im Fehlerfall liefert das Ergebnis einen Fehlercode vom Typ ara::crypto::CryptoErrc mit Rollback-Semantik ([SWS_CRYPT_20756]):
ara::crypto::CryptoErrc::kInvalidArgument: Tritt auf, wenn das Argument algId einen kryptografischen Algorithmus angibt, der sich von einer Signatur mit privatem Schlüssel unterscheidet ([SWS_CRYPT_20756]).
ara::crypto::CryptoErrc::kUnknownIdentifier: Tritt auf, wenn algId einen unbekannten oder nicht unterstützten Wert enthält ([SWS_CRYPT_20756]).
Dieser Text wurde von einer KI generiert und dient als Orientierungshilfe. Maßgeblich ist die AUTOSAR-Spezifikation.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: e2de1e3ea197Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die virtuelle Methode CreateSymmetricCipherCtx der Schnittstelle ara::crypto::cryp::CryptoProvider dient der Erzeugung eines Kontexts für symmetrische Chiffrieroperationen ([SWS_CRYPT_20742]). Sie wird über die Header-Datei #include "ara/crypto/cryp/crypto_provider.h" eingebunden ([SWS_CRYPT_20742]).
Als Eingabeparameter erwartet die Funktion algId vom Typ AlgId, welcher die Kennung des gewünschten kryptografischen Zielalgorithmus angibt ([SWS_CRYPT_20742]). Der Aufruf erfolgt synchron und liefert als Ergebnis ein ara::core::Result<SymmetricCipherCtx::Sptr> zurück, das im Erfolgsfall einen Smart Pointer auf die neu instanziierte Kontextinstanz bereitstellt ([SWS_CRYPT_20742]).
Fehlerbehandlung
Schlägt die Erzeugung fehl, enthält das zurückgegebene ara::core::Result einen entsprechenden Fehlercode ([SWS_CRYPT_20742]):
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird mit Rollback-Semantik gemeldet, falls der übergebene Wert für algId einen nicht unterstützten Algorithmus referenziert ([SWS_CRYPT_20742]).
Nebenläufigkeit und Einschränkungen
Die Funktion ist als noexcept deklariert und explizit als ausnahmesicher (exception safe) spezifiziert ([SWS_CRYPT_20742]). Zudem ist der Aufruf thread-sicher (thread-safe), sodass parallele Kontext-Erzeugungen über dieselbe CryptoProvider-Instanz zulässig sind ([SWS_CRYPT_20742]).
Dieser Nutzungshinweis wurde automatisch erstellt. Alle Angaben basieren ausschließlich auf dem AUTOSAR-Spezifikationsstand R25-11.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 81927eb57ee6Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode CreateSymmetricKeyWrapperCtx der Klasse ara::crypto::cryp::CryptoProvider dient der Erzeugung eines Kontexts für symmetrische Key-Wrap-Algorithmen ([SWS_CRYPT_20743]). Als Eingabeparameter wird algId übergeben, welcher den Ziel-Kryptoalgorithmus eindeutig identifiziert ([SWS_CRYPT_20743]). Der Aufruf ist synchron und liefert im Erfolgsfall ein ara::core::Result zurück, das einen Smart Pointer auf den erstellten Kontext (SymmetricKeyWrapperCtx::Sptr) kapselt ([SWS_CRYPT_20743]).
Fehlerbehandlung
Schlägt die Erstellung fehl, gibt die Funktion das Fehlerobjekt innerhalb des ara::core::Result zurück ([SWS_CRYPT_20743]):
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird gemeldet, wenn das Argument algId einen nicht unterstützten Wert aufweist; dabei greifen Rollback-Semantiken ([SWS_CRYPT_20743]).
Nebenläufigkeit und Einschränkungen
Die Schnittstelle ist als noexcept deklariert, gilt als ausnahmesicher (exception safe) und ist thread-safe ([SWS_CRYPT_20743]). Sie kann somit sicher aus nebenläufigen Kontexten aufgerufen werden, sofern die bereitgestellte algId vom zugrunde liegenden CryptoProvider unterstützt wird ([SWS_CRYPT_20743]).
Dieser Nutzungshinweis wurde automatisch generiert und basiert ausschließlich auf den Spezifikationsdaten aus AUTOSAR R25-11.
Create a signature verification public key context.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 6459db29afbfHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung und Aufrufkontext
Die rein virtuelle Methode CreateVerifierPublicCtx der Klasse ara::crypto::cryp::CryptoProvider wird über die Header-Datei ara/crypto/cryp/crypto_provider.h deklariert [SWS_CRYPT_20757]. Sie dient der synchronen Erstellung eines Kontexts zur Signaturprüfung mit öffentlichen Schlüsseln (Public-Key-Signaturverifikation) [SWS_CRYPT_20757].
Der Aufrufer übergibt über den Parameter algId (Typ AlgId) den Bezeichner des gewünschten Krypto-Signaturalgorithmus [SWS_CRYPT_20757]. Im Erfolgsfall liefert die Funktion ein ara::core::Result zurück, das einen Smart Pointer auf den erstellten Verifikationskontext (VerifierPublicCtx::Sptr) enthält [SWS_CRYPT_20757].
Fehlerbehandlung
Im Fehlerfall kommt eine Rollback-Semantik zum Tragen, und das resultierende ara::core::Result transportiert einen entsprechenden Fehlercode [SWS_CRYPT_20757]:
ara::crypto::CryptoErrc::kInvalidArgument: Wird gemeldet, wenn das Argument algId einen kryptografischen Algorithmus benennt, der nicht für die Signaturprüfung mit öffentlichen Schlüsseln vorgesehen ist [SWS_CRYPT_20757].
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird gemeldet, wenn für algId ein unbekannter bzw. nicht unterstützter Bezeichner übergeben wurde [SWS_CRYPT_20757].
Nebenläufigkeit und Einschränkungen
Die Methode ist als noexcept deklariert, vollständig ausnahmesicher (exception safe) und explizit als threadsicher (thread-safe) spezifiziert [SWS_CRYPT_20757]. Parallele Aufrufe aus mehreren Ausführungskontexten sind somit ohne externe Synchronisation zulässig.
Dieser Nutzungshinweis basiert auf der Spezifikation des AUTOSAR-Adaptive-Releases R25-11.
The interface shall format the data referenced by the specified key, securely wrap this payload and serialize the secured payload into the provided output buffer. The format shall be specified implicitly by the AlgId. The formatted payload shall be wrapped according to the specified algId using the kek; if kek is not provided, ExportSecuredKey shall apply a key-encryption-key implictly defined by the algId or the default key-encryption-key of the CryptoProvider.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 7d1aacdfd90aHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode ExportSecuredKey der Schnittstelle ara::crypto::cryp::CryptoProvider exportiert ein kryptografisches Schlüsselobjekt in ein gesichertes, serialisiertes Format [SWS_CRYPT_20728]. Das übergebene Schlüsselobjekt key wird gemäß dem durch algId implizit festgelegten Format aufbereitet, kryptografisch verpackt („wrapped“) und in den Ausgabepuffer resultBuffer serialisiert [SWS_CRYPT_20728]. Für das Einpacken kann optional ein Key-Encryption-Key (kek) übergeben werden; wird kein kek bereitgestellt, greift die Methode auf einen durch die algId implizit bestimmten KEK oder den Standard-KEK des CryptoProviders zurück [SWS_CRYPT_20728].
Die Funktion ist als thread-safe und exception safe eingestuft sowie mit noexcept annotiert [SWS_CRYPT_20728]. Interpretation: Da die Signatur direkt ein ara::core::Result ohne asynchrone Rückgabetypen wie Futures liefert, dürfte der gesamte Einpack- und Serialisierungsvorgang synchron im Aufruferkontext ausgeführt werden. Frage Q-3fb89afcc9300695 (offen)
Bei erfolgreichem Abschluss liefert das zurückgegebene ara::core::Result<std::size_t> die Anzahl der in resultBuffer geschriebenen Bytes [SWS_CRYPT_20728]. Schlägt die Operation fehl, greift eine Rollback-Semantik und es wird einer der folgenden Fehler gemeldet [SWS_CRYPT_20728]:
UnknownIdentifier: Der übergebene algId-Wert wird nicht unterstützt [SWS_CRYPT_20728].
ara::crypto::CryptoErrc::kInvalidArgument: Das Schlüsselobjekt kann nicht verpackt werden (z. B. ungültige Größe oder unpassender Typ) oder ein zwingend erwarteter kek wurde nicht übergeben [SWS_CRYPT_20728].
ara::crypto::CryptoErrc::kUsageViolation: Die zulässige Verwendung von key oder kek ist inkompatibel zum gewählten Algorithmus [SWS_CRYPT_20728].
ara::crypto::CryptoErrc::kIncompatibleArguments: Der übergebene kek ist inkompatibel zum Exportalgorithmus [SWS_CRYPT_20728].
ara::crypto::CryptoErrc::kInsufficientCapacity: Der Ausgabepuffer resultBuffer ist zu klein für das Resultat [SWS_CRYPT_20728].
ara::crypto::CryptoErrc::kBusyResource: Eine für den Export benötigte Ressource ist belegt [SWS_CRYPT_20728].
Dieser Text wurde von einer KI erstellt und basiert auf dem AUTOSAR-Spezifikationsstand R25-11.
an output buffer the securely exported key is written to
kek
an optional key-encryption-key to be be used for wrapping the secured payload. Only used if the used algorithm does not determine the used key (e.g., based on configuration).
Generate a new public/private key pair and return the private key. The public key can be retrieved via the function PrivateKey::GetPublicKey() The allowed usage flags of the Public Key are set based on the allowed usage of the PrivateKey: • kAllowDataDecryption --> kAllowDataEncryption • kAllowSigGeneration --> kAllowSigVerification • kAllowKeyAgreement --> kAllowKeyAgreement • kAllowKeyUnwrapping --> kAllowKeyWrapping Additionally, the allowed usage: • kAllowPlaintextExport • kAllowPersist are set for the public key.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: c90dae237830Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode GeneratePrivateKey der Klasse ara::crypto::cryp::CryptoProvider (deklariert in ara/crypto/cryp/crypto_provider.h) erzeugt synchron ein neues asymmetrisches Schlüsselpaar und liefert den erstellten privaten Schlüssel als PrivateKey::Sptr innerhalb eines ara::core::Result zurück [SWS_CRYPT_20722]. Der zugehörige öffentliche Schlüssel wird nicht direkt zurückgegeben, sondern kann nachträglich über die Methode PrivateKey::GetPublicKey() des resultierenden Schlüssels abgerufen werden [SWS_CRYPT_20722].
Beim Aufruf spezifiziert der Parameter algId den Kryptoalgorithmus, während privateKeyAllowedUsage die zulässigen Transformationsarten für den privaten Schlüssel festlegt [SWS_CRYPT_20722]. Die zulässigen Nutzungsflags des öffentlichen Schlüssels werden dabei anhand der Berechtigungen des privaten Schlüssels wie folgt abgebildet [SWS_CRYPT_20722]:
kAllowDataDecryption führt zu kAllowDataEncryption
kAllowSigGeneration führt zu kAllowSigVerification
kAllowKeyAgreement führt zu kAllowKeyAgreement
kAllowKeyUnwrapping führt zu kAllowKeyWrapping
Zusätzlich werden dem öffentlichen Schlüssel automatisch die Verwendungsflags kAllowPlaintextExport sowie kAllowPersist zugewiesen [SWS_CRYPT_20722].
Hinsichtlich Nebenläufigkeit und Ausführung ist die Funktion als thread-safe und exception-safe spezifiziert [SWS_CRYPT_20722]. Tritt während der Schlüsselgenerierung ein Fehler auf, wird das Ergebnis mit Rollback-Semantik abgewickelt [SWS_CRYPT_20722]. Folgende Fehlercodes können zurückgegeben werden:
ara::crypto::CryptoErrc::kUnknownIdentifier, wenn für algId ein nicht unterstützter Algorithmus übergeben wird,
ara::crypto::CryptoErrc::kIncompatibleArguments, falls die angegebenen privateKeyAllowedUsage-Flags mit dem gewählten Algorithmus oder Schlüsseltyp inkompatibel sind,
ara::crypto::CryptoErrc::kBusyResource, wenn die Generierung aufgrund temporär belegter Ressourcen vorübergehend nicht möglich ist [SWS_CRYPT_20722].
Dieser Nutzungshinweis wurde automatisch generiert auf Basis der Spezifikation AUTOSAR Adaptive R25-11.
virtual ara::core::Result< void > GenerateRandomData (ReadWriteMem Region randomData) noexcept=0;
Fill the provided output data buffer randomData with random data.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 405a308cad1eHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die rein virtuelle Methode GenerateRandomData der Schnittstelle ara::crypto::cryp::CryptoProvider dient dazu, einen vom Aufrufer bereitgestellten Speicherbereich mit kryptografischen Zufallsdaten zu füllen [SWS_CRYPT_30098]. Die Deklaration befindet sich in der Header-Datei ara/crypto/cryp/crypto_provider.h.
Als Ausgabeparameter wird randomData vom Typ ReadWriteMem Region übergeben, welcher den zu befüllenden Puffer repräsentiert und dessen Größe die Anzahl der generierten Zufallsbytes bestimmt [SWS_CRYPT_30098]. Interpretation: Da die Funktion als Rückgabetyp unmittelbar ara::core::Result<void> und kein Future-Objekt verwendet, dürfte die Erzeugung der Daten synchron blockierend ablaufen [SWS_CRYPT_30098]. Frage Q-315c0492dcf7f37d (offen) Der Rückgabewert ist im Erfolgsfall leer oder enthält im Fehlerfall einen entsprechenden Fehlercode [SWS_CRYPT_30098].
Tritt bei der Ausführung ein Problem auf, wird eine Rollback-Semantik angewendet, sodass keine partiellen oder ungültigen Zustände verbleiben [SWS_CRYPT_30098]. Folgende Fehlerzustände sind spezifiziert:
ara::crypto::CryptoErrc::kBusyResource: Der zugrundeliegende Zufallszahlengenerator (RNG) verfügt aktuell über unzureichende Entropie und kann die angeforderte Menge an Zufallsbytes nicht liefern [SWS_CRYPT_30098].
ara::crypto::CryptoErrc::kUnsupported: Die konkrete Implementierung des CryptoProvider unterstützt keinen Standard-Zufallszahlengenerator [SWS_CRYPT_30098].
Hinsichtlich Nebenläufigkeit und Robustheit ist die Methode als thread-safe und exception safe spezifiziert [SWS_CRYPT_30098]. Mehrere Threads können die Funktion somit parallel aufrufen, und die noexcept-Spezifikation garantiert, dass keine C++-Ausnahmen über die Schnittstellengrenze geworfen werden.
Dieser Nutzungshinweis wurde automatisch auf Basis der AUTOSAR-Spezifikation generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 202931831493Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die rein virtuelle Methode GenerateSymmetricKey wird über die Schnittstelle ara::crypto::cryp::CryptoProvider bereitgestellt (Header-Datei #include "ara/crypto/cryp/crypto_provider.h") und dient der Erzeugung eines neuen symmetrischen Schlüssels [SWS_CRYPT_20721]. Der synchrone Aufruf erwartet als Parameter algId die Kennung des symmetrischen Ziel-Kryptoalgorithmus sowie als allowedUsage Bitflags, die die zulässigen Transformationstypen für den generierten Schlüssel festlegen [SWS_CRYPT_20721]. Bei erfolgreicher Ausführung liefert die Methode ein ara::core::Result mit einem SymmetricKey::Sptr, also einem Shared Pointer auf das neu erzeugte symmetrische Schlüsselobjekt [SWS_CRYPT_20721].
Fehlerbehandlung
Tritt während der Schlüsselerzeugung ein Fehler auf, wird dieser im ara::core::Result übermittelt. Für alle spezifizierten Fehlerfälle greift eine Rollback-Semantik [SWS_CRYPT_20721]:
ara::crypto::CryptoErrc::kUnknownIdentifier: Wird gemeldet, wenn für algId ein nicht unterstützter Wert übergeben wurde [SWS_CRYPT_20721].
ara::crypto::CryptoErrc::kIncompatibleArguments: Tritt auf, wenn die angegebenen allowedUsage-Flags mit dem gewählten algId-Algorithmus oder dem Schlüsseltyp inkompatibel sind [SWS_CRYPT_20721].
ara::crypto::CryptoErrc::kBusyResource: Zeigt an, dass die Operation wegen temporär belegter Ressourcen vorübergehend nicht durchgeführt werden kann [SWS_CRYPT_20721].
Nebenläufigkeit und Einschränkungen
Die Operation ist als noexcept deklariert und besitzt die Eigenschaften ausnahmesicher (exception safe) sowie threadsicher (thread-safe) zu sein [SWS_CRYPT_20721]. Sie kann daher nebenläufig aus mehreren Threads aufgerufen werden, wobei bei hoher Systemlast der Fehler kBusyResource zur Signalisierung temporärer Engpässe auftreten kann [SWS_CRYPT_20721].
Dieser Nutzungshinweis wurde automatisiert auf Basis der Spezifikation generiert.
Get a CryptoProvider specific default set of allowedUsages for the provided AlgId. The returned allowedUsages shall not contain kAllowPlaintextExport, kAllowPersist and kAllowSecuredExport.
Get the current value of the secure counter of this CryptoProvider. The current counter value is guaranteed to be stricly larger than any previously returned counter value.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: cd7a957c648fHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode GetSecureCounter() der Klasse ara::crypto::cryp::CryptoProvider (deklariert in #include "ara/crypto/cryp/crypto_provider.h") fragt den aktuellen Zählerstand des abgesicherten Zählers der Provider-Instanz ab [SWS_CRYPT_20098]. Die Funktion arbeitet synchron und erfordert keine Übergabeparameter [SWS_CRYPT_20098]. Im Erfolgsfall liefert sie über ara::core::Result<SecureCounter> die Struktur SecureCounter zurück, welche aus zwei vorzeichenlosen 64-Bit-Werten (LSQW für Least Significant Quad Word und MSQW für Most Significant Quad Word) besteht [SWS_CRYPT_20098]. Es wird garantiert, dass jeder zurückgegebene Zählerstand strikt größer als alle zuvor über diese Instanz gelieferten Werte ist [SWS_CRYPT_20098].
Kann der Zählerstand nicht ermittelt werden, schlägt der Aufruf fehl und liefert einen Fehlercode mit Rollback-Semantik im Result-Objekt [SWS_CRYPT_20098]:
ara::crypto::CryptoErrc::kUnsupported: Der spezifische CryptoProvider unterstützt keinen abgesicherten Zähler [SWS_CRYPT_20098].
ara::crypto::CryptoErrc::kBusyResource: Eine für den Zugriff oder das Aktualisieren des Zählers erforderliche Ressource ist gegenwärtig belegt [SWS_CRYPT_20098].
Bezüglich Nebenläufigkeit und Robustheit ist die Funktion als threadsicher (thread-safe) spezifiziert und als ausnahmesicher (exception safe) mit noexcept deklariert [SWS_CRYPT_20098]. Parallele Aufrufe aus mehreren Threads sind somit ohne externe Synchronisation zulässig, wobei die strikte Monotonie der gelieferten Zählerwerte gewährleistet bleibt [SWS_CRYPT_20098].
Dieser Text wurde von einer KI generiert und dient als Orientierungshilfe. Verbindlich ist ausschließlich die offizielle Spezifikation.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 56f03864743dHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode ImportPrivateKey der Klasse ara::crypto::cryp::CryptoProvider dient dem synchronen Importieren eines serialisierten privaten Schlüssels [SWS_CRYPT_50132]. Beim Aufruf werden die Nutzdaten über den Speicherbereich serialized (ReadOnlyMemRegion) übergeben, ergänzt um die gewünschten Verwendungsbeschränkungen (allowedUsage) und das Serialisierungsformat (formatId). Der Parameter algId ist optional (ara::core::Optional<AlgId>) und muss nur gesetzt werden, wenn das gewählte Format die erforderlichen Schlüsseleigenschaften nicht bereits selbst eindeutig definiert [SWS_CRYPT_50132]. Als Rückgabewert liefert die Funktion ein ara::core::Result<PrivateKey::Sptr>, das im Erfolgsfall einen Shared Pointer auf das erzeugte Schlüsselobjekt enthält.
Fehlerbehandlung
Im Fehlerfall stellt die Methode sicher, dass Rollback-Semantik greift [SWS_CRYPT_50132]. Es können folgende Fehlercodes über das Result zurückgegeben werden:
InvalidArgument: Die serialisierten Daten in serialized entsprechen nicht dem angegebenen Format [SWS_CRYPT_50132].
ara::crypto::CryptoErrc::kIncompatibleArguments: Die übergebenen allowedUsage sind mit der algId inkompatibel [SWS_CRYPT_50132].
ara::crypto::CryptoErrc::kUnsupported: Die Funktion wird vom konkreten Provider nicht unterstützt [SWS_CRYPT_50132].
ara::crypto::CryptoErrc::kBusyResource: Die Operation kann temporär aufgrund belegter Ressourcen nicht ausgeführt werden [SWS_CRYPT_50132].
ara::crypto::CryptoErrc::kUnsupportedFormat: Die formatId wird für diesen Objekttyp nicht unterstützt [SWS_CRYPT_50132].
Nebenläufigkeit und Einschränkungen
Die Schnittstelle ist als noexcept deklariert und bietet Ausnahme-Sicherheit (exception safe) sowie Thread-Sicherheit (thread-safe) [SWS_CRYPT_50132]. Aufrufe können somit parallel aus verschiedenen Threads erfolgen.
Dieser Text wurde durch ein KI-System auf Basis der AUTOSAR-Spezifikation generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 2c89087292ccHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode ImportPublicKey dient dem Importieren eines serialisierten öffentlichen Schlüssels in den jeweiligen ara::crypto::cryp::CryptoProvider[SWS_CRYPT_20732]. Der Aufruf erfolgt synchron und liefert ein ara::core::Result<PublicKey::Sptr> zurück, welches im Erfolgsfall einen Smart Pointer auf das erzeugte Schlüsselobjekt enthält [SWS_CRYPT_20732].
serialized: Ein ReadOnlyMemRegion-Speicherbereich, der die Rohdaten des serialisierten Schlüssels bereitstellt.
allowedUsage: Die zulässigen Verwendungsflags (AllowedUsageFlags) für den importierten Schlüssel.
formatId: Der Bezeichner des Serialisierungsformats (FormatId).
algId: Eine optionale Algorithmen-ID (ara::core::Optional<AlgId>). Sie ist nicht erforderlich, wenn das Serialisierungsformat die Eigenschaften des Schlüssels bereits eindeutig bestimmt.
Fehlerbehandlung
Tritt bei der Verarbeitung ein Fehler auf, wird dieser im zurückgegebenen ara::core::Result gekapselt. Folgende Fehlercodes sind spezifiziert [SWS_CRYPT_20732]:
InvalidArgument: Die übergebenen Daten in serialized entsprechen nicht dem angegebenen Format.
ara::crypto::CryptoErrc::kIncompatibleArguments: Die Nutzungsflags allowedUsage sind inkompatibel zu algId.
ara::crypto::CryptoErrc::kUnsupportedFormat: Die angegebene formatId wird für diesen Objekttyp nicht unterstützt.
ara::crypto::CryptoErrc::kUnsupported: Die angeforderte Funktion wird vom CryptoProvider nicht unterstützt.
ara::crypto::CryptoErrc::kBusyResource: Die Operation kann temporär nicht ausgeführt werden.
Nebenläufigkeit und Sicherheit
Die Methode ist als noexcept deklariert, gilt als Exception-safe und ist gemäß Spezifikation Thread-safe spezifiziert [SWS_CRYPT_20732]. Fehlerfälle folgen definierten Rollback-Semantiken [SWS_CRYPT_20732].
Dieser Text wurde durch ein KI-System generiert und basiert ausschließlich auf den Spezifikationsdaten aus dem Release R25-11.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 46a4ead0d7caHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode ImportSymmetricKey der Schnittstelle ara::crypto::cryp::CryptoProvider dient dem Importieren eines serialisierten symmetrischen Schlüssels [SWS_CRYPT_50014]. Als Rückgabewert liefert sie ein ara::core::Result<SymmetricKey::Sptr>, das im Erfolgsfall einen Smart Pointer auf das neu instanziierte Schlüsselobjekt bereitstellt [SWS_CRYPT_50014]. Da kein asynchroner Rückgabetyp wie ein Future verwendet wird, dürfte die Ausführung synchron erfolgen. Frage Q-720a495b07c4f31d (offen)
serialized (ReadOnlyMemRegion): Der Speicherbereich, welcher die serialisierten Schlüsseldaten enthält.
allowedUsage (AllowedUsageFlags): Bitmaske der für diesen Schlüssel zulässigen Operationen und Verwendungen.
formatId (FormatId): Kennung des Serialisierungsformats der Schlüsseldaten.
algId (ara::core::Optional<AlgId>): Optionale Algorithmen-Kennung; sie ist nicht erforderlich, falls das angegebene Serialisierungsformat alle erforderlichen Eigenschaften des Schlüssels bereits eindeutig bestimmt.
Fehlerbehandlung und Randbedingungen
Die Methode ist als thread-safe und exception safe spezifiziert [SWS_CRYPT_50014]. Im Fehlerfall gewährleistet die Implementierung eine Rollback-Semantik und gibt einen entsprechenden Fehlercode im ara::core::Result zurück [SWS_CRYPT_50014]:
InvalidArgument: Die übergebenen Binärdaten in serialized entsprechen nicht dem angegebenen Format.
ara::crypto::CryptoErrc::kIncompatibleArguments: Die festgelegten allowedUsage-Flags sind inkompatibel mit der angegebenen algId.
ara::crypto::CryptoErrc::kUnsupported: Die Funktion wird von der konkreten Instanz des CryptoProvider nicht unterstützt.
ara::crypto::CryptoErrc::kUnsupportedFormat: Das spezifizierte Format wird für diesen Schlüsseltyp nicht unterstützt.
ara::crypto::CryptoErrc::kBusyResource: Die Operation kann aufgrund temporär belegter Ressourcen gegenwärtig nicht ausgeführt werden.
Dieser Nutzungshinweis wurde automatisiert auf Basis der Spezifikation AUTOSAR R25-11 erstellt.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 933cf21dc7b3Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode LoadPrivateKey der Schnittstelle ara::crypto::cryp::CryptoProvider lädt einen privaten Schlüssel aus einem bereitgestellten Schlüsselslot ([SWS_CRYPT_20764]). Der Aufruf wird synchron ausgeführt und nimmt als Parameter einen Shared Pointer auf die Quellressource (keySlot) entgegen. Im Erfolgsfall stellt die Funktion einen Shared Pointer auf das geladene Schlüsselobjekt (PrivateKey::Sptr) bereit, der innerhalb eines ara::core::Result zurückgegeben wird ([SWS_CRYPT_20764]).
Fehlerbehandlung
Tritt während der Operation ein Fehler auf, greift eine Rollback-Semantik und das ara::core::Result enthält einen spezifischen Fehlercode ([SWS_CRYPT_20764]):
ara::crypto::CryptoErrc::kEmptyKeySlot: Der übergebene Schlüsselslot ist leer ([SWS_CRYPT_20764]).
ara::crypto::CryptoErrc::kIncompatibleObject: Die zugrunde liegende Ressource gehört zu einem anderen, inkompatiblen CryptoProvider oder enthält einen abweichenden Schlüsseltyp ([SWS_CRYPT_20764]).
ara::crypto::CryptoErrc::kBusyResource: Die Operation kann temporär nicht ausgeführt werden ([SWS_CRYPT_20764]).
Nebenläufigkeit und Sicherheit
Die Spezifikation stuft die Funktion als thread-safe und exception safe ein; die Signatur ist als noexcept deklariert ([SWS_CRYPT_20764]). Mehrere Threads können die Methode parallel ansprechen, müssen jedoch im Fall temporärer Ressourcenkonflikte eine mögliche Rückgabe von kBusyResource behandeln.
Dieser Nutzungshinweis wurde automatisch auf Basis der Spezifikation generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: bd65058963fbHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode LoadPublicKey der Schnittstelle ara::crypto::cryp::CryptoProvider lädt einen öffentlichen Schlüssel aus dem bereitgestellten Schlüsselspeicherplatz [SWS_CRYPT_20763]. Als Parameter keySlot erwartet sie einen KeySlot::Sptr, der den Speicherplatz mit dem zu ladenden Schlüssel referenziert [SWS_CRYPT_20763]. Als Rückgabewert liefert die Funktion ein ara::core::Result<PublicKey::Sptr>, welches im Erfolgsfall einen Shared Pointer auf das geladene öffentliche Schlüsselobjekt enthält [SWS_CRYPT_20763]. Die direkte Bereitstellung des Result-Werts dürfte dabei auf ein synchrones Aufrufverhalten hinweisen. Frage Q-e0d2480909b1398a (offen)
Fehlerbehandlung
Schlägt der Ladevorgang fehl, enthält das ara::core::Result einen entsprechenden Fehlercode der Domäne ara::crypto::CryptoErrc, wobei für alle spezifizierten Fehlerfälle eine Rollback-Semantik definiert ist [SWS_CRYPT_20763]:
ara::crypto::CryptoErrc::kEmptyKeySlot: Tritt auf, wenn der übergebene KeySlot leer ist [SWS_CRYPT_20763].
ara::crypto::CryptoErrc::kIncompatibleObject: Wird zurückgegeben, wenn die zugrundeliegende Ressource zu einem anderen, inkompatiblen CryptoProvider gehört oder einen abweichenden Schlüsseltyp enthält [SWS_CRYPT_20763].
ara::crypto::CryptoErrc::kBusyResource: Tritt auf, falls die Operation temporär nicht ausgeführt werden kann, da die Ressource anderweitig belegt ist [SWS_CRYPT_20763].
Nebenläufigkeit und Sicherheit
Die Methode ist mit noexcept deklariert und als Exception-safe spezifiziert [SWS_CRYPT_20763]. Hinsichtlich der Nebenläufigkeit ist die Operation ausdrücklich als Thread-safe eingestuft, womit parallele Aufrufe aus mehreren Threads zulässig sind [SWS_CRYPT_20763].
Dieser Nutzungshinweis wurde von einer KI auf Basis der Spezifikation generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: fa5c0e3150ceHerkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die rein virtuelle Methode LoadSymmetricKey der Klasse ara::crypto::cryp::CryptoProvider dient dem Laden eines symmetrischen Schlüssels aus einem bereitgestellten Schlüsselspeicherplatz [SWS_CRYPT_20762]. Als Parameter nimmt die Funktion einen Shared Pointer auf den betreffenden Speicherplatz (keySlot) entgegen und liefert synchron ein ara::core::Result<SymmetricKey::Sptr> zurück, welches bei erfolgreicher Ausführung einen Shared Pointer auf das geladene Schlüsselobjekt bereitstellt [SWS_CRYPT_20762].
Hinsichtlich der Nebenläufigkeit und Ausführungssicherheit ist die Methode als thread-safe sowie exception safe spezifiziert und mit noexcept deklariert [SWS_CRYPT_20762].
Tritt beim Laden ein Fehler auf, gibt die Methode über das Result-Objekt spezifische Fehlercodes aus der Domäne ara::crypto::CryptoErrc mit definierter Rollback-Semantik zurück [SWS_CRYPT_20762]:
ara::crypto::CryptoErrc::kEmptyKeySlot: Tritt auf, wenn der übergebene KeySlot leer ist [SWS_CRYPT_20762].
ara::crypto::CryptoErrc::kIncompatibleObject: Wird zurückgegeben, falls die zugrunde liegende Ressource zu einem anderen, inkompatiblen Crypto-Provider gehört oder einen anderen Schlüsseltyp enthält [SWS_CRYPT_20762].
ara::crypto::CryptoErrc::kBusyResource: Signalisiert, dass die Operation temporär nicht ausgeführt werden kann [SWS_CRYPT_20762].
Dieser Text wurde durch ein KI-System generiert und stützt sich ausschließlich auf die Spezifikation.
gemini-3.8-flash-medium· 2026-10-13