Verschlüsselt Daten asymmetrisch im Einzelschritt oder über eine mehrteilige Streaming-Operation.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 9ba841f18186HerkunftOffene Fragen (2)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verschlüsselt Daten asymmetrisch im Einzelschritt oder über eine mehrteilige Streaming-Operation.
Die Schnittstelle dient der asymmetrischen Verschlüsselung von Klartextdaten auf der AUTOSAR Adaptive Platform und wird über den bereitgestellten Smart-Pointer verwaltet [SWS_CRYPT_50174]. Nach der Zuweisung eines passenden öffentlichen Schlüssels können Nachrichten entweder kompakt in einem einzigen Durchlauf oder fortlaufend über eine mehrteilige Streaming-Sitzung transformiert werden [SWS_CRYPT_50090]. Für eine korrekte Abwicklung müssen die Puffergrößen vorab berechnet werden, wobei alle Operationen des Kontextes als ausnahmesicher und threadsicher spezifiziert sind.
Kontext
Die C++-Klasse ara::crypto::cryp::EncryptorPublicCtx stellt die standardisierte Schnittstelle für die asymmetrische Datenverschlüsselung in der AUTOSAR Adaptive Platform bereit. Sie dient Client-Anwendungen zur Chiffrierung von Klartextdaten mithilfe eines asymmetrischen öffentlichen Schlüssels. Die Konfiguration des kryptografischen Schlüssels kann dabei entweder direkt über ein Schlüsselobjekt ([SWS_CRYPT_50175]) oder über einen Verweis auf einen Schlüsselspeicherplatz (KeySlot, [SWS_CRYPT_50086]) erfolgen. Die Datenübergabe erfolgt über speichereffiziente Pufferbereiche (ReadOnlyMemRegion für Klartextdaten und ReadWriteMemRegion für die Chiffratausgabe).
Lebenszyklus
Instanzen des Kontexts werden über den im Typalias Sptr definierten Shared-Pointer std::shared_ptr<EncryptorPublicCtx> verwaltet ([SWS_CRYPT_50174]). Die Erzeugung selbst ist nicht Teil dieser Schnittstellendefinition; vermutlich erfolgt die Instanziierung über eine übergeordnete Factory-Komponente der Crypto-Architektur. Frage Q-5b7490ba113bb861 (offen) Das Objekt durchläuft während seiner Lebensdauer klar definierte Zustände:
Nicht initialisiert: Nach der Instanziierung besitzt der Kontext noch keinen Schlüssel. Operationen zur Datenverarbeitung sind in diesem Zustand nicht zulässig.
Konfiguriert (Bereit): Durch den Aufruf von SetKey() mit einem PublicKey ([SWS_CRYPT_50175]) oder einem KeySlot ([SWS_CRYPT_50086]) wird der Kontext einsatzbereit. Aus diesem Zustand heraus kann entweder eine Einzelschritt-Verschlüsselung ausgeführt oder eine Streaming-Sitzung gestartet werden.
Streaming aktiv: Der Aufruf von Start() ([SWS_CRYPT_50087]) versetzt den Kontext in den Streaming-Zustand. Fortlaufende Datenblöcke werden über Update() ([SWS_CRYPT_50176]) verarbeitet. Die Sitzung wird entweder mit Finish() ([SWS_CRYPT_50088]) abgeschlossen oder mit Cancel() ([SWS_CRYPT_50089]) abgebrochen, wodurch der Kontext wieder in den Zustand Konfiguriert zurückkehrt.
Sämtliche Methoden der Klasse sind als ausnahmesicher (exception safe) und threadsicher (thread-safe) spezifiziert. Wird der Kontext zerstört, während eine Streaming-Operation noch nicht beendet wurde, dürfte die zugrundeliegende Implementierung allozierte Puffer bereinigen und die Sitzung implizit verwerfen. Frage Q-3eadc946a0bdbdfd (offen)
Die Klasse unterstützt zwei Verarbeitungsmodi: die Einzelschritt-Verarbeitung für vollständige Datensätze und das mehrschrittige Streaming für segmentierte Datenströme. Vor der Durchführung von Verschlüsselungen müssen Anwendungen die Puffergrenzen berücksichtigen:
Über GetMinimumChunkSize()` (<a class="spec-record-ref" data-req="SWS_CRYPT_50178">[SWS_CRYPT_50178]</a>) und <code>GetMaximumChunkSize() ([SWS_CRYPT_50091]) lassen sich die minimal und maximal unterstützten Eingabegrößen für einzelne Aufrufe ermitteln.
Die notwendige Kapazität des Ausgabepuffers muss vorab mit GetRequiredOutputBufferSize() ([SWS_CRYPT_50177]) abgefragt werden. Der Parameter isFinal steuert hierbei, ob die Berechnung für Zwischenschritte (false) oder finale Aufrufe bzw. Einzelschritte (true) erfolgt.
Der typische Ablauf einer Streaming-Verschlüsselung gliedert sich in folgende Schritte:
Schlüsselzuweisung über SetKey() mit einem gültigen PublicKey ([SWS_CRYPT_50175]).
Initialisierung der Streaming-Sitzung durch Aufruf von Start() ([SWS_CRYPT_50087]).
Berechnung der erforderlichen Ausgabepuffergröße für Zwischenblöcke mit GetRequiredOutputBufferSize(inputSize, false) ([SWS_CRYPT_50177]).
Wiederholte Transformation von Datenblöcken über Update() ([SWS_CRYPT_50176]).
Ermittlung der Puffergröße für den letzten Block (isFinal = true) und Finalisierung der Operation über Finish() ([SWS_CRYPT_50088]).
Für kompakte Daten, die in einem Durchlauf verarbeitet werden können, bietet Encrypt() ([SWS_CRYPT_50090]) einen direkten Einzelschritt-Aufruf ohne Aufteilung in Start-, Update- und Finish-Phasen.
Alle Methoden nutzen ara::core::Result zur Fehlersignalisierung und garantieren Rollback-Semantik im Fehlerfall:
Zustandsfehler: Ein Aufruf von Start(), Encrypt() oder GetRequiredOutputBufferSize() an einem nicht initialisierten Kontext führt zu ara::crypto::CryptoErrc::kUninitializedContext ([SWS_CRYPT_50087], [SWS_CRYPT_50090], [SWS_CRYPT_50177]). Werden Update(), Finish() oder Cancel() aufgerufen, ohne dass zuvor Start() ausgeführt wurde, schlägt die Operation mit ara::crypto::CryptoErrc::kProcessingNotStarted fehl ([SWS_CRYPT_50176], [SWS_CRYPT_50088], [SWS_CRYPT_50089]).
Puffer- und Datenfehler: Ist der übergebene Ausgabepuffer zu klein bemessen, antworten Encrypt(), Update() und Finish() mit ara::crypto::CryptoErrc::kInsufficientCapacity ([SWS_CRYPT_50090], [SWS_CRYPT_50176], [SWS_CRYPT_50088]). Abweichungen von den zulässigen Chunk-Größen führen zu ara::crypto::CryptoErrc::kInvalidInputSize, ungültige Eingabedaten zu ara::crypto::CryptoErrc::kInvalidArgument.
Nicht unterstützte Funktionen und Ressourcenengpässe: Unterstützt die Implementierung kein Streaming oder keinen Einzelschritt-Aufruf, schlägt die Operation mit ara::crypto::CryptoErrc::kUnsupported fehl ([SWS_CRYPT_50087], [SWS_CRYPT_50090], [SWS_CRYPT_50176], [SWS_CRYPT_50088]). Bei blockierten kryptografischen Ressourcen wird ara::crypto::CryptoErrc::kBusyResource zurückgegeben ([SWS_CRYPT_50087], [SWS_CRYPT_50090]).
Dieser Leitfaden basiert auf den Anforderungen der AUTOSAR Adaptive Platform Release R25-11 und fasst die Spezifikation der Klasse ara::crypto::cryp::EncryptorPublicCtx zusammen.
Cancel the ongoing streaming operation that has been initiated by Start() and has not yet been finished.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: c2111af75063HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die Methode Cancel() bricht eine aktive Streaming-Operation im Kontext ara::crypto::cryp::EncryptorPublicCtx ab, welche zuvor mittels Start() initiiert und noch nicht beendet wurde [SWS_CRYPT_50089]. Sie nimmt keine Übergabeparameter entgegen und gibt ein ara::core::Result<void> zurück, welches im Erfolgsfall leer ist [SWS_CRYPT_50089]. Da die Signatur unmittelbar ein Result und kein Future liefert, dürfte der Abbruch synchron ausgeführt werden. Frage Q-cd18e56d693fe1a4 (offen)
Fehlerbehandlung und Nebenläufigkeit
Wurde die Datenverarbeitung nicht vorab durch Start() gestartet, schlägt die Operation mit dem Fehlercode ara::crypto::CryptoErrc::kProcessingNotStarted unter Einhaltung von Rollback-Semantik fehl [SWS_CRYPT_50089]. Gemäß Spezifikation ist die Schnittstelle mit noexcept deklariert, ausnahmesicher (exception safe) und für den nebenläufigen Zugriff als threadsicher (thread-safe) eingestuft [SWS_CRYPT_50089].
Zusammenspiel im Krypto-Stack
Das durch Cancel() realisierte Abbruchverhalten folgt einem einheitlichen Entwurfsmuster für zustandsbehaftete Streaming-Operationen im Krypto-Modul. Analoge Schnittstellen mit identischer Fehlersemantik existieren für:
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 523fe4336ba2Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Die synchrone Methode Encrypt dient der Verschlüsselung von Klartextdaten in einem einzelnen Aufruf ([SWS_CRYPT_50090]). Sie übernimmt die Eingabedaten aus dem Puffer in (ReadOnlyMemRegion) und schreibt das Chiffrat in den Ausgabepuffer out (ReadWriteMemRegion) ([SWS_CRYPT_50090]). Der Rückgabewert ara::core::Result<std::size_t> liefert im Erfolgsfall die Größe der tatsächlich geschriebenen Ausgabedaten, welche kleiner als die Gesamtkapazität von out sein kann ([SWS_CRYPT_50090]).
Hinsichtlich der Nebenläufigkeit ist die Funktion als threadsicher (thread-safe) sowie ausnahmesicher (exception safe) spezifiziert ([SWS_CRYPT_50090]).
Im Zusammenspiel mit dem Kontext EncryptorPublicCtx müssen vor dem Aufruf folgende Puffergrenzen beachtet werden:
Die Eingabegröße muss innerhalb der von [SWS_CRYPT_50178] (GetMinimumChunkSize) und [SWS_CRYPT_50091] (GetMaximumChunkSize) vorgegebenen Limits liegen.
Die maximal erforderliche Kapazität des Ausgabepuffers out lässt sich vorab über GetRequiredOutputBufferSize mit dem Parameter isFinal = true berechnen ([SWS_CRYPT_50177]).
Alle Fehlerfälle besitzen Rollback-Semantik ([SWS_CRYPT_50090]). Zu den definierten Fehlern aus ara::crypto::CryptoErrc gehören:
kUninitializedContext: Der Kontext wurde nicht durch Bereitstellen eines Schlüssels initialisiert ([SWS_CRYPT_50090]).
kEmptyKeySlot: Ein konfigurierter KeySlot ist leer ([SWS_CRYPT_50090]).
kIncompatibleObject: Der Schlüsseltyp passt nicht zur Transformation ([SWS_CRYPT_50090]).
kUsageViolation: Die Schlüsselverwendung erlaubt keine Datenverschlüsselung (kAllowDataEncryption) ([SWS_CRYPT_50090]).
kInsufficientCapacity: Der Puffer out ist zu klein ([SWS_CRYPT_50090]).
kInvalidInputSize oder kInvalidArgument: Die Eingabegröße ist nicht verarbeitbar oder die Eingabedaten sind ungültig ([SWS_CRYPT_50090]).
kUnsupported: Single-Call-Verschlüsselung wird nicht unterstützt ([SWS_CRYPT_50090]).
kBusyResource: Eine benötigte Ressource ist belegt ([SWS_CRYPT_50090]).
Dieser Nutzungshinweis wurde von einer KI auf Basis der AUTOSAR-Spezifikation generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: ef643cd9b744Herkunft
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die Methode Finish schließt den asymmetrischen Verschlüsselungsvorgang im Kontext von ara::crypto::cryp::EncryptorPublicCtx ab [SWS_CRYPT_50088]. Der Aufruf erfolgt synchron und ist als noexcept, exception-safe sowie thread-safe spezifiziert. Als Parameter übernimmt die Funktion über in (ReadOnlyMemRegion) das abschließende Klartextfragment und schreibt die resultierenden Chiffratdaten in den Ausgabepuffer out (ReadWriteMemRegion). Die erforderliche Puffergröße für out kann vorab über GetRequiredOutputBufferSize() ermittelt werden. Der Rückgabewert ara::core::Result<std::size_t> liefert im Erfolgsfall die tatsächlich geschriebene Bytezahl, welche kleiner als die Gesamtkapazität des Ausgabepuffers ausfallen kann [SWS_CRYPT_50088].
Fehlerbehandlung und Nebenläufigkeit
Alle Fehlerfälle besitzen Rollback-Semantik, sodass der Kontextzustand bei einem Scheitern konsistent bleibt [SWS_CRYPT_50088]. Die Methode meldet folgende spezifische Fehlercodes aus ara::crypto::CryptoErrc:
kProcessingNotStarted: Die Datenverarbeitung wurde zuvor nicht durch den Aufruf von Start() initiiert.
kInsufficientCapacity: Der bereitgestellte Ausgabepuffer out ist zu klein bemessen.
kInvalidInputSize: Die Puffergröße von in kann vom Kontext nicht verarbeitet werden.
kInvalidArgument: Die übergebenen Eingabedaten enthalten ungültige Werte.
kUnsupported: Die Stream-Verarbeitung wird durch den konkreten Kontext nicht unterstützt.
Zusammenspiel
Die Finalisierung schließt den kryptographischen Verarbeitungsablauf ab [SWS_CRYPT_50088]. Als komplementäres Gegenstück für die Entschlüsselung fungiert DecryptorPrivateCtx::Finish[SWS_CRYPT_50068], während im Bereich der symmetrischen Chiffrierung SymmetricCipherCtx::Finish[SWS_CRYPT_50045] ein vergleichbares Ablaufmuster bereitstellt.
Dieser Text wurde durch ein KI-Verfahren auf Basis der Spezifikation generiert.
Configure the context to use the key stored in the provided KeySlot at the time the encryption is started.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: e68fdee554baHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung und Aufrufkontext
Die rein virtuelle Methode SetKey der Schnittstelle ara::crypto::cryp::EncryptorPublicCtx (Header-Datei ara/crypto/cryp/encryptor_public_ctx.h) dient der Zuweisung eines Schlüssels für asymmetrische Chiffrieroperationen [SWS_CRYPT_50086]. Als Parameter wird ein Smart-Pointer keySlot vom Typ KeySlot::Sptr übergeben, der einen PublicKey enthalten muss [SWS_CRYPT_50086]. Der Aufruf erfolgt synchron und signalisiert den Erfolg über ein leeres ara::core::Result<void>. Wesentlich für die Semantik ist, dass der im Slot gespeicherte Schlüssel erst zu dem Zeitpunkt herangezogen wird, an dem die Verschlüsselung gestartet wird [SWS_CRYPT_50086]. (Interpretation: Da die Schlüsselauflösung erst mit dem eigentlichen Verschlüsselungsstart erfolgt, dürften Aktualisierungen des Slot-Inhalts vor diesem Startzeitpunkt noch wirksam werden.) Frage Q-25c5d462aafde8a1 (offen)
Fehlerbehandlung
Schlägt die Konfiguration fehl, wird ein Fehlercode mit Rollback-Semantik im Result-Objekt zurückgeliefert [SWS_CRYPT_50086]:
ara::crypto::CryptoErrc::kIncompatibleObject: Wird gemeldet, wenn der bereitgestellte keySlot mit diesem Kontext inkompatibel ist [SWS_CRYPT_50086].
ara::crypto::CryptoErrc::kUnsupported: Tritt auf, wenn die konkrete Kontext-Implementierung ausschließlich das direkte Setzen eines PublicKey unterstützt und keine Schlüsselbindung über einen KeySlot erlaubt [SWS_CRYPT_50086].
Nebenläufigkeit und Zusammenspiel
Die Operation ist als noexcept deklariert, ausnahmesicher (exception safe) und für den nebenläufigen Einsatz als threadsicher (thread-safe) spezifiziert [SWS_CRYPT_50086].
Das Konzept der indirekten Schlüsselreferenzierung via KeySlot findet sich in vergleichbarer Weise auch bei anderen asymmetrischen Kontexten, wie etwa VerifierPublicCtx::SetKey[SWS_CRYPT_50018] und KeyEncapsulatorPublicCtx::SetKey[SWS_CRYPT_50012]. Es grenzt sich von Methoden ab, die Schlüsselobjekte direkt entgegennehmen, wie beispielsweise in [SWS_CRYPT_24115] oder [SWS_CRYPT_21815].
Dieser Nutzungshinweis wurde von einer KI auf Basis der AUTOSAR-Spezifikation generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 09de2ed1c4fcHerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die virtuelle Methode SetKey der Klasse ara::crypto::cryp::EncryptorPublicCtx konfiguriert den Kontext für die Verwendung eines bereitgestellten öffentlichen Schlüssels [SWS_CRYPT_50175].
Über den Parameter key (vom Typ PublicKey::Sptr) wird das für die Verschlüsselung zu nutzende Schlüsselobjekt übergeben [SWS_CRYPT_50175].
Die Ausführung erfolgt synchron und liefert ein ara::core::Result<void> zurück, welches im Erfolgsfall keinen Wert enthält [SWS_CRYPT_50175].
Fehlerbehandlung
Tritt bei der Konfiguration ein Fehler auf, wird ein entsprechender Fehlercode mit definierter Rollback-Semantik gemeldet [SWS_CRYPT_50175]:
ara::crypto::CryptoErrc::kUsageViolation: Die zulässige Verwendung des Schlüssels gestattet keine Datenverschlüsselung (kAllowDataEncryption) [SWS_CRYPT_50175].
ara::crypto::CryptoErrc::kIncompatibleObject: Das übergebene Schlüsselobjekt ist mit diesem Verschlüsselungskontext inkompatibel [SWS_CRYPT_50175].
ara::crypto::CryptoErrc::kUnsupported: Die konkrete Kontext-Implementierung unterstützt ausschließlich die Bindung über einen KeySlot[SWS_CRYPT_50175].
Nebenläufigkeit und Einschränkungen
Die Schnittstelle ist als noexcept definiert und spezifiziert ein Verhalten, das sowohl thread-safe als auch exception safe ist [SWS_CRYPT_50175].
Dank der Rollback-Semantik verbleibt der Kontext im Fehlerfall in seinem vorherigen Zustand.
Interpretation: Ein erfolgreicher Aufruf dürfte eine zwingende Voraussetzung für anschließende Verschlüsselungsoperationen sein, da der Kontext ohne zugewiesenen Schlüssel keine Operationen durchführen kann. Frage Q-ab4779cac18793fa (offen)
Zusammenspiel
Dieses Vorgehen folgt dem modulweiten Muster asymmetrischer Kontexte, wie es auch bei VerifierPublicCtx::SetKey[SWS_CRYPT_24115] und KeyEncapsulatorPublicCtx::SetKey[SWS_CRYPT_21815] zur Schlüsselbindung genutzt wird.
Alternativ sehen verwandte Schnittstellen für die Konfiguration auch KeySlot-Varianten vor, wie etwa bei VerifierPublicCtx[SWS_CRYPT_50018] oder KeyEncapsulatorPublicCtx[SWS_CRYPT_50012].
Dieser Text wurde durch ein KI-System auf Basis der Spezifikation AUTOSAR R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 50b972147b28HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung und Semantik
Die rein virtuelle Methode Start der Klasse ara::crypto::cryp::EncryptorPublicCtx dient der Initialisierung des Kontexts für eine neue Verschlüsselung [SWS_CRYPT_50087]. Sie nimmt keine Übergabeparameter entgegen und wird synchron ausgeführt. Als Rückgabewert liefert die Funktion ein ara::core::Result<void>, das entweder die erfolgreiche Initialisierung bestätigt oder einen aufgetretenen Fehlercode transportiert [SWS_CRYPT_50087].
Fehlerbehandlung und Rollback-Verhalten
Sind die erforderlichen Vorbedingungen für den Verschlüsselungsvorgang nicht gegeben, schlägt der Aufruf fehl. Die Spezifikation sichert für Fehlerfälle eine Rollback-Semantik zu und definiert folgende Fehlerursachen [SWS_CRYPT_50087]:
UninitializedContext: Dem Kontext wurde vorab kein Schlüssel zugewiesen.
ara::crypto::CryptoErrc::kEmptyKeySlot: Ein konfigurierter KeySlot ist gegenwärtig unbelegt.
ara::crypto::CryptoErrc::kUsageViolation: Die Berechtigungen des Schlüssels enthalten nicht das Nutzungsflag kAllowDataEncryption.
ara::crypto::CryptoErrc::kIncompatibleObject: Der zugewiesene Schlüsseltyp ist mit der geforderten Transformation inkompatibel.
ara::crypto::CryptoErrc::kBusyResource: Eine zur Initialisierung benötigte Ressource ist belegt.
ara::crypto::CryptoErrc::kUnsupported: Die Stream-Verarbeitung wird durch den konkreten Kontext nicht unterstützt.
Nebenläufigkeit und Zusammenspiel
Die Methode ist als thread-safe und exception safe spezifiziert [SWS_CRYPT_50087]. Die Bereitstellung eines passenden Schlüssels im Kontext ist zwingende Voraussetzung für den Erfolg. Konzeptionell fügt sich die Funktion in standardisierte Lebenszyklen kryptografischer Kontexte ein, in denen Operationen über parameterlose Aufrufe vorbereitet werden – vergleichbar mit Signaturprüfungen [SWS_CRYPT_50019], Signaturerzeugungen [SWS_CRYPT_50037] oder MAC-Berechnungen [SWS_CRYPT_22111]. Der Aufruf dürfte den zwingenden Ausgangspunkt vor der eigentlichen Durchführung einer Stream-Verschlüsselung darstellen. Frage Q-db262c3914e6b4cf (offen)
Dieser Nutzungshinweis wurde automatisiert auf Basis der AUTOSAR-Spezifikation R25-11 generiert.
KI-GENERIERTungeprüftModell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 01cf25c1d489HerkunftOffene Fragen (1)
KI-generiertgemini-3.8-flash-medium · 2026-10-13
Verwendung
Die synchrone Methode Update der Klasse ara::crypto::cryp::EncryptorPublicCtx dient der schrittweisen Verschlüsselung von Datenblöcken eines Klartextes [SWS_CRYPT_50176]. Über den Parameter in (ReadOnlyMemRegion) wird ein Teil des Klartexts übergeben, während die verschlüsselten Daten in den Ausgabepuffer out (ReadWriteMemRegion) geschrieben werden [SWS_CRYPT_50176]. Als Rückgabewert liefert die Funktion über ara::core::Result<std::size_t> die tatsächliche Anzahl der geschriebenen Bytes, welche kleiner als die bereitgestellte Kapazität von out sein kann [SWS_CRYPT_50176].
Ablauf und Zusammenspiel
Vor dem ersten Aufruf von Update muss die Datenverarbeitung zwingend durch Start() initiiert worden sein [SWS_CRYPT_50176]. Die maximal zulässige Eingabegröße für einzelne Aufrufe lässt sich über die Methode GetMaximumChunkSize() abfragen [SWS_CRYPT_50091]. Die für out benötigte Mindestgröße kann zudem über GetRequiredOutputBufferSize() berechnet werden [SWS_CRYPT_50176].
Fehlerbehandlung und Nebenläufigkeit
Tritt während der Ausführung ein Fehler auf, wird dieser mit Rollback-Semantik gemeldet [SWS_CRYPT_50176]:
ara::crypto::CryptoErrc::kProcessingNotStarted: Die Datenverarbeitung wurde zuvor nicht mit Start() begonnen [SWS_CRYPT_50176].
ara::crypto::CryptoErrc::kInsufficientCapacity: Die Kapazität des Puffers out reicht für das Ergebnis nicht aus [SWS_CRYPT_50176].
ara::crypto::CryptoErrc::kInvalidInputSize: Die Puffergröße von in ist ungültig [SWS_CRYPT_50176].
ara::crypto::CryptoErrc::kUnsupported: Die Stream-Verarbeitung wird vom aktuellen Kontext nicht unterstützt [SWS_CRYPT_50176].
Die Methode ist als ausnahmesicher und threadsicher deklariert [SWS_CRYPT_50176]. Dennoch dürfte der parallele Aufruf mehrerer Operationen auf demselben Kontextobjekt vermutlich eine externe Synchronisation erfordern, um eine deterministische Reihenfolge der verschlüsselten Datenfragmente zu gewährleisten. Frage Q-b22ffe505b583b25 (offen)
Dieser Text wurde von einer KI erstellt und dient als Orientierungshilfe. Verbindlich ist die Spezifikation.
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-medium· 2026-10-13