clase ara::crypto::cryp::AuthCipherCtx

usar

El método Cancel() de la interfaz ara::crypto::cryp::AuthCipherCtx cancela una operación de streaming activa que se inició previamente mediante Start() y aún no ha concluido [SWS_CRYPT_50077]. La función se proporciona a través de la cabecera ara/crypto/cryp/auth_cipher_ctx.h y opera sincrónicamente sin parámetros de entrada [SWS_CRYPT_50077]. Devuelve un ara::core::Result<void>, que está vacío en caso de éxito.

Tratamiento de errores y condiciones límite

Una cancelación presupone que el procesamiento de datos se haya iniciado efectivamente con anterioridad mediante Start(). Si la operación de streaming no se inició, la llamada falla y devuelve el código de error ara::crypto::CryptoErrc::kProcessingNotStarted con semántica de reversión [SWS_CRYPT_50077].

concurrencia

La operación está declarada como noexcept y, según la especificación, está clasificada tanto como thread-safe como exception safe [SWS_CRYPT_50077].

Interacción

El patrón de cancelación implementado por Cancel() está estandarizado en el módulo crypt. Se han definido una semántica de interfaz idéntica y el mismo código de error ara::crypto::CryptoErrc::kProcessingNotStarted para los contextos de streaming correspondientes:

• 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]

El método síncrono EncryptSingleCallWithOutputIv de la interfaz ara::crypto::cryp::AuthCipherCtx ejecuta un cifrado autenticado en un solo paso y genera de forma autónoma un vector de inicialización [SWS_CRYPT_50080]. Procesa datos de entrada de dataIn así como datos adicionales opcionales authenticatedData y escribe el criptograma en el búfer dataOut. El vector de inicialización generado se almacena en el búfer ivOut, mientras que la etiqueta de autenticación se emite a través de tag [SWS_CRYPT_50080]. El tamaño de búfer para ivOut se puede determinar previamente mediante el método GetOutputIvSize [SWS_CRYPT_50165]. A pesar del componente del nombre Encrypt, es de suponer que el método probablemente también se pueda utilizar para el descifrado, ya que la especificación de errores detalla explícitamente el comportamiento para transformDirection == kDecrypt [SWS_CRYPT_50080]. Pregunta Q-66618567b20f99b9 (abierta)

Para la llamada se aplican condiciones previas y restricciones esenciales:

• El contexto debe haberse inicializado previamente con éxito mediante SetKey; de lo contrario, se notifica kUninitializedContext [SWS_CRYPT_50080].
• La clave en el Key-Slot configurado debe ser compatible y presentar el permiso adecuado (p. ej., kAllowDataEncrypt); de lo contrario, se devuelve kUsageViolation o kIncompatibleObject [SWS_CRYPT_50080].
• Si los búferes de salida dataOut o ivOut no son suficientes, la llamada falla con kInsufficientCapacity [SWS_CRYPT_50080].
• Si el contexto no soporta el procesamiento en un solo paso o requiere una especificación externa de IV, se devuelve kUnsupported [SWS_CRYPT_50080].

La operación está especificada como thread-safe así como segura frente a excepciones y garantiza semántica de reversión en caso de error [SWS_CRYPT_50080]. Para cifrados simétricos puros sin procesamiento de etiquetas existe un homólogo independiente en SymmetricCipherCtx [SWS_CRYPT_50049].

Uso y semántica

El método Finish finaliza síncronamente el cifrado o descifrado dentro de un ara::crypto::cryp::AuthCipherCtx y calcula o comprueba la etiqueta de autenticación sin devolver un vector de inicialización (IV) [SWS_CRYPT_50075]. El llamador pasa los datos restantes a través del búfer in así como el búfer de destino out. A través del búfer tag se entrega la etiqueta calculada en el cifrado, mientras que en el descifrado se pasa la etiqueta que se va a comprobar [SWS_CRYPT_50075]. El valor de retorno ara::core::Result<std::size_t> cuantifica los bytes realmente escritos en out, que pueden ser menos que la capacidad del búfer de salida [SWS_CRYPT_50075].

Secuencia e interacción

Antes de la llamada, el procesamiento de datos debe haberse iniciado obligatoriamente mediante Start() [SWS_CRYPT_50075]. Si previamente se procesaron bloques de datos mediante UpdateConfidentialData, una aplicación solo debe utilizar el texto en claro resultante en el descifrado tras una autenticación correcta mediante Finish [SWS_CRYPT_50074]. El tamaño de búfer máximo requerido para out se puede determinar previamente mediante GetRequiredOutputBufferSize indicando isFinal = true [SWS_CRYPT_50081].

Tratamiento de errores y concurrencia

El método está especificado como seguro para subprocesos y seguro frente a excepciones [SWS_CRYPT_50075]. Los errores se notifican mediante ara::core::Result con semántica de reversión [SWS_CRYPT_50075]:

• ProcessingNotStarted: El procesamiento de datos no se inició previamente con Start() [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kInsufficientCapacity: El búfer de salida out es demasiado pequeño [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kInvalidInputSize: El tamaño de búfer de in o tag no es válido [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kAuthTagNotValid: No se puede confirmar la autenticidad de los datos durante el descifrado [SWS_CRYPT_50075].
• ara::crypto::CryptoErrc::kUnsupported: El procesamiento en flujo no está soportado por el contexto [SWS_CRYPT_50075].

usar

El método FinishEncrypt concluye de forma síncrona una operación de cifrado autenticado en ara::crypto::cryp::AuthCipherCtx, calcula la etiqueta de autenticación y devuelve a través de ivOut el vector de inicialización generado por el contexto [SWS_CRYPT_50076]. La llamada está especificada como segura frente a hilos y segura frente a excepciones (exception safe) [SWS_CRYPT_50076]. Como resultado, la función devuelve un ara::core::Result<std::size_t> con el número de bytes realmente escritos en el búfer de salida out, pudiendo ser el tamaño de salida menor que la capacidad del búfer [SWS_CRYPT_50076]. Interpretación: Aunque el nombre apunta a un cifrado, la especificación del parámetro tag así como el código de error ara::crypto::CryptoErrc::kAuthTagNotValid indican que es probable que la firma en el contexto se utilice también simétricamente para operaciones de descifrado. Pregunta Q-6b924f12c32e0f33 (abierta)

Interacción y dimensionamiento del búfer

El procesamiento de datos debe haberse iniciado obligatoriamente de forma previa con Start(); de lo contrario, la función notifica el error ProcessingNotStarted [SWS_CRYPT_50076]. Para el dimensionamiento del búfer debe tenerse en cuenta la interacción con las siguientes funciones del contexto:

• La capacidad máxima requerida para out puede calcularse de antemano a través de [SWS_CRYPT_50081] con el parámetro isFinal = true a fin de evitar el error ara::crypto::CryptoErrc::kInsufficientCapacity [SWS_CRYPT_50076].
• El tamaño de búfer mínimo y máximo para los datos de entrada in se determina mediante [SWS_CRYPT_50162] y [SWS_CRYPT_50082].
• El tamaño de búfer necesario para albergar el vector de inicialización generado en ivOut puede consultarse a través de [SWS_CRYPT_50165].

Tratamiento de errores y condiciones límite

En caso de error, todas las respuestas poseen una semántica de reversión definida [SWS_CRYPT_50076]. Si los tamaños de búfer son inválidos para datos de entrada o para la etiqueta de autenticación, se devuelve ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_50076]. Además, la función devuelve ara::crypto::CryptoErrc::kUnsupported si no se admite el procesamiento por secuencias, no se utiliza ningún IV o la aplicación ya especificó el IV al inicio [SWS_CRYPT_50076].

El método ProcessSingleCall de ara::crypto::cryp::AuthCipherCtx, síncrono y definido como seguro para subprocesos, ejecuta el cifrado o descifrado de datos útiles y el cálculo o la verificación simultáneos de la etiqueta de autenticación en una sola operación sin vector de inicialización (IV) [SWS_CRYPT_50078]. A través del búfer opcional authenticatedData se pueden proporcionar datos autenticados adicionales [SWS_CRYPT_50078]. El búfer tag sirve como entrada para la verificación en el descifrado y como salida para almacenar la etiqueta de autenticación generada en el cifrado [SWS_CRYPT_50078]. En caso de procesamiento correcto, ara::core::Result<std::size_t> devuelve el número real de bytes escritos en dataOut, que puede ser menor que la capacidad del búfer de destino [SWS_CRYPT_50078].

Antes de la llamada, el contexto criptográfico debe haberse inicializado mediante una llamada exitosa a SetKey; de lo contrario, la función falla con ara::crypto::CryptoErrc::kUninitializedContext [SWS_CRYPT_50078]. Además, la clave utilizada debe estar habilitada para la dirección de transformación solicitada (kAllowDataEncrypt o kAllowDataDecrypt), ya que de lo contrario se notifica ara::crypto::CryptoErrc::kUsageViolation [SWS_CRYPT_50078]. Si no se admite el procesamiento en un solo paso o si el contexto requiere un IV, la función devuelve ara::crypto::CryptoErrc::kUnsupported [SWS_CRYPT_50078]. Si la autenticación falla durante el descifrado, se desencadena ara::crypto::CryptoErrc::kAuthTagNotValid [SWS_CRYPT_50078]. Los errores en la ranura de clave asignada se señalan mediante EmptyKeySlot, ara::crypto::CryptoErrc::kBusyResource o ara::crypto::CryptoErrc::kIncompatibleObject [SWS_CRYPT_50078].

Para la gestión de búferes, el tamaño de salida máximo requerido para dataOut puede calcularse previamente mediante GetRequiredOutputBufferSize con el flag isFinal = true establecido [SWS_CRYPT_50081]; un búfer de salida demasiado pequeño da lugar a ara::crypto::CryptoErrc::kInsufficientCapacity [SWS_CRYPT_50078]. Adicionalmente, el tamaño de dataIn debe corresponder a los límites de GetMinimumChunkSize [SWS_CRYPT_50162] y GetMaximumChunkSize [SWS_CRYPT_50082] para evitar ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_50078].

El método [SWS_CRYPT_50079] de la clase ara::crypto::cryp::AuthCipherCtx lleva a cabo un procesamiento síncrono en un solo paso (single-call) para el cifrado o descifrado de datos con el cálculo o la comprobación simultáneos de la etiqueta de autenticación.

En la llamada, los datos de entrada se especifican mediante dataIn y la dirección mediante transformDirection. El vector de inicialización se pasa a través de iv, y se pueden proporcionar datos de autenticación opcionales mediante authenticatedData [SWS_CRYPT_50079]. El búfer tag sirve en el caso de cifrado como salida para la etiqueta calculada y en el caso de descifrado como entrada para la verificación [SWS_CRYPT_50079]. En caso de éxito, el valor de retorno ara::core::Result<std::size_t> proporciona el número de bytes escritos en dataOut, que puede ser menor que la capacidad del búfer [SWS_CRYPT_50079].

En caso de error, todos los códigos de error poseen semántica de reversión [SWS_CRYPT_50079]:

• ara::crypto::CryptoErrc::kUninitializedContext: No se configuró previamente ninguna clave mediante SetKey [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kUsageViolation: La clave no posee el permiso requerido kAllowDataEncrypt o kAllowDataDecrypt [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kEmptyKeySlot, ara::crypto::CryptoErrc::kBusyResource o ara::crypto::CryptoErrc::kIncompatibleObject: Un KeySlot configurado está vacío, ocupado o no contiene un SymmetricKey compatible [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kInvalidInputSize o ara::crypto::CryptoErrc::kInsufficientCapacity: Los búferes para entrada, etiqueta o IV están dimensionados de forma no válida o dataOut ofrece una capacidad insuficiente [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kAuthTagNotValid: En el descifrado falla la autenticación [SWS_CRYPT_50079].
• ara::crypto::CryptoErrc::kUnsupported: El procesamiento de disparo único (single-shot) no está soportado por el contexto o el contexto requiere establecer o emitir un IV [SWS_CRYPT_50079].

La operación está definida como thread-safe y exception safe [SWS_CRYPT_50079]. Las longitudes admisibles para iv se pueden consultar dinámicamente mediante GetMinimumInputIvSize [SWS_CRYPT_50163] y GetMaximumInputIvSize [SWS_CRYPT_50164]. En comparación con el cifrado por bloques puro en SymmetricCipherCtx [SWS_CRYPT_50048], esta interfaz vincula la transformación criptográfica y la comprobación de integridad en una sola llamada.

El método SetKey configura la instancia de ara::crypto::cryp::AuthCipherCtx para el uso de una clave simétrica pasada [SWS_CRYPT_23911]. Como parámetro se pasa un puntero compartido key (de tipo SymmetricKey::Sptr), que se utiliza para el cifrado o descifrado autenticado [SWS_CRYPT_23911]. La llamada se realiza de forma síncrona, está declarada como noexcept y devuelve un ara::core::Result<void> [SWS_CRYPT_23911].

En caso de error, el resultado se restablece con semántica de rollback y proporciona códigos de error específicos [SWS_CRYPT_23911]:

• ara::crypto::CryptoErrc::kUnsupported: en caso de que el contexto admita exclusivamente la configuración mediante un KeySlot [SWS_CRYPT_23911].
• ara::crypto::CryptoErrc::kIncompatibleObject: cuando el tipo de clave pasado no es compatible con el contexto actual [SWS_CRYPT_23911].
• ara::crypto::CryptoErrc::kUsageViolation: cuando los flags de uso permitidos de la clave no contienen kAllowDataEncrypt para cifrado o kAllowDataDecrypt para descifrado [SWS_CRYPT_23911].

Según la especificación, la interfaz está clasificada como segura para subprocesos (thread-safe) y segura frente a excepciones (exception safe) [SWS_CRYPT_23911]. En interacción con el contexto del módulo, es de suponer que la clave se establezca antes de la inicialización de una nueva transformación a través de Start [SWS_CRYPT_24715]. Pregunta Q-11f7daa370f5d438 (abierta)

La función SetKey en la interfaz ara::crypto::cryp::AuthCipherCtx configura el contexto para operaciones criptográficas de modo que se utilice la clave simétrica almacenada en un key slot proporcionado tan pronto como se ejecute el cifrado o descifrado autenticado [SWS_CRYPT_50072].

Uso: La llamada síncrona se realiza a través de la interfaz de ara/crypto/cryp/auth_cipher_ctx.h. Como parámetro keySlot se pasa una instancia de KeySlot::Sptr que encapsula una clave simétrica [SWS_CRYPT_50072]. La función devuelve un ara::core::Result<void> que confirma el éxito o contiene un código de error [SWS_CRYPT_50072].

Tratamiento de errores: Si la implementación concreta del contexto solo admite la configuración directa mediante un objeto SymmetricKey y no ofrece el establecimiento a través de KeySlot, la llamada fallará. En este caso se devuelve el error ara::crypto::CryptoErrc::kUnsupported con semántica de reversión [SWS_CRYPT_50072].

Concurrencia y restricciones: La función está especificada como thread-safe y exception safe [SWS_CRYPT_50072]. Puede llamarse de forma concurrente y asegura que, en situaciones de excepción, no permanezca ningún estado inconsistente.

Interacción: Como alternativa funcional está disponible la sobrecarga SetKey con un SymmetricKey::Sptr directo [SWS_CRYPT_23911]. Una vez efectuada la vinculación de clave, el contexto se inicializa a través de Start con la dirección de la operación así como el vector de inicialización [SWS_CRYPT_24715]. Existen asimismo firmas análogas con KeySlot::Sptr en MessageAuthnCodeCtx [SWS_CRYPT_50026] y SymmetricKeyWrapperCtx [SWS_CRYPT_50034].

El método Start inicializa el contexto ara::crypto::cryp::AuthCipherCtx para un nuevo cifrado o descifrado y establece el vector de inicialización (IV) o valor nonce que se va a utilizar [SWS_CRYPT_24715]. Mediante el parámetro transformDirection se define la dirección de transformación, mientras que iv pasa el vector como ReadOnlyMemRegion [SWS_CRYPT_24715]. El tamaño de IV admisible se puede determinar a través de GetMinimumInputIvSize() y GetMaximumInputIvSize(); en caso de longitud divergente, la función notifica el error ara::crypto::CryptoErrc::kInvalidInputSize [SWS_CRYPT_24715].

Antes de la llamada, SetKey debe haberse ejecutado con éxito; de lo contrario, se devuelve ara::crypto::CryptoErrc::kUninitializedContext [SWS_CRYPT_24715]. Un KeySlot configurado no debe estar ni vacío (EmptyKeySlot) ni ocupado (ara::crypto::CryptoErrc::kBusyResource) [SWS_CRYPT_24715]. Además, la clave almacenada debe ser un SymmetricKey adecuado (de lo contrario, ara::crypto::CryptoErrc::kIncompatibleObject) y estar autorizada para la dirección deseada (kAllowDataEncrypt o kAllowDataDecrypt; de lo contrario, ara::crypto::CryptoErrc::kUsageViolation) [SWS_CRYPT_24715]. Si falta la compatibilidad con el procesamiento en flujo (stream) o con el establecimiento de un IV en la dirección seleccionada, la llamada falla con ara::crypto::CryptoErrc::kUnsupported [SWS_CRYPT_24715]. Todos los errores presentan semántica de rollback [SWS_CRYPT_24715].

La operación está declarada como thread-safe y exception-safe (noexcept) [SWS_CRYPT_24715]. En la interacción de secuencias criptográficas, tras una inicialización exitosa típicamente seguiría la transferencia de datos autenticados adicionales a través de UpdateAuthenticatedData [SWS_CRYPT_20313]. Pregunta Q-e023e27f1cd24507 (abierta)

usar

El método puramente virtual Start de la clase ara::crypto::cryp::AuthCipherCtx inicializa el contexto de forma síncrona para un cifrado o descifrado pendiente [SWS_CRYPT_50073]. Mediante el parámetro transformDirection se indica si el contexto se prepara para cifrado o descifrado. Esta sobrecarga sin vector de inicialización (IV) solo puede utilizarse si el contexto criptográfico no requiere un IV en la dirección de transformación seleccionada o si lo determina él mismo [SWS_CRYPT_50073]. El valor de retorno es un ara::core::Result<void> vacío en caso de éxito o un código de error correspondiente.

Tratamiento de errores y precondiciones

Antes de la llamada, el contexto debe haberse configurado correctamente a través de SetKey con una clave; de lo contrario, la función fallará con ara::crypto::CryptoErrc::kUninitializedContext [SWS_CRYPT_50073]. Además, en caso de error se producen los siguientes valores de retorno:

• ara::crypto::CryptoErrc::kUnsupported, si el contexto no admite el procesamiento por secuencias (stream) o si el contexto exige obligatoriamente la indicación explícita de un IV en la dirección de transformación seleccionada [SWS_CRYPT_50073].
• ara::crypto::CryptoErrc::kUsageViolation, si el uso permitido de la clave en el KeySlot configurado en el momento de la llamada no incluye el permiso necesario kAllowDataEncrypt para el cifrado o bien kAllowDataDecrypt para el descifrado [SWS_CRYPT_50073].
• EmptyKeySlot o bien ara::crypto::CryptoErrc::kBusyResource, en caso de que un KeySlot configurado esté actualmente vacío o bloqueado [SWS_CRYPT_50073].
• ara::crypto::CryptoErrc::kIncompatibleObject, si el KeySlot configurado no contiene ningún SymmetricKey o si este tipo de clave no es compatible con el contexto [SWS_CRYPT_50073].

Si se produce un error, se aplica la semántica de reversión especificada (rollback_semantics) [SWS_CRYPT_50073].

Concurrencia e interacción

La función está declarada con noexcept=0, garantiza la seguridad frente a excepciones y está diseñada de forma segura frente a hilos [SWS_CRYPT_50073]. Si el algoritmo exige la provisión externa de un vector de inicialización, debe utilizarse en su lugar la sobrecarga Start(CryptoTransform, ReadOnlyMemRegion) [SWS_CRYPT_24715]. Tras una inicialización correcta, pueden incorporarse datos autenticados adicionales a través de UpdateAuthenticatedData en el cálculo de la etiqueta de autenticación [SWS_CRYPT_20313].

El método UpdateAuthenticatedData de la interfaz ara::crypto::cryp::AuthCipherCtx sirve para actualizar el cálculo de la etiqueta de autenticación paso a paso con un fragmento adicional de datos autenticados adicionales (Additional Authenticated Data) [SWS_CRYPT_20313]. A través del parámetro authenticatedData se transmite el búfer correspondiente como ReadOnlyMemRegion [SWS_CRYPT_20313].

En cuanto al contexto de llamada y la concurrencia, la operación está definida como thread-safe, así como exception safe [SWS_CRYPT_20313]. Para la llamada rigen condiciones estrictas de orden:

• La transformación debe haberse iniciado previamente a través del método Start(); de lo contrario, se notifica ara::crypto::CryptoErrc::kProcessingNotStarted [SWS_CRYPT_20313].
• La función ya no debe llamarse si UpdateConfidentialData ya se ha ejecutado; en caso de incumplimiento, se devuelve el error ara::crypto::CryptoErrc::kInvalidUsageOrder [SWS_CRYPT_20313].

Como valor de retorno, la función proporciona un ara::core::Result<void> que está vacío en caso de éxito o encapsula un código de error producido [SWS_CRYPT_20313]. Todos los errores presentan semántica de reversión (rollback) [SWS_CRYPT_20313]:

• ara::crypto::CryptoErrc::kInvalidInputSize: el tamaño del búfer de entrada transmitido no es válido [SWS_CRYPT_20313].
• ara::crypto::CryptoErrc::kUnsupported: el procesamiento de flujo (stream) no es admitido por el contexto actual [SWS_CRYPT_20313].

El método UpdateConfidentialData de la clase ara::crypto::cryp::AuthCipherCtx sirve para el cifrado o descifrado paso a paso de datos útiles confidenciales en el marco de un contexto de cifrado autenticado [SWS_CRYPT_50074]. Se le pasan el búfer de entrada in (tipo ReadOnlyMemRegion) con una parte del texto en claro o cifrado, así como el búfer de salida out (tipo ReadWriteMemRegion) [SWS_CRYPT_50074]. Como valor de retorno síncrono, la función devuelve un ara::core::Result<std::size_t>, el cual contiene en caso de éxito el número de bytes realmente escritos; este puede ser inferior a la capacidad de out [SWS_CRYPT_50074].

En lo que respecta a la secuencia y a la concurrencia, se aplican las siguientes condiciones:

• Secuencia de ejecución e integridad: antes del procesamiento, el proceso debe haberse iniciado mediante Start() [SWS_CRYPT_50074]. Si el método se utiliza para el descifrado, el texto en claro se emite sin comprobación previa de autenticidad; la aplicación no debe utilizar en ningún caso estos datos antes de la verificación final mediante Finish() [SWS_CRYPT_50074]. Se pueden incorporar datos autenticados adicionales de forma paralela en el cálculo de la etiqueta a través de UpdateAuthenticatedData [SWS_CRYPT_20313].
• Seguridad de subprocesos y frente a excepciones: la operación está declarada como thread-safe y exception-safe, y no lanza excepciones (noexcept) [SWS_CRYPT_50074].

Si el procesamiento falla, se aplica la semántica de reversión devolviendo un código de error correspondiente en ara::core::Result [SWS_CRYPT_50074]:

• ara::crypto::CryptoErrc::kProcessingNotStarted: El procesamiento todavía no se ha iniciado mediante Start() [SWS_CRYPT_50074].
• ara::crypto::CryptoErrc::kInsufficientCapacity: El búfer de salida out tiene unas dimensiones demasiado pequeñas [SWS_CRYPT_50074].
• ara::crypto::CryptoErrc::kInvalidInputSize: El tamaño del búfer in no es válido [SWS_CRYPT_50074].
• ara::crypto::CryptoErrc::kUnsupported: El procesamiento de flujo no es compatible con el contexto [SWS_CRYPT_50074].