class ara::crypto::cryp::MessageAuthnCodeCtx

Die reine virtuelle Methode Cancel dient im Interface ara::crypto::cryp::MessageAuthnCodeCtx dazu, eine laufende, zuvor mittels Start() initiierte und noch nicht abgeschlossene Streaming-Operation abzubrechen [SWS_CRYPT_50027]. Der Aufruf erfolgt synchron, nimmt keine Übergabeparameter entgegen und gibt im Erfolgsfall ein leeres ara::core::Result<void> zurück, welches den erfolgreichen Abbruch der Operation bestätigt [SWS_CRYPT_50027].

Wurde die Datenverarbeitung vor dem Aufruf nicht ordnungsgemäß durch die Methode Start() eingeleitet, schlägt die Ausführung fehl. In diesem Fall liefert die Funktion ein Resultat mit dem spezifischen Fehlercode ara::crypto::CryptoErrc::kProcessingNotStarted unter Gewährleistung einer Rollback-Semantik [SWS_CRYPT_50027]. Hinsichtlich der Ausführungssicherheit ist die Schnittstelle als threadsicher (thread-safe) spezifiziert und garantiert Ausnahmesicherheit (exception safe), da sie als noexcept deklariert ist und keine Ausnahmen wirft [SWS_CRYPT_50027].

Das identische Abbruchverhalten für noch nicht finalisierte Streaming-Verarbeitungen teilen alle verwandten Kontextschnittstellen des Kryptografie-Moduls:

• VerifierPublicCtx für die Prüfung digitaler Signaturen [SWS_CRYPT_50023],
• SignerPrivateCtx für das Erzeugen digitaler Signaturen [SWS_CRYPT_50041],
• SymmetricCipherCtx für symmetrische Chiffrierungen [SWS_CRYPT_50046],
• HashFunctionCtx für Hashwert-Berechnungen [SWS_CRYPT_50058],
• DecryptorPrivateCtx für asymmetrische Entschlüsselungen [SWS_CRYPT_50069],
• AuthCipherCtx für authentifizierte Verschlüsselungen [SWS_CRYPT_50077] sowie
• EncryptorPublicCtx für asymmetrische Verschlüsselungen [SWS_CRYPT_50089].

Interpretation: Durch den Abbruch der unvollendeten Operation dürfte der Kontext wieder in einen bereinigten Zustand überführt werden, der eine spätere Neuinitialisierung via Start() gestattet. Frage Q-a8fa5cb85c3dab50 (offen)

Verwendung

Die rein virtuelle Methode Compare der Klasse ara::crypto::cryp::MessageAuthnCodeCtx dient dazu, die Größe und den Inhalt eines berechneten Message Authentication Code (MAC) mit einem erwarteten Digest abzugleichen [SWS_CRYPT_50133]. Als Parameter wird der erwartete MAC-Digest über ReadOnlyMemRegion expected übergeben. Die Funktion liefert ein ara::core::Result<bool> zurück, welches true enthält, falls der berechnete MAC-Wert mit dem erwarteten Wert exakt übereinstimmt, und andernfalls false [SWS_CRYPT_50133].

Fehlerbehandlung

Im Fehlerfall wird ein Fehlercode im Ergebnisobjekt zurückgegeben, wobei eine Rollback-Semantik gilt [SWS_CRYPT_50133]:

• ara::crypto::CryptoErrc::kProcessingNotFinished: Wird gemeldet, wenn die Berechnung des Digests zuvor nicht durch den Aufruf der Methode Finish() abgeschlossen wurde [SWS_CRYPT_50133].
• ara::crypto::CryptoErrc::kInvalidInputSize: Tritt auf, wenn die übergebene Puffergröße des erwarteten MAC-Digests vom Kontext nicht unterstützt wird [SWS_CRYPT_50133].

Nebenläufigkeit und Einschränkungen

Die Methode ist als const sowie noexcept deklariert und spezifikationsgemäß threadsicher (thread-safe) sowie ausnahmesicher (exception safe) [SWS_CRYPT_50133]. Eine wesentliche Vorbedingung ist die zuvor erfolgreich vollendete Digest-Berechnung über Finish() [SWS_CRYPT_50133].

Zusammenspiel

In Abgrenzung zu Compare, das die vollständige Übereinstimmung des gesamten MAC-Digests validiert [SWS_CRYPT_50133], vergleicht CompareSubspan im selben Kontext lediglich die höchstwertigen Bits (most significant bits) mit dem erwarteten Wert [SWS_CRYPT_50028]. Für ungeschlüsselte Hashfunktionen existiert eine gleichnamige Compare-Funktion in ara::crypto::cryp::HashFunctionCtx [SWS_CRYPT_50154].

Die synchrone Methode CompareSubspan der Klasse ara::crypto::cryp::MessageAuthnCodeCtx gleicht die signifikantesten Bits (Most Significant Bits) eines berechneten MAC-Werts mit einer vorgegebenen Referenz ab [SWS_CRYPT_50028]. Der erwartete Vergleichswert wird über den Parameter expected als ReadOnlyMemRegion übergeben [SWS_CRYPT_50028]. Das Ergebnis wird als ara::core::Result<bool> zurückgegeben und enthält true bei Identität der höchstwertigen Bits sowie false bei Abweichungen [SWS_CRYPT_50028].

Fehlerbehandlung und Ablaufbedingungen

Für einen gültigen Vergleich muss die Berechnung des Prüfwerts abgeschlossen sein. Liegt kein vorheriger Aufruf der Methode Finish() vor, schlägt der Aufruf mit dem Fehlercode ara::crypto::CryptoErrc::kProcessingNotFinished fehl [SWS_CRYPT_50028]. Ist die Puffergröße des übergebenen Parameters expected für das verwendete Verfahren unzulässig, meldet die Methode ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_50028]. Beide Fehlerarten garantieren Rollback-Semantik [SWS_CRYPT_50028].

Nebenläufigkeit und Ausführungskontext

Die Operation ist als noexcept (exception-safe) spezifiziert und als thread-safe eingestuft [SWS_CRYPT_50028]. Interpretation: Die deklarierte Thread-Sicherheit dürfte sich auf den Zustand nach erfolgtem Finish() beziehen, sodass mehrere Threads denselben berechneten Digest parallel verifizieren können. Frage Q-ac8b7ead6a5b508e (offen)

Die Methode Finish() schließt die laufende Berechnung eines Message Authentication Code (MAC) innerhalb der Schnittstelle MessageAuthnCodeCtx verbindlich ab [SWS_CRYPT_22115]. Der Aufruf erfolgt synchron, nimmt keine Parameter entgegen und gibt ara::core::Result<void> zurück, was im regulären Erfolgsfall ein leeres Ergebnis darstellt [SWS_CRYPT_22115].

Im Fehlerfall liefert die Funktion den Fehlercode ara::crypto::CryptoErrc::kProcessingNotStarted, falls die MAC-Berechnung vor dem Aufruf nicht erfolgreich gestartet worden ist; dabei greift eine Rollback-Semantik [SWS_CRYPT_22115]. Die Operation ist als noexcept deklariert und gemäß Spezifikation sowohl ausnahmesicher (exception safe) als auch threadsicher (thread-safe) spezifiziert [SWS_CRYPT_22115].

Im Verarbeitungsablauf bildet Finish() das Bindeglied zwischen der Datenverarbeitung und der Auswertung: Nach dem Aufruf kann der erzeugte MAC-Digest über GetDigest() in einen bereitgestellten Puffer übertragen [SWS_CRYPT_22116] oder mit CompareSubspan() direkt gegen einen Referenzwert verifiziert werden [SWS_CRYPT_50028]. Während GetMaximumChunkSize() [SWS_CRYPT_50033] generisch Puffergrößen für Update() oder Finish() beschreibt, verarbeitet Finish() hier keine Daten direkt; die Nennung in der Anforderung dürfte vermutlich ein einheitliches Muster über alle Kryptokontexte widerspiegeln. Frage Q-79b4f4ecf3998e48 (offen)

Die synchrone Elementfunktion Generate der Klasse ara::crypto::cryp::MessageAuthnCodeCtx dient gemäß [SWS_CRYPT_50029] zur Berechnung eines Message Authentication Code (MAC) in einem Einzelschritt und schreibt den berechneten Digest in den bereitgestellten Ausgabepuffer.

Für den Aufruf werden folgende Parameter übergeben:

• data: Eingabedaten für die MAC-Berechnung als ReadOnlyMemRegion.
• digest: Zielspeicherbereich vom Typ ReadWriteMemRegion, in den der Digest geschrieben wird.
• iv: Ein optionaler Initialisierungsvektor als ara::core::Optional<ReadOnlyMemRegion>.

Im Erfolgsfall liefert die Funktion ein ara::core::Result<std::size_t> zurück, das die Größe des geschriebenen MAC-Digests in Bytes enthält [SWS_CRYPT_50029].

Tritt ein Fehler auf, wird ein Fehlercode mit Rollback-Semantik zurückgegeben [SWS_CRYPT_50029]:

• UninitializedContext: Der Kontext wurde noch nicht durch Zuweisung eines Schlüssels initialisiert.
• ara::crypto::CryptoErrc::kUsageViolation: Der verwendete Schlüssel besitzt nicht das erforderliche Nutzungsflag kAllowMac. Interpretation: Ein passender symmetrischer Schlüssel dürfte vorab über GenerateSymmetricKey erzeugt und konfiguriert werden [SWS_CRYPT_20721]. Frage Q-d22f397bbc02487b (offen)
• ara::crypto::CryptoErrc::kEmptyKeySlot: Ein konfigurierter KeySlot ist gegenwärtig leer.
• ara::crypto::CryptoErrc::kUnsupported: Die Single-Call-Verarbeitung wird nicht unterstützt oder die Angabe des Initialisierungsvektors entspricht nicht den Algorithmusanforderungen (fehlender oder unzulässig angegebener IV).
• ara::crypto::CryptoErrc::kInvalidInputSize: Die Puffergröße der Eingabedaten oder des IV wird nicht unterstützt.
• ara::crypto::CryptoErrc::kInsufficientCapacity: Der Zielpuffer digest ist zu klein für den MAC-Digest.
• ara::crypto::CryptoErrc::kBusyResource: Eine benötigte Systemressource ist belegt.

Bezüglich Nebenläufigkeit ist die Methode als thread-safe und exception safe spezifiziert [SWS_CRYPT_50029]. Sie ist als const noexcept deklariert und verändert bei der Ausführung den Zustand des Kontexts nicht.

Die Methode GenerateSubspan der Klasse ara::crypto::cryp::MessageAuthnCodeCtx berechnet in einem Einzelschritt einen Message Authentication Code (MAC) für die Eingangsdaten data und schreibt den Beginn (die höchstwertigen Bytes, MSB) des berechneten Digests in den Ausgabepuffer truncatedDigest [SWS_CRYPT_50030]. Über den optionalen Parameter iv kann bei Bedarf ein Initialisierungsvektor übergeben werden [SWS_CRYPT_50030]. Die direkte Rückgabe von ara::core::Result<std::size_t> dürfte auf eine synchrone Ausführung hinweisen; bei erfolgreichem Ablauf wird die Anzahl der geschriebenen Bytes des MAC-Digests zurückgegeben [SWS_CRYPT_50030]. Frage Q-167c6d44b9f39fed (offen)

Die Spezifikation definiert für den Fehlerfall eine Rollback-Semantik und sieht folgende Fehlercodes vor [SWS_CRYPT_50030]:

• UninitializedContext: Der Kontext wurde zuvor nicht durch Zuweisung eines Schlüssels initialisiert [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Ein konfigurierter KeySlot ist gegenwärtig leer [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kUsageViolation: Die erlaubte Verwendung des Schlüssels beinhaltet nicht kAllowMac [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kUnsupported: Die Einzelschritt-Verarbeitung wird nicht unterstützt, oder die IV-Konfiguration passt nicht zum Kontext (erforderliches IV fehlt oder unzulässiges IV übergeben) [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kInvalidInputSize: Die Größe der übergebenen Daten data oder des iv wird nicht unterstützt [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kBusyResource: Eine benötigte Ressource ist belegt [SWS_CRYPT_50030].

Hinsichtlich der Ausführungsumgebung ist die Methode als thread-safe spezifiziert und bietet Exception-Sicherheit (noexcept) [SWS_CRYPT_50030]. Voraussetzung für den fehlerfreien Aufruf ist die vorherige Bereitstellung eines Schlüssels mit entsprechender Berechtigung im Kontext [SWS_CRYPT_50030].

Die Methode SetKey konfiguriert eine Instanz von ara::crypto::cryp::MessageAuthnCodeCtx für die nachfolgende MAC-Berechnung mit einem bereitgestellten symmetrischen Schlüssel [SWS_CRYPT_22118]. Der Aufruf erfolgt synchron und nimmt das Schlüsselobjekt als Smart-Pointer SymmetricKey::Sptr entgegen. Als Ergebnis liefert die Funktion ein ara::core::Result<void> zurück, das im Erfolgsfall leer ist oder im Fehlerfall einen spezifischen Fehlercode kapselt [SWS_CRYPT_22118].

Schlägt die Zuweisung fehl, greift eine Rollback-Semantik, die den vorherigen Zustand des Kontexts bewahrt [SWS_CRYPT_22118]. Folgende Fehlerzustände aus ara::crypto::CryptoErrc sind spezifiziert:

• kUnsupported: Der Kontext unterstützt ausschließlich das Binden über einen KeySlot statt über direkte Schlüsselobjekte [SWS_CRYPT_22118].
• kIncompatibleObject: Das übergebene symmetrische Schlüsselobjekt ist mit dem Zielkontext inkompatibel [SWS_CRYPT_22118].
• kUsageViolation: Die Berechtigungsflags des Schlüssels enthalten nicht die zwingend erforderliche Nutzung kAllowMac [SWS_CRYPT_22118].

Hinsichtlich der Ausführungssicherheit ist die Schnittstelle als thread-safe und exception safe (mit noexcept) definiert [SWS_CRYPT_22118]. Im Zusammenspiel mit der Schlüsselverwaltung stellt sie das direkte Gegenstück zur slotbasierten Zuweisung dar: Unterstützt eine Implementierung oder ein Anwendungsfall die Verwendung persistierter Slots, wird stattdessen die Überladung für KeySlot::Sptr genutzt [SWS_CRYPT_50026].

Verwendung

Die virtuelle Elementfunktion SetKey des Interfaces ara::crypto::cryp::MessageAuthnCodeCtx aus der Header-Datei ara/crypto/cryp/message_authn_code_ctx.h konfiguriert den Kontext für die Berechnung oder Prüfung eines Message Authentication Code (MAC) [SWS_CRYPT_50026]. Als Parameter nimmt die synchrone Methode einen Smart-Pointer keySlot vom Typ KeySlot::Sptr entgegen, der einen symmetrischen Schlüssel bereithält, und gibt ein ara::core::Result<void> zurück [SWS_CRYPT_50026]. Die Bindung des Schlüssels ist semantisch verzögert: Der im Slot hinterlegte Schlüssel wird erst zu dem Zeitpunkt herangezogen, an dem die MAC-Berechnung tatsächlich gestartet wird [SWS_CRYPT_50026]. Interpretation: Nachträgliche Aktualisierungen des Slot-Inhalts bis zum Berechnungsstart dürften somit wirksam bleiben. Frage Q-d1886811d8af71e3 (offen)

Nebenläufigkeit und Ausführungssicherheit

Die Schnittstelle ist als noexcept definiert, gewährleistet Exception-Sicherheit (exception safe) und ist explizit für den nebenläufigen Aufruf spezifiziert (thread-safe) [SWS_CRYPT_50026].

Fehlerbehandlung und Zusammenspiel

Im Fehlerfall garantiert die Methode eine strikte Rollback-Semantik, sodass der vorherige Zustand des Kontexts vollständig erhalten bleibt [SWS_CRYPT_50026]. Folgende Fehlercodes können im Ergebnisobjekt auftreten:

• ara::crypto::CryptoErrc::kIncompatibleObject: Der übergebene KeySlot ist mit diesem symmetrischen Schlüsselkontext inkompatibel [SWS_CRYPT_50026].
• ara::crypto::CryptoErrc::kUnsupported: Die konkrete Implementierung des Kontexts unterstützt das Setzen via KeySlot nicht [SWS_CRYPT_50026]. In diesem Fall muss alternativ die Überladung SetKey(SymmetricKey::Sptr) zur direkten Übergabe eines Schlüssels verwendet werden [SWS_CRYPT_22118].

Die Methode Start von ara::crypto::cryp::MessageAuthnCodeCtx initialisiert den Kontext für eine neue MAC-Berechnung und setzt dabei einen Initialisierungsvektor oder Nonce-Wert über den Parameter iv ([SWS_CRYPT_22110]). Dies kommt beispielsweise bei Algorithmen wie GMAC zum Einsatz ([SWS_CRYPT_22110]). Für Berechnungen ohne expliziten Initialisierungsvektor steht alternativ die parameterlose Überladung Start() zur Verfügung ([SWS_CRYPT_22111]).

Verwendung und Nebenläufigkeit

Der Aufruf erfolgt synchron und ist als thread-safe sowie exception safe spezifiziert ([SWS_CRYPT_22110]). Nach erfolgreichem Aufruf können dem Kontext sukzessive Nachrichtenteile mittels Update übergeben werden ([SWS_CRYPT_22113]). Eine laufende, noch nicht abgeschlossene Streaming-Operation lässt sich bei Bedarf über Cancel abbrechen ([SWS_CRYPT_50027]).

Fehlerbehandlung

Die Methode gibt ein ara::core::Result<void> zurück, das im Fehlerfall Rollback-Semantik besitzt ([SWS_CRYPT_22110]). Mögliche Fehlerzustände sind:

• UninitializedContext: Dem Kontext wurde vorab kein Schlüssel zugewiesen ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kEmptyKeySlot: Ein konfigurierter KeySlot ist leer ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kUsageViolation: Die Berechtigungen des Schlüssels enthalten nicht kAllowMac ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kInvalidInputSize: Die übergebene IV-Größe wird nicht unterstützt ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kUnsupported: Streaming oder das Setzen eines IV wird vom Algorithmus bzw. Kontext nicht unterstützt ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kBusyResource: Eine benötigte Ressource ist belegt ([SWS_CRYPT_22110]).

Verwendung

Die Methode Start() initialisiert eine Instanz von ara::crypto::cryp::MessageAuthnCodeCtx für eine neue MAC-Berechnung [SWS_CRYPT_22111]. Der Aufruf nimmt keine Parameter entgegen und liefert ein ara::core::Result<void> zurück [SWS_CRYPT_22111]. Die Ausführung dürfte synchron erfolgen, da direkt ein Resultatobjekt bereitgestellt wird. Frage Q-1e6e36f4ed1176d3 (offen)

Fehlerbehandlung und Nebenläufigkeit

Tritt bei der Initialisierung ein Fehler auf, greift die Rollback-Semantik und es wird einer der folgenden Fehlercodes zurückgegeben [SWS_CRYPT_22111]:

• UninitializedContext: Dem Kontext wurde vorab kein Schlüssel zugewiesen [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kUnsupported: Der Kontext unterstützt kein Streaming oder der Algorithmus verlangt zwingend einen Initialisierungsvektor (IV) [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kBusyResource: Eine benötigte Ressource ist belegt [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Ein konfigurierter KeySlot ist leer [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kUsageViolation: Der Schlüssel erlaubt keine MAC-Berechnung ohne gesetztes kAllowMac [SWS_CRYPT_22111].

Die Funktion ist als threadsicher und ausnahmesicher (exception safe) spezifiziert [SWS_CRYPT_22111].

Zusammenspiel im Streaming-Ablauf

Verlangt der Algorithmus einen IV (z. B. GMAC), muss stattdessen die Überladung Start(ReadOnlyMemRegion iv) verwendet werden [SWS_CRYPT_22110]. Nach erfolgreichem Aufruf können Nachrichtendaten schrittweise über Update() übergeben werden [SWS_CRYPT_22113]. Eine noch nicht abgeschlossene Streaming-Operation lässt sich über Cancel() verwerfen [SWS_CRYPT_50027].

Verwendung

Die synchrone Methode Update des Kontexts ara::crypto::cryp::MessageAuthnCodeCtx dient dazu, die laufende Berechnung eines Message Authentication Code (MAC) um ein weiteres Fragment der Eingabenachricht zu ergänzen [SWS_CRYPT_22113]. Der zu verarbeitende Datenabschnitt wird dabei über den Parameter data in Form einer ReadOnlyMemRegion übergeben. Als Rückgabewert liefert die Funktion ein ara::core::Result<void>, das entweder den erfolgreichen Zwischenschritt bestätigt oder im Fehlerfall Aufschluss über die Fehlerursache gibt [SWS_CRYPT_22113].

Fehlerbehandlung und Nebenläufigkeit

Im Fehlerfall wird eine Rollback-Semantik garantiert, sodass der bisherige Berechnungszustand unverändert bleibt [SWS_CRYPT_22113]. Mögliche Fehlerursachen sind:

• ara::crypto::CryptoErrc::kProcessingNotStarted: Die Berechnung wurde vorab nicht durch den Aufruf der Methode Start() initiiert [SWS_CRYPT_22113].
• ara::crypto::CryptoErrc::kInvalidInputSize: Die Größe des übergebenen Datenblocks wird vom Kontext nicht unterstützt [SWS_CRYPT_22113].

Die Methode ist als noexcept deklariert sowie als threadsicher und ausnahmesicher (exception safe) spezifiziert [SWS_CRYPT_22113].

Zusammenspiel

Um Pufferfehler mit ara::crypto::CryptoErrc::kInvalidInputSize zu vermeiden, kann die maximal zulässige Eingabegröße für einzelne Aufrufe vorab über die Methode GetMaximumChunkSize() abgefragt werden [SWS_CRYPT_50033]. Nach dem sukzessiven Verarbeiten aller Nachrichtenteile dürfte die Berechnung des MAC-Tags der Interpretation nach typischerweise über die Methode Finish() abgeschlossen werden [SWS_CRYPT_50033]. Frage Q-7f8eaf8ebbf30d55 (offen)

Verwendung

Die Methode Verify in ara::crypto::cryp::MessageAuthnCodeCtx ([SWS_CRYPT_50031]) dient der synchronen Berechnung eines MAC-Digests über den Eingabepuffer data und dem direkten Vergleich mit dem erwarteten Wert expected. Optional kann über iv ein Initialisierungsvektor übergeben werden. Als Ergebnis liefert die Funktion ein ara::core::Result<bool>, welches true enthält, wenn der berechnete MAC mit der erwarteten Bytesequenz übereinstimmt, andernfalls false.

Fehlerbehandlung

Schlägt die Verifikation aus systemischen oder kryptografischen Gründen fehl, liefert die Methode ein ara::core::Result mit einem entsprechenden Fehlercode ([SWS_CRYPT_50031]):

• UninitializedContext: Wenn der Kontext nicht vorab durch Zuweisung eines Schlüssels initialisiert wurde.
• ara::crypto::CryptoErrc::kEmptyKeySlot: Wenn der konfigurierte KeySlot leer ist.
• ara::crypto::CryptoErrc::kUsageViolation: Wenn die erlaubte Nutzung des Schlüssels kAllowMac nicht umfasst.
• ara::crypto::CryptoErrc::kInvalidInputSize: Wenn die Puffergröße von data, expected oder iv unzulässig ist.
• ara::crypto::CryptoErrc::kUnsupported: Wenn die Single-Call-Ausführung nicht unterstützt wird oder die Bereitstellung des iv nicht den Erfordernissen des Algorithmus entspricht.
• ara::crypto::CryptoErrc::kBusyResource: Bei Ressourcenkonflikten.

Nebenläufigkeit und Zusammenspiel

Die Methode ist als thread-safe und exception safe spezifiziert ([SWS_CRYPT_50031]). Im Fehlerfall greift eine Rollback-Semantik. Im Unterschied zu asymmetrischen Signaturprüfungen in ara::crypto::cryp::VerifierPublicCtx ([SWS_CRYPT_24112], [SWS_CRYPT_50024]) operiert Verify auf symmetrischen MAC-Kontexten. Die maximal in einem Einzelaufruf verarbeitbare Puffergröße dürfte – analog zur Pufferabfrage bei Signaturprüfern ([SWS_CRYPT_50025]) – durch die Implementierung des Kontexts begrenzt sein. Frage Q-51e7427e4e082881 (offen)

Die Methode VerifySubspan der Klasse ara::crypto::cryp::MessageAuthnCodeCtx dient der synchronen Berechnung eines MAC-Digests und dem anschließenden Vergleich seiner signifikantesten Bits mit einer erwarteten Byte-Sequenz [SWS_CRYPT_50032]. Sie verarbeitet Eingabedaten über data, die erwarteten führenden Bits über expected sowie einen optionalen Initialisierungsvektor über iv [SWS_CRYPT_50032]. Das Ergebnis wird als ara::core::Result<bool> zurückgegeben und signalisiert bei erfolgreicher Übereinstimmung true, andernfalls false [SWS_CRYPT_50032].

Die Schnittstelle ist als noexcept spezifiziert, ist exception safe sowie thread-safe und wendet im Fehlerfall Rollback-Semantik an [SWS_CRYPT_50032]. Fehlgeschlagene Aufrufe liefern spezifische Fehlercodes im Rückgabewert [SWS_CRYPT_50032]:

• UninitializedContext: Der Kontext wurde zuvor nicht durch Zuweisen eines Schlüssels initialisiert [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kUsageViolation: Die zulässige Verwendung des Schlüssels umfasst nicht kAllowMac [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Ein konfigurierter KeySlot ist gegenwärtig leer [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kInvalidInputSize: Die Größe der übergebenen Daten, des erwarteten Prüfwerts oder des IV wird nicht unterstützt [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kUnsupported: Die Single-Call-Operation wird nicht unterstützt oder die Bereitstellung des IV widerspricht den Anforderungen des Kontexts [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kBusyResource: Eine benötigte Ressource ist belegt [SWS_CRYPT_50032].