Riferimento alla struttura keymaster1_device

Campi dati
Riferimento alla struttura keymaster1_device

#include < keymaster1.h >

Campi dati

struct hw_device_t   comuni
 
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)
 

Descrizione dettagliata

Definizione del dispositivo Keymaster1

Definizione nella riga 28 del file keymaster1.h .

Documentazione dei campi

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

Interrompe un'operazione di crittografia iniziata con begin() , liberando tutte le risorse interne e invalidando operation_handle .

Definizione nella riga 531 del file keymaster1.h .

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

Aggiunge entropia al generatore di numeri casuali utilizzato da Keymaster. L'entropia aggiunta tramite questo metodo non è garantita come unica fonte di entropia utilizzata e la funzione di miscelazione deve essere sicura, nel senso che se l'RNG viene inizializzato (da qualsiasi fonte) con dati che l'attaccante non può prevedere (o controllare), l'output dell'RNG è indistinguibile da quello casuale. Pertanto, se l'entropia di qualsiasi sorgente è buona, l'output sarà buono.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] di dati Dati casuali da includere.
[in] data_length Lunghezza di data .

Definizione nella riga 242 del file 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)

Avvia un'operazione di crittografia utilizzando la chiave specificata. Se tutto va bene, begin() restituirà KM_ERROR_OK e creerà un handle dell'operazione che deve essere passato alle chiamate successive a update() , finish() oppure abort() .

È fondamentale che ogni chiamata a begin() sia accoppiata a una chiamata successiva a finish() o abort() , per consentire all'implementazione di Keymaster di ripulire qualsiasi stato di operazione interno. Se non lo fai, potresti perdere spazio di stato interno o altre risorse interne e alla fine potresti causare begin() a restituire KM_ERROR_TOO_MANY_OPERATIONS quando non è più disponibile spazio per le operazioni. Qualsiasi risultato diverso da KM_ERROR_OK di begin() , update() o finish() comporta l'interruzione implicita dell'operazione, nel qual caso abort() non deve essere chiamato (e restituirà KM_ERROR_INVALID_OPERATION_HANDLE se chiamato).

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] scopo Lo scopo dell'operazione, uno dei valori KM_PURPOSE_ENCRYPT, KM_PURPOSE_DECRYPT, KM_PURPOSE_SIGN o KM_PURPOSE_VERIFY. Tieni presente che per le modalità AEAD, la crittografia e la decrittografia implicano rispettivamente la firma e la verifica, ma devono essere specificate come KM_PURPOSE_ENCRYPT e KM_PURPOSE_DECRYPT.
[in] chiave La chiave da utilizzare per l'operazione. key deve avere uno scopo compatibile con purpose e tutti i relativi requisiti di utilizzo devono essere soddisfatti, altrimenti begin() restituirà un codice di errore appropriato.
[in] in_params Parametri aggiuntivi per l'operazione. Questo viene in genere utilizzato per fornire i dati di autenticazione, con KM_TAG_AUTH_TOKEN. Se durante la generazione sono stati forniti KM_TAG_APPLICATION_ID o KM_TAG_APPLICATION_DATA, devono essere forniti qui, altrimenti l'operazione non andrà a buon fine con KM_ERROR_INVALID_KEY_BLOB. Per le operazioni che richiedono un nonce o un IV, nelle chiavi generate con KM_TAG_CALLER_NONCE, in_params può contenere un tag KM_TAG_NONCE. Per le operazioni AEAD, qui viene specificato KM_TAG_CHUNK_SIZE.
[out] out_params Parametri di output. Utilizzato per restituire dati aggiuntivi dall'inizializzazione dell'operazione, in particolare per restituire l'IV o il nonce dalle operazioni che generano un IV o un nonce. L'utente che chiama acquisisce la proprietà dell'array di parametri di output e deve liberarlo con keymaster_free_param_set() . out_params può essere impostato su NULL se non sono previsti parametri di output. Se out_params è NULL e vengono generati i parametri di output, begin() restituirà KM_ERROR_OUTPUT_PARAMETER_NULL.
[out] operation_handle L'handle dell'operazione appena creato che deve essere passato a update() , finish() o abort() . Se operation_handle è NULL, begin() restituirà KM_ERROR_OUTPUT_PARAMETER_NULL.

Definizione nella riga 451 del file keymaster1.h .

uint32_t client_version

QUESTA FUNZIONE È OBSOLETA. Utilizza i nuovi campi "module_api_version" e "hal_api_version" nell'inizializzazione di keymaster_module.

Definizione nella riga 41 del file keymaster1.h .

struct hw_device_t common

Metodi comuni del dispositivo Keymaster. Questo deve essere il primo membro di keymaster_device, poiché gli utenti di questa struttura eseguiranno il casting di un hw_device_t al puntatore keymaster_device in contesti in cui è noto che hw_device_t fa riferimento a un keymaster_device.

Definizione nella riga 35 del file keymaster1.h .

contesto void*

Definizione nella riga 48 del file keymaster1.h .

int(* delete_all)(const struct keymaster1_device *dev)
Ritirato:
Consente di eliminare tutte le chiavi nel keystore hardware. Utilizzato quando il keystore viene reimpostato completamente.

Questa funzione è facoltativa e deve essere impostata su NULL se non è implementata.

Restituisce 0 in caso di esito positivo o un codice di errore minore di 0.

Definizione nella riga 100 del file keymaster1.h .

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

Consente di eliminare tutte le chiavi nel keystore hardware. Utilizzato quando il keystore viene reimpostato completamente. Dopo aver chiamato questa funzione, sarà impossibile utilizzare i blob delle chiavi generati o importati in precedenza per qualsiasi operazione.

Questa funzione è facoltativa e deve essere impostata su NULL se non è implementata.

Parametri
[in] dev La struttura del dispositivo Keymaster.

Definizione nella riga 407 del file keymaster1.h .

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

Consente di eliminare la chiave o la coppia di chiavi associata al blob della chiave. Dopo aver chiamato questa funzione, non sarà possibile utilizzare la chiave per altre operazioni. Può essere applicato alle chiavi di radici di attendibilità esterne (chiavi non utilizzabili nell'attuale radice di attendibilità).

Questa funzione è facoltativa e deve essere impostata su NULL se non è implementata.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] chiave La chiave da eliminare.

Definizione nella riga 395 del file keymaster1.h .

int(* delete_keypair)(const struct keymaster1_device *dev, const uint8_t *key_blob, const size_t key_blob_length)
Ritirato:
Elimina la coppia di chiavi associata al blob della chiave.

Questa funzione è facoltativa e deve essere impostata su NULL se non è implementata.

Restituisce 0 in caso di esito positivo o un codice di errore minore di 0.

Definizione nella riga 88 del file 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)

Esporta una chiave pubblica, restituendo un array di byte nel formato specificato.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] export_format Il formato da utilizzare per l'esportazione della chiave.
[in] key_to_export La chiave da esportare.
[out] export_data Il materiale della chiave esportato. Il chiamante assume la proprietà.
[out] export_data_length La lunghezza di export_data .

Definizione nella riga 377 del file 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)

Finalizza un'operazione di crittografia iniziata con begin() e invalida operation_handle .

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] operation_handle L'handle dell'operazione restituito da begin() . Questo handle verrà invalidato.
[in] params Parametri aggiuntivi per l'operazione. Per le modalità AEAD, viene utilizzato per specificare KM_TAG_ADDITIONAL_DATA, ma solo se non sono stati forniti dati di input a update() .
[in] firma La firma da verificare se lo scopo specificato nella chiamata begin() era KM_PURPOSE_VERIFY.
[out] output Gli eventuali dati di output. Il chiamante assume la proprietà del buffer allocato.

Se l'operazione in fase di completamento è una verifica della firma o una decrittografia in modalità AEAD e la verifica non va a buon fine, finish() restituirà KM_ERROR_VERIFICATION_FAILED.

Definizione nella riga 521 del file keymaster1.h .

uint32_t flags

Consulta i flag definiti per keymaster0_devices::flags in keymaster_common.h

Definizione nella riga 46 del file 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)

Genera una chiave o una coppia di chiavi, restituendo un blob della chiave e/o una descrizione della chiave.

I parametri di generazione delle chiavi sono definiti come coppie di tag/valore keymaster, forniti in params . Consulta keymaster_tag_t per l'elenco completo. Alcuni valori sempre richiesti per la generazione di chiavi utili sono:

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

In genere, è necessario specificare KM_TAG_AUTH_TIMEOUT, a meno che non sia presente KM_TAG_NO_AUTH_REQUIRED, altrimenti l'utente dovrà autenticarsi per ogni utilizzo.

KM_TAG_BLOCK_MODE, KM_TAG_PADDING, KM_TAG_MAC_LENGTH e KM_TAG_DIGEST devono essere specificati per gli algoritmi che li richiedono.

I seguenti tag non possono essere specificati; i relativi valori verranno forniti dall'implementazione.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTANT,
  • KM_TAG_CREATION_DATETIME
Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] params Array di parametri di generazione delle chiavi.
[in] params_count Lunghezza di params .
[out] key_blob restituisce la chiave generata. key_blob non deve essere NULL. L'utente che chiama assume la proprietà di key_blob->key_material e deve eseguire free() su questa.
[out] caratteristiche restituisce le caratteristiche della chiave generata, se non è NULL. Se non è NULL, il chiamante ne assume la proprietà e deve eseguire lo scollegamento con keymaster_free_characteristics() . Tieni presente che KM_TAG_ROOT_OF_TRUST, KM_TAG_APPLICATION_ID e KM_TAG_APPLICATION_DATA non vengono mai restituiti.

Definizione nella riga 282 del file 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)
Ritirato:
Genera una chiave pubblica e una privata. Il key-blob restituito è opaco e deve essere successivamente fornito per la firma e la verifica.

Restituisce: 0 in caso di esito positivo o un codice di errore inferiore a 0.

Definizione nella riga 56 del file 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)

Restituisce le caratteristiche della chiave specificata o KM_ERROR_INVALID_KEY_BLOB se key_blob non è valido (le implementazioni devono convalidare completamente l'integrità della chiave). client_id e app_data devono essere l'ID e i dati forniti durante la generazione o l'importazione della chiave oppure essere vuoti se KM_TAG_APPLICATION_ID e/o KM_TAG_APPLICATION_DATA non sono stati forniti durante la generazione. Questi valori non sono inclusi nelle caratteristiche restituite. L'utente che chiama assume la proprietà dell'oggetto delle caratteristiche allocato, che deve essere deallocato con keymaster_free_characteristics() .

Tieni presente che KM_TAG_ROOT_OF_TRUST, KM_TAG_APPLICATION_ID e KM_TAG_APPLICATION_DATA non vengono mai restituiti.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] key_blob La chiave da cui recuperare le caratteristiche.
[in] client_id I dati dell'ID cliente o NULL se non è associato alcun ID cliente.
[in] app_id I dati dell'app o NULL se non è associato nessuno.
[out] caratteristiche Le caratteristiche principali.

Definizione nella riga 309 del file 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)
Ritirato:
Recupera la parte della chiave pubblica di una coppia di chiavi. La chiave pubblica deve essere un array di byte codificato in formato X.509 (standard Java).

Restituisce: 0 in caso di esito positivo o un codice di errore inferiore a 0. In caso di errore, x509_data non deve essere allocata.

Definizione nella riga 76 del file keymaster1.h .

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

Recupera gli algoritmi supportati.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[out] algoritmi Array di algoritmi supportati. L'autore della chiamata acquisisce la proprietà dell'array e deve chiamare free().
[out] algorithms_length Lunghezza di algorithms .

Definizione nella riga 133 del file 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)

Recupera le modalità di blocco supportate per l'algoritmo specificato.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] algoritmo L'algoritmo per cui verranno restituite le modalità supportate.
[out] modalità Array di modalità supportate. L'autore della chiamata acquisisce la proprietà dell'array e deve chiamare free().
[out] modes_length Lunghezza di modes .

Definizione nella riga 149 del file 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)

Recupera i digest supportati per l'algoritmo specificato. L'utente che chiama assume la proprietà dell'array allocato.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] algoritmo L'algoritmo per cui verranno restituiti i digest supportati.
[out] digest Array di digest supportati. L'autore della chiamata acquisisce la proprietà dell'array e deve chiamare free().
[out] digests_length Lunghezza di digests .

Definizione nella riga 187 del file 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)

Recupera i formati di esportazione delle chiavi supportati per le chiavi dell'algoritmo specificato. L'utente che chiama assume la proprietà dell'array allocato.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] algoritmo L'algoritmo per cui verranno restituiti i formati supportati.
[out] formati Array di formati supportati. L'autore della chiamata acquisisce la proprietà dell'array e deve chiamare free().
[out] formats_length Lunghezza di formats .

Definizione alla riga 224 del file 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)

Recupera i formati di importazione delle chiavi supportati per le chiavi dell'algoritmo specificato. L'utente che chiama assume la proprietà dell'array allocato.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] algoritmo L'algoritmo per cui verranno restituiti i formati supportati.
[out] formati Array di formati supportati. L'autore della chiamata acquisisce la proprietà dell'array e deve chiamare free().
[out] formats_length Lunghezza di formats .

Definizione nella riga 206 del file 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)

Recupera le modalità di riempimento supportate per l'algoritmo specificato. L'utente che chiama assume la proprietà dell'array allocato.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] algoritmo L'algoritmo per cui verranno restituite le modalità di riempimento supportate.
[out] modalità Array di modalità di spaziatura interna supportate. L'autore della chiamata acquisisce la proprietà dell'array e deve chiamare free().
[out] modes_length Lunghezza di modes .

Definizione nella riga 168 del file 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 una chiave o una coppia di chiavi, restituendo un blob della chiave e/o una descrizione della chiave.

La maggior parte dei parametri di importazione delle chiavi è definita come coppie di tag/valori keymaster, forniti in "params". Consulta keymaster_tag_t per l'elenco completo. I valori sempre richiesti per l'importazione di chiavi utili sono:

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

In genere, è necessario specificare KM_TAG_AUTH_TIMEOUT. Se non specificato, l'utente dovrà autenticarsi per ogni utilizzo.

Se non specificati, i seguenti tag assumeranno i valori predefiniti:

  • Per impostazione predefinita, KM_TAG_KEY_SIZE corrisponde alle dimensioni della chiave fornita.
  • Per impostazione predefinita, KM_TAG_RSA_PUBLIC_EXPONENT assume il valore della chiave fornita (per le chiavi RSA)

I seguenti tag non possono essere specificati; i relativi valori verranno forniti dall'implementazione.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTANT,
  • KM_TAG_CREATION_DATETIME
Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] params Parametri che definiscono la chiave importata.
[in] params_count Il numero di voci in params .
[in] key_format specifica il formato dei dati della chiave in key_data.
[out] key_blob Utilizzato per restituire il blob della chiave opaca. Non deve essere NULL. L'utente che chiama assume la proprietà del materiale della chiave contenuto.
[out] caratteristiche Utilizzato per restituire le caratteristiche della chiave importata. Può essere NULL, nel qual caso non verranno restituite caratteristiche. Se non è NULL, il chiamante ne assume la proprietà e deve eseguire la deallocazione con keymaster_free_characteristics() . Tieni presente che KM_TAG_ROOT_OF_TRUST, KM_TAG_APPLICATION_ID e KM_TAG_APPLICATION_DATA non vengono mai restituiti.

Definizione nella riga 357 del file 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)
Ritirato:
Importa una coppia di chiavi pubblica e privata. Le chiavi importate saranno in formato PKCS#8 con codifica DER (standard Java). Il key-blob restituito è opaco e verrà successivamente fornito per la firma e la verifica.

Restituisce: 0 in caso di esito positivo o un codice di errore inferiore a 0.

Definizione nella riga 66 del file 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)
Ritirato:
Firma i dati utilizzando un key-blob generato in precedenza. È possibile utilizzare una chiave asimmetrica o una chiave segreta.

Restituisce: 0 in caso di esito positivo o un codice di errore inferiore a 0.

Definizione nella riga 108 del file 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)

Fornisce dati a un'operazione di crittografia in corso iniziata con begin() e possibilmente ne riceve l'output.

Se operation_handle non è valido, update() restituirà KM_ERROR_INVALID_OPERATION_HANDLE.

update() potrebbe non utilizzare tutti i dati forniti nel buffer di dati. update() restituirà la quantità consumata in *data_consumed. L'utente che effettua la chiamata deve fornire i dati non utilizzati in una chiamata successiva.

Parametri
[in] dev La struttura del dispositivo Keymaster.
[in] operation_handle L'handle dell'operazione restituito da begin() .
[in] in_params Parametri aggiuntivi per l'operazione. Per le modalità AEAD, viene utilizzato per specificare KM_TAG_ADDITIONAL_DATA. Tieni presente che è possibile fornire dati aggiuntivi in più chiamate a update() , ma solo fino a quando non sono stati forniti i dati di input.
[in] ingresso Dati da elaborare, in base ai parametri stabiliti nella chiamata a begin() . Tieni presente che update() potrebbe o meno utilizzare tutti i dati forniti. Consulta input_consumed .
[out] input_consumed Quantità di dati consumati da update() . Se è inferiore all'importo fornito, l'utente che chiama deve fornire il resto in una chiamata successiva a update() .
[out] out_params Parametri di output. Viene utilizzato per restituire dati aggiuntivi dall'operazione. L'autore della chiamata acquisisce la proprietà dell'array di parametri di output e deve liberarlo con keymaster_free_param_set() . out_params può essere impostato su NULL se non sono previsti parametri di output. Se out_params è NULL e vengono generati i parametri di output, begin() restituirà KM_ERROR_OUTPUT_PARAMETER_NULL.
[out] output Gli eventuali dati di output. L'autore della chiamata assume la proprietà del buffer allocato. L'output non deve essere NULL.

Tieni presente che update() potrebbe non fornire alcun output, nel qual caso output->data_length sarà pari a zero e output->data potrebbe essere NULL o avere una lunghezza pari a zero (quindi l'utente che chiama deve sempre eseguire free() su di esso).

Definizione nella riga 495 del file 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)
Ritirato:
Verifica i dati firmati con un key-blob. È possibile utilizzare una chiave asimmetrica o una chiave segreta.

Restituisce 0 in caso di verifica riuscita o un codice di errore inferiore a 0.

Definizione nella riga 118 del file keymaster1.h .

La documentazione di questa struttura è stata generata dal seguente file: