Cifratura asimmetrica Cifratura asimmetrica

Cifratura asimmetrica
¾
La cifratura SIMMETRICA è un ottimo
strumento per la sicurezza
¾
Il problema della cifratura simmetrica sta nel
fatto che occorre avere una chiave condivisa e
quindi bisogna scambiarsi questa informazione
¾
Questa operazione è però molto difficile da
effettuarsi in modo che nessun altro scopra la
chiave
¾
La soluzione a questo problema è risolto con la
cifratura a chiave ASIMMETRICA
37
Cifratura asimmetrica
Cosa si vuole ottenere:
Il forziere ora ha due
serrature diverse, una
permette solo di chiudere
e l’
l’altra solo di aprire
pubblica
privata
38
Modalità
Padding
¾
Nei cifrari asimmetrici si usa
quasi sempre ECB
¾
Nella cifratura asimmetrica non
si usa PKCS#5
¾
Tipicamente i cifrari asimmetrici
sono utilizzati per cifrare un
singolo blocco in chiaro
¾
Gli standard per cifrare con RSA
sono invece PKCS#1 e OAEP
(Optimal Asymmetric Encryption
Padding)
¾
Generalmente le dimensioni di
quel blocco sono grandi quasi
come quelle della chiave
¾
Di seguito non sarà illustrato il
funzionamento di tali forme di
padding
Se è necessario cifrare più dati si
utilizzerà la cifratura a chiave di
sessione che vedremo in seguito
¾
Per chi fosse interessato :
www.rsasecurity.com/rsalabs/pkc
s/pkcs-1/index.html
¾
39
RSA
Occorre un provider che
supporti tale algoritmo
Es. BouncyCastle (Å)
In J2SE1.4
J2SE1.4 RSA è supportato
solo per le operazioni di
firma e verifica
import javax.crypto.*;
javax.crypto.*;
import java.security.*;
java.security.*;
…..
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance
("RSA
RSA");
");
KeyPairGenerator.getInstance("
keyPairGenerator.initialize(1024);
keyPairGenerator.initialize(1024);
KeyPair keyPair = keyPairGenerator.genKeyPair();
keyPairGenerator.genKeyPair();
Cipher cipher = Cipher.getInstance
("RSA/ECB/PKCS1Padding
RSA/ECB/PKCS1Padding");
");
Cipher.getInstance("
cipher.init(
cipher.init(Cipher.ENCRYPT_MODE,
Cipher.ENCRYPT_MODE, keyPair.getPublic());
keyPair.getPublic());
Questa volta occorre
una coppia di chiavi
Per la cifratura
occorre inizializzare
il cifrario con una
PublicKey
byte[]
UTF8”);
byte[] messageBytes = new String(
String(“Combinazione:1234”
Combinazione:1234”).getBytes(
.getBytes(“UTF8”
byte[]
byte[] cipherText = cipher.doFinal(
cipher.doFinal(messageBytes);
messageBytes);
Per la decifrazione
occorre inizializzare
cipher.init(
cipher.init(Cipher.DECRYPT_MODE,
Cipher.DECRYPT_MODE, keyPair.getPrivate());
keyPair.getPrivate());
il cifrario con una
PrivateKey
byte[]
byte[] decryptedMessageBytes = cipher.doFinal(
cipher.doFinal(cipherText);
cipherText);
System.out.println
System.out.println((new String(
String(decryptedMessageBytes,
decryptedMessageBytes,”UTF8”
UTF8”));
.....
40
Cifratura a chiave di sessione
La cifratura asimmetrica è
1000 volte più lenta di
quella simmetrica
Per gestire questa
inefficienza in genere
si utilizza la cifratura a
Chiave di Sessione
41
Cifratura a chiave di sessione
1. Il messaggio in chiaro è cifrato con una chiave simmetrica
2. Poi questa a sua volta viene cifrata con la chiave pubblica del destinatario
3. Il destinatario quindi decifra la chiave simmetrica con la sua
sua chiave privata
4. Infine il destinatario può decifrare il messaggio usando la chiave simmetrica ottenuta
La chiave simmetrica viene cambiata ad ogni sessione (da qui il nome chiave di sessione)
sessione)
La cifratura asimmetrica coinvolge poco testo in chiaro risultando in questo modo efficiente
42
Cifratura di una chiave simmetrica
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
.....
KeyGenerator keyGenerator = KeyGenerator.getInstance("Blowfish");
keyGenerator.init(128);
Key blowfishKey = keyGenerator.generateKey();
Generazione
della chiave di
sessione
Generazione di
una coppia di
chiavi RSA
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(1024);
KeyPair keyPair = keyPairGenerator.genKeyPair();
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
Trasformazione della chiave
nel formato richiesto per
byte[] blowfishKeyBytes = blowfishKey.getEncoded();
l’operazione di cifratura
byte[] cipherText = cipher.doFinal(blowfishKeyBytes);
cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
Riconversione dei
byte[] decryptedKeyBytes = cipher.doFinal(cipherText);
byte in chiave
SecretKey blowfishKey = new SecretKeySpec(decryptedKeyBytes,"Blowfish");
.....
43
Firme digitali (1)
Algoritmo di impronta
Messaggio
inviato dal
mittente
Autenticazione
Impronta del
messaggio
Chiave privata
Lato
Mittente
Algoritmo di firma
Firma digitale
inviata al destinatario
44
Firme digitali (2)
Autenticazione
Algoritmo di impronta
Messaggio
ricevuto dal
destinatario
Impronta del
messaggio
UGUALI?
Chiave pubblica
Impronta del
messaggio
Algoritmo di firma
Lato
Destinatario
Firma digitale
ricevuta dal mittente
45
Firmare e verificare
import java.security.Signature;
import java.security.SignatureException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
.....
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
kpg.initialize(1024);
KeyPair keyPair = kpg.genKeyPair();
byte[] messaggio = new String(“Non esistono più le mezze stagioni”).getBytes(“UTF8”);
Signature sig = Signature.getInstance("MD5WithRSA");
sig.initSign(keyPair.getPrivate());
sig.update(messaggio);
byte[] signatureBytes = sig.sign();
.....
sig.initVerify(keyPair.getPublic());
sig.update(messaggio);
Per firmare occorre istanziare
un oggetto Signature
Per firmare si inizializza con la chiave privata
update()
update() passa i dati da firmare
sign()
sign() restituisce i byte della firma digitale
Per la verifica della firma si inizializza con la
chiave pubblica
update()
update() passa i dati da verificare
boolean verified = false;
try { verified = sig.verify(signatureBytes); }
catch (SignatureException se) { System.out.println(“La firma ha un formato non valido!”); }
if (verified) { … } else { … }
SignatureException è lanciata, ad esempio, in caso di perdita
.....
di un byte e non perchè
perchè la verifica ha dato esito negativo
46
RSA e DSA a confronto
¾
Firmare con RSA significa cifrare con la chiave privata e decifrare con
la pubblica
¾
Questa operazione non nasconde i dati (perchè decifrabili attraverso la
chiave pubblica) ma prova l’identità del firmatario
¾
Il DSA (Digital Signature Algorithm) funziona come RSA per la firma
ma non può essere usato per cifrare
¾
Il DSA è più veloce nel generare le firme mentre RSA nel convalidarle
Una firma viene convalidata più spesso di quanto non venga generata
Æ RSA è più veloce per la maggior parte delle applicazioni
47
Identità della chiave pubblica
¾
Per convalidare una firma occorre una chiave pubblica
¾
Ma come essere certi che la chiave pubblica è autentica?
¾
Serve un qualche mezzo per averne la certezza
I CERTIFICATI sono il tentativo di risolvere questo problema
attribuendo l’identità ad una chiave pubblica in modo inconfutabile
¾
Java offre funzionalità di gestione dei certificati attraverso un
set di packages appositamente dedicato
¾
Tale componente prende il nome di Java CertPath
48
JSSE
Java Secure Socket Extension
Caratteristiche
¾
La Java Secure Socket Extensions (JSSE) offre:
z
z
z
¾
funzionalità
funzionalità di autenticazione
protezione dell’
dell’integrità
integrità dei dati
protezione della riservatezza dei dati
Mediante i protocolli per comunicazioni sicure:
z
z
SSL (Secure Socket Layer) v2.0 e v3.0
v3.0
TLS (Transport Layer Security)
Security) v1.0
v1.0
¾
Mentre JCE opera su specifici dati locali, JSSE adotta una differente
astrazione applicando meccanismi crittografici a livello di rete
¾
Le JSSE API contenute in javax.net e javax.net.ssl estendono:
z
z
z
javax.crypto (JCE)
java.security
java.security (JCA)
java.net
java.net
50
Caratteristiche
¾
Le funzionalità crittografiche di JSSE sono implementate dal provider
"SunJSSE“
¾
Il protocollo di applicazione più adoperato con JSSE è HTTP (Hyper Text
Transfer Protocol) che assume la dicitura di HTTPs
¾
Molti altri protocolli possono usufruire di JSSE, come NNTP (Net News
Transfer Protocol), Telnet, LDAP (Lightweight Directory Access
Protocol), IMAP (Interactive Message Access Protocol) ed FTP (File
Transfer Protocol)
¾
Novità di JSSE nella versione integrata:
z
z
Il package javax.security.cert è presente solo per compatibilità
compatibilità con le
applicazioni realizzate con JSSE opzionale. Ad esso è da preferire il package
java.security.cert di CertPath,
CertPath, integrato in J2SE a partire dalla versione 1.4
JSSE può fare uso del provider "SunJCE"
SunJCE" per operazioni di cifratura e
decifrazione
51
Architettura SSL
APPLICAZIONI SSL
A
B
abc
abc
CHANGE CIPHER SPEC
HANDSHAKE
ALERT
JSSE
RECORD
PROTOCOLLI SSL
z6f
z6f
TRASPORTO
TCP
RETE
IP
DATALINK
Ethernet
z6f
TCP
TRASPORTO
IP
RETE
Ethernet
DATALINK
52
Protocollo di Handshake
2. Server hello
3. Certificate (optional)
4. Certificate request (optional)
5. Server key exchange (optional)
6. Server hello done
7. Certificate (optional)
8. Client key exchange
9. Certificate verify (optional)
10. Change cipher spec
11. Finished
14. Encrypted data
SERVER
CLIENT
1. Client hello
12. Change cipher spec
13. Finished
14. Encrypted data
53
Classi principali
¾
Factories SSLServerSocketFactory e SSLSocketFactory per la creazione di
Socket, ServerSocket, SSLSocket, SSLServerSocket con incapsulamento
delle caratteristiche di costruzione e configurazione
(socket factory framework)
¾
Classe SSLContext che agisce da factory per le socket factories e realizza il
concetto di contesto sicuro
¾
Interfacce KeyManager e TrustManager (incluse specifiche X.509) per la
gestione delle chiavi e delle decisioni inerenti la sicurezza
(keystore e truststore)
¾
Factories KeyManagerFactory e TrustManagerFactory
¾
SSLSession per la gestione server di sessioni SSL residenti in memoria
¾
Connessioni sicure con HttpsURLConnection
54
Relationship
Key Material
Key Material
KeyManagerFactory
TrustManagerFactory
KeyManager
TrustManager
Default Context
SecureRandom
SSLContext
SSLSocketFactory
SSLServerSocketFactory
SSLServerSocket
SSLSocket
SSLSocket
SSLSession
55
Creazione di una SSLContext
.....
SSLContext ctx = SSLContext.getInstance
("TLS
TLS","
","SunJSSE
SunJSSE");
");
SSLContext.getInstance("
Creazione di un SSLContext
dal provider SunJSSE con
gestione del protocollo TLS
KeyManagerFactory kmf = KeyManagerFactory.getInstance
("SunX509
SunX509","
","SunJSSE
SunJSSE");
");
KeyManagerFactory.getInstance("
TrustManagerFactory tmf = TrustManagerFactory.getInstance
("SunX509
SunX509","
","SunJSSE
SunJSSE");
");
TrustManagerFactory.getInstance("
SecureRandom random = SecureRandom.getInstance
("SHA1PRNG
SHA1PRNG",
", "Sun
");
SecureRandom.getInstance("
"Sun");
byte seed[]
seed[] = random.generateSeed(20);
random.generateSeed(20);
Creazione di un KeyManagerFactory
random.setSeed(
random.setSeed(seed);
seed);
e TrustManagerFactory con gestione
del protocollo SunX509
KeyStore ks = KeyStore.getInstance
("PKCS12
PKCS12");
");
KeyStore.getInstance("
Creazione di un SecureRandom e
char[]
char[] passphrase = "passphrase
"passphrase"".toCharArray();
.toCharArray();
generazione di un seme di
ks.load(
testkeys"),
"), passphrase);
ks.load(new FileInputStream("
FileInputStream("testkeys
passphrase); inizializzazione mediante l’
l’algoritmo
SHA1PRNG fornito dal provider Sun
Creazione di un KeyStore secondo lo
standard PKCS#12
kmf.init(
kmf.init(ks,
ks,passphrase);
passphrase);
load()
load() per caricamento da file
kmt.init(
kmt.init(ks);
ks);
ctx.init(
ctx.init(kmf.getKeyManagers(),
kmf.getKeyManagers(), kmt.getTrustManagers(),
kmt.getTrustManagers(), random);
random);
.....
Inizializzazione del contesto SSL
56
Creazione di una SSLSession
.....
SSLServerSocketFactory ssf = ctx.getServerSocketFactory();
ctx.getServerSocketFactory();
SSLServerSocket server = ssf.createServerSocket(
ssf.createServerSocket(port);
port);
Creazione di una
SSLServerSocket associata
al contesto di sicurezza
SSlSocketFactory sf = ctx.getSocketFactory();
ctx.getSocketFactory();
SSLSocket client = sf.createServerSocket(
sf.createServerSocket(host,
host, port);
port);
Creazione lato client di una
SSLSocket associata al
contesto di sicurezza legata
alla socket del server
client.addHandshakeCompletedListener(
client.addHandshakeCompletedListener(new HandshakeCompletedListener()
HandshakeCompletedListener() {
public void handshakeCompleted(
handshakeCompleted(HandshakeCompletedEvent event)
event) {...}});
client.startHandshake();
client.startHandshake();
Avvio del protocollo
di Handshake
SSLSession session = client.getSession();
client.getSession();
.....
Gestione dell’
dell’evento di
completamento del
protocollo di Handshake
Recupero della SSLSession
dalla socket delclient
57
“SunJSSE” Provider
¾
Funzionalità crittografiche implementate da JSSE:
ALGORITMO
CRITTOGRAFICO
PROCESSO
CRITTOGRAFICO
LUNGHEZZA CHIAVE
(BITS)
RSA
autenticazione e
scambio della chiave
2048 (autenticazione)
2048 (scambio della chiave)
512 (scambio della chiave)
RC4
cifratura
128
128 (40 effettivi)
DES
cifratura
64 (56 effettivi)
64 (40 effettivi)
TripleDES
cifratura
192 (112 effettivi)
DiffieDiffie-Hellman
scambio della chiave
1024
512
DSA
autenticazione
1024
58
“SunJSSE” Provider
¾
Engine classes della JCA implementate dal provider della JSSE:
ENGINE CLASS
ALGORITMO - PROTOCOLLO
KeyFactory
“RSA”
RSA”
KeyPairGenerator
“RSA”
RSA”
KeyStore
“PKCS12”
PKCS12”
Signature
“MD2withRSA”
MD2withRSA”
Signature
“MD5withRSA”
MD5withRSA”
Signature
“SHA1withRSA”
SHA1withRSA”
KeyManagerFactory
“SunX509”
SunX509”
TrustManagerFactory
“SunX509”
SunX509” - “SunPKIX”
SunPKIX”
SSLContext
“SSL”
SSL”
SSLContext
“SSLv3”
SSLv3”
SSLContext
“TLS”
TLS”
SSLContext
“TLSv1”
TLSv1”
59
Cipher Suites
¾
Cipher suites supportate da "SunJSSE" in ordine di preferenza per default:
CIPHER SUITES
NUOVE IN J2SEv1.4
J2SEv1.4
SSL_RSA_WITH_RC4_128_MD5
SSL_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_AES_128_CBC_SHA
X
TLS_DHE_RSA_WITH_AES_128_CBC_SHA
X
TLS_DHE_DSS_WITH_AES_128_CBC_SHA
X
SSL_RSA_WITH_3DES_EDE_CBC_SHA
SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA
X
SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA
SSL_RSA_WITH_DES_CBC_SHA
SSL_DHE_RSA_WITH_DES_CBC_SHA
X
SSL_DHE_DSS_WITH_DES_CBC_SHA
SSL_RSA_EXPORT_WITH_RC4_40_MD5
SSL_DSS_EXPORT_WITH_DES40_CBC_SHA
X
.....
60
JAAS
Java Authentication
and
Authorization Service
61
Caratteristiche
¾
Java Authentication and Authorization Service (JAAS) offre due servizi:
z
z
¾
autenticazione - identificazione sicura dell’
dell’utente
autorizzazione - verifica dei permessi necessari per le operazioni richieste
Attraverso:
configurazione dinamica dei moduli di login
operazioni di callback
z
controllo degli accessi
z
distribuzione dei permessi
z
Il framework di autenticazione è progettato per essere “pluggable”
pluggable” in base al
modello PAM (Pluggable Authentication Module),
Module), che rende indipendenti le
applicazioni dalle tecnologie di autenticazione sottostanti come:
come:
verifica di username e password
z
verifica di caratteristiche biometriche (voce, impronte digitali, ...)
z
Inoltre JAAS supporta lo stacking dei moduli di autenticazione
Il componente JAAS per le autorizzazioni opera in congiunzione con
con il modello
Java per il controllo degli accessi a risorse sensibili (Java Security Framework)
Framework)
z
¾
¾
¾
62
Classi principali
¾
Le JAAS APIs sono contenute nel set di packages javax.security.auth:
Identificazione
z
z
z
Subject – sorgente di richiesta di autenticazione nell’
nell’accesso ad una risorsa
Principal – interfaccia che rappresenta l’
l’identità
identità di un Subject se l’
l’autenticazione ha successo
Refreshable / Destroyable – interfacce che esprimono la capacità
capacità di refresh e di reset delle
credenziali associate ad un Subject
Autenticazione
z
z
z
z
LoginModule – interfaccia per l'implementazione delle diverse tecnologie di autenticazione
autenticazione
LoginContext – offre i metodi per autenticare un Subject e determinare i servizi di
autenticazione o i LoginModules
LoginModules configurati per l’
l’applicazione
CallbackHandler – interfaccia implementata dall’
dall’applicazione e passata al LoginContext,
LoginContext,
attraverso la quale i LoginModules
LoginModules comunicano bidirezionalmente con gli utenti
Callback – package che offre diverse implementazioni da usare mediante CallbackHandler
Autorizzazione
z
z
z
z
Policy – classe astratta per definire le politiche di accesso al sistema
AuthPermission – incapsula i permessi di base richiesti in JAAS per l'autenticazione
l'autenticazione
Configuration - rappresenta la configurazione di un LoginModule
PrivateCredentialPermission – protegge l’
l’accesso alle credenziali di un Subject privato
63
Identificazione
¾
Un Subject contiene tre tipologie di informazioni per l'identificazione:
z
z
z
¾
Implementazioni dell'interfaccia Principal sono le seguenti classi:
z
z
z
¾
Identities - nella forma di uno o più
più Principals
Principals
Public credentials - come nome e chiavi pubbliche
Private credentials - come password e chiavi private
java.security.Identity
javax.security.auth.kerberos.KerberosPrincipal
javax.security.auth.x500.X500Principal
Qualsiasi Object può rappresentare una credential pubblica o privata
Subject subject;
Principal principal;
Object credential;
subject.getPrincipals().add(principal);
subject.getPublicCredentials().add(credential);
subject.getPrivateCredentials().add(credential);
64
Login Modules
¾
¾
Per costruire un modulo di autenticazione personalizzato occorre
implementare l'interfaccia LoginModule
J2SE 1.4 mette a disposizione un set di LoginModules ready-to-use:
z
z
z
z
¾
¾
JndiLoginModule - login con un directory service configurato sotto JNDI (Java
Naming and Directory Interface)
Krb5LoginModule - login con i protocolli di Kerberos v5
NTLoginModule - login con le informazioni di current user in NT
UnixLoginModule - login con le informazioni di current user in UNIX
In com.sun.security.auth sono disponibili alcune relative implementazioni
dell'interfaccia Principal, come NTDomainPrincipal e UnixPrincipal
La classe LoginContext carica
Application {
dinamicamente la configurazione
ModuleClass Flag ModuleOptions;
ModuleClass Flag ModuleOptions;
di un modulo di login da un file
.....
di testo con la seguente struttura:
};
Application { ..... };
.....
65
Callbacks e CallbackHandlers
¾
¾
¾
CallbackHandlers e Callbacks raccolgono le informazioni necessarie per
l'autenticazione di un utente o un sistema
Rendono indipendenti i LoginModules dai meccanismi di interazione
J2SE 1.4 mette a disposizione due CallbackHandlers all'interno del package
com.sun.security.auth.callback:
DialogCallbackHandler
TextCallbackHandler
¾
Sette Callbacks, presenti in javax.security.auth.callback, sono implementate
da JAAS e possono essere adoperate per realizzare CallbackHandlers
personalizzati:
ChoiceCallback
LocaleCallback
PasswordCallback
TextOutputCallback
ConfirmationCallback
NameCallback
TextInputCallback
66
Esempio
Applicazione client
.....
MyCallbackHandler handler = new MyCallbackHandler()
MyCallbackHandler()
LoginContext lc = new LoginContext("
Example",
", handler);
LoginContext("Example
handler);
lc.login();
lc.login();
.....
File di configurazione JAAS - "jaas.config"
jaas.config"
Example {
RdbmsLoginModule required
debug="true
debug="true""
url="jdbc
localhost/JAAS"
/JAAS"
url="jdbc::mysql://
mysql://localhost
driver="
driver="gwe.sql.gweMysqlDriver";
gwe.sql.gweMysqlDriver";
};
Esecuzione con impostazione della javax.security.auth.login.config
java -Djavax.security.auth.login.config = jaas.config MyApp"
MyApp"
67
Pluggable Authentication
APPLICAZIONI
Configuration
File
Login Context API
Login Module SPI
.....
UnixLoginModule
Krb5LoginModule
NTLoginModule
JndiLoginModule
LDAP Server
Unix
Authentication
NT
Authentication
Kerberos
Authentication
Web Service
RDBMS
Smart Card
Authentication
Biometric
Authentication
Security & Authentication Services
68
Processo di Autenticazione
APPLICAZIONE
Creazione di un LoginContext per il processo di autenticazione
LoginContext consulta le configurazioni di login (ConfigFile)
ConfigFile) per caricare tutti
i LoginModules
LoginModules configurati per l’
l’applicazione
Invocazione del metodo login()
login() di LoginContext
Il metodo login()
login() invoca tutti i LoginModules
LoginModules caricati, che interagiscono con
l'utente o il sistema da autenticare mediante il CallbackHandler
Ogni LoginModule associa Principals
Principals e Credentials al Subject autenticato
LoginContext restituisce all’
all’applicazione lo stato dell’
dell’autenticazione
Se l’
l’autenticazione ha avuto successo l’
l’applicazione recupera il Subject dal
LoginContext popolato di Principals
Principals e Credentials
69
Controllo degli Accessi
¾
¾
¾
¾
¾
JAAS offre a tempo di esecuzione rinforza il controllo degli accessi ad un
sistema
La classe SecurityManager viene consultata ogni volta che una operazione
sensibile debba essere effettuata
Il SecurityManager a sua volta delega la responsabilità del controllo ad un
AccessController
L'AccessController si procura una immagine dell'AccessControlContext
corrente e verifica se si hanno i permessi necessari per l'operazione richiesta
JAAS offre due metodi che permettono di associare dinamicamente un
Subject autenticato con il thread AccessControlContext corrente:
z
z
¾
Subject.doAs()
Subject.doAs()
Subject.doAsPrivileged()
Subject.doAsPrivileged()
Dopo l'associazione ed il controllo dei permessi viene eseguita o meno
l'operazione richiesta a seconda delle autorizzazioni concesse
70
CertPath
Java Certification Path
71
Caratteristiche
¾
¾
Java Certification Path (CertPath) offre interfacce
ed engine classes per gestire certificati e certification
paths, ovvero liste ordinate di certificati derivanti
da una gerarchia di Certification Authority (CA)
Le funzionalità offerte possono essere suddivise
in quattro categorie:
z
Basic Certification Path
• CertPath,
CertPath, CertificateFactory,
CertificateFactory, CertPathParameters
z
Certification Path Validation
Gerarchia di CA
• CertPathValidator,
CertPathValidator, CertPathValidatorResult
z
Certification Path Building
• CertPathBuilder,
CertPathBuilder, CertPathBuilderResult
z
Certificate/CRL Storage
• CertStore,
CertStore, CertStoreParameters,
CertStoreParameters, CertSelector,
CertSelector, CRLSelector
¾
CertPath offre inoltre la possibilità di costruire e validare certification
paths X.509 secondo gli standards PKIX
72
Core Classes
• Le principali CertPath APIs sono contenute in java.security.cert:
z
z
z
z
z
z
z
z
z
z
z
z
CertPath –definisce le funzionalità
funzionalità comuni per un certification path
CertificateFactory –definisce funzionalità
funzionalità di una factory di certificati
CertPathParameters – interfaccia per la rappresentazione trasparente del set di
parametri usati con un particolare CertPathBuilder o con un algoritmo
algoritmo di validazione
CertPathValidator –valida un certification path
CertPathValidatorResult – interfaccia per la rappresentazione trasparente del risultato
favorevole o dell’
dell’output di un algoritmo di validazione di una lista di certicati
CertPathBuilder –costruisce un certification path
CertPathBuilderResult – interfaccia per la rappresentazione trasparente del risultato o
dell’
dell’output di un algoritmo di costruzione di un certification path
CertStore –fornisce le funzionalità
funzionalità di deposito di una CRL
CertStoreParameters – rappresentazione trasparente del set di parametri usati con un
particolare CertStore (LDAPCertStoreParameters
(LDAPCertStoreParameters,, CollectionCertStoreParameters)
CollectionCertStoreParameters)
CertSelector / CRLSelector – interfacce per la specifica dell’
dell’insieme di criteri adottati
per selezionare certificati e CRLs da una collezione di certificati
certificati o di CRLs
X509Certificate / X509CertSelector - gestiscono certificati X.509
X.509
X509CRL / X509CRLEntry / X509CRLSelector - gestiscono CRL
73
PKIX Classes
¾
Le classi più importanti inerenti gli standard PKIX sono le seguenti:
z
z
z
TrustAnchor - rappresenta una "most
"most--trusted"
trusted" CA usata come root nella
validazione di certification paths (non modificabile e threadthread-safe)
safe)
PKIXParameters - specifica il set di parametri di ingresso per l'algoritmo PKIX
di validazione di certification paths
PKIXCertPathValidatorResult - rappresenta il risultato di una validazione
z
PolicyNode - interfaccia che rappresenta un nodo di un albero di policy
risultante da un algoritmo di validazione eseguito con successo
PolicyQualifierInfo - rappesenta il policy qualifier contenuto nella Certificate
Policy Extension del certificato a cui la policy fa riferimento
PKIXBuilderParameters - specifica il set di parametri di ingresso per
l'algoritmo PKIX di costruzione di certification paths
PKIXCertPathBuilderResult - rappresenta il risultato di una costruzione
z
PKIXCertPathChecker - permette di eseguire controlli su certificati X.509
X.509
z
z
z
74
CertPath Architecture
APPLICAZIONI
API
Java Certification Path
CertificateFactory
CertPath
CertPathParameters
CertPathValidatorResult
CertPathBuilderResult
CertStoreParameters
LDAPCertStoreParameters
CollectionCertStoreParameters
X509CertSelector
X509CRLEntry
CORE
CertPathValidator
CertPathBuilder
CertStore
CertSelector
CRLSelector
X509Certificate
X509CRL
X509CRLSelector
PKIX
TrustAnchor
PKIXParameters
PKIXCertPathValidatorResult
PolicyNode
PolicyQualifierInfo
PKIXBuilderParameters
PKIXCertPathBuilderResult
PKIXCertPathChecker
SPI
X.509 Provider
PKIX Provider
75
Certificati digitali
Un certificato digitale è la garanzia fornita da una terza
parte che una chiave pubblica appartiene al suo proprietario
¾
Questa terza parte è detta Certification Authority (CA)
¾
Le due CA più note sono Verisign e Thawte (in realtà una filiale di Verisign)
z
Per l’
l’elenco dei certificatori attivi in Italia visitare il sito del Centro Nazionale
per l’
l’Informatica nella Pubblica Amministrazione (www.cnipa.gov.it
(www.cnipa.gov.it))
¾
La CA certifica una chiave pubblica firmandola con la sua chiave privata
¾
Per default, il JDK utilizza i certificati X.509:
z
z
z
z
Sono gli standard maggiormente utilizzati per i certificati digitali.
digitali.
Sono definiti in RFC 2459 reperibile all’
/rfc2459.txt..
all’indirizzo www.ietf.org/rfc
www.ietf.org/rfc/rfc2459.txt
Esistono 3 versioni di X.509
X.509:: v1,v2 e v3.
v2 e v3 aggiungono ai certificati alcune informazioni supplementari
76
Contenuto dei certificati
¾
Certificato X.509 v1:
z
Versione
• definisce la versione del certificato: v1,v2,v3
z
Numero seriale del certificato
• intero univoco che identifica la CA che emette il certificato
z
Identificatore dell’
dell’algoritmo di firma
• definisce l’
l’algoritmo di firma usato dalla CA
z
Periodo di validità
validità
• definisce il periodo di tempo per cui è valido il certificato.
• si usano 2 date: non prima e non dopo
• il certificato è valido solo nell’
nell’intervallo
z
Soggetto
• indica a chi è stato emesso il certificato
• i soggetti sono memorizzati con nomi X.500
X.500
z
z
Chiave pubblica del soggetto
Firma dell’
dell’Autorità
Autorità di certificazione
77
Esempio in Windows
78
Stampa di un certificato DER
Il certificato deve essere in
formato DER (Distinguished
Encoding Rules)
ules) (estensione .cer)
.cer)
Un solo certificato per file
import java.io.*;
java.io.*;
import java.security.cert.*;
java.security.cert.*;
.....
Occorre aprire il
String nameCert = “File_Certificate.cer";
File_Certificate.cer";
relativo file ed
FileInputStream fis = new FileInputStream(
FileInputStream(nameCert);
nameCert);
istanziare un
CertificateFactory cf = CertificateFactory.getInstance
("X
X.509");
CertificateFactory.getInstance("
.509");
certificato con
X509Certificate x509cert = (X509Certificate
(X509Certificate))cf.generateCertificate(
cf.generateCertificate(fis);
fis);
CertificateFactory
System.out.println
("\\nInformazioni reperite dal certificato: “ +nameCert+"\
System.out.println("
+nameCert+"\n"); inizializzato allo
standard X.509
("tipo
tipo = " + x509cert.getType());
System.out.println
System.out.println("
generateCertificate()
generateCertificate()
System.out.println
("versione
versione = " + x509cert.getVersion());
System.out.println("
richiede
un cast
System.out.println("
soggetto = " + x509cert.getSubjectDN().getName
());
System.out.println("soggetto
x509cert.getSubjectDN().getName());
perchè
perchè restituisce
System.out.println
("inizio
inizio validità
System.out.println("
validità = " + x509cert.getNotBefore());
un Certificate
System.out.println
.out.println("
("fine
fine
validità
System
validità = " + x509cert.getNotAfter());
System.out.println
("numero
numero di serie = " + x509cert.getSerialNumber().toString
(16));
System.out.println("
x509cert.getSerialNumber().toString(16));
System.out.println
("emettitore
emettitore = " + x509cert.getIssuerDN().getName
());
System.out.println("
x509cert.getIssuerDN().getName());
System.out.println
.out.println("
("algoritmo
algoritmo
di
firma
=
"
+
x509cert.getSigAlgName());
System
algoritmo per la chiave pubblica = " +
System.out.println
("algoritmo
System.out.println("
x509cert.getPublicKey().getAlgorithm
());
x509cert.getPublicKey().getAlgorithm());
fis.close();
();
fis.close
.....
79
Certificate Revocation List (CRL)
import java.io.*;
java.io.*;
import java.security.cert.*;
java.security.cert.*;
.....
Il file deve contenere una
CRL (estensione .crl)
.crl)
String nameCRL = “File_CRL.crl";
File_CRL.crl";
String nameCert = “File_Certificate.cer";
File_Certificate.cer";
FileInputStream inCRL = new FileInputStream(
FileInputStream(nameCRL);
nameCRL);
FileInputStream inCert = new FileInputStream(
FileInputStream(nameCert);
nameCert);
Creazione di una
CRL di X.509
CertificateFactory cf = CertificateFactory.getInstance
("X
X.509");
CertificateFactory.getInstance("
.509");
X509CRL crl = (X509CRL
inCRL);
(X509CRL))cf.generateCRL(
cf.generateCRL(inCRL);
Certificate certificate = cf.generateCertificate(
cf.generateCertificate(inCert);
inCert);
inCRL.close();
inCRL.close();
inCert.close();
inCert.close();
Verifica del cetificato
attraverso il metodo
isRevoked()
isRevoked()
if (crl.isRevoked(certificate))
("Il
Il certificato è stato revocato!");
crl.isRevoked(certificate)) System.out.println
System.out.println("
revocato!");
else System.out.println
("Il
Il certificato "+nameCert+" e' ok!
System.out.println("
ok!");
.....
80
Esempio di Certification Path
¾
CertPath Root della Digital Signature Trust (DST Root Cert.p7b):
81
Stampa di un certification path
import java.io.*;
java.io.*;
import java.security.cert.*;
java.security.cert.*;
import java.util.Collection;
java.util.Collection;
import java.util.Iterator;
java.util.Iterator;
.....
String nameCert = “File_Certificates.p7b";
File_Certificates.p7b";
Il file deve contenere una catena
di certificati in formato PKCS#7
(estensione .p7b)
.p7b) o una sequenza
di certificati di formato DER
(estensione .cer)
.cer)
FileInputStream fis = new FileInputStream(
FileInputStream(nameCert);
nameCert);
CertificateFactory cf = CertificateFactory.getInstance
("X
X.509");
CertificateFactory.getInstance("
.509");
Collection c = cf.generateCertificates(
cf.generateCertificates(fis);
fis);
Iterator per navigare
Iterator it = c.iterator();
c.iterator();
all’
all’interno della
int j = 1;
collezione di certificati
while (it.hasNext())
it.hasNext()) {
System.out.println
("certificato
certificato N°."+j+ ":
System.out.println("
": ");
X509Certificate x509cert = (X509Certificate
(X509Certificate))it.next();
it.next();
System.out.println
(x509cert);
System.out.println(x509cert);
j++;
Stampa a video usando la
}
toString()
toString() di X509Certificate
fis.close();
fis.close();
.....
Tutto funziona correttamente solo
se l’
l’InputStream utilizzato
supporta i metodi mark()
mark() e reset()
In caso contrario
generateCertificates()
,che si avvale
generateCertificates(),che
di tali metodi, consumerà
consumerà tutto lo
stream di ingresso in un colpo solo
I vari certificati vengono inseriti in
una Collection
82
Schema di Validazione
Java Certification Path
Issuer:
Issuer: CA2
Issuer:
Issuer: CA1
Subject:
Subject: Bob
Subject:
Subject: CA2
Bob
Public Key
CA2
Public Key
CertificateFactory
VALID
CertPathValidator
INVALID
PKIX Provider
Trust
Anchor
KeyStore
CRLs
CertStore
X.509 Provider
83
Processo di validazione
Istanziaziare un TrustAnchor
import java.security.cert.*;
java.security.cert.*;
da un certificato root
.....
TrustAnchor anchor = new TrustAnchor(
TrustAnchor(“DST Root CA X1.cer”
X1.cer”, null);
null);
Set anchors = Collections.singleton
Collections.singleton((anchor);
anchor);
PKIXParameters params = new PKIXParameters(
PKIXParameters(anchors);
anchors);
params.setRevocationEnabled(false);
params.setRevocationEnabled(false);
Inserire le informazioni
contenute nel TrustAnchor
in un PKIXParameters
Indicare se usare un PKIX Revocation
Checking Mechanism (in tal caso
occorrerà
occorrerà specificare una CRL ed un
PKIXCertPathChecker)
PKIXCertPathChecker)
CertificateFactory cf = CertificateFactory.getInstance
("X
X.509");
CertificateFactory.getInstance("
.509");
FileInputStream inCertPath = new FileInputStream(
Cert.p7b”);
FileInputStream(“DST Root Cert.p7b”
CertPath co = cf.generateCertPath(
cf.generateCertPath(inCertPath);
inCertPath);
Istanziare il CertPath
da validare
CertPathValidator cpv = CertPathValidator.getInstance
("PKIX
PKIX");
");
CertPathValidator.getInstance("
CertPathValidatorResult cpvr = cpv.validate(
cpv.validate(cp,
cp, params);
params);
.....
Eseguire la
validazione attraverso
un CertPathValidator
84
JGSS
Java Generic Security Service
85
Caratteristiche
¾
¾
¾
¾
Java Generic Security Service (JGSS) contiene le Java bindings per la
Generic Security Services Application Program Interface (GSS-API)
Le GSS-API sono state progettate dal Common Authentication Technology
working group dell'IETF per offrire un accesso uniforme a servizi di
autenticazione e comunicazione peer-to-peer che adottano meccanismi di
sicurezza sottostanti, isolando il chiamante dai dettagli implementativi
Tali meccanismi di sicurezza possono essere impiegati in maniera
simultanea e selezionati dall'applicazione a tempo di esecuzione
Le GSS-API offrono i seguenti servizi di sicurezza:
z
z
z
z
z
autenticazione
riservatezza ed integrità
integrità dei messaggi
sequencing dei messaggi protetti
replay detection
credential delegation
86
Meccanismi di sicurezza
¾
IETF ha definito i seguenti due meccanismi di sicurezza:
z
z
¾
Kerberos v5
Simple Public Key Mechanism (SPKM)
Altra tecnologia utilizzata è DCE (Distributed Computing Environment)
APPLICAZIONE CLIENT
APPLICAZIONE SERVER
GSSGSS-API FRAMEWORK
GSSGSS-API FRAMEWORK
Kerberos
Mechanism
SPKM
Mechanism
Kerberos
Mechanism
SPKM
Mechanism
DCE
Mechanism
DCE
Mechanism
87
Kerberos v5 in JGSS
¾
¾
JGSS offre la possibilità di implementare il servizio Kerberos v5 con
l’ausilio dei meccanismi offerti da JAAS
Classi principali in JGSS:
z
z
z
z
z
la classe GSSManager conosce i componenti e i meccanismi di sicurezza
sottostanti ed è responsabile della loro invocazione a runrun-time
la classe Oid rappresenta l’
l’Universal Object Identifier
l'interfaccia GSSName rappresenta una entità
entità generica da instanziare e
permette di definire l'user
l'user duke del servizio sicuro implementato
l'interfaccia GSSCredential incapsula le credentials possedute da un'entità
un'entità
l'interfaccia GSSContext permette di definire i servizi di sicurezza offerti alle
applicazioni comunicanti
Meccanismi
di sicurezza
GSSManager
Oid
GSSName
GSSContext
GSSCredential
Applicazione
GSSGSS-API Framework
88
Kerberos v5 in JAAS
¾
JAAS mette a disposizione degli sviluppatori il modulo di autenticazione
Krb5LoginModule e le classi del package javax.security.auth.kerberos:
z
z
z
z
z
DelegationPermission - usata per limitare l'uso del Kerberos delegation model
(forwardable and proxiable tickets)
tickets)
KerberosKey - incapsula un segreto a lungo termine per un Kerberos principal
KerberosPrincipal - incapsula un Kerberos principal
KerberosTicket - incapsula un Kerberos ticket e le informazioni ad esso
associate dal punto di vista del cliente. Racchiude tutte le informazioni
informazioni che il
Key Distribution Center (KDC) invia al client nel messaggio di risposta
KDCKDC-REP definito in Kerberos Protocol Specification (RFC 1510)
1510)
ServicePermission - usata per proteggere i servizi Kerberos e le credenziali
necessarie per accedere a questi servizi. Contiene un service principal name e
una lista di operazioni che specificano il contesto in cui le credenziali
credenziali possono
essere usate
89
JGSS vs JSSE
¾
JGSS e JSSE presentano alcune analogie in termini di strumenti per
comunicazioni sicure peer-to-peer
¾
Sono accomunati dalle seguenti caratteristiche di sicurezza:
z
z
¾
autenticazione client/server
client/server
protezione della riservatezza e dell’
dell’integrità
integrità dei dati trasmessi
Si differenziano per i seguenti aspetti:
z
z
z
z
z
Kerberos Single SignSign-On Support
Communications API
Credential Delegation
Selective Encryption
Protocol Requirements
( When to use Java GSSGSS-API vs. JSSE )
90
Kerberos v5 in J2SE
APPLICAZIONI
JAAS
javax.security.auth
JGSS
org.ietf.jgss
JSSE
javax.net.ssl
KRB5
LoginModule
KRB5
Mechanism
KRB5
CipherSuite
KRB5
Implementation
Credentials
Cache
JCA & JCE
91
Autenticazione
¾
¾
Prima che un GSSContext possa essere usato per i servizi di sicurezza
offerti, occorre realizzare uno scambio di token per l'autenticazione tra le
applicazioni comunicanti
GSSContext offre i metodi necessari a tale scambio:
z
z
¾
initSecContext() - invia il token all'applicazione paritaria
acceptSecContext() - riceve il token
Autenticazione in Kerberos V5:
z
z
z
z
Il client per primo invia il token costruito con initSecContext()
initSecContext() contenente il
messaggio APAP-REQ di Kerberos
Il provider Kerberos ottiene dal TGT (Kerberos
(Kerberos Ticket) del client un ticket di
servizio per il target server, che viene cifrato ed inserito nel messaggio
Il server riceve il token e lo decifra con il metodo acceptSecContext() che
autentica il client generando un nuovo token
In caso di autenticazione mutua, il nuovo token viene adoperato per
l'autenticazione del server e rispedito al client con initSecContext()
initSecContext()
92
Protezione dei messaggi
¾
¾
Il contesto sicuro stabilito (GSSContext) offre protezione delle
comunicazioni mediante riservatezza ed integrità dei messaggi
I metodi relativi sono:
z
z
¾
wrap() - permette di incapsulare il testo in chiaro o cifrato in un token che ne
protegge l'integrità
l'integrità, da inviare all'applicazione paritaria
unwrap() - rimette in chiaro il testo originario dal token ricevuto
L'oggetto trasmesso contiene informazioni sul testo originario (se in chiaro
o cifrato) e relativi warnings per il controllo del sequencing e della
duplicazione dei messaggi
93
Credential Delegation
¾
¾
¾
Java GSS-API aiuta il client a comunicare in maniera sicura le proprie
credenziali al server e realizzare un nuovo contesto sicuro
Nel caso di Kerberos V5, le credenziali delegate sono rappresentate da un
forwarded TGT incapsulato nel primo token spedito dal client al server
Usando questo TGT il server può ottenere un ticket service legato al client
per alcuni altri servizi
Client
Delegates
credentials
of user duke
Gateway
Backend
Server
ENTERPRISE NETWORK
94
Default Credential Acquisition Model
Invocazione del metodo di login del modulo JAAS Kbr5LoginModule
Krb5LoginModule ottiene un TGT per il client dal KDC o da una cache preesistente e lo
memorizza nel private credentials set del Subject.
Subject. Sul lato server Kbr5LoginModule
memorizza nel Subject,
Subject, accanto al KerberosTicket,
KerberosTicket, una KerberosKey per il server,
adoperata nei passi 55-6-7 per decifrare il ticket service che il client invia
Il client riceve il Subject popolato e invoca il metodo Subject.doAs()
Subject.doAs() o il metodo
Subject.doAsPrivileged()
Subject.doAsPrivileged() per inserire il Subject nel contesto di controllo d'accesso del thread
ClientAction in esecuzione
ClientAction invoca il metodo GSSContext.createCredential()
GSSContext.createCredential() passando il Kerberos V5 OID
(unique object identifier)
identifier) in desiredMechs
GSSContext.createCredential()
GSSContext.createCredential() invoca il provider di Kerberos V5 richiedendo una Kerberos
credential per iniziare un contesto sicuro
Il provider ottiene il Subject dal corrente contesto di controllo degli accessi e ricerca il suo
suo
private credential set per un valido KerberosTicket (TGT) per l'utente
Il KerberosTicket viene fornito al GSSManager che lo memorizza in un GSSCredential da
restituire al chiamante
95
PKCS
Public Key Cryptography
Standards
96
Public Key Cryptography
Standards (PKCS)
¾
¾
¾
¾
Le specifiche PKCS sono state prodotte dagli RSA Laboratories
con lo scopo di accelerare lo sviluppo della crittografia a chiave pubblica
Pubblicate nel 1991, sono state largamente implementate ed integrate
in molti standard de facto, come ANSI X9, PKIX, SET, S/MIME e SSL
JCA e JCE implementano gli standards PKCS #1, #5, #7, #8, #9, #10 e #12
J2SDK 1.4 Beta 3 include un miglior supporto per gli standard PKCS 1.0
con un set di APIs contenuto in JSR (Java Specification Request) 74:
javax.security.pkcs.pkcs1
javax.security.pkcs.pkcs7
javax.security.pkcs.pkcs9
javax.security.pkcs.pkcs12
¾
javax.security.pkcs.pkcs5
javax.security.pkcs.pkcs8
javax.security.pkcs.pkcs10
La versione PKCS 2.1 presenta diversi miglioramenti che saranno
implementati ed aggiunti in JSR 74 nel corrente anno
97
PKCS Architecture
APPLICAZIONI
• PKCS #1 – RSA Cryptography Standard
• PKCS #5 – PasswordPassword-Based Cryptography Standard
• PKCS #7 – Cryptographic Message Syntax
• PKCS #8 – PrivatePrivate-Key Information Syntax
• PKCS #9 – Selected Attributes Types
• PKCS #10 – Certificate Request Syntax
• PKCS #12 – Personal Information Exchange Syntax
JCA & JCE
PKCS #2 - incorporato in PKCS #1
PKCS #3 - DiffieDiffie-Hellman Key Agreement Standard
PKCS #4 - incorporato in PKCS #1
PKCS #6 - ExtendedExtended-Certificate Syntax Standard
PKCS #11 - Cryptographic Token Interface Standard
PKCS #13 - Elliptic Curve Cryptography Standard
PKCS #15 - Cryptographic Token Information Format Standard
98
Java Keytool
Key and Certificate
Management Tool
Key Pair Generating
¾ Generazione di una coppia di chiavi asimmetriche e inserimento dei dati
identificativi dell'utente:
keytool -genkey -keystore keystore -keyalg rsa –keysize 1024 -alias mauz -validity 180
Immettere la password del keystore:
keystore: 20Colleluori03Maurizio1980
Specificare nome e cognome [Unknown]: Maurizio Colleluori
Specificare il nome dell’
]: MM
dell’unità
unità aziendale [Unknown
[Unknown]:
Specificare il nome dell’
dell’azienda [Unknown]: Mauz
Specificare la località
località [Unknown]: Bologna
Specificare la provincia [Unknown]: Bologna
Specificare il codice a due lettere del apese in cui si trova l’
l’unità
unità [Unknown]: IT
Il dato CN=Maurizio Colleluori, MM, O=Mauz, L=Bologna, ST=Bologna,
ST=Bologna, C=IT
è corretto? [no]: si
Immettere la password della chiave per <mauz>
(INVIO se corrisponde alla password del keystore):
keystore): 20031980
Le chiavi private hanno associato un certificato che autentica le
le corrispondenti chiavi pubbliche
L’accesso ad un keystore è protetto da una password definita al momento della sua creazione
creazione
Si può decidere di proteggere la chiave privata con una password differente
differente
100
Certificate Signing Request
¾ Produzione della richiesta di certificato (Certificate Signing Request)
auto-firma del certificato provvisorio con la chiave privata:
keytool -certreq -keystore keystore -file csr.txt -alias mauz
Immettere la password del keystore:
keystore: 20Colleluori03Maurizio1980
Immettere la password della chiave per <mauz>: 20031980
Richiesta per
ogni accesso
al keystore!
File csr.txt
Richiesta per
-----BEGIN
-----BEGIN NEW CERTIFICATE REQUEST----REQUEST----ogni accesso alla
MIIBqzCCARQCAQAwazELMAkGA1UEBhMCSVQxEDAOBgNVBAgTB0JvbG9nbmExEDAOBgNVBAcTB0Jv
MIIBqzCCARQCAQAwazELMAkGA1UEBhMCSVQxEDAOBgNVBAgTB0JvbG9nbmExEDAO
chiave segreta!BgNVBAcTB0Jv
bG9nbmExDTALBgNVBAoTBE1hdXoxCzAJBgNVBAsTAk1NMRwwGgYDVQQDExNNYXVyaXppbyBDb2xs
bG9nbmExDTALBgNVBAoTBE1hdXoxCzAJBgNVBAsTAk1NMRwwGgYDVQQDExNNYXVyaXppbyBDb2xs
ZWx1b3JpMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD0qUrx5YEOwgHlufHMmB1QEJ4FQj4d
ZWx1b3JpMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQD0qUrx5YEOwgHlufHMmB1QEJ4FQj4d
0kY4JVPzXNBTByYis9QXLDyKL9nFso8/qMxMesu0UAEKZJsLvNX8vOMv7dcudsfuLzWXqrbvyiC1
0kY4JVPzXNBTByYis9QXLDyKL9nFso8/qMxMesu0UAEKZJsLvNX8vOMv7dcudsfuLzWXqrbvyiC1
Q5wxtXdYi3Rx5l7txAbbbVcpj9BMX6lLOz7wpxcmJzv/Y7gVlo5aclnfpOQopzxRewIDAQABoAAw
Q5wxtXdYi3Rx5l7txAbbbVcpj9BMX6lLOz7wpxcmJzv/Y7gVlo5aclnfpOQopzxRewIDAQABoAAw
DQYJKoZIhvcNAQEEBQADgYEA1hDqkWAttZEzNHAEncUodsUr0Ak8pfKhhw+BL4gmOkPo78jdqCaP
DQYJKoZIhvcNAQEEBQADgYEA1hDqkWAttZEzNHAEncUodsUr0Ak8pfKhhw+BL4gmOkPo78jdqCaP
o1QIsX6KOB0X9s/+2MbWH3nVlVZP4HyQ8bv8xbDs6cY3m+adN7I01+7UHIiWqIUV2WKKmBGZSaQ+
o1QIsX6KOB0X9s/+2MbWH3nVlVZP4HyQ8bv8xbDs6cY3m+adN7I01+7UHIiWqIUV2WKKmBGZSaQ+
gPNM/oV7dMZcH8mXr9zQObPqcHKqBDNjqtQC0IhE21o=
gPNM/oV7dMZcH8mXr9zQObPqcHKqBDNjqtQC0IhE21o=
-----END
-----END NEW CERTIFICATE REQUEST----REQUEST-----
101
Self Certificate
¾
Generare un certificato X.509 auto-firmato:
keytool -selfcert -keystore keystore -keyalg rsa –keysize 1024 -alias mauz -validity 180
102
Altre funzionalità
¾
Download del certificato firmato dalla CA (estensione .cer secondo il
formato PKCS7) e aggiornamento del certificato provvisorio auto-fimato:
keytool -import -keystore keystore -file file.cer
file.cer -alias mauz
¾
Esportazione di un certificato in un file esterno:
keytool -import -keystore keystore -file file.cer
file.cer -alias mauz
¾
Visualizzazione di una entry del keystore:
keytool -list -keystore keystore -alias mauz
¾
Lettura di un file.cer:
keytool -printcert -file file.cer
file.cer
¾
Altre utilità:
keytool -keyclone ...
keytool -storepasswd ...
keytool -keypasswd ...
keytool -delete ...
clonazione di una entry del keystore
modifica della password del keystore
modifica della password della chiave privata
cancellazione di una entry del keystore
103
Java Security
Roadmap
104
Java Security Roadmap
APPLICATIONS - TOOLS - GUI
java.security
java.security
CertPath
JSSE
JGSS
JAAS
Provider
Provider
PKCS
JCA / JCE Framework
Provider
Provider
105
Riferimenti
106
Java General Security
¾
http://java.sun.com/j2se/1.4.1/docs/guide/security/
z
General Security
•
•
•
•
•
•
•
•
Security Architecture
Cryptography Architecture
How to Implement a Provider for the Java Cryptography Architecture
Architecture
Policy Permissions
Default Policy Implementation and Policy File Syntax
API for Privileged Blocks
X.509 Certificates and Certificate Revocation Lists
Security Managers and the JavaTM 2 SDK
107
Java Security Features
¾
http://java.sun.com/j2se/1.4.1/docs/guide/security/
z
JCE
• JCE Reference Guide
• How to Implement a Provider for the Java Cryptography Extension
z
JSSE
• JSSE Reference Guide
z
JAAS
•
•
•
•
z
JAAS Reference Guide
JAAS Tutorials.
Tutorials.
JAAS white paper
JAAS LoginModule Developer's
Developer's Guide
Certification Path
• Java Certification Path API Programmer's
Programmer's Guide
z
Java GSSGSS-API
• Java GSSGSS-API and JAAS Tutorials for Use with Kerberos.
Kerberos.
• Single SignSign-on Using Kerberos in Java
z
Tools
• Security Tools
108
Applicazioni
¾
JSSE
z
z
z
z
¾
JAAS
z
¾
RMI – SOCKETS – URLS
http://java.sun.com/j2se/1.4.2/docs/guide/security/jsse/samples/index.html
http://java.sun.com/j2se/1.4.2/docs/guide/security/jsse/samples/index.html
SSL CLIENT / SERVER
http://www.javaworld.com/javaworld
/jw--05http://www.javaworld.com/javaworld/jw
05-2001/jw2001/jw-05110511-howto.html
HTTPS
http://www.javaworld.com/javaworld
http://www.javaworld.com/javaworld//javatips/jw
javatips/jw--javatip111.html
SECURE MAIL
http://www.javaworld.com/javaworld/javatips/jwhttp://www.javaworld.com/javaworld/javatips/jw-javatip115.html
http://www.javaworld.com/javaworld/jwhttp://www.javaworld.com/javaworld/jw-0909-2002/jw2002/jw-09130913-jaas.html
Keytool
z
http://java.sun.com
docs//tooldocs/win32/
keytool.html
http://java.sun.com//products/
products/jdk/1.2/
jdk/1.2/docs
tooldocs/win32/keytool.html
109
Standards
¾
Public Key Cryptography Standards (PKCS)
http://www.rsasecurity.com/rsalabs/pkcs
http://www.rsasecurity.com/rsalabs/pkcs//
¾
Java Specification Request (JSR) 74
http://www.jcp.org/en/jsr/detail
?id=74
http://www.jcp.org/en/jsr/detail?id=74
110
Conferenze
¾
http://java.sun.com/security/
z
JavaOne 2002 Presentations (PDF documents)
documents) Sessions:
Sessions:
•
•
•
•
•
•
•
z
Java 2 Platform, Standard Edition (J2SE) Security: Present and Future
Authentication and Single SignSign-On
Networking with Java 2 Platform, Standard Edition (J2SE): Present and Future
Single SignSign-on Using the JAAS and Java GSS APIs
Securing the Wire
Java Naming and Directory Interface (JNDI)
JSR 105: XML Digital Signature API
JavaOne 2001 Presentations (PDF documents)
documents)
•
•
•
•
•
•
•
Java 2 Platform, Standard Edition (J2SE) Security:
Security: Present and Future
Security for the J2SE: CertPath,
CertPath, JCE, and JSSE
Java 2 Platform, Standard Edition (J2SE) Networking:
Networking: Present and Future
Java 2 Platform,
Platform, Standard Edition (J2SE ) Networking and IPv6
Unlocking Public Key Technologies for the Java Platform Update:
Update: JSR74
Security for the J2SE Platform:
Platform: JAAS, Java GSSGSS-API & Kerberos
Security for the Java 2 Platform,
Platform, Standard Edition (J2SE) and XML
111
Articoli
¾
http://java.sun.com/security/
z
FAQs, Whitepapers, Articles
• Single SignSign-on Using Kerberos in Java
• JAAS white paper
• Going Beyond the Sandbox: An Overview of the New Security Architecture
Architecture
in the JavaTM Development Kit 1.2
• Secure Computing With Java: Now and the Future
• CompCon 97 Abstract
• Applet Security FAQ
112