Crypto Driver (Crypto)

A função Crypto_Init serve para inicializar o Crypto Driver em conformidade com [SWS_Crypto_91000]. A interface está declarada no cabeçalho Crypto.h e possui o service ID 0x00 [SWS_Crypto_91000].

Para a chamada e os parâmetros da interface, estão especificadas as seguintes propriedades:

• Ponteiro de configuração: através do parâmetro de entrada configPtr do tipo const Crypto_ConfigType*, é passado um ponteiro para a estrutura de configuração selecionada [SWS_Crypto_91000].
• Valor de retorno: a função não possui valor de retorno (void); não existem parâmetros de entrada/saída nem parâmetros de saída separados [SWS_Crypto_91000].
• Comportamento de execução: a rotina de inicialização é executada de forma síncrona (Synchronous) [SWS_Crypto_91000].
• Reentrância: a função está definida como não reentrante (Non Reentrant) [SWS_Crypto_91000]. Chamadas paralelas ou sobrepostas são inadmissíveis.

Devido à classificação como não reentrante e uma vez que a especificação não retorna códigos de erro específicos, a chamada deverá ocorrer tipicamente de forma centralizada durante a fase de inicialização da unidade de controlo, antes de quaisquer outros acessos ao driver (interpretação). Pergunta Q-008bb5a45b823891 (aberta) O chamador deverá também ser responsável por assegurar que a estrutura de configuração referenciada permaneça permanentemente válida na memória (interpretação). Pergunta Q-6271a86fad440121 (aberta)

A função Crypto_ProcessJob executa a primitiva criptográfica configurada no parâmetro job sobre o Crypto Driver Object referenciado por objectId [SWS_Crypto_91003]. A chamada é reentrante e opera de forma síncrona ou assíncrona, dependendo da configuração do job [SWS_Crypto_91003]. Através do ponteiro para Crypto_JobType, são passados tanto dados de configuração para a primitiva quanto buffers para os dados de resultado [SWS_Crypto_91003].

Antes da execução efetiva de um job, o driver verifica a validade dos identificadores de chave: se job->cryptoKeyId ou, se aplicável, job->targetCryptoKeyId estiverem fora do intervalo permitido, a função reporta o erro CRYPTO_E_PARAM_HANDLE ao DET e retorna E_NOT_OK [SWS_Crypto_00217]. Isto também se aplica ao serviço CRYPTO_KEYDERIVE (job->jobPrimitiveInfo->primitiveInfo->service), caso job->targetCryptoKeyId seja inválido [SWS_Crypto_00202].

Além de E_OK e E_NOT_OK, códigos de erro específicos sinalizam a falha da solicitação [SWS_Crypto_91003]:

• CRYPTO_E_BUSY, se o objeto de driver estiver ocupado ou a sua fila estiver cheia [SWS_Crypto_91003],
• erros relacionados com a chave como CRYPTO_E_KEY_NOT_VALID, CRYPTO_E_KEY_SIZE_MISMATCH, CRYPTO_E_KEY_READ_FAIL, CRYPTO_E_KEY_WRITE_FAIL, CRYPTO_E_KEY_NOT_AVAILABLE ou CRYPTO_E_KEY_EMPTY [SWS_Crypto_91003],
• CRYPTO_E_JOB_CANCELED em caso de cancelamento de um job síncrono [SWS_Crypto_91003] bem como
• CRYPTO_E_ENTROPY_EXHAUSTED em caso de entropia insuficiente de um gerador de números aleatórios; neste caso, a função reporta adicionalmente o erro de tempo de execução CRYPTO_E_RE_ENTROPY_EXHAUSTED [SWS_Crypto_00141], [SWS_Crypto_91003].

usar

A função síncrona Crypto_CancelJob remove um job passado da fila e, na medida do possível, cancela o seu processamento [SWS_Crypto_00122]. Na chamada, são passados o identificador do Crypto Driver Object (objectId) e um ponteiro para a configuração do job (job) [SWS_Crypto_00122].

Os valores de retorno sinalizam o resultado da tentativa de cancelamento:

• E_OK: A solicitação foi bem-sucedida e o job foi removido [SWS_Crypto_00122]. Se não houver erro no driver e o job não estiver a ser processado no momento, o serviço também retorna E_OK sem ações adicionais [SWS_Crypto_00214].
• E_NOT_OK: A solicitação falhou porque o job não pôde ser removido [SWS_Crypto_00122].
• CRYPTO_E_JOB_CANCELED: O job foi cancelado, mas continua a ser executado; nenhuns resultados são reportados de volta à aplicação [SWS_Crypto_00122]. Isto aplica-se se o driver funcionar sem erros, mas não conseguir cancelar o job (por exemplo, devido a limitações de hardware) [SWS_Crypto_00183].

Simultaneidade e restrições

A interface é reentrante para instâncias diferentes, mas não pode ser chamada simultaneamente para o mesmo Crypto Driver Object [SWS_Crypto_00122].

A função síncrona Crypto_KeyElementSet destina-se a definir os dados brutos de um determinado elemento de chave para uma chave identificada através de cryptoKeyId no driver criptográfico [SWS_Crypto_91004].

Parâmetros e valores de retorno

Através de keyElementId é endereçado o elemento de chave de destino, enquanto keyPtr aponta para o buffer de dados e keyLength para o seu tamanho em bytes [SWS_Crypto_91004]. Em caso de atribuição bem-sucedida, a interface retorna E_OK [SWS_Crypto_91004].

Tratamento de erros

Se ocorrer um erro durante o processamento, a função fornece valores de retorno específicos [SWS_Crypto_91004]:

• CRYPTO_E_BUSY: O objeto de driver criptográfico associado está ocupado.
• CRYPTO_E_KEY_WRITE_FAIL: O acesso de gravação ao elemento de chave foi negado.
• CRYPTO_E_KEY_NOT_AVAILABLE: O elemento de chave solicitado ou a chave não está disponível.
• CRYPTO_E_KEY_SIZE_MISMATCH: O comprimento dos dados passados não coincide com o tamanho do elemento de chave.
• E_NOT_OK: A solicitação falhou por outros motivos.

simultaneidade

A função está especificada como não reentrante (Non Reentrant) [SWS_Crypto_91004]. Interpretação: os chamadores deverão ser responsáveis por sincronizar chamadas paralelas entre si, a fim de evitar inconsistências de dados no driver. Pergunta Q-d7ef7a774052a212 (aberta)

A função síncrona Crypto_KeySetValid serve para definir o estado de uma chave especificada pelo identificador cryptoKeyId como válido ([SWS_Crypto_91014]). A interface está disponível através do arquivo de cabeçalho Crypto.h e possui o Service ID 0x05 ([SWS_Crypto_91014]).

Durante o uso, os seguintes parâmetros e valores de retorno são definidos ([SWS_Crypto_91014]):

• Parâmetro de entrada: Através de cryptoKeyId (tipo uint32), é passado o identificador da chave cujo estado deve ser definido como válido ([SWS_Crypto_91014]). Não existem parâmetros adicionais de entrada ou de saída ([SWS_Crypto_91014]).
• Valor de retorno: Um código de status do tipo Std_ReturnType informa sobre o resultado da solicitação ([SWS_Crypto_91014]):
  • E_OK: A solicitação foi bem-sucedida ([SWS_Crypto_91014]).
  • E_NOT_OK: A solicitação falhou ([SWS_Crypto_91014]).
  • CRYPTO_E_BUSY: A execução falhou porque o Crypto Driver Object responsável está ocupado ([SWS_Crypto_91014]).

Em relação à simultaneidade, a função é especificada como não reentrante ("Non Reentrant") ([SWS_Crypto_91014]). Interpretação: Os chamadores provavelmente precisam coordenar chamadas paralelas entre tarefas externamente para evitar conflitos, e devem prever uma nova tentativa da chamada em um momento posterior ao receber CRYPTO_E_BUSY. Pergunta Q-32d775a9e61e5731 (aberta)

Utilização e semântica

A função síncrona Crypto_KeySetInvalid define o status de uma chave identificada por cryptoKeyId como inválido [SWS_Crypto_91020]. A função é definida no arquivo de cabeçalho Crypto.h e é acessada por meio do Service ID 0x15 [SWS_Crypto_91020]. O único parâmetro de passagem é o valor de entrada cryptoKeyId (tipo uint32), que contém o identificador unívoco da chave de destino; não existem parâmetros de entrada/saída nem de saída [SWS_Crypto_91020].

Tratamento de erros e valores de retorno

O resultado da execução da função é sinalizado através do valor de retorno do tipo Std_ReturnType [SWS_Crypto_91020]:

• E_OK: A solicitação foi bem-sucedida e o status da chave foi definido como inválido [SWS_Crypto_91020].
• E_NOT_OK: A execução da solicitação falhou [SWS_Crypto_91020].
• CRYPTO_E_BUSY: A solicitação falhou porque o objeto de driver de criptografia (Crypto Driver Object) responsável está atualmente ocupado [SWS_Crypto_91020].

Simultaneidade e restrições

A interface é especificada como não reentrante (Non Reentrant) [SWS_Crypto_91020]. Uma chamada simultânea ou de interrupção é, portanto, inadmissível. Como a função é executada de forma síncrona, ela só retorna ao chamador após a conclusão da alteração de status ou após a identificação do erro [SWS_Crypto_91020].

A função síncrona e reentrante Crypto_KeyElementGet destina-se a ler um elemento de chave identificado por keyElementId a partir da chave cryptoKeyId e a armazená-lo na área de memória resultPtr [SWS_Crypto_91006]. A interface é disponibilizada através do cabeçalho Crypto.h e possui o service ID 0x06 [SWS_Crypto_91006]. Na chamada, o chamador passa através do parâmetro de entrada e saída resultLengthPtr o tamanho do buffer ou, no caso de acesso parcial configurado, o tamanho de leitura desejado; após a conclusão da execução, o driver armazena aí a quantidade de dados efetivamente copiada [SWS_Crypto_91006].

Em caso de sucesso, a função retorna E_OK [SWS_Crypto_91006]. Se a operação falhar, sinaliza isso através de códigos de erro específicos: CRYPTO_E_BUSY se o objeto de driver criptográfico estiver ocupado, CRYPTO_E_KEY_NOT_AVAILABLE se o elemento de chave não estiver disponível, CRYPTO_E_KEY_READ_FAIL se o acesso de leitura for negado, CRYPTO_E_KEY_EMPTY no caso de um elemento de origem não inicializado, bem como, genericamente, E_NOT_OK [SWS_Crypto_91006].

Embora a interface esteja especificada como reentrante, a especificação salienta que, no caso de mapeamento direto do elemento de chave na memória flash, podem ocorrer latências percetíveis durante a execução síncrona [SWS_Crypto_91006]. Interpretação: devido a estes potenciais atrasos, a chamada deverá ser adequada primordialmente no contexto de tarefas e não dentro de rotinas de serviço de interrupção com requisitos críticos de tempo. Pergunta Q-ff4e2843b9aad46d (aberta)

A função síncrona Crypto_KeyGetStatus destina-se a consultar o estado atual de uma chave específica dentro do driver criptográfico [SWS_Crypto_91019]. É disponibilizada através do cabeçalho Crypto.h e possui o service ID 0x14 [SWS_Crypto_91019].

Utilização e parâmetros

A chamada ocorre de forma síncrona e espera dois parâmetros [SWS_Crypto_91019]:

• cryptoKeyId: O identificador da chave cujo estado deve ser determinado.
• keyStatusPtr: Ponteiro para a área de memória do tipo Crypto_KeyStatusType, para a qual o estado é retornado.

Como valor de retorno, a interface devolve Std_ReturnType. Em caso de execução bem-sucedida, é reportado E_OK, enquanto em caso de erro é retornado E_NOT_OK [SWS_Crypto_91019].

Simultaneidade e restrições

A função está declarada como não reentrante (Non Reentrant) [SWS_Crypto_91019]. Os chamadores devem, por conseguinte, assegurar que chamadas concorrentes sejam evitadas através de mecanismos de sincronização de nível superior. Mensagens de erro DET específicas não estão listadas; provavelmente uma chamada incorreta, como um ponteiro inválido ou um ID inválido, leva diretamente ao retorno de E_NOT_OK [SWS_Crypto_91019]. Pergunta Q-5703fab02905e91a (aberta)

A função síncrona Crypto_KeyElementCopy destina-se a copiar um elemento de chave para outro elemento de chave dentro do mesmo driver criptográfico [SWS_Crypto_00148]. São passados os identificadores da chave de origem (cryptoKeyId) e do elemento de chave de origem (keyElementId), bem como da chave de destino (targetCryptoKeyId) e do elemento de chave de destino (targetKeyElementId) [SWS_Crypto_00148].

No que diz respeito ao comportamento temporal, deve notar-se que, no caso de elementos de chave mapeados diretamente na memória flash, podem ocorrer atrasos maiores na chamada da função devido à execução síncrona [SWS_Crypto_00148]. O comportamento do tempo de execução deve, por isso, ser tido em conta, em particular em contextos com requisitos críticos de tempo.

A função é concebida como reentrante, mas explicitamente não para a mesma cryptoKeyId [SWS_Crypto_00148]. As chamadas simultâneas com uma chave de origem idêntica devem, por conseguinte, ser sincronizadas ou excluídas pelo chamador.

Em caso de sucesso, a função retorna E_OK [SWS_Crypto_00148]. Em caso de erros, o valor de retorno sinaliza a causa específica [SWS_Crypto_00148]:

• CRYPTO_E_BUSY: O objeto de driver criptográfico está ocupado [SWS_Crypto_00148].
• CRYPTO_E_KEY_NOT_AVAILABLE: O elemento de chave solicitado de pelo menos uma chave não está disponível [SWS_Crypto_00148].
• CRYPTO_E_KEY_READ_FAIL ou CRYPTO_E_KEY_WRITE_FAIL: A leitura do elemento de origem ou a escrita do elemento de destino não é permitida [SWS_Crypto_00148].
• CRYPTO_E_KEY_SIZE_MISMATCH: Os tamanhos dos elementos de chave não são compatíveis entre si [SWS_Crypto_00148].
• CRYPTO_E_KEY_EMPTY: o elemento de chave de origem não está inicializado [SWS_Crypto_00148].
• E_NOT_OK: A solicitação falhou de forma geral [SWS_Crypto_00148].

A função síncrona Crypto_KeyElementCopyPartial serve para a cópia parcial de dados de um elemento de chave de origem para um elemento de chave de destino dentro do mesmo driver de criptografia [SWS_Crypto_91015]. Por meio dos parâmetros keyElementSourceOffset e keyElementCopyLength, define-se o trecho a ser copiado do elemento de origem (cryptoKeyId, keyElementId), enquanto keyElementTargetOffset determina a posição inicial no elemento de destino (targetCryptoKeyId, targetKeyElementId). Em caso de verificação sem erros, o driver realiza a operação de cópia sincronamente e retorna E_OK [SWS_Crypto_00209].

Antes da execução, o driver valida os estados do buffer e do driver:

• Se o driver de criptografia não estiver inicializado e o controle de desenvolvimento estiver ativado, a função reporta CRYPTO_E_UNINIT ao DET e retorna E_NOT_OK [SWS_Crypto_00205].
• Se o comprimento total do elemento de chave de origem for menor que keyElementSourceOffset + keyElementCopyLength, a chamada falha com CRYPTO_E_KEY_SIZE_MISMATCH [SWS_Crypto_00207].
• Se o buffer máximo do elemento de chave de destino oferecer menos espaço do que keyElementTargetOffset + keyElementCopyLength, CRYPTO_E_KEY_SIZE_MISMATCH também é reportado [SWS_Crypto_00208].
• Outros valores de erro especificados incluem CRYPTO_E_BUSY (objeto de driver ocupado), CRYPTO_E_KEY_EMPTY (elemento de origem não inicializado), CRYPTO_E_KEY_NOT_AVAILABLE bem como erros de acesso de leitura ou escrita (CRYPTO_E_KEY_READ_FAIL, CRYPTO_E_KEY_WRITE_FAIL) [SWS_Crypto_91015].

A função é reentrante, mas não deve ser chamada simultaneamente para o mesmo ID de chave cryptoKeyId [SWS_Crypto_91015]. Se um elemento de chave estiver armazenado diretamente na memória flash, a execução síncrona pode causar atrasos perceptíveis [SWS_Crypto_91015].

usar

A função síncrona Crypto_KeyCopy copia uma chave juntamente com todos os seus elementos de chave para uma chave de destino dentro do mesmo Crypto Driver [SWS_Crypto_00155]. A atribuição é realizada por meio dos parâmetros de entrada cryptoKeyId para a chave de origem e targetCryptoKeyId para a chave de destino [SWS_Crypto_00155]. Uma operação de cópia bem-sucedida é confirmada com E_OK [SWS_Crypto_00155].

Simultaneidade e comportamento em tempo de execução

A interface foi projetada para ser reentrante, mas não deve ser executada simultaneamente para o mesmo cryptoKeyId [SWS_Crypto_00155]. Como a execução é síncrona, podem ocorrer atrasos perceptíveis durante a chamada para elementos de chave armazenados diretamente na memória flash [SWS_Crypto_00155].

Tratamento de erros

Em caso de erro, a função fornece valores de retorno específicos do tipo Std_ReturnType [SWS_Crypto_00155]:

• CRYPTO_E_BUSY: O Crypto Driver Object associado está ocupado [SWS_Crypto_00155].
• CRYPTO_E_KEY_NOT_AVAILABLE: Pelo menos uma das chaves solicitadas não está disponível [SWS_Crypto_00155].
• CRYPTO_E_KEY_READ_FAIL: A leitura do elemento de chave de origem não é permitida [SWS_Crypto_00155].
• CRYPTO_E_KEY_WRITE_FAIL: A escrita no elemento de chave de destino não é permitida [SWS_Crypto_00155].
• CRYPTO_E_KEY_SIZE_MISMATCH: Os tamanhos dos elementos de chave não são compatíveis entre si [SWS_Crypto_00155].
• CRYPTO_E_KEY_EMPTY: O elemento de chave da chave de origem não está inicializado [SWS_Crypto_00155].
• E_NOT_OK: A execução da solicitação falhou [SWS_Crypto_00155].

A função síncrona Crypto_KeyElementIdsGet destina-se a consultar informações sobre quais os elementos de chave que estão disponíveis numa determinada chave [SWS_Crypto_00160]. Através do parâmetro de entrada cryptoKeyId, é transmitido o identificador da chave cujos IDs de elementos disponíveis devem ser exportados [SWS_Crypto_00160]. Os identificadores determinados são armazenados no array referenciado pelo ponteiro keyElementIdsPtr [SWS_Crypto_00160].

A gestão do tamanho do buffer é efetuada através do parâmetro de entrada e saída keyElementIdsLengthPtr: aquando da chamada, este parâmetro deve conter o tamanho disponibilizado do buffer keyElementIdsPtr [SWS_Crypto_00160]. Após a conclusão da operação, é armazenado aí o número efetivo de elementos de chave existentes [SWS_Crypto_00160].

Como valor de retorno, o serviço fornece E_OK em caso de consulta bem-sucedida ou E_NOT_OK se a solicitação falhar [SWS_Crypto_00160]. Se o objeto de driver criptográfico competente estiver ocupado no momento da chamada, é retornado o código de erro CRYPTO_E_BUSY [SWS_Crypto_00160].

No que diz respeito à simultaneidade, a função é reentrante, mas não pode ser chamada simultaneamente para a mesma cryptoKeyId [SWS_Crypto_00160]. A declaração está disponível através do cabeçalho Crypto.h [SWS_Crypto_00160].

A função síncrona Crypto_RandomSeed (service ID 0x0d) serve, de acordo com [SWS_Crypto_91013], para a geração bem como para a atualização do estado de semente interno de uma chave utilizando uma fonte de entropia disponibilizada. A declaração da função está contida no ficheiro de cabeçalho Crypto.h.

Utilização e parâmetros de chamada

Além da geração inicial, a função também pode ser utilizada, de acordo com [SWS_Crypto_91013], para atualizar o estado de semente com nova entropia. A chamada síncrona requer três parâmetros de entrada:

• cryptoKeyId: Passa o identificador da chave para a qual deve ser gerada uma nova semente.
• seedPtr: Contém um ponteiro para a área de memória com os dados para alimentar a semente.
• seedLength: Define o comprimento dos dados de semente passados em bytes.

Valores de retorno e tratamento de erros

Como valor de retorno, Crypto_RandomSeed reporta um estado do tipo Std_ReturnType de acordo com [SWS_Crypto_91013]:

• E_OK: A solicitação foi executada com sucesso.
• E_NOT_OK: A solicitação falhou.
• CRYPTO_E_KEY_NOT_VALID: A execução falha porque o estado da chave identificada por cryptoKeyId se encontra no estado «invalid».

Simultaneidade e restrições

De acordo com [SWS_Crypto_91013], a função está especificada como reentrante, mas expressamente não para a mesma cryptoKeyId. As chamadas paralelas para a mesma chave devem, por isso, ser impedidas do lado do chamador.

usar

A função Crypto_KeyGenerate, disponibilizada através do ficheiro de cabeçalho Crypto.h, gera novo material de chave e atualiza a chave endereçada através do identificador cryptoKeyId [SWS_Crypto_91007]. A função opera de forma totalmente síncrona e está definida sob o service ID 0x07 [SWS_Crypto_91007]. Além do identificador da chave, não existem outros parâmetros [SWS_Crypto_91007].

Simultaneidade e restrições

No que diz respeito à simultaneidade, Crypto_KeyGenerate está especificado como reentrante, mas expressamente com a restrição de que isso não se aplica à mesma cryptoKeyId [SWS_Crypto_91007]. Se forem feitas várias solicitações para a mesma chave, estas devem ser sincronizadas do lado do chamador para evitar conflitos no driver.

Valores de retorno e tratamento de erros

Através do valor de retorno do tipo base Std_ReturnType, o chamador obtém feedback detalhado sobre o sucesso ou as causas de erro específicas da operação [SWS_Crypto_91007]:

• E_OK: A geração da chave foi executada com sucesso [SWS_Crypto_91007].
• CRYPTO_E_BUSY: A solicitação falhou porque o Crypto Driver Object competente está ocupado no momento [SWS_Crypto_91007].
• CRYPTO_E_KEY_EMPTY: A geração falhou porque um elemento de chave de origem necessário não está inicializado [SWS_Crypto_91007].
• CRYPTO_E_KEY_NOT_VALID: A operação falhou porque o estado da chave referenciada por cryptoKeyId está marcado como inválido [SWS_Crypto_91007].
• E_NOT_OK: A solicitação para geração da chave falhou por outros motivos [SWS_Crypto_91007].

A função síncrona Crypto_KeyDerive deriva uma nova chave criptográfica a partir dos elementos de chave de uma chave de origem (cryptoKeyId) e armazena-a no elemento de chave com o ID 1 da chave de destino (targetCryptoKeyId) [SWS_Crypto_91008]. A chave de origem deve conter os elementos de chave necessários para a palavra-passe e o salt; o número de iterações é especificado através do elemento de chave CRYPTO_KE_KEYDERIVATION_ITERATIONS [SWS_Crypto_91008].

Chamada e simultaneidade

A interface é reentrante, mas não pode ser chamada simultaneamente para a mesma cryptoKeyId [SWS_Crypto_91008]. Os chamadores devem, por conseguinte, assegurar que operações de derivação paralelas operem sobre chaves de origem diferentes.

Valores de retorno e tratamento de erros

A função sinaliza o resultado através de valores de retorno definidos do tipo Std_ReturnType [SWS_Crypto_91008]:

• E_OK: Derivação de chave realizada com sucesso.
• E_NOT_OK: Derivação falhou. Se o parâmetro targetCryptoKeyId estiver fora do intervalo válido, a função reporta adicionalmente CRYPTO_E_PARAM_HANDLE ao DET com a deteção de desenvolvimento ativada [SWS_Crypto_00180].
• CRYPTO_E_BUSY: O Crypto Driver Object responsável está ocupado [SWS_Crypto_91008].
• CRYPTO_E_KEY_EMPTY: Um elemento de chave de origem necessário não está inicializado [SWS_Crypto_91008].
• CRYPTO_E_KEY_NOT_VALID: O estado da chave referenciada por cryptoKeyId é inválido [SWS_Crypto_91008].

usar

A função síncrona Crypto_KeyExchangeCalcPubVal calcula o valor público para um protocolo de troca de chaves e armazena-o na localização de memória de publicValuePtr ([SWS_Crypto_91009]). O chamador passa através de cryptoKeyId o identificador da chave que deve ser utilizada para o protocolo. Através do parâmetro de entrada e saída publicValueLengthPtr, deve ser passado aquando da chamada o tamanho do buffer da memória disponibilizada; após a conclusão da execução, é armazenado aí o comprimento efetivo do valor público calculado ([SWS_Crypto_91009]).

Tratamento de erros e valores de retorno

A função retorna E_OK em caso de execução bem-sucedida. Se ocorrer um erro, é retornado E_NOT_OK ou um código de erro específico ([SWS_Crypto_91009]):

• CRYPTO_E_BUSY: A solicitação falha porque o Crypto Driver Object está ocupado.
• CRYPTO_E_KEY_EMPTY: A solicitação falha porque o elemento de chave de origem não está inicializado.
• CRYPTO_E_KEY_NOT_VALID: A solicitação falha porque o estado da chave referenciada através de cryptoKeyId é inválido.

Simultaneidade e integração do sistema

De acordo com [SWS_Crypto_91009], a função é reentrante, mas não para a mesma cryptoKeyId. Se o driver criptográfico necessitar de serviços de um gerador de números aleatórios (RNG) para fins internos, como Crypto_KeyExchangeCalcPubVal, o primeiro Crypto Driver Object (número de objeto 0) deve estar configurado para este fim ([SWS_Crypto_00224]).

A função síncrona Crypto_KeyExchangeCalcSecret destina-se ao cálculo de um segredo partilhado (Shared Secret Key) para um protocolo de troca de chaves [SWS_Crypto_91010]. Ela processa o material de chave da chave especificada através de cryptoKeyId juntamente com o valor público do parceiro passado através de partnerPublicValuePtr, cujo número de bytes é indicado através de partnerPublicValueLength [SWS_Crypto_91010]. O segredo partilhado calculado é armazenado diretamente como elemento de chave dentro da mesma chave [SWS_Crypto_91010].

Como valor de retorno, a função fornece o estado através de Std_ReturnType [SWS_Crypto_91010]:

• E_OK: O cálculo e o armazenamento do segredo foram concluídos com sucesso [SWS_Crypto_91010].
• E_NOT_OK: a solicitação falhou [SWS_Crypto_91010].
• CRYPTO_E_BUSY: A execução falhou porque o Crypto Driver Object competente está ocupado [SWS_Crypto_91010].
• CRYPTO_E_KEY_EMPTY: O elemento de chave de origem não está inicializado [SWS_Crypto_91010].
• CRYPTO_E_KEY_NOT_VALID: O estado da chave referenciada por cryptoKeyId é inválido [SWS_Crypto_91010].

A interface está implementada como reentrante, mas não pode ser chamada concorrentemente para a mesma cryptoKeyId [SWS_Crypto_91010]. Os chamadores devem, portanto, assegurar que sejam evitadas chamadas simultâneas com ID de chave idêntico e que o material de chave referenciado esteja previamente inicializado e num estado válido, a fim de evitar estados de erro [SWS_Crypto_91010].

A função Crypto_MainFunction destina-se ao processamento cíclico de pedidos criptográficos enfileirados nas filas de jobs do driver criptográfico [SWS_Crypto_91012]. Pré-requisito para a sua utilização é que o processamento assíncrono de pedidos tenha sido configurado no módulo e que existam as filas de pedidos correspondentes [SWS_Crypto_91012].

Chamada e semântica

A função possui a assinatura void Crypto_MainFunction(void) e está especificada com o service ID 0x0c [SWS_Crypto_91012]. Não recebe nenhuns parâmetros de entrada e não fornece nenhum valor de retorno. A interface é disponibilizada através do cabeçalho SchM_Crypto.h [SWS_Crypto_91012]. Isto permite a interpretação de que a chamada cíclica é despoletada conforme planeado pelo escalonador da BSW (Schedule Manager) no contexto de uma tarefa periódica do sistema operativo.

Simultaneidade e restrições

A chamada está estritamente vinculada à configuração de filas de jobs assíncronos [SWS_Crypto_91012]. Como a especificação não indica reentrância para Crypto_MainFunction, a função deverá ser tratada como não reentrante; chamadas paralelas a partir de múltiplas threads ou tarefas devem, por conseguinte, ser evitadas. Pergunta Q-038d384305c8c5c3 (aberta)

Tratamento de erros

Na especificação não estão registados códigos de erro específicos ou entradas DET para esta função [SWS_Crypto_91012]. Uma vez que a função não fornece valores de retorno, quaisquer erros durante o processamento assíncrono serão provavelmente transmitidos a camadas superiores através de consultas de estado ou através dos canais de retorno dos respetivos jobs. Pergunta (aberta)