classe ara::crypto::cryp::VerifierPublicCtx

Utilisation et sémantique

La méthode Cancel() interrompt une opération de streaming en cours, préalablement initiée par Start() et non encore terminée [SWS_CRYPT_50023]. Elle est définie dans l'en-tête ara/crypto/cryp/verifier_public_ctx.h en tant que méthode pure virtual du contexte ara::crypto::cryp::VerifierPublicCtx [SWS_CRYPT_50023]. L'appel s'effectue de manière synchrone et sans arguments. La valeur de retour est un ara::core::Result<void>, qui est vide en cas de succès et confirme l'interruption réussie de l'opération [SWS_CRYPT_50023].

Gestion des erreurs

Si le traitement des données n'a pas encore débuté par l'appel de la méthode Start(), l'opération d'interruption échoue. Dans ce scénario, la fonction renvoie un résultat d'erreur avec le code d'erreur ara::crypto::CryptoErrc::kProcessingNotStarted tout en garantissant une sémantique de rollback [SWS_CRYPT_50023].

Concurrence et restrictions

La spécification désigne la méthode comme sûre au niveau des threads (thread-safe) et sûre vis-à-vis des exceptions (exception safe) avec la désignation noexcept [SWS_CRYPT_50023]. Interprétation : après une interruption réussie, le contexte devrait revenir à l'état initial précédant le début du traitement, de sorte qu'une nouvelle opération de streaming puisse être initiée. Question Q-d80d09c8a8311bbc (ouverte)

Interaction au sein du module crypt

Ce modèle d'interruption unifié, présentant une signature et un traitement des erreurs identiques, s'applique de manière cohérente à l'ensemble des contextes de streaming du module crypt :

• MessageAuthnCodeCtx pour les Message Authentication Codes [SWS_CRYPT_50027],
• SignerPrivateCtx pour la génération de signatures numériques [SWS_CRYPT_50041],
• SymmetricCipherCtx pour le chiffrement et le déchiffrement symétriques [SWS_CRYPT_50046],
• HashFunctionCtx pour les opérations de hachage cryptographique [SWS_CRYPT_50058],
• DecryptorPrivateCtx pour le déchiffrement asymétrique [SWS_CRYPT_50069],
• AuthCipherCtx pour le chiffrement authentifié [SWS_CRYPT_50077] ainsi que
• EncryptorPublicCtx pour le chiffrement asymétrique [SWS_CRYPT_50089].

La méthode Finish dans ara::crypto::cryp::VerifierPublicCtx finalise une vérification de signature et renvoie le résultat de la vérification [SWS_CRYPT_50022]. Elle reçoit via le tampon d'entrée signature (type ReadOnlyMemRegion) la signature à vérifier ainsi que via signatureFormat (type FormatId) son format [SWS_CRYPT_50022]. L'appel a lieu de manière synchrone et est déclaré selon la spécification comme thread-safe ainsi qu'exception safe [SWS_CRYPT_50022].

Un ara::core::Result<bool> sert de valeur de retour [SWS_CRYPT_50022] : en cas de validation réussie de la signature, le résultat contient true, et en cas de signature invalide quant à son contenu, false. Si en revanche une erreur de traitement survient, un code d'erreur correspondant est renvoyé [SWS_CRYPT_50022] :

• ara::crypto::CryptoErrc::kProcessingNotStarted : l'opération n'a pas été démarrée avec succès au préalable (sémantique de rollback) [SWS_CRYPT_50022].
• ara::crypto::CryptoErrc::kInvalidInputSize : la taille de tampon de signature est invalide (sémantique de rollback) [SWS_CRYPT_50022].
• ara::crypto::CryptoErrc::kUnsupportedFormat : le format spécifié signatureFormat n'est pas pris en charge (sémantique de rollback) [SWS_CRYPT_50022].
• ara::crypto::CryptoErrc::kInvalidArgument : la signature ne correspond pas au format spécifié (sémantique de rollback) [SWS_CRYPT_50022].

Dans le déroulement cryptographique, cette fonction constitue le pendant de la génération de signature via ara::crypto::cryp::SignerPrivateCtx::Finish [SWS_CRYPT_50040], qui écrit une signature dans un tampon de sortie. Toutes les erreurs signalées possèdent une sémantique de rollback [SWS_CRYPT_50022], de sorte que l'état du contexte reste cohérent en cas d'échec.

La méthode SetKey configure une instance de VerifierPublicCtx pour l'utilisation d'une clé publique concrète destinée à la vérification de signature ([SWS_CRYPT_24115]). Un pointeur de type PublicKey::Sptr est transmis via le paramètre key. L'appel s'effectue de manière synchrone et renvoie un ara::core::Result<void>, qui est vide en cas de succès ou encapsule un code d'erreur spécifique.

D'après la spécification, l'opération est conçue pour être thread-safe et sûre vis-à-vis des exceptions (exception safe) ([SWS_CRYPT_24115]). Si une erreur survient pendant la liaison de la clé, une sémantique de rollback s'applique pour tous les cas d'erreur, de sorte que le contexte reste dans un état cohérent :

• CryptoErrc::kIncompatibleObject : la clé transmise est incompatible avec le contexte de vérification de signature ([SWS_CRYPT_24115]).
• CryptoErrc::kUsageViolation : les permissions de la clé ne permettent pas la vérification de signature (absence de l'indicateur d'utilisation pour la vérification de signature) ([SWS_CRYPT_24115]).
• ara::crypto::CryptoErrc::kUnsupported : l'implémentation du contexte prend exclusivement en charge la liaison d'une clé via un KeySlot ([SWS_CRYPT_24115]).

Dans le workflow cryptographique, SetKey constitue le pendant public de SignerPrivateCtx::SetKey ([SWS_CRYPT_23515]). Dans la mesure où un contexte ne permet pas la transmission directe de la clé via PublicKey::Sptr ou si les clés sont gérées dans des emplacements sécurisés, la surcharge au moyen de KeySlot::Sptr est disponible comme alternative ([SWS_CRYPT_50018]).

Utilisation

La méthode SetKey de la classe ara::crypto::cryp::VerifierPublicCtx configure le contexte de vérification pour l'utilisation d'une clé stockée dans un KeySlot transmis [SWS_CRYPT_50018]. La clé est utilisée au moment où la vérification de signature est démarrée [SWS_CRYPT_50018].

Un smart pointer keySlot de type KeySlot::Sptr, qui contient une clé publique, sert de paramètre [SWS_CRYPT_50018]. La fonction s'exécute de manière synchrone et renvoie un ara::core::Result<void> afin d'indiquer une réussite ou une erreur [SWS_CRYPT_50018].

Traitement des erreurs et sémantique

L'opération est spécifiée comme noexcept et exception safe [SWS_CRYPT_50018]. Si une erreur survient, une sémantique de rollback s'applique [SWS_CRYPT_50018] :

• ara::crypto::CryptoErrc::kIncompatibleObject : le KeySlot fourni est incompatible avec ce contexte [SWS_CRYPT_50018].
• ara::crypto::CryptoErrc::kUnsupported : le contexte prend exclusivement en charge la définition directe d'un PublicKey [SWS_CRYPT_50018].

Concurrence et interaction

La méthode est spécifiée thread-safe [SWS_CRYPT_50018]. Comme alternative au KeySlot, VerifierPublicCtx propose une surcharge permettant de définir directement un PublicKey [SWS_CRYPT_24115]. Une configuration de clé correspondante via un KeySlot existe de manière analogue dans d'autres contextes tels que SignerPrivateCtx [SWS_CRYPT_50036] ou MessageAuthnCodeCtx [SWS_CRYPT_50026].

Utilisation

La méthode synchrone Start() de l'interface ara::crypto::cryp::VerifierPublicCtx ([SWS_CRYPT_50019]) initialise le contexte pour un nouveau contrôle de signature cryptographique en mode streaming. La fonction n'accepte aucun paramètre d'entrée, est déclarée comme noexcept et retourne un ara::core::Result<void>, qui est vide en cas de succès.

Gestion des erreurs et rollback

Si une erreur survient lors de l'exécution, la sémantique de rollback s'applique ([SWS_CRYPT_50019]), maintenant ainsi le contexte dans un état cohérent. Les causes d'erreur possibles sont :

• UninitializedContext : aucune clé cryptographique n'a été préalablement assignée au contexte.
• ara::crypto::CryptoErrc::kUsageViolation : la clé assignée n'est pas autorisée pour le contrôle de signature (kAllowSig Verification).
• ara::crypto::CryptoErrc::kEmptyKeySlot : un KeySlot configuré pour la vérification est actuellement vide.
• ara::crypto::CryptoErrc::kUnsupported : le contexte ne prend pas en charge le streaming ou le procédé exige impérativement une valeur de contexte.
• ara::crypto::CryptoErrc::kBusyResource : une ressource requise pour l'opération est actuellement occupée.

Concurrence et interaction

Bien que la spécification désigne la méthode comme étant thread-safe ([SWS_CRYPT_50019]), un appel parallèle sur la même instance de contexte pendant une vérification en cours devrait réinitialiser l'opération existante ou échouer en raison de ressources occupées. Question Q-af5e08ff9d905a29 (ouverte)

Après une initialisation réussie, les fragments de message sont transmis séquentiellement via Update() ([SWS_CRYPT_50021]). Une opération de streaming en cours peut être interrompue prématurément avec Cancel() ([SWS_CRYPT_50023]) si nécessaire. Si l'algorithme requiert obligatoirement une valeur de contexte, la fonction surchargée Start(ReadOnlyMemRegion context) ([SWS_CRYPT_50020]) doit être appelée à la place.

Utilisation

La fonction Start initialise conformément à [SWS_CRYPT_50020] un contexte de vérification de la classe ara::crypto::cryp::VerifierPublicCtx pour une nouvelle vérification de signature. Comme paramètre d'entrée, elle reçoit context de type ReadOnlyMemRegion, qui fournit une valeur de contexte spécifique à l'application. La surcharge [SWS_CRYPT_50019] existe comme alternative sans données de contexte. La valeur de retour est ara::core::Result<void> ; interprétation : étant donné que ni rappels ni objets future ne sont définis, l'appel devrait être traité de façon purement synchrone. Question Q-4e10cdb1a4343a3a (ouverte)

Gestion des erreurs

En cas d'erreur, la fonction fournit un ara::core::Result avec un code d'erreur approprié issu de ara::crypto::CryptoErrc, une sémantique de rollback étant spécifiée [SWS_CRYPT_50020] :

• kUninitializedContext : le contexte n'a pas encore été initialisé par l'assignation d'une clé.
• kEmptyKeySlot : Un KeySlot configuré est actuellement vide.
• kUsageViolation : L'utilisation autorisée de la clé assignée n'inclut pas kAllowSigVerification.
• kInvalidInputSize : La taille de tampon de la valeur de contexte transmise est invalide pour l'algorithme.
• kUnsupported : Le contexte ne prend pas en charge le streaming ou l'algorithme ne prend pas en charge la définition d'une valeur de contexte.
• kBusyResource : Une ressource requise est occupée.

Concurrence et restrictions

Conformément à [SWS_CRYPT_50020], la méthode est classée comme thread-safe et exception-safe. Elle ne lève aucune exception (noexcept).

Interaction

Après l'exécution réussie de Start, le message d'entrée peut être transmis pas à pas via des appels répétés de Update [SWS_CRYPT_50021]. Une opération de streaming en cours, initiée par Start, peut être interrompue prématurément via Cancel si nécessaire [SWS_CRYPT_50023].

Utilisation

La méthode Update() sert à mettre à jour pas à pas le contexte de vérification de signature avec une partie supplémentaire du message d'entrée [SWS_CRYPT_50021]. Une zone mémoire data de type ReadOnlyMemRegion est transmise en paramètre. La fonction renvoie un ara::core::Result<void> ; interprétation : en raison de ce type de retour, le traitement devrait s'effectuer de manière synchrone. Question Q-f98391030b3b4684 (ouverte)

Gestion des erreurs

En cas d'erreur, un code d'erreur correspondant avec sémantique de rollback est renvoyé [SWS_CRYPT_50021] :

• ara::crypto::CryptoErrc::kProcessingNotStarted : La vérification de signature n'a pas été initiée auparavant par un appel de la méthode Start() [SWS_CRYPT_50021].
• ara::crypto::CryptoErrc::kInvalidInputSize : La taille des données fournies dans data n'est pas prise en charge [SWS_CRYPT_50021].

Concurrence et interaction

L'opération est classée dans la spécification comme thread-safe et exception safe [SWS_CRYPT_50021]. L'initialisation via Start() doit impérativement avoir eu lieu avant l'appel [SWS_CRYPT_50021]. Pour éviter que kInvalidInputSize ne survienne, la taille de tampon maximale autorisée pour des appels individuels peut être interrogée via la méthode GetMaximumChunkSize() du même contexte [SWS_CRYPT_50025]. Le pendant complémentaire de la génération de signature message par message est représenté par Update() dans SignerPrivateCtx [SWS_CRYPT_50039].

Utilisation

La méthode Verify du contexte ara::crypto::cryp::VerifierPublicCtx sert à vérifier la signature d'un message fourni en un seul appel [SWS_CRYPT_24112]. Le tampon de message message, la signature signature ainsi que le format signatureFormat sont transmis comme paramètres [SWS_CRYPT_24112]. La valeur de retour ara::core::Result<bool> contient true en cas de contrôle réussi, false en cas de non-concordance ou un code d'erreur [SWS_CRYPT_24112]. Interprétation : en raison du type de résultat synchrone, le processus de vérification devrait se dérouler de manière bloquante dans le thread appelant. Question Q-671054c6e2b581c6 (ouverte)

Gestion des erreurs et concurrence

La fonction est spécifiée comme exception safe et thread-safe [SWS_CRYPT_24112]. En cas d'erreur, une sémantique de rollback s'applique pour les codes d'erreur [SWS_CRYPT_24112]. Les causes d'erreur possibles comprennent :

• UninitializedContext, si le contexte n'a pas été initialisé avec une clé [SWS_CRYPT_24112],
• ara::crypto::CryptoErrc::kEmptyKeySlot en cas de slot de clé vide ou kUsageViolation si le droit kAllowSig Verification manque à la clé [SWS_CRYPT_24112],
• ara::crypto::CryptoErrc::kInvalidInputSize en cas de taille de tampon non autorisée [SWS_CRYPT_24112],
• ara::crypto::CryptoErrc::kUnsupportedFormat ou kInvalidArgument en cas de format de signature erroné ou incompatible [SWS_CRYPT_24112],
• ara::crypto::CryptoErrc::kBusyResource si des ressources requises sont occupées [SWS_CRYPT_24112].

Interaction

La taille maximale de tampon pour les appels individuels peut être interrogée via GetMaximumChunkSize() [SWS_CRYPT_50025]. Si l'algorithme exige impérativement une valeur de contexte, ara::crypto::CryptoErrc::kUnsupported est renvoyé [SWS_CRYPT_24112] ; dans ce cas, il convient de choisir la surcharge avec le paramètre context supplémentaire [SWS_CRYPT_50024]. Pour les contrôles de Message Authentication Codes, il existe de façon distincte ara::crypto::cryp::MessageAuthnCodeCtx::Verify [SWS_CRYPT_50031].

La méthode synchrone Verify vérifie la signature numérique d'un message transmis en tenant compte d'une valeur de contexte définie par l'utilisateur en un seul appel ([SWS_CRYPT_50024]). En guise de paramètres d'entrée, la méthode attend les tampons message, context et signature chacun en tant que ReadOnlyMemRegion ainsi que le format de la signature via signatureFormat ([SWS_CRYPT_50024]). La valeur de retour est un ara::core::Result<bool> : elle contient true en cas de vérification réussie, false en cas de signature erronée ou un code d'erreur correspondant ([SWS_CRYPT_50024]).

En cas d'erreur, une sémantique de rollback s'applique ([SWS_CRYPT_50024]). Les codes d'erreur spécifiques comprennent notamment :

• UninitializedContext, si le contexte de vérification n'a pas encore été initialisé avec une valeur de clé ([SWS_CRYPT_50024]),
• ara::crypto::CryptoErrc::kInvalidInputSize en cas de taille de tampon non autorisée ([SWS_CRYPT_50024]),
• ara::crypto::CryptoErrc::kUnsupported, si l'algorithme de signature sélectionné ne prend pas en charge la spécification d'une valeur de contexte ([SWS_CRYPT_50024]),
• ara::crypto::CryptoErrc::kUnsupportedFormat ou ara::crypto::CryptoErrc::kInvalidArgument, lorsque le format de signature spécifié n'est pas pris en charge ou que la signature ne correspond pas au format ([SWS_CRYPT_50024]),
• ara::crypto::CryptoErrc::kUsageViolation, si l'utilisation autorisée de la clé n'inclut pas kAllowSigVerification, ainsi que ara::crypto::CryptoErrc::kEmptyKeySlot et ara::crypto::CryptoErrc::kBusyResource ([SWS_CRYPT_50024]).

La méthode est déclarée comme const noexcept, considérée comme sûre face aux exceptions et spécifiée comme thread-safe ([SWS_CRYPT_50024]). En interaction avec le contexte, la taille maximale de tampon pour les appels individuels peut être déterminée via GetMaximumChunkSize ([SWS_CRYPT_50025]). Pour les vérifications sans contexte, la surcharge alternative de Verify est disponible ([SWS_CRYPT_24112]).