classe ara::crypto::cryp::RandomGeneratorCtx

La méthode AddEntropy de la classe ara::crypto::cryp::RandomGeneratorCtx sert à mettre à jour l'état interne d'un générateur de nombres aléatoires (RNG) en y incorporant des valeurs d'entropie transmises en supplément [SWS_CRYPT_22914]. La déclaration est disponible via le fichier d'en-tête ara/crypto/cryp/random_generator_ctx.h [SWS_CRYPT_22914]. En tant que paramètre d'entrée, la fonction attend un objet de type ReadOnlyMemRegion nommé entropy, qui encapsule la zone mémoire contenant la valeur d'entropie à ajouter [SWS_CRYPT_22914].

L'appel est exécuté de manière synchrone (interprétation : l'interface renvoie le résultat directement sans type de résultat asynchrone). Question Q-6e56e1daaa526bf8 (ouverte) Le résultat est renvoyé sous la forme d'un ara::core::Result<void>, qui est vide en cas de succès si la méthode est prise en charge et que l'entropie a pu être incorporée avec succès [SWS_CRYPT_22914]. En revanche, si le contexte concret du générateur aléatoire ne prend pas en charge l'ajout d'entropie, l'appel échoue et renvoie le code d'erreur ara::crypto::CryptoErrc::kUnsupported avec une sémantique de retour arrière garantie [SWS_CRYPT_22914].

En matière de concurrence et de sûreté face aux erreurs, l'interface est spécifiée comme sûre vis-à-vis des threads (thread-safe) et sûre vis-à-vis des exceptions (exception safe), et elle est dotée de l'identifiant noexcept [SWS_CRYPT_22914]. Les appelants peuvent donc appeler la fonction en toute sécurité depuis plusieurs threads, mais ils doivent toujours évaluer le ara::core::Result renvoyé afin d'intercepter une absence de prise en charge de l'apport d'entropie dans le contexte concerné [SWS_CRYPT_22914].

La fonction Generate de l'interface ara::crypto::cryp::RandomGeneratorCtx sert à remplir un tampon de sortie fourni avec une séquence (pseudo-)aléatoire [SWS_CRYPT_22915]. Comme paramètre de transmission, la méthode accepte la zone mémoire accessible en écriture output de type ReadWriteMemRegion, dans laquelle les octets aléatoires générés sont directement écrits [SWS_CRYPT_22915].

En ce qui concerne la sûreté d'exécution et la concurrence, la méthode est déclarée comme noexcept, est considérée comme sûre vis-à-vis des exceptions et est explicitement spécifiée comme sûre vis-à-vis des threads [SWS_CRYPT_22915]. Cela autorise les appels concurrents depuis plusieurs threads.

Gestion des erreurs

Le type de retour ara::core::Result<void> signale le succès de l'opération par un résultat vide ou fournit, en cas d'erreur, un code d'erreur correspondant avec une sémantique de retour arrière [SWS_CRYPT_22915] :

• ara::crypto::CryptoErrc::kUninitializedContext : Survient si le contexte doit être préalablement initialisé ou alimenté en entropie (« seeded ») par l'application [SWS_CRYPT_22915].
• ara::crypto::CryptoErrc::kBusyResource : Est renvoyé lorsque le contexte est actuellement à court d'entropie (« out-of-entropy ») et ne peut donc pas fournir la quantité demandée d'octets aléatoires [SWS_CRYPT_22915].

Interaction et délimitation

Tandis que RandomGeneratorCtx::Generate écrit des octets de données aléatoires brutes dans des tampons [SWS_CRYPT_22915], il existe dans le module crypt d'autres fonctions de génération avec un objectif différent : ainsi, CryptoProvider::GenerateSymmetricKey [SWS_CRYPT_20721] sert à instancier des clés symétriques et CryptoProvider::GeneratePrivateKey [SWS_CRYPT_20722] à générer des paires de clés asymétriques. De plus, la méthode ne doit pas être confondue avec la fonction homonyme Generate du MessageAuthnCodeCtx, qui sert à calculer un condensé MAC [SWS_CRYPT_50029].

Utilisation

La méthode purement virtuelle Seed de l'interface ara::crypto::cryp::RandomGeneratorCtx sert à définir l'état interne du générateur de nombres aléatoires (RNG) via une zone mémoire fournie [SWS_CRYPT_22911]. La déclaration s'effectue dans l'en-tête ara/crypto/cryp/random_generator_ctx.h avec la signature virtual ara::core::Result<void> Seed(ReadOnlyMemRegion seed) noexcept = 0; [SWS_CRYPT_22911].

Comme paramètre d'entrée, la fonction synchrone reçoit seed de type ReadOnlyMemRegion, qui contient la zone mémoire renfermant la valeur de graine [SWS_CRYPT_22911]. En cas d'exécution réussie et de prise en charge par le contexte, la méthode renvoie un ara::core::Result<void> vide [SWS_CRYPT_22911].

Gestion des erreurs

En cas d'erreur, le ara::core::Result retourné contient un code d'erreur correspondant [SWS_CRYPT_22911] :

• ara::crypto::CryptoErrc::kUnsupported : Se produit lorsque le RandomGeneratorCtx concret ne prend pas en charge l'initialisation par graine ; une sémantique de rollback est spécifiée pour ce cas d'erreur [SWS_CRYPT_22911].

Concurrence et restrictions

L'interface est déclarée comme noexcept et classifiée, en ce qui concerne la sécurité d'exécution, comme exception safe ainsi que thread-safe [SWS_CRYPT_22911].

Interaction

En complément de cette fonction basée sur une zone mémoire, [SWS_CRYPT_22912] définit une surcharge Seed(SymmetricKey::Sptr seed) qui initialise l'état du RNG au moyen d'une clé symétrique en évaluant des restrictions d'utilisation telles que kAllowRngInit.

La méthode Seed initialise l'état interne d'un générateur de nombres aléatoires dans le contexte de ara::crypto::cryp::RandomGeneratorCtx en utilisant une clé symétrique [SWS_CRYPT_22912]. L'appel est synchrone et spécifié comme thread-safe ainsi qu'exception-safe (exception safe et noexcept) [SWS_CRYPT_22912]. Un pointeur intelligent vers une clé (SymmetricKey::Sptr), dont la valeur de clé est reprise comme graine, sert de paramètre d'entrée [SWS_CRYPT_22912].

Lors du traitement des erreurs, la fonction renvoie un ara::core::Result<void> qui est vide en cas de succès [SWS_CRYPT_22912]. Si l'opération échoue, une sémantique de rollback s'applique ; cela concerne en particulier les codes d'erreur suivants :

• ara::crypto::CryptoErrc::kUsageViolation : Se produit si l'utilisation de clé autorisée pour la clé transmise ne comprend pas le drapeau kAllowRngInit [SWS_CRYPT_22912].
• ara::crypto::CryptoErrc::kUnsupported : Est signalé lorsque l'instance de contexte concrète ne prend pas en charge la définition d'une graine au moyen d'une clé symétrique [SWS_CRYPT_22912].

En interaction avec la famille d'interfaces, cette fonction représente la variante basée sur une clé, tandis que la surcharge selon [SWS_CRYPT_22911] couvre l'initialisation via une zone mémoire non structurée (ReadOnlyMemRegion). En raison de la sémantique de rollback, l'état interne du générateur demeure probablement dans son état précédent en cas d'erreur (interprétation). Question Q-970cbedd1843b26a (ouverte)