Serve para o desempacotamento e importação seguros de chaves e dados criptográficos protegidos em uma aplicação.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: a42cd9e6f52bProcedênciaPerguntas em aberto (2)
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
Serve para o desempacotamento e importação seguros de chaves e dados criptográficos protegidos em uma aplicação.
A interface permite o desempacotamento e a importação seguros de dados e chaves criptográficas protegidos com o auxílio de uma chave de transporte configurada [SWS_CRYPT_50205]. O material de chave desempacotado pode ser gravado diretamente em um slot de chave persistente ou carregado na memória de forma tipada como objeto de chave [SWS_CRYPT_50207]. Todos os métodos operam de forma segura para threads e seguem uma semântica rigorosa de erro com rollback, enquanto Reset garante a exclusão sem resíduos dos buffers internos [SWS_CRYPT_50212].
Contexto
A interface ara::crypto::cryp::ProtectedKeyImportCtx disponibiliza um contexto criptográfico para importar e desempacotar de forma segura no sistema estruturas de dados protegidas, como material de chave secreta. O contexto atua como intermediário entre uma aplicação solicitante, um mecanismo de proteção baseado em uma chave de transporte e as estruturas de destino da criptografia AUTOSAR. Pacotes de dados serializados recebidos são autenticados, descriptografados e analisados pelo contexto [SWS_CRYPT_50207]. Como fontes para a chave de transporte necessária servem objetos de chave simétrica independentes [SWS_CRYPT_50205] ou slots de chave de um armazenamento de chaves [SWS_CRYPT_50206]. Como destino, os objetos de chave desempacotados podem ser entregues diretamente à aplicação chamadora ou serializados imediatamente em um slot de chave gravável [SWS_CRYPT_50207].
Ciclo de vida
Para o acesso compartilhado, o contexto é habitualmente gerenciado por meio do tipo de smart pointer disponibilizado Sptr[SWS_CRYPT_50085]; instâncias deverão ser fornecidas por um componente de driver criptográfico competente. Pergunta Q-3517b24b5eec4529 (aberta) Antes do processamento propriamente dito, o contexto encontra-se em um estado inicial não configurado, no qual ainda nenhuma chave de transporte está atribuída. A atribuição de uma chave de transporte ocorre por meio do método SetKey, com o qual o contexto transita para o estado operacional [SWS_CRYPT_50205][SWS_CRYPT_50206].
Após a execução bem-sucedida da operação Import, o contexto mantém os dados desempacotados e metadados em buffers internos, de modo que o tipo de objeto possa ser identificado e os objetos de chave possam ser lidos [SWS_CRYPT_50207][SWS_CRYPT_50208]. Por meio do método Reset, o contexto é restaurado ao seu estado inicial: todos os buffers internos com dados previamente importados são completamente limpos e a chave de transporte registrada é removida [SWS_CRYPT_50212]. Todos os métodos de interface são especificados como seguros contra exceções e seguros para threads, mantendo controláveis os acessos concorrentes a partir de múltiplos contextos de execução [SWS_CRYPT_50207].
O fluxo de trabalho regular inicia com a configuração da chave de transporte. Para isso, a aplicação chama SetKey com um SymmetricKey::Sptr[SWS_CRYPT_50205] ou com um KeySlot::Sptr[SWS_CRYPT_50206]. Na etapa seguinte, é executado o método Import, ao qual o pacote de dados serializado é passado como ReadOnlyMemRegion[SWS_CRYPT_50207]. Caso a chave deva ser armazenada de forma persistente, pode-se opcionalmente passar diretamente um WriteableKeySlot::Sptr, no qual o material desempacotado é gravado [SWS_CRYPT_50207].
Se nenhum slot de destino tiver sido especificado ou se a chave deva ser utilizada de forma volátil, a aplicação determina por meio de GetCryptoObjectType a categoria do último objeto importado [SWS_CRYPT_50208]. Com base nesse tipo, a aplicação chama o método de obtenção apropriado ao tipo: GetPrivateKey para chaves privadas [SWS_CRYPT_50209], GetPublicKey para chaves públicas [SWS_CRYPT_50211] ou GetSymmetricKey para material de chave simétrica [SWS_CRYPT_50210]. Se o protocolo de importação utilizado exigir uma confirmação ao remetente – como, por exemplo, nos blocos de controle M4 e M5 de uma sequência SHE LoadKey –, esta pode ser gravada em um buffer disponibilizado por meio de GetResponse[SWS_CRYPT_41020]. Após a conclusão da sequência de processamento, uma chamada de Reset restaura o contexto ao estado inicial [SWS_CRYPT_50212].
Se ocorrer um erro durante a chamada de um método, aplica-se uma semântica estrita de rollback, preservando o estado anterior à chamada. Na configuração via SetKey, a chamada falha com CryptoErrc::kUsageViolation caso a flag de uso da chave não contenha a permissão kAllowKeyUnwrapping[SWS_CRYPT_50205][SWS_CRYPT_50206]. Se o objeto de chave ou o slot referenciado for fundamentalmente incompatível com o uso como chave de transporte, é reportado CryptoErrc::kIncompatibleObject[SWS_CRYPT_50205][SWS_CRYPT_50206].
Ao chamar Import, divergências de tamanho dos dados de entrada resultam em CryptoErrc::kInvalidInputSize e violações de formato em CryptoErrc::kInvalidArgument[SWS_CRYPT_50207]. Se a verificação de integridade ou autenticidade da camada de proteção falhar (por exemplo, devido a um Message Authentication Code inválido ou a uma assinatura incorreta), a chamada retorna CryptoErrc::kAuthTagNotValid[SWS_CRYPT_50207]. Se o componente criptográfico estiver temporariamente ocupado, isso é sinalizado por meio de CryptoErrc::kBusyResource[SWS_CRYPT_50207].
A pré-condição para a leitura de chaves importadas é a execução bem-sucedida de Import; caso contrário, GetPrivateKey, GetPublicKey e GetSymmetricKey respondem com CryptoErrc::kProcessingNotFinished[SWS_CRYPT_50209][SWS_CRYPT_50210][SWS_CRYPT_50211]. Se o tipo de chave solicitado não coincidir com o objeto efetivamente desempacotado ou se nenhum objeto tiver sido importado ainda, os métodos de obtenção respondem com CryptoErrc::kNoSuchValue[SWS_CRYPT_50208][SWS_CRYPT_50209][SWS_CRYPT_50210][SWS_CRYPT_50211]. Se o buffer de saída não oferecer capacidade suficiente em GetResponse, isso resulta em CryptoErrc::kInsufficientCapacity[SWS_CRYPT_41020]. Caso a implementação concreta não suporte uma função parcial (por exemplo, determinados tipos de chave ou a redefinição), é retornado uniformemente CryptoErrc::kUnsupported[SWS_CRYPT_50205][SWS_CRYPT_50208][SWS_CRYPT_50212].
Este guia de classe baseia-se na especificação AUTOSAR Adaptive Platform Release R25-11.
The interface shall write the response of the CryptoProvider to the last invocation of Import into the provided output buffer. E.g., this interface could return M4/M5 of a SHE LoadKey operation.
virtual ara::core::Result< std::size_t > GetResponse (ReadWriteMem Region responseBuffer) const noexcept=0; DIRECTION NOT responseBuffer -- DEFINED
The interface shall unwrap the protected data provided, parse the content, and make the parsed content (key-material and meta-data) available for retrieval by the application. If optionally a Key Slot is specified, the unwrapped key material shall be directly serialized into the KeySlot.
The interface shall restore the context to its initial state by ensuring that no key-import-key is set and all previously imported data is deleted from the ProtectedKeyImportCtx’s internal buffers.
The interface shall return a shared pointer to the unwrapped PrivateKey.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: 569ddfa8ee2aProcedência
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
O método GetPrivateKey da classe ara::crypto::cryp::ProtectedKeyImportCtx (disponibilizado através do cabeçalho #include "ara/crypto/cryp/protected_key_import_ctx.h") serve para obter um shared pointer para uma chave privada (PrivateKey::Sptr) previamente importada e desempacotada ([SWS_CRYPT_50209]). A interface não possui parâmetros de passagem e retorna o resultado sincronicamente como ara::core::Result<PrivateKey::Sptr> ([SWS_CRYPT_50209]).
Para a execução aplicam-se requisitos vinculativos relativos à ordem, concorrência e segurança de exceções: O método está especificado como thread-safe e exception safe e declarado com noexcept ([SWS_CRYPT_50209]). Um pré-requisito obrigatório para a obtenção bem-sucedida é que tenha sido executada previamente com sucesso uma operação de importação dentro do contexto ([SWS_CRYPT_50209]).
Se ocorrer um erro durante a disponibilização, aplica-se uma semântica de rollback para todas as situações de erro ([SWS_CRYPT_50209]). O Result retornado contém, neste caso, um dos seguintes códigos de erro específicos:
ara::crypto::CryptoErrc::kProcessingNotFinished: O passo de importação anterior ainda não foi executado com sucesso ([SWS_CRYPT_50209]).
ara::crypto::CryptoErrc::kNoSuchValue: O CryptoObject importado mais recentemente não é uma chave privada ([SWS_CRYPT_50209]).
ara::crypto::CryptoErrc::kUnsupported: O contexto não suporta, por princípio, a importação de chaves privadas ([SWS_CRYPT_50209]).
Esta nota de utilização foi criada por uma IA com base na especificação AUTOSAR R25-11.
The interface shall return a shared pointer to the unwrapped PublicKey.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: b41e5e96382cProcedência
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
O método GetPublicKey da classe ara::crypto::cryp::ProtectedKeyImportCtx serve para a recuperação síncrona de um ponteiro para uma chave pública desempacotada e previamente importada ([SWS_CRYPT_50211]). A função não recebe parâmetros de entrada e retorna o resultado de forma fortemente tipada como ara::core::Result<PublicKey::Sptr> ([SWS_CRYPT_50211]).
Antes da chamada, uma operação de importação deve ter sido concluída com sucesso; caso contrário, a chamada falha e retorna o código de erro ara::crypto::CryptoErrc::kProcessingNotFinished ([SWS_CRYPT_50211]). Se o último objeto criptográfico importado não era uma chave pública, isso resulta no erro ara::crypto::CryptoErrc::kNoSuchValue ([SWS_CRYPT_50211]). Caso o contexto concreto de importação não ofereça suporte, por princípio, à introdução de chaves públicas, ara::crypto::CryptoErrc::kUnsupported é reportado ([SWS_CRYPT_50211]). Para todos os erros especificados, a interface garante uma semântica de rollback ([SWS_CRYPT_50211]).
No que diz respeito à concorrência e à segurança contra falhas, o método é especificado como thread-safe bem como exception-safe e não lança exceções C++ (noexcept) ([SWS_CRYPT_50211]).
Funcionalmente, esse mecanismo de importação se diferencia de outras interfaces: enquanto aqui um objeto protegido é desempacotado, a função homônima em ara::crypto::cryp::PrivateKey ([SWS_CRYPT_22511]) fornece a chave pública de uma chave privada existente, gerada, por exemplo, previamente por meio de GeneratePrivateKey ([SWS_CRYPT_20722]).
Este texto foi gerado por uma IA com base nas diretrizes da especificação.
virtual ara::core::Result< std::size_t > GetResponse (ReadWriteMem Region responseBuffer) const noexcept=0; DIRECTION NOT responseBuffer -- DEFINED
The interface shall write the response of the CryptoProvider to the last invocation of Import into the provided output buffer. E.g., this interface could return M4/M5 of a SHE LoadKey operation.
The interface shall return a shared pointer to the unwrapped SymmetricKey.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: cefc876d47dbProcedência
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
O método GetSymmetricKey da classe ara::crypto::cryp::ProtectedKeyImportCtx retorna um shared pointer para uma chave simétrica desempacotada (SymmetricKey::Sptr) [SWS_CRYPT_50210]. A chamada ocorre de forma síncrona, está declarada como const e noexcept e não recebe parâmetros [SWS_CRYPT_50210].
Para uma obtenção bem-sucedida, têm de ser cumpridas determinadas pré-condições e ordens de execução [SWS_CRYPT_50210]:
Previamente, tem de ter sido concluído com sucesso um processo de importação; caso contrário, a chamada falha com o código de erro ara::crypto::CryptoErrc::kProcessingNotFinished[SWS_CRYPT_50210].
Se o objeto criptográfico importado mais recentemente não for uma chave simétrica, o método retorna ara::crypto::CryptoErrc::kNoSuchValue[SWS_CRYPT_50210].
Caso o contexto de importação selecionado geralmente não suporte a importação de chaves simétricas, é reportado o erro ara::crypto::CryptoErrc::kUnsupported[SWS_CRYPT_50210].
No que diz respeito à segurança de execução, a interface está especificada como thread-safe e exception-safe [SWS_CRYPT_50210]. Todos os casos de erro definidos oferecem uma semântica de rollback, de modo que o estado do contexto permanece inalterado em caso de erro [SWS_CRYPT_50210].
Este texto foi gerado por uma IA com base na especificação AUTOSAR R25-11.
The interface shall unwrap the protected data provided, parse the content, and make the parsed content (key-material and meta-data) available for retrieval by the application. If optionally a Key Slot is specified, the unwrapped key material shall be directly serialized into the KeySlot.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: 89f9277cd6aaProcedênciaPerguntas em aberto (1)
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
usar
O método síncrono Import da classe ara::crypto::cryp::ProtectedKeyImportCtx desempacota dados de chave protegidos a partir da área de memória serialized ([SWS_CRYPT_50207]). Ele analisa o conteúdo dos dados e disponibiliza o material de chave extraído bem como metadados para consulta subsequente. Se um WriteableKeySlot for passado opcionalmente, o material de chave é serializado diretamente neste slot ([SWS_CRYPT_50207]). Interpretação: Se nenhum keySlot for passado, o material de chave provavelmente permanecerá exclusivamente no estado do contexto de importação. Pergunta Q-130f11475af1bb33 (aberta)
Tratamento de erros
A função retorna um ara::core::Result<void>. Se a operação falhar, aplica-se uma semântica de rollback ([SWS_CRYPT_50207]) para todos os códigos de erro:
ara::crypto::CryptoErrc::kInvalidInputSize: O tamanho de entrada de serialized é inesperado ([SWS_CRYPT_50207]).
ara::crypto::CryptoErrc::kInvalidArgument: Os dados serializados não correspondem ao formato esperado ([SWS_CRYPT_50207]).
ara::crypto::CryptoErrc::kAuthTagNotValid: A verificação de autenticação (MAC ou assinatura) falha ([SWS_CRYPT_50207]).
ara::crypto::CryptoErrc::kBusyResource: A operação não pode ser executada temporariamente ([SWS_CRYPT_50207]).
Concorrência e interação
O método é seguro para threads e seguro contra exceções (noexcept) ([SWS_CRYPT_50207]). Após a chamada bem-sucedida, o objeto de chave desempacotado pode ser recuperado do contexto via GetPrivateKey ([SWS_CRYPT_50209]), GetSymmetricKey ([SWS_CRYPT_50210]) ou GetPublicKey ([SWS_CRYPT_50211]). Se o protocolo subjacente exigir um feedback para o remetente, GetResponse ([SWS_CRYPT_41020]) disponibiliza a resposta do provedor de criptografia. Para formatos de chave desprotegidos, servem alternativamente os métodos ImportPublicKey ([SWS_CRYPT_20732]), ImportSymmetricKey ([SWS_CRYPT_50014]) e ImportPrivateKey ([SWS_CRYPT_50132]) da classe factory CryptoProvider.
Este texto foi gerado por uma IA com base na especificação AUTOSAR R25-11.
The interface shall restore the context to its initial state by ensuring that no key-import-key is set and all previously imported data is deleted from the ProtectedKeyImportCtx’s internal buffers.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: 21bf97fcdbf3Procedência
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
O método Reset redefine a instância de ara::crypto::cryp::ProtectedKeyImportCtx para o seu estado inicial [SWS_CRYPT_50212]. Ao fazê-lo, a interface garante que nenhuma Key-Import-Key (KIK) permaneça definida e que todos os dados importados anteriormente sejam completamente apagados dos buffers internos do contexto [SWS_CRYPT_50212].
A chamada ocorre de forma síncrona e está classificada, de acordo com a especificação, como thread-safe e exception safe[SWS_CRYPT_50212]. O método declara a assinatura virtual ara::core::Result<void> Reset() const noexcept = 0; e requer a inclusão do cabeçalho ara/crypto/cryp/protected_key_import_ctx.h[SWS_CRYPT_50212].
Tratamento de erros
O resultado é retornado através de ara::core::Result<void>[SWS_CRYPT_50212]. Se a operação falhar, a interface retorna um código de erro:
ara::crypto::CryptoErrc::kUnsupported: Ocorre quando o contexto específico não suporta a redefinição do seu estado (semântica de rollback) [SWS_CRYPT_50212].
Esta nota de uso foi gerada automaticamente com base na especificação SWS_CRYPT_50212.
The interface shall configure the context to use the provided symmetric key as transport key.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: bb7a4eb711eaProcedênciaPerguntas em aberto (1)
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
O método SetKey da classe ara::crypto::cryp::ProtectedKeyImportCtx configura o contexto de modo que o objeto de chave simétrica passado key (SymmetricKey::Sptr) seja utilizado como chave de transporte [SWS_CRYPT_50205]. A chamada ocorre de forma síncrona e retorna um ara::core::Result<void>[SWS_CRYPT_50205].
Tratamento de erros
Se ocorrer um erro durante a configuração, este é reportado com semântica de rollback, de modo que o estado anterior do contexto permaneça inalterado [SWS_CRYPT_50205]. Os seguintes códigos de erro estão definidos:
ara::crypto::CryptoErrc::kUnsupported: É retornado caso o contexto suporte exclusivamente a atribuição de um KeySlot[SWS_CRYPT_50205].
ara::crypto::CryptoErrc::kIncompatibleObject: O objeto de chave disponibilizado não pode ser utilizado como chave de transporte [SWS_CRYPT_50205].
ara::crypto::CryptoErrc::kUsageViolation: As flags de uso da chave não contêm a permissão necessária kAllowKeyUnwrapping[SWS_CRYPT_50205].
Concorrência e interação
A operação é especificada como segura para threads (thread-safe) bem como segura contra exceções (exception safe) e não lança exceções (noexcept) [SWS_CRYPT_50205]. Enquanto contextos como SymmetricKeyWrapperCtx vinculam uma chave para proteção ou envelopamento (wrapping) [SWS_CRYPT_24018], a chave aqui serve para a importação de chaves protegidas. A condição de erro kUnsupported também aponta para arquiteturas nas quais os contextos são configurados alternativamente por meio de um KeySlot[SWS_CRYPT_50034]. Interpretação: A atribuição da chave de transporte provavelmente deve estar concluída obrigatoriamente antes de operações de importação subsequentes. Pergunta Q-f1f3eab5ab896b1b (aberta)
Esta nota de utilização foi gerada automaticamente com base na especificação AUTOSAR R25-11.
The interface shall configure the context to use the key stored in the provided KeySlot at the time the import operation is started as the transport key.
GERADO POR IAnão revisadoModelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: e6e7bd1f753cProcedência
traduzido do guia alemãogemini-3.8-flash-low · 2026-10-13 · Original em alemão
usar
O método SetKey configura o contexto [SWS_CRYPT_50206] (ara::crypto::cryp::ProtectedKeyImportCtx) de modo que a chave simétrica armazenada no KeySlot::Sptr keySlot passado seja usada como chave de transporte no momento de início do processo de importação. A chamada ocorre de forma síncrona e retorna um ara::core::Result<void>.
Tratamento de erros
Se ocorrer um erro durante a configuração, aplica-se uma semântica de rollback [SWS_CRYPT_50206]. Os códigos de erro específicos incluem:
ara::crypto::CryptoErrc::kUnsupported: Quando o contexto suporta exclusivamente a definição de um objeto SymmetricKey direto [SWS_CRYPT_50206].
ara::crypto::CryptoErrc::kIncompatibleObject: Quando a chave contida no slot não puder ser utilizada como chave de transporte [SWS_CRYPT_50206].
ara::crypto::CryptoErrc::kUsageViolation: Quando as flags de uso permitidas da chave no KeySlot não contiverem a flag kAllowKeyUnwrapping[SWS_CRYPT_50206].
Concorrência e interação
A função é especificada como segura contra exceções (exception safe) e segura para threads (thread-safe) [SWS_CRYPT_50206]. A chave é avaliada a partir do slot apenas no início da importação subsequente [SWS_CRYPT_50206]. Enquanto outros contextos criptográficos, como SymmetricKeyWrapperCtx[SWS_CRYPT_50034] ou KeyDerivationFunctionCtx[SWS_CRYPT_50010], também podem incorporar slots como fonte de chaves, ProtectedKeyImportCtx::SetKey exige explicitamente a permissão para desempacotar chaves.
Este texto foi gerado por uma ferramenta de documentação baseada em IA e não substitui a consulta às especificações oficiais da AUTOSAR.
gemini-3.8-flash-low· 2026-10-13 · Original em alemão