classe ara::crypto::x509::X509Provider

Utilisation

La méthode synchrone ClearCertificateSlot de la classe ara::crypto::x509::X509Provider vide l'emplacement de mémoire de certificats spécifié via le paramètre instanceSpecifier [SWS_CRYPT_40622]. Elle renvoie un ara::core::Result<bool> : la valeur de retour est true si un certificat existant a été supprimé avec succès, et false si l'emplacement était déjà inoccupé [SWS_CRYPT_40622].

Traitement des erreurs et restrictions

Si l'opération ne peut pas être exécutée temporairement, la fonction fournit le code d'erreur ara::crypto::CryptoErrc::kBusyResource avec une sémantique de rollback [SWS_CRYPT_40622]. De plus, des conditions préalables spécifiques de modélisation et d'accès sont définies :

• ProcessMappingViolation : Se produit lorsque le InstanceSpecifier ne pointe pas vers un PortPrototype modélisé pour le processus actuel avec l'interface CryptoCertificateInterface [SWS_CRYPT_40622].
• InsufficientPermissionsViolation : Survient lorsque le processus actuel manque de droits d'écriture, c'est-à-dire que CryptoCertificateToPortPrototypeMapping.writeAccess != True est défini [SWS_CRYPT_40622].

concurrence

L'interface est désignée comme noexcept, sûre vis-à-vis des exceptions (exception safe) et spécifiée comme thread-safe (thread-safe) pour les appels concurrents [SWS_CRYPT_40622].

Utilisation

La méthode synchrone CreateCertSignRequest de l'interface ara::crypto::x509::X509Provider de l'en-tête ara/crypto/x509/x509_provider.h crée une demande de signature de certificat (Certificate Signing Request, CSR) conformément au standard RFC 2986 [SWS_CRYPT_40640]. Comme paramètres, la fonction attend un contexte de signature entièrement configuré signerCtx, le nom distinctif (Distinguished Name) du sujet subjectDn, la clé publique associée publicKey ainsi que des attributs optionnels codés en DER attributes [SWS_CRYPT_40640]. La clé publique transmise doit obligatoirement correspondre à la clé privée configurée dans le contexte de signature. En cas de succès, un pointeur intelligent vers le CSR créé (CertSignRequest::Sptrc) encapsulé dans un ara::core::Result est renvoyé [SWS_CRYPT_40640].

Gestion des erreurs

En cas d'erreur, la méthode renvoie un ara::core::Result avec un code d'erreur correspondant selon la sémantique de rollback [SWS_CRYPT_40640] :

• ara::crypto::CryptoErrc::kInvalidArgument : si les données d'attributs transmises sont invalides ou si la clé publique ne correspond pas à la clé privée du contexte de signature.
• ara::crypto::CryptoErrc::kUninitializedContext : si le contexte de signature n'a pas été initialisé avec une valeur de clé.
• ara::crypto::CryptoErrc::kEmptyKeySlot : si un KeySlot configuré est actuellement vide.
• ara::crypto::CryptoErrc::kUsageViolation : si l'utilisation autorisée de la clé n'englobe pas la génération de signature (kAllowSigGeneration).
• ara::crypto::CryptoErrc::kBusyResource : pour autant qu'une ressource requise pour l'opération soit occupée.

Concurrence et restrictions

La méthode est spécifiée comme const, noexcept, sans émission d'exceptions (exception safe) et sûre au regard des threads (thread-safe) [SWS_CRYPT_40640]. Des appels parallèles via la même instance de provider devraient être autorisés tant que les objets de contexte et de clé transmis ne sont pas modifiés simultanément par d'autres threads. Question Q-aef8777dce55a033 (ouverte)

La méthode CreateCertificateValidationCtx est une interface fonctionnelle de la classe ara::crypto::x509::X509Provider et sert, conformément à [SWS_CRYPT_50125], à créer un contexte de validation de certificat. Elle est déclarée dans l'en-tête #include "ara/crypto/x509/x509_provider.h" et définie comme une fonction purement virtuelle sans paramètre [SWS_CRYPT_50125].

L'appel synchrone renvoie comme valeur de retour le type ara::core::Result<CertificateValidationCtx::Sptr>, qui met à disposition un smart pointer vers le contexte créé en cas de succès [SWS_CRYPT_50125]. Aucun code d'erreur standardisé n'est défini dans la spécification pour cette fonction [SWS_CRYPT_50125]. Toutefois, le retour s'effectuant via le type de résultat ara::core::Result, d'éventuelles erreurs spécifiques au fournisseur pendant la création du contexte devraient être représentées via le composant d'erreur de cet objet Result. Question Q-f81f52d8e3d73bcf (ouverte)

En ce qui concerne le contexte d'appel et la concurrence, la méthode est expressément spécifiée comme sûre pour les threads (thread-safe) ainsi que déclarée sûre face aux exceptions (exception safe) et noexcept [SWS_CRYPT_50125]. Les appelants peuvent donc exécuter la fonction de manière sûre et concurrente à partir de plusieurs threads sans devoir prévoir de synchronisation supplémentaire pour le processus de création [SWS_CRYPT_50125].

Utilisation

La méthode purement virtuelle CreateDn est mise à disposition via l'interface ara::crypto::x509::X509Provider issue du fichier d'en-tête ara/crypto/x509/x509_provider.h [SWS_CRYPT_50186]. Elle sert à instancier un objet X.509 Distinguished Name (X509DN::Sptrc) à partir d'une représentation sous forme de chaîne de caractères [SWS_CRYPT_50186]. Comme paramètre d'entrée, elle attend dnString de type ara::core::StringView, qui doit représenter un Distinguished Name conforme à la RFC 4514 [SWS_CRYPT_50186]. Interprétation : comme la fonction est déclarée comme const noexcept et renvoie directement un ara::core::Result, l'appel devrait s'effectuer de manière synchrone et bloquante, sans modification d'état du fournisseur. Question Q-c7e3ab6b4f34ad0f (ouverte)

Gestion des erreurs

Si la chaîne de caractères transmise ne peut pas être traitée avec succès parce qu'elle ne constitue pas un DN valide selon la RFC 4514, la fonction fournit un ara::core::Result avec le code d'erreur ara::crypto::CryptoErrc::kInvalidArgument [SWS_CRYPT_50186]. Des sémantiques de rollback sont spécifiées pour ce cas d'erreur [SWS_CRYPT_50186].

Concurrence et restrictions

La méthode est explicitement spécifiée comme sûre face aux exceptions (exception safe) et sûre vis-à-vis des threads (thread-safe) [SWS_CRYPT_50186]. Elle peut ainsi être appelée depuis des threads concurrents sans synchronisation externe supplémentaire.

Interaction

Comme alternative à la génération basée sur des chaînes de caractères, ara::crypto::x509::X509Provider met à disposition une autre surcharge de CreateDn [SWS_CRYPT_50187]. Celle-ci permet la construction d'un X509DN à partir d'un tampon sérialisé (ReadOnlyMemRegion) en indiquant un identifiant de format (FormatId) [SWS_CRYPT_50187].

Utilisation

La méthode CreateDn selon [SWS_CRYPT_50187] sert à créer un Distinguished Name (DN) à partir d'un tampon sérialisé. Elle est appelée de manière synchrone sur une instance de ara::crypto::x509::X509Provider. En entrée, la fonction attend une zone mémoire dn de type ReadOnlyMemRegion contenant les données sérialisées, ainsi qu'un identifiant de format formatId de type FormatId. En cas d'exécution réussie, la méthode renvoie un ara::core::Result<X509DN::Sptrc> fournissant un shared pointer vers l'objet X509DN créé.

Gestion des erreurs

Si la création échoue, la méthode renvoie un code d'erreur correspondant au sein du ara::core::Result ([SWS_CRYPT_50187]) :

• ara::crypto::CryptoErrc::kInvalidArgument : survient avec une sémantique de rollback lorsque le tampon dn transmis n'est pas valide.
• ara::crypto::CryptoErrc::kUnsupportedFormat : est signalé avec une sémantique de rollback si la formatId indiquée est inconnue ou non prise en charge.

Concurrence et interaction

L'interface est spécifiée comme thread-safe ainsi que exception safe et déclarée avec noexcept ([SWS_CRYPT_50187]). Elle peut donc être appelée en parallèle de manière sûre depuis plusieurs contextes d'exécution.

À la différence de la surcharge alternative [SWS_CRYPT_50186], qui crée un DN à partir d'une chaîne de caractères (ara::core::StringView) conformément à la RFC 4514, cette fonction traite des données binaires sérialisées. Les variantes concrètes pour FormatId devraient quant à elles être définies ailleurs à l'échelle du module. Question Q-dd7cbf35ba6fa7d1 (ouverte)

Utilisation

La méthode CreateOcspRequest de la classe ara::crypto::x509::X509Provider génère de manière synchrone une requête de vérification OCSP (Online Certificate Status Protocol) pour un certificat unique conformément à la RFC 6960 [SWS_CRYPT_40626]. Sont transmis comme paramètres le certificat à vérifier cert et son certificat émetteur issuerCert, chacun en tant que Certificate::Sptrc [SWS_CRYPT_40626]. Via le paramètre optionnel signerCtx, un pointeur vers un contexte de signature peut être fourni si la requête doit être signée cryptographiquement [SWS_CRYPT_40626]. La fonction renvoie un ara::core::Result contenant un ara::core::Vector<std::uint8_t> ; les données brutes contenues devraient correspondre à la structure de requête encodée en DER conformément à la RFC 6960 [SWS_CRYPT_40626]. Question Q-c43cf023ee5eddd9 (ouverte)

Gestion des erreurs

Si une erreur survient lors de la création, le ara::core::Result fournit des codes d'erreur spécifiques avec une sémantique de rollback [SWS_CRYPT_40626] :

• ara::crypto::CryptoErrc::kUninitializedContext : survient lorsque le contexte de signature transmis n'est pas initialisé avec une clé [SWS_CRYPT_40626].
• ara::crypto::CryptoErrc::kBusyResource : survient lorsque l'opération ne peut pas être effectuée en raison de ressources temporairement occupées [SWS_CRYPT_40626].

Concurrence et interaction

La méthode est déclarée comme noexcept, est considérée comme sûre vis-à-vis des exceptions (exception safe) et est spécifiée comme thread-safe [SWS_CRYPT_40626]. Pour les scénarios dans lesquels plusieurs certificats doivent être regroupés simultanément dans une requête OCSP commune, l'interface surchargée [SWS_CRYPT_40627] pour listes de certificats est disponible.

Utilisation

La méthode CreateOcspRequest de l'interface ara::crypto::x509::X509Provider ([SWS_CRYPT_40627]) sert à la création synchrone d'une requête de vérification OCSP (Online Certificate Status Protocol) selon la RFC 6960 pour plusieurs certificats. L'appel est mis à disposition via l'en-tête #include "ara/crypto/x509/x509_provider.h".

Comme paramètre d'entrée, la fonction attend :

• certList : Une liste des certificats à valider sous forme de ara::core::Span<Certificate::Sptrc>.
• issuerCertList : Une liste des certificats d'émetteur associés sous forme de ara::core::Span<Certificate::Sptrc>. Interprétation : une correspondance par paires selon l'index devrait être présupposée entre les entrées des deux listes. Question Q-9132b017c2c4be75 (ouverte)
• signerCtx : Un pointeur optionnel vers un contexte de signature initialisé (ara::core::Optional<cryp::SignerPrivateCtx::Sptr>), au cas où la requête devrait être signée cryptographiquement.

Comme valeur de retour, la fonction fournit un ara::core::Result qui, en cas de génération réussie, met à disposition les données binaires de la requête OCSP dans un ara::core::Vector<std::uint8_t> ([SWS_CRYPT_40627]).

Gestion des erreurs

En cas d'erreur, le ara::core::Result fournit des codes d'erreur avec une sémantique de rollback ([SWS_CRYPT_40627]) :

• ara::crypto::CryptoErrc::kUninitializedContext : Survient lorsque le contexte de signature transmis n'a pas été initialisé par une clé.
• ara::crypto::CryptoErrc::kBusyResource : Survient lorsque l'opération ne peut temporairement pas être exécutée en raison de ressources momentanément occupées.

Concurrence et interaction

La méthode est spécifiée comme thread-safe ainsi que exception safe et déclarée avec noexcept ([SWS_CRYPT_40627]). Contrairement à [SWS_CRYPT_40626], où la requête OCSP est générée pour un certificat unique, cette interface permet de regrouper plusieurs certificats dans une seule requête.

Utilisation

La méthode DeleteCrl de l'interface ara::crypto::x509::X509Provider sert à la suppression d'une liste de révocation de certificats (Certificate Revocation List, CRL) enregistrée de manière persistante [SWS_CRYPT_50184]. En tant que paramètre, le crlInstanceSpecifier est transmis, lequel référence un RPortPrototype d'un CryptoCertificateInterface qui identifie le certificat associé [SWS_CRYPT_50184]. La fonction opère de manière synchrone et renvoie un ara::core::Result<void> ; celui-ci est vide si la CRL a été supprimée avec succès ou si aucune CRL n'avait été enregistrée auparavant [SWS_CRYPT_50184].

Gestion des erreurs et concurrence

Si un conflit temporaire de ressources survient pendant l'exécution, la fonction signale l'erreur ara::crypto::CryptoErrc::kBusyResource avec une sémantique de rollback [SWS_CRYPT_50184]. La méthode est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) et sûre vis-à-vis des threads (thread-safe) [SWS_CRYPT_50184].

Restrictions et conditions de configuration

Les prérequis de configuration et d'autorisation suivants s'appliquent à l'appel [SWS_CRYPT_50184] :

• ProcessMappingViolation : survient lorsque le InstanceSpecifier ne pointe pas vers un PortPrototype modélisé pour le processus actuel, typé par un CryptoCertificateInterface [SWS_CRYPT_50184].
• InsufficientPermissionsViolation : survient lorsque le processus actuel ne dispose pas de droits d'écriture, c'est-à-dire CryptoCertificateToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50184].

Utilisation

La méthode ImportCertificate de l'interface ara::crypto::x509::X509Provider (déclarée dans ara/crypto/x509/x509_provider.h) sert à l'enregistrement persistant d'un certificat X.509 dans un slot de certificat défini [SWS_CRYPT_40621]. Le slot cible est adressé via instanceSpecifier (type ara::core::InstanceSpecifier), tandis que le certificat à importer est transmis via l'argument certificate (type Certificate::Sptrc) [SWS_CRYPT_40621]. Interprétation : l'exécution devrait s'effectuer de manière synchrone, étant donné que l'interface renvoie directement un ara::core::Result<void> [SWS_CRYPT_40621]. Question Q-514863e9a90f1c72 (ouverte)

Gestion des erreurs et règles de modélisation

En cas d'erreur, un ara::core::Result défectueux est renvoyé. Si l'opération ne peut temporairement pas être exécutée, la méthode fournit ara::crypto::CryptoErrc::kBusyResource avec une sémantique de retour arrière [SWS_CRYPT_40621]. De plus, les exigences de configuration et de modélisation doivent être satisfaites, faute de quoi des violations à l'exécution sont signalées [SWS_CRYPT_40621] :

• ProcessMappingViolation : Est déclenché si le instanceSpecifier ne pointe pas vers un PortPrototype modélisé pour le processus actuel et typé par un CryptoCertificateInterface [SWS_CRYPT_40621].
• InsufficientPermissionsViolation : Survient si aucune autorisation d'écriture n'est présente pour le processus actuel (CryptoCertificateToPortPrototypeMapping.writeAccess != True) [SWS_CRYPT_40621].

Concurrence et contexte d'exécution

L'opération est spécifiée comme thread-safe et exception safe (noexcept=0), ce qui sécurise les appels concurrents sans verrous externes [SWS_CRYPT_40621].

Utilisation

La méthode ImportCertificateInGroup de la classe ara::crypto::x509::X509Provider enregistre de manière persistante un certificat fourni dans un groupe de certificats identifié via instanceSpecifier [SWS_CRYPT_50127]. Sont transmis comme paramètres une référence au ara::core::InstanceSpecifier du groupe cible ainsi qu'un smart pointer vers le certificat (Certificate::Sptrc certificate) [SWS_CRYPT_50127]. L'appel est déclaré via l'en-tête ara/crypto/x509/x509_provider.h et renvoie de manière synchrone un ara::core::Result<void>, qui signale l'importation réussie ou encapsule un état d'erreur [SWS_CRYPT_50127].

Traitement des erreurs et violations

En cas d'erreur standard, l'opération offre une sémantique de rollback et renvoie des codes d'erreur spécifiques dans l'objet Result [SWS_CRYPT_50127] :

• ara::crypto::CryptoErrc::kInsufficientCapacity : la capacité du groupe de certificats adressé ne suffit pas pour accueillir le certificat [SWS_CRYPT_50127].
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut temporairement pas être effectuée car la ressource requise est occupée [SWS_CRYPT_50127].

En outre, des exigences contraignantes de modélisation et d'autorisation sont définies, dont le non-respect est classé comme Violations [SWS_CRYPT_50127] :

• ProcessMappingViolation : survient lorsque le InstanceSpecifier ne pointe pas vers un PortPrototype modélisé pour le processus actuel et typé par un CryptoCertificateGroupInterface [SWS_CRYPT_50127].
• InsufficientPermissionsViolation : survient lorsque le processus appelant ne possède pas de droit d'écriture, ce qui est caractérisé par CryptoCertificateGroupToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50127].

Concurrence et contexte d'exécution

L'interface est spécifiée comme sûre pour les threads (thread-safe) ainsi que sûre face aux exceptions (exception safe) et est déclarée avec noexcept [SWS_CRYPT_50127].

La méthode ImportCrl de la classe ara::crypto::x509::X509Provider analyse et persiste une Certificate Revocation List (CRL) ou Delta CRL émise par le certificat d'AC identifié via crlInstanceSpecifier [SWS_CRYPT_50183]. L'exécution devrait être synchrone, étant donné qu'un ara::core::Result est immédiatement retourné. Question Q-648a00ec967c7524 (ouverte)

Lors de l'appel, les paramètres suivants sont transmis [SWS_CRYPT_50183] :

• crlInstanceSpecifier : ara::core::InstanceSpecifier sur le RPortPrototype d'un CryptoCertificateInterface qui identifie le certificat.
• crl : ReadOnlyMemRegion contenant les données sérialisées de la CRL ou de la Delta CRL.
• formatId : format de la CRL sérialisée.

L'opération est spécifiée comme thread-safe ainsi qu'exception safe [SWS_CRYPT_50183]. En cas de succès, elle renvoie un ara::core::Result avec l'état CertificateValidationStatus::kValid ou le résultat de validation de la CRL [SWS_CRYPT_50183].

En cas d'erreur, les valeurs de retour possèdent une sémantique de rollback [SWS_CRYPT_50183] :

• ara::crypto::CryptoErrc::kInvalidArgument : la CRL ne correspond pas au format indiqué.
• ara::crypto::CryptoErrc::kUnsupportedFormat : la FormatId indiquée est inconnue ou non prise en charge.
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut pas être exécutée temporairement.

De plus, des conditions préalables de configuration doivent être respectées [SWS_CRYPT_50183] : un ProcessMappingViolation survient si l'identifiant d'instance ne renvoie pas à un port modélisé pour le processus actuel, et un InsufficientPermissionsViolation lorsque CryptoCertificateToPortPrototypeMapping.writeAccess != True est défini.

La méthode ara::crypto::x509::X509Provider::LoadCertificateGroup sert à charger un groupe de certificats depuis la mémoire de certificats persistante conformément à [SWS_CRYPT_50126].

Utilisation et contexte d'appel

L'appel s'effectue via une instance de X509Provider issue de l'en-tête ara/crypto/x509/x509_provider.h. Comme paramètre d'entrée, la fonction attend un instanceSpecifier de type const ara::core::InstanceSpecifier&, qui identifie l'emplacement logique du groupe de certificats souhaité [SWS_CRYPT_50126]. En guise de résultat, l'interface renvoie un ara::core::Result<ara::core::Vector<Certificate::Sptrc>> qui, en cas de succès, fournit un vecteur de smart pointers vers les certificats chargés [SWS_CRYPT_50126]. En l'absence de types de retour asynchrones tels que ara::core::Future, l'accès à la mémoire persistante devrait s'effectuer de manière synchrone et bloquante. Question Q-b743367ccc9904ab (ouverte)

Gestion des erreurs et restrictions de modélisation

Dans la spécification, aucun code d'erreur standardisé n'est défini pour la valeur de retour [SWS_CRYPT_50126]. Cependant, un contrôle à l'exécution est prescrit : si le instanceSpecifier transmis ne pointe pas vers un PortPrototype modélisé pour le processus actuel et typé par un CryptoCertificateGroupInterface, il s'agit d'une ProcessMappingViolation [SWS_CRYPT_50126].

Concurrence et sécurité vis-à-vis des exceptions

La méthode purement virtuelle est annotée avec noexcept et spécifiée comme sûre face aux exceptions (exception safe). De plus, l'appel est explicitement déclaré sûr pour les threads (thread-safe), de sorte que des accès en lecture parallèles depuis plusieurs threads ne posent aucun problème [SWS_CRYPT_50126].

La méthode ParseCert fait partie de la classe ara::crypto::x509::X509Provider (définie dans l'en-tête ara/crypto/x509/x509_provider.h) et sert à analyser une représentation sérialisée d'un certificat X.509v3 et à instancier un objet de certificat correspondant [SWS_CRYPT_40614].

Appel et paramètres : La fonction est appelée de manière synchrone et est spécifiée comme noexcept [SWS_CRYPT_40614]. Elle reçoit deux paramètres d'entrée :

• cert : Une zone de mémoire de type ReadOnlyMemRegion qui fournit les données de certificat encodées dans le format spécifié [SWS_CRYPT_40614].
• formatId : L'identifiant du format d'entrée permettant de déterminer la procédure d'analyse [SWS_CRYPT_40614].

Valeur de retour et gestion des erreurs : Le résultat est renvoyé sous la forme de ara::core::Result<Certificate::Sptrc>, qui contient, en cas de succès, un Shared Pointer vers l'objet de certificat créé [SWS_CRYPT_40614]. Si une erreur survient, une sémantique de rollback s'applique avec les codes d'erreur spécifiques suivants [SWS_CRYPT_40614] :

• ara::crypto::CryptoErrc::kInvalidArgument : L'argument cert ne peut pas être analysé comme un certificat valide [SWS_CRYPT_40614].
• ara::crypto::CryptoErrc::kUnsupportedFormat : Le formatId spécifié est inconnu ou n'est pas pris en charge [SWS_CRYPT_40614].

Concurrence et implémentation : L'interface est expressément spécifiée comme sûre vis-à-vis des exceptions (exception safe) et thread-safe (thread-safe) [SWS_CRYPT_40614]. ParseCert étant déclaré purement virtuel, la logique d'analyse effective devrait être fournie par un pilote cryptographique ou un fournisseur spécifique à la plateforme [SWS_CRYPT_40614]. Question Q-d3239d62d2e7d831 (ouverte)

Utilisation

La méthode ParseCertChain de l'interface ara::crypto::x509::X509Provider issue de l'en-tête ara/crypto/x509/x509_provider.h analyse une représentation sérialisée d'une chaîne de certificats [SWS_CRYPT_40616]. En tant que paramètres, elle accepte la zone de mémoire de la chaîne de certificats codée certChain en tant que ReadOnlyMemRegion ainsi que l'identifiant de format formatId de type FormatId [SWS_CRYPT_40616]. Pour chaque certificat analysé avec succès, une nouvelle instance de Certificate est créée. En cas de succès, la fonction synchrone renvoie un ara::core::Result contenant un ara::core::Vector<Certificate::Sptrc>, dans lequel les certificats sont disposés dans le même ordre que dans la chaîne transmise [SWS_CRYPT_40616].

Gestion des erreurs

En cas d'erreur, le ara::core::Result renvoyé contient un code d'erreur spécifique avec sémantique de rollback [SWS_CRYPT_40616] :

• ara::crypto::CryptoErrc::kInvalidArgument : L'argument certChain ne peut pas être analysé [SWS_CRYPT_40616].
• ara::crypto::CryptoErrc::kUnsupportedFormat : L'identifiant formatId spécifié est inconnu ou n'est pas pris en charge [SWS_CRYPT_40616].

Concurrence et contraintes

La méthode est déclarée comme noexcept, spécifiée comme thread-safe (thread-safe) et garantit la sécurité vis-à-vis des exceptions (exception safe) [SWS_CRYPT_40616].

Utilisation et contexte d'appel

La méthode synchrone ParseOcspResponse fait partie de l'interface ara::crypto::x509::X509Provider (définie dans ara/crypto/x509/x509_provider.h) et sert à la lecture ainsi qu'à l'analyse de réponses OCSP sérialisées [SWS_CRYPT_50185]. L'appelant transmet les données brutes de la réponse sous forme de ReadOnlyMemRegion via le paramètre response ainsi que le format de données attendu au moyen de formatId de type FormatId [SWS_CRYPT_50185]. En cas de validation et de traitement réussis, la fonction renvoie un ara::core::Result encapsulant un smart pointer OcspResponse::Sptrc vers le nouvel objet de réponse OCSP créé [SWS_CRYPT_50185].

Gestion des erreurs

Les cas d'erreur sont signalés sans lever d'exceptions via le type de retour ara::core::Result avec une sémantique de rollback [SWS_CRYPT_50185] :

• ara::crypto::CryptoErrc::kInvalidArgument : survient lorsque les octets fournis dans le tampon response ne peuvent pas être analysés comme une réponse OCSP valide [SWS_CRYPT_50185].
• ara::crypto::CryptoErrc::kUnsupportedFormat : est signalé si l'identifiant formatId transmis est inconnu ou non pris en charge par le fournisseur [SWS_CRYPT_50185].

Concurrence et sécurité des threads

La méthode purement virtuelle est déclarée comme noexcept, classée comme sûre vis-à-vis des exceptions (exception safe) et explicitement spécifiée comme sûre vis-à-vis des threads (thread-safe) [SWS_CRYPT_50185]. Grâce à la déclaration const, ParseOcspResponse peut être appelée de manière concurrente dans des environnements multithread sur la même instance de fournisseur sans modifier l'état interne de l'objet [SWS_CRYPT_50185].

Utilisation

La méthode d'interface synchrone RemoveCertificateFromGroup issue de la portée ara::crypto::x509::X509Provider sert à supprimer de manière ciblée un certificat d'un groupe de certificats existant [SWS_CRYPT_50128]. Le groupe de certificats concerné est identifié via le paramètre instanceSpecifier, tandis que certificate fournit le certificat à supprimer sous la forme d'un smart pointer (Certificate::Sptrc) [SWS_CRYPT_50128]. L'appel renvoie un ara::core::Result<void>, qui acquitte l'exécution réussie sans valeur de retour ou encapsule une erreur survenue [SWS_CRYPT_50128].

Gestion des erreurs

Si une erreur survient lors de l'exécution, une sémantique de rollback définie s'applique, de sorte que l'état du groupe de certificats reste inchangé [SWS_CRYPT_50128]. Les codes d'erreur suivants sont spécifiés :

• ara::crypto::CryptoErrc::kNoSuchValue : le groupe de certificats spécifié ne contient pas le certificat à supprimer [SWS_CRYPT_50128].
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut temporairement pas être effectuée car les ressources requises sont occupées [SWS_CRYPT_50128].

Concurrence et conditions de configuration

La méthode est spécifiée comme thread-safe et exception safe et déclarée avec noexcept [SWS_CRYPT_50128]. Avant l'appel, les conditions préalables suivantes pour le processus doivent impérativement être remplies dans le modèle de système [SWS_CRYPT_50128] :

• Pour éviter une ProcessMappingViolation, le InstanceSpecifier transmis doit pointer vers un PortPrototype typé par un CryptoCertificateGroupInterface modélisé pour le processus actuel [SWS_CRYPT_50128].
• Pour éviter une InsufficientPermissionsViolation, le processus actuel doit disposer de droits d'écriture, c'est-à-dire que CryptoCertificateGroupToPortPrototypeMapping.writeAccess doit être configuré sur True [SWS_CRYPT_50128].