keymaster1_device Riferimento alla struttura

keymaster1_device Riferimento alla struttura

#include < keymaster1.h >

Campi dati

struttura hw_device_t Comune
uint32_t versione_client
uint32_t bandiere
vuoto * contesto
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(* verificare_dati )(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 **algoritmi, size_t *algorithms_length)
keymaster_error_t (* get_supported_block_modes )(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , scopo keymaster_purpose_t , keymaster_block_mode_t **modes, size_t *modes_length)
keymaster_error_t (* get_supported_padding_modes )(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , scopo keymaster_purpose_t , keymaster_padding_t **modes, size_t *modes_length)
keymaster_error_t (* get_supported_digests )(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , scopo keymaster_purpose_t , keymaster_digest_t **digest, size_t *digests_length)
keymaster_error_t (* get_supported_import_formats )(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , keymaster_key_format_t **formats, size_t *formats_length)
keymaster_error_t (* get_supported_export_formats )(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , 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 **caratteristiche)
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 **caratteristiche)
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 scopo, 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 (* fine )(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 alla riga 28 del file keymaster1.h .

Documentazione sul campo

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

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

Definizione alla 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 all'RNG utilizzato da keymaster. L'entropia aggiunta attraverso questo metodo è garantita per non essere l'unica fonte di entropia utilizzata, e la funzione di miscelazione deve essere sicura, nel senso che se l'RNG viene seminato (da qualsiasi fonte) con qualsiasi dato l'attaccante non può prevedere (o controllo), quindi l'uscita RNG è indistinguibile da casuale. Pertanto, se l'entropia da qualsiasi fonte è buona, l'output sarà buono.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] dati Dati casuali da mischiare.
[in] lunghezza_dati Lunghezza dei data .

Definizione alla riga 242 del file keymaster1.h .

keymaster_error_t (* begin)(const struct keymaster1_device *dev, keymaster_purpose_t scopo, 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 di operazione che deve essere passato alle successive chiamate a update() , finish() o abort() .

È fondamentale che ogni chiamata a begin() sia accoppiata con una successiva chiamata a finish() o abort() , per consentire all'implementazione del keymaster di ripulire qualsiasi stato operativo interno. In caso contrario, potrebbe perdere lo spazio di stato interno o altre risorse interne e alla fine potrebbe causare la restituzione di KM_ERROR_TOO_MANY_OPERATIONS da parte di Begin() quando si esaurisce lo spazio per le operazioni. Qualsiasi risultato diverso da KM_ERROR_OK da begin() , update() o finish() interrompe implicitamente l'operazione, nel qual caso non è necessario chiamare abort() (e restituirà KM_ERROR_INVALID_OPERATION_HANDLE se chiamato).

Parametri
[in] div La struttura del dispositivo keymaster.
[in] scopo Lo scopo dell'operazione, uno tra KM_PURPOSE_ENCRYPT, KM_PURPOSE_DECRYPT, KM_PURPOSE_SIGN o KM_PURPOSE_VERIFY. Si noti 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 suoi requisiti di utilizzo devono essere soddisfatti, altrimenti begin() restituirà un codice di errore appropriato.
[in] in_params Ulteriori parametri per l'operazione. Viene in genere utilizzato per fornire 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 avrà esito negativo con KM_ERROR_INVALID_KEY_BLOB. Per le operazioni che richiedono un nonce o un IV, sulle chiavi che sono state generate con KM_TAG_CALLER_NONCE, in_params può contenere un tag KM_TAG_NONCE. Per le operazioni AEAD KM_TAG_CHUNK_SIZE è specificato qui.
[fuori] out_params Parametri di uscita. Utilizzato per restituire dati aggiuntivi dall'inizializzazione dell'operazione, in particolare per restituire IV o nonce da operazioni che generano un IV o nonce. Il chiamante assume la proprietà dell'array dei 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 parametri di output, begin() restituirà KM_ERROR_OUTPUT_PARAMETER_NULL.
[fuori] operazione_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 alla riga 451 del file keymaster1.h .

uint32_t versione_client

QUESTO E' DEPRECATO. Utilizzare invece i nuovi campi "module_api_version" e "hal_api_version" nell'inizializzazione keymaster_module.

Definizione alla riga 41 del file keymaster1.h .

struct hw_device_t comune

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

Definizione alla riga 35 del file keymaster1.h .

contesto vuoto*

Definizione alla riga 48 del file keymaster1.h .

int(* delete_all)(const struct keymaster1_device *dev)
Deprecato:
Elimina tutte le chiavi nell'archivio chiavi hardware. Utilizzato quando il keystore viene reimpostato completamente.

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

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

Definizione alla riga 100 del file keymaster1.h .

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

Elimina tutte le chiavi nell'archivio chiavi hardware. Utilizzato quando il keystore viene reimpostato completamente. Dopo aver chiamato questa funzione sarà impossibile utilizzare i BLOB di chiavi precedentemente generati o importati per qualsiasi operazione.

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

Parametri
[in] div La struttura del dispositivo keymaster.

Definizione alla riga 407 del file keymaster1.h .

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

Elimina la chiave, o la coppia di chiavi, associata al BLOB di chiavi. Dopo aver chiamato questa funzione sarà impossibile utilizzare il tasto per altre operazioni. Può essere applicato a chiavi da radici di fiducia esterne (chiavi non utilizzabili con la radice di fiducia corrente).

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

Parametri
[in] div La struttura del dispositivo keymaster.
[in] chiave La chiave da cancellare.

Definizione alla 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)
Deprecato:
Elimina la coppia di chiavi associata al BLOB di chiavi.

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

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

Definizione alla 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 una matrice di byte nel formato specificato.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] formato_esportazione Il formato da utilizzare per esportare la chiave.
[in] chiave_da_esportare La chiave per esportare.
[fuori] export_data Il materiale chiave esportato. Il chiamante assume la proprietà.
[fuori] export_data_length La lunghezza di export_data .

Definizione alla 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 crittografica iniziata con begin() e invalida operation_handle .

Parametri
[in] div La struttura del dispositivo keymaster.
[in] operazione_handle L'handle dell'operazione restituito da begin() . Questo handle verrà invalidato.
[in] parametri Ulteriori parametri 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 per update() .
[in] firma La firma da verificare se lo scopo specificato nella chiamata begin() era KM_PURPOSE_VERIFY.
[fuori] produzione I dati di output, se presenti. Il chiamante assume la proprietà del buffer allocato.

Se l'operazione in corso è una verifica della firma o una decrittografia in modalità AEAD e la verifica non riesce, finish() restituirà KM_ERROR_VERIFICATION_FAILED.

Definizione alla riga 521 del file keymaster1.h .

flag uint32_t

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

Definizione alla 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 **caratteristiche)

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

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

  • KM_TAG_ALGORITMO;
  • KM_TAG_SCOPO; e
  • (KM_TAG_USER_SECURE_ID e KM_TAG_USER_AUTH_TYPE) o KM_TAG_NO_AUTH_REQUIRED.

KM_TAG_AUTH_TIMEOUT dovrebbe generalmente essere specificato a meno che KM_TAG_NO_AUTH_REQUIRED non sia presente, 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 potrebbero non essere specificati; i loro valori saranno forniti dall'implementazione.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTANT,
  • KM_TAG_CREATION_DATETIME
Parametri
[in] div La struttura del dispositivo keymaster.
[in] parametri Matrice di parametri di generazione delle chiavi.
[in] conteggio_parametri Lunghezza dei params .
[fuori] key_blob restituisce la chiave generata. key_blob non deve essere NULL. Il chiamante assume la proprietà key_blob->key_material e deve liberarlo.
[fuori] caratteristiche restituisce le caratteristiche della chiave che è stata generata, se non NULL. Se non NULL, il chiamante assume la proprietà e deve deallocare 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 alla 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)
Deprecato:
Genera una chiave pubblica e privata. Il key-blob restituito è opaco e deve essere successivamente fornito per la firma e la verifica.

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

Definizione alla 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 al momento della generazione o dell'importazione della chiave oppure vuoti se KM_TAG_APPLICATION_ID e/o KM_TAG_APPLICATION_DATA non sono stati forniti durante la generazione. Tali valori non sono inclusi nelle caratteristiche restituite. Il chiamante 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] div La struttura del dispositivo keymaster.
[in] key_blob La chiave da cui recuperare le caratteristiche.
[in] Identificativo cliente I dati dell'ID client o NULL se nessuno è associato.
[in] app_id I dati dell'app o NULL se nessuno è associato.
[fuori] caratteristiche Le caratteristiche chiave.

Definizione alla 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)
Deprecato:
Ottiene la parte della chiave pubblica di una coppia di chiavi. La chiave pubblica deve essere nella matrice di byte codificata in formato X.509 (standard Java).

Restituisce: 0 in caso di successo o un codice di errore inferiore a 0. In caso di errore, x509_data non dovrebbe essere allocato.

Definizione alla riga 76 del file keymaster1.h .

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

Ottiene gli algoritmi supportati.

Parametri
[in] div La struttura del dispositivo keymaster.
[fuori] algoritmi Matrice di algoritmi supportati. Il chiamante assume la proprietà dell'array e lo deve free().
[fuori] algoritmi_lunghezza Lunghezza degli algorithms .

Definizione alla riga 133 del file keymaster1.h .

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

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

Parametri
[in] div La struttura del dispositivo keymaster.
[in] algoritmo L'algoritmo per il quale verranno restituite le modalità supportate.
[fuori] modalità Matrice di modalità supportate. Il chiamante assume la proprietà dell'array e lo deve free().
[fuori] modi_lunghezza Lunghezza delle modes .

Definizione alla riga 149 del file keymaster1.h .

keymaster_error_t (* get_supported_digests)(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , scopo keymaster_purpose_t , keymaster_digest_t **digest, size_t *digests_length)

Ottiene i digest supportati per l'algoritmo specificato. Il chiamante assume la proprietà dell'array allocato.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] algoritmo L'algoritmo per il quale verranno restituiti i digest supportati.
[fuori] digerisce Array di digest supportati. Il chiamante assume la proprietà dell'array e lo deve free().
[fuori] digest_lunghezza Lunghezza di digests .

Definizione alla riga 187 del file keymaster1.h .

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

Ottiene i formati di esportazione delle chiavi supportati per le chiavi dell'algoritmo specificato. Il chiamante assume la proprietà dell'array allocato.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] algoritmo L'algoritmo per il quale verranno restituiti i formati supportati.
[fuori] formati Matrice di formati supportati. Il chiamante assume la proprietà dell'array e lo deve free().
[fuori] formati_lunghezza Lunghezza dei formats .

Definizione alla riga 224 del file keymaster1.h .

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

Ottiene i formati di importazione delle chiavi supportati per le chiavi dell'algoritmo specificato. Il chiamante assume la proprietà dell'array allocato.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] algoritmo L'algoritmo per il quale verranno restituiti i formati supportati.
[fuori] formati Matrice di formati supportati. Il chiamante assume la proprietà dell'array e lo deve free().
[fuori] formati_lunghezza Lunghezza dei formats .

Definizione alla riga 206 del file keymaster1.h .

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

Ottiene le modalità di riempimento supportate per l'algoritmo specificato. Il chiamante assume la proprietà dell'array allocato.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] algoritmo L'algoritmo per il quale verranno restituite le modalità di riempimento supportate.
[fuori] modalità Supporta una serie di modalità di riempimento. Il chiamante assume la proprietà dell'array e lo deve free().
[fuori] modi_lunghezza Lunghezza delle modes .

Definizione alla 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 **caratteristiche)

Importa una chiave o una coppia di chiavi, restituendo un BLOB di chiavi e/o una descrizione della chiave.

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

  • KM_TAG_ALGORITMO;
  • KM_TAG_SCOPO; 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.

I seguenti tag assumeranno valori predefiniti se non specificati:

  • KM_TAG_KEY_SIZE utilizzerà per impostazione predefinita la dimensione della chiave fornita.
  • KM_TAG_RSA_PUBLIC_EXPONENT verrà impostato automaticamente sul valore nella chiave fornita (per chiavi RSA)

I seguenti tag potrebbero non essere specificati; i loro valori saranno forniti dall'implementazione.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTANT,
  • KM_TAG_CREATION_DATETIME
Parametri
[in] div La struttura del dispositivo keymaster.
[in] parametri Parametri che definiscono la chiave importata.
[in] conteggio_parametri Il numero di voci in params .
[in] formato_chiave specifica il formato dei dati chiave in key_data.
[fuori] key_blob Utilizzato per restituire il blob chiave opaco. Deve essere non NULL. Il chiamante assume la proprietà del key_material contenuto.
[fuori] caratteristiche Utilizzato per restituire le caratteristiche della chiave importata. Può essere NULL, nel qual caso non verranno restituite le caratteristiche. Se non NULL, il chiamante assume la proprietà e deve deallocare 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 alla 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)
Deprecato:
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 successo o un codice di errore inferiore a 0.

Definizione alla 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)
Deprecato:
Firma i dati utilizzando un BLOB di chiavi generato in precedenza. Questo può utilizzare una chiave asimmetrica o una chiave segreta.

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

Definizione alla 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 e possibilmente riceve l'output da un'operazione crittografica in corso iniziata con begin() .

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

update() potrebbe non consumare tutti i dati forniti nel buffer di dati. update() restituirà la quantità consumata in *data_consumed. Il chiamante dovrebbe fornire i dati non consumati in una chiamata successiva.

Parametri
[in] div La struttura del dispositivo keymaster.
[in] operazione_handle L'handle dell'operazione restituito da begin() .
[in] in_params Ulteriori parametri per l'operazione. Per le modalità AEAD, viene utilizzato per specificare KM_TAG_ADDITIONAL_DATA. Si noti che dati aggiuntivi possono essere forniti in più chiamate a update() , ma solo fino a quando non sono stati forniti i dati di input.
[in] ingresso Dati da elaborare, secondo i parametri stabiliti nella chiamata a begin() . Tieni presente che update() può consumare o meno tutti i dati forniti. Vedi input_consumed .
[fuori] input_consumato Quantità di dati consumata da update() . Se questo è inferiore all'importo fornito, il chiamante dovrebbe fornire il resto in una successiva chiamata a update() .
[fuori] out_params Parametri di uscita. Utilizzato per restituire dati aggiuntivi dall'operazione Il chiamante assume la proprietà dell'array dei 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 parametri di output, begin() restituirà KM_ERROR_OUTPUT_PARAMETER_NULL.
[fuori] produzione I dati di output, se presenti. Il chiamante assume la proprietà del buffer allocato. l'output non deve essere NULL.

Nota che update() potrebbe non fornire alcun output, nel qual caso output->data_length sarà zero e output->data potrebbe essere NULL o lunghezza zero (quindi il chiamante dovrebbe sempre liberarlo()).

Definizione alla riga 495 del file keymaster1.h .

int (*)
Deprecato:
Verifica i dati firmati con un BLOB di chiavi. Questo può utilizzare una chiave asimmetrica o una chiave segreta.

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

Definizione alla riga 118 del file keymaster1.h .


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