Newsgroup: it.comp.java
Titolo: Sicurezza j2ee nella pratica

Salve,
ho sempre lavorato in progetti con applicazioni java web based con
autenticazione/autorizzazione fatte in casa, in modo totalmente
proprietario e non standard.
In futuro vorrei usare metodologie standard di j2ee per autenticazione/
autorizzazione, come jaas e compagnia bella.
Ho però dei dubbi su come usare in pratica utenti, gruppi, ruoli,
realm ecc...
Mettiamo che si debba sviluppare una applicazione con varie
"Gestioni", tipo Gestione Clienti, Gestione Fornitori, Gestione
Prodotti, ecc ....
Dove ogni gestione comprende le solite funzionalità elenca, nuovo,
modifica, cancella, visualizza.
Mettiamo anche che si richiede la possibilità di una gestione molto
fine e granulare delle autenticazioni, cioè non solo un dato utente è
abilitato ad una data Gestione, ma si deve poter imporre cose del
tipo: l'utente pippo può fare elenca, nuovo e modifica di Gestione
Clienti ed elenca e visualizza di Gestione Prodotti mentre l'utente
pluto può fare solo elenca di Gestione Fornitori ecc...
Qual'è il modo ottimale di usare la sicurezza j2ee?
Va creato un ruolo per ogni funzionalità elementare?
Un ruolo per elenca clienti, uno per nuovo cliente, uno per modifica
cliente ecc... ?
Poi mi sembra di aver capito che normalmente si associano utenti e/o
gruppi ai ruoli al momento del deploy dell'applicazione
nell'Application Sever.
Però io vorrei avere una Gestione Utenti, e una Gestione Gruppi
all'interno della mia applicazione e vorrei che ci sia una
funzionalità che permette dinamicamente (non solo al deploy) di
associare i ruoli di cui sopra ai gruppi e/o utenti
E' possibile farlo?
Ciao e grazie per eventuali risposte.

 Ciao e grazie per eventuali risposte.
Di niente mi interessa l'argomento e mi fa piacere parlarne.
Ciao
Co

Massimo S. ha scritto:

io sto sviluppando una webapp che contempla la gestione dei ruoli degli 
utenti in maniera dinamica.
in pratica faccio proprio come dici tu, cioè ad ogni azione associo un 
ruolo, un permesso quindi, e per permettere ad un utente di poter 
effettuare quella data azione, non devo fare altro che aggiungergli quel 
ruolo.
se preferisci, potresti creare dei macro-ruoli contenenti + ruoli, tipo 
gestione fornitori, che contempla inserisci, cancella, modifica, etc.
spero di esserti stato d'aiuto.
Riccki


Mi sei stato molto utile, ringrazio molto te e Corrado per avermi
risposto

Ciao Massimo,
dipende da che tipo di LginModlue usi;
se usi uno bassato sull' accesso al DB,vedi subito le modifiche fatte!
poi secondo me le autorizzazioni JAAS serrvono per controllare
l'accesso fisico alle pagine, ma tipicamente la creazione del menu
dinamicamente è un problema applicativo!
in pratica,
cio che ti permette di fare JAAS è:
1) non preoccuparti, nelle servlet, di far loggare l'utente
2) non preoccuparti dell' accesso a risorse non autorizzate
3) ti permette  nelle servlet/jsp di sapere facilmente se un utente
appartiene a un dato ruolo, tramite il metodo dell oggetto Request
isUSerInRole. tra l'altro associare ruoli all' utente è semplice,
basta inserire nel loginModule N nomi nel set dei Principals quani
sono i ruoli cui vuoi assegnare!

 wrote:


supponiamo che utilizzi un db in cui ci sono gli utenti e i ruoli.
l'accesso alle tabelle permette di creare dinamicamente gli utenti e di 
associare, a questi, i ruoli.
se per ogni action-mapping (utilizziamo struts, per esempio) definiamo 
un ruolo di accesso, avremo una mappa di tutti i ruoli necessari per 
poter accedere ad ogni parte dell'applicazione.
a questo punto, in runtime, puoi aggiungere o levare un ruolo ad un 
utente (direttamente dal db), e permettere o impedire l'accesso ad una 
determinata risorsa (action).
volendo, organizzi dei gruppi come insieme di + ruoli, in modo da 
associare direttamente un utente ad un gruppo anziché perdere tempo ad 
inserire ogni singolo ruolo.
non credo che questa dei macro-ruoli sia prevista nello standard j2ee, 
ma non credo che sia un problema implementare qualcosa che faccia questo 
(magari ne trovi una già bella pronta da qualche parte).
quindi, ricapitolando: l'associazione dei ruoli per le action va fatto 
durante il deploy dell'applicazione (le action quelle sono e quelle 
restano), mentre l'associazione dei ruoli agli utenti viene fatta in 
runtime.
spero di essermi inoltrato maggiormente, comunque se hai bisogno fammi 
sapere.

Una domanda dato che l'argomento sta diventando interessante. Per la mia 
webapp, utilizzo un'autenticazione via FORM. Bene, questo prevede due 
tabelle, una per gli utenti, e una di mappaggio utente ruolo
[Usate un carattere MONOSPACED!]
USERTABLE
|----|----------|----------|
| id | username | password |
|----|----------|----------|
| 1  | corrado  | secret   |
|----|----------|----------|
GROUPTABLE
|----|----------|-----------|
| id | username | groupname |
|----|----------|-----------|
| 1  | corrado  | USERS     |
|----|----------|-----------|
Questa e' la situazione tipo, mi confermate? Quando creo il mio 
JDBCRealm, passo come parametri il nome delle due tabelle, e il nome 
delle 4 colonne. STOP. Magia fatta e tutto funziona. Ma questi dati non 
sono normalizzati, cioe non ha senso dover *scrivere* tutte le volte il 
nome del gruppo per gli utenti in USERTABLE. Quello che mi piacerebbe e' 
una tabella di mappaggio intermedio che associ l'id di un utente con 
l'id di un gruppo, per normalizzare.
Qualcosa tipo:
USERTABLE
|----|----------|----------|
| id | username | password |
|----|----------|----------|
| 1  | corrado  | secret   |
|----|----------|----------|
GROUPTABLE
|----|-----------|
| id | groupname |
|----|-----------|
| 1  | USERS     |
|----|-----------|
USER_GROUP
|--------|---------|
| userid | groupid |
|--------|---------|
|   1    |    1    |
|--------|---------|
Ovviamente questo non e' contemplato da JAAS. _Suppongo_ che l'unico 
modo per realizzare qualcosa del genere e restare con le API di JAAS sia 
estendere o riscrivere il JDBCRealm. Mi confermate (cosi smetto di 
pensarci!) o qualcuno ha idee su come procedere?
Grazie e ciao
Co

Scusate se ho scritto lo stesso messaggio più volte ma l'interfaccia
web di google grouppi continuava a dirmi che c'era stato un errore
nell'invio del messaggio e di riprovare e io ho riprovato :-)

Corrado Alesso ha scritto:

Il mappaggio previsto in genere è ruolo-utente, per cui se vuoi 
utilizzare un gruppo di ruoli, devi implementarti un sistema tu.
La limitazione è dovuta dal fatto che il controllo dei permessi avviene 
proprio sulla tabella grouptable del primo caso, a meno di riscrivere il 
JDBCRealm, come dici tu.
Ti dico cosa ho fatto io: per diversi motivi ho la necessità di tenere 
determinati parametri relativi all'utente autenticato, quindi mi sono 
implementato una classe in sessione che contiene i vari dati.
Su questa classe ho creato il metodo hasUserGroup e mappato la 
isUserInRole a quella della request, in modo da poter fare riferimento 
proprio a questa classe per tutto quanto concerne la sicurezza.
Certo, quando setto un utente ad un gruppo, devo anche settare tutti i 
ruoli dell'utente nella tabella ruoli.
Per quanto riguarda la gestione degli accessi ai singoli elementi delle 
jsp (pulsanti, link e altro), si potrebbe creare una taglib che prevede 
l'interfacciamento a questa classe in sessione, così da distinguere gli 
accessi per ruolo e per gruppo.
non so se questo sia il massimo dell'efficienza, ma sicuramente risulta 
essere molto funzionale
Ricki


Scusa ma non sono pratico di struts, spero di colmare anche questa
lacuna prossimamente, ma fino ad ora ho lavorato solo con jsp nude e
crude :-)
Quanto dici sopra è struts-specifico, oppure in qualche modo si può
fare in generale per web-application  j2ee ?

 
uhm...
quello che ti ho detto io č per struts.
l'autenticazione funziona allo stesso modo, ma non mi sembra di 
ricordare che ci fosse un sistema automatico per filtrare i ruoli in 
base alle richieste.....
dovresti implementare un "filter" e con questo controllare le richieste, 
verificare se l'utente ha il ruolo adatto a soddisfare la richiesta, e 
quindi redirezionare ad una pagina di errore o alla pagina selezionata.
per quanto riguarda la mappatura dei ruoli per le pagine....prova a 
guardarti questi link.....
http://weblogs.java.net/blog/tchangu/archive/2006/06/glassfish_role_1.html
http://java-x.blogspot.com/2007/01/securing-java-ee-5-web-applications.html
ciao.