BlackBerry Java SDK. Security Versione: 6.0. Guida allo sviluppo

Transcript

1 BlackBerry Java SDK Security Versione: 6.0 Guida allo sviluppo

2 Pubblicato: SWD

3 Indice 1 Panoramica sulla protezione RIM Cryptographic API... 6 Panoramica sulla crittografia... 6 Panoramica della funzione RIM Cryptographic API... 7 Esempio di codice: implementazione della crittografia... 9 Elementi di un'implementazione crittografica Sistemi crittografici Chiavi Archivi chiavi Chiave concordata Certificati Catene di certificati Firme Digest MAC Crittografia e decrittografia dei dati Crittografia e decrittografia dei dati tramite classi predefinite Algoritmi a blocchi Motori del componente di crittografia Gestione delle eccezioni Algoritmi crittografici e codici crittografici supportati da RIM Cryptographic API Algoritmi simmetrici a blocchi supportati da RIM Cryptographic API Algoritmi di crittografia a flusso supportati da RIM Cryptographic API Algoritmi di crittografia asimmetrici supportati da RIM Cryptographic API Algoritmi degli schemi di firma supportati da RIM Cryptographic API Algoritmi dello schema delle chiavi concordate supportati da RIM Cryptographic API Algoritmi di generazione delle chiavi supportati da RIM Cryptographic API Codici di autenticazione messaggi supportati da RIM Cryptographic API Codici dei digest di messaggi supportati da RIM Cryptographic API Protocolli TLS e WTLS supportati da RIM Cryptographic API Pacchetti di crittografia per l'algoritmo di generazione delle chiavi supportati da RIM Cryptographic API Algoritmi simmetrici supportati da RIM Cryptographic API Algoritmi hash supportati da RIM Cryptographic API Limitazioni del supporto di RIM Cryptographic API ai pacchetti di crittografia dell'algoritmo di generazione delle chiavi... 43

4 3 Protezione contenuto Compressione dei dati con protezione del contenuto Attivazione della protezione del contenuto Attivazione della protezione del contenuto tramite le regole dei criteri IT Attivazione della protezione del contenuto da parte di un utente Stati di blocco e sblocco del dispositivo Chiavi crittografiche Crittografia dei dati con il dispositivo bloccato Decrittografia dei dati con il dispositivo sbloccato Crittografia dei dati con il dispositivo sbloccato Blocco del dispositivo Implementazione della protezione del contenuto Ricezione e rilascio dei ticket di protezione del contenuto Sottoscrizione al framework di protezione del contenuto Registrazione di un PersistentContentListener Codifica di un oggetto Decodifica di un oggetto Gestione delle eccezioni Controllo delle API e firma codice Esecuzione delle applicazioni del dispositivo BlackBerry che utilizzano le API protette Registrazione per l'utilizzo delle API BlackBerry protette Utilizzo delle firme di codice con restrizioni Firma dell'applicazione Richiesta di una chiave di registrazione sostitutiva Come impedire a un'applicazione del dispositivo BlackBerry, in esecuzione su BlackBerry Smartphone Simulator, di accedere alle API protette Uso di una chiave di firma codice per la protezione di pacchetti e classi Registrazione per l'utilizzo di una nuova chiave di firma codice Importazione di una chiave di firma codice registrata esistente Rimozione di una chiave di firma codice registrata Visualizzazione dello stato della firma per le richieste di firma codice Annullamento degli avvisi di firma codice Annullamento delle richieste di password da parte di BlackBerry Signature Tool Attivazione della firma automatica dopo la preparazione di un progetto dell'applicazione BlackBerry Esecuzione di BlackBerry Signature Tool in background Disattivazione della firma automatica durante la preparazione di un progetto dell'applicazione BlackBerry... 63

5 Uso delle chiavi di firma codice per limitare l'accesso ai pacchetti o alle classi in un progetto della libreria BlackBerry Uso delle chiavi di firma codice per la protezione dei dati nelle applicazioni Restrizione dell'accesso ai dati della memoria permanente tramite le chiavi di firma codice Restrizione dell'accesso ai dati dell'archivio di runtime tramite le chiavi di firma codice Supporto dei criteri IT Ulteriori informazioni Glossario Commenti e suggerimenti Cronologia delle revisioni del documento Note legali... 76

6 Panoramica sulla protezione Panoramica sulla protezione 1 Research In Motion offre diverse opzioni di protezione dei dati nell'applicazione del dispositivo BlackBerry. Autenticazione Gli utenti BlackBerry possono impostare una password per i propri dispositivi BlackBerry. Una volta attivata, la password va immessa per poter accedere al dispositivo. Inoltre, è possibile implementare l'autenticazione della connessione tra l'applicazione e il server, Internet o intranet tramite l'autenticazione HTTP Basic o HTTPS. Crittografia La crittografia consiste nel rendere i dati illeggibili finché non vengono decrittografati. Esistono molti modi per crittografare i dati presenti nell'applicazione: Metodo di crittografia RIM Cryptographic API Protezione contenuto Crittografia SQLite Crittografia della scheda di memoria Descrizione Questa API consente di crittografare e decrittografare i dati, gestire le chiavi crittografiche, apporre una firma digitale e verificare i dati, nonché creare connessioni altamente protette. Basata sulla funzione RIM Cryptographic API, l'api di protezione del contenuto fornisce una soluzione per la crittografia dell'oggetto String e degli oggetti dell'array di byte. L'API di protezione del contenuto utilizza il framework di protezione del contenuto sul dispositivo BlackBerry. Il framework deve essere attivato tramite l'impostazione di una regola dei criteri IT o di un'opzione. L'API Database include la funzionalità di crittografia per i database SQLite. Questa funzionalità è basata su JSR 75. Consente di crittografare i dati memorizzati nelle schede di memoria esterne (microsd) e nella memoria contenuto multimediale integrata (emmc). Limitazione dell'accesso È possibile limitare l'accesso ai dati contenuti nell'applicazione in uso ad altre applicazioni installate in un dispositivo BlackBerry. Il modo in cui viene eseguita tale operazione dipende dalla modalità di memorizzazione dei dati. Posizione di memorizzazione dei dati File Database SQLite Come limitare l'accesso ai dati È possibile limitare l'accesso ai file nel file system con le chiavi di firma codice, utilizzate insieme alla classe ControlledAccess. L'API Database fornisce l'opzione di protezione Protected, che rende disponibile il database solo per le applicazioni firmate con la stessa chiave di firma codice. 4

7 Panoramica sulla protezione Posizione di memorizzazione dei dati Memoria permanente Archivio di record Archivio di runtime Come limitare l'accesso ai dati È possibile limitare l'accesso agli oggetti nella memoria permanente con le chiavi di firma codice, utilizzate insieme alla classe ControlledAccess. È possibile memorizzare i dati in maniera privata, in modo da impedirne l'accesso ad altre applicazioni installate sul dispositivo. È possibile limitare l'accesso agli oggetti presenti nell'archivio di runtime con le chiavi di firma codice, utilizzate insieme alla classe ControlledAccess. Protezione durante il trasporto È possibile proteggere i dati durante il trasporto: API RIM Cryptographic API Protezione durante il trasporto La funzione RIM Cryptographic API include le API TLS, WTLS e SSL, che consentono la creazione di connessioni altamente protette. Altri meccanismi di protezione Questa guida non descrive tutte le forme di protezione in dettaglio. La risorsa principale per la protezione BlackBerry è disponibile all'indirizzo Per ulteriori informazioni sulla protezione degli approcci di memorizzazione di dati specifici come i database SQLite, la memoria permanente e l'archivio di runtime, consultare la Guida a BlackBerry Java SDK per sviluppatori - Memorizzazione dei dati, disponibile all'indirizzo Per informazioni sullo sviluppo delle applicazioni per smart card, consultare la Guida a BlackBerry Java SDK per sviluppatori - Smart card, disponibile all'indirizzo 5

8 RIM Cryptographic API RIM Cryptographic API 2 La funzione RIM Cryptographic API è una raccolta di classi che consentono di creare soluzioni di protezione per l'applicazione del dispositivo BlackBerry. Tramite la funzione RIM Cryptographic API, è possibile crittografare e decrittografare i dati, firmare e verificare i dati, stabilire connessioni altamente protette e gestire le chiavi crittografiche. Le specifiche relative a CLDC e MIDP di Java ME non definiscono un'api crittografica. Nella creazione della funzione RIM Cryptographic API, RIM ha scelto di non seguire il modello di protezione Java perché i dispositivi mobili non dispongono di molto spazio per più provider degli algoritmi di crittografia. Inoltre, il controllo dell'ora di compilazione è più appropriato per lo sviluppo integrato rispetto al controllo del runtime. Le funzioni RIM Cryptographic API si trovano nel pacchetto net.rim.device.api.crypto. Panoramica sulla crittografia Per la trasmissione elettronica dei dati, viene utilizzata la crittografia per fornire una comunicazione altamente protetta e autenticata tra il mittente e il destinatario. La crittografia comprende una serie di processi, dai protocolli e algoritmi complessi alla semplice codifica di lettere del testo. Sebbene la crittografia svolga un ruolo di fondamentale importanza nel mantenere la protezione e l'integrità dei dati trasmessi, nessun protocollo si può considerare totalmente sicuro. I protocolli e gli algoritmi sono costantemente presi d'assalto da criminali sempre più intelligenti, dotati di computer sempre più potenti. I crittografi cercano di migliorare costantemente le routine e gli algoritmi, ad esempio, cercano di incrementare le dimensioni delle chiavi per rendere più difficile il lavoro agli hacker. Esistono due tipi principali di sistema crittografico: Simmetrico: questo sistema crittografico è noto anche come cifratura a blocchi e utilizza la stessa chiave per la crittografia e la decrittografia. Tra i vantaggi di questo sistema, figura la relativa rapidità delle operazioni di crittografia e decrittografia, mentre il principale svantaggio è rappresentato dalla difficoltà di distribuire le chiavi in modo sicuro. Asimmetrico: questo sistema crittografico è noto anche come crittografia a chiave pubblica. Il mittente crittografa i dati con una chiave pubblica, quindi il destinatario li decrittografa con una chiave privata di cui è già fornito. Le chiavi sono facili da distribuire, ma la crittografia e la decrittografia risultano relativamente lente. I sistemi crittografici simmetrico e asimmetrico vengono spesso utilizzati insieme. Supponiamo, ad esempio, che due utenti, user1 e user2, debbano crittografare una notevole quantità di dati; pertanto, necessitano di un sistema crittografico veloce, in grado di rendere rapida la loro comunicazione, ma anche di un sistema semplice per la creazione della chiave. L'utente user1 utilizza la chiave pubblica di user2 per crittografare una chiave simmetrica, quindi, invia la chiave simmetrica a user2. L'utente user2 decrittografa la chiave simmetrica tramite la propria chiave privata (nota solo all'utente). A questo punto, gli utenti user1 e user2 condividono una chiave simmetrica, pertanto possono scambiarsi dati crittografati tramite un sistema crittografico veloce e simmetrico. I tre obiettivi principali della crittografia sono: la riservatezza, l'integrità e l'autenticazione. 6

9 Panoramica della funzione RIM Cryptographic API Riservatezza: l'utilizzo più comune della crittografia nell'ambiente aziendale riguarda la crittografia dei dati. La crittografia consiste nel "camuffare" un messaggio in modo da nasconderne il vero significato finché non venga decifrato dal destinatario designato. Esistono molti modi diversi per ottenere questo scopo. L'approccio più comune avviene attraverso l'utilizzo di cifre. In uno scenario tipico, un messaggio viene codificato tramite un protocollo e una cifra predeterminati e prestabiliti. Il messaggio risultante, definito come testo crittografato, viene trasmesso al destinatario. Una volta recapitato il messaggio, il destinatario decrittografa il messaggio tramite il protocollo prestabilito. Gli algoritmi di crittografia sono numerosi e diversi tra loro, alcuni di essi più sicuri e più pratici di altri. Integrità: nella crittografia moderna, l'integrità dei dati si ottiene utilizzando una funzione hash per produrre una cosiddetta "impronta digitale" univoca di un documento. In altre parole, a un documento viene applicata una funzione complessa per creare un valore univoco. Una volta recapitato il messaggio, l'utente applica la stessa funzione hash al messaggio. Se i valori risultanti corrispondono, probabilmente il messaggio non è stato modificato. Sebbene anche le migliori funzioni hash non garantiscano sempre la produzione di valori univoci, le probabilità che due documenti diversi restituiscano lo stesso valore sono molto ridotte. Esistono routine di hashing diverse per l'utilizzo in scenari diversi. Una routine di hashing comune è rappresentata dal MAC. I MAC combinano le funzioni di hashing e delle chiavi di crittografia per consentire la trasmissione di valori hash protetti e basati su una chiave. Autenticazione: l'autenticazione rappresenta un modo per verificare l'identità dell'interlocutore. Un protocollo di uso comune combina la firma digitale con una routine di crittografia a chiave privata per creare una sorta di stampigliatura digitale. Per decrittografare il messaggio, il destinatario deve decrittografare la stampigliatura digitale utilizzando la chiave privata del mittente. Questo metodo garantisce l'autenticità della firma digitale, purché la chiave privata del mittente non venga compromessa. Panoramica della funzione RIM Cryptographic API La funzione RIM Cryptographic API contiene le API riportate di seguito. API di messaggistica protetta L'API di messaggistica protetta costituisce un'implementazione dello standard CMS, che specifica i tipi di contenuto standard per la crittografia e descrive i formati del messaggio e della trasmissione per tali tipi di contenuto. La funzionalità S/MIME è basata sullo standard CMS. Il pacchetto net.rim.device.api.crypto.cms fornisce le classi per la creazione e la gestione dei tipi di contenuto CMS. API di connessione protetta L'API di connessione protetta definisce la funzionalità del protocollo che è possibile utilizzare per stabilire una comunicazione altamente protetta. È possibile utilizzare il protocollo SSL, TLS o WTLS. SSL: il protocollo SSL è progettato per la protezione dei dati inviati tramite le connessioni TCP/IP e viene utilizzato nell'implementazione del protocollo HTTPS. Il protocollo SSL è fornito nel pacchetto net.rim.device.api.crypto.tls.ssl30. TLS: il protocollo TLS è un protocollo standard di IETF basato su SSL versione 3. Il protocollo TLS è stato progettato per sostituire SSL e ha conosciuto un vasto utilizzo. Il protocollo TLS viene fornito nei seguenti pacchetti: 7

10 Panoramica della funzione RIM Cryptographic API net.rim.device.api.crypto.tls net.rim.device.api.crypto.tls.tls10 WTLS: il protocollo WTLS si situa a un livello superiore a WAP rispetto al protocollo TCP/IP. La protezione delle comunicazioni wireless che utilizzano il protocollo WAP implica l'utilizzo del protocollo WTLS tra il dispositivo client e il gateway WAP e di uno dei protocolli SSL o TLS oltre al gateway WAP. Il protocollo WTLS viene fornito nel pacchetto net.rim.device.api.crypto.tls.wtls20. API dell'archivio chiavi Un archivio chiavi è un database in cui vengono memorizzati i certificati e le chiavi crittografiche. Ciascun dispositivo BlackBerry dispone di un archivio chiavi, precaricato con i certificati di origine per tutte le autorità di certificazione. Questa procedura consente agli utenti BlackBerry di verificare l'attendibilità dei certificati di origine, che costituisce la base per tutte le successive verifiche di attendibilità. Le classi dell'archivio chiavi sono fornite nel pacchetto net.rim.device.api.crypto.keystore. API del certificato I certificati sono documenti elettronici contenenti le chiavi, unitamente alle informazioni di identificazione. Sono disponibili diversi pacchetti per la gestione dei certificati di crittografia: net.rim.device.api.crypto.certificate net.rim.device.api.crypto.certificate.status net.rim.device.api.crypto.certificate.x509 javax.microedition.pki net.rim.device.api.crypto.certificate.wtls API del codificatore La codifica è la procedura di conversione dei dati da un formato all'altro. Sebbene faccia spesso parte della procedura di crittografia, la codifica non corrisponde esattamente alla crittografia e, in genere, non è protetta. Le chiavi vengono codificate per fornire una rappresentazione standard, non per proteggerne l'identità. Le classi per la codifica delle chiavi e delle firme vengono fornite nel pacchetto net.rim.device.api.crypto.encoder. API ASN1 La maggior parte delle applicazioni utilizza i certificati prodotti da un'autorità di certificazione. Se è necessario analizzare o leggere i certificati personalmente, occorre utilizzare il pacchetto net.rim.device.api.crypto.asn1. API OID Gli identificatori dell'oggetto vengono gestiti tramite il pacchetto net.rim.device.api.crypto.oid. API dei dati primitivi I dati primitivi della crittografia sono le chiavi, i MAC, le cifre, gli algoritmi privi di chiavi, come digest e PRNG, e altre funzionalità associate alla crittografia a chiave simmetrica e a chiave pubblica. I dati primitivi della crittografia vengono forniti nel pacchetto net.rim.device.api.crypto. 8

11 Esempio di codice: implementazione della crittografia Esempio di codice: implementazione della crittografia L'esempio di codice seguente utilizza Triple DES, ovvero un algoritmo di crittografia a chiave simmetrica. RIM Cryptographic API semplifica l'utilizzo di Triple DES per crittografare e decrittografare i messaggi. import java.io.*; import net.rim.device.api.crypto.*; import net.rim.device.api.util.*; import net.rim.device.api.ui.*; import net.rim.device.api.ui.component.*; import net.rim.device.api.ui.container.*; import net.rim.device.api.util.*; public class EncodeDecodeString extends UiApplication implements FieldChangeListener private ButtonField _encrypt_button; private ButtonField _decrypt_button; private TripleDESKey _key; private TextField _edit_input_string; public static void main( String[] args ) EncodeDecodeString theapp = new EncodeDecodeString(); theapp.entereventdispatcher(); public void fieldchanged(field field, int context) String strcurrentmessage = _edit_input_string.gettext(); if(field == _encrypt_button) _edit_input_string.settext(encrypt(strcurrentmessage)); else _edit_input_string.settext(decrypt(strcurrentmessage)); public EncodeDecodeString() MainScreen screen = new MainScreen(); screen.settitle(new LabelField("Crypto Demo", LabelField.ELLIPSIS LabelField.USE_ALL_WIDTH)); _edit_input_string = new BasicEditField("Message:", null, 256, BasicEditField.FILTER_DEFAULT); screen.add(_edit_input_string); _encrypt_button = new ButtonField("Encrypt",ButtonField.CONSUME_CLICK); _encrypt_button.setchangelistener(this); screen.add(_encrypt_button); _decrypt_button = new ButtonField("Decrypt"); _decrypt_button.setchangelistener(this); screen.add(_decrypt_button); pushscreen(screen); public String encrypt(string plaintext) try 9

12 Esempio di codice: implementazione della crittografia _key = new TripleDESKey(); TripleDESEncryptorEngine encryptionengine = new TripleDESEncryptorEngine(_key); // In most cases, the data to encrypt will not fit into the block // length of a cipher. When that happens, use a padding algorithm // to pad out the last block. This uses PKCS5 to do the padding. PKCS5FormatterEngine formatterengine = new PKCS5FormatterEngine( encryptionengine ); // Use the byte array output stream to catch the encrypted information. ByteArrayOutputStream outputstream = new ByteArrayOutputStream(); // Create a block encryptor to help use the triple DES engine. BlockEncryptor encryptor = new BlockEncryptor( formatterengine, outputstream ); // Encrypt the data. encryptor.write( plaintext.getbytes() ); // Close the stream. This forces the extra bytes to be padded out if // there were not enough bytes to fill all of the blocks. encryptor.close(); // Get the encrypted data. byte[] encrypteddata = outputstream.tobytearray(); String strencrypted = new String(encryptedData); return(strencrypted); catch( CryptoTokenException e ) System.out.println(e.toString()); catch (CryptoUnsupportedOperationException e) System.out.println(e.toString()); catch( IOException e ) System.out.println(e.toString()); return "error"; public String decrypt(string ciphertext) try // Perform the decryption. Since this is a symmetric algorithm, // use the same key as before. TripleDESDecryptorEngine decryptorengine = new TripleDESDecryptorEngine(_key); // Create the unformatter engine to remove padding bytes. PKCS5UnformatterEngine unformatterengine = new PKCS5UnformatterEngine( decryptorengine ); // Set up an input stream to hand the encrypted data to the // block decryptor. ByteArrayInputStream inputstream = new ByteArrayInputStream( ciphertext.getbytes() ); // Create the block decryptor passing in the unformatter engine and the // encrypted data. BlockDecryptor decryptor = 10

13 Elementi di un'implementazione crittografica new BlockDecryptor( unformatterengine, inputstream ); // Next, read from the stream. This example reads the data 10 bytes // at a time and then adds that new data to the decrypteddata array. // For efficiency in a real situation, you should use a value // larger than 10. This example uses a small value to demonstrate // several iterations through the loop. byte[] temp = new byte[10]; DataBuffer db = new DataBuffer(); for( ;; ) int bytesread = decryptor.read( temp ); if( bytesread <= 0 ) // No more information to read, so leave loop. break; db.write(temp, 0, bytesread); // Make sure that the decrypted data is the same as the data // that was passed into the encryptor. byte[] decrypteddata = db.toarray(); String strdecrypted = new String(decryptedData); return(strdecrypted); catch( CryptoTokenException e ) System.out.println(e.toString()); catch (CryptoUnsupportedOperationException e) System.out.println(e.toString()); catch( IOException e ) System.out.println(e.toString()); return "error"; Elementi di un'implementazione crittografica Per creare un'applicazione con RIM Cryptographic API, è necessario utilizzare elementi crittografici come chiavi, archivi chiavi e certificati. Sistemi crittografici Un sistema crittografico rappresenta una serie di algoritmi che consente di implementare la crittografia, la decrittografia e la generazione di chiavi. I sistemi crittografici vengono utilizzati da tutti gli algoritmi crittografici a chiave pubblica per mantenere informazioni pubbliche comuni a tutti gli utenti entro una comunità o un sistema crittografico. In genere, il sistema crittografico comprende alcuni numeri matematici di cui ogni computer dell'utente deve disporre per l'esecuzione dei calcoli crittografici. 11

14 Elementi di un'implementazione crittografica RIM Cryptographic API supporta i seguenti sistemi crittografici: Diffie-Hellman, DSA, Elliptic Curve, Key Exchange Algorithm e RSA. Per creare un sistema crittografico, viene implementata una classe nell'interfaccia net.rim.device.api.crypto.cryptosystem. L'interfaccia CryptoSystem semplifica la creazione e la gestione delle chiavi e consente di specificare tutti i parametri possibili per le chiavi. Sistema crittografico RSA RSA è un sistema crittografico a chiave pubblica. Il sistema crittografico RSA è generalmente considerato quello di più semplice utilizzo tra i sistemi crittografici supportati perché è necessario impostare solo la dimensione del modulo. Per creare un sistema crittografico RSA, utilizzare la classe RSACryptoSystem. Esempio di codice L'esempio di codice seguente utilizza la classe RSACryptoSystem per creare un sistema crittografico RSA e consente di specificare il parametro modulusbitlength come RSACryptoSystem rsacryptosystem = new RSACryptoSystem(1024); Sistema crittografico DSA Il sistema DSA è uno standard del governo federale degli Stati Uniti definito nel documento FIPS 186. Per creare un sistema crittografico DSA, utilizzare la classe DSACryptoSystem. È possibile usare diversi costruttori per creare un sistema crittografico DSA. Il metodo più semplice per creare un sistema crittografico DSA è il seguente: DSACryptoSystem system = new DSACryptoSystem(); In alternativa, è possibile specificare appositi parametri. Nell'esempio seguente, il costruttore viene richiamato con valori per p, q e g. /* 1024 bit key parameters */ private static final byte[] p = new byte[] (byte)0xfd, (byte)0x7f, (byte)0x53, (byte)0x81, (byte)0x1d, (byte)0x75, (byte)0x12, (byte)0x29, (byte)0x52, (byte)0xdf, (byte)0x4a, (byte)0x9c, (byte)0x2e, (byte)0xec, (byte)0xe4, (byte)0xe7, (byte)0xf6, (byte)0x11, (byte)0xb7, (byte)0x52, (byte)0x3c, (byte)0xef, (byte)0x44, (byte)0x00, (byte)0xc3, (byte)0x1e, (byte)0x3f, (byte)0x80, (byte)0xb6, (byte)0x51, (byte)0x26, (byte)0x69, (byte)0x45, (byte)0x5d, (byte)0x40, (byte)0x22, (byte)0x51, (byte)0xfb, (byte)0x59, (byte)0x3d, (byte)0x8d, (byte)0x58, (byte)0xfa, (byte)0xbf, (byte)0xc5, (byte)0xf5, (byte)0xba, (byte)0x30, (byte)0xf6, (byte)0xcb, (byte)0x9b, (byte)0x55, (byte)0x6c, (byte)0xd7, (byte)0x81, (byte)0x3b, (byte)0x80, (byte)0x1d, (byte)0x34, (byte)0x6f, (byte)0xf2, (byte)0x66, (byte)0x60, (byte)0xb7, (byte)0x6b, (byte)0x99, (byte)0x50, (byte)0xa5, (byte)0xa4, (byte)0x9f, (byte)0x9f, (byte)0xe8, (byte)0x04, (byte)0x7b, (byte)0x10, (byte)0x22, (byte)0xc2, (byte)0x4f, (byte)0xbb, (byte)0xa9, (byte)0xd7, (byte)0xfe, (byte)0xb7, (byte)0xc6, (byte)0x1b, (byte)0xf8, (byte)0x3b, (byte)0x57, (byte)0xe7, (byte)0xc6, (byte)0xa8, (byte)0xa6, (byte)0x15, (byte)0x0f, (byte)0x04, (byte)0xfb, (byte)0x83, (byte)0xf6, (byte)0xd3, (byte)0xc5, (byte)0x1e, (byte)0xc3, 12

15 Elementi di un'implementazione crittografica (byte)0x02, (byte)0x35, (byte)0x54, (byte)0x13, (byte)0x5a, (byte)0x16, (byte)0x91, (byte)0x32, (byte)0xf6, (byte)0x75, (byte)0xf3, (byte)0xae, (byte)0x2b, (byte)0x61, (byte)0xd7, (byte)0x2a, (byte)0xef, (byte)0xf2, (byte)0x22, (byte)0x03, (byte)0x19, (byte)0x9d, (byte)0xd1, (byte)0x48, (byte)0x01, (byte)0xc7 ; private static final byte[] q = new byte[] (byte)0x97, (byte)0x60, (byte)0x50, (byte)0x8f, (byte)0x15, (byte)0x23, (byte)0x0b, (byte)0xcc, (byte)0xb2, (byte)0x92, (byte)0xb9, (byte)0x82, (byte)0xa2, (byte)0xeb, (byte)0x84, (byte)0x0b, (byte)0xf0, (byte)0x58, (byte)0x1c, (byte)0xf5 ; private static final byte[] g = new byte[] (byte)0xf7, (byte)0xe1, (byte)0xa0, (byte)0x85, (byte)0xd6, (byte)0x9b, (byte)0x3d, (byte)0xde, (byte)0xcb, (byte)0xbc, (byte)0xab, (byte)0x5c, (byte)0x36, (byte)0xb8, (byte)0x57, (byte)0xb9, (byte)0x79, (byte)0x94, (byte)0xaf, (byte)0xbb, (byte)0xfa, (byte)0x3a, (byte)0xea, (byte)0x82, (byte)0xf9, (byte)0x57, (byte)0x4c, (byte)0x0b, (byte)0x3d, (byte)0x07, (byte)0x82, (byte)0x67, (byte)0x51, (byte)0x59, (byte)0x57, (byte)0x8e, (byte)0xba, (byte)0xd4, (byte)0x59, (byte)0x4f, (byte)0xe6, (byte)0x71, (byte)0x07, (byte)0x10, (byte)0x81, (byte)0x80, (byte)0xb4, (byte)0x49, (byte)0x16, (byte)0x71, (byte)0x23, (byte)0xe8, (byte)0x4c, (byte)0x28, (byte)0x16, (byte)0x13, (byte)0xb7, (byte)0xcf, (byte)0x09, (byte)0x32, (byte)0x8c, (byte)0xc8, (byte)0xa6, (byte)0xe1, (byte)0x3c, (byte)0x16, (byte)0x7a, (byte)0x8b, (byte)0x54, (byte)0x7c, (byte)0x8d, (byte)0x28, (byte)0xe0, (byte)0xa3, (byte)0xae, (byte)0x1e, (byte)0x2b, (byte)0xb3, (byte)0xa6, (byte)0x75, (byte)0x91, (byte)0x6e, (byte)0xa3, (byte)0x7f, (byte)0x0b, (byte)0xfa, (byte)0x21, (byte)0x35, (byte)0x62, (byte)0xf1, (byte)0xfb, (byte)0x62, (byte)0x7a, (byte)0x01, (byte)0x24, (byte)0x3b, (byte)0xcc, (byte)0xa4, (byte)0xf1, (byte)0xbe, (byte)0xa8, (byte)0x51, (byte)0x90, (byte)0x89, (byte)0xa8, (byte)0x83, (byte)0xdf, (byte)0xe1, (byte)0x5a, (byte)0xe5, (byte)0x9f, (byte)0x06, (byte)0x92, (byte)0x8b, (byte)0x66, (byte)0x5e, (byte)0x80, (byte)0x7b, (byte)0x55, (byte)0x25, (byte)0x64, (byte)0x01, (byte)0x4c, (byte)0x3b, (byte)0xfe, (byte)0xcf, (byte)0x49, (byte)0x2a ; DSACryptoSystem system = new DSACryptoSystem( p, q, g ); Chiavi La crittografia a chiave asimmetrica utilizza due chiavi: una chiave pubblica per crittografare e verificare l'input e una chiave privata per decrittografare i dati. La crittografia a chiave simmetrica utilizza una sola chiave per la crittografia e la decrittografia. In RIM Cryptographic API, è possibile creare chiavi tramite sottointerfacce dell'interfaccia net.rim.device.api.crypto.key. Di seguito, sono riportate alcune sottointerfacce dell'interfaccia Key: PublicKey: Le chiavi pubbliche vengono utilizzate nella crittografia a chiave asimmetrica. La chiave pubblica viene generalmente utilizzata in operazioni come la crittografia e la verifica. I contenuti di questa chiave possono essere divulgati a chiunque. PrivateKey: Le chiavi private vengono utilizzate nella crittografia a chiave asimmetrica. La chiave privata viene generalmente utilizzata in operazioni come la decrittografia e la firma. È necessario proteggere i contenuti di questa chiave. 13

16 Elementi di un'implementazione crittografica SymmetricKey: Le chiavi simmetriche sono utilizzate nella crittografia a chiave simmetrica. La chiave simmetrica viene utilizzata sia per la crittografia che per la decrittografia. È necessario proteggere i contenuti di questa chiave. Esempio di codice: creazione di una chiave simmetrica L'esempio di codice seguente mostra come creare un oggetto chiave DES simmetrica contenente una chiave DES generata a caso. La classe DESKey si trova nell'interfaccia SymmetricKey. DESKey unknownkey = new DESKey(); Esempio di codice: creazione di una chiave pubblica e di una chiave privata L'esempio di codice seguente crea una coppia di chiavi: una chiave pubblica e una chiave privata. Tale esempio utilizza il valore predefinito per l'esponente pubblico (e). Il valore scelto per e rappresenta un compromesso tra l'efficienza e la protezione. // Create an RSA key pair. RSAKeyPair rsakeypair = new RSAKeyPair( rsacryptosystem ); // Get the private and public keys that were just created. RSAPublicKey rsapublickey = rsakeypair.getrsapublickey(); RSAPrivateKey rsaprivatekey = rsakeypair.getrsaprivatekey(); L'esempio seguente crea chiavi asimmetriche, tuttavia, l'utente non può specificare i valori per e e n. // Create an RSA key pair with a modulus 1024 bits in length and values e and n. RSACryptoSystem rsacryptosystem = new RSACryptoSystem(1024); RSAPublicKey rsapublickey = new RSAPublicKey( rsacryptosystem, e, n ); Archivi chiavi Un archivio chiavi è una raccolta di record KeyStoreData. Un record KeyStoreData contiene dati come chiavi pubbliche, chiavi private, chiavi simmetriche, certificati, identificativo per il record KeyStoreData e altri elementi. Ogni dispositivo BlackBerry dispone di un archivio chiavi precaricato con certificati di origine per le varie autorità di certificazione. Questi certificati di origine attendibili formano la base per tutte le catene di attendibilità successive. Gli utenti BlackBerry possono personalizzare il loro archivio chiavi. Ad esempio, possono richiedere l'immissione della password ad ogni accesso all'archivio chiavi. La funzionalità per la creazione e la gestione degli archivi chiavi, compresi alcuni archivi chiavi predefiniti, è fornita nel pacchetto net.rim.device.api.crypto.keystore.keystore. Il pacchetto KeyStore fornisce un modello di archivio chiavi che consente di gestire la distribuzione e l'accesso alle chiavi sul desktop e sul dispositivo. Il pacchetto KeyStore include le classi seguenti: La classe RIMKeyStore viene fornita come implementazione predefinita. Questa classe memorizza le chiavi fino al riavvio del dispositivo, in modo da impedirne l'utilizzo per la memorizzazione di chiavi permanenti. Un esempio del suo utilizzo consiste nella memorizzazione di chiavi smart card: in tal caso, le chiavi vengono memorizzate nella smart card e non nell'archivio chiavi. Gli archivi chiavi riportati di seguito rappresentano alcune varianti di questa classe: 14

17 Elementi di un'implementazione crittografica La classe PersistableRIMKeyStore è utile per le chiavi da archiviare tra un riavvio del dispositivo e l'altro. La classe SyncableRIMKeyStore è utile per le chiavi da archiviare tra un riavvio e l'altro e consente di sincronizzare le chiavi con lo strumento di sincronizzazione certificati presente in BlackBerry Desktop Manager (BlackBerry Desktop Manager 5 e versioni precedenti). La classe TrustedKeyStore fornisce una memorizzazione altamente protetta per i certificati e le chiavi che dispongono di un livello di protezione elevato. Solo le applicazioni firmate possono aggiungere chiavi all'archivio TrustedKeyStore. L'archivio DeviceKeyStore fornisce la funzionalità per la sincronizzazione con il software desktop. L'archivio CombinedKeyStore consente di combinare diversi archivi chiavi in un singolo archivio chiavi. Esempio di codice: creazione di un archivio chiavi L'esempio di codice seguente consente di creare un nuovo archivio chiavi denominato "My Keystore" e una coppia di chiavi denominata keypair. Un oggetto associateddata viene creato per facilitare il recupero successivo dall'archivio chiavi. RIMKeyStore keystore = new RIMKeyStore("My Keystore"); DSAKeyPair keypair = new DSAKeyPair( new DSACryptoSystem() ); AssociatedData associateddata = new AssociatedData( AssociatedData. , "user01@example.com".getbytes() ); L'esempio di codice successivo consente di aggiungere la chiave keypair all'archivio chiavi. Il metodo set aggiunge un oggetto KeyStoreData contenente informazioni che verranno associate all'array di alias contenuto nella classe. Il metodo keystore.set è richiamato con otto parametri: L'oggetto AssociatedData (un array di dati associato contenente gli alias per indicizzare questo record nell'archivio chiavi). Un'etichetta ("Crypto Signing Key") che identifica la chiave. La chiave privata. L'algoritmo di codifica della chiave privata, che, in questo caso, è impostato su null e utilizza, in tal modo, il formato predefinito, PKCS8. Un livello di protezione basso per la chiave: ad ogni tentativo di accesso alla chiave privata, non verrà richiesto di immettere la password. La chiave pubblica. Le impostazioni KeyUsage (in tal caso, specificano che la chiave pubblica vale per la protezione e come chiave concordata). Il ticket, che, in tal caso, è null. Un blocco try/catch viene utilizzato per acquisire tutte le eccezioni eventualmente generate. try keystore.set( new AssociatedData[] associateddata, "Crypto Signing Key", keypair.getdsaprivatekey(), null, KeyStore.SECURITY_LEVEL_LOW, keypair.getdsapublickey(), KeyUsage. _PROTECTION KeyUsage.KEY_AGREEMENT, null ); 15

18 Elementi di un'implementazione crittografica catch( NoSuchAlgorithmException e ) catch( KeyStoreCancelException e ) return; catch( InvalidKeyEncodingException e ) catch( CryptoTokenException e ) catch( InvalidKeyException e ) catch( CryptoUnsupportedOperationException e ) L'esempio di codice seguente recupera la chiave keypair dall'archivio chiavi. Il codice crea un indice. Viene aggiunto un indice a un archivio chiavi una sola volta. Precedentemente, in quest'esempio, un oggetto AssociatedData è stato associato all'indirizzo user01@example.com, pertanto, il nuovo indice è di tipo AssociatedDataKeyStoreIndex. L'indice viene aggiunto all'archivio chiavi. Viene utilizzato il metodo KeyStore.elements per recuperare la chiave. Il metodo elements utilizza l'indice (index.getid) e i byte associati all'oggetto AssociatedData ("user01@example.com".getbytes). Il metodo elements restituisce un'enumerazione di tutti gli oggetti KeyStoreData corrispondenti ai criteri di ricerca. Un ciclo while viene utilizzato per scorrere l'enumerazione durante la ricerca dell'etichetta "Crypto Signing Key" (in un'applicazione reale, due chiavi potrebbero contenere le stesse informazioni AssociatedData e la stessa etichetta, pertanto l'utente dovrebbe essere chiamato a specificare la chiave da recuperare). Il metodo getprivatekey viene richiamato per recuperare la chiave. Il parametro null viene utilizzato perché non è disponibile un ticket. AssociatedDataKeyStoreIndex index = new AssociatedDataKeyStoreIndex( AssociatedData. ); keystore.addindex( index ); Enumeration enum = keystore.elements( index.getid(), "user01@example.com".getbytes() ); KeyStoreData data = null; PrivateKey privatekey = null; while( enum.hasmoreelements() ) data = (KeyStoreData)enum.nextElement(); if( "Crypto Signing Key".equals( data.getlabel() ) ) try privatekey = data.getprivatekey( null ); catch( NoSuchAlgorithmException e ) catch( KeyStoreCancelException e ) 16

19 Elementi di un'implementazione crittografica catch( InvalidKeyEncodingException e ) catch( CryptoTokenException e ) catch( CryptoUnsupportedOperationException e ) catch( KeyStoreDecodeException e ) L'esempio di codice successivo aggiunge un certificato all'archivio chiavi, quindi verifica l'esistenza del certificato. Questo esempio di codice presuppone la disponibilità di un certificato WTLS. Il primo parametro per il metodo keystore.set rappresenta un array contenente gli alias necessari per indicizzare il record nell'archivio chiavi. Quando vengono fornite queste informazioni, è possibile interrogare il certificato con l'alias specificato, come illustrato nell'esempio precedente. In questo esempio, tuttavia, il parametro è impostato su null, il certificato è memorizzato nell'archivio chiavi e la voce keystore.ismember() viene richiamata per controllare l'appartenenza. Il metodo ismember crea un indice per il certificato. byte[] certdata = /* Certificate data as a byte array */ ; try //Assuming that you have a WTLS certificate, create a WTLS certificate. WTLSCertificate cert = WTLSCertificate( certdata ); keystore.set(null, "my certificate", cert, new CertificateStatus(), null);... catch ( CertificateParsingException e ) catch ( NoSuchAlgorithmException e ) catch ( InvalidKeyEncodingException e ) catch ( InvalidKeyException e ) catch ( CryptoTokenException e ) catch ( CryptoUnsupportedOperationException e ) catch ( KeyStorePasswordException e ) 17

20 Elementi di un'implementazione crittografica //Verify that the certificate is in the key store. WTLSCertificate mynewcert = WTLSCertificate( certdata ); if ( keystore.ismember(mynewcert) ) System.out.println("Certificate provided is in the key store"); else System.out.println("Certificate provided is not in the key store"); Chiave concordata La chiave concordata offre a due parti indipendenti un modo per stabilire un canale altamente protetto su una rete non sicura. I protocolli della chiave concordata utilizzano generalmente le chiavi pubbliche e private di entrambe le parti, insieme ai parametri specifici dell'algoritmo, per creare una serie di dati segreti. I dati segreti vengono creati in modo indipendente da entrambe le parti, mediante le informazioni pubblicamente condivise, e utilizzati come chiave di sessione per stabilire una comunicazione altamente protetta. La chiave segreta deriva dai dati pubblici, ma non viene inviata tramite la rete. La funzione RIM Cryptographic API supporta i seguenti schemi delle chiavi concordate: DHKeyAgreement: Chiave concordata Diffie-Hellman ECDHKeyAgreement: Chiave concordata Diffie-Hellman a curva ellittica ECMQVKeyAgreement: Chiave concordata Menezes, Qu e Vanstone a curva ellittica KEAKeyAgreement: Algoritmo di scambio chiave ECDHKeyAgreement è uno schema delle chiavi concordate molto diffuso e richiede l'utilizzo di una chiave pubblica e di una chiave privata. In una comunicazione altamente protetta, ciascuna parte utilizza la propria chiave privata e la chiave pubblica dell'altra parte. Quando ciascuna parte utilizza l'algoritmo della chiave concordata, vengono creati gli stessi dati segreti. Esempio di codice: implementazione di ECDHKeyAgreement L'esempio di codice seguente illustra lo schema ECDHKeyAgreement. Si presuppone che sendpublickey() e receivepublickey() siano presenti e attivino lo scambio di chiavi tra i due client. Quando un messaggio viene inviato da un client, viene ricevuto dall'altro client. Le operazioni si svolgono a livello locale e i dettagli relativi allo scambio di chiavi non vengono visualizzati. Nell'applicazione in uso, le chiavi pubbliche vengono scambiate tramite la rete e le chiavi private deve essere protette da ciascuna parte. I segreti identici condivisi vengono creati da ciascun client (qui denominati client1secret e client2secret). In questo esempio, viene generato il segreto locale sul client locale, viene creato un segreto locale condiviso, identico al segreto del client locale, e viene generata la chiave segreta. Infine, viene creato un segreto locale condiviso, identico al segreto appena generato. //Generate the local secret on the local client. public void generatelocalsecret() // Create an EC crypto system for key creation 18