DEENESPTFRRUARHIKOZHNL

AUTOSAR Classic Crypto Services

Guia do clusterGERADO POR IA

Disponibiliza serviços padronizados de computação criptográfica e gestão de chaves através de drivers de hardware e software.
GERADO POR IA não revisado Modelo: gemini-3.8-flash-medium · Esforço: medium · Temperatura: não controlável · Prompt: b0f0d6315c89 Procedência Perguntas em aberto (1)
Âncora causal: R20-11 Válido a partir de R20-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 serviços padronizados de computação criptográfica e gestão de chaves através de drivers de hardware e software.

O cluster agrupa os módulos CSM, CryIf e Crypto Driver para o fornecimento independente de hardware de serviços criptográficos e funções de gestão de chaves na AUTOSAR Classic Platform EXP_UtilizationOfCryptoServices p. 8. Os jobs criptográficos são priorizados através do CSM, encaminhados no CryIf para canais lógicos e executados de forma síncrona ou assíncrona no Crypto Driver [SWS_CryIf_91003]. Por razões de consistência, as persistências de chaves na NVM ocorrem estritamente apenas após validação bem-sucedida mediante KeySetValid SWS_CryptoDriver p. 37.

O cluster de módulos «Crypto Services & Hardware Abstraction» compreende os módulos AUTOSAR Classic Crypto Service Manager (csm), Crypto Interface (cryif) e Crypto Driver (crypto) EXP_UtilizationOfCryptoServices p. 8. Disponibiliza uma camada de abstração independente de hardware para operações criptográficas (entre outras, cifragem, assinaturas, cálculo de MAC e geração de números aleatórios), bem como para uma gestão segura de chaves [SWS_Csm_00982], [SWS_Csm_00984], SWS_CryptoDriver p. 15.

Os pedidos criptográficos são encapsulados como Crypto_JobType, o qual define prioridades, buffers de entrada e saída, bem como modos de operação (Start, Update, Finish para streaming ou SingleCall) [SWS_Csm_01013], [SWS_Csm_01039]. O CSM aceita os pedidos, atribui-os a filas de espera de software e encaminha-os através de CryIf_ProcessJob() [SWS_Csm_00017], [SWS_CryIf_91003]. O CryIf assume o encaminhamento de canais para os drivers e traduz identificadores de chaves do CSM em IDs de chaves de driver específicas do módulo [SWS_CryIf_00133].

CryptoArchitecture cluster_app Application Layer / BSW Users cluster_csm Service Layer cluster_cryif ECU Abstraction Layer cluster_crypto Microcontroller Abstraction Layer (MCAL) SecOC SecOC / TLS / SW-C CSM Crypto Service Manager (csm) - Service-APIs (Csm_MacGenerate, ...) - Priorisierte Job-Queues - Csm_MainFunction SecOC->CSM Job / Service Request CSM->SecOC Application Callback CryIf Crypto Interface (cryif) - Channel Dispatching (CryIf_ProcessJob) - Key-ID Mapping (cryIfKeyId -> cryptoKeyId) - Callback Notification Dispatching CSM->CryIf CryIf_ProcessJob() / CryIf_Key*() CryIf->CSM Csm_CallbackNotification() CryptoDrv1 Crypto Driver (crypto) - HW - Crypto Driver Object 0 (por ex. AES / HSM) - Sincronização NVM CryIf->CryptoDrv1 Crypto_ProcessJob() [Kanal 0] CryptoDrv2 Crypto Driver (crypto) - SW - Crypto Driver Object 1 (por ex. Software RSA) CryIf->CryptoDrv2 Crypto_ProcessJob() [Kanal 1] CryptoDrv1->CryIf CryIf_CallbackNotification() CryptoDrv2->CryIf CryIf_CallbackNotification()

Diagrama de contexto: arquitetura de camadas e cascata de interfaces da stack de criptografia AUTOSAR. Fontes: SWS_CryptoDriver p. 15, SWS_CryptoServiceManager p. 29

A Csm_MainFunction() periódica serve para a sincronização de pedidos criptográficos assíncronos, esvaziando as filas de espera e desencadeando os cálculos pendentes [SWS_Csm_00479]. Após a conclusão de um cálculo de hardware assíncrono, o Crypto Driver notifica o CryIf através de CryIf_CallbackNotification(), que repassa a mensagem a Csm_CallbackNotification() e, finalmente, à aplicação chamadora [SWS_CryIf_91013], [SWS_Csm_00970].

Fluxo assíncrono de jobs de criptografia no Crypto ClusterApplicationcsmcryifcryptoCsm_MacGenerate(jobId, mode, ...)Verificar job / verificação da filaaltTreiberobjekt freiCryIf_ProcessJob(channelId, job)Key-ID Mapping (cryIfKeyId -> cryptoKeyId)Crypto_ProcessJob(objectId, job)E_OK (Auftrag angenommen)E_OKTreiberobjekt belegt / Queuing aktivJob in CSM-Queue einreihenE_OK (Asynchron gepuffert)Csm_MainFunction(): Dequeue JobCryIf_ProcessJob(channelId, job)Crypto_ProcessJob(objectId, job)E_OKUse Case: Hardware-/Treiber-Berechnung & AbschlussKrypto-Primitive berechnen (HW/ISR)CryIf_CallbackNotification(job, result)Csm_CallbackNotification(job, result)CallbackNotification(result)

Diagrama de sequência: fluxo assíncrono de pedidos criptográficos com enfileiramento e cascata de callbacks. Fontes: [SWS_Csm_00970], [SWS_CryIf_91013], AUTOSAR_CP_SWS_CryptoServiceManager p. 146

A gestão de chaves é realizada através de interfaces padronizadas como Csm_KeyElementSet() e CryIf_KeyElementCopy() sob estrita observância dos direitos de acesso configurados [SWS_Csm_00957], [SWS_CryIf_91015], [SWS_Crypto_00219]. A persistência na NVM é acionada apenas mediante validação explícita através de Crypto_KeySetValid(), evitando assim armazenamentos incompletos de chaves [SWS_Crypto_91014], SWS_CryptoDriver p. 37. Erros como sobrecargas ou estados de chave inválidos são intercetados de forma robusta através de CRYPTO_E_BUSY e CRYPTO_E_KEY_NOT_VALID, respetivamente [SWS_Csm_00018], [SWS_CryIf_91003].

1. Arquitetura de sistema & papel do cluster de módulos

O cluster de módulos «Crypto Services & Hardware Abstraction» constitui a base funcional para operações criptográficas, gestão de chaves baseada em software e hardware, bem como comunicação on-board segura na AUTOSAR Classic Platform EXP_UtilizationOfCryptoServices p. 8. A arquitetura estrutura-se rigorosamente ao longo do modelo de camadas do AUTOSAR em três módulos BSW padronizados: o Crypto Service Manager (csm) na camada de serviços, a Crypto Interface (cryif) na ECU Abstraction Layer e pelo menos um Crypto Driver (crypto) na Microcontroller Abstraction Layer (MCAL) SWS_CryptoDriver p. 15. Esta estrutura em camadas abstrai completamente aplicações de segurança (por exemplo, SecOC, estabelecimentos de ligação TLS e autenticação de diagnóstico UDS) de coprocessadores criptográficos proprietários, tais como Hardware Security Modules (HSM) ou Secure Hardware Extensions (SHE) SWS_SecureOnboardCommunication p. 78.

O Crypto Service Manager (CSM) atua como o principal fornecedor de serviços para componentes de aplicação (SW-Cs) e módulos BSW de nível superior. Ele disponibiliza interfaces de programação padronizadas para algoritmos simétricos e assimétricos (p. ex., AES, RSA), hashing, Message Authentication Codes (MAC), geração de números aleatórios (RNG) e procedimentos AEAD [SWS_Csm_00980], [SWS_Csm_00982], [SWS_Csm_00984], [SWS_Csm_01023]. Além disso, o CSM implementa filas de jobs por software e controla a priorização de pedidos criptográficos paralelos [SWS_Csm_00022], SWS_CryptoServiceManager p. 29.

A Crypto Interface (CryIf), enquanto camada de abstração, disponibiliza uma interface 1:n uniforme entre o CSM e qualquer número de drivers criptográficos. A sua função central é o dispatching: encaminha pedidos para a instância correspondente do Crypto Driver com base em canais lógicos configurados (channelId) e transforma referências lógicas de chaves (cryIfKeyId) em identificadores específicos de driver (cryptoKeyId) [SWS_CryIf_00133], [SWS_CryIf_91003]. O Crypto Driver encapsula a unidade de execução física (Crypto Driver Object) e atende primitivas criptográficas puramente de software ou módulos de segurança de hardware dedicados [SWS_Crypto_00224], SWS_CryptoDriver p. 15.

CryptoArchitecture cluster_app Application Layer / BSW Users cluster_csm Service Layer cluster_cryif ECU Abstraction Layer cluster_crypto Microcontroller Abstraction Layer (MCAL) SecOC SecOC / TLS / SW-C CSM Crypto Service Manager (csm) - Service-APIs (Csm_MacGenerate, ...) - Priorisierte Job-Queues - Csm_MainFunction SecOC->CSM Job / Service Request CSM->SecOC Application Callback CryIf Crypto Interface (cryif) - Channel Dispatching (CryIf_ProcessJob) - Key-ID Mapping (cryIfKeyId -> cryptoKeyId) - Callback Notification Dispatching CSM->CryIf CryIf_ProcessJob() / CryIf_Key*() CryIf->CSM Csm_CallbackNotification() CryptoDrv1 Crypto Driver (crypto) - HW - Crypto Driver Object 0 (por ex. AES / HSM) - Sincronização NVM CryIf->CryptoDrv1 Crypto_ProcessJob() [Kanal 0] CryptoDrv2 Crypto Driver (crypto) - SW - Crypto Driver Object 1 (por ex. Software RSA) CryIf->CryptoDrv2 Crypto_ProcessJob() [Kanal 1] CryptoDrv1->CryIf CryIf_CallbackNotification() CryptoDrv2->CryIf CryIf_CallbackNotification()

Diagrama de contexto: arquitetura de camadas e cascata de interfaces da stack de criptografia AUTOSAR. Fontes: SWS_CryptoDriver p. 15, SWS_CryptoServiceManager p. 29

2. Interação & caminhos de interação entre os módulos

O processamento de pedidos no cluster ocorre primariamente através do modelo baseado em jobs mediante a estrutura Crypto_JobType [SWS_Csm_01013], AUTOSAR_CP_SWS_CryptoServiceManager p. 21. Um job criptográfico agrega o ID do job, informações de prioridade, referências de chaves, metadados de primitivas e a estrutura Crypto_JobPrimitiveInputOutputType para gestão de ponteiros de parâmetros de entrada, saída e comprimento [SWS_Csm_01012]. O campo de máscara de bits Crypto_OperationModeType (com as flags START, UPDATE, FINISH) controla se um pedido é calculado como uma chamada única contígua (SINGLECALL) ou incrementalmente em modo de streaming [SWS_Csm_01039], [SWS_Csm_01029].

Se uma função de serviço do CSM for chamada de forma síncrona, o CSM verifica o estado do job. Se o driver estiver livre ou o pedido estiver configurado como síncrono, o CSM chama diretamente CryIf_ProcessJob() [SWS_Csm_00017], [SWS_CryIf_91003]. O CryIf mapeia os IDs de chave e despacha o job para a instância de driver atribuída via Crypto_ProcessJob() [SWS_CryIf_00133]. Em pedidos assíncronos, se o objeto do driver estiver ocupado, o job é colocado na fila de espera do CSM [SWS_Csm_00018], AUTOSAR_CP_SWS_CryptoServiceManager p. 30. Após a conclusão do cálculo assíncrono do driver, o driver aciona CryIf_CallbackNotification() [SWS_CryIf_91013], o CryIf encaminha a mensagem para Csm_CallbackNotification() [SWS_Csm_00970] e, finalmente, o CSM notifica a aplicação requerente através do respetivo callback configurado [SWS_Csm_01044], [SWS_Csm_00928].

Fluxo assíncrono de jobs de criptografia no Crypto ClusterApplicationcsmcryifcryptoCsm_MacGenerate(jobId, mode, ...)Verificar job / verificação da filaaltTreiberobjekt freiCryIf_ProcessJob(channelId, job)Key-ID Mapping (cryIfKeyId -> cryptoKeyId)Crypto_ProcessJob(objectId, job)E_OK (Auftrag angenommen)E_OKTreiberobjekt belegt / Queuing aktivJob in CSM-Queue einreihenE_OK (Asynchron gepuffert)Csm_MainFunction(): Dequeue JobCryIf_ProcessJob(channelId, job)Crypto_ProcessJob(objectId, job)E_OKUse Case: Hardware-/Treiber-Berechnung & AbschlussKrypto-Primitive berechnen (HW/ISR)CryIf_CallbackNotification(job, result)Csm_CallbackNotification(job, result)CallbackNotification(result)

Diagrama de sequência: fluxo assíncrono de pedidos criptográficos com enfileiramento e cascata de callbacks. Fontes: [SWS_Csm_00970], [SWS_CryIf_91013], AUTOSAR_CP_SWS_CryptoServiceManager p. 146

Além da execução criptográfica primária, a gestão de chaves constitui um caminho de interação integral do cluster SWS_CryptoDriver p. 24. Uma chave é composta por múltiplos elementos lógicos de chave (como material de chave, vetores de inicialização ou valores de iteração) [SWS_Csm_00954], [SWS_Csm_01022]. Operações como a definição de material de chave via Csm_KeyElementSet(), a cópia mediante Csm_KeyElementCopy() ou a derivação de chaves através de Csm_KeyDerive() são encaminhadas de forma síncrona através do CryIf (CryIf_KeyElementCopy(), CryIf_KeyDerive()) para as funções do driver [SWS_Csm_00957], [SWS_Csm_00969], [SWS_CryIf_91015], [SWS_CryIf_91009]. O acesso aos elementos de chave é rigorosamente monitorizado com base nos direitos de acesso configurados (CRYPTO_RA_ALLOWED, CRYPTO_RA_ENCRYPTED, CRYPTO_RA_INTERNAL_COPY) [SWS_Crypto_00219].

3. Sincronização, reentrância e contextos de tarefas

As operações criptográficas variam drasticamente na sua duração de execução. Enquanto cifras de bloco rápidas ou cálculos de hash podem ser executados de forma síncrona no contexto de tarefa do chamador, cálculos assimétricos (p. ex., geração de assinatura RSA) ou processos de hardware morosos exigem processamento assíncrono [SWS_Csm_00984], [SWS_Csm_00992]. Para o desacoplamento, o CSM disponibiliza a função principal de chamada cíclica Csm_MainFunction() [SWS_Csm_00479]. Esta monitoriza as filas de espera, despacha jobs pendentes para o CryIf e avança as máquinas de estado internas de primitivas assíncronas [SWS_Csm_00019].

Em arquiteturas multinúcleo e multissetor modernas, o CSM suporta múltiplas instâncias Csm_MainFunction_<shortName>() atribuídas a partições dedicadas do SO [SWS_Csm_00479], AUTOSAR_SWS_CryptoServiceManager p. 170. Na execução assíncrona de drivers, os cálculos são terminados ou por polling na MainFunction do driver ou por rotinas de serviço de interrupção (ISR) de motores criptográficos baseados em hardware [SWS_Crypto_00027], [SWS_Crypto_00028]. Por definição, um único Crypto Driver Object pode processar exatamente um job criptográfico de cada vez; um driver com n objetos processa n pedidos verdadeiramente em paralelo [SWS_Crypto_00014], [SWS_Crypto_00117].

Relativamente à reentrância, interfaces de serviço como Csm_MacGenerate() ou CryIf_ProcessJob() são concebidas como reentrantes para jobs distintos, mas proíbem a submissão paralela múltipla da mesma instância de job [SWS_Csm_00016], [SWS_CryIf_91003]. Funções de gestão de chaves como Csm_KeyElementCopy(), CryIf_KeyElementCopy() ou Crypto_KeyCopy() estão implementadas como reentrantes, mas não podem ser aplicadas de forma concorrente ao mesmo identificador de chave de origem (keyId ou cryptoKeyId) para evitar inconsistências de dados e condições de corrida [SWS_Csm_00969], [SWS_CryIf_91015], [SWS_Crypto_00155]. Os drivers de hardware podem utilizar áreas exclusivas internas (Exclusive Areas) para a modificação de áreas de trabalho e registos de chaves internos, prevenindo condições de corrida entre a ISR e o nível de tarefas SWS_CryptoDriver p. 27. Pergunta Q-b1e9578255723a0e (aberta)

CsmDispatchLogic Start Eintritt Csm_<Service>() CheckActive Job aktiv? (jobState == ACTIVE) Start->CheckActive CheckSync Synchroner Modus? (CRYPTO_PROCESSING_SYNC) CheckActive->CheckSync Nein DirectCall Executar CryIf_ProcessJob() CheckActive->DirectCall Ja (Streaming Update/Finish) CheckSync->DirectCall Ja CheckQueueEmpty CSM-Queue leer? CheckSync->CheckQueueEmpty Nein (Asynchron) CheckPrio Prioridade mais alta que a do job de maior prioridade na fila? CheckQueueEmpty->CheckPrio Nein ForwardCryIf Job sofort dispatchen: CryIf_ProcessJob() CheckQueueEmpty->ForwardCryIf Ja CheckQueueFull CSM-Queue voll? CheckPrio->CheckQueueFull Nein CheckPrio->ForwardCryIf Ja EnqueueJob Job in CSM-Queue einreihen Return E_OK CheckQueueFull->EnqueueJob Nein ReturnBusy Return CRYPTO_E_BUSY (Det: CSM_E_QUEUE_FULL) CheckQueueFull->ReturnBusy Ja

Diagrama de atividades: lógica de decisão e desacoplamento por enfileiramento na aceitação de pedidos no CSM. Fontes: AUTOSAR_CP_SWS_CryptoServiceManager p. 30, [SWS_Csm_00017], [SWS_Csm_00018]

4. Ciclos de vida típicos e modos de operação

A inicialização do cluster criptográfico ocorre durante o arranque do BSW por ordem hierárquica. Primeiramente, o EcuM ou o BswM inicializa o nível de driver via Crypto_Init() passando a configuração Crypto_ConfigType [SWS_Crypto_91016], seguido pela camada de interface via CryIf_Init() com CryIf_ConfigType [SWS_CryIf_91118]. Por fim, o CSM é iniciado mediante Csm_Init(), sendo que o seu ponteiro de configuração deve, de acordo com a especificação, ser sempre definido como NULL_PTR [SWS_Csm_00646]. Apenas após a inicialização completa de todas as camadas é permitida a aceitação de pedidos criptográficos ou acessos a chaves [SWS_CryIf_00076], [SWS_Crypto_00196].

Um aspeto central do ciclo de vida da chave é a validação e persistência em memória não volátil (NVM). Após o carregamento de novos valores de chave através de Csm_KeyElementSet(), a chave permanece no estado «incompleto ou desconhecido» [SWS_Csm_00957]. Apenas a chamada explícita de Csm_JobKeySetValid() ou Crypto_KeySetValid() verifica a consistência e altera o estado da chave para válido [SWS_Csm_91027], [SWS_Crypto_91014]. Para chaves persistidas, exclusivamente esta validação aciona o armazenamento na NVM [SWS_Crypto_91026], SWS_CryptoDriver p. 37. Isto previne múltiplos ciclos de escrita fragmentados na NVM e protege contra conjuntos de chaves incompletos SWS_CryptoDriver p. 37. Para a sincronização com o NVRAM Manager, o Crypto Driver utiliza os callbacks Crypto_<vi>_<ai>_NvBlock_ReadFrom_<NvBlock>() e Crypto_<vi>_<ai>_NvBlock_WriteTo_<NvBlock>(), bem como NvM_WriteBlock() [SWS_Crypto_91024], [SWS_Crypto_91025], [SWS_Crypto_91017].

Pedidos de streaming em curso podem, caso necessário, ser interrompidos via Csm_SaveContextJob(), guardados num buffer próprio da aplicação e retomados posteriormente através do restauro de contexto [SWS_Csm_91063], [SWS_Csm_01029]. Antes do encerramento de uma unidade de comando (ECU) ou de uma transição para modos de baixo consumo (low-power), pedidos assíncronos podem ser cancelados de forma controlada via Csm_CancelJob(), pelo que o CryIf remove os jobs das filas de espera do driver e dos canais de hardware através de CryIf_CancelJob() [SWS_Csm_00968], [SWS_CryIf_91014].

5. Tratamento de erros, rastreamento de DET e degradação

O cluster implementa uma estratégia de deteção e defesa contra erros em múltiplos níveis. Com o rastreamento ativo, erros de desenvolvimento são reportados diretamente ao módulo Default Error Tracer (DET) [SWS_Csm_91101], [SWS_Crypto_91017]. Entre os eventos típicos de DET incluem-se chamadas a módulos antes de concluída a inicialização (CRYIF_E_UNINIT, CRYPTO_E_UNINIT), parâmetros de handle ou chave inválidos (CRYIF_E_PARAM_HANDLE, CRYPTO_E_PARAM_HANDLE), bem como a passagem de ponteiros nulos [SWS_CryIf_00076], [SWS_CryIf_00134], [SWS_Crypto_00196], [SWS_Crypto_00217].

Sobrecargas em tempo de execução e escassez de recursos são tratadas deterministicamente através de valores de retorno definidos. Se a fila de espera do CSM para um job assíncrono estiver esgotada, o CSM rejeita o pedido com o código de estado CRYPTO_E_BUSY e gera o erro de tempo de execução CSM_E_QUEUE_FULL [SWS_Csm_00018], [SWS_Csm_01089]. Se um buffer de resultados disponibilizado tiver dimensões insuficientes, o driver cancela a operação com CRYPTO_E_SMALL_BUFFER [SWS_Crypto_00195]. Se um serviço criptográfico referenciar uma chave não inicializada ou explicitamente invalidada (por exemplo, após a chamada de Csm_JobKeySetInvalid() ou Crypto_KeySetInvalid()), os pedidos de serviço falham de forma controlada com CRYPTO_E_KEY_NOT_VALID ou CRYPTO_E_KEY_EMPTY [SWS_Csm_91002], [SWS_CryIf_91003], [SWS_Crypto_91020].

Mecanismos de degradação e fallback são viabilizados no nível do sistema: as aplicações podem verificar o estado de integridade de chaves por meio de Csm_KeyGetStatus() antes do envio de ordens [SWS_Csm_91047], [SWS_CryIf_91012]. Caso um acelerador criptográfico de hardware esteja permanentemente ocupado ou falhe, a configuração de canais CryIf permite uma rota alternativa baseada em software, desde que um driver de software redundante esteja integrado SWS_CryptoDriver p. 15.

Este guia baseia-se exclusivamente na especificação AUTOSAR Classic R20-11 e foi gerado pelo assistente de curadoria autodocs.

Die Crypto Services bieten hardware- und softwaregestützte Kryptographie-Primitive (CSM, CryIf, Crypto-Treiber) für symmetrische/asymmetrische Verschlüsselung, Signaturen und Hashing.

Module im Cluster

Crypto Abstraction Library (Cal)

AUTOSAR Classic Crypto Services-Modul Crypto Abstraction Library (Cal, Spezifikation: AUTOSAR_SWS_CryptoAbstractionLibrary.pdf).

BSW ID 206 Keine C-API · 0 Records #include "Cal.h"

Crypto Interface (CryIf)

Abstracts cryptographic hardware and software acceleration engines.

BSW ID 112 19 APIs (18 Funktionen, 1 Typen) #include "CryIf.h"

Crypto Driver (Crypto)

Low-level driver executing cryptographic primitives on hardware security modules (HSM) or software libraries.

BSW ID 114 20 APIs (19 Funktionen, 1 Typen) #include "Crypto.h"

Crypto Service Manager (CSM)

Provides standardized cryptographic services (encryption, hashing, digital signatures, key management) to applications and BSW.

BSW ID 110 82 APIs (38 Funktionen, 44 Typen) #include "Csm.h"

Mapa de temas

CSM

82
<Csm_ApplicationCallbackNotification>Csm_AEADDecryptCsm_AEADEncryptCsm_CallbackNotificationCsm_CancelJobCsm_DecryptCsm_EncryptCsm_GetVersionInfoCsm_HashCsm_InitCsm_JobKeyDeriveCsm_JobKeyExchangeCalcPubValCsm_JobKeyExchangeCalcSecretCsm_JobKeyGenerateCsm_JobKeySetInvalidCsm_JobKeySetValidCsm_JobRandomSeedCsm_KeyCopyCsm_KeyDeriveCsm_KeyElementCopyCsm_KeyElementCopyPartialCsm_KeyElementGetCsm_KeyElementSetCsm_KeyExchangeCalcPubValCsm_KeyExchangeCalcSecretCsm_KeyGenerateCsm_KeyGetStatusCsm_KeySetInvalidCsm_KeySetValidCsm_MacGenerateCsm_MacVerifyCsm_MainFunctionCsm_RandomGenerateCsm_RandomSeedCsm_RestoreContextJobCsm_SaveContextJobCsm_SignatureGenerateCsm_SignatureVerifyCrypto_AlgorithmFamilyTypeCrypto_AlgorithmInfoTypeCrypto_AlgorithmModeTypeCrypto_InputOutputRedirectionConfigTypeCrypto_JobPrimitiveInfoTypeCrypto_JobPrimitiveInputOutputTypeCrypto_JobRedirectionInfoTypeCrypto_JobStateTypeCrypto_JobTypeCrypto_KeyStatusTypeCrypto_OperationModeTypeCrypto_PrimitiveInfoTypeCrypto_ProcessingTypeCrypto_ResultTypeCrypto_ServiceInfoTypeCrypto_VerifyResultTypeCsm_AEADDecryptAssociatedDataTypeCsm_AEADDecryptCiphertextTypeCsm_AEADDecryptPlaintextTypeCsm_AEADDecryptTagTypeCsm_AEADEncryptAssociatedDataTypeCsm_AEADEncryptCiphertextTypeCsm_AEADEncryptPlaintextTypeCsm_AEADEncryptTagTypeCsm_ConfigIdTypeCsm_ConfigTypeCsm_DecryptDataTypeCsm_DecryptResultTypeCsm_EncryptDataTypeCsm_EncryptResultTypeCsm_HashDataTypeCsm_HashResultTypeCsm_KeyDataTypeCsm_LengthPtrCsm_MacGenerateDataTypeCsm_MacGenerateResultTypeCsm_MacVerifyCompareTypeCsm_MacVerifyDataTypeCsm_RandomGenerateResultTypeCsm_SignatureGenerateDataTypeCsm_SignatureGenerateResultTypeCsm_SignatureVerifyCompareTypeCsm_SignatureVerifyDataTypeCsm_VerifyResultPtr

Vista de detalhes

Selecione uma entrada no índice.

CryIf

Notifies the CRYIF about the completion of the request with the result of the cryptographic operation.

void CryIf_CallbackNotification (Crypto_JobType* job, Crypto_ResultType result);

This interface dispatches the job cancellation function to the configured crypto driver object.

Std_ReturnType CryIf_CancelJob (uint32 channelId, Crypto_JobType* job);

Returns the version information of this module.

void CryIf_GetVersionInfo (Std_VersionInfoType* versioninfo);
CryIf_Init função

Initializes the CRYIF module. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoInterface

void CryIf_Init (const CryIf_ConfigType* configPtr);
CryIf_KeyCopy função

This function shall co py all key elements from the source key to a target key.

Std_ReturnType CryIf_KeyCopy (uint32 cryIfKeyId, uint32 targetCryIfKeyId);

This function shall dispatch th e key derive function to the configured crypto driver object.

Std_ReturnType CryIf_KeyDerive (uint32 cryIfKeyId, uint32 targetCryIfKeyId);

Service CryIf_KeyElementCopy.

Std_ReturnType CryIf_KeyElementCopy (uint32 cryIfKeyId, uint32 keyElementId, uint32 targetCryIfKeyId, uint32 targetKeyElementId);

Service CryIf_KeyElementCopyPartial.

Std_ReturnType CryIf_KeyElementCopyPartial (uint32 cryIfKeyId, uint32 keyElementId, uint32 keyElementSourceOffset, uint32 keyElementTargetOffset, uint32 keyElementCopyLength, uint32 targetCryIfKeyId, uint32 targetKeyElementId);

This function shall dispatch the get key ele ment function to the configured crypto driver object.

Std_ReturnType CryIf_KeyElementGet (uint32 cryIfKeyId, uint32 keyElementId, uint8* resultPtr, uint32* resultLengthPtr);

This function shall dispatch the set key element function to the configured crypto driver object.

Std_ReturnType CryIf_KeyElementSet (uint32 cryIfKeyId, uint32 keyElementId, const uint8* keyPtr, uint32 keyLength);

This function shall dispatch the key exchange public value calculation function to the configured crypto driver object. Available

Std_ReturnType CryIf_KeyExchangeCalcPubVal (uint32 cryIfKeyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);

This function shall dispatch the key exchange common shared secret calculation function to the configured crypto driver object.

Std_ReturnType CryIf_KeyExchangeCalcSecret (uint32 cryIfKeyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);

This function shall dispatch the key generate function to the configured crypto driver object.

Std_ReturnType CryIf_KeyGenerate (uint32 cryIfKeyId);

Returns the key state of the key identified by cry If Key Id.

Std_ReturnType CryIf_KeyGetStatus (uint32 cryIfKeyId, Crypto_KeyStatusType* keyStatusPtr);

Sets invalid for the status of the key identifi ed by cry If Key Id.

Std_ReturnType CryIf_KeySetInvalid (uint32 cryIfKeyId);

This function shall dispatch the set key valid function to the configured crypto driver object.

Std_ReturnType CryIf_KeySetValid (uint32 cryIfKeyId);

Service CryIf_ProcessJob.

Std_ReturnType CryIf_ProcessJob (uint32 channelId, Crypto_JobType* job);

This function shall dispatch the random seed function to the configured crypto driver object.

Std_ReturnType CryIf_RandomSeed (uint32 cryIfKeyId, const uint8* seedPtr, uint32 seedLength);

Configuration data structure of Cry If module

Crypto

This interface removes the provided job from the queue and cancels the processing of the job if possible.

Std_ReturnType Crypto_CancelJob (uint32 objectId, Crypto_JobType* job);

Returns the version information of this module.

void Crypto_GetVersionInfo (Std_VersionInfoType* versioninfo);
Crypto_Init função

Initializes the Crypto Driver.

void Crypto_Init (const Crypto_ConfigType* configPtr);

Copies a key with all its elements to another key in the same crypto driver. Note: If the actual key element is directly mapped to flash memory, there could be a bigger delay when calling this function (synchronous operation)

Std_ReturnType Crypto_KeyCopy (uint32 cryptoKeyId, uint32 targetCryptoKeyId);

Derives a new key by using the key elements in the given key identified by the crypto Key Id. The given key contains the key elements for the password, salt. The derived key is stored in the key element with the id 1 of the key identified by target Crypto Key Id. The number of iterations is given in the key element CRYPTO_ KE_ KEYDERIVATION_ ITERATIONS.

Std_ReturnType Crypto_KeyDerive (uint32 cryptoKeyId, uint32 targetCryptoKeyId);

Service Crypto_KeyElementCopy.

Std_ReturnType Crypto_KeyElementCopy (uint32 cryptoKeyId, uint32 keyElementId, uint32 targetCryptoKeyId, uint32 targetKeyElementId);

Service Crypto_KeyElementCopyPartial.

Std_ReturnType Crypto_KeyElementCopyPartial (uint32 cryptoKeyId, uint32 keyElementId, uint32 keyElementSourceOffset, uint32 keyElementTargetOffset, uint32 keyElementCopyLength, uint32 targetCryptoKeyId, uint32 targetKeyElementId);

This interface shall be used to get a key element of the key identified by the crypto

Std_ReturnType Crypto_KeyElementGet (uint32 cryptoKeyId, uint32 keyElementId, uint8* resultPtr, uint32* resultLengthPtr);

Used to retrieve information which key elements are available in a given key.

Std_ReturnType Crypto_KeyElementIdsGet (uint32 cryptoKeyId, uint32* keyElementIdsPtr, uint32* keyElementIdsLengthPtr);

Sets the given key element bytes to the key identified by crypto Key Id.

Std_ReturnType Crypto_KeyElementSet (uint32 cryptoKeyId, uint32 keyElementId, const uint8* keyPtr, uint32 keyLength);

Calculates the public value for the key exchange a nd stores the public key in the memory location pointed by the public value pointer.

Std_ReturnType Crypto_KeyExchangeCalcPubVal (uint32 cryptoKeyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);

Calculates the shared secret key for the key exchange with the key material of the key identified by the crypto Key Id and the partner public key. The shared secret key is stored as a key element in the same key.

Std_ReturnType Crypto_KeyExchangeCalcSecret (uint32 cryptoKeyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);

Generates new key material store it in the key identified by crypto Key Id.

Std_ReturnType Crypto_KeyGenerate (uint32 cryptoKeyId);

Returns the key state of the key identified by crypto Key Id.

Std_ReturnType Crypto_KeyGetStatus (uint32 cryptoKeyId, Crypto_KeyStatusType* keyStatusPtr);

Sets invalid for the status of the key identifi ed by crypto Key Id.

Std_ReturnType Crypto_KeySetInvalid (uint32 cryptoKeyId);

Sets the key state of the key identified by crypto Key Id to valid.

Std_ReturnType Crypto_KeySetValid (uint32 cryptoKeyId);

If asynchronous job processing is configured and there are job queues, the function is called cyclically to process queued jobs. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoDriver

void Crypto_MainFunction (void);

Service Crypto_ProcessJob.

Std_ReturnType Crypto_ProcessJob (uint32 objectId, Crypto_JobType* job);

This function generates the internal seed state using the pro vided entropy source. Furthermore, this function can be used to update the seed state with new entropy

Std_ReturnType Crypto_RandomSeed (uint32 cryptoKeyId, const uint8* seedPtr, uint32 seedLength);

Configuration data structure of Cry If module

CSM

CSM notifies the application that a job has finished. The function name is configurable. The function name itself is derived from "{CSM Job/ CSM Job Primitive Callback Ref}/CSM Callback Func".

void <Csm_ApplicationCallbackNotification> (uint32 jobId, Crypto_ResultType result);

Service Csm_AEADDecryptManager.

Std_ReturnType Csm_AEADDecrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* ciphertextPtr, uint32 ciphertextLength, const uint8* associatedDataPtr, uint32 associatedDataLength, const uint8* tagPtr, uint32 tagLength, uint8* plaintextPtr, uint32* plaintextLengthPtr, Crypto_VerifyResultType* verifyPtr);

Service Csm_AEADEncrypt.

Std_ReturnType Csm_AEADEncrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* plaintextPtr, uint32 plaintextLength, const uint8* associatedDataPtr, uint32 associatedDataLength, uint8* ciphertextPtr, uint32* ciphertextLengthPtr, uint8* tagPtr, uint32* tagLengthPtr);

Notifies the CSM that a job has finished. This function is used by the underlying layer (CRYIF).

void Csm_CallbackNotification (Crypto_JobType* job, Crypto_ResultType result);
Csm_CancelJob função

Cancels the job processing from asynchronous or streaming jobs .

Csm_Decrypt função

Service Csm_Decrypt.

Std_ReturnType Csm_Decrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* resultPtr, uint32* resultLengthPtr);
Csm_Encrypt função

Service Csm_Encrypt.

Std_ReturnType Csm_Encrypt (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* resultPtr, uint32* resultLengthPtr);

Returns the version information of this module.

void Csm_GetVersionInfo (Std_VersionInfoType* versioninfo);
Csm_Hash função

Uses the given data to perform the hash calculation and stores the hash.

Std_ReturnType Csm_Hash (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* resultPtr, uint32* resultLengthPtr);
Csm_Init função

Initializes the CSM module. In configurations, in which CSM is assigned to more than one partition (i.e. Csm_ Main Functions are mapped to partitions), CSM may provide one init function per partition.

void Csm_Init (const Csm_ConfigType* configPtr);

Derives a new key by using the key elements in the given key identified by the key Id. The given key contains the key elements for the password and salt. The derived key is stored in the key element with the id 1 of the key identified by target Crypto

Std_ReturnType Csm_JobKeyDerive (uint32 jobId, uint32 keyId, uint32 targetKeyId);

Calculates the public value of the current user for the key exchange and stores the

Std_ReturnType Csm_JobKeyExchangeCalcPubVal (uint32 jobId, uint32 keyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);

Calculates the shared secret key for the key exchange with the key material of the key identified by the key Id and the partner public key. The shared secret key is stored as a key element in the same key.

Std_ReturnType Csm_JobKeyExchangeCalcSecret (uint32 jobId, uint32 keyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);

Generates new key material and stores it in the key identified by key Id.

Std_ReturnType Csm_JobKeyGenerate (uint32 jobId, uint32 keyId);

Sets the key status to invalid. The key cannot be used any longer for cryptographic operations until it has been set to valid state again.

Std_ReturnType Csm_JobKeySetInvalid (uint32 jobId, uint32 keyId);

Stores the key if necessary and sets the key state of the key identified by key Id to valid.

Std_ReturnType Csm_JobKeySetValid (uint32 jobId, uint32 keyId);

Provides a new seed for the specified key that is used for an associated random number generator.

Std_ReturnType Csm_JobRandomSeed (uint32 jobId, uint32 keyId, const uint8* seedPtr, Manager uint32 seedLength);
Csm_KeyCopy função

This function shall copy all key elements from the source key to a target key. Ava ilable via Csm.h

Std_ReturnType Csm_KeyCopy (const uint32 keyId, const uint32 targetKeyId);
Csm_KeyDerive função

Derives a new key by using the key elements in the given key identified by the key Id. The given key contains the key elements for the password and salt. The derived key is stored in the k ey element with the id 1 of the key identified by target Crypto Key Id.

Std_ReturnType Csm_KeyDerive (uint32 keyId, uint32 targetKeyId);

Service Csm_KeyElementCopyManager.

Std_ReturnType Csm_KeyElementCopy (const uint32 keyId, const uint32 keyElementId, const uint32 targetKeyId, const uint32 targetKeyElementId);

Service Csm_KeyElementCopyPartial.

Std_ReturnType Csm_KeyElementCopyPartial (uint32 keyId, uint32 keyElementId, uint32 keyElementSourceOffset, uint32 keyElementTargetOffset, uint32 keyElementCopyLength, uint32 targetKeyId, uint32 targetKeyElementId);

Service Csm_KeyElementGet.

Std_ReturnType Csm_KeyElementGet (uint32 keyId, uint32 keyElementId, uint8* keyElementPtr, Manager uint32* keyElementLengthPtr);

Sets the given key element bytes to the key identified by key Id.

Std_ReturnType Csm_KeyElementSet (uint32 keyId, uint32 keyElementId, const uint8* keyElementPtr, uint32 keyElementLength);

Calculates the public value of the current user for the key exchange and stores the pub lic key in the memory location pointed by the public value pointer.

Std_ReturnType Csm_KeyExchangeCalcPubVal (uint32 keyId, uint8* publicValuePtr, uint32* publicValueLengthPtr);

Calculates the shared secret key for the key exchange with the key material of the key identified by the key Id and the partner public key. The shared secret key is stored as a key element in the same key.

Std_ReturnType Csm_KeyExchangeCalcSecret (uint32 keyId, const uint8* partnerPublicValuePtr, uint32 partnerPublicValueLength);

Generates new key material and store it in the key identified by key Id.

Std_ReturnType Csm_KeyGenerate (uint32 keyId);

Returns the key state of the key identified by key Id.

Std_ReturnType Csm_KeyGetStatus (uint32 keyId, Crypto_KeyStatusType* keyStatusPtr);

Sets the key status to invalid. The key cannot be used any longer for cryptographic operations until it has been set to valid state again.

Std_ReturnType Csm_KeySetInvalid (uint32 keyId);

Sets the key state of the key identified by key Id to valid.

Std_ReturnType Csm_KeySetValid (uint32 keyId);

Service Csm_MacGenerate.

Std_ReturnType Csm_MacGenerate (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* macPtr, uint32* macLengthPtr);
Csm_MacVerify função

Service Csm_MacVerify.

Std_ReturnType Csm_MacVerify (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, const uint8* macPtr, const uint32 macLength, Crypto_VerifyResultType* verifyPtr);

API to be called cyclically to process the requested jobs. The Csm_ Main Function shall check the queues for jobs to pass to the underlying CRYIF. Per configured CSM Main Function ins tance one Csm_ Main Function_ shall be implemented. Hereby is the short name of the CSM Main Function configuration container in the ECU configuration.

void Csm_MainFunction (void);

Generate a random number and stores it in the memory location pointed by th e result pointer.

Std_ReturnType Csm_RandomGenerate (uint32 jobId, uint8* resultPtr, uint32* resultLengthPtr);

Feeds the key element CRYPTO_ KE_ RANDOM_ SEED with a random seed. Manager AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoServiceManager

Std_ReturnType Csm_RandomSeed (uint32 keyId, const uint8* seedPtr, uint32 seedLength);

The Crypto Driver extracts the context data from the context Buffer and restores the internal state so that further crypto operation of this crypto service will continue at the exact point when the context was taken.

Std_ReturnType Csm_RestoreContextJob (uint32 jobId, uint8* contextBufferPtr, uint32 contextBufferLength);

The Crypto Driver stores the internal context of the respective crypto operation to the context Buffer.

Std_ReturnType Csm_SaveContextJob (uint32 jobId, uint8* contextBufferPtr, uint32* contextBufferLengthPtr);

Service Csm_SignatureGenerate.

Std_ReturnType Csm_SignatureGenerate (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, uint8* signaturePtr, uint32* signatureLengthPtr);

Service Csm_SignatureVerify.

Std_ReturnType Csm_SignatureVerify (uint32 jobId, Crypto_OperationModeType mode, const uint8* dataPtr, uint32 DataLength, const uint8* signaturePtr, uint32 signatureLength, Crypto_VerifyResultType* verifyPtr);

Type Crypto_AlgorithmFamilyType.

Structure which determines the exact algorithm. Note, not every algorithm needs to specify all fields. AUTOSAR shall only allow valid combinations.

Type Crypto_AlgorithmModeType.

Defines which of the input/ output parameters are re - directed to a key element. The values can be combined to define a bit field.

Structure which contains further information, which depends on the job and the crypto primitive.

Type Crypto_JobPrimitiveInputOutputType.

Type Crypto_JobRedirectionInfoType.

Enumeration of the current job state.

Structure which contains further information, which depends on the job and the crypto primitive.

Enumeration for key status.

Enume ration which operation shall be performed. This enumeration is constructed from a bit mask, where the first bit indicates "Start", the second "Update" and the third "Finish".

Structure which contains basic information about the crypto primitive. Manager AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_CryptoServiceManager

Enumeration of the processing type.

Return for Std_ Return Type for Cryptostack.

Enumeration of the kind of the service.

Enumeration of the result type of verification operations.

Array long enough to store the data of the header.

Array long enough to store the ciphertext to be decrypted with AEAD.

Array long enough to store the data of the plaintext.

Array long enough to store the data of the Tag.

Array long enough to store the data of the header.

Array long enough to store the data of the cipher.

Array long enough to store the plaintext to be encrypted with AEAD.

Array long enough to store the data of the Tag.

Identification of a CSM service configuration via a numeric identifier, that is unique within a service. The name of a CSM service configuration, i.e. the name of the container Csm_Config, shall serve as a symbolic name for this parameter Avail able via Csm.h

Configuration data structure of CSM module

Array long enough to store the data to be decrypted.

Array long enough to store the data of the decrypted plaintext.

Array long enough to store the data to be encrypted.

Array long enough to store the data of the cipher.

Array long enough to store the data which shall be hashed.

Array long enough to store the data of the hash.

Array long enough to store any key element of the considered key

Implementation Data Type of category DATA_ REFERENCE with the pointer target uint32 to be able to return asynchronously the length.

Array long enough to store the data from which a MAC shall be generated.

Array long enough to store the data of the MAC.

Array long enough to store a MAC to be verified.

Array long enough to store the data for whichs MAC shall be verified.

Array long enough to store the data of the random number.

Array long enough to store the data from which the signature shall be generated.

Array long enough to store the signature and its length.

Array long enough to store a signature to be verified.

Array long enough to store the data for whichs signature shall be verified.

Implementation Data Type of category DATA_ REFERENCE with the pointer target Csm_ Verify Result Type to be able to return asynchronously the verify result.