Riferimento alla struttura keymaster1_device

Campi dati
Riferimento alla struttura keymaster1_device

#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(* 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, algoritmo keymaster_algorithm_t , keymaster_scopo_t scopo, 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 , keymaster_scopo_t scopo, keymaster_padding_t **modes, size_t *modes_length)
keymaster_error_t (* get_supported_digests )(const struct keymaster1_device *dev, algoritmo keymaster_algorithm_t , keymaster_scopo_t scopo, keymaster_digest_t **digests, 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 **caratteristiche)
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_scopo_t scopo, const keymaster_key_blob_t *key, const keymaster_key_param_set_t *in_params, keymaster_key_param_set_t *out_params, keymaster_operazione_handle_t *operazione_handle)
keymaster_error_t (* aggiornamento )(const struct keymaster1_device *dev, keymaster_Operation_handle_t operazione_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 (* finitura )(const struct keymaster1_device *dev, keymaster_Operation_handle_t operazione_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_operazione_handle_t operazione_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_operative_handle_t operazione_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 dal keymaster. È garantito che l'entropia aggiunta tramite questo metodo non sia 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 dati l'attaccante non può prevedere (o controllo), allora l'uscita RNG non è distinguibile da quella casuale. Pertanto, se l’entropia proveniente da qualsiasi fonte è buona, il risultato sarà buono.

Parametri
[In] dev La struttura del dispositivo keymaster.
[In] dati Dati casuali da mescolare.
[In] lunghezza_dati Lunghezza dei data .

Definizione alla riga 242 del file keymaster1.h .

keymaster_error_t (* Begin)(const struct keymaster1_device *dev, keymaster_scopo_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)

Inizia un'operazione di crittografia utilizzando la chiave specificata. Se tutto va bene, Begin() restituirà KM_ERROR_OK e creerà un handle di operazione che dovrà essere passato alle chiamate successive 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 keymaster di ripulire qualsiasi stato operativo interno. In caso contrario, potrebbe verificarsi una perdita di spazio di stato interno o di altre risorse interne e potrebbe causare la restituzione di Begin() KM_ERROR_TOO_MANY_OPERATION quando 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] dev 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. 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 suoi 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 dati di autenticazione, con KM_TAG_AUTH_TOKEN. Se durante la generazione sono stati forniti KM_TAG_APPLICATION_ID o KM_TAG_APPLICATION_DATA, è necessario fornirli qui altrimenti l'operazione fallirà con KM_ERROR_INVALID_KEY_BLOB. Per le operazioni che richiedono un nonce o un IV, sulle 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.
[fuori] out_params Parametri di uscita. 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. Il chiamante diventa proprietario 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 operazione_handle è NULL, Begin() restituirà KM_ERROR_OUTPUT_PARAMETER_NULL.

Definizione alla riga 451 del file keymaster1.h .

uint32_t versione_client

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

Definizione alla riga 41 del file keymaster1.h .

struttura hw_device_t comune

Metodi comuni del dispositivo keymaster. Questo deve essere il primo membro di keymaster_device poiché gli utenti di questa struttura trasformeranno un puntatore hw_device_t in keymaster_device in contesti in cui è noto che hw_device_t fa riferimento a 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 ripristinato completamente.

Questa funzione è facoltativa e deve 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 ripristinato completamente. Dopo aver chiamato questa funzione sarà impossibile utilizzare i key blob precedentemente generati o importati per qualsiasi operazione.

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

Parametri
[In] dev 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 richiamato questa funzione sarà impossibile utilizzare il tasto per qualsiasi altra operazione. Può essere applicato a chiavi provenienti da radici di fiducia esterne (chiavi non utilizzabili con la radice di fiducia corrente).

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 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 deve 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] dev La struttura del dispositivo keymaster.
[In] formato_esportazione Il formato da utilizzare per esportare la chiave.
[In] chiave_per_esportare La chiave per esportare.
[fuori] dati_esporta Il materiale chiave esportato. Il chiamante ne assume la proprietà.
[fuori] lunghezza_dati_esporta La lunghezza di export_data .

Definizione alla riga 377 del file keymaster1.h .

keymaster_error_t (* finitura)(const struct keymaster1_device *dev, keymaster_Operation_handle_t operazione_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] dev La struttura del dispositivo keymaster.
[In] operazione_handle L'handle dell'operazione restituito da Begin() . Questo handle verrà invalidato.
[In] parametri 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.
[fuori] produzione I dati di output, se presenti. Il chiamante assume la proprietà del buffer allocato.

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

Definizione alla riga 521 del file keymaster1.h .

uint32_t flag

Vedere 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 una coppia di chiavi, restituendo un BLOB di chiave e/o una descrizione della chiave.

I parametri di generazione delle chiavi sono definiti come coppie tag/valore keymaster, fornite 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_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 loro valori saranno forniti dall'implementazione.

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTENTE,
  • KM_TAG_CREATION_DATETIME
Parametri
[In] dev La struttura del dispositivo keymaster.
[In] parametri Matrice di parametri di generazione delle chiavi.
[In] params_count 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 diversa da NULL. Se diverso da NULL, il chiamante ne assume la proprietà e deve effettuare 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 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 dovrà 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 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] Identificativo cliente I dati dell'ID client o NULL se nessuno è associato.
[In] app_id I dati dell'app o NULL se non associati.
[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 in un array di byte codificato 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 deve essere allocato.

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

Ottiene il supporto degli algoritmi.

Parametri
[In] dev La struttura del dispositivo keymaster.
[fuori] algoritmi Array di algoritmi supportati. Il chiamante assume la proprietà dell'array e deve liberarlo.
[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 , keymaster_scopo_t scopo, keymaster_block_mode_t **modes, size_t *modes_length)

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

Parametri
[In] dev La struttura del dispositivo keymaster.
[In] algoritmo L'algoritmo per il quale verranno restituite le modalità supportate.
[fuori] modalità Gamma di modalità supportate. Il chiamante assume la proprietà dell'array e deve liberarlo.
[fuori] modalità_lunghezza Durata 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 , keymaster_scopo_t scopo, keymaster_digest_t **digests, size_t *digests_length)

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

Parametri
[In] dev La struttura del dispositivo keymaster.
[In] algoritmo L'algoritmo per il quale verranno restituiti i digest supportati.
[fuori] digerisce Array di digest supportato. Il chiamante assume la proprietà dell'array e deve liberarlo.
[fuori] digest_lunghezza Lunghezza dei 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] dev La struttura del dispositivo keymaster.
[In] algoritmo L'algoritmo per il quale verranno restituiti i formati supportati.
[fuori] formati Gamma di formati supportati. Il chiamante assume la proprietà dell'array e deve liberarlo.
[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] dev La struttura del dispositivo keymaster.
[In] algoritmo L'algoritmo per il quale verranno restituiti i formati supportati.
[fuori] formati Gamma di formati supportati. Il chiamante assume la proprietà dell'array e deve liberarlo.
[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 , keymaster_scopo_t scopo, 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] dev La struttura del dispositivo keymaster.
[In] algoritmo L'algoritmo per il quale verranno restituite le modalità di riempimento supportate.
[fuori] modalità È supportata una serie di modalità di riempimento. Il chiamante assume la proprietà dell'array e deve liberarlo.
[fuori] modalità_lunghezza Durata 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 chiave e/o una descrizione della chiave.

La maggior parte dei parametri di importazione delle chiavi sono definiti come coppie tag/valore keymaster, fornite 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_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 ad 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 utilizzerà per impostazione predefinita il valore nella chiave fornita (per chiavi RSA)

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

  • KM_TAG_ORIGIN,
  • KM_TAG_ROLLBACK_RESISTENTE,
  • KM_TAG_CREATION_DATETIME
Parametri
[In] dev La struttura del dispositivo keymaster.
[In] parametri Parametri che definiscono la chiave importata.
[In] params_count 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 della chiave opaca. Deve essere diverso da 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 verrà restituita alcuna caratteristica. Se diverso da NULL, il chiamante ne assume la proprietà e deve effettuare 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 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 keyblob generato in precedenza. 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 (* aggiornamento)(const struct keymaster1_device *dev, keymaster_operazione_handle_t operazione_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 e possibilmente riceve output da un'operazione crittografica in corso iniziata con Begin() .

Se operazione_handle non è valida, update() restituirà KM_ERROR_INVALID_OPERATION_HANDLE.

update() potrebbe non consumare tutti i dati forniti nel buffer di dati. update() restituirà l'importo consumato in *data_consumed. Il chiamante dovrà fornire i dati non utilizzati in una chiamata successiva.

Parametri
[In] dev La struttura del dispositivo keymaster.
[In] operazione_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 dati aggiuntivi potrebbero essere forniti in più chiamate a update() , ma solo fino a quando non saranno stati forniti i dati di input.
[In] ingresso Dati da elaborare, secondo i parametri stabiliti nella chiamata a Begin() . Tieni presente che update() potrebbe consumare o meno tutti i dati forniti. Vedi input_consumed .
[fuori] input_consumato Quantità di dati consumati da update() . Se questo è inferiore all'importo fornito, il chiamante dovrebbe fornire il resto in una chiamata successiva a update() .
[fuori] out_params Parametri di uscita. Utilizzato per restituire dati aggiuntivi dall'operazione. Il chiamante diventa proprietario 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.

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

Definizione alla 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)
Deprecato:
Verifica i dati firmati con un keyblob. 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: