Spring Security 3 -> Deixando sua aplicação Web segura!

By Felipe Saab

Continuando com o assunto dos posts anteriores, vamos falar sobre mais uma vantagem do Spring Framework: o Spring Security.

O Spring Security antes era conhecido como Acegi Security pois era um projeto paralelo ao Spring Framework e aos poucos foi integrado a ele. Quando eu digo ‘integrado’ eu quero dizer que ele (Acegi Security) continuou sendo desenvolvido baseado no Spring, ou seja, ele funciona perfeitamente sobre o container do Spring. Há algum tempo o nome do projeto foi alterado para Spring Security pois ele acabou entrando para a família do Spring (péssimo trocadilho não… ).

Mesmo com a integração, quando você baixa o Spring Framework o Spring Security não está incluído. Precisamos baixá-lo separadamente.

O Spring Security utiliza uma biblioteca externa para logging das suas funções e essa biblioteca também não vem no download do projeto, portanto temos que baixar o Apache Commons Logging também.

Apenas mais um detalhe: se você acompanhou os posts anteriores sobre o Spring Framework você notou que a versão do framework era a 2.5 (que vem nativamente com o NetBeans 6.8), porém neste post eu já irei utilizar a mais nova versão: 3.0 pois o Spring Security 3.0 (versão melhor e mais fácil de usar do que a anterior) só roda em cima do Spring Framework 3.0.

Ahh, vou trocar a IDE também, ao invés de utilizar o NetBeans eu irei utilizar o SpringSource Tool Suite (Eclipse que o pessoal da SpringSource deu uma turbinada para facilitar a vida de quem usa o Spring).

Seguem os links para os downloads necessários:

• Spring Framework 3.0
• Spring Security 3.0
• Apache Commons Logging 1.1.1
• SpringSource Tool Suite (caso queira conhecer a ferramenta)

Nosso escopo para a aplicação: teremos dois tipos de usuários na aplicação: Funcionários e Gerentes. Os funcionários tem acesso apenas à área restrita a funcionários e os gerentes tem acesso tanto à área de funcionários (mesmo sendo gerentes eles também são funcionários poxa) quanto à área restrita aos gerentes.

A autenticação será baseada nos dados contidos em uma tabela no banco de dados, então para o usuário possuir acesso ele deve estar cadastrado no banco de dados.

OBS: Também será necessário fazer o download do driver JDBC para a conexão com o banco de dados que você for utilizar. Eu irei utilizar o MySQL, caso você também use ele pode pegar o driver aqui.

Nossa tabela que conterá os dados dos usuários será essa:

CREATE TABLE `users` (
  `username` VARCHAR(15) COLLATE utf8_unicode_ci NOT NULL,
  `password` VARCHAR(40) COLLATE utf8_unicode_ci DEFAULT NULL,
  `authority` VARCHAR(30) COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY  (`username`)
)

Os campos só estão em inglês porque eu fiquei com preguiça de mudar para português, desculpem..

Com o banco de dados pronto nós já podemos por a mão na massa!

Criei um novo projeto (Dynamic Web Project) no STS (SpringSource Tool Suite) chamado ControleAcesso e a primeira coisa que fiz foi incluir as dependências no classpath, ou seja, todos os .jar encontrados na pasta /dist dos releases do Spring Framework e do Spring Security e também o .jar do Apache Commons Logging e o .jar o driver JDBC do MySQL:

OBS: Adicionei também os .jar referentes a JSTL para poder utilizá-la nos JSPs.

Estrutura da Aplicação
Agora vou criar a estrutura básica de arquivos para a nossa aplicação:

Uma estrutura bem básica onde nós podemos ver que as páginas que estão na raiz da aplicação são as páginas de login, index e uma responsável por mostrar uma mensagem de acesso negado caso o usuário tente acessar uma página que não pode.

OBS: Essa é a estrutura final da aplicação, chegaremos até ela aos poucos durante o decorrer do post.

Depois existem mais duas pastas (funcionario e gerente) representando as partes da aplicação que somente usuários autenticados podem acessar. Nestas pastas eu coloquei apenas um index para confirmar que tivemos acesso ou não a página.

Vamos começar a ver as páginas então:

index.jsp (raíz):

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
	<title>Home Page</title>
    </head>
    <body>
        <h1>Página de Boas Vindas</h1>
	<a href="./funcionario">Área de Funcionários</a>
	<br/>
	<a href="./gerente">Área de Gerentes</a>
    </body>
</html>

A página inicial da aplicação apenas dá as boas vindas ao usuário e mostra os possíveis caminhos para ele: área de funcionários ou área de gerentes.

funcionario/index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
	<title>Área do Funcionário</title>
    </head>
    <body>
        <h1>Bem Vindo a Área do Funcionário</h1>
	<a href="../index.jsp">Retornar para a Página Inicial</a>
    </body>
</html>

gerente/index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
	<title>Área do Gerente</title>
    </head>
    <body>
        <h1>Bem Vindo a Área do Gerente</h1>
	<a href="../index.jsp">Retornar para a Página Inicial</a>
    </body>
</html>

Pronto, esta é a estrutura básica da aplicação, caso você rode ela agora você vai conseguir navegar livremente pelas áreas que devem ser restritas (funcionários e gerentes).

Adicionando o Spring na aplicação
Próximo passo é por o Spring para funcionar nessa nossa aplicação. Como as bibliotecas já estão no classpath então vamos criar o arquivo de configuração do Spring: dentro da pasta WEB-INF crie um xml chamado “applicationContext“.

Caso esteja usando o STS basta clicar com o botão direito na pasta WEB-INF, ir em New e depois em Other. Vá na pasta Spring e selecione Spring Bean Configuration File, na proxima janela digite o nome (applicationContext) e na proxima janela você pode escolher os namespaces que quer usar no arquivo então deixe selecionado os seguintes: beans e sec. Quando selecionar o sec você ainda deve especificar o XSD do Spring Framework 3.0. Fazendo isso a IDE já vai criar a estrutura básica do arquivo de configuração com todos os namespaces.

O applicationContext.xml deve ficar parecido com este (já vou adiantar um detalhe e declarar o dataSource responsável por se comunicar com o banco de dados onde está a tabela com os usuários e suas autenticações):

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sec="http://www.springframework.org/schema/security"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">
 
    <!-- data source -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
	<property name="url" value="jdbc:mysql://localhost/spring_security" />
	<property name="username" value="root" />
	<property name="password" value="123" />
    </bean>
 
</beans>

Para concluir esta etapa basta fazer uma pequena modificação no web.xml para adicionar um listener que o Spring tem para facilitar nossa vida. Sempre que a aplicação vai começar a funcionar esse listener procura pelo arquivo applicationContext.xml e carrega o Spring e os beans e configurações definidos nesse arquivo.

OBS: Tem como configurar o listener para receber uma lista com o nome de vários arquivos de configuração (caso você goste de separar as configurações em arquivos separados) e então ele carrega todos, porém esse é um assunto para outro post (ou uma rápida busca no google ).

Basta adicionar a seguinte tag no web.xml:

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

OK, caso você execute a aplicação agora e ficar atento às mensagens de LOG você irá ver o Spring carregando e o dataSource sendo configurado, ou seja, tudo indo bem até aqui!

Aliás, verá também que você consegue facilmente acessar as áreas que deveriam ser restritas. Tudo certo até aqui.

Adicionando segurança na aplicação
Vamos começar a fazer algumas modificações para podermos adicionar a segurança na nossa aplicação.

Primeiro de tudo vamos adicionar um novo filtro no nosso web.xml. Esse filtro será responsável por interceptar todas as requisições à aplicacão, verificar se o usuário possui acesso e liberar a requisição normalmente ou então mostrar um erro.

Segue o XML necessário para a declaração e configuração do filtro:

    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
 
    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

A partir de agora todas as requisições serão interceptadas pelo Spring, só falta deixar bem claro para o Spring Security quem pode fazer o que na aplicação.

Antes de continuar com o processo de autenticação de usuários nós precisamos ter o usuários concorda? hehehe
Vou adicionar agora dois usuários para nossa aplicação: um gerente e um funcionário comum.

INSERT INTO users(username,password,authority) VALUES('func','func','ROLE_FUNC');
INSERT INTO users(username,password,authority) VALUES('ger','ger','ROLE_GER');

Agora já temos o usuário func e o usuário ger para poder testar na nossa aplicação.

Repare que o atributo authority foi preenchido com ROLE_FUNC e ROLE_GER. Isso ocorre porque o Spring Security sempre busca um prefixo no tipo de autorização de cada usuário e o padrão é este (“ROLE_”). Logo mais mostrarei como trocar para um prefixo a sua escolha como “FUNCAO_”, “AUTH_” ou o que você quiser.

Continuando: toda a autenticação será feita com a declaração de apenas dois beans no applicationContext.xml. Vamos ao primeiro:

<sec:http auto-config="true">
    <sec:form-login login-page="/login.jsp" authentication-failure-url="/login.jsp?erro=invalido" />
    <sec:intercept-url pattern="/funcionario/**" access="ROLE_FUNC,ROLE_GER" />
    <sec:intercept-url pattern="/gerente/**" access="ROLE_GER" />
    <sec:intercept-url pattern="/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />
</sec:http>

OBS: O prefixo das tags dos Spring Security é “sec” pois foi o namespace declarado para ele na tag root : xmlns:sec=”…”

A tag serve para definir os parâmetros básicos para o Spring Security saber o que fazer com as requisições. O atributo auto-config nos poupa de definir todas as tags necessárias para o funciomento correto, sendo assim, só precisamos nos focar no que realmente faz parte da nossa aplicação, como o que eu coloquei: formulário de login e URL’s que serão interceptadas.

Cada tag < intercept-url > identifica uma URL ou um padrão de URL’s e qual a permissão o usuário deve ter para acessar tal (tais) URL (s).
A primeira tag diz que todas as URL’s que comecem com “/funcionario/” só poderão ser acessadas por usuários que tiverem autorização ROLE_FUNC ou ROLE_GER.
Já a segunda restringe o acesso a todas URL’s que comecem com “/gerente/” para usuários que estiverem autorizados com ROLE_GER.
E a última tag define que qualquer outra URL que ainda não foi definida anteriormente pode ser acessada sem autenticação nenhuma.

Na tag < form-login> foram definidos alguns atributos meio básicos: login-page informando qual é a página de login e authentication-failure-url informando qual é a página que será exibida caso o login falhe (neste caso eu coloquei a mesma página de login e apenas enviei um parâmetro via GET para podermos saber quando ocorre o erro).

Segue a página de login e como deve ser o formulário:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Autenticação</title>
    </head>
    <body>
        <c:if test="${param.erro ==  'invalido'}">
            Usuário e/ou senha inválidos!<br/><br/>
        </c:if>
 
        <form action="j_spring_security_check" method="post">
            Usuário: <input type="text" name="j_username" /><br />
            Senha: <input type="text" name="j_password"><br />
            <input type="submit" value="Efetuar Login">
        </form>
        <br /><br />
        <a href="index.jsp">Retornar para a Página Inicial</a>
    </body>
</html>

Caso a página seja carregada com o parâmetro “erro” contendo o valor “invalido” então um erro será mostrado (fiz usando JSTL). E o formulário de login deve ser enviado para a URL “j_spring_security_check” passando como parâmetros o nome de usuário (j_username) e a senha (j_password). Esses nomes são padrões do Spring Framework e bem fáceis de serem seguidos.

O processo de login é simples assim e encerra as explicações sobre o primeiro bean responsável pela segurança de nossa aplicação.

Vamos ao próximo bean:

<sec:authentication-manager>
    <sec:authentication-provider>
        <sec:jdbc-user-service data-source-ref="dataSource"
            users-by-username-query="SELECT username, password, 'true' as enable FROM users WHERE username=?"
            authorities-by-username-query="SELECT username, authority FROM users WHERE username=?" />
    </sec:authentication-provider>
</sec:authentication-manager>

Dentro do < authentication-manager > é onde especificamos onde o Spring Security deve buscar os dados para verificar se um usuário está autenticado ou não. Como já tinhamos previsto desde o começo do post que iríamos fazer a autenticação através do banco de dados, utilizamos a tag < jdbc-user-service-data-source > passando o dataSource que conecta no banco que contém nossos usuários.

Quando o Spring Security tenta autenticar um usuário com dados vindos de um banco de dados ele possui um padrão: para cada usuário devem ser retornados 3 campos: username, password e enable, sendo eles usuário, senha e o último dizendo se o usuário está habilitado ou não.

Para não ficarmos presos no padrão de tabelas que o Spring Security sugere para usuários, nós podemos escrever quais querys ele irá utilizar para recuperar os dados que ele precisa.

O atributo users-by-username-query deve trazer os dados do usuário (username, password e enabled) selecionado pelo nome de usuário e o atributo authorities-by-username-query deve trazer o nome de usuário e o tipo de autenticação (username, authority) também selecionado pelo nome de usuário.

Com essa flexibilidade de configuração é possível utilizar qualquer estrutura de tabelas responsável por armazenar os usuários.

E pronto! Agora nossa aplicação web já possui um mecanismo de segurança para restringir o acesso apenas a usuários autenticados! Executando a aplicação agora você verá que só consegue acessar a área de funcionários autenticando-se como um funcionário ou gerente, exatamente como havíamos configurado.

Mudar o prefixo do tipo de autorização
Para mudar o prefixo padrão (ROLE_) podemos setar o atributo role-prefix da tag < jdbc-user-service-data-source >.

<sec:authentication-manager>
    <sec:authentication-provider>
        <sec:jdbc-user-service data-source-ref="dataSource"  role-prefix="TIPO_"
            users-by-username-query="SELECT username, password, 'true' as enable FROM users WHERE username=?"
            authorities-by-username-query="SELECT username, authority FROM users WHERE username=?" />
    </sec:authentication-provider>
</sec:authentication-manager>

Com essa configuração os prefixos devem ser “TIPO_”. Ex de tipos de autorização: TIPO_GERENTE e TIPO_FUNCIONARIO.

Logout
Para o usuário efetuar logout no sistema basta acessar a URL “j_spring_security_logout” na raiz da aplicação.

Ex: para colocar um link “Sair” na página /funcionario/index.jsp devemos colocar assim:

<a href="../j_spring_security_logout">Sair</a>.

Porque a url deve ser acessada na raiz da aplicação web: /Aplicacao/j_spring_security_logout e não /Aplicacao/funcionario/j_spring_security_logout.

Acesso Negado
Caso o usuário logado como funcionário queira acessar a seção restrita a gerentes ele irá receber uma página de erro bem estranha (que o servidor de aplicativos gera). Para mostrar uma página mais amigável avisando que o usuário não tem acesso a uma certa área basta preencher o atributo access-denied-page da tag < http >.

<sec:http auto-config="true" access-denied-page="/negado.jsp">
    <sec:form-login login-page="/login.jsp" authentication-failure-url="/login.jsp?erro=invalido" />
    <sec:intercept-url pattern="/funcionario/**" access="ROLE_FUNC,ROLE_GER" />
    <sec:intercept-url pattern="/gerente/**" access="ROLE_GER" />
    <sec:intercept-url pattern="/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />
</sec:http>

negado.jsp:

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Acesso Negado</title>
    </head>
    <body>
        <h1>Acesso Negado</h1>
        <a href="../index.jsp">Página Inicial</a>
    </body>
</html>

Encriptação da senha
Caso queira que a senha seja protegida por algum algoritmo de encriptação basta adicionar uma nova tag no authentication-manager:

<sec:authentication-manager>
    <sec:authentication-provider>
        <sec:password-encoder hash="md5"/>
        <sec:jdbc-user-service data-source-ref="dataSource"  role-prefix="TIPO_"
            users-by-username-query="SELECT username, password, 'true' as enable FROM users WHERE username=?"
            authorities-by-username-query="SELECT username, authority FROM users WHERE username=?" />
    </sec:authentication-provider>
</sec:authentication-manager>

Neste caso o algoritmo usado é o MD5, poderia ser o MD4, SHA, entre outros.

Para inserir o usuário com uma senha criptografada com MD5 no MySQL fica assim:

INSERT INTO users(username,password,authority) VALUES('func',MD5('func'),'ROLE_FUNC');

Exibindo partes da página apenas para usuários autorizados UPDATE(19/03/2011)

Respondendo a pergunta que nosso leitor Gerson postou nos comentários vamos ver como podemos restringir partes da página com base na autorização que o usuário possui.

A primeira coisa a fazer é ter certeza de que a biblioteca spring-security-taglibs-3.x.x.jar está no classpath da aplicação.

Depois temos que importar as taglibs do Spring Security na página onde queremos usá-la e então utilizá-las de fato. Referência das taglibs do Spring Security.

Eu alterei a página /funcionario/index.jsp para mostrar uma mensagem de boas vindas somente para os usuários que possuem a autorização ROLE_GER:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
        <title>Área do Funcionário</title>
    </head>
    <body>
        <h1>Bem Vindo a Área do Funcionário</h1>
 
        <sec:authorize ifAnyGranted="ROLE_GER">
            Bem vindo gerente <sec:authentication property="principal.username" />.
        </sec:authorize>
 
        <br/><br/>
        <a href="../j_spring_security_logout">Sair</a>.<br/>
        <a href="../index.jsp">Retornar para a Página Inicial</a>
    </body>
</html>

Fácil de ler e de fazer não é?
Só para explicar melhor, o que utilizamos foram as tags authorize e authentication.

authorize: tudo o que estiver dentro esta tag só irá ser rendererizado caso a autorização do usuário logado atenda a regra de algum atributo que informarmos. Neste exemplo usei o atributo ifAnyGranted, quer dizer que o conteúdo da tag só irá ser renderizado caso o usuário logado possua alguma das autorizações (ROLEs) informadas no atributo.

Para informar mais de uma autorização basta separá-las por vírgula.
Ex: ifAnyGranted=”ROLE_GER,ROLE_FUNC”.
Neste caso o conteúdo da tag será renderizado caso o usuário possua autorização ROLE_GER ou ROLE_FUNC.

Outros possíveis atributos são: ifAllGranted (somente irá renderizar caso o usuário possua todas as autorizações informadas) e ifNotGranted (irá renderizar somente se o usuário não possuir a autorização informada).

authentication: utilizada para recuperar o objeto Authentication que está guardado no contexto do Spring Security. O usuário logado é guardado na propriedade principal do objeto Authentication, sendo assim nós podemos exibir seu nome de usuário através do atributo property informando principal.username.

Obs: os dados do usuário logado são guardados em um objeto que implementa a interface UserDetails, ou seja, o atributo principal do objeto Authentication é uma implementação de UserDetails.

E chegamos ao final de mais um post.
O projeto do STS está disponível para download aqui.

A seção de comentários está aberta para feedback e dúvidas pessoal, fiquem a vontade. =]

Até a proxima,
Saab.