class ara::crypto::x509::X509Provider

Verwendung

Die synchrone Methode ClearCertificateSlot der Klasse ara::crypto::x509::X509Provider leert den über den Parameter instanceSpecifier angegebenen Zertifikatsspeicherplatz [SWS_CRYPT_40622]. Sie gibt ein ara::core::Result<bool> zurück: Der Rückgabewert ist true, wenn ein vorhandenes Zertifikat erfolgreich gelöscht wurde, und false, wenn der Slot bereits unbesetzt war [SWS_CRYPT_40622].

Fehlerbehandlung und Einschränkungen

Wenn der Vorgang temporär nicht ausgeführt werden kann, liefert die Funktion den Fehlercode ara::crypto::CryptoErrc::kBusyResource mit Rollback-Semantik [SWS_CRYPT_40622]. Zudem sind spezifische Modellierungs- und Zugriffsvoraussetzungen definiert:

• ProcessMappingViolation: Liegt vor, wenn der InstanceSpecifier nicht auf einen für den aktuellen Prozess modellierten PortPrototype mit dem Interface CryptoCertificateInterface zeigt [SWS_CRYPT_40622].
• InsufficientPermissionsViolation: Tritt auf, wenn dem aktuellen Prozess Schreibberechtigungen fehlen, d. h. CryptoCertificateToPortPrototypeMapping.writeAccess != True gesetzt ist [SWS_CRYPT_40622].

Nebenläufigkeit

Die Schnittstelle ist als noexcept ausgewiesen, ausnahmesicher (exception safe) und für nebenläufige Aufrufe threadsicher (thread-safe) spezifiziert [SWS_CRYPT_40622].

Verwendung

Die synchrone Methode CreateCertSignRequest der Schnittstelle ara::crypto::x509::X509Provider aus dem Header ara/crypto/x509/x509_provider.h erstellt eine Zertifikatssignierungsanforderung (Certificate Signing Request, CSR) gemäß dem Standard RFC 2986 [SWS_CRYPT_40640]. Als Parameter erwartet die Funktion einen vollständig konfigurierten Signierkontext signerCtx, den Distinguished Name des Subjekts subjectDn, den zugehörigen öffentlichen Schlüssel publicKey sowie optionale DER-codierte Attribute attributes [SWS_CRYPT_40640]. Der übergebene öffentliche Schlüssel muss zwingend mit dem im Signierkontext konfigurierten privaten Schlüssel korrespondieren. Im Erfolgsfall wird ein Smart Pointer auf den erstellten CSR (CertSignRequest::Sptrc) verpackt in einem ara::core::Result zurückgegeben [SWS_CRYPT_40640].

Fehlerbehandlung

Im Fehlerfall liefert die Methode ein ara::core::Result mit einem entsprechenden Fehlercode gemäß Rollback-Semantik [SWS_CRYPT_40640]:

• ara::crypto::CryptoErrc::kInvalidArgument: Wenn die übergebenen Attributdaten ungültig sind oder der öffentliche Schlüssel nicht zum privaten Schlüssel des Signierkontexts passt.
• ara::crypto::CryptoErrc::kUninitializedContext: Falls der Signierkontext nicht mit einem Schlüsselwert initialisiert wurde.
• ara::crypto::CryptoErrc::kEmptyKeySlot: Falls ein konfigurierter KeySlot gegenwärtig leer ist.
• ara::crypto::CryptoErrc::kUsageViolation: Wenn die zulässige Schlüsselverwendung die Signaturerzeugung (kAllowSigGeneration) nicht umfasst.
• ara::crypto::CryptoErrc::kBusyResource: Sofern eine für die Operation benötigte Ressource belegt ist.

Nebenläufigkeit und Einschränkungen

Die Methode ist als const, noexcept, ausnahmesicher (exception safe) sowie threadsicher (thread-safe) spezifiziert [SWS_CRYPT_40640]. Parallele Aufrufe über dieselbe Provider-Instanz dürften zulässig sein, solange die übergebenen Kontext- und Schlüsselobjekte nicht zeitgleich durch andere Threads modifiziert werden. Frage Q-aef8777dce55a033 (offen)

Die Methode CreateCertificateValidationCtx ist eine funktionale Schnittstelle der Klasse ara::crypto::x509::X509Provider und dient gemäß [SWS_CRYPT_50125] der Erstellung eines Zertifikatsvalidierungskontexts. Sie ist im Header #include "ara/crypto/x509/x509_provider.h" deklariert und als parameterlose, rein virtuelle Funktion definiert [SWS_CRYPT_50125].

Der synchrone Aufruf liefert als Rückgabewert den Typ ara::core::Result<CertificateValidationCtx::Sptr> zurück, welcher im Erfolgsfall einen Smart Pointer auf den erzeugten Kontext bereitstellt [SWS_CRYPT_50125]. Für diese Funktion werden in der Spezifikation keine standardisierten Fehlercodes definiert [SWS_CRYPT_50125]. Da die Rückgabe jedoch über den Ergebnistyp ara::core::Result erfolgt, dürften etwaige providerspezifische Fehler während der Kontexterzeugung über die Fehlerkomponente dieses Result-Objekts abgebildet werden. Frage Q-f81f52d8e3d73bcf (offen)

Hinsichtlich des Aufrufkontexts und der Nebenläufigkeit ist die Methode ausdrücklich als threadsicher (thread-safe) spezifiziert sowie als ausnahmesicher (exception safe) und noexcept deklariert [SWS_CRYPT_50125]. Aufrufer können die Funktion daher sicher und nebenläufig aus mehreren Threads heraus ausführen, ohne eine zusätzliche Synchronisierung für den Erzeugungsvorgang vorsehen zu müssen [SWS_CRYPT_50125].

Verwendung

Die rein virtuelle Methode CreateDn wird über die Schnittstelle ara::crypto::x509::X509Provider aus der Header-Datei ara/crypto/x509/x509_provider.h bereitgestellt [SWS_CRYPT_50186]. Sie dient dazu, ein X.509-Distinguished-Name-Objekt (X509DN::Sptrc) anhand einer Zeichenkettendarstellung zu instanziieren [SWS_CRYPT_50186]. Als Eingabeparameter erwartet sie dnString vom Typ ara::core::StringView, welcher einen Distinguished Name gemäß RFC 4514 repräsentieren muss [SWS_CRYPT_50186]. Interpretation: Da die Funktion als const noexcept deklariert ist und direkt ein ara::core::Result zurückgibt, dürfte der Aufruf synchron blockierend ohne Zustandsänderung des Providers erfolgen. Frage Q-c7e3ab6b4f34ad0f (offen)

Fehlerbehandlung

Kann die übergebene Zeichenkette nicht erfolgreich verarbeitet werden, weil sie keinen gültigen DN nach RFC 4514 darstellt, liefert die Funktion ein ara::core::Result mit dem Fehlercode ara::crypto::CryptoErrc::kInvalidArgument [SWS_CRYPT_50186]. Für diesen Fehlerfall sind Rollback-Semantiken spezifiziert [SWS_CRYPT_50186].

Nebenläufigkeit und Einschränkungen

Die Methode ist explizit als ausnahmesicher (exception safe) und threadsicher (thread-safe) spezifiziert [SWS_CRYPT_50186]. Sie kann somit ohne zusätzliche externe Synchronisation aus nebenläufigen Threads aufgerufen werden.

Zusammenspiel

Als Alternative zur zeichenkettenbasierten Erzeugung stellt ara::crypto::x509::X509Provider eine weitere Überladung von CreateDn bereit [SWS_CRYPT_50187]. Diese erlaubt die Konstruktion eines X509DN aus einem serialisierten Puffer (ReadOnlyMemRegion) unter Angabe eines Formatbezeichners (FormatId) [SWS_CRYPT_50187].

Verwendung

Die Methode CreateDn gemäß [SWS_CRYPT_50187] dient der Erzeugung eines Distinguished Name (DN) aus einem serialisierten Puffer. Sie wird synchron auf einer Instanz von ara::crypto::x509::X509Provider aufgerufen. Als Eingaben erwartet die Funktion einen Speicherbereich dn vom Typ ReadOnlyMemRegion, der die serialisierten Daten enthält, sowie eine Formatkennung formatId vom Typ FormatId. Bei erfolgreicher Ausführung liefert die Methode ein ara::core::Result<X509DN::Sptrc> zurück, welches einen Shared Pointer auf das erzeugte X509DN-Objekt bereitstellt.

Fehlerbehandlung

Schlägt die Erzeugung fehl, gibt die Methode einen entsprechenden Fehlercode innerhalb des ara::core::Result zurück ([SWS_CRYPT_50187]):

• ara::crypto::CryptoErrc::kInvalidArgument: Tritt mit Rollback-Semantik auf, wenn der übergebene Puffer dn ungültig ist.
• ara::crypto::CryptoErrc::kUnsupportedFormat: Wird mit Rollback-Semantik gemeldet, falls die angegebene formatId unbekannt oder nicht unterstützt ist.

Nebenläufigkeit und Zusammenspiel

Die Schnittstelle ist als thread-safe sowie exception safe spezifiziert und mit noexcept deklariert ([SWS_CRYPT_50187]). Sie kann daher sicher parallel aus mehreren Ausführungskontexten heraus aufgerufen werden.

Im Unterschied zu der alternativen Überladung [SWS_CRYPT_50186], welche einen DN aus einer Zeichenkette (ara::core::StringView) gemäß RFC 4514 erzeugt, verarbeitet diese Funktion serialisierte Binärdaten. Die konkreten Ausprägungen für FormatId dürften dabei modulweit an anderer Stelle definiert sein. Frage Q-dd7cbf35ba6fa7d1 (offen)

Verwendung

Die Methode CreateOcspRequest der Klasse ara::crypto::x509::X509Provider erzeugt synchron eine OCSP-Prüfanfrage (Online Certificate Status Protocol) für ein einzelnes Zertifikat gemäß RFC 6960 [SWS_CRYPT_40626]. Als Parameter werden das zu überprüfende Zertifikat cert und dessen Ausstellerzertifikat issuerCert jeweils als Certificate::Sptrc übergeben [SWS_CRYPT_40626]. Über den optionalen Parameter signerCtx kann ein Zeiger auf einen Signierkontext bereitgestellt werden, falls die Anfrage kryptografisch signiert werden soll [SWS_CRYPT_40626]. Die Funktion gibt ein ara::core::Result mit einem ara::core::Vector<std::uint8_t> zurück; die enthaltenen Rohdaten dürften der DER-kodierten Anfragestruktur gemäß RFC 6960 entsprechen [SWS_CRYPT_40626]. Frage Q-c43cf023ee5eddd9 (offen)

Fehlerbehandlung

Tritt bei der Erstellung ein Fehler auf, liefert das ara::core::Result spezifische Fehlercodes mit Rollback-Semantik [SWS_CRYPT_40626]:

• ara::crypto::CryptoErrc::kUninitializedContext: Tritt auf, wenn der übergebene Signierkontext nicht mit einem Schlüssel initialisiert ist [SWS_CRYPT_40626].
• ara::crypto::CryptoErrc::kBusyResource: Tritt auf, wenn die Operation wegen vorübergehend belegter Ressourcen nicht durchgeführt werden kann [SWS_CRYPT_40626].

Nebenläufigkeit und Zusammenspiel

Die Methode ist als noexcept deklariert, gilt als ausnahmesicher (exception safe) und ist thread-safe spezifiziert [SWS_CRYPT_40626]. Für Szenarien, in denen mehrere Zertifikate gleichzeitig in einer gemeinsamen OCSP-Anfrage gebündelt werden sollen, steht die überladene Schnittstelle [SWS_CRYPT_40627] für Zertifikatslisten zur Verfügung.

Verwendung

Die Methode CreateOcspRequest der Schnittstelle ara::crypto::x509::X509Provider ([SWS_CRYPT_40627]) dient der synchronen Erstellung einer OCSP-Prüfanfrage (Online Certificate Status Protocol) gemäß RFC 6960 für mehrere Zertifikate. Der Aufruf wird über den Header #include "ara/crypto/x509/x509_provider.h" bereitgestellt.

Als Eingabeparameter erwartet die Funktion:

• certList: Eine Liste der zu validierenden Zertifikate als ara::core::Span<Certificate::Sptrc>.
• issuerCertList: Eine Liste der zugehörigen Ausstellerzertifikate als ara::core::Span<Certificate::Sptrc>. Interpretation: Zwischen den Einträgen beider Listen dürfte eine paarweise Zuordnung nach Index vorausgesetzt werden. Frage Q-9132b017c2c4be75 (offen)
• signerCtx: Ein optionaler Zeiger auf einen initialisierten Signierkontext (ara::core::Optional<cryp::SignerPrivateCtx::Sptr>), falls die Anfrage kryptografisch signiert werden soll.

Als Rückgabewert liefert die Funktion ein ara::core::Result, das bei erfolgreicher Erzeugung die Binärdaten der OCSP-Anfrage in einem ara::core::Vector<std::uint8_t> bereitstellt ([SWS_CRYPT_40627]).

Fehlerbehandlung

Im Fehlerfall stellt das ara::core::Result Fehlercodes mit Rollback-Semantik bereit ([SWS_CRYPT_40627]):

• ara::crypto::CryptoErrc::kUninitializedContext: Tritt auf, wenn der übergebene Signierkontext nicht durch einen Schlüssel initialisiert wurde.
• ara::crypto::CryptoErrc::kBusyResource: Tritt auf, wenn die Operation aufgrund temporär belegter Ressourcen vorübergehend nicht ausgeführt werden kann.

Nebenläufigkeit und Zusammenspiel

Die Methode ist als thread-safe sowie exception safe spezifiziert und mit noexcept deklariert ([SWS_CRYPT_40627]). Im Gegensatz zu [SWS_CRYPT_40626], wo die OCSP-Anfrage für ein einzelnes Zertifikat erzeugt wird, ermöglicht diese Schnittstelle die Bündelung mehrerer Zertifikate in einer einzigen Anfrage.

Verwendung

Die Methode DeleteCrl der Schnittstelle ara::crypto::x509::X509Provider dient dem Löschen einer persistent hinterlegten Zertifikatssperrliste (Certificate Revocation List, CRL) [SWS_CRYPT_50184]. Als Parameter wird der crlInstanceSpecifier übergeben, welcher auf einen RPortPrototype eines CryptoCertificateInterface verweist, der das zugehörige Zertifikat identifiziert [SWS_CRYPT_50184]. Die Funktion arbeitet synchron und liefert ein ara::core::Result<void> zurück; dieses ist leer, wenn die CRL erfolgreich gelöscht wurde oder zuvor gar keine CRL hinterlegt war [SWS_CRYPT_50184].

Fehlerbehandlung und Nebenläufigkeit

Tritt während der Ausführung ein temporärer Ressourcenkonflikt auf, meldet die Funktion den Fehler ara::crypto::CryptoErrc::kBusyResource mit Rollback-Semantik [SWS_CRYPT_50184]. Die Methode ist als noexcept deklariert sowie als ausnahmesicher (exception safe) und threadsicher (thread-safe) spezifiziert [SWS_CRYPT_50184].

Einschränkungen und Konfigurationsbedingungen

Für den Aufruf gelten folgende Konfigurations- und Berechtigungsvoraussetzungen [SWS_CRYPT_50184]:

• ProcessMappingViolation: Tritt auf, wenn der InstanceSpecifier nicht auf einen für den aktuellen Prozess modellierten PortPrototype zeigt, der durch ein CryptoCertificateInterface typisiert ist [SWS_CRYPT_50184].
• InsufficientPermissionsViolation: Tritt auf, wenn der aktuelle Prozess keine Schreibberechtigungen besitzt, das heißt CryptoCertificateToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50184].

Verwendung

Die Methode ImportCertificate der Schnittstelle ara::crypto::x509::X509Provider (deklariert in ara/crypto/x509/x509_provider.h) dient dem persistenten Speichern eines X.509-Zertifikats in einem definierten Zertifikats-Slot [SWS_CRYPT_40621]. Der Ziel-Slot wird über instanceSpecifier (Typ ara::core::InstanceSpecifier) adressiert, während das zu importierende Zertifikat über das Argument certificate (Typ Certificate::Sptrc) übergeben wird [SWS_CRYPT_40621]. Interpretation: Die Ausführung dürfte synchron erfolgen, da die Schnittstelle direkt ein ara::core::Result<void> zurückliefert [SWS_CRYPT_40621]. Frage Q-514863e9a90f1c72 (offen)

Fehlerbehandlung und Modellierungsregeln

Im Fehlerfall wird ein fehlerhaftes ara::core::Result zurückgegeben. Kann der Vorgang temporär nicht ausgeführt werden, liefert die Methode ara::crypto::CryptoErrc::kBusyResource mit Rollback-Semantik [SWS_CRYPT_40621]. Darüber hinaus müssen Konfigurations- und Modellierungsvorgaben erfüllt sein, da andernfalls Laufzeitverletzungen gemeldet werden [SWS_CRYPT_40621]:

• ProcessMappingViolation: Wird ausgelöst, falls der instanceSpecifier nicht auf einen für den aktuellen Prozess modellierten PortPrototype zeigt, der durch ein CryptoCertificateInterface typisiert ist [SWS_CRYPT_40621].
• InsufficientPermissionsViolation: Tritt auf, wenn für den aktuellen Prozess keine Schreibberechtigung vorliegt (CryptoCertificateToPortPrototypeMapping.writeAccess != True) [SWS_CRYPT_40621].

Nebenläufigkeit und Ausführungskontext

Die Operation ist als thread-safe und exception safe spezifiziert (noexcept=0), wodurch nebenläufige Aufrufe ohne externe Sperren abgesichert sind [SWS_CRYPT_40621].

Verwendung

Die Methode ImportCertificateInGroup der Klasse ara::crypto::x509::X509Provider speichert ein bereitgestelltes Zertifikat persistent in einer über instanceSpecifier identifizierten Zertifikatsgruppe [SWS_CRYPT_50127]. Als Parameter werden eine Referenz auf den ara::core::InstanceSpecifier der Zielgruppe sowie ein Smart-Pointer auf das Zertifikat (Certificate::Sptrc certificate) übergeben [SWS_CRYPT_50127]. Der Aufruf wird über den Header ara/crypto/x509/x509_provider.h deklariert und gibt synchron ein ara::core::Result<void> zurück, welches den erfolgreichen Import signalisiert oder einen Fehlerstatus kapselt [SWS_CRYPT_50127].

Fehlerbehandlung und Verletzungen

Im regulären Fehlerfall bietet die Operation Rollback-Semantik und liefert spezifische Fehlercodes im Result-Objekt zurück [SWS_CRYPT_50127]:

• ara::crypto::CryptoErrc::kInsufficientCapacity: Die Kapazität der adressierten Zertifikatsgruppe reicht nicht aus, um das Zertifikat aufzunehmen [SWS_CRYPT_50127].
• ara::crypto::CryptoErrc::kBusyResource: Die Operation kann temporär nicht durchgeführt werden, da die erforderliche Ressource belegt ist [SWS_CRYPT_50127].

Darüber hinaus sind bindende Modellierungs- und Berechtigungsanforderungen definiert, deren Nichteinhaltung als Violations klassifiziert ist [SWS_CRYPT_50127]:

• ProcessMappingViolation: Tritt auf, wenn der InstanceSpecifier nicht auf einen für den aktuellen Prozess modellierten PortPrototype zeigt, der durch ein CryptoCertificateGroupInterface typisiert ist [SWS_CRYPT_50127].
• InsufficientPermissionsViolation: Tritt auf, wenn der aufrufende Prozess keine Schreibberechtigung besitzt, was durch CryptoCertificateGroupToPortPrototypeMapping.writeAccess != True charakterisiert wird [SWS_CRYPT_50127].

Nebenläufigkeit und Ausführungskontext

Die Schnittstelle ist als threadsicher (thread-safe) sowie ausnahmesicher (exception safe) spezifiziert und mit noexcept deklariert [SWS_CRYPT_50127].

Die Methode ImportCrl der Klasse ara::crypto::x509::X509Provider parst und persistiert eine Certificate Revocation List (CRL) oder Delta CRL, die durch das über crlInstanceSpecifier identifizierte CA-Zertifikat ausgestellt wurde [SWS_CRYPT_50183]. Die Ausführung dürfte synchron erfolgen, da unmittelbar ein ara::core::Result zurückgegeben wird. Frage Q-648a00ec967c7524 (offen)

Beim Aufruf werden folgende Parameter übergeben [SWS_CRYPT_50183]:

• crlInstanceSpecifier: ara::core::InstanceSpecifier auf den RPortPrototype eines CryptoCertificateInterface, welcher das Zertifikat identifiziert.
• crl: ReadOnlyMemRegion mit den serialisierten CRL- oder Delta-CRL-Daten.
• formatId: Format der serialisierten CRL.

Die Operation ist als thread-safe sowie exception safe spezifiziert [SWS_CRYPT_50183]. Sie liefert im Erfolgsfall ein ara::core::Result mit dem Status CertificateValidationStatus::kValid oder das Validierungsergebnis der CRL [SWS_CRYPT_50183].

Im Fehlerfall besitzen die Rückgabewerte Rollback-Semantik [SWS_CRYPT_50183]:

• ara::crypto::CryptoErrc::kInvalidArgument: Die CRL entspricht nicht dem angegebenen Format.
• ara::crypto::CryptoErrc::kUnsupportedFormat: Die angegebene FormatId ist unbekannt oder wird nicht unterstützt.
• ara::crypto::CryptoErrc::kBusyResource: Die Operation kann temporär nicht ausgeführt werden.

Zusätzlich sind Konfigurationsvoraussetzungen einzuhalten [SWS_CRYPT_50183]: Eine ProcessMappingViolation tritt auf, falls der Instanzbezeichner nicht auf einen für den aktuellen Prozess modellierten Port verweist, und eine InsufficientPermissionsViolation, wenn CryptoCertificateToPortPrototypeMapping.writeAccess != True gesetzt ist.

Die Methode LoadCertificate der Schnittstelle ara::crypto::x509::X509Provider dient dem Laden eines Zertifikats aus dem persistenten Zertifikatsspeicher [SWS_CRYPT_40641]. Der Aufruf wird synchron ausgeführt (Interpretation: direkte Rückgabe von ara::core::Result ohne asynchrones Zukunftsobjekt wie ara::core::Future). Frage Q-a2e3c23a02b4f8a1 (offen) Als Eingabeparameter erwartet die Funktion einen ara::core::InstanceSpecifier, der den konkreten Speicherort des Zertifikats identifiziert [SWS_CRYPT_40641].

Der Rückgabewert kapselt bei erfolgreicher Ausführung einen Smart-Pointer auf das instanziierte Zertifikat (Certificate::Sptrc) in einem ara::core::Result [SWS_CRYPT_40641]. Schlägt das Laden fehl, enthält das Resultat einen Fehlercode:

• ara::crypto::CryptoErrc::kEmptyCertificateSlot: Tritt mit Rollback-Semantik auf, falls das durch den angegebenen instanceSpecifier identifizierte CryptoCertificate kein persistiertes Zertifikat enthält [SWS_CRYPT_40641].

Hinsichtlich der Nebenläufigkeit und Exception-Sicherheit ist LoadCertificate als thread-safe sowie exception-safe spezifiziert und als noexcept deklariert [SWS_CRYPT_40641]. Bei der Konfiguration und Prozesszuordnung ist eine Modellierungsbedingung zu beachten: Verweist der übergebene instanceSpecifier nicht auf einen für den aktuellen Prozess modellierten PortPrototype, der durch ein CryptoCertificateInterface typisiert ist, liegt eine ProcessMappingViolation vor [SWS_CRYPT_40641].

Die Methode ara::crypto::x509::X509Provider::LoadCertificateGroup dient dem Laden einer Gruppe von Zertifikaten aus dem persistenten Zertifikatsspeicher gemäß [SWS_CRYPT_50126].

Verwendung und Aufrufkontext

Der Aufruf erfolgt über eine Instanz von X509Provider aus dem Header ara/crypto/x509/x509_provider.h. Als Eingabeparameter erwartet die Funktion einen instanceSpecifier vom Typ const ara::core::InstanceSpecifier&, welcher den logischen Speicherort der gewünschten Zertifikatsgruppe identifiziert [SWS_CRYPT_50126]. Als Ergebnis liefert die Schnittstelle ein ara::core::Result<ara::core::Vector<Certificate::Sptrc>> zurück, das im Erfolgsfall einen Vektor mit Smart-Pointern auf die geladenen Zertifikate bereitstellt [SWS_CRYPT_50126]. Mangels asynchroner Rückgabetypen wie ara::core::Future dürfte der Zugriff auf den persistenten Speicher synchron blockierend erfolgen. Frage Q-b743367ccc9904ab (offen)

Fehlerbehandlung und Modellierungseinschränkungen

In der Spezifikation sind keine standardisierten Fehlercodes für den Rückgabewert definiert [SWS_CRYPT_50126]. Jedoch ist eine Laufzeitüberprüfung vorgegeben: Verweist der übergebene instanceSpecifier nicht auf einen für den aktuellen Prozess modellierten PortPrototype, der durch ein CryptoCertificateGroupInterface typisiert ist, liegt eine ProcessMappingViolation vor [SWS_CRYPT_50126].

Nebenläufigkeit und Ausnahmesicherheit

Die rein virtuelle Methode ist mit noexcept annotiert und als ausnahmesicher (exception safe) spezifiziert. Zudem ist der Aufruf explizit als threadsicher (thread-safe) deklariert, sodass parallele Lesezugriffe aus mehreren Threads unbedenklich sind [SWS_CRYPT_50126].

Die Methode ParseCert ist Bestandteil der Klasse ara::crypto::x509::X509Provider (definiert im Header ara/crypto/x509/x509_provider.h) und dient dazu, eine serialisierte Repräsentation eines X.509v3-Zertifikats zu analysieren und ein entsprechendes Zertifikatsobjekt zu instanziieren [SWS_CRYPT_40614].

Aufruf und Parameter: Die Funktion wird synchron aufgerufen und ist als noexcept spezifiziert [SWS_CRYPT_40614]. Sie nimmt zwei Eingabeparameter entgegen:

• cert: Ein Speicherbereich vom Typ ReadOnlyMemRegion, der die im angegebenen Format kodierten Zertifikatsdaten bereitstellt [SWS_CRYPT_40614].
• formatId: Der Bezeichner des Eingabeformats zur Bestimmung des Parsing-Verfahrens [SWS_CRYPT_40614].

Rückgabewert und Fehlerbehandlung: Das Ergebnis wird als ara::core::Result<Certificate::Sptrc> zurückgegeben, das im Erfolgsfall einen Shared Pointer auf das erstellte Zertifikatsobjekt enthält [SWS_CRYPT_40614]. Tritt ein Fehler auf, greift eine Rollback-Semantik mit folgenden spezifischen Fehlercodes [SWS_CRYPT_40614]:

• ara::crypto::CryptoErrc::kInvalidArgument: Das Argument cert kann nicht als gültiges Zertifikat geparst werden [SWS_CRYPT_40614].
• ara::crypto::CryptoErrc::kUnsupportedFormat: Das spezifizierte formatId ist unbekannt oder wird nicht unterstützt [SWS_CRYPT_40614].

Nebenläufigkeit und Implementierung: Die Schnittstelle ist ausdrücklich als exceptionsicher (exception safe) und threadsicher (thread-safe) spezifiziert [SWS_CRYPT_40614]. Da ParseCert rein virtuell deklariert ist, dürfte die tatsächliche Parsing-Logik von einem plattformspezifischen Krypto-Treiber oder Provider bereitgestellt werden [SWS_CRYPT_40614]. Frage Q-d3239d62d2e7d831 (offen)

Verwendung

Die Methode ParseCertChain des Interfaces ara::crypto::x509::X509Provider aus dem Header ara/crypto/x509/x509_provider.h parst eine serialisierte Repräsentation einer Zertifikatskette [SWS_CRYPT_40616]. Als Parameter übernimmt sie den Speicherbereich der codierten Zertifikatskette certChain als ReadOnlyMemRegion sowie den Formatbezeichner formatId vom Typ FormatId [SWS_CRYPT_40616]. Für jedes erfolgreich geparste Zertifikat wird eine neue Certificate-Instanz erzeugt. Im Erfolgsfall liefert die synchrone Funktion ein ara::core::Result mit einem ara::core::Vector<Certificate::Sptrc> zurück, in welchem die Zertifikate in derselben Reihenfolge wie in der übergebenen Kette angeordnet sind [SWS_CRYPT_40616].

Fehlerbehandlung

Im Fehlerfall enthält das zurückgegebene ara::core::Result einen spezifischen Fehlercode mit Rollback-Semantik [SWS_CRYPT_40616]:

• ara::crypto::CryptoErrc::kInvalidArgument: Das Argument certChain kann nicht geparst werden [SWS_CRYPT_40616].
• ara::crypto::CryptoErrc::kUnsupportedFormat: Der angegebene Bezeichner formatId ist unbekannt oder wird nicht unterstützt [SWS_CRYPT_40616].

Nebenläufigkeit und Randbedingungen

Die Methode ist als noexcept deklariert, als threadsicher (thread-safe) spezifiziert und gewährleistet Ausnahmesicherheit (exception safe) [SWS_CRYPT_40616].

Verwendung und Aufrufkontext

Die synchrone Methode ParseOcspResponse ist Teil der Schnittstelle ara::crypto::x509::X509Provider (definiert in ara/crypto/x509/x509_provider.h) und dient dem Einlesen sowie Parsen serialisierter OCSP-Antworten [SWS_CRYPT_50185]. Der Aufrufer übergibt die Rohdaten der Antwort als ReadOnlyMemRegion über den Parameter response sowie das erwartete Datenformat mittels formatId vom Typ FormatId [SWS_CRYPT_50185]. Bei erfolgreicher Validierung und Verarbeitung liefert die Funktion ein ara::core::Result zurück, das einen Smart-Pointer OcspResponse::Sptrc auf das neu erzeugte OCSP-Antwortobjekt kapselt [SWS_CRYPT_50185].

Fehlerbehandlung

Fehlerfälle werden ohne Werfen von Exceptions über den Rückgabetyp ara::core::Result mit Rollback-Semantik signalisiert [SWS_CRYPT_50185]:

• ara::crypto::CryptoErrc::kInvalidArgument: Tritt auf, wenn die im Puffer response bereitgestellten Bytes nicht als gültige OCSP-Antwort geparst werden können [SWS_CRYPT_50185].
• ara::crypto::CryptoErrc::kUnsupportedFormat: Wird gemeldet, falls der übergebene Bezeichner formatId unbekannt ist oder vom Provider nicht unterstützt wird [SWS_CRYPT_50185].

Nebenläufigkeit und Thread-Sicherheit

Die rein virtuelle Methode ist als noexcept deklariert, als ausnahmesicher (exception safe) eingestuft und explizit als threadsicher (thread-safe) spezifiziert [SWS_CRYPT_50185]. Dank der const-Deklaration kann ParseOcspResponse in Multithreading-Umgebungen nebenläufig auf derselben Provider-Instanz aufgerufen werden, ohne den internen Zustand des Objekts zu modifizieren [SWS_CRYPT_50185].

Verwendung

Die synchrone Schnittstellenmethode RemoveCertificateFromGroup aus dem Scope ara::crypto::x509::X509Provider dient dem gezielten Entfernen eines Zertifikats aus einer bestehenden Zertifikatsgruppe [SWS_CRYPT_50128]. Über den Parameter instanceSpecifier wird die betreffende Zertifikatsgruppe identifiziert, während certificate als Smart-Pointer (Certificate::Sptrc) das zu entfernende Zertifikat bereitstellt [SWS_CRYPT_50128]. Der Aufruf liefert ein ara::core::Result<void> zurück, welches den erfolgreichen Vollzug ohne Rückgabewert quittiert oder einen aufgetretenen Fehler kapselt [SWS_CRYPT_50128].

Fehlerbehandlung

Tritt bei der Ausführung ein Fehler auf, greift eine definierte Rollback-Semantik, sodass der Zustand der Zertifikatsgruppe unverändert bleibt [SWS_CRYPT_50128]. Folgende Fehlercodes sind spezifiziert:

• ara::crypto::CryptoErrc::kNoSuchValue: Die angegebene Zertifikatsgruppe enthält das zu entfernende Zertifikat nicht [SWS_CRYPT_50128].
• ara::crypto::CryptoErrc::kBusyResource: Die Operation kann temporär nicht durchgeführt werden, da benötigte Ressourcen belegt sind [SWS_CRYPT_50128].

Nebenläufigkeit und Konfigurationsbedingungen

Die Methode ist als thread-safe und exception safe spezifiziert sowie mit noexcept deklariert [SWS_CRYPT_50128]. Vor dem Aufruf müssen im Systemmodell zwingend folgende Voraussetzungen für den Prozess erfüllt sein [SWS_CRYPT_50128]:

• Zur Vermeidung einer ProcessMappingViolation muss der übergebene InstanceSpecifier auf einen PortPrototype zeigen, der durch ein für den aktuellen Prozess modelliertes CryptoCertificateGroupInterface typisiert ist [SWS_CRYPT_50128].
• Zur Vermeidung einer InsufficientPermissionsViolation muss der aktuelle Prozess über Schreibrechte verfügen, das heißt, CryptoCertificateGroupToPortPrototypeMapping.writeAccess muss auf True konfiguriert sein [SWS_CRYPT_50128].