klasse ara::crypto::cryp::AuthCipherCtx

Gebruik

De methode Cancel() van de interface ara::crypto::cryp::AuthCipherCtx breekt een actieve streamingoperatie af die eerder via Start() werd ingeleid en nog niet is voltooid [SWS_CRYPT_50077]. De functie wordt ter beschikking gesteld via de header ara/crypto/cryp/auth_cipher_ctx.h en werkt synchroon zonder invoerparameters [SWS_CRYPT_50077]. Deze retourneert een ara::core::Result<void>, die bij succes leeg is.

Foutafhandeling en randvoorwaarden

Een beëindiging vereist dat de gegevensverwerking daadwerkelijk vooraf is gestart door Start(). Is de streamingoperatie niet gestart, dan mislukt de aanroep en levert deze de foutcode ara::crypto::CryptoErrc::kProcessingNotStarted met rollback-semantiek op [SWS_CRYPT_50077].

Concurrency

De operatie is gedeclareerd als noexcept en volgens de specificatie geclassificeerd als zowel thread-safe als exception safe [SWS_CRYPT_50077].

Samenspel

Het door Cancel() gerealiseerde afbreekpatroon is gestandaardiseerd in module crypt. Een identieke interfacesemantiek en dezelfde foutcode ara::crypto::CryptoErrc::kProcessingNotStarted zijn gedefinieerd voor corresponderende streamingcontexten:

• ara::crypto::cryp::VerifierPublicCtx [SWS_CRYPT_50023]
• ara::crypto::cryp::MessageAuthnCodeCtx [SWS_CRYPT_50027]
• ara::crypto::cryp::SignerPrivateCtx [SWS_CRYPT_50041]
• ara::crypto::cryp::SymmetricCipherCtx [SWS_CRYPT_50046]
• ara::crypto::cryp::HashFunctionCtx [SWS_CRYPT_50058]
• ara::crypto::cryp::DecryptorPrivateCtx [SWS_CRYPT_50069]
• ara::crypto::cryp::EncryptorPublicCtx [SWS_CRYPT_50089]

De synchrone methode EncryptSingleCallWithOutputIv van de interface ara::crypto::cryp::AuthCipherCtx voert een geauthentiseerde versleuteling uit in één enkele stap en genereert daarbij zelfstandig een initialisatievector [SWS_CRYPT_50080]. Deze verwerkt invoergegevens uit dataIn evenals optionele aanvullende gegevens authenticatedData en schrijft de cijfertekst naar de buffer dataOut. De gegenereerde initialisatievector wordt opgeslagen in de buffer ivOut, terwijl de authenticatie-tag via tag wordt uitgevoerd [SWS_CRYPT_50080]. De buffergrootte voor ivOut kan vooraf via de methode GetOutputIvSize worden bepaald [SWS_CRYPT_50165]. Ondanks het naamsbestanddeel Encrypt kan de methode vermoedelijk ook voor ontsleuteling worden gebruikt, aangezien de foutspecificatie het gedrag voor transformDirection == kDecrypt expliciet vermeldt [SWS_CRYPT_50080]. Vraag Q-66618567b20f99b9 (open)

Voor de aanroep gelden wezenlijke voorwaarden en beperkingen:

• De context moet vooraf succesvol zijn geïnitialiseerd met SetKey; anders wordt kUninitializedContext gemeld [SWS_CRYPT_50080].
• De sleutel in het geconfigureerde key-slot moet compatibel zijn en over de juiste autorisatie beschikken (bijv. kAllowDataEncrypt), omdat anders kUsageViolation of kIncompatibleObject wordt geretourneerd [SWS_CRYPT_50080].
• Als de uitvoerbuffers dataOut of ivOut niet toereikend zijn, mislukt de aanroep met kInsufficientCapacity [SWS_CRYPT_50080].
• Als de context geen verwerking in één stap ondersteunt of een externe IV-opgave vereist, wordt kUnsupported geretourneerd [SWS_CRYPT_50080].

De operatie is gespecificeerd als thread-safe evenals uitzonderingsveilig en garandeert rollback-semantiek in geval van een fout [SWS_CRYPT_50080]. Voor zuiver symmetrische versleutelingen zonder tag-verwerking bestaat een separaat equivalent in SymmetricCipherCtx [SWS_CRYPT_50049].

Gebruik en semantiek

De methode Finish sluit de ver- of ontsleuteling binnen een ara::crypto::cryp::AuthCipherCtx synchroon af en berekent respectievelijk controleert de authenticatietag, zonder een initialisatievector (IV) te retourneren [SWS_CRYPT_50075]. De aanroeper geeft de resterende gegevens door via de buffer in en de doelbuffer out. Via de buffer tag wordt bij versleuteling de berekende tag uitgevoerd, terwijl bij ontsleuteling de te controleren tag wordt meegegeven [SWS_CRYPT_50075]. De retourwaarde ara::core::Result<std::size_t> kwantificeert de werkelijk in out geschreven bytes, die minder kunnen zijn dan de capaciteit van de uitvoerbuffer [SWS_CRYPT_50075].

Verloop en interactie

Voorafgaand aan de aanroep moet de gegevensverwerking dwingend zijn geïnitieerd door Start() [SWS_CRYPT_50075]. Als er eerder datablokken zijn verwerkt met behulp van UpdateConfidentialData, mag een toepassing de resulterende platte tekst bij ontsleuteling pas gebruiken na succesvolle authenticatie door Finish [SWS_CRYPT_50074]. De maximaal vereiste buffergrootte voor out kan vooraf via GetRequiredOutputBufferSize onder opgave van isFinal = true worden bepaald [SWS_CRYPT_50081].

Foutafhandeling en gelijktijdigheid

De methode is thread-safe en uitzonderingsveilig gespecificeerd [SWS_CRYPT_50075]. Fouten worden via ara::core::Result met rollback-semantiek teruggemeld [SWS_CRYPT_50075]:

• ProcessingNotStarted: De gegevensverwerking is niet vooraf gestart met Start() [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kInsufficientCapacity: De uitvoerbuffer out is te klein [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kInvalidInputSize: De buffergrootte van in of tag is ongeldig [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kAuthTagNotValid: De gegevensauthenticiteit kan bij de ontsleuteling niet worden bevestigd [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kUnsupported: Streaming-verwerking wordt niet ondersteund door de context [SWS_CRYPT_50075].

Gebruik

De methode FinishEncrypt voltooit een geauthenticeerde versleutelingsoperatie in ara::crypto::cryp::AuthCipherCtx synchroon, berekent de authenticatietag en retourneert de door de context gegenereerde initialisatievector via ivOut [SWS_CRYPT_50076]. De aanroep is gespecificeerd als thread-safe en uitzonderingsveilig (exception safe) [SWS_CRYPT_50076]. Als resultaat levert de functie een ara::core::Result<std::size_t> met het aantal daadwerkelijk naar de uitvoerbuffer out geschreven bytes, waarbij de uitvoergrootte kleiner mag zijn dan de buffercapaciteit [SWS_CRYPT_50076]. Interpretatie: Hoewel de naam duidt op versleuteling, wijzen de specificatie van de parameter tag en de foutcode ara::crypto::CryptoErrc::kAuthTagNotValid erop dat de signatuur in de context symmetrisch vermoedelijk ook voor decryptieoperaties wordt gebruikt. Vraag Q-6b924f12c32e0f33 (open)

Interactie en bufferdimensionering

De dataverwerking moet vooraf dwingend zijn gestart met Start(), anders meldt de functie de fout ProcessingNotStarted [SWS_CRYPT_50076]. Voor de bufferdimensionering moet rekening worden gehouden met het samenspel met de volgende contextfuncties:

• De maximaal vereiste capaciteit voor out kan vooraf via [SWS_CRYPT_50081] met de parameter isFinal = true worden berekend om de fout ara::crypto::CryptoErrc::kInsufficientCapacity te voorkomen [SWS_CRYPT_50076].
• De minimale en maximale buffergrootte voor de invoerdata in wordt bepaald door [SWS_CRYPT_50162] en [SWS_CRYPT_50082].
• De benodigde buffergrootte voor de opname van de gegenereerde initialisatievector in ivOut kan via [SWS_CRYPT_50165] worden opgevraagd.

Foutafhandeling en randvoorwaarden

In geval van een fout hebben alle terugmeldingen een gedefinieerde rollback-semantiek [SWS_CRYPT_50076]. Bij ongeldige buffergroottes voor invoerdata of de authenticatietag wordt ara::crypto::CryptoErrc::kInvalidInputSize geretourneerd [SWS_CRYPT_50076]. Bovendien levert de functie ara::crypto::CryptoErrc::kUnsupported indien streamverwerking niet wordt ondersteund, er geen IV wordt gebruikt of de IV reeds bij de start door de applicatie is opgegeven [SWS_CRYPT_50076].

De synchrone en als thread-safe gedefinieerde methode ProcessSingleCall van ara::crypto::cryp::AuthCipherCtx voert de versleuteling of ontsleuteling van payload en de gelijktijdige berekening resp. verificatie van de authenticatietag uit in één enkele bewerking zonder initialisatievector (IV) [SWS_CRYPT_50078]. Via de optionele buffer authenticatedData kunnen aanvullende geauthenticeerde gegevens beschikbaar worden gesteld [SWS_CRYPT_50078]. De buffer tag dient bij ontsleuteling als invoer voor verificatie en bij versleuteling als uitvoer voor het opslaan van de gegenereerde authenticatietag [SWS_CRYPT_50078]. Bij succesvolle verwerking retourneert ara::core::Result<std::size_t> het daadwerkelijke aantal in dataOut geschreven bytes, dat kleiner kan zijn dan de capaciteit van de doelbuffer [SWS_CRYPT_50078].

Vóór de aanroep moet de cryptografische context via een succesvolle aanroep van SetKey zijn geïnitialiseerd; anders mislukt de functie met ara::crypto::CryptoErrc::kUninitializedContext [SWS_CRYPT_50078]. Bovendien moet de gebruikte sleutel zijn vrijgegeven voor de aangevraagde transformatierichting (kAllowDataEncrypt resp. kAllowDataDecrypt), omdat anders ara::crypto::CryptoErrc::kUsageViolation wordt gemeld [SWS_CRYPT_50078]. Wordt enkelstapsverwerking niet ondersteund of vereist de context een IV, dan retourneert de functie ara::crypto::CryptoErrc::kUnsupported [SWS_CRYPT_50078]. Mislukt bij de ontsleuteling de authenticatie, dan wordt ara::crypto::CryptoErrc::kAuthTagNotValid geactiveerd [SWS_CRYPT_50078]. Fouten bij het toegewezen sleutelslot worden via EmptyKeySlot, ara::crypto::CryptoErrc::kBusyResource of ara::crypto::CryptoErrc::kIncompatibleObject gesignaleerd [SWS_CRYPT_50078].

Voor het bufferbeheer kan de maximaal vereiste uitvoergrootte voor dataOut vooraf via GetRequiredOutputBufferSize met gezette vlag isFinal = true worden berekend [SWS_CRYPT_50081]; een te kleine uitvoerbuffer leidt tot ara::crypto::CryptoErrc::kInsufficientCapacity [SWS_CRYPT_50078]. Daarnaast moet de grootte van dataIn voldoen aan de grenzen van GetMinimumChunkSize [SWS_CRYPT_50162] en GetMaximumChunkSize [SWS_CRYPT_50082] om ara::crypto::CryptoErrc::kInvalidInputSize te voorkomen [SWS_CRYPT_50078].

De methode [SWS_CRYPT_50079] van de klasse ara::crypto::cryp::AuthCipherCtx voert een synchrone éénstapsverwerking (single-call) uit voor het ver- of ontsleutelen van gegevens onder gelijktijdige berekening resp. controle van de authenticatietag.

Bij de aanroep worden de invoergegevens via dataIn en de richting via transformDirection opgegeven. De initialisatievector wordt via iv doorgegeven en optionele authenticatiegegevens kunnen via authenticatedData beschikbaar worden gesteld [SWS_CRYPT_50079]. De buffer tag dient in het geval van versleuteling als uitvoer voor de berekende tag en in het geval van ontsleuteling als invoer voor de verificatie [SWS_CRYPT_50079]. De retourwaarde ara::core::Result<std::size_t> levert bij succes het aantal in dataOut geschreven bytes op, dat kleiner kan zijn dan de buffercapaciteit [SWS_CRYPT_50079].

In het geval van een fout hebben alle foutcodes rollback-semantiek [SWS_CRYPT_50079]:

• ara::crypto::CryptoErrc::kUninitializedContext: Vooraf is er geen sleutel geconfigureerd via SetKey [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kUsageViolation: De sleutel beschikt niet over de vereiste rechten kAllowDataEncrypt resp. kAllowDataDecrypt [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kEmptyKeySlot, ara::crypto::CryptoErrc::kBusyResource of ara::crypto::CryptoErrc::kIncompatibleObject: Een geconfigureerde KeySlot is leeg, bezet of bevat geen compatibele SymmetricKey [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kInvalidInputSize of ara::crypto::CryptoErrc::kInsufficientCapacity: De buffers voor invoer, tag of IV zijn ongeldig gedimensioneerd of dataOut biedt ontoereikende capaciteit [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kAuthTagNotValid: Bij de ontsleuteling mislukt de authenticatie [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kUnsupported: Single-shot-verwerking wordt niet ondersteund door de context of de context vereist het instellen resp. uitvoeren van een IV [SWS_CRYPT_50079].

De bewerking is gedefinieerd als thread-safe en exception safe [SWS_CRYPT_50079]. De toegestane lengtes voor iv kunnen dynamisch via GetMinimumInputIvSize [SWS_CRYPT_50163] en GetMaximumInputIvSize [SWS_CRYPT_50164] worden opgevraagd. In vergelijking met het zuivere blokcijfer in SymmetricCipherCtx [SWS_CRYPT_50048] combineert deze interface cryptografische transformatie en integriteitscontrole in één aanroep.

De methode SetKey configureert de instantie van ara::crypto::cryp::AuthCipherCtx voor het gebruik van een doorgegeven symmetrische sleutel [SWS_CRYPT_23911]. Als parameter wordt een shared pointer key (van het type SymmetricKey::Sptr) doorgegeven, die wordt gebruikt voor de geauthenticeerde ver- of ontsleuteling [SWS_CRYPT_23911]. De aanroep vindt synchroon plaats, is gedeclareerd als noexcept en retourneert een ara::core::Result<void> [SWS_CRYPT_23911].

In geval van een fout wordt het resultaat met rollback-semantiek teruggezet en levert het specifieke foutcodes [SWS_CRYPT_23911]:

• ara::crypto::CryptoErrc::kUnsupported: indien de context uitsluitend configuratie via een KeySlot ondersteunt [SWS_CRYPT_23911].
• ara::crypto::CryptoErrc::kIncompatibleObject: wanneer het doorgegeven sleuteltype niet compatibel is met de huidige context [SWS_CRYPT_23911].
• ara::crypto::CryptoErrc::kUsageViolation: wanneer de toegestane gebruiksvlaggen van de sleutel niet kAllowDataEncrypt voor versleuteling resp. kAllowDataDecrypt voor ontsleuteling bevatten [SWS_CRYPT_23911].

Volgens de specificatie is de interface geclassificeerd als thread-safe (thread-safe) en uitzonderingsveilig (exception safe) [SWS_CRYPT_23911]. In samenhang met de modulecontext kan de sleutel vermoedelijk vóór de initialisatie van een nieuwe transformatie via Start [SWS_CRYPT_24715] worden ingesteld. Vraag Q-11f7daa370f5d438 (open)

De functie SetKey in de interface ara::crypto::cryp::AuthCipherCtx configureert de context voor cryptografische operaties zodanig dat de in een ter beschikking gesteld sleutelslot opgeslagen symmetrische sleutel wordt gebruikt zodra de geauthenticeerde ver- of ontsleuteling wordt uitgevoerd [SWS_CRYPT_50072].

Gebruik: De synchrone aanroep vindt plaats via de interface uit ara/crypto/cryp/auth_cipher_ctx.h. Als parameter keySlot wordt een instantie van KeySlot::Sptr meegegeven, die een symmetrische sleutel inkapselt [SWS_CRYPT_50072]. De functie retourneert een ara::core::Result<void>, die het succes bevestigt of een foutcode bevat [SWS_CRYPT_50072].

Foutafhandeling: Voor zover de concrete implementatie van de context uitsluitend de directe configuratie via een SymmetricKey-object ondersteunt en het instellen via KeySlot niet aanbiedt, mislukt de aanroep. In dat geval wordt de fout ara::crypto::CryptoErrc::kUnsupported met rollback-semantiek geretourneerd [SWS_CRYPT_50072].

Gelijktijdigheid en beperkingen: De functie is gespecificeerd als thread-safe en exception safe [SWS_CRYPT_50072]. Deze kan gelijktijdig worden aangeroepen en waarborgt dat er bij uitzonderingssituaties geen inconsistente toestand achterblijft.

Samenspel: Als functioneel alternatief is de overbelasting SetKey met een direct SymmetricKey::Sptr beschikbaar [SWS_CRYPT_23911]. Na succesvolle sleutelbinding wordt de context via Start geïnitialiseerd met de operatierichting en de initialisatievector [SWS_CRYPT_24715]. Analoge signaturen met KeySlot::Sptr bestaan bovendien in MessageAuthnCodeCtx [SWS_CRYPT_50026] en SymmetricKeyWrapperCtx [SWS_CRYPT_50034].

De methode Start initialiseert de context ara::crypto::cryp::AuthCipherCtx voor een nieuwe ver- of ontsleuteling en stelt de te gebruiken initialisatievector (IV) resp. nonce-waarde in [SWS_CRYPT_24715]. Via de parameter transformDirection wordt de transformatierichting vastgelegd, terwijl iv de vector als ReadOnlyMemRegion doorgegeven [SWS_CRYPT_24715]. De toelaatbare IV-grootte kan via GetMinimumInputIvSize() en GetMaximumInputIvSize() worden bepaald; bij een afwijkende lengte meldt de functie de fout ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_24715].

Vóór de aanroep moet SetKey succesvol zijn uitgevoerd, anders wordt ara::crypto::CryptoErrc::kUninitializedContext geretourneerd [SWS_CRYPT_24715]. Een geconfigureerde KeySlot mag noch leeg (EmptyKeySlot) noch bezet zijn (ara::crypto::CryptoErrc::kBusyResource) [SWS_CRYPT_24715]. Bovendien moet de opgeslagen sleutel een passende SymmetricKey zijn (anders ara::crypto::CryptoErrc::kIncompatibleObject) en bevoegd zijn voor de gewenste richting (kAllowDataEncrypt resp. kAllowDataDecrypt, anders ara::crypto::CryptoErrc::kUsageViolation) [SWS_CRYPT_24715]. Ontbreekt de ondersteuning voor streamingverwerking of het instellen van een IV in de gekozen richting, dan mislukt de aanroep met ara::crypto::CryptoErrc::kUnsupported [SWS_CRYPT_24715]. Alle fouten vertonen rollback-semantiek [SWS_CRYPT_24715].

De bewerking is gedeclareerd als thread-safe evenals exception-safe (noexcept) [SWS_CRYPT_24715]. In de samenhang van cryptografische processen volgt na een succesvolle initialisatie vermoedelijk typisch de overdracht van aanvullende geauthenticeerde data via UpdateAuthenticatedData [SWS_CRYPT_20313]. Vraag Q-e023e27f1cd24507 (open)

Gebruik

De puur virtuele methode Start van de klasse ara::crypto::cryp::AuthCipherCtx initialiseert de context synchroon voor een aanstaande ver- of ontsleuteling [SWS_CRYPT_50073]. Via de parameter transformDirection wordt aangegeven of de context voor versleuteling of ontsleuteling wordt voorbereid. Deze overbelasting zonder initialisatievector (IV) mag alleen worden gebruikt wanneer de cryptografische context in de gekozen transformatierichting geen IV vereist of deze zelf vastlegt [SWS_CRYPT_50073]. De retourwaarde is een lege ara::core::Result<void> in geval van succes of een bijbehorende foutcode.

Foutafhandeling en randvoorwaarden

Vóór de aanroep moet de context succesvol via SetKey met een sleutel zijn geconfigureerd; anders mislukt de functie met ara::crypto::CryptoErrc::kUninitializedContext [SWS_CRYPT_50073]. Daarnaast treden in geval van een fout de volgende retourwaarden op:

• ara::crypto::CryptoErrc::kUnsupported, wanneer streamverwerking niet door de context wordt ondersteund of wanneer de context in de gekozen transformatierichting dwingend de expliciete opgave van een IV vereist [SWS_CRYPT_50073].
• ara::crypto::CryptoErrc::kUsageViolation, wanneer het toegestane sleutelgebruik in het geconfigureerde KeySlot op het tijdstip van aanroepen niet de vereiste machtiging kAllowDataEncrypt voor versleuteling resp. kAllowDataDecrypt voor ontsleuteling omvat [SWS_CRYPT_50073].
• EmptyKeySlot resp. ara::crypto::CryptoErrc::kBusyResource, indien een geconfigureerde KeySlot momenteel leeg of geblokkeerd is [SWS_CRYPT_50073].
• ara::crypto::CryptoErrc::kIncompatibleObject, wanneer de geconfigureerde KeySlot geen SymmetricKey bevat of dit sleuteltype niet door de context wordt ondersteund [SWS_CRYPT_50073].

Als er een fout optreedt, is de gespecificeerde rollback-semantiek van toepassing (rollback_semantics) [SWS_CRYPT_50073].

Gelijktijdigheid en wisselwerking

De functie is gedeclareerd met noexcept=0, waarborgt uitzonderingsveiligheid en is ontworpen als thread-safe [SWS_CRYPT_50073]. Vereist het algoritme het extern ter beschikking stellen van een initialisatievector, dan dient in plaats daarvan de overbelasting Start(CryptoTransform, ReadOnlyMemRegion) te worden gebruikt [SWS_CRYPT_24715]. Na succesvolle initialisatie kunnen aanvullende geauthenticeerde data via UpdateAuthenticatedData worden meegenomen in de berekening van de authenticatietag [SWS_CRYPT_20313].

De methode UpdateAuthenticatedData van de interface ara::crypto::cryp::AuthCipherCtx dient ertoe de berekening van de authenticatietag stapsgewijs bij te werken met een volgend deel van aanvullende geauthenticeerde gegevens (Additional Authenticated Data) [SWS_CRYPT_20313]. Via de parameter authenticatedData wordt de betreffende buffer als ReadOnlyMemRegion doorgegeven [SWS_CRYPT_20313].

Wat betreft de aanroepcontext en de gelijktijdigheid is de operatie gedefinieerd als thread-safe en exception safe [SWS_CRYPT_20313]. Voor de aanroep gelden strikte volgordevoorwaarden:

• De transformatie moet vooraf zijn geïnitieerd via de methode Start(), anders wordt ara::crypto::CryptoErrc::kProcessingNotStarted gemeld [SWS_CRYPT_20313].
• De functie mag niet meer worden aangeroepen wanneer UpdateConfidentialData al is uitgevoerd; bij niet-naleving wordt de fout ara::crypto::CryptoErrc::kInvalidUsageOrder geretourneerd [SWS_CRYPT_20313].

Als retourwaarde levert de functie een ara::core::Result<void> op, die in het geval van succes leeg is of een opgetreden foutcode inkapselt [SWS_CRYPT_20313]. Alle fouten vertonen een rollback-semantiek [SWS_CRYPT_20313]:

• ara::crypto::CryptoErrc::kInvalidInputSize: de grootte van de meegegeven invoerbuffer is ongeldig [SWS_CRYPT_20313].
• ara::crypto::CryptoErrc::kUnsupported: streamverwerking wordt niet ondersteund door de huidige context [SWS_CRYPT_20313].

De methode UpdateConfidentialData van de klasse ara::crypto::cryp::AuthCipherCtx dient voor het stapsgewijs versleutelen of ontsleutelen van vertrouwelijke payload binnen het kader van een geauthenticeerde cijfercontext [SWS_CRYPT_50074]. Hieraan worden de invoerbuffer in (type ReadOnlyMemRegion) met een deel van de leesbare tekst of cijfertekst en de uitvoerbuffer out (type ReadWriteMemRegion) meegegeven [SWS_CRYPT_50074]. Als synchrone retourwaarde levert de functie een ara::core::Result<std::size_t> op, die bij succes het daadwerkelijk geschreven aantal bytes bevat; dit kan kleiner zijn dan de capaciteit van out [SWS_CRYPT_50074].

Met betrekking tot het verloop en de gelijktijdigheid gelden de volgende voorwaarden:

• Volgorde van uitvoering en integriteit: Vóór de verwerking moet de bewerking via Start() zijn geïnitieerd [SWS_CRYPT_50074]. Wordt de methode gebruikt voor ontsleuteling, dan wordt de leesbare tekst zonder voorafgaande authenticiteitscontrole uitgevoerd; de toepassing mag deze gegevens onder geen beding vóór de afsluitende verificatie met Finish() gebruiken [SWS_CRYPT_50074]. Aanvullende geauthenticeerde gegevens kunnen parallel via UpdateAuthenticatedData in de tagberekening worden meegenomen [SWS_CRYPT_20313].
• Thread- en uitzonderingsveiligheid: De bewerking is als thread-safe en exception-safe gedeclareerd en werpt geen uitzonderingen op (noexcept) [SWS_CRYPT_50074].

Mislukt de verwerking, dan geldt rollback-semantiek onder teruggave van een overeenkomstige foutcode in ara::core::Result [SWS_CRYPT_50074]:

• ara::crypto::CryptoErrc::kProcessingNotStarted: De verwerking is nog niet via Start() ingeleid [SWS_CRYPT_50074].
• ara::crypto::CryptoErrc::kInsufficientCapacity: De uitvoerbuffer out is te klein gedimensioneerd [SWS_CRYPT_50074].
• ara::crypto::CryptoErrc::kInvalidInputSize: De grootte van de buffer in is ongeldig [SWS_CRYPT_50074].
• ara::crypto::CryptoErrc::kUnsupported: Streamverwerking wordt niet ondersteund door de context [SWS_CRYPT_50074].