classe ara::crypto::cryp::CryptoProvider

La méthode CreateAuthCipherCtx sert à créer un contexte pour le chiffrement symétrique authentifié ([SWS_CRYPT_20745]). Elle est définie comme une interface virtuelle pure dans la classe ara::crypto::cryp::CryptoProvider et doit être incluse via le fichier d'en-tête ara/crypto/cryp/crypto_provider.h ([SWS_CRYPT_20745]).

Utilisation et sémantique

Le paramètre d'entrée transmis est algId, qui identifie l'algorithme cryptographique cible ([SWS_CRYPT_20745]). La fonction opère de manière synchrone et ne lève aucune exception (noexcept) ([SWS_CRYPT_20745]). En cas d'exécution réussie, elle renvoie un ara::core::Result avec un smart pointer vers l'instance créée AuthCipherCtx::Sptr ([SWS_CRYPT_20745]).

Gestion des erreurs

En cas d'erreur, un code d'erreur correspondant est renvoyé dans le ara::core::Result avec une sémantique de rollback ([SWS_CRYPT_20745]) :

• ara::crypto::CryptoErrc::kInvalidArgument : lorsque algId ne spécifie pas d'algorithme pour un chiffrement de flux symétrique authentifié ([SWS_CRYPT_20745]).
• ara::crypto::CryptoErrc::kUnknownIdentifier : lorsqu'une valeur non prise en charge a été transmise pour algId ([SWS_CRYPT_20745]).

concurrence

L'appel de CreateAuthCipherCtx est thread-safe (thread-safe) et spécifié comme sûr vis-à-vis des exceptions (exception safe) ([SWS_CRYPT_20745]).

Utilisation

La méthode CreateDecryptorPrivateCtx de l'interface ara::crypto::cryp::CryptoProvider sert à créer un contexte pour le déchiffrement asymétrique à l'aide d'une clé privée conformément à [SWS_CRYPT_20751]. Comme paramètre d'entrée, la fonction attend algId, qui définit l'identifiant de l'algorithme de chiffrement ou de déchiffrement asymétrique souhaité. Interprétation : l'appel devrait être exécuté de manière synchrone, étant donné que la signature renvoie directement un ara::core::Result qui, en cas de succès, contient un smart pointer vers le contexte créé (DecryptorPrivateCtx::Sptr) [SWS_CRYPT_20751]. Question Q-45d1c4a1b2133f4c (ouverte)

Gestion des erreurs

Si le contexte ne peut pas être créé, l'erreur est acheminée dans le ara::core::Result renvoyé. Si une valeur non prise en charge a été transmise pour le paramètre algId, cela se traduit spécifiquement par le code d'erreur ara::crypto::CryptoErrc::kUnknownIdentifier avec une sémantique de rollback [SWS_CRYPT_20751].

Concurrence et restrictions

La fonction est définie comme noexcept et garantit la sécurité vis-à-vis des exceptions (exception safe) [SWS_CRYPT_20751]. Pour l'accès simultané depuis plusieurs threads, la méthode est spécifiée comme thread-safe [SWS_CRYPT_20751]. Étant donné que la signature dans l'en-tête ara/crypto/cryp/crypto_provider.h est déclarée comme méthode virtuelle pure, la réalisation concrète incombe à l'implémentation du fournisseur respectif [SWS_CRYPT_20751].

La méthode d'interface virtuelle pure CreateEncryptorPublicCtx appartient à la classe ara::crypto::cryp::CryptoProvider et est déclarée via le fichier d'en-tête ara/crypto/cryp/crypto_provider.h [SWS_CRYPT_20750]. Son rôle consiste à instancier un nouveau contexte pour les opérations de chiffrement asymétrique avec une clé publique [SWS_CRYPT_20750].

Utilisation : l'appel s'effectue de manière synchrone en spécifiant le paramètre algId de type AlgId, qui définit l'identifiant de l'algorithme de chiffrement ou de déchiffrement asymétrique souhaité [SWS_CRYPT_20750]. La méthode renvoie le résultat dans un ara::core::Result qui, en cas de succès, fournit un smart pointer de type EncryptorPublicCtx::Sptr vers le contexte créé [SWS_CRYPT_20750].

Gestion des erreurs : pour autant que l'argument algId contienne une valeur d'algorithme non prise en charge, l'appel échoue et renvoie dans le ara::core::Result le code d'erreur ara::crypto::CryptoErrc::kUnknownIdentifier [SWS_CRYPT_20750]. Pour ce cas d'erreur, une sémantique de rollback explicite est spécifiée [SWS_CRYPT_20750].

Concurrence et sécurité vis-à-vis des exceptions : l'interface est déclarée comme noexcept, est considérée comme sûre vis-à-vis des exceptions (exception safe) et est expressément spécifiée comme thread-safe (thread-safe) [SWS_CRYPT_20750].

La méthode CreateHashFunctionCtx sert à instancier un contexte de hachage cryptographique ([SWS_CRYPT_20747]). Elle est mise à disposition sous la forme d'une interface virtuelle pure de la classe ara::crypto::cryp::CryptoProvider via l'en-tête ara/crypto/cryp/crypto_provider.h.

Utilisation et paramètres

L'appel s'effectue de manière synchrone et attend comme paramètre d'entrée algId (de type AlgId), qui identifie l'algorithme cryptographique souhaité ([SWS_CRYPT_20747]). Comme valeur de retour, la fonction fournit un ara::core::Result<HashFunctionCtx::Sptr> qui, en cas de succès, contient un smart pointer vers le contexte créé.

Gestion des erreurs

Si la création échoue, le ara::core::Result contient un code d'erreur correspondant avec une sémantique de rollback ([SWS_CRYPT_20747]) :

• ara::crypto::CryptoErrc::kInvalidArgument : est renvoyé lorsque la algId transmise est spécifiée pour un type d'algorithme autre qu'une fonction de hachage ([SWS_CRYPT_20747]).
• ara::crypto::CryptoErrc::kUnknownIdentifier : survient si un identifiant non pris en charge a été transmis pour algId ([SWS_CRYPT_20747]).

Concurrence et restrictions

La fonction est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (« exception safe ») ([SWS_CRYPT_20747]). De plus, l'appel est thread-safe (« thread-safe »), de sorte que des appels simultanés depuis plusieurs threads sur la même instance de CryptoProvider sont autorisés ([SWS_CRYPT_20747]).

La méthode CreateKeyAgreementPrivateCtx de la classe ara::crypto::cryp::CryptoProvider sert à créer un contexte de clé privée pour les accords de clés (KeyAgreementPrivateCtx) conformément à [SWS_CRYPT_20758]. La déclaration est fournie via le fichier d'en-tête #include "ara/crypto/cryp/crypto_provider.h".

Utilisation et appel

Comme paramètre d'entrée, la méthode synchrone attend l'identifiant algId de type AlgId, qui spécifie l'algorithme cryptographique souhaité pour le key-agreement. Comme valeur de retour, la fonction renvoie un ara::core::Result<KeyAgreementPrivateCtx::Sptr> qui encapsule, en cas de succès, un pointeur intelligent vers l'instance de contexte nouvellement créée [SWS_CRYPT_20758].

Gestion des erreurs

Si l'instanciation échoue, le ara::core::Result retourné contient un code d'erreur avec sémantique de rollback [SWS_CRYPT_20758] :

• ara::crypto::CryptoErrc::kInvalidArgument : Se produit si l'argument algId indique un algorithme cryptographique qui diffère des procédures d'accord de clés.
• ara::crypto::CryptoErrc::kUnknownIdentifier : Est retourné si l'identifiant algId présente une valeur non prise en charge.

Concurrence et sécurité

L'interface est déclarée comme noexcept et définie comme sûre du point de vue des exceptions (exception safe). De plus, l'appel est spécifié comme sûr du point de vue des threads (thread-safe), de sorte que les appels simultanés sur la même instance de CryptoProvider sont autorisés [SWS_CRYPT_20758].

Utilisation

La méthode CreateKeyDecapsulatorPrivateCtx de l'interface ara::crypto::cryp::CryptoProvider sert à la création d'un contexte privé de décapsulation de clé pour un mécanisme d'encapsulation de clé (KEM) [SWS_CRYPT_20753]. Elle attend comme paramètre d'entrée algId de type AlgId, qui identifie l'algorithme cryptographique KEM souhaité [SWS_CRYPT_20753]. La fonction opère de manière synchrone et renvoie le résultat dans un ara::core::Result<KeyDecapsulatorPrivateCtx::Sptr> qui, en cas de succès, encapsule un pointeur intelligent vers le contexte nouvellement instancié [SWS_CRYPT_20753].

Gestion des erreurs

Si une erreur survient lors de la création du contexte, celle-ci est signalée via le ara::core::Result avec sémantique de rollback [SWS_CRYPT_20753] :

• ara::crypto::CryptoErrc::kInvalidArgument : l'argument algId spécifie un algorithme cryptographique qui n'est pas un mécanisme KEM asymétrique [SWS_CRYPT_20753].
• ara::crypto::CryptoErrc::kUnknownIdentifier : l'argument algId présente une valeur non prise en charge [SWS_CRYPT_20753].

Concurrence et sécurité d'exécution

L'interface est déclarée comme noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception safe) [SWS_CRYPT_20753]. De plus, l'exécution est conçue pour être thread-safe (thread-safe) [SWS_CRYPT_20753].

La méthode CreateKeyDerivationFunctionCtx de la classe ara::crypto::cryp::CryptoProvider sert à la création d'un contexte d'exécution pour les fonctions de dérivation de clé ([SWS_CRYPT_20748]). L'identifiant algId de type AlgId est transmis en tant que paramètre d'entrée, lequel détermine l'algorithme cryptographique cible souhaité. L'appel synchrone renvoie un ara::core::Result qui, lors d'une exécution réussie, fournit un pointeur intelligent sur le contexte créé (KeyDerivationFunctionCtx::Sptr) ([SWS_CRYPT_20748]).

Si une erreur survient lors de l'instanciation, le résultat est renvoyé avec un code d'erreur correspondant sous sémantique de rollback ([SWS_CRYPT_20748]) :

• ara::crypto::CryptoErrc::kInvalidArgument : l'argument algId spécifie un algorithme cryptographique qui ne constitue pas une fonction de dérivation de clé ([SWS_CRYPT_20748]).
• ara::crypto::CryptoErrc::kUnknownIdentifier : l'identifiant transmis algId possède une valeur non prise en charge ([SWS_CRYPT_20748]).

L'interface est déclarée comme fonction virtuelle pure, désignée comme noexcept et classée de manière obligatoire comme thread-safe ainsi que exception safe ([SWS_CRYPT_20748]). L'intégration s'effectue via le fichier d'en-tête #include "ara/crypto/cryp/crypto_provider.h". La fonction répond aux exigences de niveau supérieur [RS_CRYPTO_02103] et [RS_AP_00144].

Utilisation

La méthode CreateKeyEncapsulatorPublicCtx de l'interface ara::crypto::cryp::CryptoProvider sert à créer un contexte public pour un Key Encapsulation Mechanism (KEM) [SWS_CRYPT_20752]. Pour cela, le fichier d'en-tête #include "ara/crypto/cryp/crypto_provider.h" doit être inclus [SWS_CRYPT_20752]. L'appel s'effectue de manière synchrone : le paramètre d'entrée transmis est algId, qui spécifie l'algorithme cryptographique cible du KEM. En cas d'exécution réussie, la méthode renvoie un smart pointer vers le contexte créé (KeyEncapsulatorPublicCtx::Sptr), encapsulé dans un ara::core::Result [SWS_CRYPT_20752].

Gestion des erreurs

Si une erreur survient pendant la création, une sémantique de rollback s'applique et le ara::core::Result contient un code d'erreur spécifique issu de ara::crypto::CryptoErrc [SWS_CRYPT_20752] :

• ara::crypto::CryptoErrc::kInvalidArgument : est renvoyé lorsque l'argument algId désigne un algorithme cryptographique qui n'est pas un KEM asymétrique [SWS_CRYPT_20752].
• ara::crypto::CryptoErrc::kUnknownIdentifier : est signalé si l'argument algId présente une valeur non prise en charge [SWS_CRYPT_20752].

Concurrence et sécurité

La fonction d'interface est déclarée avec noexcept et classifiée comme sûre vis-à-vis des exceptions (exception safe) ainsi que thread-safe (thread-safe) [SWS_CRYPT_20752]. Elle peut ainsi être appelée en toute sécurité depuis des contextes concurrents sans synchronisation externe [SWS_CRYPT_20752].

Utilisation

La méthode virtuelle pure CreateMessageAuthnCodeCtx de l'interface ara::crypto::cryp::CryptoProvider nécessite le fichier d'en-tête ara/crypto/cryp/crypto_provider.h et sert à la création synchrone d'un contexte pour les Message Authentication Codes symétriques [SWS_CRYPT_20746]. Comme valeur d'entrée, la fonction accepte le paramètre algId de type AlgId, qui spécifie l'algorithme cryptographique cible [SWS_CRYPT_20746]. En cas d'exécution réussie, la méthode renvoie un ara::core::Result<MessageAuthnCodeCtx::Sptr> encapsulant un smart pointer vers l'instance de contexte nouvellement instanciée [SWS_CRYPT_20746].

Gestion des erreurs

En cas d'erreur, l'objet Result renvoyé fournit des codes d'erreur spécifiques avec une sémantique de rollback [SWS_CRYPT_20746] :

• ara::crypto::CryptoErrc::kInvalidArgument : l'argument algId spécifie un algorithme cryptographique qui n'est pas un Message Authentication Code symétrique [SWS_CRYPT_20746].
• ara::crypto::CryptoErrc::kUnknownIdentifier : un identifiant inconnu ou non pris en charge a été transmis pour l'argument algId [SWS_CRYPT_20746].

Concurrence et sécurité d'exécution

L'interface est dotée du spécificateur noexcept et garantit une sécurité totale vis-à-vis des exceptions (exception safe) [SWS_CRYPT_20746]. En outre, la fonction est explicitement spécifiée comme thread-safe (thread-safe), de sorte que les appels peuvent être effectués en parallèle et sans synchronisation externe depuis des threads concurrents [SWS_CRYPT_20746].

Utilisation

L’interface CreateProtectedKeyImportCtx de la classe ara::crypto::cryp::CryptoProvider (définie dans ara/crypto/cryp/crypto_provider.h) sert à la création synchrone d’un contexte pour l’importation protégée de clés ([SWS_CRYPT_50017]). L’identifiant de l’algorithme de wrapping souhaité est transmis via le paramètre d’entrée algId ([SWS_CRYPT_50017]). En cas d’instanciation réussie, la méthode renvoie un ara::core::Result fournissant un pointeur intelligent ProtectedKeyImportCtx::Sptr vers le contexte généré ([SWS_CRYPT_50017]).

Gestion des erreurs

Si la création échoue, la méthode renvoie dans le ara::core::Result un code d’erreur avec sémantique de rollback ([SWS_CRYPT_50017]) :

• ara::crypto::CryptoErrc::kInvalidArgument : survient lorsque l’algorithme cryptographique spécifié par algId n’est pas pris en charge pour le wrapping par le CryptoProvider ([SWS_CRYPT_50017]).
• ara::crypto::CryptoErrc::kUnknownIdentifier : est signalé lorsque l’argument algId contient une valeur d’identifiant inconnue ou non prise en charge ([SWS_CRYPT_50017]).

Concurrence et restrictions

La méthode virtuelle pure est déclarée comme noexcept, offre une sécurité vis-à-vis des exceptions et est explicitement spécifiée comme thread-safe ([SWS_CRYPT_50017]). Elle peut ainsi être appelée en parallèle depuis plusieurs threads sans synchronisation externe ([SWS_CRYPT_50017]).

La méthode CreateRandomGeneratorCtx sert à créer un contexte pour générateurs de nombres aléatoires (Random Number Generator, RNG) au sein de la classe ara::crypto::cryp::CryptoProvider [SWS_CRYPT_20741].

Utilisation et contexte d'appel

La fonction est appelée de manière synchrone et nécessite le fichier d'en-tête ara/crypto/cryp/crypto_provider.h [SWS_CRYPT_20741] :

• Paramètres : algId de type AlgId est transmis, ce qui identifie l'algorithme RNG souhaité. Si aucune algId spécifique n'est spécifiée, la méthode fournit le RNG par défaut [SWS_CRYPT_20741].
• Valeur de retour : un ara::core::Result<RandomGeneratorCtx::Sptr> qui, en cas de succès, contient un pointeur partagé vers l'instance créée de RandomGeneratorCtx [SWS_CRYPT_20741].

Gestion des erreurs

La méthode ne lève pas d'exceptions (noexcept) et est spécifiée comme sûre vis-à-vis des exceptions [SWS_CRYPT_20741]. Si l'opération échoue, le ara::core::Result fournit un code d'erreur :

• ara::crypto::CryptoErrc::kUnknownIdentifier : survient lorsque l'argument algId présente une valeur non prise en charge (avec sémantique de rollback) [SWS_CRYPT_20741].

Concurrence et restrictions

La méthode est classifiée comme thread-safe (thread-safe), de sorte que les appels parallèles via la même instance du CryptoProvider sont autorisés [SWS_CRYPT_20741].

La méthode CreateSignerPrivateCtx de la classe ara::crypto::cryp::CryptoProvider sert à créer un contexte pour des opérations de signature avec une clé privée ([SWS_CRYPT_20756]).

Utilisation et paramètres : l'appel nécessite l'inclusion du fichier d'en-tête ara/crypto/cryp/crypto_provider.h. Le paramètre d'entrée algId permet de spécifier l'algorithme cryptographique cible de signature. En cas de succès, la fonction fournit via le type de retour ara::core::Result<SignerPrivateCtx::Sptr> un smart pointer vers l'instance de contexte créée ([SWS_CRYPT_20756]). Interprétation : la méthode renvoyant directement un ara::core::Result, l'appel devrait être exécuté de manière synchrone. Question Q-8480f3cf5cef5f49 (ouverte)

Concurrence et sécurité : la méthode est spécifiée comme thread-safe (thread-safe) ainsi que sûre vis-à-vis des exceptions (exception safe) et est déclarée avec noexcept ([SWS_CRYPT_20756]). Elle peut ainsi être appelée sans synchronisation supplémentaire depuis des contextes concurrents.

Gestion des erreurs : en cas d'erreur, le résultat fournit un code d'erreur de type ara::crypto::CryptoErrc avec une sémantique de rollback ([SWS_CRYPT_20756]) :

• ara::crypto::CryptoErrc::kInvalidArgument : survient lorsque l'argument algId indique un algorithme cryptographique différent d'une signature avec clé privée ([SWS_CRYPT_20756]).
• ara::crypto::CryptoErrc::kUnknownIdentifier : survient si algId contient une valeur inconnue ou non prise en charge ([SWS_CRYPT_20756]).

Utilisation

La méthode virtuelle CreateSymmetricCipherCtx de l'interface ara::crypto::cryp::CryptoProvider sert à créer un contexte pour les opérations de chiffrement symétrique ([SWS_CRYPT_20742]). Elle est incluse via le fichier d'en-tête #include "ara/crypto/cryp/crypto_provider.h" ([SWS_CRYPT_20742]).

Comme paramètre d'entrée, la fonction attend algId de type AlgId, qui indique l'identifiant de l'algorithme cryptographique cible souhaité ([SWS_CRYPT_20742]). L'appel s'effectue de manière synchrone et renvoie en résultat un ara::core::Result<SymmetricCipherCtx::Sptr> qui, en cas de succès, met à disposition un smart pointer vers l'instance de contexte nouvellement instanciée ([SWS_CRYPT_20742]).

Gestion des erreurs

Si la création échoue, le ara::core::Result renvoyé contient un code d'erreur correspondant ([SWS_CRYPT_20742]) :

• ara::crypto::CryptoErrc::kUnknownIdentifier : est signalé avec une sémantique de rollback si la valeur transmise pour algId référence un algorithme non pris en charge ([SWS_CRYPT_20742]).

Concurrence et restrictions

La fonction est déclarée comme noexcept et explicitement spécifiée comme sûre vis-à-vis des exceptions (exception safe) ([SWS_CRYPT_20742]). De plus, l'appel est thread-safe (thread-safe), de sorte que les créations de contexte parallèles via la même instance de CryptoProvider sont autorisées ([SWS_CRYPT_20742]).

Utilisation

La méthode CreateSymmetricKeyWrapperCtx de la classe ara::crypto::cryp::CryptoProvider sert à la génération d’un contexte pour des algorithmes de key-wrap symétriques ([SWS_CRYPT_20743]). algId, qui identifie de manière univoque l’algorithme cryptographique cible ([SWS_CRYPT_20743]), est transmis en paramètre d’entrée. L’appel est synchrone et renvoie, en cas de succès, un ara::core::Result qui encapsule un pointeur intelligent vers le contexte créé (SymmetricKeyWrapperCtx::Sptr) ([SWS_CRYPT_20743]).

Gestion des erreurs

Si la création échoue, la fonction renvoie l’objet d’erreur au sein du ara::core::Result ([SWS_CRYPT_20743]) :

• ara::crypto::CryptoErrc::kUnknownIdentifier : est signalé lorsque l’argument algId présente une valeur non prise en charge ; les sémantiques de rollback s’appliquent alors ([SWS_CRYPT_20743]).

Concurrence et restrictions

L’interface est déclarée comme noexcept, est considérée comme sûre vis-à-vis des exceptions (exception safe) et est thread-safe ([SWS_CRYPT_20743]). Elle peut donc être appelée en toute sécurité depuis des contextes concurrents, pour autant que la algId fournie soit prise en charge par le CryptoProvider sous-jacent ([SWS_CRYPT_20743]).

Utilisation et contexte d'appel

La méthode virtuelle pure CreateVerifierPublicCtx de la classe ara::crypto::cryp::CryptoProvider est déclarée via le fichier d'en-tête ara/crypto/cryp/crypto_provider.h [SWS_CRYPT_20757]. Elle sert à la création synchrone d'un contexte de vérification de signature avec des clés publiques (vérification de signature à clé publique) [SWS_CRYPT_20757].

L'appelant transmet via le paramètre algId (type AlgId) l'identifiant de l'algorithme de signature cryptographique souhaité [SWS_CRYPT_20757]. En cas de succès, la fonction renvoie un ara::core::Result contenant un smart pointer vers le contexte de vérification créé (VerifierPublicCtx::Sptr) [SWS_CRYPT_20757].

Gestion des erreurs

En cas d'erreur, une sémantique de rollback s'applique, et le ara::core::Result résultant achemine un code d'erreur correspondant [SWS_CRYPT_20757] :

• ara::crypto::CryptoErrc::kInvalidArgument : est signalé lorsque l'argument algId désigne un algorithme cryptographique qui n'est pas prévu pour la vérification de signature avec des clés publiques [SWS_CRYPT_20757].
• ara::crypto::CryptoErrc::kUnknownIdentifier : Signalé si un identifiant inconnu ou non pris en charge a été transmis pour algId [SWS_CRYPT_20757].

Concurrence et restrictions

La méthode est déclarée comme noexcept, totalement sûre du point de vue des exceptions (exception safe) et explicitement spécifiée comme sûre du point de vue des threads (thread-safe) [SWS_CRYPT_20757]. Les appels simultanés provenant de plusieurs contextes d'exécution sont par conséquent autorisés sans synchronisation externe.

La méthode ExportSecuredKey de l'interface ara::crypto::cryp::CryptoProvider exporte un objet de clé cryptographique dans un format sérialisé sécurisé [SWS_CRYPT_20728]. L'objet de clé transmis key est préparé conformément au format déterminé implicitement par algId, enveloppé de manière cryptographique (« wrapped ») et sérialisé dans le tampon de sortie resultBuffer [SWS_CRYPT_20728]. Pour l'encapsulage, une clé de chiffrement de clé (kek) peut être transmise en option ; si aucun kek n'est fourni, la méthode a recours à une KEK déterminée implicitement par la algId ou à la KEK par défaut du CryptoProvider [SWS_CRYPT_20728].

La fonction est classée comme thread-safe et exception safe et annotée avec noexcept [SWS_CRYPT_20728]. Interprétation : étant donné que la signature fournit directement un ara::core::Result sans types de retour asynchrones comme des futures, l'ensemble du processus d'encapsulage et de sérialisation devrait être exécuté de manière synchrone dans le contexte de l'appelant. Question Q-3fb89afcc9300695 (ouverte)

En cas de réussite, le ara::core::Result<std::size_t> renvoyé fournit le nombre d'octets écrits dans resultBuffer [SWS_CRYPT_20728]. Si l'opération échoue, une sémantique de rollback s'applique et l'une des erreurs suivantes est signalée [SWS_CRYPT_20728] :

• UnknownIdentifier : la valeur algId transmise n'est pas prise en charge [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kInvalidArgument : l'objet de clé ne peut pas être enveloppé (par ex. taille non valide ou type inapproprié) ou un kek obligatoire n'a pas été transmis [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kUsageViolation : l'utilisation autorisée de key ou kek est incompatible avec l'algorithme sélectionné [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kIncompatibleArguments : le kek transmis est incompatible avec l'algorithme d'exportation [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kInsufficientCapacity : le tampon de sortie resultBuffer est trop petit pour le résultat [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kBusyResource : une ressource requise pour l'exportation est occupée [SWS_CRYPT_20728].

La méthode GeneratePrivateKey de la classe ara::crypto::cryp::CryptoProvider (déclarée dans ara/crypto/cryp/crypto_provider.h) génère de manière synchrone une nouvelle paire de clés asymétriques et renvoie la clé privée créée sous la forme PrivateKey::Sptr au sein d'un ara::core::Result [SWS_CRYPT_20722]. La clé publique associée n'est pas directement renvoyée, mais peut être récupérée ultérieurement via la méthode PrivateKey::GetPublicKey() de la clé résultante [SWS_CRYPT_20722].

Lors de l'appel, le paramètre algId spécifie l'algorithme cryptographique, tandis que privateKeyAllowedUsage définit les types de transformation autorisés pour la clé privée [SWS_CRYPT_20722]. Les drapeaux d'utilisation autorisés pour la clé publique sont alors mis en correspondance à partir des autorisations de la clé privée de la manière suivante [SWS_CRYPT_20722] :

• kAllowDataDecryption conduit à kAllowDataEncryption
• kAllowSigGeneration conduit à kAllowSigVerification
• kAllowKeyAgreement conduit à kAllowKeyAgreement
• kAllowKeyUnwrapping conduit à kAllowKeyWrapping

De plus, les drapeaux d'utilisation kAllowPlaintextExport ainsi que kAllowPersist sont automatiquement attribués à la clé publique [SWS_CRYPT_20722].

En matière de concurrence et d'exécution, la fonction est spécifiée comme thread-safe et exception-safe [SWS_CRYPT_20722]. Si une erreur survient pendant la génération de clé, le résultat est traité avec une sémantique de rollback [SWS_CRYPT_20722]. Les codes d'erreur suivants peuvent être renvoyés :

• ara::crypto::CryptoErrc::kUnknownIdentifier, si un algorithme non pris en charge est transmis pour algId,
• ara::crypto::CryptoErrc::kIncompatibleArguments, si les indicateurs privateKeyAllowedUsage spécifiés sont incompatibles avec l'algorithme ou le type de clé choisi,
• ara::crypto::CryptoErrc::kBusyResource, si la génération est temporairement impossible en raison de ressources temporairement occupées [SWS_CRYPT_20722].

La méthode purement virtuelle GenerateRandomData de l'interface ara::crypto::cryp::CryptoProvider sert à remplir une zone de mémoire fournie par l'appelant avec des données aléatoires cryptographiques [SWS_CRYPT_30098]. La déclaration se trouve dans le fichier d'en-tête ara/crypto/cryp/crypto_provider.h.

Le paramètre de sortie transmis est randomData de type ReadWriteMem Region, qui représente le tampon à remplir et dont la taille détermine le nombre d'octets aléatoires générés [SWS_CRYPT_30098]. Interprétation : étant donné que la fonction utilise directement ara::core::Result<void> comme type de retour et aucun objet Future, la génération des données devrait se dérouler de manière synchrone et bloquante [SWS_CRYPT_30098]. Question Q-315c0492dcf7f37d (ouverte) La valeur de retour est vide en cas de succès ou contient un code d'erreur correspondant en cas d'erreur [SWS_CRYPT_30098].

Si un problème survient lors de l'exécution, une sémantique de rollback est appliquée afin qu'aucun état partiel ou non valide ne subsiste [SWS_CRYPT_30098]. Les états d'erreur suivants sont spécifiés :

• ara::crypto::CryptoErrc::kBusyResource : Le générateur de nombres aléatoires (RNG) sous-jacent dispose actuellement d'une entropie insuffisante et ne peut pas fournir la quantité demandée d'octets aléatoires [SWS_CRYPT_30098].
• ara::crypto::CryptoErrc::kUnsupported : L'implémentation concrète de CryptoProvider ne prend pas en charge de générateur de nombres aléatoires standard [SWS_CRYPT_30098].

Concernant la concurrence et la robustesse, la méthode est spécifiée comme thread-safe et exception safe [SWS_CRYPT_30098]. Plusieurs threads peuvent ainsi appeler la fonction en parallèle, et la spécification noexcept garantit qu'aucune exception C++ n'est levée au-delà de la frontière de l'interface.

Utilisation

La méthode purement virtuelle GenerateSymmetricKey est fournie via l'interface ara::crypto::cryp::CryptoProvider (fichier d'en-tête #include "ara/crypto/cryp/crypto_provider.h") et sert à la génération d'une nouvelle clé symétrique [SWS_CRYPT_20721]. L'appel synchrone attend comme paramètre algId l'identifiant de l'algorithme cryptographique symétrique cible ainsi que, sous forme de allowedUsage, des drapeaux binaires définissant les types de transformation autorisés pour la clé générée [SWS_CRYPT_20721]. En cas d'exécution réussie, la méthode fournit un ara::core::Result avec un SymmetricKey::Sptr, c'est-à-dire un shared pointer vers l'objet clé symétrique nouvellement généré [SWS_CRYPT_20721].

Gestion des erreurs

Si une erreur survient pendant la génération de la clé, celle-ci est transmise dans le ara::core::Result. Pour tous les cas d'erreur spécifiés, une sémantique de retour arrière (rollback) s'applique [SWS_CRYPT_20721] :

• ara::crypto::CryptoErrc::kUnknownIdentifier : signalé si une valeur non prise en charge a été transmise pour algId [SWS_CRYPT_20721].
• ara::crypto::CryptoErrc::kIncompatibleArguments : survient lorsque les drapeaux allowedUsage spécifiés sont incompatibles avec l'algorithme algId choisi ou avec le type de clé [SWS_CRYPT_20721].
• ara::crypto::CryptoErrc::kBusyResource : indique que l'opération ne peut temporairement pas être effectuée en raison de ressources momentanément occupées [SWS_CRYPT_20721].

Concurrence et restrictions

L'opération est déclarée comme noexcept et possède les propriétés d'être sûre vis-à-vis des exceptions (exception safe) ainsi que thread-safe [SWS_CRYPT_20721]. Elle peut donc être appelée de manière concurrente depuis plusieurs threads, l'erreur kBusyResource pouvant survenir sous forte charge système pour signaler des goulots d'étranglement temporaires [SWS_CRYPT_20721].

La méthode GetSecureCounter() de la classe ara::crypto::cryp::CryptoProvider (déclarée dans #include "ara/crypto/cryp/crypto_provider.h") interroge l'état de comptage actuel du compteur sécurisé de l'instance de fournisseur [SWS_CRYPT_20098]. La fonction s'exécute de manière synchrone et ne requiert aucun paramètre d'entrée [SWS_CRYPT_20098]. En cas de succès, elle renvoie via ara::core::Result<SecureCounter> la structure SecureCounter, qui est constituée de deux valeurs 64 bits non signées (LSQW pour Least Significant Quad Word et MSQW pour Most Significant Quad Word) [SWS_CRYPT_20098]. Il est garanti que chaque état de comptage renvoyé est strictement supérieur à toutes les valeurs précédemment fournies via cette instance [SWS_CRYPT_20098].

Si l'état de comptage ne peut pas être déterminé, l'appel échoue et renvoie un code d'erreur avec une sémantique de rollback dans l'objet Result [SWS_CRYPT_20098] :

• ara::crypto::CryptoErrc::kUnsupported : le CryptoProvider spécifique ne prend pas en charge de compteur sécurisé [SWS_CRYPT_20098].
• ara::crypto::CryptoErrc::kBusyResource : une ressource requise pour l'accès ou la mise à jour du compteur est actuellement occupée [SWS_CRYPT_20098].

En ce qui concerne la concurrence et la robustesse, la fonction est spécifiée comme thread-safe (thread-safe) et déclarée avec noexcept comme sûre vis-à-vis des exceptions (exception safe) [SWS_CRYPT_20098]. Des appels parallèles depuis plusieurs threads sont ainsi autorisés sans synchronisation externe, la stricte monotonie des valeurs de compteur fournies restant garantie [SWS_CRYPT_20098].

Utilisation

La méthode ImportPrivateKey de la classe ara::crypto::cryp::CryptoProvider sert à importer de manière synchrone une clé privée sérialisée [SWS_CRYPT_50132]. Lors de l'appel, les données utiles sont transmises via la zone de mémoire serialized (ReadOnlyMemRegion), complétées par les restrictions d'utilisation souhaitées (allowedUsage) et le format de sérialisation (formatId). Le paramètre algId est facultatif (ara::core::Optional<AlgId>) et ne doit être défini que si le format choisi ne définit pas déjà lui-même sans ambiguïté les propriétés de clé requises [SWS_CRYPT_50132]. Comme valeur de retour, la fonction renvoie un ara::core::Result<PrivateKey::Sptr> qui, en cas de succès, contient un shared pointer vers l'objet clé créé.

Gestion des erreurs

En cas d'erreur, la méthode garantit qu'une sémantique de rollback s'applique [SWS_CRYPT_50132]. Les codes d'erreur suivants peuvent être renvoyés via le Result :

• InvalidArgument : les données sérialisées dans serialized ne correspondent pas au format indiqué [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kIncompatibleArguments : les allowedUsage transmis sont incompatibles avec la algId [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kUnsupported : la fonction n'est pas prise en charge par le provider concret [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut temporairement pas être exécutée en raison de ressources occupées [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kUnsupportedFormat : la formatId n'est pas prise en charge pour ce type d'objet [SWS_CRYPT_50132].

Concurrence et restrictions

L'interface est déclarée comme noexcept et offre la sécurité vis-à-vis des exceptions (exception safe) ainsi que la sécurité des threads (thread-safe) [SWS_CRYPT_50132]. Les appels peuvent ainsi s'effectuer en parallèle depuis différents threads.

Utilisation

La méthode ImportPublicKey sert à importer une clé publique sérialisée dans le ara::crypto::cryp::CryptoProvider respectif [SWS_CRYPT_20732]. L'appel s'effectue de manière synchrone et renvoie un ara::core::Result<PublicKey::Sptr> qui, en cas de succès, contient un Smart Pointer vers l'objet de clé créé [SWS_CRYPT_20732].

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

• serialized : une zone mémoire ReadOnlyMemRegion qui fournit les données brutes de la clé sérialisée.
• allowedUsage : les indicateurs d'utilisation autorisés (AllowedUsageFlags) pour la clé importée.
• formatId : l'identifiant du format de sérialisation (FormatId).
• algId : un ID d'algorithme optionnel (ara::core::Optional<AlgId>). Il n'est pas requis si le format de sérialisation détermine déjà sans ambiguïté les propriétés de la clé.

Gestion des erreurs

Si une erreur survient lors du traitement, elle est encapsulée dans le ara::core::Result renvoyé. Les codes d'erreur suivants sont spécifiés [SWS_CRYPT_20732] :

• InvalidArgument : les données transmises dans serialized ne correspondent pas au format spécifié.
• ara::crypto::CryptoErrc::kIncompatibleArguments : les flags d'utilisation allowedUsage sont incompatibles avec algId.
• ara::crypto::CryptoErrc::kUnsupportedFormat : la formatId spécifiée n'est pas prise en charge pour ce type d'objet.
• ara::crypto::CryptoErrc::kUnsupported : la fonction demandée n'est pas prise en charge par CryptoProvider.
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut pas être exécutée temporairement.

Concurrence et sécurité

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 conformément à la spécification [SWS_CRYPT_20732]. Les cas d'erreur suivent des sémantiques de rollback définies [SWS_CRYPT_20732].

Utilisation

La méthode ImportSymmetricKey de l'interface ara::crypto::cryp::CryptoProvider sert à importer une clé symétrique sérialisée [SWS_CRYPT_50014]. Comme valeur de retour, elle fournit un ara::core::Result<SymmetricKey::Sptr> qui met à disposition en cas de succès un pointeur intelligent vers l'objet de clé nouvellement instancié [SWS_CRYPT_50014]. Comme aucun type de retour asynchrone tel qu'un Future n'est utilisé, l'exécution devrait avoir lieu de manière synchrone. Question Q-720a495b07c4f31d (ouverte)

Les paramètres suivants doivent être transmis lors de l'appel [SWS_CRYPT_50014] :

• serialized (ReadOnlyMemRegion) : la zone mémoire contenant les données de clé sérialisées.
• allowedUsage (AllowedUsageFlags) : masque de bits des opérations et utilisations autorisées pour cette clé.
• formatId (FormatId) : identifiant du format de sérialisation des données de clé.
• algId (ara::core::Optional<AlgId>) : identifiant d'algorithme optionnel ; il n'est pas nécessaire si le format de sérialisation spécifié détermine déjà de manière univoque toutes les propriétés requises de la clé.

Gestion des erreurs et conditions limites

La méthode est spécifiée comme thread-safe et exception safe [SWS_CRYPT_50014]. En cas d'erreur, l'implémentation garantit une sémantique de rollback et renvoie un code d'erreur correspondant dans le ara::core::Result [SWS_CRYPT_50014] :

• InvalidArgument : les données binaires transmises dans serialized ne correspondent pas au format spécifié.
• ara::crypto::CryptoErrc::kIncompatibleArguments : les indicateurs allowedUsage définis sont incompatibles avec la algId spécifiée.
• ara::crypto::CryptoErrc::kUnsupported : la fonction n'est pas prise en charge par l'instance concrète du CryptoProvider.
• ara::crypto::CryptoErrc::kUnsupportedFormat : le format spécifié n'est pas pris en charge pour ce type de clé.
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut pas être exécutée actuellement en raison de ressources temporairement occupées.

Utilisation

La méthode LoadPrivateKey de l'interface ara::crypto::cryp::CryptoProvider charge une clé privée depuis un slot de clé fourni ([SWS_CRYPT_20764]). L'appel est exécuté de manière synchrone et prend en paramètre un pointeur partagé vers la ressource source (keySlot). En cas de succès, la fonction fournit un pointeur partagé vers l'objet clé chargé (PrivateKey::Sptr), qui est renvoyé au sein d'un ara::core::Result ([SWS_CRYPT_20764]).

Gestion des erreurs

Si une erreur survient pendant l'opération, une sémantique de retour arrière (rollback) s'applique et le ara::core::Result contient un code d'erreur spécifique ([SWS_CRYPT_20764]) :

• ara::crypto::CryptoErrc::kEmptyKeySlot : Le slot de clé transmis est vide ([SWS_CRYPT_20764]).
• ara::crypto::CryptoErrc::kIncompatibleObject : La ressource sous-jacente appartient à un autre CryptoProvider incompatible ou contient un type de clé divergent ([SWS_CRYPT_20764]).
• ara::crypto::CryptoErrc::kBusyResource : l'opération ne peut pas être exécutée temporairement ([SWS_CRYPT_20764]).

Concurrence et sécurité

La spécification classe la fonction comme thread-safe et exception-safe ; la signature est déclarée comme noexcept ([SWS_CRYPT_20764]). Plusieurs threads peuvent appeler la méthode en parallèle, mais doivent traiter un éventuel retour de kBusyResource en cas de conflits temporaires de ressources.

Utilisation

La méthode LoadPublicKey de l'interface ara::crypto::cryp::CryptoProvider charge une clé publique à partir de l'emplacement de stockage de clés fourni [SWS_CRYPT_20763]. En tant que paramètre keySlot, elle attend un KeySlot::Sptr qui référence l'emplacement de stockage contenant la clé à charger [SWS_CRYPT_20763]. Comme valeur de retour, la fonction fournit un ara::core::Result<PublicKey::Sptr> qui, en cas de succès, contient un pointeur partagé vers l'objet clé publique chargé [SWS_CRYPT_20763]. La fourniture directe de la valeur Result devrait à cet égard indiquer un comportement d'appel synchrone. Question Q-e0d2480909b1398a (ouverte)

Gestion des erreurs

Si le processus de chargement échoue, le ara::core::Result contient un code d'erreur correspondant du domaine ara::crypto::CryptoErrc, une sémantique de rollback étant définie pour tous les cas d'erreur spécifiés [SWS_CRYPT_20763] :

• ara::crypto::CryptoErrc::kEmptyKeySlot : survient lorsque le KeySlot transmis est vide [SWS_CRYPT_20763].
• ara::crypto::CryptoErrc::kIncompatibleObject : est renvoyé lorsque la ressource sous-jacente appartient à un autre CryptoProvider incompatible ou contient un type de clé divergent [SWS_CRYPT_20763].
• ara::crypto::CryptoErrc::kBusyResource : survient si l'opération ne peut pas être exécutée temporairement, car la ressource est occupée par ailleurs [SWS_CRYPT_20763].

Concurrence et sécurité

La méthode est déclarée avec noexcept et spécifiée comme sûre vis-à-vis des exceptions (exception-safe) [SWS_CRYPT_20763]. En ce qui concerne la concurrence, l'opération est explicitement classée comme sûre vis-à-vis des threads (thread-safe), ce qui autorise les appels parallèles depuis plusieurs threads [SWS_CRYPT_20763].

La méthode virtuelle pure LoadSymmetricKey de la classe ara::crypto::cryp::CryptoProvider sert à charger une clé symétrique à partir d'un emplacement de stockage de clés fourni [SWS_CRYPT_20762]. Comme paramètre, la fonction reçoit un pointeur partagé vers l'emplacement de stockage concerné (keySlot) et renvoie de manière synchrone un ara::core::Result<SymmetricKey::Sptr> qui, lors d'une exécution réussie, fournit un pointeur partagé vers l'objet clé chargé [SWS_CRYPT_20762].

Concernant la concurrence et la sûreté d'exécution, la méthode est spécifiée comme thread-safe ainsi que exception safe et déclarée avec noexcept [SWS_CRYPT_20762].

Si une erreur survient lors du chargement, la méthode renvoie, via l'objet Result, des codes d'erreur spécifiques du domaine ara::crypto::CryptoErrc avec une sémantique de rollback définie [SWS_CRYPT_20762] :

• ara::crypto::CryptoErrc::kEmptyKeySlot : survient lorsque le KeySlot transmis est vide [SWS_CRYPT_20762].
• ara::crypto::CryptoErrc::kIncompatibleObject : est renvoyé si la ressource sous-jacente appartient à un autre Crypto-Provider incompatible ou contient un autre type de clé [SWS_CRYPT_20762].
• ara::crypto::CryptoErrc::kBusyResource : signale que l'opération ne peut pas être exécutée temporairement [SWS_CRYPT_20762].