Post on 01-May-2015
JAAS
JAVA Security
• I primi framework JAVA security mirano a lla protezione dell’utente l’utente dall’esecuzione di codice mobile basandosi su:– L’origine del codice– Chi ha creato il codice
• JAAS si preoccupa di proteggere il systema dagli utenti basandosi su:– L’identità di chi esegue il codice – I permessi concessi a chi esegue il codice
Motivazioni
• Meccanismi di autenticazione possono essere implementati in differenti modi:– Usando un database Oracol– Un’autenticazione NT– Il protocollo LDAP (lightweight access
directory protocol)
• Il punto è come utilizzare qualunque di questi meccanismi senza cambiare il codice dell’applicazione …
JAAS
“JAVA Authentication and Authorization Service”.
1. Tali API sono un’estensione di J2SE (Java 2 Platform, Standard Edition) 1.3.
2. Fanno parte delle core API in J2SE 1.4
3. Sono parte di J2EE (Java 2 Platform, Enterprise Edition) 1.3 specification.
Nasce JAVA Security
• Java nasce per essere utilizzato come codice mobile (applets)
• Il modello di sicurezza utilizzato inizialmente mirava a considerare:– La provenienza del codice– Il creatore del codice
• Tutti i meccanismi (sandbox, firma digitale del codice, files di policy) erano concepiti per proteggere l’utente dal sistema
JAAS
• JAAS consente di effettuare sia autenticazione che autorizzazione
• JAAS semplifica la gestione della sicurezza inJAVA inserendo un livello di astrazione tra il livello applicativo e i meccanismi di autenticazione ed autorizzazione sottostanti
• Come la maggior parte delle security APIs di JAVA, anche JAAS riesce ad essere indipendente dalle implementazioni utilizzando un sistema di moduli SPIs (Serive Provider Interfaces)
JAVA providers
Caratteristiche
• JAAS mette a disposizione moduli pre-sviluppati
• È possibile sviluppare nuovi moduli o importarne degli esterni
• È inoltre possibile utilizzare uno stack di moduli: ogni modulo può utilizzare i meccanismi di un modulo sottostante per interagire con diverse infrastrutture.
• L’utilizzo di uno stack di autenticazione riprende il Pluggable Authentication Module (PAM) di Unix
Caratteristiche
• JAAS utilizza un approccio simile ad un protocollo di commit a due fasi
• JAAS eredita dal security packages di J2SE 1.2 i principi per la configurazione come Policy files ed i Permessi
• JAAS infine eredita idee da altri affermati framework per la sicurezza, come i certificati X.509
Subject e Principals
• JAAS usa il termine subject per riferirsi a qualsiasi servizio o utente
• Per identificare i soggetti con cui interagire si basa su di nomi. Tuttavi i soggetti potrebbero avere nomi diversi per utilizzre servizi diversi
Le interfacce utilizzate sono:
public interface Principal {public String getName(); }
public final class Subject {public Set getPrincipals() { } }
Utilizzo
• Se la versione di JAVA è anteriore alla J2SEv1.4 occorre procurarsi l’estensione
• Occorre salvare il file jaas.jar nel classpath o nella cartella <jre-home>/lib/ext/
Utilizzo
Per utilizzare JAAS nelle proprie applicazioni occorre:
– Creare un LoginContext – Passare un CallbackHandler al LoginContext, per
prelevare o processare i dati utente– Effettuare l’autenticazione chiamando il metodo
login() del LoginContext – Effettuare le operazioni privilegiate utilizzando il
Subject restituito dal metodo login() (asssumendo che l’autenticazione sia andata a buon fine)
Un esempio
LoginContext lc = new LoginContext("MyExample"); try { lc.login(); } catch (LoginException) { // Authentication failed. }
// Authentication successful, we can now continue. // We can use the returned Subject if we like. Subject sub = lc.getSubject(); Subject.doAs(sub, new MyPrivilegedAction());
Cosa succede
Ecco cosa avviene: • Durante l’inizializzazione dell’oggetto LoginContext viene
cercata la entry "MyExample" in un file di configurazione di JAAS (scritto dallo sviluppatore) per capire quale LoginModule caricare
• Durante il login, il LoginContext chiama il metodo login() di ogni modulo caricato
• Ogni chiamata effettua l’autenticazione o utilizza un CallbackHandler
• Il CallbackHandler usa uno o più Callbacks per interagire con gli utenti e prelevare l’input
• Viene creata una istanza Subject popolata con dettagli dell’autenticazione quali Principal e Credenziali
JAAS classi ed interfacce
Common
Subject, Principal, credential (credential is not any specific class, but can be any object)
Authentication
LoginContext, LoginModule, CallbackHandler, Callback
Authorization Policy, AuthPermission, PrivateCredentialPermission
Common: Subjects, Principals, and Credentials
La classe Subject rappresenta un entità autenticata. La classe contiene tre insieme di informazioni di sicurezza:• Identities: uno o più Principal• Public credentials: es: un nome o una chiave pubblica • Private credentials: password o chiavi private
I Principals rappresentano delle identità che un soggetto può assumere (un codicee fiscale, un indirizzo email, una login ID). Implementano l’interfaccia Principal e serializable
Una credenziale è un qualsiasi Oggetto (una chiave, un ticket, una password). Tali credenziali vengono usati a livello sistema piuttosto che a quello applicativo.
Authentication: LoginContext
È’ la classe direttamente usata dal livello applicativo usato per autenticare i Subjects.
All’interno del del LoginContext vengono caricati i moduli pluggable indicati nel file di configurazione
I tre metodi usati più comunemente sono:
Table 2. LoginContext methods
login()
Invoca i meccanismi di autenticazione dei diversi LoginModules. In caso di successo viene creato un Subject autenticato, altrimenti viene generata una LoginException.
getSubject() Ritorna il Subject autenticato
logout()Effettua il logout del Subject e rimuove Principals e credenziali
Autenticazione: LoginModules
JndiLoginModule
Verifies against a directory service configured under JNDI (Java Naming and Directory Interface)
Krb5LoginModule Autentica usando il Protocollo Kerberos
NTLoginModuleUsa le informazioni correnti dell’utente NT per autenticare
UnixLoginModuleUsa le informazione del utente Unix corrente
LoginModule: metodi
initialize() Chiamato dopo la creazione dell’oggetto
login() Effettua l’autenticazione
commit()Chiamato dopo l’autenticazione dal LoginContext. Qui si assegnano Principals e Credenziali al Subject.
abort()Chiamato quando fallisce l’autenticazione snche se nelle prime fasi. Non vengono assegnati Principals e Credenziali al Subject.
logout() Rimuove Principals e Credenziali associate al Subject.
•Devono essere implementati dal programmatore
•Non vengono utilizzati dal livello applicativo, ma dal LoginContext
Authentication: CallbackHandlers and Callbacks • CallbackHandlers and Callbacks fanno si che il
LoginModule riesca a prelevare le credenziali dell’utente. • Devono poter essere utilizzati indipendentemente da
qual è l’ambito applicativo entro il quale le credenziali sono prelevate (es: e command line o JSP).
• JAAS dispone già di 7 built-in Callbacks nel javax.security.auth.callback package:
– ChoiceCallback,– ConfirmationCallback, – LocaleCallback,– NameCallback, – PasswordCallback,– TextInputCallback, – TextOutputCallback.
Configuration files Hanno la seguente struttura:
Application { ModuleClass Flag ModuleOptions; ModuleClass Flag ModuleOptions; ... }; Application { ModuleClass Flag ModuleOptions; ... }; ...
Un esempio:
Sample { com.sun.security.auth.module.NTLoginModule Required debug=true;};
Flags
Login2 Authentication Status
SampleLoginModule
required pass pass pass pass fail fail fail fail
NTLoginModule sufficient pass fail fail fail pass fail fail fail
SmartCard requisite * pass pass fail * pass pass fail
Kerberos optional * pass fail * * pass fail *
Overall Authentication pass pass pass fail fail fail fail fail
Un esempio di login da linea di comando
Per utilizzare un database per l’autenticazione: 1. Creare un database 2. Creare un file di configurazione che dice al
LoginContext come usare il modulo RdbmsLoginModule 3. Creare un ConsoleCallbackHandler pre prelevare l’input
utente4. Aggiunfre il codice applicativo per utilizzare il Modulo
RdbmsLoginModule, il file di Configurazione, ed il ConsoleCallbackHandler
5. Nel RdbmsLoginModule, occorre implementare i 5 metodi definiti nella LoginModule interface.
InizializzazioneIl primo di questi metodi è: initialize() :
public void initialize(Subject subject, CallbackHandler callbackHandler, Map sharedState, Map options){ this.subject = subject; this.callbackHandler = callbackHandler; this.sharedState = sharedState; this.options = options;
url = (String)options.get("url"); driverClass = (String)options.get("driver"); debug ="true“.equalsIgnoreCase((String)options.get("debug"));}
The sharedState Map permette di condividere dati tra diversi LoginModules; un caratteristica non usata qui
Il file di inizializzazione
Example { RdbmsLoginModule required driver="org.gjt.mm.mysql.Driver" url="jdbc:mysql://localhost/jaasdb?user=root" debug="true"; };
L’applicazione
ConsoleCallbackHandler cbh = new
ConsoleCallbackHandler();
LoginContext lc = new LoginContext("Example", cbh);
lc.login();
• Our login() method then performs the following steps: • Creates two Callbacks that will receive
username/password information from the user. It uses two of the built-in JAAS callbacks from the javax.security.auth.callback package: NameCallback and PasswordCallback. Both of these classes implement the Callback interface, a marker interface with no methods.
• Invokes the Callbacks indirectly by passing them to the handle() method of the CallbackHandler parameter specified in the call to initialize().
• Retrieves the username/password from the Callbacks. • Uses the username/password in our own
rdbmsValidate() method, which checks them against the database via a JDBC query.
public boolean login() throws LoginException { if (callbackHandler == null) throw new LoginException("no handler");
NameCallback nameCb = new NameCallback("user: "); PasswordCallback passCb = new PasswordCallback("password: ", true); callbacks = new Callback[] { nameCb, passCb }; callbackHandler.handle(callbacks);
String username = nameCb.getName(); String password = new String(passCb.getPassword()); success = rdbmsValidate(username, password);
return(true);}
public void handle(Callback[] callbacks) throws java.io.IOException, UnsupportedCallbackException {
for (int i = 0; i < callbacks.length; i++) { if (callbacks[i] instanceof NameCallback) { NameCallback nameCb = (NameCallback)callbacks[i]; System.out.print(nameCb.getPrompt()); String user=(new BufferedReader(new
InputStreamReader(System.in))).readLine(); nameCb.setName(user); } else if (callbacks[i] instanceof PasswordCallback) { PasswordCallback passCb = (PasswordCallback)callbacks[i]; System.out.print(passCb.getPrompt()); String pass=(new BufferedReader(new
InputStreamReader(System.in))).readLine(); passCb.setPassword(pass.toCharArray()); } else { throw(new UnsupportedCallbackException(callbacks[i], "Callback class not supported")); } }}
JSP Callback
String user = request.getParameter("user");String pass = request.getParameter("pass");PassiveCallbackHandler cbh = new PassiveCallbackHandler(user, pass);LoginContext lc = new LoginContext("Example", cbh);
PassiveCallbackpublic void handle(Callback[] callbacks)
throws java.io.IOException, UnsupportedCallbackException { for (int i = 0; i < callbacks.length; i++) { if (callbacks[i] instanceof NameCallback) { NameCallback nameCb = (NameCallback)callbacks[i];
nameCb.setName(user); } else if(callbacks[i] instanceof PasswordCallback) { PasswordCallback passCb = (PasswordCallback)callbacks[i]; passCb.setPassword(pass.toCharArray()); } else { throw(new UnsupportedCallbackException(callbacks[i], "Callback class not supported")); } } }}
No richiede interazione con l’utente
Autorizzazione
• Una volta che l’autenticazione è stata completata con successo JAAS permette il controllo degli accessi per i principals associati al Subject autenticato
• Il controllo dell’accesso JAAS principal-based (basato su chi esegue il codice) completa l’esistente sistema Java 2 codesource-based (basato sulla provenienza del codice e sulla firma)
Autorizzazioni
• Occorre definire un insieme di risorse protette
• Un insieme di condizioni secondo le quali i Principal menzionati possono accedere alle risorse
• JAAS estende la policy di default di Java 2 utilizzando insieme i due criteri (code base and user based)
Esempio
• // Java 2 codesource-based policy grant Codebase "http://foo.com", Signedby "foo" {permission java.io.FilePermission "/cdrom/-", "read"; }
• // JAAS principal-based policy grant Codebase "http://bar.com, Signedby "bar",
Principal bar.Principal "duke" {
permission java.io.FilePermission "/cdrom/duke/-", "read"; }
Esempio• Questo esempio consente al codice:
– caricato da 'bar.com‘– firmato da 'bar',– ed eseguito da ‘'duke‘di leggere solo quei files che si trovano nella cartella '/cdrom/duke'
directory. • Per essere eseguito come ‘duke’ il subject autenticato dal
LoginContext deve essere associato ad un Principal il cui metodo “getName” ritorna la stringa ‘duke’.
• Se il codice caricato da 'bar.com', firmato da 'bar', eseguissse stand-alone (non eseguito come 'duke'), allora non otterrebbe il permesso
• Se la policy non specificasse l’informazione Codbase o SygnedBy quel permesso sarebbe concsso a qualunque codice eseguto come ‘duke’
Ruoli e Gruppi
• JAAS tratta ruoli e gruppi semplicemente come Principals.
• Il controllo dell’accesso può essere applicato a ruoli e gruppi così come ad altri tipi di Principal:
// an administrator role can access user password
grant Principal foo.Role "administrator" {
permission java.io.FilePermission "/passwords/-", "read, write";
// a basketball team (group) can read its directory
grant Principal foo.Team "SlamDunk" {
permission java.io.FilePermission "/teams/SlamDunk/-", "read"; }
Eseguire un’operazione con particolari Privilegi
In JAVA 2 la runtime richiama il Seccurity Manager quando occorre accedere a delle operazioni sensibili
Per determinare se il codice ha sufficienti permessi Il SecurityManager delega la responsabilità al
“java.security.AccessController”
che ottiene un immagine del contesto corrente (AccessControlContext) e si assicura che questi contenga sufficienti privilegi per portare a termine l’operazione.
Eseguire azioni privilegiate con JAAS
• JAAS completa questa architettura mettendo a disposizione il metodo: Subject.doAs, per associare dinamicamente un soggetto autenticato al corrente AccessControlContext.
• Utilizzando JAAS, il server può essere sicuro di ciò definendo l’operazione qualle
java.security.PrivilegedAction, e poi invocando il metodo doAs
Fornendo sia il subject autenticato che il PrivilegedActionil metodo doAs associa il subject all’AccessControlContext
corrente ed esegue l’azione
Esempio
public final class Subject {
...
// associate the subject with the current
// AccessControlContext and execute the action
public static Object doAs(Subject s,java.security.PrivilegedAction action) {
}
}