Tutorial de JAAS

<%
if (request.isUserInRole("admins") && request.isUserInRole("managers")){ 
%>
Only authorized people can see this.
<%
}
%>
<%
if (request.isUserInRole("create")){ 
%>
Only authorized people can see this.
<%
}
%>

dataSourceName="jdbc/GUJ"

public void doLogout(ActionEvent event) throws IOException{
	     final HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
	     request.getSession( false ).invalidate();	
             FacesContext.getCurrentInstance().getExternalContext().redirect("/aplicacao");
	}

grupoRole.addMember(new Role("admin'));
 grupoRole.addMember(new Role("logado));
 subject.getPrincipals().add(UsuarioPrincipal("teste"));
 subject.getPrincipals().add(grupoRole);

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import javax.security.auth.Subject;

import javax.security.auth.callback.Callback;

import javax.security.auth.callback.CallbackHandler;

import javax.security.auth.callback.NameCallback;

import javax.security.auth.callback.PasswordCallback;

import javax.security.auth.callback.UnsupportedCallbackException;

import javax.security.auth.login.LoginException;

import javax.security.auth.spi.LoginModule;

import javax.sql.DataSource;

public class GujLoginModule implements LoginModule {

private boolean commitSucceeded = false;

private boolean succeeded = false;

private User user;
private Set roles = new HashSet();

private GroupRole grupoRole = new GroupRole("abc");

protected Subject subject;
protected CallbackHandler callbackHandler;
protected Map sharedState;
private String dataSourceName;
private String sqlUser;
private String sqlRoles;

public void initialize(Subject subject, CallbackHandler callbackHandler, Map sharedState, Map options) {
	System.err.println("1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + callbackHandler);
	this.subject = subject;
    this.callbackHandler = callbackHandler;
    this.sharedState = sharedState;
    dataSourceName = (String) options.get("dataSourceName");
    sqlUser = (String) options.get("sqlUser");
    sqlRoles = (String) options.get("sqlRoles");
}

public boolean login() throws LoginException {
	System.err.println("2xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    // recupera o login e senha informados no form
    getUsernamePassword();

    Connection conn = null;
    try {
        // obtem a conexão
        try {
            Context initContext = new InitialContext();

DataSource ds = (DataSource) initContext.lookup(dataSourceName);
            conn = ds.getConnection();
        } catch (NamingException e) {
        	System.err.println("2 NamingException");
            succeeded = false;
            throw new LoginException("Erro ao recuperar DataSource: " + e.getClass().getName() + ": " + e.getMessage());
        } catch (SQLException e) {
        	System.err.println("2 SQLException");
            succeeded = false;
            throw new LoginException("Erro ao obter conexão: " + e.getClass().getName() + ": " + e.getMessage());
        }
        // valida o usuario
        validaUsuario(conn);
    } finally {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
            }
        }
    }
    // acidiona o usuario e roles no mapa de compartilhamento
    sharedState.put("javax.security.auth.principal", user);
    sharedState.put("javax.security.auth.roles", roles);

    return true;
}

public boolean commit() throws LoginException {
	System.err.println("3xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    // adiciona o usuario no principals
    if (user != null && !subject.getPrincipals().contains(user)) {
    	
    	System.err.println("3 user = " + user );
        subject.getPrincipals().add(user);
    }
    // adiciona as roles no principals
    if (roles != null) {
        Iterator it = roles.iterator();
        while (it.hasNext()) {
            Role role = (Role) it.next();
            if (!subject.getPrincipals().contains(role)) {
            	System.err.println("Aqui 3 role = [" + role.getName()+"]" );
            	grupoRole.addMember(role);
            }
        }
        System.err.println("3 adicionando grupoRole" + grupoRole);
        subject.getPrincipals().add(grupoRole);
    }
    
    commitSucceeded = true;
    
    System.err.println("3 commitSucceeded xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    return true;
}

public boolean abort() throws LoginException {
	System.err.println("4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    if (!succeeded) {
        return false;
    } else if (succeeded && !commitSucceeded) {
        succeeded = false;
    } else {
        succeeded = false;
        logout();
    }

    this.subject = null;
    this.callbackHandler = null;
    this.sharedState = null;
    this.roles = new HashSet();

    return succeeded;
}

public boolean logout() throws LoginException {
	System.err.println("5xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    // remove o usuario e as roles do principals
    subject.getPrincipals().removeAll(roles);
    subject.getPrincipals().remove(user);
    return true;
}

/**
 * Valida login e senha no banco
 */
private void validaUsuario(Connection conn) throws LoginException {
	System.err.println("6xxxxxxxxxxxxxxx loginInformado = "+ loginInformado);
    String senhaBanco = null;
    PreparedStatement statement = null;
    ResultSet rs = null;
    try {
        statement = conn.prepareStatement(sqlUser);
        statement.setString(1, loginInformado);
        rs = statement.executeQuery();
        if (rs.next()) {
            senhaBanco = rs.getString(1);
        } else {
            succeeded = false;
            System.err.println("Usuário não localizado.");
            throw new LoginException("Usuário não localizado.");
        }
    } catch (SQLException e) {
        succeeded = false;
        
        System.err.println("Erro ao abrir sessão: "
                + e.getClass().getName() + ": " + e.getMessage());
        throw new LoginException("Erro ao abrir sessão: "
                + e.getClass().getName() + ": " + e.getMessage());
    } finally {
        try {
            if (rs != null)
                rs.close();
            if (statement != null)
                statement.close();
        } catch (Exception e) {

        }
    }

    if (senhaInformado.equals(senhaBanco)) {
        user = new User(loginInformado);
        recuperaRoles(conn);
        user.setRoles(roles);
        return;
    } else {
        throw new LoginException("Senha Inválida.");
    }
}

/**
 * Recupera as roles no banco
 */
public void recuperaRoles(Connection conn) throws LoginException {
	System.err.println("7xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
    PreparedStatement statement = null;
    ResultSet rs = null;
    try {
        statement = conn.prepareStatement(sqlRoles);
        statement.setString(1, loginInformado);
        rs = statement.executeQuery();
        while (rs.next()) {
            roles.add(new Role(rs.getString(1)));
            
            System.err.println("7 rs.getString(1) = ["+rs.getString(1)+"]");
        }
        
        //roles.add(new Role("LOGADO"));
    } catch (SQLException e) {
    	System.err.println("7 SQLException" + "Erro ao recuperar roles: " + e.getClass().getName() + ": " + e.getMessage());
        succeeded = false;
        throw new LoginException("Erro ao recuperar roles: " + e.getClass().getName() + ": " + e.getMessage());
    } finally {
        try {
            if (rs != null)
                rs.close();
            if (statement != null)
                statement.close();
        } catch (Exception e) {

        }
    }
}

/**
 * Login do usuário.
 */
protected String loginInformado;

/**
 * Senha do usuário.
 */
protected String senhaInformado;

/**
 * Obtem o login e senha digitados
 */
protected void getUsernamePassword() throws LoginException {
	System.err.println("8xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
	if (callbackHandler == null) {
		System.err.println("8 callbackHandler == null");
        throw new LoginException("Error: no CallbackHandler available to garner authentication information from the user");
	}
    Callback[] callbacks = new Callback[2];
    callbacks[0] = new NameCallback("Login");
    callbacks[1] = new PasswordCallback("Senha", false);
    try {
        callbackHandler.handle(callbacks);
        loginInformado = ((NameCallback) callbacks[0]).getName();
        char[] tmpPassword = ((PasswordCallback) callbacks[1]).getPassword();
        senhaInformado = new String(tmpPassword);
        ((PasswordCallback) callbacks[1]).clearPassword();
    } catch (java.io.IOException ioe) {
    	System.err.println("8 ioe");
        throw new LoginException(ioe.toString());
    } catch (UnsupportedCallbackException uce) {
    	System.err.println("8 uce");
        throw new LoginException("Error: " + uce.getCallback().toString() + " not available to garner authentication information from the user");
    }
}

private GroupRole grupoRole = new GroupRole("abc");

private GroupRole grupoRole = new GroupRole("Roles");

session.invalidate();