clase ara::crypto::cryp::CryptoProvider

El método CreateAuthCipherCtx sirve para crear un contexto para cifrado autenticado simétrico ([SWS_CRYPT_20745]). Está definido como interfaz virtual pura en la clase ara::crypto::cryp::CryptoProvider y debe incluirse a través del archivo de cabecera ara/crypto/cryp/crypto_provider.h ([SWS_CRYPT_20745]).

Uso y semántica

Como parámetro de entrada se pasa algId, que identifica el algoritmo criptográfico de destino ([SWS_CRYPT_20745]). La función opera de forma síncrona y no genera excepciones (noexcept) ([SWS_CRYPT_20745]). En caso de ejecución correcta, devuelve un ara::core::Result con un puntero inteligente a la instancia creada AuthCipherCtx::Sptr ([SWS_CRYPT_20745]).

Manejo de errores

En caso de error, se devuelve el código de error correspondiente en el ara::core::Result con semántica de reversión ([SWS_CRYPT_20745]):

• ara::crypto::CryptoErrc::kInvalidArgument: Si algId no especifica un algoritmo para un cifrado de flujo autenticado simétrico ([SWS_CRYPT_20745]).
• ara::crypto::CryptoErrc::kUnknownIdentifier: Si se ha pasado un valor no compatible para algId ([SWS_CRYPT_20745]).

concurrencia

La llamada a CreateAuthCipherCtx es segura para subprocesos (thread-safe) y está especificada como segura frente a excepciones (exception safe) ([SWS_CRYPT_20745]).

usar

El método CreateDecryptorPrivateCtx de la interfaz ara::crypto::cryp::CryptoProvider sirve para crear un contexto para el descifrado asimétrico utilizando una clave privada según [SWS_CRYPT_20751]. Como parámetro de entrada, la función espera algId, que determina el identificador del algoritmo de cifrado o descifrado asimétrico deseado. Interpretación: Se asume que la llamada se ejecuta de forma síncrona, ya que la signatura devuelve directamente un ara::core::Result que, en caso de éxito, contiene un puntero inteligente al contexto creado (DecryptorPrivateCtx::Sptr) [SWS_CRYPT_20751]. Pregunta Q-45d1c4a1b2133f4c (abierta)

Manejo de errores

Si el contexto no puede crearse, el error se transmite en el ara::core::Result devuelto. Si se ha pasado un valor no compatible para el parámetro algId, esto da como resultado específicamente el código de error ara::crypto::CryptoErrc::kUnknownIdentifier con semántica de reversión [SWS_CRYPT_20751].

Concurrencia y restricciones

La función está definida como noexcept y garantiza seguridad frente a excepciones (exception safe) [SWS_CRYPT_20751]. Para el acceso simultáneo desde múltiples subprocesos, el método está especificado como thread-safe [SWS_CRYPT_20751]. Dado que la signatura está declarada en la cabecera ara/crypto/cryp/crypto_provider.h como método virtual puro, la concreción específica corresponde a la respectiva implementación del proveedor [SWS_CRYPT_20751].

El método de interfaz virtual puro CreateEncryptorPublicCtx pertenece a la clase ara::crypto::cryp::CryptoProvider y se declara a través del archivo de cabecera ara/crypto/cryp/crypto_provider.h [SWS_CRYPT_20750]. Su cometido consiste en instanciar un nuevo contexto para operaciones de cifrado asimétrico con una clave pública [SWS_CRYPT_20750].

Uso: La llamada se realiza de forma síncrona indicando el parámetro algId de tipo AlgId, que determina el identificador del algoritmo de cifrado o descifrado asimétrico deseado [SWS_CRYPT_20750]. El método devuelve el resultado en un ara::core::Result que, en caso de éxito, proporciona un puntero inteligente de tipo EncryptorPublicCtx::Sptr al contexto creado [SWS_CRYPT_20750].

Tratamiento de errores: Si el argumento algId contiene un valor de algoritmo no compatible, la llamada falla y devuelve el código de error ara::crypto::CryptoErrc::kUnknownIdentifier en el ara::core::Result [SWS_CRYPT_20750]. Para este caso de error se ha especificado una semántica de reversión explícita [SWS_CRYPT_20750].

Concurrencia y seguridad frente a excepciones: La interfaz está declarada como noexcept, se considera segura frente a excepciones (exception safe) y está especificada expresamente como segura para subprocesos (thread-safe) [SWS_CRYPT_20750].

El método CreateHashFunctionCtx sirve para instanciar un contexto de hash criptográfico ([SWS_CRYPT_20747]). Se proporciona como interfaz virtual pura de la clase ara::crypto::cryp::CryptoProvider a través de la cabecera ara/crypto/cryp/crypto_provider.h.

Uso y parámetros

La llamada se realiza de forma síncrona y espera como parámetro de entrada algId (de tipo AlgId), que identifica el algoritmo criptográfico deseado ([SWS_CRYPT_20747]). Como valor de retorno, la función proporciona un ara::core::Result<HashFunctionCtx::Sptr> que, en caso de éxito, contiene un puntero inteligente al contexto creado.

Manejo de errores

Si la creación falla, el ara::core::Result contiene un código de error correspondiente con semántica de reversión ([SWS_CRYPT_20747]):

• ara::crypto::CryptoErrc::kInvalidArgument: Se devuelve si la algId pasada está especificada para un tipo de algoritmo distinto a una función hash ([SWS_CRYPT_20747]).
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se produce si se ha pasado un identificador no compatible para algId ([SWS_CRYPT_20747]).

Concurrencia y restricciones

La función está declarada como noexcept y especificada como segura frente a excepciones («exception safe») ([SWS_CRYPT_20747]). Además, la llamada es segura para subprocesos («thread-safe»), por lo que se permiten llamadas simultáneas desde varios subprocesos sobre la misma instancia de CryptoProvider ([SWS_CRYPT_20747]).

El método CreateKeyAgreementPrivateCtx de la clase ara::crypto::cryp::CryptoProvider sirve para crear un contexto de clave privada para acuerdos de claves (KeyAgreementPrivateCtx) de acuerdo con [SWS_CRYPT_20758]. La declaración se proporciona a través del archivo de cabecera #include "ara/crypto/cryp/crypto_provider.h".

Uso y llamada

Como parámetro de transferencia, el método síncrono espera el identificador algId del tipo AlgId, el cual especifica el algoritmo criptográfico deseado para el acuerdo de claves. Como valor de retorno, la función proporciona un ara::core::Result<KeyAgreementPrivateCtx::Sptr> que, en caso de éxito, encapsula un puntero inteligente a la instancia de contexto recién creada [SWS_CRYPT_20758].

Manejo de errores

Si la instanciación falla, el ara::core::Result devuelto contiene un código de error con semántica de reversión [SWS_CRYPT_20758]:

• ara::crypto::CryptoErrc::kInvalidArgument: Se produce cuando el argumento algId indica un algoritmo criptográfico que difiere de los procedimientos de acuerdo de claves.
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se devuelve en caso de que el identificador algId presente un valor no admitido.

Concurrencia y seguridad

La interfaz está declarada como noexcept y definida como segura ante excepciones (exception safe). Además, la llamada está especificada como segura para subprocesos (thread-safe), de modo que se permiten llamadas simultáneas sobre la misma instancia de CryptoProvider [SWS_CRYPT_20758].

usar

El método CreateKeyDecapsulatorPrivateCtx de la interfaz ara::crypto::cryp::CryptoProvider sirve para crear un contexto privado para el desencapsulado de claves para un Key Encapsulation Mechanism (KEM) [SWS_CRYPT_20753]. Como parámetro de entrada espera algId del tipo AlgId, el cual identifica el algoritmo criptográfico KEM deseado [SWS_CRYPT_20753]. La función opera de forma síncrona y devuelve el resultado en un ara::core::Result<KeyDecapsulatorPrivateCtx::Sptr>, que en caso de éxito encapsula un puntero inteligente al contexto recién instanciado [SWS_CRYPT_20753].

Manejo de errores

Si se produce un error durante la creación del contexto, este se notifica a través del ara::core::Result con semántica de reversión [SWS_CRYPT_20753]:

• ara::crypto::CryptoErrc::kInvalidArgument: el argumento algId especifica un algoritmo criptográfico que no es un procedimiento KEM asimétrico [SWS_CRYPT_20753].
• ara::crypto::CryptoErrc::kUnknownIdentifier: el argumento algId presenta un valor no compatible [SWS_CRYPT_20753].

Concurrencia y seguridad de ejecución

La interfaz está declarada como noexcept y especificada como segura frente a excepciones (exception safe) [SWS_CRYPT_20753]. Además, la ejecución está diseñada para ser segura para subprocesos (thread-safe) [SWS_CRYPT_20753].

El método CreateKeyDerivationFunctionCtx de la clase ara::crypto::cryp::CryptoProvider sirve para crear un contexto de ejecución para funciones de derivación de claves ([SWS_CRYPT_20748]). Como parámetro de entrada se pasa el identificador algId del tipo AlgId, el cual define el algoritmo criptográfico de destino deseado. La llamada síncrona devuelve un ara::core::Result que, en caso de ejecución correcta, proporciona un puntero inteligente al contexto creado (KeyDerivationFunctionCtx::Sptr) ([SWS_CRYPT_20748]).

Si se produce un error durante la instanciación, el resultado se devuelve con el código de error correspondiente bajo una semántica de reversión ([SWS_CRYPT_20748]):

• ara::crypto::CryptoErrc::kInvalidArgument: el argumento algId especifica un algoritmo criptográfico que no representa una función de derivación de claves ([SWS_CRYPT_20748]).
• ara::crypto::CryptoErrc::kUnknownIdentifier: el identificador proporcionado algId posee un valor no admitido ([SWS_CRYPT_20748]).

La interfaz está declarada como función virtual pura, identificada como noexcept y clasificada de manera vinculante como thread-safe y exception safe ([SWS_CRYPT_20748]). La integración se realiza a través del archivo de cabecera #include "ara/crypto/cryp/crypto_provider.h". La función atiende a los requisitos de nivel superior [RS_CRYPTO_02103] y [RS_AP_00144].

usar

El método CreateKeyEncapsulatorPublicCtx de la interfaz ara::crypto::cryp::CryptoProvider sirve para crear un contexto público para un mecanismo de encapsulación de claves (Key Encapsulation Mechanism, KEM) [SWS_CRYPT_20752]. Para ello, debe incluirse el archivo de cabecera #include "ara/crypto/cryp/crypto_provider.h" [SWS_CRYPT_20752]. La llamada se realiza de forma síncrona: como parámetro de entrada se pasa algId, que especifica el algoritmo criptográfico de destino del KEM. En caso de ejecución correcta, el método devuelve un puntero inteligente al contexto creado (KeyEncapsulatorPublicCtx::Sptr), encapsulado en un ara::core::Result [SWS_CRYPT_20752].

Manejo de errores

Si se produce un error durante la creación, se aplica una semántica de reversión (rollback) y el ara::core::Result contiene un código de error específico de ara::crypto::CryptoErrc [SWS_CRYPT_20752]:

• ara::crypto::CryptoErrc::kInvalidArgument: Se devuelve si el argumento algId especifica un algoritmo criptográfico que no es un KEM asimétrico [SWS_CRYPT_20752].
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se notifica si el argumento algId presenta un valor no admitido [SWS_CRYPT_20752].

Concurrencia y seguridad

La función de interfaz está declarada con noexcept y clasificada como segura ante excepciones (exception safe), así como segura para subprocesos (thread-safe) [SWS_CRYPT_20752]. Por lo tanto, se puede llamar de forma segura desde contextos concurrentes sin sincronización externa [SWS_CRYPT_20752].

usar

El método virtual puro CreateMessageAuthnCodeCtx de la interfaz ara::crypto::cryp::CryptoProvider requiere el archivo de cabecera ara/crypto/cryp/crypto_provider.h y sirve para crear de forma síncrona un contexto para códigos de autenticación de mensajes simétricos [SWS_CRYPT_20746]. Como valor de entrada, la función recibe el parámetro algId de tipo AlgId, que especifica el algoritmo criptográfico de destino [SWS_CRYPT_20746]. En caso de ejecución correcta, el método devuelve un ara::core::Result<MessageAuthnCodeCtx::Sptr> que encapsula un puntero inteligente a la instancia de contexto recién instanciada [SWS_CRYPT_20746].

Manejo de errores

En caso de error, el objeto Result devuelto proporciona códigos de error específicos con semántica de reversión [SWS_CRYPT_20746]:

• ara::crypto::CryptoErrc::kInvalidArgument: El argumento algId especifica un algoritmo criptográfico que no es un código de autenticación de mensajes simétrico [SWS_CRYPT_20746].
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se ha pasado un identificador desconocido o no compatible para el argumento algId [SWS_CRYPT_20746].

Concurrencia y seguridad de ejecución

La interfaz cuenta con el especificador noexcept y garantiza una total seguridad frente a excepciones (exception safe) [SWS_CRYPT_20746]. Asimismo, la función está especificada explícitamente como segura para subprocesos (thread-safe), de modo que las llamadas pueden realizarse en paralelo y sin sincronización externa desde subprocesos concurrentes [SWS_CRYPT_20746].

usar

La interfaz CreateProtectedKeyImportCtx de la clase ara::crypto::cryp::CryptoProvider (definida en ara/crypto/cryp/crypto_provider.h) sirve para la creación sincrónica de un contexto para la importación protegida de claves ([SWS_CRYPT_50017]). A través del parámetro de entrada algId se transmite el identificador del algoritmo de envoltura deseado ([SWS_CRYPT_50017]). En caso de instanciación correcta, el método devuelve un ara::core::Result que proporciona un smart pointer ProtectedKeyImportCtx::Sptr hacia el contexto generado ([SWS_CRYPT_50017]).

Manejo de errores

Si la creación falla, el método devuelve en ara::core::Result un código de error con semántica de rollback ([SWS_CRYPT_50017]):

• ara::crypto::CryptoErrc::kInvalidArgument: Se produce cuando el criptoalgoritmo especificado por algId no es compatible con CryptoProvider para la envoltura ([SWS_CRYPT_50017]).
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se notifica si el argumento algId contiene un valor de identificador desconocido o no compatible ([SWS_CRYPT_50017]).

Concurrencia y restricciones

El método puramente virtual está declarado como noexcept, ofrece seguridad frente a excepciones y está especificado explícitamente como seguro para hilos (thread-safe) ([SWS_CRYPT_50017]). Por consiguiente, puede invocarse en paralelo desde múltiples hilos sin sincronización externa ([SWS_CRYPT_50017]).

El método CreateRandomGeneratorCtx sirve para crear un contexto para generadores de números aleatorios (Random Number Generator, RNG) dentro de la clase ara::crypto::cryp::CryptoProvider [SWS_CRYPT_20741].

Uso y contexto de llamada

La función se invoca de forma síncrona y requiere el archivo de cabecera ara/crypto/cryp/crypto_provider.h [SWS_CRYPT_20741]:

• Parámetro: Se pasa algId de tipo AlgId, que identifica el algoritmo de RNG deseado. Si no se especifica ningún algId concreto, el método proporciona el RNG predeterminado [SWS_CRYPT_20741].
• Valor de retorno: Un ara::core::Result<RandomGeneratorCtx::Sptr> que, en caso de éxito, contiene un puntero compartido a la instancia creada de RandomGeneratorCtx [SWS_CRYPT_20741].

Manejo de errores

El método no genera excepciones (noexcept) y está especificado como seguro frente a excepciones [SWS_CRYPT_20741]. Si la operación falla, el ara::core::Result devuelve un código de error:

• ara::crypto::CryptoErrc::kUnknownIdentifier: Se produce cuando el argumento algId presenta un valor no compatible (con semántica de reversión) [SWS_CRYPT_20741].

Concurrencia y restricciones

El método está clasificado como seguro para subprocesos (thread-safe), por lo que se permiten llamadas paralelas a través de la misma instancia del CryptoProvider [SWS_CRYPT_20741].

El método CreateSignerPrivateCtx de la clase ara::crypto::cryp::CryptoProvider sirve para crear un contexto para operaciones de firma con una clave privada ([SWS_CRYPT_20756]).

Uso y parámetros: La llamada requiere incluir el archivo de cabecera ara/crypto/cryp/crypto_provider.h. Mediante el parámetro de entrada algId se especifica el algoritmo criptográfico de firma de destino. En caso de éxito, la función proporciona a través del tipo de retorno ara::core::Result<SignerPrivateCtx::Sptr> un puntero inteligente a la instancia de contexto creada ([SWS_CRYPT_20756]). Interpretación: Dado que el método devuelve directamente un ara::core::Result, es probable que la llamada se ejecute de forma síncrona. Pregunta Q-8480f3cf5cef5f49 (abierta)

Concurrencia y seguridad: El método está especificado como seguro para subprocesos (thread-safe), así como seguro ante excepciones (exception safe), y está declarado con noexcept ([SWS_CRYPT_20756]). Por lo tanto, se puede invocar desde contextos concurrentes sin sincronización adicional.

Tratamiento de errores: En caso de error, el resultado proporciona un código de error del tipo ara::crypto::CryptoErrc con semántica de reversión ([SWS_CRYPT_20756]):

• ara::crypto::CryptoErrc::kInvalidArgument: Se produce cuando el argumento algId indica un algoritmo criptográfico que difiere de una firma con clave privada ([SWS_CRYPT_20756]).
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se produce cuando algId contiene un valor desconocido o no admitido ([SWS_CRYPT_20756]).

usar

El método virtual CreateSymmetricCipherCtx de la interfaz ara::crypto::cryp::CryptoProvider sirve para crear un contexto para operaciones de cifrado simétrico ([SWS_CRYPT_20742]). Se incluye a través del archivo de cabecera #include "ara/crypto/cryp/crypto_provider.h" ([SWS_CRYPT_20742]).

Como parámetro de entrada, la función espera algId de tipo AlgId, que indica el identificador del algoritmo criptográfico de destino deseado ([SWS_CRYPT_20742]). La llamada se realiza de forma síncrona y devuelve como resultado un ara::core::Result<SymmetricCipherCtx::Sptr> que, en caso de éxito, proporciona un puntero inteligente a la instancia de contexto recién instanciada ([SWS_CRYPT_20742]).

Manejo de errores

Si la creación falla, el ara::core::Result devuelto contiene un código de error correspondiente ([SWS_CRYPT_20742]):

• ara::crypto::CryptoErrc::kUnknownIdentifier: Se notifica con semántica de reversión si el valor pasado para algId hace referencia a un algoritmo no compatible ([SWS_CRYPT_20742]).

Concurrencia y restricciones

La función está declarada como noexcept y especificada explícitamente como segura frente a excepciones (exception safe) ([SWS_CRYPT_20742]). Además, la llamada es segura para subprocesos (thread-safe), por lo que se permiten creaciones paralelas de contexto a través de la misma instancia de CryptoProvider ([SWS_CRYPT_20742]).

usar

El método CreateSymmetricKeyWrapperCtx de la clase ara::crypto::cryp::CryptoProvider sirve para generar un contexto para algoritmos simétricos de envoltura de claves ([SWS_CRYPT_20743]). Como parámetro de entrada se transmite algId, el cual identifica unívocamente el criptoalgoritmo de destino ([SWS_CRYPT_20743]). La llamada es sincrónica y, en caso de éxito, devuelve un ara::core::Result que encapsula un smart pointer hacia el contexto creado (SymmetricKeyWrapperCtx::Sptr) ([SWS_CRYPT_20743]).

Manejo de errores

Si la creación falla, la función devuelve el objeto de error dentro de ara::core::Result ([SWS_CRYPT_20743]):

• ara::crypto::CryptoErrc::kUnknownIdentifier: Se notifica si el argumento algId presenta un valor no compatible; en tal caso se aplican semánticas de rollback ([SWS_CRYPT_20743]).

Concurrencia y restricciones

La interfaz está declarada como noexcept, se considera segura frente a excepciones (exception safe) y es segura para hilos (thread-safe) ([SWS_CRYPT_20743]). Por lo tanto, puede invocarse de forma segura desde contextos concurrentes, siempre que el algId proporcionado sea compatible con el CryptoProvider subyacente ([SWS_CRYPT_20743]).

Uso y contexto de llamada

El método virtual puro CreateVerifierPublicCtx de la clase ara::crypto::cryp::CryptoProvider se declara a través del archivo de cabecera ara/crypto/cryp/crypto_provider.h [SWS_CRYPT_20757]. Sirve para la creación síncrona de un contexto para la verificación de firmas con claves públicas (verificación de firmas de clave pública) [SWS_CRYPT_20757].

La entidad llamadora pasa mediante el parámetro algId (tipo AlgId) el identificador del algoritmo de firma criptográfica deseado [SWS_CRYPT_20757]. En caso de éxito, la función devuelve un ara::core::Result que contiene un puntero inteligente al contexto de verificación creado (VerifierPublicCtx::Sptr) [SWS_CRYPT_20757].

Manejo de errores

En caso de error, se aplica una semántica de reversión y el ara::core::Result resultante transmite un código de error correspondiente [SWS_CRYPT_20757]:

• ara::crypto::CryptoErrc::kInvalidArgument: Se notifica si el argumento algId especifica un algoritmo criptográfico que no está previsto para la verificación de firmas con claves públicas [SWS_CRYPT_20757].
• ara::crypto::CryptoErrc::kUnknownIdentifier: Se notifica si para algId se ha pasado un identificador desconocido o no admitido [SWS_CRYPT_20757].

Concurrencia y restricciones

El método está declarado como noexcept, es completamente seguro ante excepciones (exception safe) y está especificado explícitamente como seguro para subprocesos (thread-safe) [SWS_CRYPT_20757]. Por tanto, las llamadas paralelas desde múltiples contextos de ejecución están permitidas sin sincronización externa.

El método ExportSecuredKey de la interfaz ara::crypto::cryp::CryptoProvider exporta un objeto de clave criptográfica a un formato protegido y serializado [SWS_CRYPT_20728]. El objeto de clave pasado key se procesa según el formato establecido implícitamente por algId, se empaqueta criptográficamente («wrapped») y se serializa en el búfer de salida resultBuffer [SWS_CRYPT_20728]. Para el empaquetado se puede pasar opcionalmente una clave de cifrado de claves (kek); si no se proporciona ningún kek, el método recurre a un KEK determinado implícitamente por la algId o al KEK predeterminado del CryptoProvider [SWS_CRYPT_20728].

La función está clasificada como thread-safe y exception safe, y anotada con noexcept [SWS_CRYPT_20728]. Interpretación: Dado que la signatura devuelve directamente un ara::core::Result sin tipos de retorno asíncronos como futuros, se asume que todo el proceso de empaquetado y serialización se ejecuta de forma síncrona en el contexto del llamador. Pregunta Q-3fb89afcc9300695 (abierta)

En caso de finalización correcta, el ara::core::Result<std::size_t> devuelto proporciona el número de bytes escritos en resultBuffer [SWS_CRYPT_20728]. Si la operación falla, se aplica una semántica de reversión y se notifica uno de los siguientes errores [SWS_CRYPT_20728]:

• UnknownIdentifier: El valor algId pasado no es compatible [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kInvalidArgument: El objeto de clave no se puede empaquetar (p. ej., tamaño no válido o tipo inadecuado) o no se pasó un kek obligatorio [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kUsageViolation: El uso permitido de key o kek es incompatible con el algoritmo seleccionado [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kIncompatibleArguments: El kek pasado es incompatible con el algoritmo de exportación [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kInsufficientCapacity: El búfer de salida resultBuffer es demasiado pequeño para el resultado [SWS_CRYPT_20728].
• ara::crypto::CryptoErrc::kBusyResource: Un recurso necesario para la exportación está ocupado [SWS_CRYPT_20728].

El método GeneratePrivateKey de la clase ara::crypto::cryp::CryptoProvider (declarado en ara/crypto/cryp/crypto_provider.h) genera de forma síncrona un nuevo par de claves asimétricas y devuelve la clave privada creada como PrivateKey::Sptr dentro de un ara::core::Result [SWS_CRYPT_20722]. La clave pública correspondiente no se devuelve directamente, sino que se puede consultar con posterioridad mediante el método PrivateKey::GetPublicKey() de la clave resultante [SWS_CRYPT_20722].

En la llamada, el parámetro algId especifica el algoritmo criptográfico, mientras que privateKeyAllowedUsage determina los tipos de transformación admisibles para la clave privada [SWS_CRYPT_20722]. Los indicadores de uso admisibles de la clave pública se asignan en función de los permisos de la clave privada de la siguiente manera [SWS_CRYPT_20722]:

• kAllowDataDecryption conduce a kAllowDataEncryption
• kAllowSigGeneration conduce a kAllowSigVerification
• kAllowKeyAgreement conduce a kAllowKeyAgreement
• kAllowKeyUnwrapping conduce a kAllowKeyWrapping

Además, a la clave pública se le asignan automáticamente los indicadores de uso kAllowPlaintextExport así como kAllowPersist [SWS_CRYPT_20722].

En lo relativo a la concurrencia y la ejecución, la función está especificada como segura para subprocesos (thread-safe) y segura frente a excepciones (exception-safe) [SWS_CRYPT_20722]. Si se produce un error durante la generación de claves, el resultado se procesa con semántica de reversión [SWS_CRYPT_20722]. Se pueden devolver los siguientes códigos de error:

• ara::crypto::CryptoErrc::kUnknownIdentifier, si para algId se transmite un algoritmo no admitido,
• ara::crypto::CryptoErrc::kIncompatibleArguments, en caso de que los indicadores de privateKeyAllowedUsage indicados sean incompatibles con el algoritmo o tipo de clave seleccionado,
• ara::crypto::CryptoErrc::kBusyResource, si la generación no es posible temporalmente debido a recursos ocupados de forma provisional [SWS_CRYPT_20722].

El método virtual puro GenerateRandomData de la interfaz ara::crypto::cryp::CryptoProvider sirve para llenar con datos aleatorios criptográficos una zona de memoria proporcionada por el llamador [SWS_CRYPT_30098]. La declaración se encuentra en el archivo de cabecera ara/crypto/cryp/crypto_provider.h.

Como parámetro de salida se transfiere randomData de tipo ReadWriteMem Region, el cual representa el búfer que se va a rellenar y cuyo tamaño determina el número de bytes aleatorios generados [SWS_CRYPT_30098]. Interpretación: Dado que la función utiliza directamente ara::core::Result<void> como tipo de retorno y no un objeto Future, es probable que la generación de los datos se ejecute de forma síncrona y bloqueante [SWS_CRYPT_30098]. Pregunta Q-315c0492dcf7f37d (abierta) En caso de éxito, el valor de retorno está vacío o, en caso de error, contiene el código de error correspondiente [SWS_CRYPT_30098].

Si se produce un problema durante la ejecución, se aplica una semántica de reversión (rollback), de modo que no permanezcan estados parciales o no válidos [SWS_CRYPT_30098]. Se especifican los siguientes estados de error:

• ara::crypto::CryptoErrc::kBusyResource: El generador de números aleatorios (RNG) subyacente dispone actualmente de entropía insuficiente y no puede suministrar la cantidad solicitada de bytes aleatorios [SWS_CRYPT_30098].
• ara::crypto::CryptoErrc::kUnsupported: La implementación concreta del CryptoProvider no admite un generador de números aleatorios estándar [SWS_CRYPT_30098].

En cuanto a concurrencia y robustez, el método está especificado como thread-safe y exception safe [SWS_CRYPT_30098]. Por lo tanto, varios hilos pueden invocar la función en paralelo, y la especificación noexcept garantiza que no se lancen excepciones de C++ a través del límite de la interfaz.

usar

El método puramente virtual GenerateSymmetricKey se proporciona a través de la interfaz ara::crypto::cryp::CryptoProvider (archivo de cabecera #include "ara/crypto/cryp/crypto_provider.h") y sirve para generar una nueva clave simétrica [SWS_CRYPT_20721]. La llamada síncrona espera como parámetro algId el identificador del algoritmo criptográfico simétrico de destino, así como allowedUsage flags de bits que determinan los tipos de transformación permitidos para la clave generada [SWS_CRYPT_20721]. En caso de ejecución correcta, el método devuelve un ara::core::Result con un SymmetricKey::Sptr, es decir, un puntero compartido al objeto de clave simétrica recién generado [SWS_CRYPT_20721].

Manejo de errores

Si se produce un error durante la generación de la clave, este se transmite en el ara::core::Result. Para todos los casos de error especificados se aplica una semántica de reversión (rollback) [SWS_CRYPT_20721]:

• ara::crypto::CryptoErrc::kUnknownIdentifier: se notifica si se ha pasado un valor no admitido para algId [SWS_CRYPT_20721].
• ara::crypto::CryptoErrc::kIncompatibleArguments: se produce si los flags de allowedUsage indicados son incompatibles con el algoritmo algId seleccionado o con el tipo de clave [SWS_CRYPT_20721].
• ara::crypto::CryptoErrc::kBusyResource: indica que la operación no se puede llevar a cabo temporalmente debido a recursos ocupados de forma transitoria [SWS_CRYPT_20721].

Concurrencia y restricciones

La operación está declarada como noexcept y posee las propiedades de ser segura frente a excepciones (exception safe) y segura para subprocesos (thread-safe) [SWS_CRYPT_20721]. Por lo tanto, se puede llamar de forma concurrente desde varios subprocesos, pudiendo producirse el error kBusyResource bajo una alta carga del sistema para señalar cuellos de botella temporales [SWS_CRYPT_20721].

El método GetSecureCounter() de la clase ara::crypto::cryp::CryptoProvider (declarado en #include "ara/crypto/cryp/crypto_provider.h") consulta el valor actual del contador protegido de la instancia del proveedor [SWS_CRYPT_20098]. La función opera de forma síncrona y no requiere parámetros de entrada [SWS_CRYPT_20098]. En caso de éxito, devuelve a través de ara::core::Result<SecureCounter> la estructura SecureCounter, compuesta por dos valores sin signo de 64 bits (LSQW para la palabra cuádruple menos significativa y MSQW para la palabra cuádruple más significativa) [SWS_CRYPT_20098]. Se garantiza que cada valor de contador devuelto es estrictamente mayor que todos los valores proporcionados previamente mediante esta instancia [SWS_CRYPT_20098].

Si no se puede determinar el valor del contador, la llamada falla y devuelve un código de error con semántica de reversión (rollback) en el objeto de resultado [SWS_CRYPT_20098]:

• ara::crypto::CryptoErrc::kUnsupported: el CryptoProvider específico no admite un contador protegido [SWS_CRYPT_20098].
• ara::crypto::CryptoErrc::kBusyResource: un recurso necesario para acceder al contador o actualizarlo está ocupado actualmente [SWS_CRYPT_20098].

Respecto a la concurrencia y robustez, la función está especificada como segura para subprocesos (thread-safe) y declarada como segura frente a excepciones (exception safe) con noexcept [SWS_CRYPT_20098]. Por lo tanto, las llamadas paralelas desde múltiples subprocesos están permitidas sin sincronización externa, garantizándose la estricta monotonía de los valores de contador devueltos [SWS_CRYPT_20098].

usar

El método ImportPrivateKey de la clase ara::crypto::cryp::CryptoProvider sirve para importar de forma síncrona una clave privada serializada [SWS_CRYPT_50132]. En la llamada, los datos útiles se transfieren a través del área de memoria serialized (ReadOnlyMemRegion), complementados con las restricciones de uso deseadas (allowedUsage) y el formato de serialización (formatId). El parámetro algId es opcional (ara::core::Optional<AlgId>) y solo debe establecerse si el formato seleccionado no define ya por sí mismo de forma unívoca las propiedades de clave requeridas [SWS_CRYPT_50132]. Como valor de retorno, la función proporciona un ara::core::Result<PrivateKey::Sptr> que, en caso de éxito, contiene un shared pointer al objeto de clave generado.

Manejo de errores

En caso de error, el método garantiza que se aplique la semántica de reversión [SWS_CRYPT_50132]. Se pueden devolver los siguientes códigos de error a través de Result:

• InvalidArgument: Los datos serializados en serialized no se corresponden con el formato indicado [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kIncompatibleArguments: Los allowedUsage transferidos son incompatibles con la algId [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kUnsupported: La función no es compatible con el proveedor concreto [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kBusyResource: La operación no se puede ejecutar temporalmente debido a recursos ocupados [SWS_CRYPT_50132].
• ara::crypto::CryptoErrc::kUnsupportedFormat: La formatId no es compatible con este tipo de objeto [SWS_CRYPT_50132].

Concurrencia y restricciones

La interfaz está declarada como noexcept y ofrece seguridad frente a excepciones (exception safe), así como seguridad frente a subprocesos (thread-safe) [SWS_CRYPT_50132]. Por lo tanto, las llamadas pueden realizarse en paralelo desde diferentes subprocesos.

usar

El método ImportPublicKey sirve para importar una clave pública serializada en el ara::crypto::cryp::CryptoProvider correspondiente [SWS_CRYPT_20732]. La llamada se realiza de forma síncrona y devuelve un ara::core::Result<PublicKey::Sptr> que, en caso de éxito, contiene un puntero inteligente al objeto de clave generado [SWS_CRYPT_20732].

En la llamada se transfieren los siguientes parámetros [SWS_CRYPT_20732]:

• serialized: Un área de memoria ReadOnlyMemRegion que proporciona los datos sin procesar de la clave serializada.
• allowedUsage: Los indicadores de uso permitido (AllowedUsageFlags) para la clave importada.
• formatId: El identificador del formato de serialización (FormatId).
• algId: Un ID de algoritmo opcional (ara::core::Optional<AlgId>). No es necesario si el formato de serialización ya determina de forma unívoca las propiedades de la clave.

Manejo de errores

Si se produce un error durante el procesamiento, este se encapsula en el ara::core::Result devuelto. Se especifican los siguientes códigos de error [SWS_CRYPT_20732]:

• InvalidArgument: Los datos pasados en serialized no se corresponden con el formato indicado.
• ara::crypto::CryptoErrc::kIncompatibleArguments: Los indicadores de uso allowedUsage son incompatibles con algId.
• ara::crypto::CryptoErrc::kUnsupportedFormat: El formatId especificado no es compatible para este tipo de objeto.
• ara::crypto::CryptoErrc::kUnsupported: La función solicitada no es compatible con el CryptoProvider.
• ara::crypto::CryptoErrc::kBusyResource: La operación no se puede ejecutar temporalmente.

Concurrencia y seguridad

El método está declarado como noexcept, se considera Exception-safe y, según la especificación, está especificado como Thread-safe [SWS_CRYPT_20732]. Los casos de error siguen semánticas de reversión definidas [SWS_CRYPT_20732].

usar

El método ImportSymmetricKey de la interfaz ara::crypto::cryp::CryptoProvider sirve para importar una clave simétrica serializada [SWS_CRYPT_50014]. Como valor de retorno proporciona un ara::core::Result<SymmetricKey::Sptr> que, en caso de éxito, suministra un puntero inteligente al objeto de clave recién instanciado [SWS_CRYPT_50014]. Puesto que no se utiliza ningún tipo de retorno asincrónico como un Future, presumiblemente la ejecución se produce de forma sincrónica. Pregunta Q-720a495b07c4f31d (abierta)

En la llamada deben pasarse los siguientes parámetros [SWS_CRYPT_50014]:

• serialized (ReadOnlyMemRegion): el área de memoria que contiene los datos serializados de la clave.
• allowedUsage (AllowedUsageFlags): máscara de bits de las operaciones y usos permitidos para esta clave.
• formatId (FormatId): identificador del formato de serialización de los datos de la clave.
• algId (ara::core::Optional<AlgId>): identificador de algoritmo opcional; no es necesario si el formato de serialización indicado ya determina unívocamente todas las propiedades requeridas de la clave.

Tratamiento de errores y condiciones límite

El método está especificado como thread-safe y exception safe [SWS_CRYPT_50014]. En caso de error, la implementación garantiza una semántica de reversión (rollback) y devuelve el código de error correspondiente en el ara::core::Result [SWS_CRYPT_50014]:

• InvalidArgument: los datos binarios pasados en serialized no se corresponden con el formato indicado.
• ara::crypto::CryptoErrc::kIncompatibleArguments: los indicadores allowedUsage establecidos son incompatibles con la algId indicada.
• ara::crypto::CryptoErrc::kUnsupported: la instancia concreta del CryptoProvider no admite la función.
• ara::crypto::CryptoErrc::kUnsupportedFormat: el formato especificado no es compatible con este tipo de clave.
• ara::crypto::CryptoErrc::kBusyResource: la operación no se puede ejecutar actualmente debido a recursos temporalmente ocupados.

usar

El método LoadPrivateKey de la interfaz ara::crypto::cryp::CryptoProvider carga una clave privada desde una ranura de clave proporcionada ([SWS_CRYPT_20764]). La llamada se ejecuta de forma síncrona y recibe como parámetro un puntero compartido al recurso de origen (keySlot). En caso de éxito, la función proporciona un puntero compartido al objeto de clave cargado (PrivateKey::Sptr), que se devuelve dentro de un ara::core::Result ([SWS_CRYPT_20764]).

Manejo de errores

Si se produce un error durante la operación, se aplica una semántica de reversión y el ara::core::Result contiene un código de error específico ([SWS_CRYPT_20764]):

• ara::crypto::CryptoErrc::kEmptyKeySlot: la ranura de clave pasada está vacía ([SWS_CRYPT_20764]).
• ara::crypto::CryptoErrc::kIncompatibleObject: el recurso subyacente pertenece a otro CryptoProvider incompatible o contiene un tipo de clave discrepante ([SWS_CRYPT_20764]).
• ara::crypto::CryptoErrc::kBusyResource: la operación no se puede ejecutar temporalmente ([SWS_CRYPT_20764]).

Concurrencia y seguridad

La especificación clasifica la función como thread-safe y exception safe; la signatura está declarada como noexcept ([SWS_CRYPT_20764]). Múltiples subprocesos pueden invocar el método en paralelo, pero deben gestionar una posible devolución de kBusyResource en caso de conflictos de recursos temporales.

usar

El método LoadPublicKey de la interfaz ara::crypto::cryp::CryptoProvider carga una clave pública desde el espacio de almacenamiento de claves proporcionado [SWS_CRYPT_20763]. Como parámetro keySlot espera un KeySlot::Sptr que referencia el espacio de almacenamiento con la clave que se va a cargar [SWS_CRYPT_20763]. Como valor devuelto, la función proporciona un ara::core::Result<PublicKey::Sptr> que, en caso de éxito, contiene un puntero compartido al objeto de clave pública cargado [SWS_CRYPT_20763]. La entrega directa del valor Result probablemente indica un comportamiento de llamada síncrono. Pregunta Q-e0d2480909b1398a (abierta)

Manejo de errores

Si el proceso de carga falla, el ara::core::Result contiene un código de error correspondiente del dominio ara::crypto::CryptoErrc, definiéndose una semántica de reversión para todos los casos de error especificados [SWS_CRYPT_20763]:

• ara::crypto::CryptoErrc::kEmptyKeySlot: se produce cuando el KeySlot pasado está vacío [SWS_CRYPT_20763].
• ara::crypto::CryptoErrc::kIncompatibleObject: se devuelve cuando el recurso subyacente pertenece a otro CryptoProvider incompatible o contiene un tipo de clave discrepante [SWS_CRYPT_20763].
• ara::crypto::CryptoErrc::kBusyResource: se produce si la operación no se puede ejecutar temporalmente porque el recurso está ocupado de otro modo [SWS_CRYPT_20763].

Concurrencia y seguridad

El método está declarado con noexcept y especificado como Exception-safe [SWS_CRYPT_20763]. En cuanto a la concurrencia, la operación está catalogada expresamente como Thread-safe, por lo que se permiten llamadas paralelas desde múltiples subprocesos [SWS_CRYPT_20763].

El método virtual puro LoadSymmetricKey de la clase ara::crypto::cryp::CryptoProvider sirve para cargar una clave simétrica desde un espacio de almacenamiento de claves proporcionado [SWS_CRYPT_20762]. Como parámetro, la función recibe un puntero compartido al espacio de almacenamiento en cuestión (keySlot) y devuelve de forma síncrona un ara::core::Result<SymmetricKey::Sptr> que, en caso de ejecución correcta, proporciona un puntero compartido al objeto de clave cargado [SWS_CRYPT_20762].

Con respecto a la concurrencia y a la seguridad de ejecución, el método está especificado como thread-safe y exception safe, y declarado con noexcept [SWS_CRYPT_20762].

Si se produce un error durante la carga, el método devuelve a través del objeto Result códigos de error específicos del dominio ara::crypto::CryptoErrc con semántica de reversión definida [SWS_CRYPT_20762]:

• ara::crypto::CryptoErrc::kEmptyKeySlot: se produce cuando el KeySlot pasado está vacío [SWS_CRYPT_20762].
• ara::crypto::CryptoErrc::kIncompatibleObject: se devuelve si el recurso subyacente pertenece a otro proveedor criptográfico incompatible o contiene un tipo de clave diferente [SWS_CRYPT_20762].
• ara::crypto::CryptoErrc::kBusyResource: señala que la operación no se puede ejecutar temporalmente [SWS_CRYPT_20762].