klasse ara::crypto::x509::X509Provider

Gebruik

De synchrone methode ClearCertificateSlot van de klasse ara::crypto::x509::X509Provider maakt de via parameter instanceSpecifier opgegeven certificaatopslaglocatie leeg [SWS_CRYPT_40622]. Zij retourneert een ara::core::Result<bool>: de teruggeefwaarde is true wanneer een aanwezig certificaat succesvol is gewist, en false wanneer het slot al niet bezet was [SWS_CRYPT_40622].

Foutafhandeling en beperkingen

Als de bewerking tijdelijk niet kan worden uitgevoerd, levert de functie de foutcode ara::crypto::CryptoErrc::kBusyResource met rollback-semantiek [SWS_CRYPT_40622]. Daarnaast zijn er specifieke modellerings- en toegangsvoorwaarden gedefinieerd:

• ProcessMappingViolation: Doet zich voor wanneer de InstanceSpecifier niet wijst naar een voor het huidige proces gemodelleerde PortPrototype met de interface CryptoCertificateInterface [SWS_CRYPT_40622].
• InsufficientPermissionsViolation: Treedt op wanneer het huidige proces schrijfrechten ontbeert, d.w.z. CryptoCertificateToPortPrototypeMapping.writeAccess != True is ingesteld [SWS_CRYPT_40622].

Concurrency

De interface is aangeduid als noexcept, uitzonderingsveilig (exception safe) en voor gelijktijdige aanroepen als thread-safe (thread-safe) gespecificeerd [SWS_CRYPT_40622].

Gebruik

De synchrone methode CreateCertSignRequest van de interface ara::crypto::x509::X509Provider uit header ara/crypto/x509/x509_provider.h maakt een certificaatondertekeningsaanvraag (Certificate Signing Request, CSR) conform de standaard RFC 2986 [SWS_CRYPT_40640]. Als parameters verwacht de functie een volledig geconfigureerde ondertekeningscontext signerCtx, de Distinguished Name van het subject subjectDn, de bijbehorende openbare sleutel publicKey en optionele DER-gecodeerde attributen attributes [SWS_CRYPT_40640]. De meegegeven openbare sleutel moet dwingend corresponderen met de in de ondertekeningscontext geconfigureerde privésleutel. Bij succes wordt een smart pointer naar het aangemaakte CSR (CertSignRequest::Sptrc) verpakt in een ara::core::Result geretourneerd [SWS_CRYPT_40640].

Foutafhandeling

Bij een fout levert de methode een ara::core::Result met een overeenkomstige foutcode conform rollback-semantiek [SWS_CRYPT_40640]:

• ara::crypto::CryptoErrc::kInvalidArgument: Wanneer de meegegeven attribuutgegevens ongeldig zijn of de openbare sleutel niet past bij de privésleutel van de ondertekeningscontext.
• ara::crypto::CryptoErrc::kUninitializedContext: Indien de ondertekeningscontext niet met een sleutelwaarde is geïnitialiseerd.
• ara::crypto::CryptoErrc::kEmptyKeySlot: Indien een geconfigureerde KeySlot momenteel leeg is.
• ara::crypto::CryptoErrc::kUsageViolation: Wanneer het toegestane sleutelgebruik het genereren van signaturen (kAllowSigGeneration) niet omvat.
• ara::crypto::CryptoErrc::kBusyResource: Voor zover een voor de operatie benodigde resource bezet is.

Gelijktijdigheid en beperkingen

De methode is gespecificeerd als const, noexcept, uitzonderingsveilig (exception safe) en thread-safe (thread-safe) [SWS_CRYPT_40640]. Parallelle aanroepen via dezelfde provider-instantie zijn vermoedelijk toegestaan, zolang de meegegeven context- en sleutelobjecten niet gelijktijdig door andere threads worden gewijzigd. Vraag Q-aef8777dce55a033 (open)

De methode CreateCertificateValidationCtx is een functionele interface van de klasse ara::crypto::x509::X509Provider en dient conform [SWS_CRYPT_50125] voor het aanmaken van een certificaatvalidatiecontext. Deze is gedeclareerd in de header #include "ara/crypto/x509/x509_provider.h" en gedefinieerd als een parameterloze, puur virtuele functie [SWS_CRYPT_50125].

De synchrone aanroep retourneert als retourwaarde het type ara::core::Result<CertificateValidationCtx::Sptr>, dat bij succes een smart pointer naar de aangemaakte context levert [SWS_CRYPT_50125]. Voor deze functie worden in de specificatie geen gestandaardiseerde foutcodes gedefinieerd [SWS_CRYPT_50125]. Aangezien het retourneren echter via het resultaattype ara::core::Result plaatsvindt, worden eventuele providerspecifieke fouten tijdens de contextaanmaak vermoedelijk via de foutcomponent van dit Result-object afgehandeld. Vraag Q-f81f52d8e3d73bcf (open)

Met betrekking tot de aanroepcontext en concurrency is de methode uitdrukkelijk gespecificeerd als thread-veilig (thread-safe) en gedeclareerd als uitzonderingsveilig (exception safe) en noexcept [SWS_CRYPT_50125]. Aanroepers kunnen de functie daarom veilig en gelijktijdig vanuit meerdere threads uitvoeren, zonder dat een aanvullende synchronisatie voor het aanmaakproces hoeft te worden voorzien [SWS_CRYPT_50125].

Gebruik

De puur virtuele methode CreateDn wordt beschikbaar gesteld via de interface ara::crypto::x509::X509Provider uit het headerbestand ara/crypto/x509/x509_provider.h [SWS_CRYPT_50186]. Deze dient om een X.509-Distinguished-Name-object (X509DN::Sptrc) aan de hand van een tekenreeksweergave te instantiëren [SWS_CRYPT_50186]. Als invoerparameter verwacht zij dnString van het type ara::core::StringView, dat een Distinguished Name conform RFC 4514 moet vertegenwoordigen [SWS_CRYPT_50186]. Interpretatie: Aangezien de functie als const noexcept is gedeclareerd en direct een ara::core::Result retourneert, vindt de aanroep vermoedelijk synchroon blokkerend plaats zonder statuswijziging van de provider. Vraag Q-c7e3ab6b4f34ad0f (open)

Foutafhandeling

Kan de doorgegeven tekenreeks niet succesvol worden verwerkt omdat deze geen geldige DN conform RFC 4514 vormt, dan levert de functie een ara::core::Result op met de foutcode ara::crypto::CryptoErrc::kInvalidArgument [SWS_CRYPT_50186]. Voor dit foutgeval is rollback-semantiek gespecificeerd [SWS_CRYPT_50186].

Gelijktijdigheid en beperkingen

De methode is expliciet als uitzonderingsveilig (exception safe) en thread-safe (thread-safe) gespecificeerd [SWS_CRYPT_50186]. Zij kan zodoende zonder aanvullende externe synchronisatie vanuit concurrerende threads worden aangeroepen.

Samenspel

Als alternatief voor de op tekenreeksen gebaseerde creatie stelt ara::crypto::x509::X509Provider een verdere overbelasting van CreateDn beschikbaar [SWS_CRYPT_50187]. Deze maakt de constructie van een X509DN mogelijk vanuit een geserialiseerde buffer (ReadOnlyMemRegion) onder vermelding van een formaat-ID (FormatId) [SWS_CRYPT_50187].

Gebruik

De methode CreateDn volgens [SWS_CRYPT_50187] dient voor het genereren van een Distinguished Name (DN) uit een geserialiseerde buffer. Ze wordt synchroon op een instantie van ara::crypto::x509::X509Provider aangeroepen. Als invoer verwacht de functie een geheugengebied dn van het type ReadOnlyMemRegion dat de geserialiseerde data bevat, evenals een formaat-id formatId van het type FormatId. Bij succesvolle uitvoering retourneert de methode een ara::core::Result<X509DN::Sptrc> die een shared pointer naar het gegenereerde X509DN-object beschikbaar stelt.

Foutafhandeling

Mislukt het genereren, dan retourneert de methode een bijbehorende foutcode binnen de ara::core::Result ([SWS_CRYPT_50187]):

• ara::crypto::CryptoErrc::kInvalidArgument: Treedt met rollback-semantiek op wanneer de doorgegeven buffer dn ongeldig is.
• ara::crypto::CryptoErrc::kUnsupportedFormat: Wordt met rollback-semantiek gemeld indien de opgegeven formatId onbekend of niet-ondersteund is.

Gelijktijdigheid en wisselwerking

De interface is gespecificeerd als thread-safe en exception safe en gedeclareerd met noexcept ([SWS_CRYPT_50187]). Ze kan daarom veilig parallel vanuit meerdere uitvoeringscontexten worden aangeroepen.

In tegenstelling tot de alternatieve overload [SWS_CRYPT_50186], die een DN genereert uit een tekenreeks (ara::core::StringView) conform RFC 4514, verwerkt deze functie geserialiseerde binaire data. De concrete waarden voor FormatId zullen vermoedelijk elders binnen de module gedefinieerd zijn. Vraag Q-dd7cbf35ba6fa7d1 (open)

Gebruik

De methode CreateOcspRequest van de klasse ara::crypto::x509::X509Provider genereert synchroon een OCSP-statusaanvraag (Online Certificate Status Protocol) voor een afzonderlijk certificaat conform RFC 6960 [SWS_CRYPT_40626]. Als parameters worden het te controleren certificaat cert en het verlenercertificaat daarvan issuerCert elk als Certificate::Sptrc doorgegeven [SWS_CRYPT_40626]. Via de optionele parameter signerCtx kan een pointer naar een ondertekeningscontext worden verstrekt, indien het verzoek cryptografisch moet worden ondertekend [SWS_CRYPT_40626]. De functie retourneert een ara::core::Result met een ara::core::Vector<std::uint8_t>; de opgenomen ruwe gegevens komen vermoedelijk overeen met de DER-gecodeerde aanvraagstructuur conform RFC 6960 [SWS_CRYPT_40626]. Vraag Q-c43cf023ee5eddd9 (open)

Foutafhandeling

Treedt bij het aanmaken een fout op, dan levert de ara::core::Result specifieke foutcodes met rollback-semantiek [SWS_CRYPT_40626]:

• ara::crypto::CryptoErrc::kUninitializedContext: Treedt op wanneer de overgedragen ondertekeningscontext niet is geïnitialiseerd met een sleutel [SWS_CRYPT_40626].
• ara::crypto::CryptoErrc::kBusyResource: Treedt op wanneer de bewerking wegens tijdelijk bezette resources niet kan worden uitgevoerd [SWS_CRYPT_40626].

Gelijktijdigheid en wisselwerking

De methode is gedeclareerd als noexcept, geldt als uitzonderingsveilig (exception safe) en is thread-safe gespecificeerd [SWS_CRYPT_40626]. Voor scenario's waarin meerdere certificaten tegelijkertijd in een gezamenlijk OCSP-verzoek moeten worden gebundeld, is de overbelaste interface [SWS_CRYPT_40627] voor certificaatlijsten beschikbaar.

Gebruik

De methode CreateOcspRequest van de interface ara::crypto::x509::X509Provider ([SWS_CRYPT_40627]) dient voor het synchroon aanmaken van een OCSP-verificatieaanvraag (Online Certificate Status Protocol) conform RFC 6960 voor meerdere certificaten. De aanroep wordt beschikbaar gesteld via header #include "ara/crypto/x509/x509_provider.h".

Als invoerparameters verwacht de functie:

• certList: Een lijst van de te valideren certificaten als ara::core::Span<Certificate::Sptrc>.
• issuerCertList: Een lijst van de bijbehorende uitgeverscertificaten als ara::core::Span<Certificate::Sptrc>. Interpretatie: tussen de items van beide lijsten wordt vermoedelijk een paarsgewijze toewijzing op basis van index verondersteld. Vraag Q-9132b017c2c4be75 (open)
• signerCtx: Een optionele pointer naar een geïnitialiseerde ondertekeningscontext (ara::core::Optional<cryp::SignerPrivateCtx::Sptr>), voor het geval de aanvraag cryptografisch moet worden ondertekend.

Als teruggeefwaarde levert de functie een ara::core::Result op, die bij succesvolle aanmaak de binaire gegevens van de OCSP-aanvraag in een ara::core::Vector<std::uint8_t> levert ([SWS_CRYPT_40627]).

Foutafhandeling

Bij een fout levert de ara::core::Result foutcodes met rollback-semantiek ([SWS_CRYPT_40627]):

• ara::crypto::CryptoErrc::kUninitializedContext: Treedt op wanneer de meegegeven ondertekeningscontext niet met een sleutel is geïnitialiseerd.
• ara::crypto::CryptoErrc::kBusyResource: Treedt op wanneer de operatie wegens tijdelijk bezette resources tijdelijk niet kan worden uitgevoerd.

Gelijktijdigheid en wisselwerking

De methode is gespecificeerd als thread-safe en exception safe en gedeclareerd met noexcept ([SWS_CRYPT_40627]). In tegenstelling tot [SWS_CRYPT_40626], waar de OCSP-aanvraag voor een individueel certificaat wordt gegenereerd, maakt deze interface het bundelen van meerdere certificaten in één enkele aanvraag mogelijk.

Gebruik

De methode DeleteCrl van de interface ara::crypto::x509::X509Provider dient voor het wissen van een persistent opgeslagen certificaatintrekkingslijst (Certificate Revocation List, CRL) [SWS_CRYPT_50184]. Als parameter wordt de crlInstanceSpecifier doorgegeven, die verwijst naar een RPortPrototype van een CryptoCertificateInterface die het bijbehorende certificaat identificeert [SWS_CRYPT_50184]. De functie werkt synchroon en retourneert een ara::core::Result<void>; deze is leeg wanneer de CRL succesvol is gewist of er vooraf helemaal geen CRL was opgeslagen [SWS_CRYPT_50184].

Foutafhandeling en gelijktijdigheid

Als er tijdens de uitvoering een tijdelijk bronconflict optreedt, meldt de functie de fout ara::crypto::CryptoErrc::kBusyResource met rollback-semantiek [SWS_CRYPT_50184]. De methode is gedeclareerd als noexcept en gespecificeerd als exception-safe en thread-safe [SWS_CRYPT_50184].

Beperkingen en configuratievoorwaarden

Voor de aanroep gelden de volgende configuratie- en machtigingsvoorwaarden [SWS_CRYPT_50184]:

• ProcessMappingViolation: treedt op wanneer de InstanceSpecifier niet wijst naar een voor het huidige proces gemodelleerde PortPrototype die getypeerd is door een CryptoCertificateInterface [SWS_CRYPT_50184].
• InsufficientPermissionsViolation: treedt op wanneer het huidige proces geen schrijfmachtigingen heeft, dat wil zeggen CryptoCertificateToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50184].

Gebruik

De methode ImportCertificate van de interface ara::crypto::x509::X509Provider (gedeclareerd in ara/crypto/x509/x509_provider.h) dient voor het persistent opslaan van een X.509-certificaat in een gedefinieerd certificaatslot [SWS_CRYPT_40621]. Het doel-slot wordt geadresseerd via instanceSpecifier (type ara::core::InstanceSpecifier), terwijl het te importeren certificaat wordt meegegeven via het argument certificate (type Certificate::Sptrc) [SWS_CRYPT_40621]. Interpretatie: de uitvoering zal vermoedelijk synchroon plaatsvinden, aangezien de interface direct een ara::core::Result<void> teruglevert [SWS_CRYPT_40621]. Vraag Q-514863e9a90f1c72 (open)

Foutafhandeling en modelleringsregels

In het geval van een fout wordt een foutieve ara::core::Result geretourneerd. Kan de bewerking tijdelijk niet worden uitgevoerd, dan levert de methode ara::crypto::CryptoErrc::kBusyResource met rollback-semantiek [SWS_CRYPT_40621]. Daarnaast moet worden voldaan aan configuratie- en modelleringsvoorschriften, aangezien anders runtime-overtredingen worden gemeld [SWS_CRYPT_40621]:

• ProcessMappingViolation: Wordt geactiveerd indien de instanceSpecifier niet wijst naar een voor het huidige proces gemodelleerde PortPrototype die is getypeerd door een CryptoCertificateInterface [SWS_CRYPT_40621].
• InsufficientPermissionsViolation: Treedt op wanneer voor het huidige proces geen schrijfrecht aanwezig is (CryptoCertificateToPortPrototypeMapping.writeAccess != True) [SWS_CRYPT_40621].

Gelijktijdigheid en uitvoeringscontext

De bewerking is gespecificeerd als thread-safe en exception safe (noexcept=0), waardoor concurrente aanroepen zonder externe vergrendelingen beveiligd zijn [SWS_CRYPT_40621].

Gebruik

De methode ImportCertificateInGroup van de klasse ara::crypto::x509::X509Provider slaat een verstrekt certificaat persistent op in een via instanceSpecifier geïdentificeerde certificaatgroep [SWS_CRYPT_50127]. Als parameters worden een referentie naar de ara::core::InstanceSpecifier van de doelgroep en een smart pointer naar het certificaat (Certificate::Sptrc certificate) doorgegeven [SWS_CRYPT_50127]. De aanroep wordt gedeclareerd via de header ara/crypto/x509/x509_provider.h en retourneert synchroon een ara::core::Result<void>, die de succesvolle import signaleert of een foutstatus inkapselt [SWS_CRYPT_50127].

Foutafhandeling en schendingen

In een regulier foutgeval biedt de operatie rollback-semantiek en levert deze specifieke foutcodes op in het Result-object [SWS_CRYPT_50127]:

• ara::crypto::CryptoErrc::kInsufficientCapacity: De capaciteit van de geadresseerde certificaatgroep is ontoereikend om het certificaat op te nemen [SWS_CRYPT_50127].
• ara::crypto::CryptoErrc::kBusyResource: De operatie kan tijdelijk niet worden uitgevoerd, omdat de vereiste bron bezet is [SWS_CRYPT_50127].

Daarnaast zijn er bindende modellerings- en autorisatievereisten gedefinieerd, waarvan het niet-naleven als overtreding (violation) is geclassificeerd [SWS_CRYPT_50127]:

• ProcessMappingViolation: Treedt op wanneer de InstanceSpecifier niet wijst naar een voor het huidige proces gemodelleerde PortPrototype, die door een CryptoCertificateGroupInterface is getypeerd [SWS_CRYPT_50127].
• InsufficientPermissionsViolation: Treedt op wanneer het aanroepende proces geen schrijfrechten heeft, wat gekarakteriseerd wordt door CryptoCertificateGroupToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50127].

Gelijktijdigheid en uitvoeringscontext

De interface is gespecificeerd als thread-veilig (thread-safe) evenals uitzonderingsveilig (exception safe) en gedeclareerd met noexcept [SWS_CRYPT_50127].

De methode ImportCrl van de klasse ara::crypto::x509::X509Provider parset en persisteert een Certificate Revocation List (CRL) of Delta CRL die is uitgegeven door het via crlInstanceSpecifier geïdentificeerde CA-certificaat [SWS_CRYPT_50183]. De uitvoering zal vermoedelijk synchroon plaatsvinden, aangezien er direct een ara::core::Result wordt geretourneerd. Vraag Q-648a00ec967c7524 (open)

Bij de aanroep worden de volgende parameters doorgegeven [SWS_CRYPT_50183]:

• crlInstanceSpecifier: ara::core::InstanceSpecifier naar de RPortPrototype van een CryptoCertificateInterface die het certificaat identificeert.
• crl: ReadOnlyMemRegion met de geserialiseerde CRL- of Delta-CRL-data.
• formatId: Formaat van de geserialiseerde CRL.

De bewerking is gespecificeerd als thread-safe en exception-safe [SWS_CRYPT_50183]. Ze levert bij succes een ara::core::Result met de status CertificateValidationStatus::kValid of het validatieresultaat van de CRL op [SWS_CRYPT_50183].

In geval van fouten hebben de retourwaarden rollback-semantiek [SWS_CRYPT_50183]:

• ara::crypto::CryptoErrc::kInvalidArgument: De CRL voldoet niet aan het opgegeven formaat.
• ara::crypto::CryptoErrc::kUnsupportedFormat: De opgegeven FormatId is onbekend of wordt niet ondersteund.
• ara::crypto::CryptoErrc::kBusyResource: De bewerking kan tijdelijk niet worden uitgevoerd.

Daarnaast moet worden voldaan aan configuratievereisten [SWS_CRYPT_50183]: Een ProcessMappingViolation treedt op wanneer de instantie-identificator niet verwijst naar een voor het huidige proces gemodelleerde poort, en een InsufficientPermissionsViolation wanneer CryptoCertificateToPortPrototypeMapping.writeAccess != True is ingesteld.

De methode LoadCertificate van de interface ara::crypto::x509::X509Provider dient voor het laden van een certificaat uit de persistente certificaatopslag [SWS_CRYPT_40641]. De aanroep wordt synchroon uitgevoerd (interpretatie: directe teruggave van ara::core::Result zonder asynchroon future-object zoals ara::core::Future). Vraag Q-a2e3c23a02b4f8a1 (open) Als invoerparameter verwacht de functie een ara::core::InstanceSpecifier, die de concrete opslaglocatie van het certificaat identificeert [SWS_CRYPT_40641].

De retourwaarde kapselt bij succesvolle uitvoering een smart pointer naar het geïnstantieerde certificaat (Certificate::Sptrc) in binnen een ara::core::Result [SWS_CRYPT_40641]. Mislukt het laden, dan bevat het resultaat een foutcode:

• ara::crypto::CryptoErrc::kEmptyCertificateSlot: Treedt op met rollback-semantiek indien het door de opgegeven instanceSpecifier geïdentificeerde CryptoCertificate geen gepersisteerd certificaat bevat [SWS_CRYPT_40641].

Wat betreft concurrency en exception-veiligheid is LoadCertificate gespecificeerd als thread-safe en exception-safe en gedeclareerd als noexcept [SWS_CRYPT_40641]. Bij de configuratie en procestoewijzing moet rekening worden gehouden met een modelleringsvoorwaarde: verwijst de meegegeven instanceSpecifier niet naar een voor het huidige proces gemodelleerde PortPrototype die is getypeerd door een CryptoCertificateInterface, dan is er sprake van een ProcessMappingViolation [SWS_CRYPT_40641].

De methode ara::crypto::x509::X509Provider::LoadCertificateGroup dient voor het laden van een groep certificaten uit het persistente certificaatgeheugen conform [SWS_CRYPT_50126].

Gebruik en aanroepcontext

De aanroep vindt plaats via een instantie van X509Provider uit de header ara/crypto/x509/x509_provider.h. Als invoerparameter verwacht de functie een instanceSpecifier van het type const ara::core::InstanceSpecifier&, die de logische opslaglocatie van de gewenste certificaatgroep identificeert [SWS_CRYPT_50126]. Als resultaat retourneert de interface een ara::core::Result<ara::core::Vector<Certificate::Sptrc>>, die bij succes een vector met smart pointers naar de geladen certificaten levert [SWS_CRYPT_50126]. Bij gebrek aan asynchrone retourtypen zoals ara::core::Future vindt de toegang tot het persistente geheugen vermoedelijk synchroon blokkerend plaats. Vraag Q-b743367ccc9904ab (open)

Foutafhandeling en modelleringsbeperkingen

In de specificatie zijn geen gestandaardiseerde foutcodes voor de retourwaarde gedefinieerd [SWS_CRYPT_50126]. Er is echter wel een runtime-controle voorgeschreven: als de doorgegeven instanceSpecifier niet verwijst naar een voor het huidige proces gemodelleerde PortPrototype, die door een CryptoCertificateGroupInterface is getypeerd, is er sprake van een ProcessMappingViolation [SWS_CRYPT_50126].

Concurrentie en exceptieveiligheid

De puur virtuele methode is geannoteerd met noexcept en gespecificeerd als uitzonderingsveilig (exception safe). Bovendien is de aanroep expliciet gedeclareerd als thread-veilig (thread-safe), zodat parallelle leesbewerkingen vanuit meerdere threads veilig zijn [SWS_CRYPT_50126].

De methode ParseCert maakt deel uit van de klasse ara::crypto::x509::X509Provider (gedefinieerd in header ara/crypto/x509/x509_provider.h) en dient om een geserialiseerde representatie van een X.509v3-certificaat te analyseren en een bijbehorend certificaatobject te instantiëren [SWS_CRYPT_40614].

Aanroep en parameters: De functie wordt synchroon aangeroepen en is gespecificeerd als noexcept [SWS_CRYPT_40614]. Ze accepteert twee invoerparameters:

• cert: Een geheugengebied van het type ReadOnlyMemRegion dat de in het opgegeven formaat gecodeerde certificaatgegevens levert [SWS_CRYPT_40614].
• formatId: De identifier van het invoerformaat voor het bepalen van de parsingprocedure [SWS_CRYPT_40614].

Teruggeefwaarde en foutafhandeling: Het resultaat wordt geretourneerd als ara::core::Result<Certificate::Sptrc>, dat bij succes een shared pointer naar het gemaakte certificaatobject bevat [SWS_CRYPT_40614]. Als er een fout optreedt, geldt een rollback-semantiek met de volgende specifieke foutcodes [SWS_CRYPT_40614]:

• ara::crypto::CryptoErrc::kInvalidArgument: Het argument cert kan niet als een geldig certificaat worden geparset [SWS_CRYPT_40614].
• ara::crypto::CryptoErrc::kUnsupportedFormat: Het gespecificeerde formatId is onbekend of wordt niet ondersteund [SWS_CRYPT_40614].

Gelijktijdigheid en implementatie: De interface is uitdrukkelijk gespecificeerd als exception-safe (exception safe) en thread-safe (thread-safe) [SWS_CRYPT_40614]. Omdat ParseCert puur virtueel is gedeclareerd, wordt de feitelijke parsinglogica vermoedelijk geleverd door een platformspecifieke cryptodriver of provider [SWS_CRYPT_40614]. Vraag Q-d3239d62d2e7d831 (open)

Gebruik

De methode ParseCertChain van de interface ara::crypto::x509::X509Provider uit header ara/crypto/x509/x509_provider.h parset een geserialiseerde representatie van een certificaatketen [SWS_CRYPT_40616]. Als parameters accepteert zij het geheugengebied van de gecodeerde certificaatketen certChain als ReadOnlyMemRegion en de formaat-identifier formatId van het type FormatId [SWS_CRYPT_40616]. Voor elk succesvol geparset certificaat wordt een nieuwe Certificate-instantie gecreëerd. Bij succes retourneert de synchrone functie een ara::core::Result met een ara::core::Vector<Certificate::Sptrc>, waarin de certificaten in dezelfde volgorde zijn gerangschikt als in de meegegeven keten [SWS_CRYPT_40616].

Foutafhandeling

Bij een fout bevat de geretourneerde ara::core::Result een specifieke foutcode met rollback-semantiek [SWS_CRYPT_40616]:

• ara::crypto::CryptoErrc::kInvalidArgument: Het argument certChain kan niet worden geparset [SWS_CRYPT_40616].
• ara::crypto::CryptoErrc::kUnsupportedFormat: De opgegeven identifier formatId is onbekend of wordt niet ondersteund [SWS_CRYPT_40616].

Gelijktijdigheid en randvoorwaarden

De methode is gedeclareerd als noexcept, gespecificeerd als thread-safe (thread-safe) en waarborgt uitzonderingsveiligheid (exception safe) [SWS_CRYPT_40616].

Gebruik en aanroepcontext

De synchrone methode ParseOcspResponse maakt deel uit van de interface ara::crypto::x509::X509Provider (gedefinieerd in ara/crypto/x509/x509_provider.h) en dient voor het inlezen en parsen van geserialiseerde OCSP-antwoorden [SWS_CRYPT_50185]. De aanroeper geeft de ruwe data van het antwoord door als ReadOnlyMemRegion via de parameter response en het verwachte dataformaat middels formatId van het type FormatId [SWS_CRYPT_50185]. Bij succesvolle validatie en verwerking retourneert de functie een ara::core::Result die een smart pointer OcspResponse::Sptrc naar het nieuw aangemaakte OCSP-antwoordobject inkapselt [SWS_CRYPT_50185].

Foutafhandeling

Foutsituaties worden zonder het opwerpen van exceptions via het retourtype ara::core::Result met rollback-semantiek gesignaleerd [SWS_CRYPT_50185]:

• ara::crypto::CryptoErrc::kInvalidArgument: Treedt op wanneer de in de buffer response klaargezette bytes niet als geldig OCSP-antwoord kunnen worden geparst [SWS_CRYPT_50185].
• ara::crypto::CryptoErrc::kUnsupportedFormat: Wordt gemeld indien de doorgegeven identificator formatId onbekend is of niet door de provider wordt ondersteund [SWS_CRYPT_50185].

Gelijktijdigheid en thread-safety

De zuiver virtuele methode is gedeclareerd als noexcept, geclassificeerd als uitzonderingsveilig (exception safe) en expliciet gespecificeerd als thread-veilig (thread-safe) [SWS_CRYPT_50185]. Dankzij de const-declaratie kan ParseOcspResponse in multithreading-omgevingen gelijktijdig op dezelfde provider-instantie worden aangeroepen zonder de interne toestand van het object te wijzigen [SWS_CRYPT_50185].

Gebruik

De synchrone interfacemethode RemoveCertificateFromGroup uit de scope ara::crypto::x509::X509Provider dient voor het gericht verwijderen van een certificaat uit een bestaande certificaatgroep [SWS_CRYPT_50128]. Via de parameter instanceSpecifier wordt de desbetreffende certificaatgroep geïdentificeerd, terwijl certificate als smart pointer (Certificate::Sptrc) het te verwijderen certificaat levert [SWS_CRYPT_50128]. De aanroep retourneert een ara::core::Result<void>, die de succesvolle voltooiing zonder retourwaarde bevestigt of een opgetreden fout inkapselt [SWS_CRYPT_50128].

Foutafhandeling

Als er tijdens de uitvoering een fout optreedt, treedt een gedefinieerde rollback-semantiek in werking, zodat de toestand van de certificaatgroep ongewijzigd blijft [SWS_CRYPT_50128]. De volgende foutcodes zijn gespecificeerd:

• ara::crypto::CryptoErrc::kNoSuchValue: De opgegeven certificaatgroep bevat het te verwijderen certificaat niet [SWS_CRYPT_50128].
• ara::crypto::CryptoErrc::kBusyResource: De operatie kan tijdelijk niet worden uitgevoerd, omdat benodigde bronnen bezet zijn [SWS_CRYPT_50128].

Concurrency en configuratievoorwaarden

De methode is gespecificeerd als thread-safe en exception safe en gedeclareerd met noexcept [SWS_CRYPT_50128]. Vóór de aanroep moet in het systeemmodel dwingend aan de volgende voorwaarden voor het proces worden voldaan [SWS_CRYPT_50128]:

• Om een ProcessMappingViolation te voorkomen, moet de doorgegeven InstanceSpecifier wijzen naar een PortPrototype die is getypeerd door een voor het huidige proces gemodelleerde CryptoCertificateGroupInterface [SWS_CRYPT_50128].
• Om een InsufficientPermissionsViolation te voorkomen, moet het huidige proces over schrijfrechten beschikken, dat wil zeggen dat CryptoCertificateGroupToPortPrototypeMapping.writeAccess geconfigureerd moet zijn op True [SWS_CRYPT_50128].