DEENESPTFRRUARHIKOZHNL

módulo ara::crypto — Cryptography

Spezifikation: AUTOSAR_AP_SWS_Cryptography.pdf (R25-11) · 387 API-Records

Guia do móduloGERADO POR IA

Disponibiliza operações criptográficas isoladas, gerenciamento de chaves e serviços de certificados X.509 para aplicações.
GERADO POR IA não revisado Modelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: b84ff51de547 Procedência Perguntas em aberto (1)
Âncora causal: R25-11 Válido a partir de R25-11 Sintetizado para esta versão de especificação.
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão

Disponibiliza operações criptográficas isoladas, gerenciamento de chaves e serviços de certificados X.509 para aplicações.

O cluster funcional Cryptography fornece serviços padronizados de segurança para criptografia simétrica e assimétrica, verificação de assinaturas, bem como gerenciamento seguro de chaves e certificados (PlatformDesign p. 71). O acesso a operações criptográficas e posições persistentes de chaves ocorre de forma estritamente isolada por meio de provedores específicos da plataforma e especificadores de instância ancorados declarativamente no manifesto (SWS Cryptography p. 39). A aplicação de restrições de uso impede, assim, o comprometimento do material sensível de chave ([SWS_CRYPT_50092]).

O cluster funcional Cryptography (ara::crypto) fornece uma arquitetura de segurança abrangente para a AUTOSAR Adaptive Platform (PlatformDesign p. 71). Para a proteção contra aplicações de usuário comprometidas, o armazenamento de chaves e a execução criptográfica são tipicamente encapsulados em um daemon isolado da plataforma ou em um módulo de segurança em hardware (HSM) (AUTOSAR AP EXP SWArchitecture p. 97, SWS Cryptography p. 87). A funcionalidade geral divide-se em CryptoProvider especializadas para primitivas de cálculo, a área de armazenamento de chaves para posições persistentes de chave (KeySlots) e um X509Provider em nível de máquina para o gerenciamento de certificados PKI (SWS Cryptography p. 39).

diag_crypto_arch App Adaptive Application Daemon Cryptography Daemon (ara::crypto) App->Daemon IPC / C++ API CryptoProvider CryptoProvider (HSM / Driver / Software) Daemon->CryptoProvider Primitive Execution KeyStorage Key Storage Provider (KeySlots) Daemon->KeyStorage Key Lifecycle X509Prov X.509 Provider (Certificates / CRL) Daemon->X509Prov PKI Services KeyStorage->CryptoProvider Key Deployment

Diagrama de contexto: relações de arquitetura e componentes do Functional Cluster Cryptography entre aplicação, daemon e provedores. Fontes: SWS Cryptography p. 39, PlatformDesign p. 71, AUTOSAR AP EXP SWArchitecture p. 97.

As aplicações criam contextos criptográficos, como cifras simétricas ([SWS_CRYPT_20742]), cifras autenticadas ([SWS_CRYPT_20745]), funções de hash ([SWS_CRYPT_20747]) ou instâncias de Signer e Verifier ([SWS_CRYPT_20756], [SWS_CRYPT_20757]), por meio de seu provedor (AUTOSAR AP EXP SWArchitecture p. 99). O processamento segue um ciclo de vida determinístico: após a vinculação da chave (SetKey), a transformação é iniciada via Start(), transmitida em fluxo via Update() e finalizada com Finish() (AUTOSAR AP TR SystemTests p. 206, EXP SWArchitecture p. 104). AllowedUsageFlags imutáveis impedem eficazmente o uso não autorizado de chaves ([SWS_CRYPT_50092], AUTOSAR AP TR SystemTests p. 177).

diag_context_state Uninit Uninitialized Ready Ready (Key Deployed) Uninit->Ready SetKey() Ready->Uninit Reset() Streaming Processing (Started / Update) Ready->Streaming Start() Streaming->Uninit Cancel() / Reset() Streaming->Streaming Update() / UpdateConfidentialData() Finished Finished / Digest Available Streaming->Finished Finish() / FinishEncrypt() Finished->Uninit Reset() Finished->Ready Start() (Re-use)

Diagrama de estados: ciclo de vida de contextos de transformação criptográfica, desde a alocação até o reset. Fontes: [SWS_CRYPT_20742], [SWS_CRYPT_23911], [SWS_CRYPT_23625], [SWS_CRYPT_50046], [SWS_CRYPT_50212].

Certificados e CSRs são gerenciados via X509Provider ([SWS_CRYPT_40099], [SWS_CRYPT_40640]), enquanto contextos de validação verificam cadeias de certificados considerando listas de revogação CRL ([SWS_CRYPT_50183]) e respostas OCSP ([SWS_CRYPT_50124]) (AUTOSAR AP TR SystemTests p. 194). A atribuição de KeySlots e certificados a aplicações ocorre de forma baseada em modelo no manifesto via InstanceSpecifier (AUTOSAR AP TPS ManifestSpecification p. 245, AUTOSAR AP TPS ManifestSpecification p. 649). Todas as interfaces operam com retornos ara::core::Result sem exceções e sinalizam erros por meio de CryptoErrorDomain ([SWS_CRYPT_19902], SWS Cryptography p. 208).

Arquitetura, domínios de segurança e isolamento de daemon

O cluster funcional Cryptography (ara::crypto) forma a base central de segurança da AUTOSAR Adaptive Platform e fornece mecanismos criptográficos básicos, gerenciamento de chaves e serviços de certificados (PlatformDesign p. 71). De acordo com o modelo de confiança da plataforma, os clusters funcionais da plataforma pertencem à base confiável, enquanto as Adaptive Applications são executadas no espaço de usuário não privilegiado (SWS Cryptography p. 37). Para proteger eficazmente o material de chave e as operações criptográficas mesmo em caso de um potencial comprometimento de uma aplicação, a arquitetura é tipicamente projetada com base em daemon; a execução propriamente dita e o armazenamento de chaves permanecem em um processo isolado da plataforma ou em um ambiente de execução seguro (AUTOSAR AP EXP SWArchitecture p. 97, SWS Cryptography p. 87).

A arquitetura divide a funcionalidade criptográfica em três domínios primários: o CryptoProvider para primitivas de cálculo e transformações de chaves, a área de armazenamento de chaves (ara::crypto::keys) para a retenção persistente de objetos e o X509Provider (ara::crypto::x509) para o gerenciamento de certificados (SWS Cryptography p. 39, SWS Cryptography p. 87). Em uma unidade de controle eletrônico, podem coexistir em paralelo várias instâncias especializadas de CryptoProvider, por exemplo, para a conexão de diferentes módulos de segurança em hardware (HSM, TPM) ou drivers baseados em software (SWS Cryptography p. 39). No entanto, não há propositadamente interoperabilidade entre provedores diferentes: um objeto criptográfico ou uma chave pertence exatamente a um provedor e não pode ser processado por outro provedor (SWS Cryptography p. 39). É provável que esse encapsulamento estrito se deva principalmente ao fato de que os domínios de segurança de hardware impõem seus limites de chaves fisicamente e os identificadores de chaves não são válidos entre domínios. Pergunta Q-63efe107cf111983 (aberta)

diag_crypto_arch App Adaptive Application Daemon Cryptography Daemon (ara::crypto) App->Daemon IPC / C++ API CryptoProvider CryptoProvider (HSM / Driver / Software) Daemon->CryptoProvider Primitive Execution KeyStorage Key Storage Provider (KeySlots) Daemon->KeyStorage Key Lifecycle X509Prov X.509 Provider (Certificates / CRL) Daemon->X509Prov PKI Services KeyStorage->CryptoProvider Key Deployment

Diagrama de contexto: relações de arquitetura e componentes do Functional Cluster Cryptography entre aplicação, daemon e provedores. Fontes: SWS Cryptography p. 39, PlatformDesign p. 71, AUTOSAR AP EXP SWArchitecture p. 97.

Pontos de entrada e inicialização dos provedores criptográficos

A entrada no módulo ocorre por meio de funções globais de entrada, que servem como fábricas para as interfaces centrais de abstração (SWArchitecture p. 71). As aplicações criam ou carregam uma instância de um CryptoProvider por meio da função [SWS_CRYPT_20099], especificando um ara::core::InstanceSpecifier modelado. Para o gerenciamento de certificados, existe exatamente um provedor de certificados global em todo o sistema, que é carregado via [SWS_CRYPT_40099] (SWS Cryptography p. 39). Adicionalmente, estão disponíveis serviços auxiliares globais, incluindo a geração direta de dados aleatórios via [SWS_CRYPT_30098] e a consulta a um contador de segurança baseado em hardware via [SWS_CRYPT_20098] (SWArchitecture p. 71).

Recursos de chaves persistentes não são instanciados diretamente, mas carregados por meio de posições lógicas de chave (KeySlots). Para isso, o ambiente de execução disponibiliza as funções [SWS_CRYPT_50004] para acessos somente de leitura e [SWS_CRYPT_50005] para posições graváveis de chave, que validam o identificador de instância transmitido em relação à configuração de permissões (SWS Cryptography p. 87, AUTOSAR AP TPS ManifestSpecification p. 649). Por meio de uma instância de KeySlot obtida, a instância do provedor associado pode ser consultada através de [SWS_CRYPT_30403], garantindo que a forte vinculação entre o local de armazenamento e o ambiente de execução seja mantida (SWS Cryptography p. 39).

Assim que uma instância de CryptoProvider está disponível, ela atua como uma fábrica central para a instanciação de contextos de trabalho criptográficos específicos (AUTOSAR AP EXP SWArchitecture p. 99). Entre os contextos passíveis de criação estão, entre outros, contextos para geradores de números aleatórios ([SWS_CRYPT_20741]), cifras simétricas de bloco e de fluxo ([SWS_CRYPT_20742]), criptografia autenticada ([SWS_CRYPT_20745]), Message Authentication Codes ([SWS_CRYPT_20746]), funções de hash criptográficas ([SWS_CRYPT_20747]), criptografia ou descriptografia assimétrica ([SWS_CRYPT_20750], [SWS_CRYPT_20751]), bem como contextos de assinatura e verificação ([SWS_CRYPT_20756], [SWS_CRYPT_20757]) (EXP SWArchitecture p. 99).

Contextos de transformação criptográfica e processamento de dados

O processamento de dados criptográficos em ara::crypto segue um ciclo de vida estritamente baseado em estados, o que garante o desacoplamento entre configuração do algoritmo, vinculação da chave e processamento em fluxo (AUTOSAR AP TR SystemTests p. 211). Após a alocação do contexto por meio do provedor, ele se encontra inicialmente no estado não inicializado. Apenas com a passagem de uma chave compatível por meio das sobrecargas específicas de tipo de SetKey() – por exemplo, para chaves simétricas ([SWS_CRYPT_23911]), chaves privadas ([SWS_CRYPT_23515]) ou diretamente de um KeySlot ([SWS_CRYPT_50043]) – o contexto transita para o estado pronto (AUTOSAR AP TR SystemTests p. 206).

Para processamentos em fluxo, a transformação é iniciada por Start(), opcionalmente com a passagem de um vetor de inicialização ou contexto ([SWS_CRYPT_22110], [SWS_CRYPT_23625], [SWS_CRYPT_50020]). Em seguida, blocos de dados podem ser alimentados passo a passo via Update() ([SWS_CRYPT_21113], [SWS_CRYPT_22113], [SWS_CRYPT_50139]). Na criptografia autenticada (AEAD), a interface separa estritamente os dados associados, processados via [SWS_CRYPT_20313], dos dados úteis confidenciais via [SWS_CRYPT_50074] (EXP SWArchitecture p. 104). A conclusão de uma transformação ocorre via Finish() ou FinishEncrypt() ([SWS_CRYPT_21115], [SWS_CRYPT_23618], [SWS_CRYPT_50075]), após o que tags de autenticação ou somas de verificação podem ser lidas via GetDigest() ([SWS_CRYPT_21116], [SWS_CRYPT_22116]).

Além do modo de streaming, classes de contexto como cifras simétricas e cifras autenticadas suportam chamadas únicas compactas via [SWS_CRYPT_50047] ou [SWS_CRYPT_50078], permitindo que payloads curtos sejam cifrados ou decifrados com eficiência sem chamadas de protocolo em múltiplas etapas (SWS Cryptography p. 58). Se uma operação em andamento precisar ser cancelada, uma chamada de Cancel() ([SWS_CRYPT_50023], [SWS_CRYPT_50046]) ou Reset() ([SWS_CRYPT_50212]) retorna o contexto de forma determinística ao estado inicial limpo (EXP SWArchitecture p. 100).

diag_context_state Uninit Uninitialized Ready Ready (Key Deployed) Uninit->Ready SetKey() Ready->Uninit Reset() Streaming Processing (Started / Update) Ready->Streaming Start() Streaming->Uninit Cancel() / Reset() Streaming->Streaming Update() / UpdateConfidentialData() Finished Finished / Digest Available Streaming->Finished Finish() / FinishEncrypt() Finished->Uninit Reset() Finished->Ready Start() (Re-use)

Diagrama de estados: ciclo de vida de contextos de transformação criptográfica, desde a alocação até o reset. Fontes: [SWS_CRYPT_20742], [SWS_CRYPT_23911], [SWS_CRYPT_23625], [SWS_CRYPT_50046], [SWS_CRYPT_50212].

Gerenciamento de chaves, encapsulamento e aplicação de permissões

Chaves criptográficas são tipificadas no modelo de objetos como CryptoObject ou RestrictedUseObject (AUTOSAR AP EXP SWArchitecture p. 111, EXP SWArchitecture p. 111). O padrão da plataforma distingue entre chaves simétricas (SymmetricKey), chaves privadas assimétricas (PrivateKey) e chaves públicas (PublicKey) (SWS Cryptography p. 291). O material de chave pode ser gerado diretamente através do CryptoProvider ([SWS_CRYPT_20721], [SWS_CRYPT_20722]) ou derivado a partir de material de chave existente parametrizando um KeyDerivationFunctionCtx ([SWS_CRYPT_20748]) com uma chave base e executando-o via [SWS_CRYPT_21515] (EXP SWArchitecture p. 108).

Para a aplicação do princípio do menor privilégio, cada objeto de chave contém restrições de uso imutáveis (AllowedUsageFlags), que podem ser consultadas via [SWS_CRYPT_50092] (AUTOSAR AP TR SystemTests p. 177). A pilha de criptografia valida a cada tentativa de vinculação (SetKey) se a operação do contexto de destino (por exemplo, criptografar, assinar, derivar ou exportar) está autorizada pelas flags da chave e rejeita estritamente utilizações não permitidas (AUTOSAR AP TR SystemTests p. 177, SWArchitecture p. 95). A atribuição padrão para um algoritmo pode ser determinada via [SWS_CRYPT_20955].

Para a troca segura de chaves, o módulo implementa vários procedimentos padronizados: no acordo de chaves assimétricas (Diffie-Hellman / ECDH), cria-se via [SWS_CRYPT_20758] um KeyAgreementPrivateCtx ao qual a chave privada é vinculada ([SWS_CRYPT_21313]); o método [SWS_CRYPT_21312] calcula em seguida, com a inclusão da chave pública da contraparte, a chave simétrica de destino compartilhada (AUTOSAR AP TR SystemTests p. 179). No Key Encapsulation Mechanism (KEM), um KeyEncapsulatorPublicCtx ([SWS_CRYPT_20752]) encapsula uma chave simétrica por meio de [SWS_CRYPT_21813], enquanto a contraparte realiza o desencapsulamento por meio de um KeyDecapsulatorPrivateCtx ([SWS_CRYPT_20753]) via [SWS_CRYPT_21412] (AUTOSAR AP TR SystemTests p. 173, AUTOSAR TR AdaptivePlatformSystemTests p. 188). Para o transporte protegido de chaves, estão disponíveis o Key Wrapping ([SWS_CRYPT_24014], [SWS_CRYPT_24016]) e a exportação protegida ([SWS_CRYPT_20728]) (AUTOSAR AP TR SystemTests p. 174, AUTOSAR AP TR SystemTests p. 182).

Acordo de chaves assimétrico (ECDH) e derivação simétricaApp (CRYPTOApp01)CryptoProviderKeyAgreementPrivateCtxSymmetricKeyCreateKeyAgreementPrivateCtx(algId)Result<KeyAgreementPrivateCtx::Sptr>SetKey(privKey)Result<void>AgreeKey(otherSidePublicKey, targetAlgId, allowedUsage)Criar objeto de chave simétricaResult<SymmetricKey::Sptr>

Diagrama de sequência: acordo de chaves assimétricas via Diffie-Hellman e derivação de chaves úteis simétricas. Fontes: [SWS_CRYPT_20758], [SWS_CRYPT_21313], [SWS_CRYPT_21312], AUTOSAR AP TR SystemTests p. 179.

Assinaturas assimétricas são processadas por meio de contextos separados: a assinatura ocorre via um SignerPrivateCtx ([SWS_CRYPT_20756]) e o método [SWS_CRYPT_23512], enquanto a verificação é realizada via um VerifierPublicCtx ([SWS_CRYPT_20757]) e o método [SWS_CRYPT_24112] (AUTOSAR AP TR SystemTests p. 164, SWArchitecture p. 84). Se um KeySlot for atualizado em segundo plano por serviços privilegiados de gerenciamento (por exemplo, OTA-Key-Rollover), bibliotecas consumidoras podem ser notificadas por meio de um observador de atualização via [SWS_CRYPT_30404] para recarregar seu material de chave sincronicamente (AUTOSAR AP SWS Cryptography p. 36).

Geração e verificação de assinatura via SignerPrivateCtx e VerifierPublicCtxApplikationCryptoProviderSignerPrivateCtxVerifierPublicCtxCreateSignerPrivateCtx(algId)Result<SignerPrivateCtx::Sptr>SetKey(privKey)Result<void>Sign(message, signatureBuffer, format)Result<std::size_t> (tamanho da assinatura)Use Case: Verificação da assinaturaCreateVerifierPublicCtx(algId)Result<VerifierPublicCtx::Sptr>SetKey(pubKey)Result<void>Verify(message, signature, format)Result<bool> (Válido / Inválido)

Diagrama de sequência: fluxo de geração e verificação de assinatura com uso de contextos privados e públicos separados. Fontes: [SWS_CRYPT_20756], [SWS_CRYPT_23515], [SWS_CRYPT_23512], [SWS_CRYPT_20757], [SWS_CRYPT_24115], [SWS_CRYPT_24112], AUTOSAR AP TR SystemTests p. 164.

Gerenciamento de certificados X.509, validação e grupos

O subsistema ara::crypto::x509 fornece funções padronizadas para infraestruturas de chaves públicas (PKI) (EXP SWArchitecture p. 116). O X509Provider central ([SWS_CRYPT_40099]) suporta tanto armazenamento volátil de sessão quanto repositórios persistentes (SWS Cryptography p. 39). Certificados e cadeias são analisados a partir de buffers de bytes via [SWS_CRYPT_40614] ou [SWS_CRYPT_40616]. Para a solicitação de novos certificados de identidade, as aplicações podem gerar Certificate Signing Requests (CSR) assinadas criptograficamente via [SWS_CRYPT_40640], sendo o contexto do Signer e o Distinguished Name (DN) passados via [SWS_CRYPT_50186] (AUTOSAR AP TR SystemTests p. 189).

Para a verificação de conformidade e validade, a aplicação instancia um CertificateValidationCtx via [SWS_CRYPT_50125]. A esse contexto são adicionadas âncoras de confiança (Trust Anchors) via [SWS_CRYPT_50117], opções de validação são definidas via [SWS_CRYPT_50120] e timestamps de referência são armazenados via [SWS_CRYPT_50121]. A verificação hierárquica da cadeia em relação à cadeia de confiança ocorre via [SWS_CRYPT_50122] ou [SWS_CRYPT_50123] (AUTOSAR AP TR SystemTests p. 194). Para o registro de revogações de certificados, podem ser importadas Certificate Revocation Lists (CRL) ([SWS_CRYPT_50183]) ou integradas consultas de status de certificado online (OCSP conforme RFC 6960) ao status de validação via [SWS_CRYPT_40626], [SWS_CRYPT_50185] e [SWS_CRYPT_50124] (AUTOSAR AP TR SystemTests p. 194).

Para desacoplar os consumidores de certificados de instâncias individuais de certificados durante trocas de chaves, o manifesto suporta o conceito de CryptoCertificateGroup (AUTOSAR AP TPS ManifestSpecification p. 657). As aplicações consumidoras carregam todo o grupo de certificados logicamente vinculados por meio de [SWS_CRYPT_50126], enquanto serviços de administração privilegiados podem substituir ou limpar certificados dinamicamente via [SWS_CRYPT_50127] e [SWS_CRYPT_50128] (AUTOSAR AP TPS ManifestSpecification p. 657).

Validação de certificados X.509 com cadeia de certificados, CRL e OCSPApplikationX509ProviderValidationCtxCreateCertificateValidationCtx()Result<CertificateValidationCtx::Sptr>AddTrustedCertificate(rootCert)Result<void>ImportCrl(instanceSpecifier, crlBytes, format)Result<CertificateValidationStatus>AddOcspResponse(ocspResponse, issuerCert)Result<CertificateValidationStatus>ValidateCertificate(targetCert)Result<CertificateValidationResult::Sptrc>

Diagrama de sequência: validação de certificados X.509 com cadeia de certificados, importação de CRL e verificação online de status OCSP. Fontes: [SWS_CRYPT_40099], [SWS_CRYPT_50125], [SWS_CRYPT_50122], [SWS_CRYPT_50183], [SWS_CRYPT_50124], AUTOSAR AP TR SystemTests p. 194.

Modelagem de manifesto, interfaces de portas e deployment

A integração de recursos criptográficos em uma arquitetura veicular global ocorre de forma declarativa por meio do metamodelo AUTOSAR no manifesto ARXML (AUTOSAR AP TPS ManifestSpecification p. 244). Componentes de software modelam seus requisitos de segurança no nível de projeto através de portas (RPortPrototype), tipificadas por especializações de CryptoInterface: CryptoKeySlotInterface para slots de chave, CryptoCertificateInterface para recursos de certificado e CryptoProviderInterface para acesso a provedores de execução (TPS ManifestSpecification p. 167, AUTOSAR AP TPS ManifestSpecification p. 245). Os atributos das interfaces definem de maneira imutável se permissões de leitura ou escrita são concedidas (writeAccess) e quais tipos de objetos são permitidos (TPS ManifestSpecification p. 168, TPS ManifestSpecification p. 438).

No manifesto de deployment, a configuração de destino (Target Configuration) conecta os protótipos abstratos de porta a recursos físicos concretos da plataforma (AUTOSAR AP TPS ManifestSpecification p. 649). O elemento de metamodelo CryptoKeySlotToPortPrototypeMapping mapeia a porta de um processo para um CryptoModuleInstantiation declarado no CryptoKeySlot da máquina (TPS ManifestSpecification p. 614, TPS ManifestSpecification p. 646). De forma análoga, CryptoCertificateToPortPrototypeMapping associa certificados (TPS ManifestSpecification p. 655). Em tempo de execução, o caminho da porta no manifesto representa o ara::core::InstanceSpecifier, que o código da aplicação passa para funções de carregamento como [SWS_CRYPT_50004] (ManifestSpecification p. 154).

Para interações de plataforma entre clusters funcionais – por exemplo, entre o Communication Management (SecOC, IPsec, TLS) e a pilha de criptografia –, não existem protótipos de porta clássicos (TPS ManifestSpecification p. 861). Aqui, o InstanceSpecifier é formado, em vez disso, por elementos derivados de FunctionalClusterInteractsWithFunctionalClusterMapping, como ComKeyToCryptoKeySlotMapping ou SecOcJobMapping (TPS ManifestSpecification p. 861, TPS ManifestSpecification p. 864, ManifestSpecification p. 411). A proteção de persistência (Persistency Deployment) e os checksums de clusters de software também vinculam suas chaves e provedores por meio desses mapeamentos padronizados de manifesto (TPS ManifestSpecification p. 867, TPS ManifestSpecification p. 896).

Comportamento em caso de erro

O conceito de tratamento de erros do módulo de criptografia segue as rígidas diretrizes da Adaptive Platform para código à prova de falhas e livre de exceções (noexcept) (SWS Cryptography p. 145). Todas as operações síncronas retornam situações de erro por meio do tipo de resultado genérico ara::core::Result<T, ara::core::ErrorCode> (SWS Cryptography p. 208). Os códigos de erro estão ancorados em um domínio de erro próprio, representado por [SWS_CRYPT_19902]; seu nome pode ser consultado via [SWS_CRYPT_19950] e a descrição textual do erro via [SWS_CRYPT_19953]. Para aplicações que utilizam explicitamente o tratamento de exceções, a pilha disponibiliza o tipo de exceção CryptoException ([SWS_CRYPT_19906]) e a função auxiliar [SWS_CRYPT_19954].

Códigos de erro funcionais típicos abrangem violações de contexto como CryptoErrc::kUninitializedContext, quando operações criptográficas são iniciadas antes da chamada de SetKey(), ou CryptoErrc::kInvalidInputSize, quando os buffers de dados de entrada fornecidos não correspondem ao alinhamento de bloco exigido (SWS Cryptography p. 208). Em operações de serialização e conversão, CryptoErrc::kUnknownIdentifier sinaliza valores de argumentos não suportados e CryptoErrc::kIncompatibleArguments combinações incompatíveis de parâmetros (SWS Cryptography p. 145). Ao acessar recursos de chaves, a pilha impede acessos não autorizados retornando kAccessViolation (SWS Cryptography p. 87). Ao analisar extensões de certificado X.509 personalizadas incorretas, o analisador é interrompido com CryptoErrc::kRuntimeFault (SWS Cryptography p. 280, SWS Cryptography p. 356).

Para restabelecer um estado definido no contexto após a ocorrência de um erro e evitar vazamentos de memória ou buffers de streaming travados no daemon, o chamador deve limpar o contexto. Isso é feito de forma direcionada chamando Cancel() ([SWS_CRYPT_50046], [SWS_CRYPT_50089]), descartando transformações incompletas, ou por meio de Reset() ([SWS_CRYPT_50212]), o que redefine totalmente o contexto para o estado anterior à vinculação da chave (EXP SWArchitecture p. 100).

Evidências mais detalhadas

A especificação do módulo Cryptography baseia-se em uma série de requisitos centrais e documentos de arquitetura, classificados a seguir:

Este guia de módulo foi gerado por um assistente de curadoria baseado em IA com base na especificação R25-11 da AUTOSAR Adaptive.

function: 261 type alias: 43 variable: 43 class: 34 enumeration: 5 struct: 1

Mapa de temas

Vista de detalhes

Selecione uma entrada no índice.

ara::crypto

Crypto Error Domain class that provides interfaces as defined by ara::core::ErrorDomain such as a name of the Crypto Error Domain or message

herda de ara::core::ErrorDomain

Exception type thrown for CRYPTO errors.

herda de ara::core::Exception

Formatter classe

Formatter object interface.

128 bit secure counter made up of two uint64_t’s representing the most significant and least significant bits

Serializable object interface.

Return a reference to the global CryptoErrorDomain.

constexpr const ara::core::ErrorDomain & GetCryptoErrorDomain () noexcept;

This factory method shall create or return the existing instance of a specific Crypto Provider.

ara::core::Result< cryp::CryptoProvider::Sptr > LoadCryptoProvider (const ara::core::InstanceSpecifier &iSpecify) noexcept;
LoadFormatter função

Factory that creates a Formatter.

ara::core::Result< Formatter::Sptr > LoadFormatter () noexcept;
LoadKeySlot função

Load a read-only key slot. This factory method shall load the information associated with the specified KeySlot into a KeySlot object.

ara::core::Result< cryp::KeySlot::Sptr > LoadKeySlot (const ara::core::InstanceSpecifier &iSpecify) noexcept;

Load a writeable key slot. This factory method shall load the information associated with the specified KeySlot into a WriteableKeySlot object.

ara::core::Result< cryp::WriteableKeySlot::Sptr > LoadWriteableKeySlot (const ara::core::InstanceSpecifier &iSpecify) noexcept;

This factory method shall create or return the existing instance of the singleton X.509 Provider.

ara::core::Result< x509::X509Provider::Sptr > LoadX509Provider () noexcept;
MakeErrorCode função

Makes Error Code instances from the Crypto Error Domain. The returned ErrorCode instance always references to CryptoErrorDomain.

constexpr ara::core::ErrorCode MakeErrorCode (CryptoErrorDomain::Errc code, ara::core::ErrorDomain::SupportDataType data) noexcept;
CryptoErrc enumeração

Defines the error codes for the ara::crypto::CryptoErrorDomain

enum class CryptoErrc : ara::core::ErrorDomain::CodeType {...};
CryptoObjectType enumeração

Enumeration of all types of crypto objects, i.e. types of content that can be stored to a key slot.

enum class CryptoObjectType : std::uint8_t {...};
CryptoTransform enumeração

Enumeration of cryptographic transformation directions.

enum class CryptoTransform : std::uint8_t {...};
AlgId alias de tipo

Type for holding StringView of algorithm according to standardized format described in the chapter ’Naming Convention’.

using AlgId = ara::core::StringView;
AlgIdString alias de tipo

Type for holding String of algorithm according to standardized format described in the chapter ’Naming Convention’.

using AlgIdString = ara::core::String;
AllowedUsageFlags alias de tipo

Type for holding bit-flags of allowed usages of a key.

using AllowedUsageFlags = std::uint32_t;
FormatId alias de tipo

A container type for the encoding format identifiers.

using FormatId = std::uint32_t;
LoadCryptoProvider alias de tipo

Type for holding StringView of algorithm according to standardized format described in the chapter ’Naming Convention’.

ReadOnlyMemRegion alias de tipo

Read-Only Memory Region (intended for [in] arguments)

using ReadOnlyMemRegion = ara::core::Span<const std::uint8_t>;
ReadWriteMemRegion alias de tipo

Read-Write Memory Region (intended for [out] or [in/out] arguments)

using ReadWriteMemRegion = ara::core::Span<std::uint8_t>;
Timestamp alias de tipo

The key can be used for data decryption.

constexpr AllowedUsageFlags kAllowDataDecryption {0x0002};

The following constants define 1-bit values representing allowed usages. The key can be used for data encryption

constexpr AllowedUsageFlags kAllowDataEncryption {0x0001};

The derived key can be exported in plaintext.

constexpr AllowedUsageFlags kAllowDerivedPlaintextExport {0x4000};

The key can be used as input to a HashFunctionCtx.

constexpr AllowedUsageFlags kAllowHashCalculation {0x1000};

The key can be used as private or public input to key agreement.

constexpr AllowedUsageFlags kAllowKeyAgreement {0x0020};

The key can be used for key derivation.

constexpr AllowedUsageFlags kAllowKeyDerivation {0x0040};

The key can be used as a key encryption key for key unwrapping or key decapsulation.

constexpr AllowedUsageFlags kAllowKeyUnwrapping {0x0100};

The key can be used as a key encryption key for key wrapping or key encapsulation.

constexpr AllowedUsageFlags kAllowKeyWrapping {0x0080};
kAllowMac variável

The key can be used for MAC generation and verification.

constexpr AllowedUsageFlags kAllowMac {0x0004};
kAllowPersist variável

The key can persisted.

constexpr AllowedUsageFlags kAllowPersist {0x0200};

The key can be exported in plaintext.

constexpr AllowedUsageFlags kAllowPlaintextExport {0x2000};
kAllowRngInit variável

The symmetric key can be used for seeding of a RandomGeneratorCtx.

constexpr AllowedUsageFlags kAllowRngInit {0x0800};

The key can be securely exported (protected export)

constexpr AllowedUsageFlags kAllowSecuredExport {0x0400};

The key can be used for signature generation.

constexpr AllowedUsageFlags kAllowSigGeneration {0x0008};

The key can be used for signature verification.

constexpr AllowedUsageFlags kAllowSigVerification {0x0010};

Export DER-encoded value of an object.

constexpr FormatId kFormatDerEncoded {2};

Export PEM-encoded value of an object.

constexpr FormatId kFormatPemEncoded {3};

Export only raw value of an object, i.e., a plain byte array for symmetric keys and ISO/IEC 7816-8 / IEEE P1363 encoding for combined values.

constexpr FormatId kFormatRawValueOnly {1};

Proprietary format that is only valid in the context of a CryptoProvider.

constexpr FormatId kProprietaryFormat {0};

ara::crypto::cryp

Authenticated Cipher Context interface.

herda de CryptoContext

A common interface for all cryptographic objects recognizable by the Crypto Provider.

herda de ara::crypto::Serializable

base de PrivateKey, PublicKey, SymmetricKey

CryptoProviderInterface representing one implementation of a set of cryptographic primitives with a key storage.

Interface for asymmetric decryption.

herda de CryptoContext

Interface for asymmetric encryption.

herda de CryptoContext

Hash function interface.

herda de CryptoContext

Key Agreement Private key Context interface.

herda de CryptoContext

Asymmetric Key Encapsulation Mechanism (KEM) Private key Context interface.

herda de CryptoContext

Key Derivation Function interface.

herda de CryptoContext

Asymmetric Key Encapsulation Mechanism (KEM) Public key Context interface.

herda de CryptoContext

KeySlot classe

KeySlot interface representing a storage location for a key in a CryptoProvider.

base de WriteableKeySlot

Keyed Message Authentication Code Context interface definition.

herda de CryptoContext

PrivateKey classe

Generalized Asymmetric Private Key interface.

herda de CryptoObject

A contexts for importing secured data such as secret key-material.

herda de CryptoContext

PublicKey classe

General Asymmetric Public Key interface.

herda de CryptoObject

Interface of Random Number Generator Context.

herda de CryptoContext

Signature Private key Context interface.

herda de CryptoContext

Interface for Symmetric Cipher Operations.

herda de CryptoContext

Symmetric Key interface.

herda de CryptoObject

Context of a symmetric key wrap algorithm.

herda de CryptoContext

Signature Verification Public key Context interface.

herda de CryptoContext

WriteableKeySlot interface representing a writeable storage location for a key in a Crypto Provider.

herda de KeySlot

ara::crypto::x509

X.509 Certificate interface.

herda de ara::crypto::Serializable

Certificate Validation Context.

X.509 Certificate Validation Result.

Certificate Signing Request (CSR) object interface.

herda de ara::crypto::Serializable

Interface of OcspResponse.

X509DN classe

Interface of X.509 Distinguished Name (DN).

herda de ara::crypto::Serializable

X.509 Provider interface.

Certificate Validation Status.

enum class CertificateValidationStatus : std::uint8_t {...};
OcspResponseStatus enumeração

On-line Certificate Status Protocol (OCSP) Response Status.

enum class OcspResponseStatus : std::uint8_t {...};

Type for holding bit-flags of certificate validation options.

using CertificateValidationOptions = std::uint32_t;
X509ExtendedKeyUsage alias de tipo

X.509 v3 Extended Key Usage type definition.

using X509ExtendedKeyUsage = std::uint32_t;
X509KeyUsage alias de tipo

X.509 v3 Key Usage type definition.

using X509KeyUsage = std::uint32_t;
kClientAuth variável

TLS WWW client authentication.

constexpr X509ExtendedKeyUsage kClientAuth {0x4000};
kCodeSigning variável

Signing of downloadable executable code.

constexpr X509ExtendedKeyUsage kCodeSigning {0x2000};
kConstrCrlSign variável

The key can be used for Certificates Revokation Lists (CRL) signing.

constexpr X509KeyUsage kConstrCrlSign {0x0200};

The key can be used for data encipherment.

constexpr X509KeyUsage kConstrDataEncipherment {0x1000};

The enciphermet key can be used for deciphering only.

constexpr X509KeyUsage kConstrDecipherOnly {0x0080};

The key can be used for digital signature production.

constexpr X509KeyUsage kConstrDigitalSignature {0x8000};

The enciphermet key can be used for enciphering only.

constexpr X509KeyUsage kConstrEncipherOnly {0x0100};

The key can be used for a key agreement protocol execution.

constexpr X509KeyUsage kConstrKeyAgreement {0x0800};

The key can be used for certificates signing.

constexpr X509KeyUsage kConstrKeyCertSign {0x0400};

The key can be used for key encipherment.

constexpr X509KeyUsage kConstrKeyEncipherment {0x2000};

The key can be used in cases requiring the "non-repudiation" guarantee.

constexpr X509KeyUsage kConstrNonRepudiation {0x4000};

Email protection.

constexpr X509ExtendedKeyUsage kEmailProtection {0x1000};
kIgnoreCrl variável

ignore previously imported CRLs

constexpr CertificateValidationOptions kIgnoreCrl {0x0008};
kIgnoreNotAfter variável

ignore the NotAfter field

constexpr CertificateValidationOptions kIgnoreNotAfter {0x0002};

ignore the NotBefore field

constexpr CertificateValidationOptions kIgnoreNotBefore {0x0001};

ignore all unknown critical extensions

constexpr CertificateValidationOptions kIgnoreUnknownCritical Extensions {0x0004};
kOcspOff variável

do not require OCSP response during certificate validation. This is the default behavior.

constexpr CertificateValidationOptions kOcspOff {0x0040};

require OCSP response for all certificates of chain

constexpr CertificateValidationOptions kOcspResponseCompleteChain {0x0010};

require OCSP response only for target certificate

constexpr CertificateValidationOptions kOcspResponseTargetOnly {0x0020};
kOCSPSigning variável

Signing OCSP responses.

constexpr X509ExtendedKeyUsage kOCSPSigning {0x0400};
kServerAuth variável

TLS WWW server authentication.

constexpr X509ExtendedKeyUsage kServerAuth {0x8000};
kTimeStamping variável

Binding the hash of an object to a time.

constexpr X509ExtendedKeyUsage kTimeStamping {0x0800};

Namespaces

Diagrama de classes UML do módulo

Abgerundete Rahmen = Namespaces; hohle Dreieckspfeile = Vererbung (zeigt zur Basisklasse); graue Boxen = modulfremde bzw. externe Basisklassen. Klicken öffnet die Klassenseite.

G cluster_1 ara::crypto cluster_2 ara::crypto::cryp cluster_3 ara::crypto::x509 nara__crypto__Serializable855 Serializable nara__crypto__CryptoErrorDomain690 CryptoErrorDomain nara__core__ErrorDomain335 ara::core::ErrorDomain nara__crypto__CryptoErrorDomain690->nara__core__ErrorDomain335 nara__crypto__CryptoException764 CryptoException nara__core__Exception792 ara::core::Exception nara__crypto__CryptoException764->nara__core__Exception792 nara__crypto__Formatter631 Formatter nara__crypto__SecureCounter126 «struct» SecureCounter nara__crypto__cryp__AuthCipherCtx142 AuthCipherCtx nara__crypto__cryp__CryptoContext85 CryptoContext nara__crypto__cryp__AuthCipherCtx142->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__CryptoObject679 CryptoObject nara__crypto__cryp__CryptoObject679->nara__crypto__Serializable855 nara__crypto__cryp__DecryptorPrivateCtx616 DecryptorPrivateCtx nara__crypto__cryp__DecryptorPrivateCtx616->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__EncryptorPublicCtx829 EncryptorPublicCtx nara__crypto__cryp__EncryptorPublicCtx829->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__HashFunctionCtx412 HashFunctionCtx nara__crypto__cryp__HashFunctionCtx412->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__KeyAgreementPrivateCtx203 KeyAgreementPrivateCtx nara__crypto__cryp__KeyAgreementPrivateCtx203->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__KeyDecapsulatorPrivateCtx748 KeyDecapsulatorPrivateCtx nara__crypto__cryp__KeyDecapsulatorPrivateCtx748->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__KeyDerivationFunctionCtx485 KeyDerivationFunctionCtx nara__crypto__cryp__KeyDerivationFunctionCtx485->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__KeyEncapsulatorPublicCtx699 KeyEncapsulatorPublicCtx nara__crypto__cryp__KeyEncapsulatorPublicCtx699->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__KeySlot637 KeySlot nara__crypto__cryp__MessageAuthnCodeCtx845 MessageAuthnCodeCtx nara__crypto__cryp__MessageAuthnCodeCtx845->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__PrivateKey762 PrivateKey nara__crypto__cryp__PrivateKey762->nara__crypto__cryp__CryptoObject679 nara__crypto__cryp__ProtectedKeyImportCtx279 ProtectedKeyImportCtx nara__crypto__cryp__ProtectedKeyImportCtx279->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__PublicKey940 PublicKey nara__crypto__cryp__PublicKey940->nara__crypto__cryp__CryptoObject679 nara__crypto__cryp__RandomGeneratorCtx512 RandomGeneratorCtx nara__crypto__cryp__RandomGeneratorCtx512->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__SignerPrivateCtx943 SignerPrivateCtx nara__crypto__cryp__SignerPrivateCtx943->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__SymmetricCipherCtx167 SymmetricCipherCtx nara__crypto__cryp__SymmetricCipherCtx167->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__SymmetricKey111 SymmetricKey nara__crypto__cryp__SymmetricKey111->nara__crypto__cryp__CryptoObject679 nara__crypto__cryp__SymmetricKeyWrapperCtx465 SymmetricKeyWrapperCtx nara__crypto__cryp__SymmetricKeyWrapperCtx465->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__VerifierPublicCtx35 VerifierPublicCtx nara__crypto__cryp__VerifierPublicCtx35->nara__crypto__cryp__CryptoContext85 nara__crypto__cryp__WriteableKeySlot529 WriteableKeySlot nara__crypto__cryp__WriteableKeySlot529->nara__crypto__cryp__KeySlot637 nara__crypto__cryp__CryptoProvider844 CryptoProvider nara__crypto__x509__Certificate240 Certificate nara__crypto__x509__Certificate240->nara__crypto__Serializable855 nara__crypto__x509__CertSignRequest934 CertSignRequest nara__crypto__x509__CertSignRequest934->nara__crypto__Serializable855 nara__crypto__x509__X509DN930 X509DN nara__crypto__x509__X509DN930->nara__crypto__Serializable855 nara__crypto__x509__CertificateValidationCtx565 CertificateValidationCtx nara__crypto__x509__CertificateValidationResult372 CertificateValidationResult nara__crypto__x509__OcspResponse358 OcspResponse nara__crypto__x509__X509Provider937 X509Provider