classe ara::crypto::cryp::SymmetricCipherCtx

O método síncrono Cancel() da classe ara::crypto::cryp::SymmetricCipherCtx destina-se ao cancelamento prematuro de uma operação de streaming em andamento, previamente iniciada com Start() e ainda não concluída [SWS_CRYPT_50046]. A interface é declarada sem parâmetros em ara/crypto/cryp/symmetric_cipher_ctx.h e retorna um ara::core::Result<void> vazio em caso de execução bem-sucedida [SWS_CRYPT_50046].

Se o processamento de dados não tiver sido iniciado previamente pela chamada de Start(), a operação falha com o código de erro específico ara::crypto::CryptoErrc::kProcessingNotStarted e semântica de rollback [SWS_CRYPT_50046]. Para o contexto de chamada, a especificação garante segurança de threads (thread-safe) bem como segurança contra exceções (exception safe) com declaração noexcept [SWS_CRYPT_50046]. Interpretação: devido à semântica de rollback, o objeto deve retornar a um estado inicial pronto após um cancelamento. Pergunta Q-b6deb8db5367acc5 (aberta)

Este padrão funcional está definido de forma consistente em todos os contextos de streaming criptográfico no AUTOSAR Adaptive. Assinaturas e semânticas de erro idênticas aplicam-se às classes de contexto VerifierPublicCtx ([SWS_CRYPT_50023]), MessageAuthnCodeCtx ([SWS_CRYPT_50027]), SignerPrivateCtx ([SWS_CRYPT_50041]), HashFunctionCtx ([SWS_CRYPT_50058]), DecryptorPrivateCtx ([SWS_CRYPT_50069]), AuthCipherCtx ([SWS_CRYPT_50077]) e EncryptorPublicCtx ([SWS_CRYPT_50089]).

Utilização e tratamento de buffers

O método síncrono EncryptSingleCallWithOutputIv executa uma cifragem simétrica numa única chamada e retorna o vetor de inicialização gerado pelo contexto através do buffer ivOut [SWS_CRYPT_50049]. Os dados de entrada são passados através de in, enquanto out recebe os dados cifrados [SWS_CRYPT_50049]. Em caso de execução bem-sucedida, o resultado ara::core::Result<std::size_t> fornece o tamanho real dos dados de saída gerados, o qual pode ser inferior à capacidade total de out [SWS_CRYPT_50049]. Se o algoritmo selecionado não necessitar de vetor de inicialização, nenhuns dados são escritos em ivOut [SWS_CRYPT_50049].

Interação e pré-condições

Antes da chamada, o contexto tem de ser inicializado através de uma chave adequada [SWS_CRYPT_50049]. Para assegurar uma capacidade suficiente do buffer ivOut, o comprimento de IV necessário pode ser determinado previamente através de GetOutputIvSize() [SWS_CRYPT_50143]. Caso seja adicionalmente necessária uma autenticação com cálculo de tag, ara::crypto::cryp::AuthCipherCtx oferece a contraparte correspondente [SWS_CRYPT_50080].

Tratamento de erros e simultaneidade

A interface está especificada como thread-safe, bem como segura contra exceções ("exception safe"), e aplica uma semântica de rollback em caso de erros [SWS_CRYPT_50049]. Interpretação: esta semântica de rollback presumivelmente deverá garantir que, na ocorrência de erros, o estado do contexto permaneça intacto e nenhuns dados incompletos permaneçam como válidos no buffer. Pergunta Q-841087731518d866 (aberta) Entre os erros relevantes contam-se:

• UninitializedContext: ainda não foi atribuída nenhuma chave ao contexto [SWS_CRYPT_50049].
• ara::crypto::CryptoErrc::kInsufficientCapacity: a capacidade de out ou de ivOut é insuficiente [SWS_CRYPT_50049].
• ara::crypto::CryptoErrc::kUnsupported: a cifragem em chamada única não é suportada ou o algoritmo força a especificação de um IV de entrada [SWS_CRYPT_50049].
• ara::crypto::CryptoErrc::kUsageViolation ou ara::crypto::CryptoErrc::kIncompatibleObject: o tipo de chave não é adequado à transformação ou a utilização da chave não permite a cifragem de dados [SWS_CRYPT_50049].

usar

O método síncrono Finish finaliza uma cifragem ou decifragem simétrica dentro de ara::crypto::cryp::SymmetricCipherCtx sem retorno de um vetor de inicialização ([SWS_CRYPT_50045]). Ele processa a última secção de dados do buffer de entrada in (ReadOnlyMemRegion) e escreve os dados resultantes no buffer de saída out (ReadWriteMemRegion) ([SWS_CRYPT_50045]). O tamanho de buffer necessário para o efeito pode ser consultado previamente através de GetRequiredOutputBufferSize() ([SWS_CRYPT_50045]). O valor de retorno do tipo ara::core::Result<std::size_t> fornece, em caso de sucesso, o número exato de bytes escritos, o qual pode ser inferior à capacidade total de out ([SWS_CRYPT_50045]).

Tratamento de erros

Em caso de erro, o método fornece um ara::core::Result com códigos de erro específicos ([SWS_CRYPT_50045]):

• ProcessingNotStarted: o processamento de dados não foi iniciado previamente por Start() ([SWS_CRYPT_50045]).
• ara::crypto::CryptoErrc::kInsufficientCapacity: o buffer de saída out é demasiado pequeno ([SWS_CRYPT_50045]).
• ara::crypto::CryptoErrc::kInvalidInputSize: o tamanho dos dados de entrada não pode ser processado ([SWS_CRYPT_50045]).
• ara::crypto::CryptoErrc::kInvalidArgument: os dados de entrada passados são inválidos ([SWS_CRYPT_50045]).
• ara::crypto::CryptoErrc::kUnsupported: o processamento de stream não é suportado pelo contexto atual ([SWS_CRYPT_50045]).

Se ocorrer um dos erros CryptoErrc, aplica-se uma semântica de rollback ([SWS_CRYPT_50045]).

Concorrência e interação

A operação está definida como thread-safe e exception safe ([SWS_CRYPT_50045]). Antes da chamada, a transformação tem de ter sido obrigatoriamente iniciada por Start() ([SWS_CRYPT_50045]). O tamanho de entrada máximo permitido para chamadas individuais de Finish() pode ser determinado através de GetMaximumChunkSize() ([SWS_CRYPT_50050]). Após a conclusão, a execução da transformação presumivelmente deverá estar terminada e, para operações adicionais, presumivelmente tornar-se-á necessária uma nova chamada de Start(). Pergunta Q-c4ffc8028e8f522b (aberta)

O método FinishEncrypt conclui uma operação de criptografia e retorna o vetor de inicialização (IV) gerado pelo contexto [SWS_CRYPT_23618]. Ele processa o buffer de dados de entrada final in e grava os dados resultantes no buffer de saída out, bem como o IV em ivOut. Como valor de retorno, ele fornece um ara::core::Result<std::size_t> com o tamanho real dos dados de saída gravados, o qual pode ser menor do que a capacidade de out [SWS_CRYPT_23618].

Para uma execução sem erros, as dimensões dos buffers e o estado do contexto devem ser ajustados previamente:

• O tamanho de buffer necessário para out pode ser determinado via [SWS_CRYPT_50140] com o parâmetro isFinal = true definido. Se out for dimensionado pequeno demais, a chamada falhará com CryptoErrc::kInsufficientCapacity [SWS_CRYPT_23618].
• O tamanho esperado para ivOut pode ser consultado por meio de [SWS_CRYPT_50143].
• O tamanho de entrada de in deve estar entre os limites mínimo e máximo definidos por [SWS_CRYPT_50144] e [SWS_CRYPT_50050]; caso contrário, CryptoErrc::kInvalidInputSize será retornado [SWS_CRYPT_23618].

Se o processamento de dados não tiver sido iniciado previamente por Start(), o método reportará CryptoErrc::kProcessingNotStarted [SWS_CRYPT_23618]. Se o buffer de entrada contiver dados inválidos, segue-se CryptoErrc::kInvalidArgument [SWS_CRYPT_23618]. O erro CryptoErrc::kUnsupported ocorre se o processamento em stream não for suportado, se o contexto não utilizar um IV ou se um IV já tiver sido passado em Start() [SWS_CRYPT_23618]. Todos os erros possuem semântica de rollback [SWS_CRYPT_23618]. De acordo com a especificação, a chamada é segura para threads e segura contra exceções (noexcept) [SWS_CRYPT_23618].

O método ProcessSingleCall executa uma cifragem ou decifragem numa única chamada síncrona sem vetor de inicialização (IV) ([SWS_CRYPT_50047]). Como parâmetros de entrada servem o buffer de dados in (ReadOnlyMemRegion) e o sentido de transformação transformDirection (CryptoTransform), enquanto o resultado é escrito no buffer out (ReadWriteMemRegion). Em caso de execução bem-sucedida, a função retorna um ara::core::Result<std::size_t> que contém o número de bytes escritos; este valor pode ser menor do que a capacidade total do buffer de saída.

No que diz respeito à concorrência e à segurança, o método está especificado como thread-safe e exception safe ([SWS_CRYPT_50047]). O tamanho de entrada processável de in está sujeito aos limites definidos pelo contexto, os quais podem ser consultados através de [SWS_CRYPT_50144] (GetMinimumChunkSize) e [SWS_CRYPT_50050] (GetMaximumChunkSize).

Todos os casos de erro seguem uma semântica de rollback ([SWS_CRYPT_50047]):

• ara::crypto::CryptoErrc::kUninitializedContext: o contexto não foi inicializado previamente pela atribuição de uma chave.
• ara::crypto::CryptoErrc::kUnsupported: o processamento em chamada única não é suportado ou a transformação exige a definição ou a leitura de um IV.
• ara::crypto::CryptoErrc::kInsufficientCapacity: o buffer de saída out não disponibiliza capacidade suficiente.
• ara::crypto::CryptoErrc::kInvalidInputSize: o tamanho de entrada não pode ser processado pelo contexto.
• ara::crypto::CryptoErrc::kUsageViolation: a utilização da chave não cobre a operação solicitada (kAllowDataEncryption ou kAllowDataDecryption).
• ara::crypto::CryptoErrc::kIncompatibleObject, kEmptyKeySlot, kInvalidArgument ou kBusyResource: a chave é incompatível, o slot de chave está vazio, os dados de entrada são inválidos ou os recursos necessários estão ocupados.

Na interação com outras interfaces, a chamada requer um contexto completamente configurado; para cifras autenticadas com processamento de tag adicional, a interface alternativa [SWS_CRYPT_50078] está disponível em AuthCipherCtx.

O método ProcessSingleCallWithInputIv em ara::crypto::cryp::SymmetricCipherCtx executa uma cifragem ou decifragem simétrica de dados numa única chamada síncrona (single-call) [SWS_CRYPT_50048]. Neste processo, o vetor de inicialização utilizado para a transformação é passado explicitamente através do buffer de entrada iv.

Utilização e interação

Através de transformDirection, controla-se se os dados de in são cifrados ou decifrados. O resultado é escrito no buffer out. O ara::core::Result<std::size_t> retornado contém o número real de bytes escritos, o qual pode revelar-se inferior à capacidade total de out [SWS_CRYPT_50048].

Para o dimensionamento dos buffers, estão disponíveis funções auxiliares:

• O tamanho de buffer necessário para out pode ser calculado previamente através de GetRequiredOutputBufferSize com o parâmetro isFinal = true [SWS_CRYPT_50140].
• O comprimento permitido para iv pode ser determinado para o sentido de transformação selecionado através de GetMinimumInputIvSize [SWS_CRYPT_50141], bem como de GetMaximumInputIvSize [SWS_CRYPT_50142].
• Se adicionalmente for necessária a geração ou verificação de uma tag de autenticação, deve utilizar-se ara::crypto::cryp::AuthCipherCtx::ProcessSingleCallWithInputIv em seu lugar [SWS_CRYPT_50079].

Tratamento de erros e simultaneidade

A operação está definida como thread-safe e exception safe [SWS_CRYPT_50048]. Todos os erros possuem semântica de rollback:

• CryptoErrc::kUninitializedContext ou CryptoErrc::kEmptyKeySlot: nenhuma chave foi atribuída ao contexto ou o KeySlot está vazio [SWS_CRYPT_50048].
• CryptoErrc::kUsageViolation: a chave não permite o sentido selecionado (falta kAllowDataEncryption ou kAllowDataDecryption) [SWS_CRYPT_50048].
• CryptoErrc::kIncompatibleObject: o tipo de chave é incompatível com a transformação [SWS_CRYPT_50048].
• CryptoErrc::kInsufficientCapacity: o buffer de saída out é demasiado pequeno [SWS_CRYPT_50048].
• CryptoErrc::kInvalidInputSize ou CryptoErrc::kInvalidArgument: o tamanho do buffer ou o conteúdo de in são inválidos [SWS_CRYPT_50048].
• CryptoErrc::kUnsupported: o processamento em chamada única ou os IVs de entrada não são suportados [SWS_CRYPT_50048].
• CryptoErrc::kBusyResource: um recurso necessário está ocupado [SWS_CRYPT_50048].

O método Seek da interface ara::crypto::cryp::SymmetricCipherCtx define a posição do próximo byte a ser processado dentro de um fluxo de dados [SWS_CRYPT_23613]. Devido à ausência de tipos de retorno assíncronos, tais como futures, a chamada deve ocorrer de forma síncrona. Pergunta Q-fccf732722263f60 (aberta)

usar

O posicionamento é controlado através de dois parâmetros [SWS_CRYPT_23613]:

• offset: Deslocamento de bytes no fluxo de dados, referenciado em relação ao início do fluxo ou à posição atual [SWS_CRYPT_23613].
• fromBegin: Ponto de referência do posicionamento; true endereça o deslocamento a partir do início do fluxo, false relativamente à posição atual [SWS_CRYPT_23613].

A função é declarada como noexcept e retorna um ara::core::Result<void>, o qual sinaliza a conclusão bem-sucedida ou contém um objeto de erro ocorrido [SWS_CRYPT_23613].

Simultaneidade e restrições

De acordo com a especificação, Seek é classificado como seguro contra exceções (exception safe) e seguro para threads (thread-safe) [SWS_CRYPT_23613]. O pré-requisito para a execução é que o processamento de dados tenha sido iniciado previamente através da chamada de Start() [SWS_CRYPT_23613].

Tratamento de erros

Todos os casos de erro estão sujeitos a uma semântica de rollback definida (rollback_semantics), de modo que o estado interno permaneça consistente em caso de erros [SWS_CRYPT_23613]:

• ara::crypto::CryptoErrc::kUnsupported: A operação de seek não é suportada pelo contexto criptográfico atual [SWS_CRYPT_23613].
• ara::crypto::CryptoErrc::kProcessingNotStarted: O processamento de dados não foi iniciado previamente através de Start() [SWS_CRYPT_23613].
• ara::crypto::CryptoErrc::kOutOfBounds: O deslocamento resultante é pequeno demais ou grande demais para o fluxo de dados [SWS_CRYPT_23613].
• ara::crypto::CryptoErrc::kInvalidArgument: O offset resultante não está alinhado a um limite de bloco, embora o contexto exija alinhamento de bloco [SWS_CRYPT_23613].

O método puramente virtual SetKey configura a instância de ara::crypto::cryp::SymmetricCipherCtx de modo a que utilize a chave proveniente do KeySlot passado para operações criptográficas futuras [SWS_CRYPT_50043].

Utilização e contexto de chamada

A chamada ocorre de forma síncrona e recebe como parâmetro keySlot um KeySlot::Sptr que contém um SymmetricKey [SWS_CRYPT_50043]. O valor de retorno é um ara::core::Result<void>, o qual sinaliza o sucesso ou, em caso de erro, transporta um código de erro [SWS_CRYPT_50043]. A configuração faz com que a chave guardada no slot apenas seja utilizada no momento em que a cifragem ou decifragem propriamente dita for iniciada [SWS_CRYPT_50043].

Tratamento de erros

Em caso de erro, nenhuma exceção é lançada (o método está especificado como noexcept e exception safe), sendo retornado um código de erro com semântica de rollback [SWS_CRYPT_50043]:

• ara::crypto::CryptoErrc::kIncompatibleObject: o KeySlot passado é incompatível com o contexto de cifragem [SWS_CRYPT_50043].
• ara::crypto::CryptoErrc::kUnsupported: a implementação do contexto suporta exclusivamente a definição de uma chave direta (como SymmetricKey) e nenhuma atribuição através de um KeySlot [SWS_CRYPT_50043].

Concorrência e interação

O método está identificado como thread-safe [SWS_CRYPT_50043]. Interpretação: a leitura real do material de chave presumivelmente só deverá ocorrer ao iniciar a cifragem ou decifragem, de modo que o slot deve permanecer consistente até ao início da transformação. O conceito de configurar contextos através de KeySlot::Sptr em vez de objetos de chave diretos corresponde ao padrão uniforme de contextos criptográficos relacionados, entre os quais KeyDerivationFunctionCtx [SWS_CRYPT_50010], MessageAuthnCodeCtx [SWS_CRYPT_50026], SymmetricKeyWrapperCtx [SWS_CRYPT_50034], bem como VerifierPublicCtx [SWS_CRYPT_50018]. Pergunta Q-799125800ab0f93c (aberta)

usar

O método SetKey serve para configurar uma instância de ara::crypto::cryp::SymmetricCipherCtx para a utilização de uma chave simétrica passada [SWS_CRYPT_50138]. Como parâmetro de entrada, a função recebe a chave a utilizar como smart pointer key do tipo SymmetricKey::Sptr. A chamada efetua-se de forma síncrona e retorna um ara::core::Result<void>, que está vazio em caso de atribuição bem-sucedida ou disponibiliza um código de erro em caso de falha [SWS_CRYPT_50138]. A declaração está incluída através do cabeçalho ara/crypto/cryp/symmetric_cipher_ctx.h.

Tratamento de erros

O tratamento de erros garante semântica de rollback, de modo que o contexto permaneça no seu estado anterior em caso de falha da atribuição [SWS_CRYPT_50138]. Estão definidos dois erros específicos:

• ara::crypto::CryptoErrc::kUnsupported: Ocorre quando o contexto suporta exclusivamente a atribuição de uma chave através de um KeySlot [SWS_CRYPT_50138].
• ara::crypto::CryptoErrc::kIncompatibleObject: É retornado quando o objeto de chave passado não é compatível com o contexto [SWS_CRYPT_50138].

Concorrência e interação

A função virtual está definida como noexcept, é considerada exception-safe e está implementada como thread-safe de acordo com a especificação [SWS_CRYPT_50138]. Interfaces semelhantes para a atribuição de SymmetricKey::Sptr encontram-se em contextos criptográficos relacionados, como AuthCipherCtx [SWS_CRYPT_23911] bem como SymmetricKeyWrapperCtx [SWS_CRYPT_24018]. A interação com contentores de chave é também ilustrada por classes de contexto que, em alternativa, aceitam KeySlot::Sptr [SWS_CRYPT_50034].

usar

O método Start inicializa o contexto ara::crypto::cryp::SymmetricCipherCtx para uma nova operação síncrona de cifragem ou decifragem e define o respectivo vetor de inicialização (IV) ou valor de nonce [SWS_CRYPT_23625]. A direção de transformação é especificada através do parâmetro transformDirection, enquanto iv disponibiliza o vetor de inicialização como ReadOnlyMemRegion [SWS_CRYPT_23625]. O tamanho permitido do buffer pode ser consultado previamente através dos métodos GetMinimumInputIvSize() e GetMaximumInputIvSize() [SWS_CRYPT_23625]. A chamada retorna um ara::core::Result<void>, é declarada como noexcept e é considerada segura contra exceções (exception safe) [SWS_CRYPT_23625].

Tratamento de erros

Em caso de erro, é retornado um código de erro com semântica de rollback [SWS_CRYPT_23625]:

• ara::crypto::CryptoErrc::kUninitializedContext: O contexto não foi inicializado previamente através da atribuição de uma chave [SWS_CRYPT_23625].
• ara::crypto::CryptoErrc::kInvalidInputSize: O tamanho de IV fornecido não é suportado [SWS_CRYPT_23625].
• ara::crypto::CryptoErrc::kUnsupported: A definição de um IV na direção de transformação especificada ou o processamento em fluxo não é suportado pelo contexto [SWS_CRYPT_23625].
• ara::crypto::CryptoErrc::kEmptyKeySlot: Um KeySlot configurado está atualmente vazio [SWS_CRYPT_23625].
• ara::crypto::CryptoErrc::kUsageViolation: O uso permitido da chave não inclui kAllowDataEncryption para a cifragem ou kAllowDataDecryption para a decifragem [SWS_CRYPT_23625].
• ara::crypto::CryptoErrc::kIncompatibleObject: O tipo de chave é incompatível com a transformação ou com a direção de transformação [SWS_CRYPT_23625].
• ara::crypto::CryptoErrc::kBusyResource: um recurso necessário está ocupado [SWS_CRYPT_23625].

Concorrência e interação

A função está especificada como segura para threads (thread-safe) [SWS_CRYPT_23625]. No fluxo de um processamento em stream, Start atua como passo iniciador, ao qual se seguem, por exemplo, operações de posicionamento via Seek [SWS_CRYPT_23613] ou a finalização através de FinishEncrypt [SWS_CRYPT_23618].

usar

O método Start inicializa uma instância de ara::crypto::cryp::SymmetricCipherCtx de forma síncrona para uma criptografia ou descriptografia pendente ([SWS_CRYPT_50044]). Ele é utilizado quando não é necessário nenhum vetor de inicialização (IV) para a direção de transformação pré-definida através do parâmetro transformDirection ou quando o próprio contexto o gera ([SWS_CRYPT_50044]). Se, pelo contrário, o contexto exigir um IV explícito na direção selecionada, a sobrecarga com o parâmetro IV deve ser chamada ([SWS_CRYPT_23625]).

Tratamento de erros e simultaneidade

A operação é especificada como segura para threads e segura contra exceções ([SWS_CRYPT_50044]). Em caso de erro, a função retorna um ara::core::Result<void> com semântica de rollback ([SWS_CRYPT_50044]). Causas de erro relevantes são:

• ara::crypto::CryptoErrc::kUninitializedContext: Nenhuma chave foi atribuída previamente ao contexto ([SWS_CRYPT_50044]).
• ara::crypto::CryptoErrc::kUnsupported: O processamento de stream não é suportado ou a operação exige obrigatoriamente a definição de um IV nessa direção ([SWS_CRYPT_50044]).
• ara::crypto::CryptoErrc::kUsageViolation: A chave não possui a permissão necessária kAllowDataEncryption ou kAllowDataDecryption ([SWS_CRYPT_50044]).
• ara::crypto::CryptoErrc::kIncompatibleObject ou ara::crypto::CryptoErrc::kEmptyKeySlot: O tipo de chave não corresponde à transformação ou o espaço de chave configurado está vazio ([SWS_CRYPT_50044]).
• ara::crypto::CryptoErrc::kBusyResource: Um recurso necessário está ocupado no momento ([SWS_CRYPT_50044]).

Interação

Após a inicialização bem-sucedida, o fluxo de dados pode ser posicionado através de Seek, se necessário ([SWS_CRYPT_23613]). Se o IV tiver sido definido pelo próprio contexto, este será entregue ao chamador ao final da criptografia através de FinishEncrypt ([SWS_CRYPT_23618]).

O método síncrono Update() serve em ara::crypto::cryp::SymmetricCipherCtx para encriptar ou desencriptar passo a passo fluxos de dados parciais [SWS_CRYPT_50139]. Processa um buffer de entrada in (tipo ReadOnlyMemRegion) com texto em claro ou texto cifrado e escreve os dados transformados no buffer de saída out (tipo ReadWriteMemRegion) [SWS_CRYPT_50139]. Em caso de sucesso, o valor de retorno ara::core::Result<std::size_t> fornece o número exato de bytes efetivamente escritos em out, que pode ser inferior à capacidade total do buffer de destino [SWS_CRYPT_50139].

Aplicam-se à chamada pré-condições definidas e regras de buffer:

• Ordem de execução: O processamento de dados tem de ter sido obrigatoriamente iniciado previamente com o método Start(); caso contrário, a chamada falha com ara::crypto::CryptoErrc::kProcessingNotStarted [SWS_CRYPT_50139].
• Dimensionamento do buffer: O tamanho máximo de entrada permitido por chamada individual pode ser determinado através de GetMaximumChunkSize() [SWS_CRYPT_50050]; o método responde a tamanhos de buffer inválidos com ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_50139]. O buffer de saída necessário pode ser consultado através de GetRequiredOutputBufferSize() [SWS_CRYPT_50139]; um buffer demasiado pequeno leva a ara::crypto::CryptoErrc::kInsufficientCapacity [SWS_CRYPT_50139].
• Suporte de streaming: Se o contexto concreto não suportar processamento de stream contínuo, a chamada falha com ara::crypto::CryptoErrc::kUnsupported [SWS_CRYPT_50139].

A interface está especificada como thread-safe e exception safe e garante semântica de rollback em qualquer erro [SWS_CRYPT_50139]. No ciclo de processamento, interage com GetMaximumChunkSize() bem como com operações de finalização como Finish() ou FinishEncrypt() [SWS_CRYPT_50050].