Sicurezza dichiarativa Java EE, Impossibile caricare gruppo per utente realm JDBC

Question

È il mio primo post qui. Avrei due domande riguardo alla sicurezza dichiarativa di Java EE: (1) autenticazione basata su file e (2) autenticazione basata su DB. Ho allegato le parti rilevanti della configurazione per entrambe le domande. Corro il codice su Glassfish 3.1.1. Grazie per la vostra assistenza anche in anticipo.

Cercavo anche risposte alle mie domande e ho trovato alcuni esempi utili che ho inserito anche in fondo al messaggio. Ho provato a seguirli in modo che lo stato attuale della configurazione possa contenere dettagli di questi campioni, ma non hanno risolto il problema.

-L'autenticazione basata su file funziona correttamente se viene selezionata l'opzione "default default to role mapping", altrimenti non ha funzionato anche se un principal è stato aggiunto alla mappatura. Potrei aver configurato qualcosa non nel modo giusto.

-Autenticazione basata su DB. Non ha funzionato per quanto riguarda l'autorizzazione, perché i nomi dei gruppi non potevano essere letti. Vedi i dettagli di seguito. L'autenticazione funziona bene, cioè l'utente è riconosciuto. Ho anche provato con rinominare i tavoli per evitare potenziali collisioni nome con alcune cose interna di Glassfish ...

(1) l'autenticazione basata su file: regno File, 2 useres: utente, amministratore aggiunto e assegnato alla gruppi: utente e amministratore (configurazioni///regni/file di protezione del server-config -> Gestione utenti)

configurazioni/server-config/sicurezza predefinito principale Per la mappatura del ruolo "tic tac" -> funziona Principal predefinito Alla mappatura dei ruoli "non spuntato" -> non funziona anche se viene aggiunto alla mappatura della sicurezza.

web.xml 

[...] 
    <security-constraint> 
     <display-name>Admin Pages</display-name> 
     <web-resource-collection> 
      <web-resource-name>Protected Admin Area</web-resource-name> 
      <description/> 
      <url-pattern>/faces/admin/*</url-pattern> 
      <http-method>GET</http-method> 
      <http-method>POST</http-method> 
      <http-method>HEAD</http-method> 
      <http-method>PUT</http-method> 
      <http-method>OPTIONS</http-method> 
      <http-method>TRACE</http-method> 
      <http-method>DELETE</http-method> 
     </web-resource-collection> 
     <auth-constraint> 
      <description/> 
      <role-name>admin</role-name> 
     </auth-constraint> 
    </security-constraint> 
    <security-constraint> 
     <display-name>User Pages</display-name> 
     <web-resource-collection> 
      <web-resource-name>Protected Users Area</web-resource-name> 
      <description/> 
      <url-pattern>/faces/users/*</url-pattern> 
      <http-method>GET</http-method> 
      <http-method>POST</http-method> 
      <http-method>HEAD</http-method> 
      <http-method>PUT</http-method> 
      <http-method>OPTIONS</http-method> 
      <http-method>TRACE</http-method> 
      <http-method>DELETE</http-method> 
     </web-resource-collection> 
     <auth-constraint> 
      <description/> 
      <role-name>user</role-name> 
     </auth-constraint> 
    </security-constraint> 
    <login-config> 
     <auth-method>FORM</auth-method> 
     <realm-name>file</realm-name> 
     <form-login-config> 
      <form-login-page>/faces/loginForm.xhtml</form-login-page> 
      <form-error-page>/faces/loginError.xhtml</form-error-page> 
     </form-login-config> 
    </login-config> 

[...] 

---

glassfish-web.xml: 

<glassfish-web-app> 
    <security-role-mapping> 
     <role-name>admin</role-name> 
     <group-name>admin</group-name> 
    </security-role-mapping> 
    <security-role-mapping> 
     <role-name>user</role-name> 
     <group-name>user</group-name> 
    </security-role-mapping> 
</glassfish-web-app> 

errori registrati senza la mappatura predefinita principale:

1. Nessun presidi mappati al ruolo [utente].
2. Nessun principal associato a ruolo [admin].

---

Log without the default principal mapping: 
    <security-role-mapping> 
     <role-name>admin</role-name> 
     <group-name>admin</group-name> 
     <principal-name>admin</principal-name> 
    </security-role-mapping> 
    <security-role-mapping> 
     <role-name>user</role-name> 
     <group-name>user</group-name> 
     <principal-name>user</principal-name> 
    </security-role-mapping> 

errori registrati senza la mappatura predefinita principali: 1. Nessun presidi mappati al ruolo [utente]. 2. Nessun principal mappato su Role [admin].

---

(2) autenticazione DB-based:

Realm cambiato regno sopra per jdbcRealm nel web.xml

• 1) mn (molti-a-molti tra la tabella utenti e gruppi)

  SEC1111, Impossibile caricare il gruppo per utente realm JDBC [tamas].

• 2) stesso per 1-n (uno-a-molti tra la tabella di utenti e gruppi)

  SEC1111, non caricare gruppo per l'utente reame JDBC [tamas].

• 3) il nome del gruppo nella stessa tabella come nome utente e password

  SEC1111, Impossibile caricare gruppo per l'utente reame JDBC [Tamas].

configurazione Realm: (. Ho anche cercato di lasciare "Gruppi Assegnare" vuoto o per riempire in "default", ma il risultato era lo stesso)

Image had to be omitted, summary: 
JAAS context: jdbcRealm 
JNDI: jdbc/securityDataSource 
User Table: TBLUSERS 
User Name Column: USERNAME 
Password Column: PASSWORD 
Group Table: TBLGROUPS 
Group Name Column: GROUPNAME 
Assign Groups: default 
Digest Algorithm: none 

DB diagramma ER per la relazione mn:

Immagine doveva essere omessa ma come compensazione :-) si trova lo script SQL di seguito.

SQL Script: 
SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0; 
SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0; 
SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL'; 

CREATE SCHEMA IF NOT EXISTS `jdbcrealm` ; 
USE `jdbcrealm` ; 

-- ----------------------------------------------------- 
-- Table `jdbcrealm`.`TBLUSERS` 
-- ----------------------------------------------------- 
DROP TABLE IF EXISTS `jdbcrealm`.`TBLUSERS` ; 
CREATE TABLE IF NOT EXISTS `jdbcrealm`.`TBLUSERS` (
    `USERID` INT NOT NULL AUTO_INCREMENT , 
    `USERNAME` VARCHAR(30) NOT NULL , 
    `PASSWORD` VARCHAR(45) NOT NULL , 
    UNIQUE INDEX `USERNAME_UNIQUE` (`USERNAME` ASC) , 
    PRIMARY KEY (`USERID`)) 

ENGINE = InnoDB; 

-- ----------------------------------------------------- 
-- Table `jdbcrealm`.`TBLGROUPS` 
-- ----------------------------------------------------- 
DROP TABLE IF EXISTS `jdbcrealm`.`TBLGROUPS` ; 
CREATE TABLE IF NOT EXISTS `jdbcrealm`.`TBLGROUPS` (
    `GROUPID` INT NOT NULL AUTO_INCREMENT , 
    `GROUPNAME` VARCHAR(30) NOT NULL , 
    PRIMARY KEY (`GROUPID`)) 

ENGINE = InnoDB; 

-- ----------------------------------------------------- 
-- Table `jdbcrealm`.`USERS_GROUPS` 
-- ----------------------------------------------------- 
DROP TABLE IF EXISTS `jdbcrealm`.`USERS_GROUPS` ; 
CREATE TABLE IF NOT EXISTS `jdbcrealm`.`USERS_GROUPS` (
    `USER_USERID` INT NOT NULL , 
    `GROUP_GROUPID` INT NOT NULL , 
    PRIMARY KEY (`USER_USERID`, `GROUP_GROUPID`) , 

    INDEX `fk_USER_has_GROUP_GROUP1` (`GROUP_GROUPID` ASC) , 
    INDEX `fk_USER_has_GROUP_USER` (`USER_USERID` ASC) , 
    CONSTRAINT `fk_USER_has_GROUP_USER` 
    FOREIGN KEY (`USER_USERID`) 
    REFERENCES `jdbcrealm`.`TBLUSERS` (`USERID`) 
    ON DELETE NO ACTION 
    ON UPDATE NO ACTION, 
    CONSTRAINT `fk_USER_has_GROUP_GROUP1` 
    FOREIGN KEY (`GROUP_GROUPID`) 
    REFERENCES `jdbcrealm`.`TBLGROUPS` (`GROUPID`) 
    ON DELETE NO ACTION 
    ON UPDATE NO ACTION) 

ENGINE = InnoDB; 

SET SQL_MODE=@OLD_SQL_MODE; 
SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS; 
SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS; 

Copia qui alcuni link interessanti su Google, che sono stati utili per me. Inizialmente, ho seguito il secondo. Forse anche gli altri li troveranno utili.

• http://docs.oracle.com/javaee/6/tutorial/doc/bnbxj.html
• http://blog.eisele.net/2011/01/jdbc-security-realm-and-form-based.html
• ... e ancora un po 'ho dovuto omettere in quanto vi possono essere solo due collegamenti inclusi nel primo post.

Grazie per aver letto finora. I migliori auguri,

Tamas

---

---

Parte 2 Grazie per le risposte. Ho creato 2 nuove tabelle utente e gruppo con una relazione uno-a-molti. Nella pagina di configurazione del regno ho impostato i nomi delle tabelle e le colonne per nome utente, pwd e gruppi. Il commento di Matt è anche in linea con il collegamento (vedi sotto non riesco a postare qui)

[...] parte interessante è che per la tabella utente e la tabella del gruppo che ho usato v_user_role come valore per la proprietà. v_user_role è una vista del database che contiene informazioni sia sull'utente che sul gruppo. Il motivo per cui i non ha utilizzato direttamente la tabella utenti è perché glassfish presuppone che sia la tabella utente che la tabella gruppo contengano una colonna contenente nome utente e che risulterebbero in dati duplicati. [...]

-- ----------------------------------------------------- 
-- Table `jdbcrealm`.`user` 
-- ----------------------------------------------------- 
DROP TABLE IF EXISTS `jdbcrealm`.`user` ; 
CREATE TABLE IF NOT EXISTS `jdbcrealm`.`user` (
    `userid` VARCHAR(30) NOT NULL , 
    `password` VARCHAR(45) NOT NULL , 
    PRIMARY KEY (`userid`)) 
ENGINE = InnoDB; 

-- ----------------------------------------------------- 
-- Table `jdbcrealm`.`group` 
-- ----------------------------------------------------- 
DROP TABLE IF EXISTS `jdbcrealm`.`group` ; 
CREATE TABLE IF NOT EXISTS `jdbcrealm`.`group` (
    `groupid` VARCHAR(30) NOT NULL , 
    `userid` VARCHAR(30) NOT NULL , 
    INDEX `fk_group_user1` (`userid` ASC) , 
    CONSTRAINT `fk_group_user1` 
    FOREIGN KEY (`userid`) 
    REFERENCES `jdbcrealm`.`user` (`userid`) 
    ON DELETE NO ACTION 
    ON UPDATE NO ACTION) 
ENGINE = InnoDB; 

Lo stesso errore emerge. Ho anche tentato di inserire una chiave primaria nella groupid della colonna nella tabella dei gruppi, ma non ho riscontrato alcun cambiamento dal punto di vista della domanda.È anche interessante che ho provato a fare lo stesso con 1 tabella in cui sono localizzati nomi utente, pwds, gruppi e lo stesso errore.

---

---

verso la soluzione e la soluzione

I commenti di Matt ha aiutato molto, grazie per questo grande post. In sintesi, all'inizio quando ho scritto la domanda relativa all'autenticazione basata su DB, era chiaro che i gruppi di utenti non possono essere caricati. Questo è stato indicato dal messaggio di errore nel server.log.

Tuttavia, il mio sospetto si è rivolto verso i collegamenti tra i tavoli e i loro nomi di colonne. Tuttavia, dopo aver semplificato il modello di dati per le entità del gruppo di utenti, non ho potuto spiegare perché non ha funzionato anche con una semplice tabella contenente utente, pwd e gruppo. Ho continuato le indagini in questa direzione. Ho assunto che anche i nomi delle colonne possono influenzare questo. Quando ho applicato la configurazione di Matt, il messaggio "Impossibile caricare i gruppi" è scomparso dal server.log ma il fenomeno è rimasto lo stesso. Quindi ho pensato che i gruppi potessero già essere caricati ma c'era anche un altro problema. Ho preso quindi la configurazione di Matt e ho iniziato a cambiare i nomi delle colonne indietro passo dopo passo per avvicinarmi alla configurazione originale, ma il messaggio "Impossibile caricare i gruppi" non appariva nel registro. Quando ho riprodotto il caso con le mie impostazioni originali e il messaggio di registro non c'era, sapevo che c'era qualcosa di sbagliato nel logging che era stato in qualche modo spento. Così ho iniziato a studiare l'intera configurazione.

Quando ho dato un'occhiata all'applicazione distribuita, ho selezionato i descrittori di distribuzione e li ho caricati sulla console glassfish. web.xml era tutto perfetto aveva lo stesso contenuto che ho scritto ma glassfish-web.xml aveva un contenuto completamente diverso! È stato generato come se non avessi avuto glassfish-web.xml. Quindi ho notato che my glassfish-web.xml non è stato inserito nella directory WEB-INF. L'ho spostato lì, ho fatto un "clean all, build" e ho distribuito l'applicazione. Successivamente sono tornato alla vista db che rappresenta i dati tra TBLUSERS e TBLGROUPS in una relazione molti-a-molti. Questa soluzione mi piace di più poiché mostra l'immagine più chiara dal punto di vista dei dati. Ho impostato le colonne appropriate sulla pagina di configurazione del regno. L'ho provato con due utenti "tamas" e "arpi". "tamas" è stato aggiunto all'utente e ai gruppi di amministratori mentre "arpi" è stato aggiunto al gruppo di utenti. La mappatura tra i ruoli e i gruppi di utenti si trova in glassfish-web.xml. È stato dato l'accesso a "tamas" sia alle risorse utente che a quelle amministratore, mentre "arpi" ha ricevuto accesso solo alle risorse utente.

Grazie per l'aiuto. Tamas

Answer 1

A prima vista, avrei individuato i nomi delle colonne della tabella.

Dalla mia esperienza personale ho memorizzato che la colonna utente nella tabella utente deve avere esattamente lo stesso nome della colonna utente nella tabella USER_GROUPS. La corrispondenza è fatta per nome di colonna.

Quindi il vostro tavolo USER_GROUPS necessita di una colonna USERNAME corrispondente ai nomi utente dalla tabella TBLUSERS.

Si noti che è necessario modificare le relazioni della tabella per questo.

Ci possono essere una dozzina di altri motivi, ma si può fare un tentativo.

Questa è la mia configurazione locale:

CREATE TABLE `user` (
    `LOGIN` varchar(32) NOT NULL, 
    `password` varchar(256) DEFAULT NULL, 
    PRIMARY KEY (`LOGIN`) 
) 

CREATE TABLE `group` (
    `IDGROUP` int(11) NOT NULL AUTO_INCREMENT, 
    `name` varchar(45) DEFAULT NULL, 
    PRIMARY KEY (`IDGROUP`) 
) 

CREATE TABLE `group_has_user` (
    `IDGROUP` int(11) NOT NULL, 
    `LOGIN` varchar(32) NOT NULL, 
    PRIMARY KEY (`IDGROUP`,`LOGIN`), 
    KEY `fk_group_has_user_user1` (`LOGIN`), 
    CONSTRAINT `fk_group_has_user_user1` FOREIGN KEY (`LOGIN`) 
    REFERENCES `user` (`LOGIN`) 
    ON DELETE NO ACTION ON UPDATE NO ACTION, 
    CONSTRAINT `fk_group_has_user_group1` FOREIGN KEY (`IDGROUP`) 
    REFERENCES `group` (`IDGROUP`) 
    ON DELETE NO ACTION ON UPDATE NO ACTION 
) 

con le seguenti impostazioni nella console di amministrazione GF:

Ecco il mio mapping di protezione-ruolo da sun-web.xml (ora glassfish-web.xml):

<security-role-mapping> 
    <role-name>user</role-name> 
    <group-name>1</group-name> 
    </security-role-mapping> 
    <security-role-mapping> 
    <role-name>sponsor</role-name> 
    <group-name>2</group-name> 
    </security-role-mapping> 
    <security-role-mapping> 
    <role-name>admin</role-name> 
    <group-name>3</group-name> 
</security-role-mapping> 

E ho definito i seguenti ruoli security-in web.xml direttamente sotto login-config:

<security-role> 
    <description/> 
    <role-name>user</role-name> 
</security-role> 
<security-role> 
    <description/> 
    <role-name>sponsor</role-name> 
</security-role> 
<security-role> 
    <description/> 
    <role-name>admin</role-name> 
</security-role>