Referência da estrutura keymaster1_device

Campos de dados
Referência da estrutura keymaster1_device

#include < keymaster1.h >

Campos de dados

struct hw_device_t   comum
 
uint32_t  client_version
 
uint32_t  flags
 
void *  context
 
int(*  generate_keypair )(const struct keymaster1_device *dev, const keymaster_keypair_t key_type, const void *key_params, uint8_t **key_blob, size_t *key_blob_length)
 
int(*  import_keypair )(const struct keymaster1_device *dev, const uint8_t *key, const size_t key_length, uint8_t **key_blob, size_t *key_blob_length)
 
int(*  get_keypair_public )(const struct keymaster1_device *dev, const uint8_t *key_blob, const size_t key_blob_length, uint8_t **x509_data, size_t *x509_data_length)
 
int(*  delete_keypair )(const struct keymaster1_device *dev, const uint8_t *key_blob, const size_t key_blob_length)
 
int(*  delete_all )(const struct keymaster1_device *dev)
 
int(*  sign_data )(const struct keymaster1_device *dev, const void *signing_params, const uint8_t *key_blob, const size_t key_blob_length, const uint8_t *data, const size_t data_length, uint8_t **signed_data, size_t *signed_data_length)
 
int(*  verify_data )(const struct keymaster1_device *dev, const void *signing_params, const uint8_t *key_blob, const size_t key_blob_length, const uint8_t *signed_data, const size_t signed_data_length, const uint8_t *signature, const size_t signature_length)
 
keymaster_error_t (*  get_supported_algorithms )(const struct keymaster1_device *dev, keymaster_algorithm_t **algorithms, size_t *algorithms_length)
 
keymaster_error_t (*  get_supported_block_modes )(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_purpose_t purpose, keymaster_block_mode_t **modes, size_t *modes_length)
 
keymaster_error_t (*  get_supported_padding_modes )(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_purpose_t purpose, keymaster_padding_t **modes, size_t *modes_length)
 
keymaster_error_t (*  get_supported_digests )(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_purpose_t purpose, keymaster_digest_t **digests, size_t *digests_length)
 
keymaster_error_t (*  get_supported_import_formats )(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_key_format_t **formats, size_t *formats_length)
 
keymaster_error_t (*  get_supported_export_formats )(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_key_format_t **formats, size_t *formats_length)
 
keymaster_error_t (*  add_rng_entropy )(const struct keymaster1_device *dev, const uint8_t *data, size_t data_length)
 
keymaster_error_t (*  generate_key )(const struct keymaster1_device *dev, const keymaster_key_param_set_t *params, keymaster_key_blob_t *key_blob, keymaster_key_characteristics_t **characteristics)
 
keymaster_error_t (*  get_key_characteristics )(const struct keymaster1_device *dev, const keymaster_key_blob_t *key_blob, const keymaster_blob_t *client_id, const keymaster_blob_t *app_data, keymaster_key_characteristics_t **characteristics)
 
keymaster_error_t (*  import_key )(const struct keymaster1_device *dev, const keymaster_key_param_set_t *params, keymaster_key_format_t key_format, const keymaster_blob_t *key_data, keymaster_key_blob_t *key_blob, keymaster_key_characteristics_t **characteristics)
 
keymaster_error_t (*  export_key )(const struct keymaster1_device *dev, keymaster_key_format_t export_format, const keymaster_key_blob_t *key_to_export, const keymaster_blob_t *client_id, const keymaster_blob_t *app_data, keymaster_blob_t *export_data)
 
keymaster_error_t (*  delete_key )(const struct keymaster1_device *dev, const keymaster_key_blob_t *key)
 
keymaster_error_t (*  delete_all_keys )(const struct keymaster1_device *dev)
 
keymaster_error_t (*  begin )(const struct keymaster1_device *dev, keymaster_purpose_t purpose, const keymaster_key_blob_t *key, const keymaster_key_param_set_t *in_params, keymaster_key_param_set_t *out_params, keymaster_operation_handle_t *operation_handle)
 
keymaster_error_t (*  update )(const struct keymaster1_device *dev, keymaster_operation_handle_t operation_handle, const keymaster_key_param_set_t *in_params, const keymaster_blob_t *input, size_t *input_consumed, keymaster_key_param_set_t *out_params, keymaster_blob_t *output)
 
keymaster_error_t (*  finish )(const struct keymaster1_device *dev, keymaster_operation_handle_t operation_handle, const keymaster_key_param_set_t *in_params, const keymaster_blob_t *signature, keymaster_key_param_set_t *out_params, keymaster_blob_t *output)
 
keymaster_error_t (*  abort )(const struct keymaster1_device *dev, keymaster_operation_handle_t operation_handle)
 

Descrição detalhada

Definição do dispositivo Keymaster1

Definição na linha 28 do arquivo keymaster1.h .

Documentação do campo

keymaster_error_t (* abort)(const struct keymaster1_device *dev, keymaster_operation_handle_t operation_handle)

Aborta uma operação criptográfica iniciada com begin() , liberando todos os recursos internos e invalidando operation_handle .

Definição na linha 531 do arquivo keymaster1.h .

keymaster_error_t (* add_rng_entropy)(const struct keymaster1_device *dev, const uint8_t *data, size_t data_length)

Adiciona entropia ao RNG usado pelo keymaster. A entropia adicionada por esse método não é a única fonte de entropia usada, e a função de mistura precisa ser segura, ou seja, se o RNG for inicializado (de qualquer fonte) com dados que o invasor não pode prever (ou controlar), a saída do RNG não poderá ser distinguida de uma saída aleatória. Assim, se a entropia de qualquer fonte for boa, a saída será boa.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] dados Dados aleatórios a serem misturados.
[in] data_length Comprimento de data .

Definição na linha 242 do arquivo keymaster1.h .

keymaster_error_t (* begin)(const struct keymaster1_device *dev, keymaster_purpose_t purpose, const keymaster_key_blob_t *key, const keymaster_key_param_set_t *in_params, keymaster_key_param_set_t *out_params, keymaster_operation_handle_t *operation_handle)

Inicia uma operação criptográfica usando a chave especificada. Se tudo estiver bem, begin() vai retornar KM_ERROR_OK e criar um identificador de operação que precisa ser transmitido para chamadas subsequentes para update() , finish() ou abort() .

É fundamental que cada chamada para begin() seja associada a uma chamada subsequente para finish() ou abort() , para permitir que a implementação do keymaster limpe qualquer estado de operação interno. Se isso não for feito, pode ocorrer um vazamento de espaço de estado interno ou outros recursos internos, e isso pode fazer com que begin() retorne KM_ERROR_TOO_MANY_OPERATIONS quando o espaço para operações acabar. Qualquer resultado diferente de KM_ERROR_OK de begin() , update() ou finish() aborta implicitamente a operação. Nesse caso, abort() não precisa ser chamado (e vai retornar KM_ERROR_INVALID_OPERATION_HANDLE se for chamado).

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] propósito A finalidade da operação, uma de KM_PURPOSE_ENCRYPT, KM_PURPOSE_DECRYPT, KM_PURPOSE_SIGN ou KM_PURPOSE_VERIFY. Para os modos AEAD, a criptografia e a descriptografia implicam assinatura e verificação, respectivamente, mas precisam ser especificadas como KM_PURPOSE_ENCRYPT e KM_PURPOSE_DECRYPT.
[in] chave A chave a ser usada para a operação. key precisa ter uma finalidade compatível com purpose e todos os requisitos de uso precisam ser atendidos. Caso contrário, begin() vai retornar um código de erro adequado.
[in] in_params Parâmetros adicionais para a operação. Isso geralmente é usado para fornecer dados de autenticação com KM_TAG_AUTH_TOKEN. Se KM_TAG_APPLICATION_ID ou KM_TAG_APPLICATION_DATA foram fornecidos durante a geração, eles precisam ser fornecidos aqui. Caso contrário, a operação falhará com KM_ERROR_INVALID_KEY_BLOB. Para operações que exigem um valor de uso único ou IV, em chaves geradas com KM_TAG_CALLER_NONCE, in_params pode conter uma tag KM_TAG_NONCE. Para operações AEAD, o KM_TAG_CHUNK_SIZE é especificado aqui.
[out] out_params Parâmetros de saída. Usado para retornar dados adicionais da inicialização da operação, principalmente para retornar o IV ou o valor de uso único de operações que geram um IV ou valor de uso único. O autor da chamada assume a propriedade da matriz de parâmetros de saída e precisa liberá-la com keymaster_free_param_set() . out_params pode ser definido como NULL se nenhum parâmetro de saída for esperado. Se out_params for NULL e os parâmetros de saída forem gerados, begin() vai retornar KM_ERROR_OUTPUT_PARAMETER_NULL.
[out] operation_handle O identificador de operação recém-criado que precisa ser transmitido para update() , finish() ou abort() . Se operation_handle for NULL, begin() vai retornar KM_ERROR_OUTPUT_PARAMETER_NULL.

Definição na linha 451 do arquivo keymaster1.h .

uint32_t client_version

OBSOLETO. Use os novos campos "module_api_version" e "hal_api_version" na inicialização do keymaster_module.

Definição na linha 41 do arquivo keymaster1.h .

struct hw_device_t common

Métodos comuns do dispositivo keymaster. Ele precisa ser o primeiro membro de keymaster_device, já que os usuários dessa estrutura vão transmitir um hw_device_t para o ponteiro keymaster_device em contextos em que se sabe que o hw_device_t faz referência a um keymaster_device.

Definição na linha 35 do arquivo keymaster1.h .

void* context

Definição na linha 48 do arquivo keymaster1.h .

int(* delete_all)(const struct keymaster1_device *dev)
Uso descontinuado:
Exclui todas as chaves no keystore de hardware. Usado quando o keystore é redefinido completamente.

Essa função é opcional e precisa ser definida como NULL se não for implementada.

Retorna 0 em caso de sucesso ou um código de erro menor que 0.

Definição na linha 100 do arquivo keymaster1.h .

keymaster_error_t (* delete_all_keys)(const struct keymaster1_device *dev)

Exclui todas as chaves no keystore de hardware. Usado quando o keystore é redefinido completamente. Depois de chamar essa função, será impossível usar blobs de chaves gerados ou importados anteriormente em qualquer operação.

Essa função é opcional e precisa ser definida como NULL se não for implementada.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.

Definição na linha 407 do arquivo keymaster1.h .

keymaster_error_t (* delete_key)(const struct keymaster1_device *dev, const keymaster_key_blob_t *key)

Exclui a chave ou o par de chaves associado ao blob de chave. Depois de chamar essa função, será impossível usar a chave para outras operações. Pode ser aplicado a chaves de raízes de confiança estrangeiras (chaves não utilizáveis na raiz de confiança atual).

Essa função é opcional e precisa ser definida como NULL se não for implementada.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] chave A chave a ser excluída.

Definição na linha 395 do arquivo keymaster1.h .

int(* delete_keypair)(const struct keymaster1_device *dev, const uint8_t *key_blob, const size_t key_blob_length)
Uso descontinuado:
Exclui o par de chaves associado ao blob de chaves.

Essa função é opcional e precisa ser definida como NULL se não for implementada.

Retorna 0 em caso de sucesso ou um código de erro menor que 0.

Definição na linha 88 do arquivo keymaster1.h .

keymaster_error_t (* export_key)(const struct keymaster1_device *dev, keymaster_key_format_t export_format, const keymaster_key_blob_t *key_to_export, const keymaster_blob_t *client_id, const keymaster_blob_t *app_data, keymaster_blob_t *export_data)

Exporta uma chave pública, retornando uma matriz de bytes no formato especificado.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] export_format O formato a ser usado para exportar a chave.
[in] key_to_export A chave a ser exportada.
[out] export_data O material da chave exportado. O autor da chamada assume a propriedade.
[out] export_data_length O comprimento de export_data .

Definição na linha 377 do arquivo keymaster1.h .

keymaster_error_t (* finish)(const struct keymaster1_device *dev, keymaster_operation_handle_t operation_handle, const keymaster_key_param_set_t *in_params, const keymaster_blob_t *signature, keymaster_key_param_set_t *out_params, keymaster_blob_t *output)

Finaliza uma operação criptográfica iniciada com begin() e invalida operation_handle .

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] operation_handle O identificador de operação retornado por begin() . Esse identificador será invalidado.
[in] params Parâmetros adicionais para a operação. Para modos AEAD, isso é usado para especificar KM_TAG_ADDITIONAL_DATA, mas apenas se nenhum dado de entrada tiver sido fornecido para update() .
[in] assinatura A assinatura a ser verificada se a finalidade especificada na chamada begin() foi KM_PURPOSE_VERIFY.
[out] output Os dados de saída, se houver. O autor da chamada assume a propriedade do buffer alocado.

Se a operação concluída for uma verificação de assinatura ou uma descriptografia no modo AEAD e a verificação falhar, finish() vai retornar KM_ERROR_VERIFICATION_FAILED.

Definição na linha 521 do arquivo keymaster1.h .

Flags uint32_t

Consulte as flags definidas para keymaster0_devices::flags em keymaster_common.h .

Definição na linha 46 do arquivo keymaster1.h .

keymaster_error_t (* generate_key)(const struct keymaster1_device *dev, const keymaster_key_param_set_t *params, keymaster_key_blob_t *key_blob, keymaster_key_characteristics_t **characteristics)

Gera uma chave ou um par de chaves, retornando um blob de chave e/ou uma descrição da chave.

Os parâmetros de geração de chaves são definidos como pares de chave/valor do keymaster, fornecidos em params . Consulte keymaster_tag_t para conferir a lista completa. Alguns valores que sempre são necessários para a geração de chaves úteis são:

  • KM_TAG_ALGORITHM;
  • KM_TAG_PURPOSE; e
  • (KM_TAG_USER_SECURE_ID e KM_TAG_USER_AUTH_TYPE) ou KM_TAG_NO_AUTH_REQUIRED.

O valor KM_TAG_AUTH_TIMEOUT geralmente precisa ser especificado, a menos que KM_TAG_NO_AUTH_REQUIRED esteja presente. Caso contrário, o usuário terá que fazer a autenticação para cada uso.

KM_TAG_BLOCK_MODE, KM_TAG_PADDING, KM_TAG_MAC_LENGTH e KM_TAG_DIGEST precisam ser especificados para algoritmos que os exigem.

As tags a seguir não podem ser especificadas. Os valores delas serão fornecidos pela implementação.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTANT,
  • KM_TAG_CREATION_DATETIME
Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] params Matriz de parâmetros de geração de chaves.
[in] params_count Comprimento de params .
[out] key_blob retorna a chave gerada. key_blob não pode ser nulo. O autor da chamada assume a propriedade key_blob->key_material e precisa fazer free() nela.
[out] características retorna as características da chave gerada, se não for NULL. Se não for NULL, o autor da chamada assume a propriedade e precisa ser desalocado com keymaster_free_characteristics() . KM_TAG_ROOT_OF_TRUST, KM_TAG_APPLICATION_ID e KM_TAG_APPLICATION_DATA nunca são retornados.

Definição na linha 282 do arquivo keymaster1.h .

int(* generate_keypair)(const struct keymaster1_device *dev, const keymaster_keypair_t key_type, const void *key_params, uint8_t **key_blob, size_t *key_blob_length)
Uso descontinuado:
Gera uma chave pública e privada. O blob de chaves retornado é opaco e precisa ser fornecido para assinatura e verificação.

Retorna: 0 em caso de sucesso ou um código de erro menor que 0.

Definição na linha 56 do arquivo keymaster1.h .

keymaster_error_t (* get_key_characteristics)(const struct keymaster1_device *dev, const keymaster_key_blob_t *key_blob, const keymaster_blob_t *client_id, const keymaster_blob_t *app_data, keymaster_key_characteristics_t **characteristics)

Retorna as características da chave especificada ou KM_ERROR_INVALID_KEY_BLOB se o key_blob for inválido. As implementações precisam validar totalmente a integridade da chave. client_id e app_data precisam ser o ID e os dados fornecidos quando a chave foi gerada ou importada, ou vazios se KM_TAG_APPLICATION_ID e/ou KM_TAG_APPLICATION_DATA não tiverem sido fornecidos durante a geração. Esses valores não são incluídos nas características retornadas. O autor da chamada assume a propriedade do objeto de características alocado, que precisa ser desalocado com keymaster_free_characteristics() .

KM_TAG_ROOT_OF_TRUST, KM_TAG_APPLICATION_ID e KM_TAG_APPLICATION_DATA nunca são retornados.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] key_blob A chave para extrair características.
[in] client_id Os dados do ID do cliente ou NULL se nenhum estiver associado.
[in] app_id Os dados do app ou NULL se nenhum estiver associado.
[out] características As principais características.

Definição na linha 309 do arquivo keymaster1.h .

int(* get_keypair_public)(const struct keymaster1_device *dev, const uint8_t *key_blob, const size_t key_blob_length, uint8_t **x509_data, size_t *x509_data_length)
Uso descontinuado:
Extrai a parte da chave pública de um par de chaves. A chave pública precisa estar em uma matriz de bytes codificada no formato X.509 (padrão Java).

Retorna: 0 em caso de sucesso ou um código de erro menor que 0. Em caso de erro, x509_data não deve ser alocado.

Definição na linha 76 do arquivo keymaster1.h .

keymaster_error_t (* get_supported_algorithms)(const struct keymaster1_device *dev, keymaster_algorithm_t **algorithms, size_t *algorithms_length)

Recebe algoritmos com suporte.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[out] algoritmos Matriz de algoritmos com suporte. O autor da chamada se torna o proprietário da matriz e precisa fazer free() nela.
[out] algorithms_length Comprimento de algorithms .

Definição na linha 133 do arquivo keymaster1.h .

keymaster_error_t (* get_supported_block_modes)(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_purpose_t purpose, keymaster_block_mode_t **modes, size_t *modes_length)

Recebe os modos de bloco compatíveis com o algoritmo especificado.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] algoritmo O algoritmo para os modos com suporte que serão retornados.
[out] modos Matriz de modos com suporte. O autor da chamada se torna o proprietário da matriz e precisa fazer free() nela.
[out] modes_length Comprimento de modes .

Definição na linha 149 do arquivo keymaster1.h .

keymaster_error_t (* get_supported_digests)(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_purpose_t purpose, keymaster_digest_t **digests, size_t *digests_length)

Recebe os resumos compatíveis com o algoritmo especificado. O autor da chamada assume a propriedade da matriz alocada.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] algoritmo O algoritmo para o qual os resumos com suporte serão retornados.
[out] resumos Matriz de resumos aceita. O autor da chamada se torna o proprietário da matriz e precisa fazer free() nela.
[out] digests_length Comprimento de digests .

Definição na linha 187 do arquivo keymaster1.h .

keymaster_error_t (* get_supported_export_formats)(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_key_format_t **formats, size_t *formats_length)

Consegue os formatos de exportação de chaves compatíveis com as chaves do algoritmo especificado. O autor da chamada assume a propriedade da matriz alocada.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] algoritmo O algoritmo para os formatos compatíveis que serão retornados.
[out] populares Matriz de formatos aceitos. O autor da chamada se torna o proprietário da matriz e precisa fazer free() nela.
[out] formats_length Comprimento de formats .

Definição na linha 224 do arquivo keymaster1.h .

keymaster_error_t (* get_supported_import_formats)(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_key_format_t **formats, size_t *formats_length)

Recebe os formatos de importação de chaves compatíveis com as chaves do algoritmo especificado. O autor da chamada assume a propriedade da matriz alocada.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] algoritmo O algoritmo para os formatos compatíveis que serão retornados.
[out] populares Matriz de formatos aceitos. O autor da chamada se torna o proprietário da matriz e precisa fazer free() nela.
[out] formats_length Comprimento de formats .

Definição na linha 206 do arquivo keymaster1.h .

keymaster_error_t (* get_supported_padding_modes)(const struct keymaster1_device *dev, keymaster_algorithm_t algorithm, keymaster_purpose_t purpose, keymaster_padding_t **modes, size_t *modes_length)

Recebe os modos de preenchimento aceitos para o algoritmo especificado. O autor da chamada assume a propriedade da matriz alocada.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] algoritmo O algoritmo para o qual os modos de preenchimento compatíveis serão retornados.
[out] modos Matriz de modos de preenchimento aceitos. O autor da chamada se torna o proprietário da matriz e precisa fazer free() nela.
[out] modes_length Comprimento de modes .

Definição na linha 168 do arquivo keymaster1.h .

keymaster_error_t (* import_key)(const struct keymaster1_device *dev, const keymaster_key_param_set_t *params, keymaster_key_format_t key_format, const keymaster_blob_t *key_data, keymaster_key_blob_t *key_blob, keymaster_key_characteristics_t **characteristics)

Importa uma chave ou um par de chaves, retornando um blob de chave e/ou uma descrição da chave.

A maioria dos parâmetros de importação principais são definidos como pares de chave/valor do keymaster, fornecidos em "params". Consulte keymaster_tag_t para conferir a lista completa. Os valores sempre necessários para a importação de chaves úteis são:

  • KM_TAG_ALGORITHM;
  • KM_TAG_PURPOSE; e
  • (KM_TAG_USER_SECURE_ID e KM_TAG_USER_AUTH_TYPE) ou KM_TAG_NO_AUTH_REQUIRED.

Geralmente, é necessário especificar KM_TAG_AUTH_TIMEOUT. Se não for especificado, o usuário vai precisar fazer a autenticação para cada uso.

As tags a seguir vão receber valores padrão se não forem especificadas:

  • O valor padrão de KM_TAG_KEY_SIZE será o tamanho da chave fornecida.
  • KM_TAG_RSA_PUBLIC_EXPONENT vai usar o valor na chave fornecida (para chaves RSA) como padrão.

As tags a seguir não podem ser especificadas. Os valores delas serão fornecidos pela implementação.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTANT,
  • KM_TAG_CREATION_DATETIME
Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] params Parâmetros que definem a chave importada.
[in] params_count O número de entradas em params .
[in] key_format Especifica o formato dos dados da chave em key_data.
[out] key_blob Usado para retornar o blob de chave opaco. Precisa ser diferente de NULL. O autor da chamada assume a propriedade do key_material contido.
[out] características Usado para retornar as características da chave importada. Pode ser NULL. Nesse caso, nenhuma característica será retornada. Se não for NULL, o autor da chamada assume a propriedade e precisa ser desalocado com keymaster_free_characteristics() . KM_TAG_ROOT_OF_TRUST, KM_TAG_APPLICATION_ID e KM_TAG_APPLICATION_DATA nunca são retornados.

Definição na linha 357 do arquivo keymaster1.h .

int(* import_keypair)(const struct keymaster1_device *dev, const uint8_t *key, const size_t key_length, uint8_t **key_blob, size_t *key_blob_length)
Uso descontinuado:
Importa um par de chaves pública e privada. As chaves importadas estarão no formato PKCS#8 com codificação DER (padrão Java). O blob de chaves retornado é opaco e será fornecido posteriormente para assinatura e verificação.

Retorna: 0 em caso de sucesso ou um código de erro menor que 0.

Definição na linha 66 do arquivo keymaster1.h .

int(* sign_data)(const struct keymaster1_device *dev, const void *signing_params, const uint8_t *key_blob, const size_t key_blob_length, const uint8_t *data, const size_t data_length, uint8_t **signed_data, size_t *signed_data_length)
Uso descontinuado:
Assina dados usando um blob de chave gerado anteriormente. Isso pode usar uma chave assimétrica ou uma chave secreta.

Retorna: 0 em caso de sucesso ou um código de erro menor que 0.

Definição na linha 108 do arquivo keymaster1.h .

keymaster_error_t (* update)(const struct keymaster1_device *dev, keymaster_operation_handle_t operation_handle, const keymaster_key_param_set_t *in_params, const keymaster_blob_t *input, size_t *input_consumed, keymaster_key_param_set_t *out_params, keymaster_blob_t *output)

Fornece dados para uma operação criptográfica em andamento iniciada com begin() e possivelmente recebe a saída dela.

Se operation_handle for inválido, update() vai retornar KM_ERROR_INVALID_OPERATION_HANDLE.

update() pode não consumir todos os dados fornecidos no buffer de dados. update() vai retornar a quantidade consumida em *data_consumed. O autor da chamada precisa fornecer os dados não consumidos em uma chamada subsequente.

Parâmetros
[in] dev A estrutura do dispositivo do keymaster.
[in] operation_handle O identificador de operação retornado por begin() .
[in] in_params Parâmetros adicionais para a operação. Para modos AEAD, isso é usado para especificar KM_TAG_ADDITIONAL_DATA. Dados adicionais podem ser fornecidos em várias chamadas para update() , mas somente até que os dados de entrada sejam fornecidos.
[in] input Dados a serem processados, de acordo com os parâmetros estabelecidos na chamada para begin() . Observe que update() pode ou não consumir todos os dados fornecidos. Consulte input_consumed .
[out] input_consumed Quantidade de dados consumidos por update() . Se o valor for menor que o valor fornecido, o autor da chamada precisará fornecer o restante em uma chamada subsequente para update() .
[out] out_params Parâmetros de saída. Usado para retornar dados adicionais da operação. O autor da chamada assume a propriedade da matriz de parâmetros de saída e precisa liberá-la com keymaster_free_param_set() . out_params pode ser definido como NULL se nenhum parâmetro de saída for esperado. Se out_params for NULL e os parâmetros de saída forem gerados, begin() vai retornar KM_ERROR_OUTPUT_PARAMETER_NULL.
[out] output Os dados de saída, se houver. O autor da chamada assume a propriedade do buffer alocado. A saída não pode ser NULO.

update() pode não fornecer nenhuma saída. Nesse caso, output->data_length será zero, e output->data pode ser NULL ou ter comprimento zero. Portanto, o autor da chamada sempre precisa fazer free().

Definição na linha 495 do arquivo keymaster1.h .

int(* verify_data)(const struct keymaster1_device *dev, const void *signing_params, const uint8_t *key_blob, const size_t key_blob_length, const uint8_t *signed_data, const size_t signed_data_length, const uint8_t *signature, const size_t signature_length)
Uso descontinuado:
Verifica os dados assinados com um blob de chave. Isso pode usar uma chave assimétrica ou uma chave secreta.

Retorna: 0 em caso de verificação bem-sucedida ou um código de erro menor que 0.

Definição na linha 118 do arquivo keymaster1.h .

A documentação desse struct foi gerada com base no seguinte arquivo: