Chiffre des données de manière asymétrique en une seule étape ou via une opération de streaming en plusieurs parties.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 9ba841f18186ProvenanceQuestions ouvertes (2)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Chiffre des données de manière asymétrique en une seule étape ou via une opération de streaming en plusieurs parties.
L'interface sert au chiffrement asymétrique de données en clair sur l'AUTOSAR Adaptive Platform et est gérée via le pointeur intelligent mis à disposition [SWS_CRYPT_50174]. Après l'assignation d'une clé publique appropriée, les messages peuvent être transformés soit de manière compacte en un seul passage, soit en continu via une session de streaming en plusieurs parties [SWS_CRYPT_50090]. Pour un déroulement correct, les tailles de tampon doivent être calculées au préalable, toutes les opérations du contexte étant spécifiées comme sûres vis-à-vis des exceptions et des threads.
Contexte
La classe C++ ara::crypto::cryp::EncryptorPublicCtx fournit l'interface standardisée pour le chiffrement asymétrique de données dans l'AUTOSAR Adaptive Platform. Elle sert aux applications clientes pour le chiffrement de données en clair à l'aide d'une clé publique asymétrique. La configuration de la clé cryptographique peut alors s'effectuer soit directement via un objet de clé ([SWS_CRYPT_50175]), soit via une référence à un emplacement de stockage de clé (KeySlot, [SWS_CRYPT_50086]). La transmission des données s'effectue via des zones de tampon efficaces en mémoire (ReadOnlyMemRegion pour les données en clair et ReadWriteMemRegion pour la sortie chiffrée).
Cycle de vie
Les instances du contexte sont gérées via le pointeur partagé std::shared_ptr<EncryptorPublicCtx> défini dans l'alias de type Sptr ([SWS_CRYPT_50174]). La création elle-même ne fait pas partie de cette définition d'interface ; l'instanciation s'effectue probablement via un composant de fabrique de niveau supérieur de l'architecture Crypto. Question Q-5b7490ba113bb861 (ouverte) L'objet traverse des états clairement définis au cours de sa durée de vie :
Non initialisé : après l'instanciation, le contexte ne possède pas encore de clé. Les opérations de traitement de données ne sont pas autorisées dans cet état.
Configuré (prêt) : par l'appel de SetKey() avec un PublicKey ([SWS_CRYPT_50175]) ou un KeySlot ([SWS_CRYPT_50086]), le contexte devient prêt à l'emploi. À partir de cet état, il est possible soit d'exécuter un chiffrement en une seule étape, soit de démarrer une session de streaming.
Streaming actif : l'appel de Start() ([SWS_CRYPT_50087]) place le contexte dans l'état de streaming. Les blocs de données continus sont traités via Update() ([SWS_CRYPT_50176]). La session est soit conclue avec Finish() ([SWS_CRYPT_50088]), soit interrompue avec Cancel() ([SWS_CRYPT_50089]), ramenant ainsi le contexte à l'état Configuré.
Toutes les méthodes de la classe sont spécifiées comme sûres vis-à-vis des exceptions (exception safe) et des threads (thread-safe). Si le contexte est détruit alors qu'une opération de streaming n'est pas encore terminée, l'implémentation sous-jacente devrait nettoyer les tampons alloués et abandonner implicitement la session. Question Q-3eadc946a0bdbdfd (ouverte)
La classe prend en charge deux modes de traitement : le traitement en une seule étape pour des ensembles de données complets et le streaming en plusieurs étapes pour des flux de données segmentés. Avant de procéder aux chiffrements, les applications doivent prendre en compte les limites de tampon :
Via GetMinimumChunkSize()` (<a class="spec-record-ref" data-req="SWS_CRYPT_50178">[SWS_CRYPT_50178]</a>) und <code>GetMaximumChunkSize() ([SWS_CRYPT_50091]), il est possible de déterminer les tailles d'entrée minimale et maximale prises en charge pour des appels individuels.
La capacité nécessaire du tampon de sortie doit être demandée au préalable avec GetRequiredOutputBufferSize() ([SWS_CRYPT_50177]). Le paramètre isFinal contrôle ici si le calcul s'effectue pour des étapes intermédiaires (false) ou des appels finaux / étapes uniques (true).
Le déroulement typique d'un chiffrement par streaming se divise selon les étapes suivantes :
Attribution de clé via SetKey() avec un PublicKey valide ([SWS_CRYPT_50175]).
Initialisation de la session de streaming par appel de Start() ([SWS_CRYPT_50087]).
Calcul de la taille de tampon de sortie requise pour les blocs intermédiaires avec GetRequiredOutputBufferSize(inputSize, false) ([SWS_CRYPT_50177]).
Transformation répétée de blocs de données via Update() ([SWS_CRYPT_50176]).
Détermination de la taille de tampon pour le dernier bloc (isFinal = true) et finalisation de l'opération via Finish() ([SWS_CRYPT_50088]).
Pour les données compactes pouvant être traitées en un seul passage, Encrypt() ([SWS_CRYPT_50090]) offre un appel direct en une seule étape, sans division en phases Start, Update et Finish.
Toutes les méthodes utilisent ara::core::Result pour le signalement des erreurs et garantissent une sémantique de retour arrière (rollback) en cas d'erreur :
Erreurs d’état : Un appel de Start(), Encrypt() ou GetRequiredOutputBufferSize() sur un contexte non initialisé entraîne ara::crypto::CryptoErrc::kUninitializedContext ([SWS_CRYPT_50087], [SWS_CRYPT_50090], [SWS_CRYPT_50177]). Si Update(), Finish() ou Cancel() sont appelés sans que Start() n’ait été exécuté au préalable, l’opération échoue avec ara::crypto::CryptoErrc::kProcessingNotStarted ([SWS_CRYPT_50176], [SWS_CRYPT_50088], [SWS_CRYPT_50089]).
Erreurs de tampon et de données : Si le tampon de sortie transmis est sous-dimensionné, Encrypt(), Update() et Finish() répondent par ara::crypto::CryptoErrc::kInsufficientCapacity ([SWS_CRYPT_50090], [SWS_CRYPT_50176], [SWS_CRYPT_50088]). Les écarts par rapport aux tailles de blocs autorisées entraînent ara::crypto::CryptoErrc::kInvalidInputSize, et des données d’entrée non valides entraînent ara::crypto::CryptoErrc::kInvalidArgument.
Fonctions non prises en charge et goulots d’étranglement de ressources : Si l’implémentation ne prend pas en charge le streaming ou un appel en une seule étape, l’opération échoue avec ara::crypto::CryptoErrc::kUnsupported ([SWS_CRYPT_50087], [SWS_CRYPT_50090], [SWS_CRYPT_50176], [SWS_CRYPT_50088]). En cas de ressources cryptographiques bloquées, ara::crypto::CryptoErrc::kBusyResource est renvoyé ([SWS_CRYPT_50087], [SWS_CRYPT_50090]).
Ce guide se base sur les exigences de la version R25-11 d’AUTOSAR Adaptive Platform et résume la spécification de la classe ara::crypto::cryp::EncryptorPublicCtx.
Cancel the ongoing streaming operation that has been initiated by Start() and has not yet been finished.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : c2111af75063ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode Cancel() interrompt une opération de streaming active dans le contexte ara::crypto::cryp::EncryptorPublicCtx, qui a été préalablement initiée au moyen de Start() et n'est pas encore terminée [SWS_CRYPT_50089]. Elle n'accepte aucun paramètre d'entrée et renvoie un ara::core::Result<void> qui est vide en cas de succès [SWS_CRYPT_50089]. Étant donné que la signature fournit directement un Result et non un Future, l'interruption devrait s'exécuter de manière synchrone. Question Q-cd18e56d693fe1a4 (ouverte)
Gestion des erreurs et concurrence
Si le traitement des données n'a pas été démarré préalablement par Start(), l'opération échoue avec le code d'erreur ara::crypto::CryptoErrc::kProcessingNotStarted dans le respect de la sémantique de rollback [SWS_CRYPT_50089]. Conformément à la spécification, l'interface est déclarée avec noexcept, sûre face aux exceptions (exception safe) et classée comme sûre pour les threads (thread-safe) pour les accès concurrents [SWS_CRYPT_50089].
Interaction au sein de la pile cryptographique
Le comportement d'interruption réalisé par Cancel() suit un patron de conception uniforme pour les opérations de streaming avec état dans le module de cryptographie. Des interfaces analogues présentant une sémantique d'erreur identique existent pour :
le déchiffrement asymétrique dans DecryptorPrivateCtx[SWS_CRYPT_50069],
les codes d'authentification de message dans MessageAuthnCodeCtx[SWS_CRYPT_50027] ainsi que les calculs de hachage dans HashFunctionCtx[SWS_CRYPT_50058].
Ce texte a été généré par une IA et se base sur AUTOSAR Adaptive R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 523fe4336ba2Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
La méthode synchrone Encrypt sert à chiffrer des données en texte clair en un seul appel ([SWS_CRYPT_50090]). Elle prend les données d'entrée depuis le tampon in (ReadOnlyMemRegion) et écrit le texte chiffré dans le tampon de sortie out (ReadWriteMemRegion) ([SWS_CRYPT_50090]). La valeur de retour ara::core::Result<std::size_t> fournit en cas de succès la taille des données de sortie effectivement écrites, qui peut être inférieure à la capacité totale de out ([SWS_CRYPT_50090]).
En ce qui concerne la concurrence, la fonction est spécifiée comme sûre vis-à-vis des threads (thread-safe) ainsi que sûre vis-à-vis des exceptions (exception safe) ([SWS_CRYPT_50090]).
En interaction avec le contexte EncryptorPublicCtx, les limites de tampon suivantes doivent être respectées avant l'appel :
La taille d'entrée doit se situer dans les limites prescrites par [SWS_CRYPT_50178] (GetMinimumChunkSize) et [SWS_CRYPT_50091] (GetMaximumChunkSize).
La capacité maximale requise du tampon de sortie out peut être calculée au préalable via GetRequiredOutputBufferSize avec le paramètre isFinal = true ([SWS_CRYPT_50177]).
Tous les cas d'erreur possèdent une sémantique de rollback ([SWS_CRYPT_50090]). Les erreurs définies issues de ara::crypto::CryptoErrc comprennent :
kUninitializedContext : le contexte n'a pas été initialisé par la mise à disposition d'une clé ([SWS_CRYPT_50090]).
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : ef643cd9b744Provenance
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode Finish finalise l'opération de chiffrement asymétrique dans le contexte de ara::crypto::cryp::EncryptorPublicCtx[SWS_CRYPT_50088]. L'appel s'effectue de manière synchrone et est spécifié comme noexcept, exception-safe ainsi que thread-safe. En tant que paramètre, la fonction reçoit via in (ReadOnlyMemRegion) le fragment de texte en clair final et écrit les données chiffrées résultantes dans le tampon de sortie out (ReadWriteMemRegion). La taille de tampon requise pour out peut être déterminée au préalable via GetRequiredOutputBufferSize(). La valeur de retour ara::core::Result<std::size_t> fournit en cas de succès le nombre d'octets effectivement écrits, qui peut être inférieur à la capacité totale du tampon de sortie [SWS_CRYPT_50088].
Gestion des erreurs et concurrence
Tous les cas d'erreur possèdent une sémantique de rollback, de sorte que l'état du contexte reste cohérent en cas d'échec [SWS_CRYPT_50088]. La méthode signale les codes d'erreur spécifiques suivants issus de ara::crypto::CryptoErrc :
kProcessingNotStarted : le traitement des données n'a pas été préalablement initié par l'appel de Start().
kInsufficientCapacity : le tampon de sortie fourni out est dimensionné trop petit.
kInvalidInputSize : la taille de tampon de in ne peut pas être traitée par le contexte.
kInvalidArgument : les données d'entrée transmises contiennent des valeurs non valides.
kUnsupported : le traitement de flux n'est pas pris en charge par le contexte concret.
Interaction
La finalisation conclut la séquence de traitement cryptographique [SWS_CRYPT_50088]. DecryptorPrivateCtx::Finish[SWS_CRYPT_50068] fait office de contrepartie complémentaire pour le déchiffrement, tandis que dans le domaine du chiffrement symétrique, SymmetricCipherCtx::Finish[SWS_CRYPT_50045] fournit un modèle de déroulement comparable.
Ce texte a été généré par un procédé d'IA sur la base de la spécification.
Configure the context to use the key stored in the provided KeySlot at the time the encryption is started.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : e68fdee554baProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation et contexte d'appel
La méthode purement virtuelle SetKey de l'interface ara::crypto::cryp::EncryptorPublicCtx (fichier d'en-tête ara/crypto/cryp/encryptor_public_ctx.h) sert à l'assignation d'une clé pour des opérations de chiffrement asymétrique [SWS_CRYPT_50086]. En tant que paramètre, un smart pointer keySlot de type KeySlot::Sptr est transmis, qui doit contenir un PublicKey[SWS_CRYPT_50086]. L'appel a lieu de manière synchrone et signale le succès via un ara::core::Result<void> vide. Il est essentiel pour la sémantique que la clé stockée dans le slot ne soit consultée qu'au moment où le chiffrement est démarré [SWS_CRYPT_50086]. (Interprétation : étant donné que la résolution de la clé n'intervient qu'avec le démarrage effectif du chiffrement, des mises à jour du contenu du slot avant cet instant de démarrage devraient encore être effectives.) Question Q-25c5d462aafde8a1 (ouverte)
Gestion des erreurs
Si la configuration échoue, un code d'erreur avec sémantique de rollback est renvoyé dans l'objet Result [SWS_CRYPT_50086] :
ara::crypto::CryptoErrc::kIncompatibleObject : Est signalé lorsque le keySlot fourni est incompatible avec ce contexte [SWS_CRYPT_50086].
ara::crypto::CryptoErrc::kUnsupported : survient lorsque l'implémentation concrète du contexte prend exclusivement en charge la définition directe d'un PublicKey et n'autorise aucune liaison de clé via un KeySlot[SWS_CRYPT_50086].
Concurrence et interaction
L'opération est déclarée comme noexcept, spécifiée comme sûre vis-à-vis des exceptions (exception safe) et sûre vis-à-vis des threads (thread-safe) pour une utilisation concurrente [SWS_CRYPT_50086].
Le concept de référencement indirect de clé via KeySlot se retrouve de manière comparable dans d'autres contextes asymétriques, tels que VerifierPublicCtx::SetKey[SWS_CRYPT_50018] et KeyEncapsulatorPublicCtx::SetKey[SWS_CRYPT_50012]. Il se distingue des méthodes qui acceptent directement des objets clés, comme par exemple dans [SWS_CRYPT_24115] ou [SWS_CRYPT_21815].
Cette note d'utilisation a été générée par une IA sur la base de la spécification AUTOSAR.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 09de2ed1c4fcProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode virtuelle SetKey de la classe ara::crypto::cryp::EncryptorPublicCtx configure le contexte pour l'utilisation d'une clé publique fournie [SWS_CRYPT_50175].\nL'objet clé à utiliser pour le chiffrement est transmis via le paramètre key (de type PublicKey::Sptr) [SWS_CRYPT_50175].\nL'exécution s'effectue de manière synchrone et renvoie un ara::core::Result<void> qui, en cas de succès, ne contient aucune valeur [SWS_CRYPT_50175].
Gestion des erreurs
Si une erreur survient lors de la configuration, un code d'erreur correspondant est signalé avec une sémantique de rollback définie [SWS_CRYPT_50175] :
ara::crypto::CryptoErrc::kUsageViolation : l'utilisation autorisée de la clé ne permet pas le chiffrement de données (kAllowDataEncryption) [SWS_CRYPT_50175].
ara::crypto::CryptoErrc::kIncompatibleObject : l'objet clé transmis est incompatible avec ce contexte de chiffrement [SWS_CRYPT_50175].
ara::crypto::CryptoErrc::kUnsupported : l'implémentation concrète du contexte prend exclusivement en charge la liaison via un KeySlot[SWS_CRYPT_50175].
Concurrence et restrictions
L'interface est définie comme noexcept et spécifie un comportement à la fois thread-safe et exception safe[SWS_CRYPT_50175].\nGrâce à la sémantique de rollback, le contexte reste dans son état précédent en cas d'erreur.\nInterprétation : un appel réussi devrait être une précondition obligatoire pour les opérations de chiffrement ultérieures, car le contexte ne peut effectuer aucune opération sans clé assignée.
Question Q-ab4779cac18793fa (ouverte)
Interaction
Cette approche suit le modèle des contextes asymétriques à l'échelle du module, tel qu'il est également utilisé dans VerifierPublicCtx::SetKey[SWS_CRYPT_24115] et KeyEncapsulatorPublicCtx::SetKey[SWS_CRYPT_21815] pour la liaison de clés.\nEn alternative, des interfaces apparentées prévoient également pour la configuration des variantes KeySlot, comme par exemple dans VerifierPublicCtx[SWS_CRYPT_50018] ou KeyEncapsulatorPublicCtx[SWS_CRYPT_50012].
Ce texte a été généré par un système d'IA sur la base de la spécification AUTOSAR R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 50b972147b28ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation et sémantique
La méthode purement virtuelle Start de la classe ara::crypto::cryp::EncryptorPublicCtx sert à initialiser le contexte pour un nouveau chiffrement [SWS_CRYPT_50087]. Elle ne prend aucun paramètre d'entrée et s'exécute de manière synchrone. En valeur de retour, la fonction fournit un ara::core::Result<void> qui confirme soit le succès de l'initialisation, soit transporte un code d'erreur survenu [SWS_CRYPT_50087].
Traitement des erreurs et comportement de rollback
Si les préconditions requises pour l'opération de chiffrement ne sont pas remplies, l'appel échoue. La spécification garantit une sémantique de rollback en cas d'erreur et définit les causes d'erreur suivantes [SWS_CRYPT_50087] :
UninitializedContext : aucune clé n'a été préalablement assignée au contexte.
ara::crypto::CryptoErrc::kEmptyKeySlot : un KeySlot configuré est actuellement inoccupé.
ara::crypto::CryptoErrc::kUsageViolation : les autorisations de la clé ne contiennent pas le drapeau d'utilisation kAllowDataEncryption.
ara::crypto::CryptoErrc::kIncompatibleObject : le type de clé assigné est incompatible avec la transformation requise.
ara::crypto::CryptoErrc::kBusyResource : une ressource nécessaire à l'initialisation est occupée.
ara::crypto::CryptoErrc::kUnsupported : le traitement de flux n'est pas pris en charge par le contexte concret.
Concurrence et interaction
La méthode est spécifiée comme thread-safe et exception safe[SWS_CRYPT_50087]. La mise à disposition d'une clé appropriée dans le contexte est une condition préalable obligatoire au succès. Sur le plan conceptuel, la fonction s'intègre dans des cycles de vie standardisés de contextes cryptographiques au sein desquels les opérations sont préparées au moyen d'appels sans paramètres – comparable aux vérifications de signature [SWS_CRYPT_50019], aux générations de signature [SWS_CRYPT_50037] ou aux calculs de MAC [SWS_CRYPT_22111]. L'appel devrait constituer le point de départ obligatoire avant l'exécution proprement dite d'un chiffrement de flux. Question Q-db262c3914e6b4cf (ouverte)
Cette note d'utilisation a été générée automatiquement sur la base de la spécification AUTOSAR R25-11.
GÉNÉRÉ PAR IAnon vérifiéModèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 01cf25c1d489ProvenanceQuestions ouvertes (1)
traduit du guide allemandgemini-3.8-flash-low · 2026-10-13 · Original allemand
Utilisation
La méthode synchrone Update de la classe ara::crypto::cryp::EncryptorPublicCtx sert au chiffrement pas à pas de blocs de données d'un texte clair [SWS_CRYPT_50176]. Une partie du texte clair est transmise via le paramètre in (ReadOnlyMemRegion), tandis que les données chiffrées sont écrites dans le tampon de sortie out (ReadWriteMemRegion) [SWS_CRYPT_50176]. En tant que valeur de retour, la fonction fournit via ara::core::Result<std::size_t> le nombre réel d'octets écrits, qui peut être inférieur à la capacité fournie de out[SWS_CRYPT_50176].
Déroulement et interaction
Avant le premier appel de Update, le traitement des données doit obligatoirement avoir été initié par Start()[SWS_CRYPT_50176]. La taille d'entrée maximale autorisée pour des appels individuels peut être interrogée via la méthode GetMaximumChunkSize()[SWS_CRYPT_50091]. La taille minimale requise pour out peut en outre être calculée via GetRequiredOutputBufferSize()[SWS_CRYPT_50176].
Gestion des erreurs et concurrence
Si une erreur survient pendant l'exécution, elle est signalée avec une sémantique de rollback [SWS_CRYPT_50176] :
ara::crypto::CryptoErrc::kProcessingNotStarted : le traitement des données n'a pas été préalablement commencé avec Start()[SWS_CRYPT_50176].
ara::crypto::CryptoErrc::kInsufficientCapacity : la capacité du tampon out ne suffit pas pour le résultat [SWS_CRYPT_50176].
ara::crypto::CryptoErrc::kInvalidInputSize : la taille de tampon de in n'est pas valide [SWS_CRYPT_50176].
ara::crypto::CryptoErrc::kUnsupported : le traitement de flux n'est pas pris en charge par le contexte actuel [SWS_CRYPT_50176].
La méthode est déclarée comme sûre vis-à-vis des exceptions et sûre vis-à-vis des threads [SWS_CRYPT_50176]. Néanmoins, l'appel parallèle de plusieurs opérations sur le même objet de contexte nécessiterait sans doute une synchronisation externe pour garantir un ordre déterministe des fragments de données chiffrées. Question Q-b22ffe505b583b25 (ouverte)
Ce texte a été créé par une IA et sert de guide d'orientation. La spécification fait foi.
an input data buffer containing a part of the plaintext
Parameter (out)
Parameter
Beschreibung
out
an output data buffer that the encrypted data will be written into. The required size of this buffer can be queried using GetRequired OutputBufferSize()
gemini-3.8-flash-low· 2026-10-13 · Original allemand