klasse ara::crypto::cryp::MessageAuthnCodeCtx

De zuiver virtuele methode Cancel dient in de interface ara::crypto::cryp::MessageAuthnCodeCtx om een lopende, eerder middels Start() geïnitieerde en nog niet voltooide streamingoperatie af te breken [SWS_CRYPT_50027]. De aanroep verloopt synchroon, accepteert geen invoerparameters en retourneert bij succes een lege ara::core::Result<void>, die het succesvol afbreken van de operatie bevestigt [SWS_CRYPT_50027].

Als de gegevensverwerking voorafgaand aan de aanroep niet correct werd gestart door de methode Start(), mislukt de uitvoering. In dat geval levert de functie een resultaat op met de specifieke foutcode ara::crypto::CryptoErrc::kProcessingNotStarted onder waarborging van een rollback-semantiek [SWS_CRYPT_50027]. Wat de uitvoeringsveiligheid betreft, is de interface gespecificeerd als thread-safe en garandeert deze uitzonderingsveiligheid (exception safe), aangezien deze is gedeclareerd als noexcept en geen uitzonderingen genereert [SWS_CRYPT_50027].

Hetzelfde afbreekgedrag voor nog niet gefinaliseerde streamingverwerkingen wordt gedeeld door alle verwante contextinterfaces van de cryptografiemodule:

• VerifierPublicCtx voor de verificatie van digitale handtekeningen [SWS_CRYPT_50023],
• SignerPrivateCtx voor het genereren van digitale handtekeningen [SWS_CRYPT_50041],
• SymmetricCipherCtx voor symmetrische versleutelingen [SWS_CRYPT_50046],
• HashFunctionCtx voor hashwaarde-berekeningen [SWS_CRYPT_50058],
• DecryptorPrivateCtx voor asymmetrische ontsleutelingen [SWS_CRYPT_50069],
• AuthCipherCtx voor geauthenticeerde versleutelingen [SWS_CRYPT_50077] evenals
• EncryptorPublicCtx voor asymmetrische versleutelingen [SWS_CRYPT_50089].

Interpretatie: door het afbreken van de onvoltooide operatie wordt de context vermoedelijk weer in een opgeschoonde toestand gebracht, die een latere herinitialisatie via Start() mogelijk maakt. Vraag Q-a8fa5cb85c3dab50 (open)

Gebruik

De puur virtuele methode Compare van de klasse ara::crypto::cryp::MessageAuthnCodeCtx dient ertoe de grootte en inhoud van een berekende Message Authentication Code (MAC) te vergelijken met een verwachte digest [SWS_CRYPT_50133]. Als parameter wordt de verwachte MAC-digest via ReadOnlyMemRegion expected doorgegeven. De functie retourneert een ara::core::Result<bool> die true bevat indien de berekende MAC-waarde exact overeenkomt met de verwachte waarde, en anders false [SWS_CRYPT_50133].

Foutafhandeling

In geval van een fout wordt een foutcode geretourneerd in het resultaatobject, waarbij een rollback-semantiek geldt [SWS_CRYPT_50133]:

• ara::crypto::CryptoErrc::kProcessingNotFinished: Wordt gemeld als de berekening van de digest niet vooraf is voltooid door het aanroepen van de methode Finish() [SWS_CRYPT_50133].
• ara::crypto::CryptoErrc::kInvalidInputSize: Treedt op als de doorgegeven buffergrootte van de verwachte MAC-digest niet wordt ondersteund door de context [SWS_CRYPT_50133].

Gelijktijdigheid en beperkingen

De methode is gedeclareerd als const evenals noexcept en is conform de specificatie thread-veilig (thread-safe) en uitzonderingsveilig (exception safe) [SWS_CRYPT_50133]. Een wezenlijke voorwaarde is de vooraf succesvol voltooide digest-berekening via Finish() [SWS_CRYPT_50133].

Samenspel

In tegenstelling tot Compare, dat de volledige overeenstemming van de gehele MAC-digest valideert [SWS_CRYPT_50133], vergelijkt CompareSubspan in dezelfde context uitsluitend de meest significante bits (most significant bits) met de verwachte waarde [SWS_CRYPT_50028]. Voor niet-versleutelde hashfuncties bestaat een gelijknamige Compare-functie in ara::crypto::cryp::HashFunctionCtx [SWS_CRYPT_50154].

De synchrone methode CompareSubspan van de klasse ara::crypto::cryp::MessageAuthnCodeCtx vergelijkt de meest significante bits (Most Significant Bits) van een berekende MAC-waarde met een vooraf gedefinieerde referentie [SWS_CRYPT_50028]. De verwachte vergelijkingswaarde wordt via de parameter expected als ReadOnlyMemRegion doorgegeven [SWS_CRYPT_50028]. Het resultaat wordt als ara::core::Result<bool> geretourneerd en bevat true bij identiteit van de meest significante bits evenals false bij afwijkingen [SWS_CRYPT_50028].

Foutafhandeling en voorwaarden voor het verloop

Voor een geldige vergelijking moet de berekening van de controlewaarde zijn voltooid. Als er geen eerdere aanroep van de methode Finish() heeft plaatsgevonden, mislukt de aanroep met de foutcode ara::crypto::CryptoErrc::kProcessingNotFinished [SWS_CRYPT_50028]. Is de buffergrootte van de doorgegeven parameter expected ontoelaatbaar voor de gebruikte procedure, dan meldt de methode ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_50028]. Beide foutsoorten garanderen rollback-semantiek [SWS_CRYPT_50028].

Gelijktijdigheid en uitvoeringscontext

De bewerking is gespecificeerd als noexcept (exception-safe) en geclassificeerd als thread-safe [SWS_CRYPT_50028]. Interpretatie: De gedeclareerde thread-safety heeft vermoedelijk betrekking op de toestand na voltooide Finish(), zodat meerdere threads dezelfde berekende digest parallel kunnen verifiëren. Vraag Q-ac8b7ead6a5b508e (open)

De methode Finish() sluit de lopende berekening van een Message Authentication Code (MAC) binnen de interface MessageAuthnCodeCtx dwingend af [SWS_CRYPT_22115]. De aanroep vindt synchroon plaats, neemt geen parameters aan en retourneert ara::core::Result<void>, wat in het reguliere succesgeval een leeg resultaat voorstelt [SWS_CRYPT_22115].

In geval van een fout levert de functie de foutcode ara::crypto::CryptoErrc::kProcessingNotStarted als de MAC-berekening vóór de aanroep niet succesvol is gestart; daarbij treedt een rollback-semantiek in werking [SWS_CRYPT_22115]. De bewerking is gedeclareerd als noexcept en conform specificatie zowel exceptieveilig (exception safe) als thread-veilig (thread-safe) gespecificeerd [SWS_CRYPT_22115].

In het verwerkingsverloop vormt Finish() de schakel tussen de gegevensverwerking en de evaluatie: na de aanroep kan de gegenereerde MAC-digest via GetDigest() worden overgedragen naar een bereitgestelde buffer [SWS_CRYPT_22116] of met CompareSubspan() direct worden geverifieerd tegen een referentiewaarde [SWS_CRYPT_50028]. Terwijl GetMaximumChunkSize() [SWS_CRYPT_50033] generiek buffergroottes voor Update() of Finish() beschrijft, verwerkt Finish() hier geen gegevens direct; de vermelding in de eis weerspiegelt vermoedelijk een uniform patroon over alle cryptocontexten. Vraag Q-79b4f4ecf3998e48 (open)

De synchrone lidfunctie Generate van de klasse ara::crypto::cryp::MessageAuthnCodeCtx dient conform [SWS_CRYPT_50029] voor de berekening van een Message Authentication Code (MAC) in één enkele stap en schrijft de berekende digest naar de bereitgestelde uitvoerbuffer.

Voor de aanroep worden de volgende parameters doorgegeven:

• data: invoergegevens voor de MAC-berekening als ReadOnlyMemRegion.
• digest: doelgeheugengebied van het type ReadWriteMemRegion waarin de digest wordt geschreven.
• iv: een optionele initialisatievector als ara::core::Optional<ReadOnlyMemRegion>.

In een geval van succes levert de functie een ara::core::Result<std::size_t> op, die de grootte van de geschreven MAC-digest in bytes bevat [SWS_CRYPT_50029].

Treedt er een fout op, dan wordt een foutcode met rollback-semantiek geretourneerd [SWS_CRYPT_50029]:

• UninitializedContext: de context is nog niet geïnitialiseerd door toewijzing van een sleutel.
• ara::crypto::CryptoErrc::kUsageViolation: de gebruikte sleutel bevat niet de vereiste gebruiksvlag kAllowMac. Interpretatie: een passende symmetrische sleutel dient vermoedelijk vooraf via GenerateSymmetricKey te worden gegenereerd en geconfigureerd [SWS_CRYPT_20721]. Vraag Q-d22f397bbc02487b (open)
• ara::crypto::CryptoErrc::kEmptyKeySlot: Een geconfigureerde KeySlot is momenteel leeg.
• ara::crypto::CryptoErrc::kUnsupported: de single-call-verwerking wordt niet ondersteund of het specificeren van de initialisatievector voldoet niet aan de algoritme-eisen (ontbrekende of ontoelaatbaar opgegeven IV).
• ara::crypto::CryptoErrc::kInvalidInputSize: de buffergrootte van de invoergegevens of van de IV wordt niet ondersteund.
• ara::crypto::CryptoErrc::kInsufficientCapacity: de doelbuffer digest is te klein voor de MAC-digest.
• ara::crypto::CryptoErrc::kBusyResource: een benodigde systeembron is bezet.

Wat betreft concurrency is de methode als thread-safe en exception safe gespecificeerd [SWS_CRYPT_50029]. Ze is gedeclareerd als const noexcept en wijzigt bij uitvoering de toestand van de context niet.

De methode GenerateSubspan van de klasse ara::crypto::cryp::MessageAuthnCodeCtx berekent in een enkele stap een Message Authentication Code (MAC) voor de invoergegevens data en schrijft het begin (de meest significante bytes, MSB) van de berekende digest naar de uitvoerbuffer truncatedDigest [SWS_CRYPT_50030]. Via de optionele parameter iv kan desgewenst een initialisatievector worden meegegeven [SWS_CRYPT_50030]. De directe teruggave van ara::core::Result<std::size_t> duidt vermoedelijk op een synchrone uitvoering; bij een succesvol verloop wordt het aantal geschreven bytes van de MAC-digest geretourneerd [SWS_CRYPT_50030]. Vraag Q-167c6d44b9f39fed (open)

De specificatie definieert voor het foutgeval een rollback-semantiek en voorziet in de volgende foutcodes [SWS_CRYPT_50030]:

• UninitializedContext: De context is vooraf niet geïnitialiseerd door toewijzing van een sleutel [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Een geconfigureerde KeySlot is momenteel leeg [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kUsageViolation: Het toegestane gebruik van de sleutel omvat niet kAllowMac [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kUnsupported: De bewerking in één stap wordt niet ondersteund, of de IV-configuratie past niet bij de context (vereiste IV ontbreekt of ontoelaatbare IV meegegeven) [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kInvalidInputSize: De grootte van de meegegeven gegevens data of van de iv wordt niet ondersteund [SWS_CRYPT_50030].
• ara::crypto::CryptoErrc::kBusyResource: Een benodigde resource is bezet [SWS_CRYPT_50030].

Wat betreft de uitvoeringsomgeving is de methode gespecificeerd als thread-safe en biedt deze exception-veiligheid (noexcept) [SWS_CRYPT_50030]. Voorwaarde voor een foutloze aanroep is het vooraf bereitstellen van een sleutel met de overeenkomstige bevoegdheid in de context [SWS_CRYPT_50030].

De methode SetKey configureert een instantie van ara::crypto::cryp::MessageAuthnCodeCtx voor de daaropvolgende MAC-berekening met een bereitgestelde symmetrische sleutel [SWS_CRYPT_22118]. De aanroep vindt synchroon plaats en accepteert het sleutelobject als smart pointer SymmetricKey::Sptr. Als resultaat levert de functie een ara::core::Result<void> op, dat bij succes leeg is of bij een fout een specifieke foutcode inkapselt [SWS_CRYPT_22118].

Mislukt de toewijzing, dan treedt een rollback-semantiek in werking die de eerdere toestand van de context behoudt [SWS_CRYPT_22118]. De volgende fouttoestanden uit ara::crypto::CryptoErrc zijn gespecificeerd:

• kUnsupported: De context ondersteunt uitsluitend het binden via een KeySlot in plaats van via directe sleutelobjecten [SWS_CRYPT_22118].
• kIncompatibleObject: Het doorgegeven symmetrische sleutelobject is incompatibel met de doelcontext [SWS_CRYPT_22118].
• kUsageViolation: De bevoegdheidsvlaggen van de sleutel bevatten niet het dwingend vereiste gebruik kAllowMac [SWS_CRYPT_22118].

Wat betreft de uitvoeringsveiligheid is de interface gedefinieerd als thread-safe en exception safe (met noexcept) [SWS_CRYPT_22118]. In samenspel met het sleutelbeheer vormt deze de directe tegenhanger van de slotgebaseerde toewijzing: als een implementatie of een usecase het gebruik van gepersisteerde slots ondersteunt, wordt in plaats daarvan de overbelading voor KeySlot::Sptr gebruikt [SWS_CRYPT_50026].

Gebruik

De virtuele lidfunctie SetKey van de interface ara::crypto::cryp::MessageAuthnCodeCtx uit het headerbestand ara/crypto/cryp/message_authn_code_ctx.h configureert de context voor de berekening of verificatie van een Message Authentication Code (MAC) [SWS_CRYPT_50026]. Als parameter accepteert de synchrone methode een smart pointer keySlot van het type KeySlot::Sptr, die een symmetrische sleutel bevat, en retourneert een ara::core::Result<void> [SWS_CRYPT_50026]. De binding van de sleutel is semantisch uitgesteld: de in het slot opgeslagen sleutel wordt pas gebruikt op het moment dat de MAC-berekening daadwerkelijk wordt gestart [SWS_CRYPT_50026]. Interpretatie: latere bijwerkingen van de slotinhoud tot aan de start van de berekening blijven zodoende vermoedelijk van kracht. Vraag Q-d1886811d8af71e3 (open)

Gelijktijdigheid en uitvoeringsveiligheid

De interface is gedefinieerd als noexcept, waarborgt uitzonderingsveiligheid (exception safe) en is expliciet gespecificeerd voor gelijktijdige aanroepen (thread-safe) [SWS_CRYPT_50026].

Foutafhandeling en wisselwerking

In geval van een fout garandeert de methode een strikte rollback-semantiek, zodat de voorgaande toestand van de context volledig behouden blijft [SWS_CRYPT_50026]. De volgende foutcodes kunnen in het resultaatobject optreden:

• ara::crypto::CryptoErrc::kIncompatibleObject: de doorgegeven KeySlot is incompatibel met deze symmetrische sleutelcontext [SWS_CRYPT_50026].
• ara::crypto::CryptoErrc::kUnsupported: de concrete implementatie van de context ondersteunt het instellen via KeySlot niet [SWS_CRYPT_50026]. In dit geval moet als alternatief de overload SetKey(SymmetricKey::Sptr) voor het direct doorgeven van een sleutel worden gebruikt [SWS_CRYPT_22118].

De methode Start van ara::crypto::cryp::MessageAuthnCodeCtx initialiseert de context voor een nieuwe MAC-berekening en stelt daarbij een initialisatievector of nonce-waarde in via de parameter iv ([SWS_CRYPT_22110]). Dit wordt bijvoorbeeld toegepast bij algoritmen zoals GMAC ([SWS_CRYPT_22110]). Voor berekeningen zonder expliciete initialisatievector is als alternatief de parameterloze overbelasting Start() beschikbaar ([SWS_CRYPT_22111]).

Gebruik en concurrency

De aanroep geschiedt synchroon en is gespecificeerd als thread-safe en exception safe ([SWS_CRYPT_22110]). Na een succesvolle aanroep kunnen opeenvolgende berichtdelen via Update aan de context worden overgedragen ([SWS_CRYPT_22113]). Een lopende, nog niet voltooide streamingbewerking kan indien nodig via Cancel worden afgebroken ([SWS_CRYPT_50027]).

Foutafhandeling

De methode retourneert een ara::core::Result<void>, die in geval van een fout rollback-semantiek heeft ([SWS_CRYPT_22110]). Mogelijke fouttoestanden zijn:

• UninitializedContext: Aan de context is vooraf geen sleutel toegewezen ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kEmptyKeySlot: Een geconfigureerde KeySlot is leeg ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kUsageViolation: De machtigingen van de sleutel bevatten niet kAllowMac ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kInvalidInputSize: De doorgegeven IV-grootte wordt niet ondersteund ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kUnsupported: Streaming of het instellen van een IV wordt niet ondersteund door het algoritme respectievelijk de context ([SWS_CRYPT_22110]).
• ara::crypto::CryptoErrc::kBusyResource: Een benodigde resource is bezet ([SWS_CRYPT_22110]).

Gebruik

De methode Start() initialiseert een instantie van ara::crypto::cryp::MessageAuthnCodeCtx voor een nieuwe MAC-berekening [SWS_CRYPT_22111]. De aanroep accepteert geen parameters en retourneert een ara::core::Result<void> [SWS_CRYPT_22111]. De uitvoering zal vermoedelijk synchroon plaatsvinden, aangezien direct een resultaatobject ter beschikking wordt gesteld. Vraag Q-1e6e36f4ed1176d3 (open)

Foutafhandeling en gelijktijdigheid

Als er bij de initialisatie een fout optreedt, geldt de rollback-semantiek en wordt een van de volgende foutcodes geretourneerd [SWS_CRYPT_22111]:

• UninitializedContext: Er is vooraf geen sleutel aan de context toegewezen [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kUnsupported: De context ondersteunt geen streaming of het algoritme vereist dwingend een initialisatievector (IV) [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kBusyResource: Een benodigde resource is bezet [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Een geconfigureerde KeySlot is leeg [SWS_CRYPT_22111].
• ara::crypto::CryptoErrc::kUsageViolation: De sleutel staat geen MAC-berekening toe zonder ingestelde kAllowMac [SWS_CRYPT_22111].

De functie is gespecificeerd als thread-safe en exceptieveilig (exception safe) [SWS_CRYPT_22111].

Samenspel in het streamingproces

Vereist het algoritme een IV (bijv. GMAC), dan moet in plaats daarvan de overbelasting Start(ReadOnlyMemRegion iv) worden gebruikt [SWS_CRYPT_22110]. Na een succesvolle aanroep kunnen berichtgegevens stapsgewijs via Update() worden doorgegeven [SWS_CRYPT_22113]. Een nog niet voltooide streamingbewerking kan via Cancel() worden verworpen [SWS_CRYPT_50027].

Gebruik

De synchrone methode Update van de context ara::crypto::cryp::MessageAuthnCodeCtx dient ertoe om de lopende berekening van een Message Authentication Code (MAC) aan te vullen met een volgend fragment van het invoerbericht [SWS_CRYPT_22113]. Het te verwerken gegevenssegment wordt daarbij via parameter data doorgegeven in de vorm van een ReadOnlyMemRegion. Als retourwaarde levert de functie een ara::core::Result<void> op, die ofwel de succesvolle tussenstap bevestigt ofwel bij een fout inzicht geeft in de foutoorzaak [SWS_CRYPT_22113].

Foutafhandeling en gelijktijdigheid

In geval van een fout wordt een rollback-semantiek gegarandeerd, zodat de eerdere berekeningstoestand ongewijzigd blijft [SWS_CRYPT_22113]. Mogelijke foutoorzaken zijn:

• ara::crypto::CryptoErrc::kProcessingNotStarted: De berekening is vooraf niet geïnitieerd door de aanroep van de methode Start() [SWS_CRYPT_22113].
• ara::crypto::CryptoErrc::kInvalidInputSize: De grootte van het doorgegeven gegevensblok wordt niet ondersteund door de context [SWS_CRYPT_22113].

De methode is gedeclareerd als noexcept alsmede gespecificeerd als thread-safe en exceptieveilig (exception safe) [SWS_CRYPT_22113].

Samenspel

Om bufferfouten met ara::crypto::CryptoErrc::kInvalidInputSize te voorkomen, kan de maximaal toelaatbare invoergrootte voor afzonderlijke aanroepen vooraf worden opgevraagd via de methode GetMaximumChunkSize() [SWS_CRYPT_50033]. Na de opeenvolgende verwerking van alle berichtdelen zal de berekening van de MAC-tag volgens de interpretatie doorgaans worden afgerond via de methode Finish() [SWS_CRYPT_50033]. Vraag Q-7f8eaf8ebbf30d55 (open)

Gebruik

De methode Verify in ara::crypto::cryp::MessageAuthnCodeCtx ([SWS_CRYPT_50031]) dient voor de synchrone berekening van een MAC-digest over de invoerbuffer data en de directe vergelijking met de verwachte waarde expected. Optioneel kan via iv een initialisatievector worden doorgegeven. Als resultaat levert de functie een ara::core::Result<bool> op, die true bevat wanneer de berekende MAC overeenkomt met de verwachte bytesequentie, en anders false.

Foutafhandeling

Mislukt de verificatie om systemische of cryptografische redenen, dan levert de methode een ara::core::Result op met een overeenkomstige foutcode ([SWS_CRYPT_50031]):

• UninitializedContext: wanneer de context vooraf niet is geïnitialiseerd door toewijzing van een sleutel.
• ara::crypto::CryptoErrc::kEmptyKeySlot: wanneer de geconfigureerde KeySlot leeg is.
• ara::crypto::CryptoErrc::kUsageViolation: wanneer het toegestane gebruik van de sleutel kAllowMac niet omvat.
• ara::crypto::CryptoErrc::kInvalidInputSize: wanneer de buffergrootte van data, expected of iv ontoelaatbaar is.
• ara::crypto::CryptoErrc::kUnsupported: wanneer de single-call-uitvoering niet wordt ondersteund of het bereitstellen van de iv niet voldoet aan de vereisten van het algoritme.
• ara::crypto::CryptoErrc::kBusyResource: bij bronconflicten.

Gelijktijdigheid en wisselwerking

De methode is gespecificeerd als thread-safe en exception safe ([SWS_CRYPT_50031]). Bij een fout geldt een rollback-semantiek. In tegenstelling tot asymmetrische handtekeningcontroles in ara::crypto::cryp::VerifierPublicCtx ([SWS_CRYPT_24112], [SWS_CRYPT_50024]) opereert Verify op symmetrische MAC-contexten. De maximaal in één enkele aanroep te verwerken buffergrootte is – analoog aan het opvragen van de buffer bij handtekeningverificateurs ([SWS_CRYPT_50025]) – vermoedelijk beperkt door de implementatie van de context. Vraag Q-51e7427e4e082881 (open)

De methode VerifySubspan van de klasse ara::crypto::cryp::MessageAuthnCodeCtx dient voor de synchrone berekening van een MAC-digest en de aansluitende vergelijking van de meest significante bits ervan met een verwachte bytereeks [SWS_CRYPT_50032]. Zij verwerkt invoergegevens via data, de verwachte leidende bits via expected evenals een optionele initialisatievector via iv [SWS_CRYPT_50032]. Het resultaat wordt geretourneerd als ara::core::Result<bool> en signaleert bij succesvolle overeenkomst true, anders false [SWS_CRYPT_50032].

De interface is gespecificeerd als noexcept, is exception safe en thread-safe en past in geval van een fout rollback-semantiek toe [SWS_CRYPT_50032]. Mislukte aanroepen leveren specifieke foutcodes in de retourwaarde [SWS_CRYPT_50032]:

• UninitializedContext: De context is vooraf niet geïnitialiseerd door toewijzing van een sleutel [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kUsageViolation: Het toegestane gebruik van de sleutel omvat niet kAllowMac [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Een geconfigureerde KeySlot is momenteel leeg [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kInvalidInputSize: De grootte van de meegegeven gegevens, van de verwachte controlewaarde of van de IV wordt niet ondersteund [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kUnsupported: De single-call-bewerking wordt niet ondersteund of het bereitstellen van de IV is in strijd met de vereisten van de context [SWS_CRYPT_50032].
• ara::crypto::CryptoErrc::kBusyResource: Een benodigde resource is bezet [SWS_CRYPT_50032].