clase ara::crypto::x509::X509Provider

usar

El método síncrono ClearCertificateSlot de la clase ara::crypto::x509::X509Provider vacía el espacio de almacenamiento de certificados especificado mediante el parámetro instanceSpecifier [SWS_CRYPT_40622]. Devuelve un ara::core::Result<bool>: el valor de retorno es true si se ha eliminado correctamente un certificado existente, y false si la ranura ya estaba desocupada [SWS_CRYPT_40622].

Tratamiento de errores y restricciones

Si la operación no se puede ejecutar temporalmente, la función devuelve el código de error ara::crypto::CryptoErrc::kBusyResource con semántica de reversión (rollback) [SWS_CRYPT_40622]. Además, se definen requisitos específicos de modelado y acceso:

• ProcessMappingViolation: Se produce cuando el InstanceSpecifier no apunta a un PortPrototype modelado para el proceso actual con la interfaz CryptoCertificateInterface [SWS_CRYPT_40622].
• InsufficientPermissionsViolation: Ocurre si el proceso actual carece de permisos de escritura, es decir, si CryptoCertificateToPortPrototypeMapping.writeAccess != True está establecido [SWS_CRYPT_40622].

concurrencia

La interfaz está identificada como noexcept, segura frente a excepciones (exception safe) y especificada como segura para subprocesos (thread-safe) para llamadas concurrentes [SWS_CRYPT_40622].

usar

El método síncrono CreateCertSignRequest de la interfaz ara::crypto::x509::X509Provider de la cabecera ara/crypto/x509/x509_provider.h genera una solicitud de firma de certificado (Certificate Signing Request, CSR) según el estándar RFC 2986 [SWS_CRYPT_40640]. Como parámetros, la función espera un contexto de firma completamente configurado signerCtx, el nombre distinguido (Distinguished Name) del sujeto subjectDn, la clave pública asociada publicKey así como atributos opcionales codificados en DER attributes [SWS_CRYPT_40640]. La clave pública transferida debe corresponder obligatoriamente con la clave privada configurada en el contexto de firma. En caso de éxito, se devuelve un puntero inteligente al CSR creado (CertSignRequest::Sptrc) empaquetado en un ara::core::Result [SWS_CRYPT_40640].

Manejo de errores

En caso de error, el método devuelve un ara::core::Result con el código de error correspondiente según la semántica de reversión (rollback) [SWS_CRYPT_40640]:

• ara::crypto::CryptoErrc::kInvalidArgument: Si los datos de atributos transferidos no son válidos o si la clave pública no se corresponde con la clave privada del contexto de firma.
• ara::crypto::CryptoErrc::kUninitializedContext: En caso de que el contexto de firma no se haya inicializado con un valor de clave.
• ara::crypto::CryptoErrc::kEmptyKeySlot: En caso de que un KeySlot configurado esté actualmente vacío.
• ara::crypto::CryptoErrc::kUsageViolation: Si el uso de clave permitido no incluye la generación de firmas (kAllowSigGeneration).
• ara::crypto::CryptoErrc::kBusyResource: En la medida en que un recurso requerido para la operación esté ocupado.

Concurrencia y restricciones

El método está especificado como const, noexcept, seguro frente a excepciones (exception safe) y seguro para subprocesos (thread-safe) [SWS_CRYPT_40640]. Es probable que las llamadas paralelas a través de la misma instancia del proveedor sean admisibles, siempre que los objetos de clave y de contexto transferidos no sean modificados simultáneamente por otros hilos. Pregunta Q-aef8777dce55a033 (abierta)

El método CreateCertificateValidationCtx es una interfaz funcional de la clase ara::crypto::x509::X509Provider y sirve, según [SWS_CRYPT_50125], para la creación de un contexto de validación de certificados. Está declarado en el encabezado #include "ara/crypto/x509/x509_provider.h" y definido como una función puramente virtual sin parámetros [SWS_CRYPT_50125].

La llamada síncrona devuelve como valor de retorno el tipo ara::core::Result<CertificateValidationCtx::Sptr>, el cual, en caso de éxito, proporciona un puntero inteligente al contexto creado [SWS_CRYPT_50125]. Para esta función no se definen códigos de error estandarizados en la especificación [SWS_CRYPT_50125]. No obstante, dado que el retorno se realiza mediante el tipo de resultado ara::core::Result, es de esperar que cualquier posible error específico del proveedor durante la creación del contexto se refleje a través del componente de error de este objeto Result. Pregunta Q-f81f52d8e3d73bcf (abierta)

En cuanto al contexto de llamada y la concurrencia, el método está especificado expresamente como seguro para subprocesos (thread-safe), así como declarado seguro frente a excepciones (exception safe) y noexcept [SWS_CRYPT_50125]. Por lo tanto, los llamadores pueden ejecutar la función de forma segura y concurrente desde varios subprocesos sin tener que prever una sincronización adicional para el proceso de creación [SWS_CRYPT_50125].

usar

El método virtual puro CreateDn se proporciona a través de la interfaz ara::crypto::x509::X509Provider del archivo de cabecera ara/crypto/x509/x509_provider.h [SWS_CRYPT_50186]. Sirve para instanciar un objeto Distinguished Name X.509 (X509DN::Sptrc) a partir de una representación en cadena de caracteres [SWS_CRYPT_50186]. Como parámetro de entrada, espera dnString del tipo ara::core::StringView, el cual debe representar un Distinguished Name conforme a RFC 4514 [SWS_CRYPT_50186]. Interpretación: Dado que la función se declara como const noexcept y devuelve directamente un ara::core::Result, es probable que la llamada se realice de forma síncrona bloqueante sin modificación del estado del proveedor. Pregunta Q-c7e3ab6b4f34ad0f (abierta)

Manejo de errores

Si la cadena de caracteres transmitida no puede procesarse correctamente porque no representa un DN válido según RFC 4514, la función devuelve un ara::core::Result con el código de error ara::crypto::CryptoErrc::kInvalidArgument [SWS_CRYPT_50186]. Para este caso de error se han especificado semánticas de reversión (rollback) [SWS_CRYPT_50186].

Concurrencia y restricciones

El método está especificado explícitamente como seguro contra excepciones (exception safe) y seguro para subprocesos (thread-safe) [SWS_CRYPT_50186]. Por lo tanto, puede llamarse desde subprocesos concurrentes sin sincronización externa adicional.

Interacción

Como alternativa a la creación basada en cadenas de caracteres, ara::crypto::x509::X509Provider proporciona otra sobrecarga de CreateDn [SWS_CRYPT_50187]. Esta permite la construcción de un X509DN a partir de un búfer serializado (ReadOnlyMemRegion) indicando un identificador de formato (FormatId) [SWS_CRYPT_50187].

usar

El método CreateDn según [SWS_CRYPT_50187] sirve para la creación de un Distinguished Name (DN) a partir de un búfer serializado. Se invoca de forma síncrona en una instancia de ara::crypto::x509::X509Provider. Como entradas, la función espera un área de memoria dn del tipo ReadOnlyMemRegion que contiene los datos serializados, así como un identificador de formato formatId del tipo FormatId. En caso de ejecución correcta, el método devuelve un ara::core::Result<X509DN::Sptrc> que proporciona un shared pointer al objeto X509DN generado.

Manejo de errores

Si la creación falla, el método devuelve un código de error correspondiente dentro del ara::core::Result ([SWS_CRYPT_50187]):

• ara::crypto::CryptoErrc::kInvalidArgument: Ocurre con semántica de reversión si el búfer dn transferido no es válido.
• ara::crypto::CryptoErrc::kUnsupportedFormat: Se notifica con semántica de reversión en caso de que la formatId indicada sea desconocida o no sea compatible.

Concurrencia e interacción

La interfaz está especificada como thread-safe y exception safe, y declarada con noexcept ([SWS_CRYPT_50187]). Por consiguiente, se puede invocar de forma segura en paralelo desde múltiples contextos de ejecución.

A diferencia de la sobrecarga alternativa [SWS_CRYPT_50186], que crea un DN a partir de una cadena de caracteres (ara::core::StringView) según RFC 4514, esta función procesa datos binarios serializados. Es de suponer que las variantes concretas para FormatId estén definidas en otra parte a escala de módulo. Pregunta Q-dd7cbf35ba6fa7d1 (abierta)

usar

El método CreateOcspRequest de la clase ara::crypto::x509::X509Provider genera de forma síncrona una solicitud de verificación OCSP (Online Certificate Status Protocol) para un certificado individual conforme a RFC 6960 [SWS_CRYPT_40626]. Como parámetros se pasan el certificado que se va a verificar cert y su certificado de emisor issuerCert, cada uno como Certificate::Sptrc [SWS_CRYPT_40626]. Mediante el parámetro opcional signerCtx se puede proporcionar un puntero a un contexto de firma en caso de que la solicitud deba firmarse criptográficamente [SWS_CRYPT_40626]. La función devuelve un ara::core::Result con un ara::core::Vector<std::uint8_t>; es probable que los datos sin procesar contenidos correspondan a la estructura de solicitud codificada en DER según RFC 6960 [SWS_CRYPT_40626]. Pregunta Q-c43cf023ee5eddd9 (abierta)

Manejo de errores

Si se produce un error durante la creación, el ara::core::Result devuelve códigos de error específicos con semántica de reversión [SWS_CRYPT_40626]:

• ara::crypto::CryptoErrc::kUninitializedContext: Se produce si el contexto de firma proporcionado no está inicializado con una clave [SWS_CRYPT_40626].
• ara::crypto::CryptoErrc::kBusyResource: Se produce si la operación no puede llevarse a cabo debido a recursos temporalmente ocupados [SWS_CRYPT_40626].

Concurrencia e interacción

El método está declarado como noexcept, se considera seguro frente a excepciones (exception safe) y está especificado como thread-safe [SWS_CRYPT_40626]. Para escenarios en los que se deban agrupar varios certificados simultáneamente en una solicitud OCSP común, está disponible la interfaz sobrecargada [SWS_CRYPT_40627] para listas de certificados.

usar

El método CreateOcspRequest de la interfaz ara::crypto::x509::X509Provider ([SWS_CRYPT_40627]) sirve para la creación síncrona de una solicitud de verificación OCSP (Online Certificate Status Protocol) según RFC 6960 para múltiples certificados. La llamada se proporciona a través de la cabecera #include "ara/crypto/x509/x509_provider.h".

Como parámetro de entrada, la función espera:

• certList: Una lista de los certificados que se van a validar como ara::core::Span<Certificate::Sptrc>.
• issuerCertList: Una lista de los certificados de emisor asociados como ara::core::Span<Certificate::Sptrc>. Interpretación: Probablemente se presuponga una asignación por pares según el índice entre las entradas de ambas listas. Pregunta Q-9132b017c2c4be75 (abierta)
• signerCtx: Un puntero opcional a un contexto de firma inicializado (ara::core::Optional<cryp::SignerPrivateCtx::Sptr>), en caso de que la solicitud deba firmarse criptográficamente.

Como valor de retorno, la función proporciona un ara::core::Result que, en caso de creación correcta, suministra los datos binarios de la solicitud OCSP en un ara::core::Vector<std::uint8_t> ([SWS_CRYPT_40627]).

Manejo de errores

En caso de error, el ara::core::Result proporciona códigos de error con semántica de reversión ([SWS_CRYPT_40627]):

• ara::crypto::CryptoErrc::kUninitializedContext: Se produce cuando el contexto de firma transferido no se ha inicializado mediante una clave.
• ara::crypto::CryptoErrc::kBusyResource: Se produce cuando la operación no se puede ejecutar temporalmente debido a recursos ocupados de forma transitoria.

Concurrencia e interacción

El método está especificado como thread-safe y exception safe y declarado con noexcept ([SWS_CRYPT_40627]). A diferencia de [SWS_CRYPT_40626], donde la solicitud OCSP se genera para un único certificado, esta interfaz permite agrupar varios certificados en una sola solicitud.

usar

El método DeleteCrl de la interfaz ara::crypto::x509::X509Provider sirve para eliminar una lista de revocación de certificados (Certificate Revocation List, CRL) almacenada de forma persistente [SWS_CRYPT_50184]. Como parámetro se transfiere el crlInstanceSpecifier, que hace referencia a un RPortPrototype de un CryptoCertificateInterface que identifica el certificado correspondiente [SWS_CRYPT_50184]. La función opera de forma síncrona y devuelve un ara::core::Result<void>; este está vacío si la CRL se eliminó correctamente o si previamente no había ninguna CRL almacenada [SWS_CRYPT_50184].

Tratamiento de errores y concurrencia

Si se produce un conflicto temporal de recursos durante la ejecución, la función notifica el error ara::crypto::CryptoErrc::kBusyResource con semántica de reversión [SWS_CRYPT_50184]. El método está declarado como noexcept y especificado como seguro frente a excepciones (exception safe) y seguro para subprocesos (thread-safe) [SWS_CRYPT_50184].

Restricciones y condiciones de configuración

Para la llamada se aplican los siguientes requisitos previos de configuración y autorización [SWS_CRYPT_50184]:

• ProcessMappingViolation: se produce cuando el InstanceSpecifier no apunta a un PortPrototype modelado para el proceso actual que esté tipificado mediante un CryptoCertificateInterface [SWS_CRYPT_50184].
• InsufficientPermissionsViolation: se produce cuando el proceso actual no posee permisos de escritura, es decir, CryptoCertificateToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50184].

usar

El método ImportCertificate de la interfaz ara::crypto::x509::X509Provider (declarado en ara/crypto/x509/x509_provider.h) sirve para el almacenamiento persistente de un certificado X.509 en un slot de certificados definido [SWS_CRYPT_40621]. El slot de destino se direcciona mediante instanceSpecifier (tipo ara::core::InstanceSpecifier), mientras que el certificado que se va a importar se pasa a través del argumento certificate (tipo Certificate::Sptrc) [SWS_CRYPT_40621]. Interpretación: La ejecución probablemente se realice de forma síncrona, ya que la interfaz devuelve directamente un ara::core::Result<void> [SWS_CRYPT_40621]. Pregunta Q-514863e9a90f1c72 (abierta)

Tratamiento de errores y reglas de modelado

En caso de error, se devuelve un ara::core::Result erróneo. Si la operación no se puede ejecutar temporalmente, el método devuelve ara::crypto::CryptoErrc::kBusyResource con semántica de reversión [SWS_CRYPT_40621]. Además, deben cumplirse las directrices de configuración y modelado, ya que de lo contrario se notificarán infracciones en tiempo de ejecución [SWS_CRYPT_40621]:

• ProcessMappingViolation: Se activa si el instanceSpecifier no apunta a un PortPrototype modelado para el proceso actual que esté tipificado mediante un CryptoCertificateInterface [SWS_CRYPT_40621].
• InsufficientPermissionsViolation: Se produce si el proceso actual no dispone de permiso de escritura (CryptoCertificateToPortPrototypeMapping.writeAccess != True) [SWS_CRYPT_40621].

Concurrencia y contexto de ejecución

La operación está especificada como thread-safe y exception safe (noexcept=0), por lo que las llamadas concurrentes quedan protegidas sin necesidad de bloqueos externos [SWS_CRYPT_40621].

usar

El método ImportCertificateInGroup de la clase ara::crypto::x509::X509Provider almacena de forma persistente un certificado proporcionado en un grupo de certificados [SWS_CRYPT_50127] identificado mediante instanceSpecifier. Como parámetros se transfieren una referencia al ara::core::InstanceSpecifier del grupo de destino y un puntero inteligente al certificado (Certificate::Sptrc certificate) [SWS_CRYPT_50127]. La llamada se declara a través del encabezado ara/crypto/x509/x509_provider.h y devuelve de forma síncrona un ara::core::Result<void>, que señala la importación correcta o encapsula un estado de error [SWS_CRYPT_50127].

Tratamiento de errores e infracciones

En caso de error ordinario, la operación ofrece semántica de reversión (rollback) y devuelve códigos de error específicos en el objeto Result [SWS_CRYPT_50127]:

• ara::crypto::CryptoErrc::kInsufficientCapacity: La capacidad del grupo de certificados direccionado no es suficiente para alojar el certificado [SWS_CRYPT_50127].
• ara::crypto::CryptoErrc::kBusyResource: La operación no se puede realizar temporalmente porque el recurso necesario está ocupado [SWS_CRYPT_50127].

Además, se definen requisitos vinculantes de modelado y de autorización, cuyo incumplimiento se clasifica como violaciones (violations) [SWS_CRYPT_50127]:

• ProcessMappingViolation: Ocurre si el InstanceSpecifier no apunta a un PortPrototype modelado para el proceso actual y tipado mediante un CryptoCertificateGroupInterface [SWS_CRYPT_50127].
• InsufficientPermissionsViolation: Ocurre si el proceso llamador no posee permisos de escritura, lo cual se caracteriza mediante CryptoCertificateGroupToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50127].

Concurrencia y contexto de ejecución

La interfaz está especificada como segura frente a subprocesos (thread-safe, thread-safe), segura frente a excepciones (exception safe) y declarada con noexcept [SWS_CRYPT_50127].

El método ImportCrl de la clase ara::crypto::x509::X509Provider analiza sintácticamente y persiste una Certificate Revocation List (CRL) o Delta CRL emitida por el certificado de CA identificado mediante crlInstanceSpecifier [SWS_CRYPT_50183]. Es de esperar que la ejecución se realice de forma síncrona, ya que se devuelve inmediatamente un ara::core::Result. Pregunta Q-648a00ec967c7524 (abierta)

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

• crlInstanceSpecifier: ara::core::InstanceSpecifier al RPortPrototype de un CryptoCertificateInterface que identifica el certificado.
• crl: ReadOnlyMemRegion con los datos serializados de la CRL o Delta CRL.
• formatId: Formato de la CRL serializada.

La operación está especificada como segura frente a subprocesos (thread-safe), así como segura frente a excepciones (exception safe) [SWS_CRYPT_50183]. En caso de éxito, devuelve un ara::core::Result con el estado CertificateValidationStatus::kValid o el resultado de validación de la CRL [SWS_CRYPT_50183].

En caso de error, los valores de retorno poseen semántica de reversión [SWS_CRYPT_50183]:

• ara::crypto::CryptoErrc::kInvalidArgument: La CRL no se corresponde con el formato indicado.
• ara::crypto::CryptoErrc::kUnsupportedFormat: La FormatId indicada es desconocida o no es compatible.
• ara::crypto::CryptoErrc::kBusyResource: La operación no se puede ejecutar temporalmente.

Adicionalmente deben cumplirse requisitos de configuración [SWS_CRYPT_50183]: Se produce una ProcessMappingViolation si el identificador de instancia no hace referencia a un puerto modelado para el proceso actual, y una InsufficientPermissionsViolation si CryptoCertificateToPortPrototypeMapping.writeAccess != True está establecido.

El método LoadCertificate de la interfaz ara::crypto::x509::X509Provider sirve para cargar un certificado desde el almacenamiento persistente de certificados [SWS_CRYPT_40641]. La llamada se ejecuta de forma síncrona (interpretación: retorno directo de ara::core::Result sin un objeto futuro asíncrono como ara::core::Future). Pregunta Q-a2e3c23a02b4f8a1 (abierta) Como parámetro de entrada, la función espera un ara::core::InstanceSpecifier que identifica la ubicación de almacenamiento concreta del certificado [SWS_CRYPT_40641].

En caso de ejecución exitosa, el valor de retorno encapsula un puntero inteligente al certificado instanciado (Certificate::Sptrc) en un ara::core::Result [SWS_CRYPT_40641]. Si la carga falla, el resultado contiene un código de error:

• ara::crypto::CryptoErrc::kEmptyCertificateSlot: Se produce con semántica de reversión si el CryptoCertificate identificado mediante el instanceSpecifier especificado no contiene ningún certificado persistido [SWS_CRYPT_40641].

En lo relativo a la concurrencia y la seguridad frente a excepciones, LoadCertificate está especificado como thread-safe así como exception-safe y está declarado como noexcept [SWS_CRYPT_40641]. En la configuración y asignación de procesos debe tenerse en cuenta una condición de modelado: si el instanceSpecifier proporcionado no remite a un PortPrototype modelado para el proceso actual que esté tipificado por un CryptoCertificateInterface, se produce una ProcessMappingViolation [SWS_CRYPT_40641].

El método ara::crypto::x509::X509Provider::LoadCertificateGroup sirve para cargar un grupo de certificados desde el almacenamiento persistente de certificados según [SWS_CRYPT_50126].

Uso y contexto de llamada

La llamada se realiza a través de una instancia de X509Provider del encabezado ara/crypto/x509/x509_provider.h. Como parámetro de entrada, la función espera un instanceSpecifier de tipo const ara::core::InstanceSpecifier&, el cual identifica la ubicación lógica de almacenamiento del grupo de certificados deseado [SWS_CRYPT_50126]. Como resultado, la interfaz devuelve un ara::core::Result<ara::core::Vector<Certificate::Sptrc>> que, en caso de éxito, proporciona un vector con punteros inteligentes a los certificados cargados [SWS_CRYPT_50126]. A falta de tipos de retorno asíncronos como ara::core::Future, es de suponer que el acceso al almacenamiento persistente se produce de forma síncrona bloqueante. Pregunta Q-b743367ccc9904ab (abierta)

Gestión de errores y restricciones de modelado

En la especificación no se definen códigos de error estandarizados para el valor de retorno [SWS_CRYPT_50126]. No obstante, se prescribe una comprobación en tiempo de ejecución: si el instanceSpecifier pasado no hace referencia a un PortPrototype modelado para el proceso actual que esté tipificado mediante un CryptoCertificateGroupInterface, se produce una ProcessMappingViolation [SWS_CRYPT_50126].

Concurrencia y seguridad frente a excepciones

El método puramente virtual está anotado con noexcept y especificado como seguro frente a excepciones (exception safe). Además, la llamada está declarada explícitamente como segura para subprocesos (thread-safe), de modo que los accesos de lectura paralelos desde varios subprocesos no presentan problemas [SWS_CRYPT_50126].

El método ParseCert forma parte de la clase ara::crypto::x509::X509Provider (definida en la cabecera ara/crypto/x509/x509_provider.h) y sirve para analizar una representación serializada de un certificado X.509v3 e instanciar el correspondiente objeto de certificado [SWS_CRYPT_40614].

Llamada y parámetros: La función se invoca de forma síncrona y está especificada como noexcept [SWS_CRYPT_40614]. Recibe dos parámetros de entrada:

• cert: Una zona de memoria de tipo ReadOnlyMemRegion que proporciona los datos del certificado codificados en el formato especificado [SWS_CRYPT_40614].
• formatId: El identificador del formato de entrada para determinar el procedimiento de análisis sintáctico [SWS_CRYPT_40614].

Valor de retorno y tratamiento de errores: El resultado se devuelve como ara::core::Result<Certificate::Sptrc>, que en caso de éxito contiene un puntero compartido al objeto de certificado creado [SWS_CRYPT_40614]. Si se produce un error, se aplica una semántica de reversión (rollback) con los siguientes códigos de error específicos [SWS_CRYPT_40614]:

• ara::crypto::CryptoErrc::kInvalidArgument: El argumento cert no se puede analizar como un certificado válido [SWS_CRYPT_40614].
• ara::crypto::CryptoErrc::kUnsupportedFormat: El formatId especificado es desconocido o no se admite [SWS_CRYPT_40614].

Concurrencia e implementación: La interfaz está especificada expresamente como segura frente a excepciones (exception safe) y segura para subprocesos (thread-safe) [SWS_CRYPT_40614]. Puesto que ParseCert está declarado como virtual puro, es probable que la lógica de análisis real sea proporcionada por un proveedor o controlador criptográfico específico de la plataforma [SWS_CRYPT_40614]. Pregunta Q-d3239d62d2e7d831 (abierta)

usar

El método ParseCertChain de la interfaz ara::crypto::x509::X509Provider de la cabecera ara/crypto/x509/x509_provider.h analiza una representación serializada de una cadena de certificados [SWS_CRYPT_40616]. Como parámetros recibe la zona de memoria de la cadena de certificados codificada certChain como ReadOnlyMemRegion, así como el identificador de formato formatId de tipo FormatId [SWS_CRYPT_40616]. Para cada certificado analizado con éxito se genera una nueva instancia Certificate. En caso de éxito, la función síncrona devuelve un ara::core::Result con un ara::core::Vector<Certificate::Sptrc> en el que los certificados están dispuestos en el mismo orden que en la cadena transferida [SWS_CRYPT_40616].

Manejo de errores

En caso de error, el ara::core::Result devuelto contiene un código de error específico con semántica de reversión (rollback) [SWS_CRYPT_40616]:

• ara::crypto::CryptoErrc::kInvalidArgument: El argumento certChain no se puede analizar [SWS_CRYPT_40616].
• ara::crypto::CryptoErrc::kUnsupportedFormat: El identificador especificado formatId es desconocido o no se admite [SWS_CRYPT_40616].

Concurrencia y condiciones de contorno

El método está declarado como noexcept, especificado como seguro para subprocesos (thread-safe) y garantiza la seguridad frente a excepciones (exception safe) [SWS_CRYPT_40616].

Uso y contexto de llamada

El método síncrono ParseOcspResponse forma parte de la interfaz ara::crypto::x509::X509Provider (definida en ara/crypto/x509/x509_provider.h) y sirve para la lectura y el análisis sintáctico de respuestas OCSP serializadas [SWS_CRYPT_50185]. El llamador transfiere los datos brutos de la respuesta como ReadOnlyMemRegion a través del parámetro response, así como el formato de datos esperado mediante formatId del tipo FormatId [SWS_CRYPT_50185]. En caso de validación y procesamiento correctos, la función devuelve un ara::core::Result que encapsula un puntero inteligente OcspResponse::Sptrc al objeto de respuesta OCSP recién creado [SWS_CRYPT_50185].

Manejo de errores

Los casos de error se señalan sin lanzar excepciones a través del tipo de retorno ara::core::Result con semántica de reversión [SWS_CRYPT_50185]:

• ara::crypto::CryptoErrc::kInvalidArgument: Ocurre si los bytes proporcionados en el búfer response no se pueden analizar sintácticamente como una respuesta OCSP válida [SWS_CRYPT_50185].
• ara::crypto::CryptoErrc::kUnsupportedFormat: Se notifica en caso de que el identificador formatId transferido sea desconocido o no sea compatible con el proveedor [SWS_CRYPT_50185].

Concurrencia y seguridad para subprocesos

El método puramente virtual está declarado como noexcept, catalogado como seguro frente a excepciones (exception safe) y especificado explícitamente como seguro frente a subprocesos (thread-safe) [SWS_CRYPT_50185]. Gracias a la declaración const, ParseOcspResponse puede invocarse de manera concurrente en entornos multihilo sobre la misma instancia de proveedor sin modificar el estado interno del objeto [SWS_CRYPT_50185].

usar

El método de interfaz síncrono RemoveCertificateFromGroup del ámbito ara::crypto::x509::X509Provider sirve para la eliminación selectiva de un certificado de un grupo de certificados existente [SWS_CRYPT_50128]. A través del parámetro instanceSpecifier se identifica el grupo de certificados en cuestión, mientras que certificate proporciona el certificado que se va a eliminar como puntero inteligente (Certificate::Sptrc) [SWS_CRYPT_50128]. La llamada devuelve un ara::core::Result<void>, que confirma la ejecución correcta sin valor de retorno o encapsula un error ocurrido [SWS_CRYPT_50128].

Manejo de errores

Si se produce un error durante la ejecución, se aplica una semántica de reversión definida, de modo que el estado del grupo de certificados permanece inalterado [SWS_CRYPT_50128]. Se especifican los siguientes códigos de error:

• ara::crypto::CryptoErrc::kNoSuchValue: El grupo de certificados especificado no contiene el certificado que se va a eliminar [SWS_CRYPT_50128].
• ara::crypto::CryptoErrc::kBusyResource: La operación no se puede llevar a cabo temporalmente porque los recursos requeridos están ocupados [SWS_CRYPT_50128].

Concurrencia y condiciones de configuración

El método está especificado como thread-safe y exception safe, y declarado con noexcept [SWS_CRYPT_50128]. Antes de la llamada, deben cumplirse obligatoriamente en el modelo del sistema los siguientes requisitos previos para el proceso [SWS_CRYPT_50128]:

• Para evitar una ProcessMappingViolation, el InstanceSpecifier transferido debe apuntar a un PortPrototype tipado mediante un CryptoCertificateGroupInterface modelado para el proceso actual [SWS_CRYPT_50128].
• Para evitar una InsufficientPermissionsViolation, el proceso actual debe disponer de permisos de escritura, es decir, CryptoCertificateGroupToPortPrototypeMapping.writeAccess debe estar configurado como True [SWS_CRYPT_50128].