classe ara::crypto::x509::X509Provider

usar

O método síncrono ClearCertificateSlot da classe ara::crypto::x509::X509Provider esvazia o espaço de armazenamento de certificados especificado através do parâmetro instanceSpecifier [SWS_CRYPT_40622]. Ele retorna um ara::core::Result<bool>: o valor de retorno é true se um certificado existente tiver sido excluído com sucesso e false se o slot já estiver desocupado [SWS_CRYPT_40622].

Tratamento de erros e restrições

Se a operação temporariamente não puder ser executada, a função retorna o código de erro ara::crypto::CryptoErrc::kBusyResource com semântica de rollback [SWS_CRYPT_40622]. Além disso, pré-requisitos específicos de modelagem e acesso estão definidos:

• ProcessMappingViolation: ocorre quando o InstanceSpecifier não aponta para um PortPrototype modelado para o processo atual com a interface CryptoCertificateInterface [SWS_CRYPT_40622].
• InsufficientPermissionsViolation: ocorre se faltarem permissões de escrita ao processo atual, ou seja, se CryptoCertificateToPortPrototypeMapping.writeAccess != True estiver definido [SWS_CRYPT_40622].

simultaneidade

A interface é indicada como noexcept, especificada como segura contra exceções (exception safe) e, para chamadas concorrentes, como segura para threads (thread-safe) [SWS_CRYPT_40622].

usar

O método síncrono CreateCertSignRequest da interface ara::crypto::x509::X509Provider do cabeçalho ara/crypto/x509/x509_provider.h cria uma solicitação de assinatura de certificado (Certificate Signing Request, CSR) conforme o padrão RFC 2986 [SWS_CRYPT_40640]. Como parâmetros, a função espera um contexto de assinatura totalmente configurado signerCtx, o Distinguished Name do sujeito subjectDn, a chave pública correspondente publicKey, bem como atributos codificados em DER opcionais attributes [SWS_CRYPT_40640]. A chave pública passada deve obrigatoriamente corresponder à chave privada configurada no contexto de assinatura. Em caso de sucesso, um smart pointer para o CSR criado (CertSignRequest::Sptrc) é retornado empacotado em um ara::core::Result [SWS_CRYPT_40640].

Tratamento de erros

Em caso de erro, o método retorna um ara::core::Result com um código de erro correspondente de acordo com a semântica de rollback [SWS_CRYPT_40640]:

• ara::crypto::CryptoErrc::kInvalidArgument: se os dados de atributo passados forem inválidos ou a chave pública não corresponder à chave privada do contexto de assinatura.
• ara::crypto::CryptoErrc::kUninitializedContext: caso o contexto de assinatura não tenha sido inicializado com um valor de chave.
• ara::crypto::CryptoErrc::kEmptyKeySlot: caso um KeySlot configurado esteja atualmente vazio.
• ara::crypto::CryptoErrc::kUsageViolation: se o uso permitido da chave não abranger a geração de assinatura (kAllowSigGeneration).
• ara::crypto::CryptoErrc::kBusyResource: desde que um recurso necessário para a operação esteja ocupado.

Simultaneidade e restrições

O método é especificado como const, noexcept, seguro contra exceções (exception safe) e seguro para threads (thread-safe) [SWS_CRYPT_40640]. Chamadas paralelas através da mesma instância de provedor devem ser admissíveis, desde que os objetos de contexto e chave passados não sejam modificados simultaneamente por outras threads. Pergunta Q-aef8777dce55a033 (aberta)

O método CreateCertificateValidationCtx é uma interface funcional da classe ara::crypto::x509::X509Provider e serve, de acordo com [SWS_CRYPT_50125], para criar um contexto de validação de certificados. Está declarado no cabeçalho #include "ara/crypto/x509/x509_provider.h" e definido como uma função puramente virtual sem parâmetros [SWS_CRYPT_50125].

A chamada síncrona retorna como valor de retorno o tipo ara::core::Result<CertificateValidationCtx::Sptr>, que, em caso de sucesso, fornece um smart pointer para o contexto criado [SWS_CRYPT_50125]. Para esta função, não estão definidos códigos de erro padronizados na especificação [SWS_CRYPT_50125]. No entanto, como o retorno é efetuado através do tipo de resultado ara::core::Result, eventuais erros específicos do fornecedor durante a criação do contexto devem ser mapeados através do componente de erro deste objeto Result. Pergunta Q-f81f52d8e3d73bcf (aberta)

No que diz respeito ao contexto de chamada e à concorrência, o método está expressamente especificado como seguro para threads (thread-safe), bem como declarado como seguro para exceções (exception safe) e noexcept [SWS_CRYPT_50125]. Por conseguinte, os chamadores podem executar a função de forma segura e concorrente a partir de múltiplas threads, sem necessidade de sincronização adicional para o processo de criação [SWS_CRYPT_50125].

usar

O método puramente virtual CreateDn é disponibilizado por meio da interface ara::crypto::x509::X509Provider a partir do arquivo de cabeçalho ara/crypto/x509/x509_provider.h [SWS_CRYPT_50186]. Ele serve para instanciar um objeto X.509 Distinguished Name (X509DN::Sptrc) com base em uma representação em cadeia de caracteres [SWS_CRYPT_50186]. Como parâmetro de entrada, ele espera dnString do tipo ara::core::StringView, que deve representar um Distinguished Name conforme a RFC 4514 [SWS_CRYPT_50186]. Interpretação: Uma vez que a função está declarada como const noexcept e retorna diretamente um ara::core::Result, é provável que a chamada ocorra de forma síncrona e bloqueante, sem alteração de estado do provedor. Pergunta Q-c7e3ab6b4f34ad0f (aberta)

Tratamento de erros

Se a cadeia de caracteres passada não puder ser processada com sucesso por não representar um DN válido conforme a RFC 4514, a função retorna um ara::core::Result com o código de erro ara::crypto::CryptoErrc::kInvalidArgument [SWS_CRYPT_50186]. Para este caso de erro, estão especificadas semânticas de rollback [SWS_CRYPT_50186].

Simultaneidade e restrições

O método é explicitamente especificado como seguro contra exceções (exception safe) e seguro para threads (thread-safe) [SWS_CRYPT_50186]. Ele pode, portanto, ser chamado a partir de threads concorrentes sem sincronização externa adicional.

Interação

Como alternativa à criação baseada em cadeia de caracteres, ara::crypto::x509::X509Provider disponibiliza uma sobrecarga adicional de CreateDn [SWS_CRYPT_50187]. Esta permite a construção de um X509DN a partir de um buffer serializado (ReadOnlyMemRegion) sob a especificação de um identificador de formato (FormatId) [SWS_CRYPT_50187].

usar

O método CreateDn de acordo com [SWS_CRYPT_50187] serve para a criação de um Distinguished Name (DN) a partir de um buffer serializado. É chamado sincronicamente numa instância de ara::crypto::x509::X509Provider. Como entradas, a função espera uma área de memória dn do tipo ReadOnlyMemRegion, que contém os dados serializados, bem como um identificador de formato formatId do tipo FormatId. Em caso de execução bem-sucedida, o método retorna um ara::core::Result<X509DN::Sptrc>, que disponibiliza um shared pointer para o objeto X509DN criado.

Tratamento de erros

Se a criação falhar, o método retorna um código de erro correspondente dentro do ara::core::Result ([SWS_CRYPT_50187]):

• ara::crypto::CryptoErrc::kInvalidArgument: Ocorre com semântica de rollback se o buffer passado dn for inválido.
• ara::crypto::CryptoErrc::kUnsupportedFormat: É reportado com semântica de rollback caso a formatId indicada seja desconhecida ou não suportada.

Concorrência e interação

A interface está especificada como thread-safe e exception safe e declarada com noexcept ([SWS_CRYPT_50187]). Pode, portanto, ser chamada com segurança em paralelo a partir de múltiplos contextos de execução.

Ao contrário da sobrecarga alternativa [SWS_CRYPT_50186], que cria um DN a partir de uma cadeia de carateres (ara::core::StringView) de acordo com a RFC 4514, esta função processa dados binários serializados. As concretizações específicas para FormatId devem estar definidas noutro local em todo o módulo. Pergunta Q-dd7cbf35ba6fa7d1 (aberta)

usar

O método CreateOcspRequest da classe ara::crypto::x509::X509Provider gera de forma síncrona uma solicitação de verificação OCSP (Online Certificate Status Protocol) para um único certificado de acordo com a RFC 6960 [SWS_CRYPT_40626]. Como parâmetros, o certificado a ser verificado cert e seu certificado de emissor issuerCert são passados, cada um, como Certificate::Sptrc [SWS_CRYPT_40626]. Através do parâmetro opcional signerCtx, pode ser disponibilizado um ponteiro para um contexto de assinatura, caso a solicitação deva ser assinada criptograficamente [SWS_CRYPT_40626]. A função retorna um ara::core::Result com um ara::core::Vector<std::uint8_t>; os dados brutos contidos devem corresponder à estrutura de solicitação codificada em DER de acordo com a RFC 6960 [SWS_CRYPT_40626]. Pergunta Q-c43cf023ee5eddd9 (aberta)

Tratamento de erros

Se ocorrer um erro durante a criação, o ara::core::Result fornece códigos de erro específicos com semântica de rollback [SWS_CRYPT_40626]:

• ara::crypto::CryptoErrc::kUninitializedContext: Ocorre quando o contexto de assinatura passado não está inicializado com uma chave [SWS_CRYPT_40626].
• ara::crypto::CryptoErrc::kBusyResource: Ocorre quando a operação não pode ser realizada devido a recursos temporariamente ocupados [SWS_CRYPT_40626].

Concorrência e interação

O método é declarado como noexcept, é considerado seguro contra exceções (exception safe) e está especificado como thread-safe [SWS_CRYPT_40626]. Para cenários em que vários certificados devem ser agrupados simultaneamente em uma solicitação OCSP comum, está disponível a interface sobrecarregada [SWS_CRYPT_40627] para listas de certificados.

usar

O método CreateOcspRequest da interface ara::crypto::x509::X509Provider ([SWS_CRYPT_40627]) serve para a criação síncrona de uma solicitação de verificação OCSP (Online Certificate Status Protocol) em conformidade com a RFC 6960 para múltiplos certificados. A chamada é disponibilizada através do cabeçalho #include "ara/crypto/x509/x509_provider.h".

Como parâmetro de entrada, a função espera:

• certList: uma lista dos certificados a serem validados como ara::core::Span<Certificate::Sptrc>.
• issuerCertList: uma lista dos certificados de emissor associados como ara::core::Span<Certificate::Sptrc>. Interpretação: deve-se pressupor uma correspondência par a par por índice entre as entradas de ambas as listas. Pergunta Q-9132b017c2c4be75 (aberta)
• signerCtx: um ponteiro opcional para um contexto de assinatura inicializado (ara::core::Optional<cryp::SignerPrivateCtx::Sptr>), caso a solicitação deva ser assinada criptograficamente.

Como valor de retorno, a função fornece um ara::core::Result que, em caso de geração bem-sucedida, disponibiliza os dados binários da solicitação OCSP em um ara::core::Vector<std::uint8_t> ([SWS_CRYPT_40627]).

Tratamento de erros

Em caso de erro, o ara::core::Result disponibiliza códigos de erro com semântica de rollback ([SWS_CRYPT_40627]):

• ara::crypto::CryptoErrc::kUninitializedContext: ocorre quando o contexto de assinatura passado não foi inicializado por uma chave.
• ara::crypto::CryptoErrc::kBusyResource: ocorre quando a operação temporariamente não puder ser executada devido a recursos temporariamente ocupados.

Concorrência e interação

O método é especificado como thread-safe bem como exception safe e declarado com noexcept ([SWS_CRYPT_40627]). Diferentemente de [SWS_CRYPT_40626], onde a solicitação OCSP é gerada para um único certificado, esta interface permite agrupar múltiplos certificados em uma única solicitação.

usar

O método DeleteCrl da interface ara::crypto::x509::X509Provider serve para excluir uma lista de revogação de certificados (Certificate Revocation List, CRL) persistida [SWS_CRYPT_50184]. Como parâmetro, é passado o crlInstanceSpecifier, que referencia um RPortPrototype de um CryptoCertificateInterface que identifica o certificado correspondente [SWS_CRYPT_50184]. A função opera de forma síncrona e retorna um ara::core::Result<void>; este fica vazio se a CRL tiver sido excluída com sucesso ou se nenhuma CRL estiver armazenada anteriormente [SWS_CRYPT_50184].

Tratamento de erros e simultaneidade

Se ocorrer um conflito temporário de recursos durante a execução, a função reporta o erro ara::crypto::CryptoErrc::kBusyResource com semântica de rollback [SWS_CRYPT_50184]. O método é declarado como noexcept e especificado como seguro contra exceções (exception safe) e seguro para threads (thread-safe) [SWS_CRYPT_50184].

Restrições e condições de configuração

Para a chamada aplicam-se os seguintes pré-requisitos de configuração e permissão [SWS_CRYPT_50184]:

• ProcessMappingViolation: Ocorre quando o InstanceSpecifier não aponta para um PortPrototype modelado para o processo atual tipificado por um CryptoCertificateInterface [SWS_CRYPT_50184].
• InsufficientPermissionsViolation: Ocorre quando o processo atual não possui permissões de escrita, ou seja, CryptoCertificateToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50184].

usar

O método ImportCertificate da interface ara::crypto::x509::X509Provider (declarado em ara/crypto/x509/x509_provider.h) serve para o armazenamento persistente de um certificado X.509 em um slot de certificado definido [SWS_CRYPT_40621]. O slot de destino é endereçado via instanceSpecifier (tipo ara::core::InstanceSpecifier), enquanto o certificado a ser importado é passado através do argumento certificate (tipo Certificate::Sptrc) [SWS_CRYPT_40621]. Interpretação: A execução provavelmente ocorre de forma síncrona, uma vez que a interface retorna diretamente um ara::core::Result<void> [SWS_CRYPT_40621]. Pergunta Q-514863e9a90f1c72 (aberta)

Tratamento de erros e regras de modelagem

Em caso de erro, é retornado um ara::core::Result indicando falha. Se o processo não puder ser executado temporariamente, o método retorna ara::crypto::CryptoErrc::kBusyResource com semântica de rollback [SWS_CRYPT_40621]. Além disso, diretrizes de configuração e de modelagem devem ser atendidas, pois, caso contrário, serão reportadas violações em tempo de execução [SWS_CRYPT_40621]:

• ProcessMappingViolation: É disparado caso o instanceSpecifier não aponte para um PortPrototype modelado para o processo atual, o qual é tipificado por um CryptoCertificateInterface [SWS_CRYPT_40621].
• InsufficientPermissionsViolation: Ocorre quando não há permissão de escrita para o processo atual (CryptoCertificateToPortPrototypeMapping.writeAccess != True) [SWS_CRYPT_40621].

Concorrência e contexto de execução

A operação é especificada como thread-safe e exception safe (noexcept=0), pela qual chamadas concorrentes são protegidas sem bloqueios externos [SWS_CRYPT_40621].

usar

O método ImportCertificateInGroup da classe ara::crypto::x509::X509Provider armazena persistentemente um certificado fornecido num grupo de certificados identificado através de instanceSpecifier [SWS_CRYPT_50127]. São passados como parâmetros uma referência para o ara::core::InstanceSpecifier do grupo de destino, bem como um smart pointer para o certificado (Certificate::Sptrc certificate) [SWS_CRYPT_50127]. A chamada é declarada através do cabeçalho ara/crypto/x509/x509_provider.h e retorna sincronicamente um ara::core::Result<void>, que assinala a importação bem-sucedida ou encapsula um estado de erro [SWS_CRYPT_50127].

Tratamento de erros e violações

No caso de erro regular, a operação oferece semântica de rollback e retorna códigos de erro específicos no objeto Result [SWS_CRYPT_50127]:

• ara::crypto::CryptoErrc::kInsufficientCapacity: A capacidade do grupo de certificados endereçado não é suficiente para acomodar o certificado [SWS_CRYPT_50127].
• ara::crypto::CryptoErrc::kBusyResource: A operação temporariamente não pode ser realizada porque o recurso necessário está ocupado [SWS_CRYPT_50127].

Além disso, estão definidos requisitos vinculativos de modelação e de autorização cujo incumprimento é classificado como Violations [SWS_CRYPT_50127]:

• ProcessMappingViolation: Ocorre se o InstanceSpecifier não apontar para um PortPrototype modelado para o processo atual que seja tipificado por um CryptoCertificateGroupInterface [SWS_CRYPT_50127].
• InsufficientPermissionsViolation: Ocorre se o processo chamador não possuir permissão de escrita, o que é caraterizado por CryptoCertificateGroupToPortPrototypeMapping.writeAccess != True [SWS_CRYPT_50127].

Concorrência e contexto de execução

A interface está especificada como segura para threads (thread-safe) e segura para exceções (exception safe), e declarada com noexcept [SWS_CRYPT_50127].

O método ImportCrl da classe ara::crypto::x509::X509Provider analisa sintaticamente e persiste uma Certificate Revocation List (CRL) ou Delta CRL emitida pelo certificado de CA identificado através de crlInstanceSpecifier [SWS_CRYPT_50183]. A execução deve ocorrer de forma síncrona, uma vez que é retornado imediatamente um ara::core::Result. Pergunta Q-648a00ec967c7524 (aberta)

Na chamada, são passados os seguintes parâmetros [SWS_CRYPT_50183]:

• crlInstanceSpecifier: ara::core::InstanceSpecifier para o RPortPrototype de um CryptoCertificateInterface, que identifica o certificado.
• crl: ReadOnlyMemRegion com os dados serializados da CRL ou Delta CRL.
• formatId: Formato da CRL serializada.

A operação está especificada como thread-safe bem como exception safe [SWS_CRYPT_50183]. Em caso de sucesso, fornece um ara::core::Result com o estado CertificateValidationStatus::kValid ou o resultado da validação da CRL [SWS_CRYPT_50183].

Em caso de erro, os valores de retorno possuem semântica de rollback [SWS_CRYPT_50183]:

• ara::crypto::CryptoErrc::kInvalidArgument: A CRL não corresponde ao formato especificado.
• ara::crypto::CryptoErrc::kUnsupportedFormat: A FormatId indicada é desconhecida ou não é suportada.
• ara::crypto::CryptoErrc::kBusyResource: temporariamente não é possível executar a operação.

Adicionalmente, devem ser cumpridos requisitos de configuração [SWS_CRYPT_50183]: Ocorre uma ProcessMappingViolation se o identificador de instância não referenciar uma porta modelada para o processo atual, e uma InsufficientPermissionsViolation se CryptoCertificateToPortPrototypeMapping.writeAccess != True estiver definido.

O método LoadCertificate da interface ara::crypto::x509::X509Provider serve para carregar um certificado a partir do armazenamento de certificados persistente [SWS_CRYPT_40641]. A chamada é executada de forma síncrona (interpretação: retorno direto de ara::core::Result sem um objeto futuro assíncrono como ara::core::Future). Pergunta Q-a2e3c23a02b4f8a1 (aberta) Como parâmetro de entrada, a função espera um ara::core::InstanceSpecifier que identifica o local de armazenamento concreto do certificado [SWS_CRYPT_40641].

Em caso de execução bem-sucedida, o valor de retorno encapsula um smart pointer para o certificado instanciado (Certificate::Sptrc) em um ara::core::Result [SWS_CRYPT_40641]. Se o carregamento falhar, o resultado contém um código de erro:

• ara::crypto::CryptoErrc::kEmptyCertificateSlot: Ocorre com semântica de rollback caso o CryptoCertificate identificado pelo instanceSpecifier indicado não contenha nenhum certificado persistido [SWS_CRYPT_40641].

No que diz respeito à concorrência e à segurança contra exceções, LoadCertificate é especificado como thread-safe bem como exception-safe e declarado como noexcept [SWS_CRYPT_40641]. Na configuração e atribuição de processos, deve-se observar uma condição de modelagem: se o instanceSpecifier transmitido não referenciar um PortPrototype modelado para o processo atual, que seja tipificado por um CryptoCertificateInterface, haverá uma ProcessMappingViolation [SWS_CRYPT_40641].

O método ara::crypto::x509::X509Provider::LoadCertificateGroup serve para carregar um grupo de certificados do armazenamento persistente de certificados de acordo com [SWS_CRYPT_50126].

Utilização e contexto de chamada

A chamada é feita através de uma instância de X509Provider do cabeçalho ara/crypto/x509/x509_provider.h. Como parâmetro de entrada, a função espera um instanceSpecifier do tipo const ara::core::InstanceSpecifier&, que identifica a localização lógica de armazenamento do grupo de certificados pretendido [SWS_CRYPT_50126]. Como resultado, a interface retorna um ara::core::Result<ara::core::Vector<Certificate::Sptrc>>, que, em caso de sucesso, disponibiliza um vetor com smart pointers para os certificados carregados [SWS_CRYPT_50126]. Na ausência de tipos de retorno assíncronos como ara::core::Future, o acesso ao armazenamento persistente deve ocorrer de forma síncrona e bloqueante. Pergunta Q-b743367ccc9904ab (aberta)

Tratamento de erros e restrições de modelação

Na especificação não estão definidos códigos de erro padronizados para o valor de retorno [SWS_CRYPT_50126]. No entanto, está predefinida uma verificação em tempo de execução: se o instanceSpecifier passado não referenciar um PortPrototype modelado para o processo atual que seja tipificado por um CryptoCertificateGroupInterface, ocorre uma ProcessMappingViolation [SWS_CRYPT_50126].

Simultaneidade e segurança contra exceções

O método puramente virtual está anotado com noexcept e especificado como seguro para exceções (exception safe). Além disso, a chamada está explicitamente declarada como segura para threads (thread-safe), pelo que acessos de leitura paralelos a partir de múltiplas threads são seguros [SWS_CRYPT_50126].

O método ParseCert é parte integrante da classe ara::crypto::x509::X509Provider (definida no cabeçalho ara/crypto/x509/x509_provider.h) e serve para analisar uma representação serializada de um certificado X.509v3 e instanciar um objeto de certificado correspondente [SWS_CRYPT_40614].

Chamada e parâmetros: a função é chamada de forma síncrona e está especificada como noexcept [SWS_CRYPT_40614]. Ela recebe dois parâmetros de entrada:

• cert: uma região de memória do tipo ReadOnlyMemRegion que fornece os dados do certificado codificados no formato especificado [SWS_CRYPT_40614].
• formatId: o identificador do formato de entrada para determinar o procedimento de parsing [SWS_CRYPT_40614].

Valor de retorno e tratamento de erros: o resultado é retornado como ara::core::Result<Certificate::Sptrc>, que, em caso de sucesso, contém um shared pointer para o objeto de certificado criado [SWS_CRYPT_40614]. Se ocorrer um erro, aplica-se uma semântica de rollback com os seguintes códigos de erro específicos [SWS_CRYPT_40614]:

• ara::crypto::CryptoErrc::kInvalidArgument: o argumento cert não pode ser analisado como um certificado válido [SWS_CRYPT_40614].
• ara::crypto::CryptoErrc::kUnsupportedFormat: o formatId especificado é desconhecido ou não é suportado [SWS_CRYPT_40614].

Concorrência e implementação: a interface é expressamente especificada como segura contra exceções (exception safe) e segura para threads (thread-safe) [SWS_CRYPT_40614]. Como ParseCert está declarado como puramente virtual, a lógica de parsing real deve ser fornecida por um driver ou provedor de criptografia específico da plataforma [SWS_CRYPT_40614]. Pergunta Q-d3239d62d2e7d831 (aberta)

usar

O método ParseCertChain da interface ara::crypto::x509::X509Provider do cabeçalho ara/crypto/x509/x509_provider.h analisa uma representação serializada de uma cadeia de certificados [SWS_CRYPT_40616]. Como parâmetros, ele recebe a região de memória da cadeia de certificados codificada certChain como ReadOnlyMemRegion, bem como o identificador de formato formatId do tipo FormatId [SWS_CRYPT_40616]. Para cada certificado analisado com sucesso, é criada uma nova instância de Certificate. Em caso de sucesso, a função síncrona retorna um ara::core::Result com um ara::core::Vector<Certificate::Sptrc>, no qual os certificados estão dispostos na mesma ordem que na cadeia passada [SWS_CRYPT_40616].

Tratamento de erros

Em caso de erro, o ara::core::Result retornado contém um código de erro específico com semântica de rollback [SWS_CRYPT_40616]:

• ara::crypto::CryptoErrc::kInvalidArgument: o argumento certChain não pode ser analisado [SWS_CRYPT_40616].
• ara::crypto::CryptoErrc::kUnsupportedFormat: o identificador especificado formatId é desconhecido ou não é suportado [SWS_CRYPT_40616].

Simultaneidade e condições marginais

O método é declarado como noexcept, especificado como seguro para threads (thread-safe) e garante segurança contra exceções (exception safe) [SWS_CRYPT_40616].

Utilização e contexto de chamada

O método síncrono ParseOcspResponse faz parte da interface ara::crypto::x509::X509Provider (definida em ara/crypto/x509/x509_provider.h) e serve para a leitura e análise sintática de respostas OCSP serializadas [SWS_CRYPT_50185]. O chamador passa os dados brutos da resposta como ReadOnlyMemRegion através do parâmetro response, bem como o formato de dados esperado através de formatId do tipo FormatId [SWS_CRYPT_50185]. Em caso de validação e processamento bem-sucedidos, a função retorna um ara::core::Result que encapsula um smart pointer OcspResponse::Sptrc para o objeto de resposta OCSP recém-criado [SWS_CRYPT_50185].

Tratamento de erros

As situações de erro são sinalizadas sem lançamento de exceções através do tipo de retorno ara::core::Result com semântica de rollback [SWS_CRYPT_50185]:

• ara::crypto::CryptoErrc::kInvalidArgument: Ocorre se os bytes fornecidos no buffer response não puderem ser analisados como uma resposta OCSP válida [SWS_CRYPT_50185].
• ara::crypto::CryptoErrc::kUnsupportedFormat: É reportado caso o identificador passado formatId seja desconhecido ou não seja suportado pelo provider [SWS_CRYPT_50185].

Concorrência e segurança de threads

O método puramente virtual está declarado como noexcept, classificado como seguro para exceções (exception safe) e explicitamente especificado como seguro para threads (thread-safe) [SWS_CRYPT_50185]. Graças à declaração const, ParseOcspResponse pode ser chamado concorrentemente em ambientes multithreading na mesma instância do provider sem modificar o estado interno do objeto [SWS_CRYPT_50185].

usar

O método de interface síncrono RemoveCertificateFromGroup do âmbito ara::crypto::x509::X509Provider serve para a remoção direcionada de um certificado de um grupo de certificados existente [SWS_CRYPT_50128]. Através do parâmetro instanceSpecifier, é identificado o grupo de certificados em causa, enquanto certificate, como smart pointer (Certificate::Sptrc), disponibiliza o certificado a remover [SWS_CRYPT_50128]. A chamada retorna um ara::core::Result<void>, que confirma a conclusão bem-sucedida sem valor de retorno ou encapsula um erro ocorrido [SWS_CRYPT_50128].

Tratamento de erros

Se ocorrer um erro durante a execução, aplica-se uma semântica de rollback definida, de modo que o estado do grupo de certificados permanece inalterado [SWS_CRYPT_50128]. Estão especificados os seguintes códigos de erro:

• ara::crypto::CryptoErrc::kNoSuchValue: O grupo de certificados especificado não contém o certificado a remover [SWS_CRYPT_50128].
• ara::crypto::CryptoErrc::kBusyResource: A operação temporariamente não pode ser realizada porque os recursos necessários estão ocupados [SWS_CRYPT_50128].

Concorrência e condições de configuração

O método está especificado como thread-safe e exception safe, bem como declarado com noexcept [SWS_CRYPT_50128]. Antes da chamada, têm de estar obrigatoriamente cumpridos os seguintes requisitos para o processo no modelo do sistema [SWS_CRYPT_50128]:

• Para evitar uma ProcessMappingViolation, o InstanceSpecifier passado tem de apontar para um PortPrototype tipificado por um CryptoCertificateGroupInterface modelado para o processo atual [SWS_CRYPT_50128].
• Para evitar uma InsufficientPermissionsViolation, o processo atual tem de dispor de direitos de escrita, ou seja, CryptoCertificateGroupToPortPrototypeMapping.writeAccess tem de estar configurado para True [SWS_CRYPT_50128].