jGuard: Introdução ao Framework
Veja neste artigo uma introdução ao framework jGuard, que está sendo cada vez mais utilizado pelos desenvolvedores Java em seus projetos. Veja na prática como ele funciona.
jGuard é um dos aspectos mais difíceis e importantes no desenvolvimento de aplicações é a segurança em aplicações web, especialmente a autenticação e autorização. A plataforma J2EE oferece o framework JAAS (Java Authorization and Authentication Service) que oferece um passo na direção correta para conseguirmos autenticação e autorização nas nossas aplicações, no entanto o JAAS está um pouco longe de ser completo. Dessa forma, os desenvolvedores e projetistas de containers estão livres para fazer a sua própria implementação. Isso leva a problemas de portabilidade e restrições no gerenciamento de usuários.
Com isso surgiram diversos frameworks como Acegi Security framework, jGuard, Spring Security e tantos outros que implementam uma versão única e sólida para que tenhamos uma camada de segurança nas aplicações.
De forma geral, os frameworks lidam com a autenticação, ou seja, antes de decidir se daremos acesso ou não a um recurso para um usuário, o usuário deve fornecer uma identificação de segurança apropriada, e a autorização que relaciona papeis a recursos, protegendo assim os recursos.
No restante do artigo veremos como o framework jGuard implementa a segurança nas aplicações Java e como o framework lida com a autenticação e autorização dos usuários.
Características do jGuard
jGuard é uma bibliotecas que fornece uma forma de implementar a segurança mais facilmente em aplicações Java para web. Esta biblioteca está construída sobre o estável e maduro framework JAAS, que é parte da Java J2SE API.
Uma das características do jGuard é que ele é muito flexível e permite diferentes formas de configurar esses mecanismos para autenticação e autorização seja em banco de dados relacionais, arquivos XML ou serviço LDAP. O jGuard está licenciado sobre a Open Source LGPL.
Instalando o jGuard
Para instalar o jGuard devemos primeiramente baixá-lo em Aqui.
A última versão até o presente momento é a versão jGuard 1.0.4.
Para executar o jGuard deveremos ter o Apache Tomcat configurado na máquina, mais informações estão disponíveis em Apache Tomcat Tutorial.
Utilizando o jGuard
Todos os JARs devem ser colocados no diretório WEB-INF/lib e os arquivos de configuração devem ser colocados em WEB-INF/conf/jGuard.
Para configurar o jGuard devemos configurar os arquivos de configuração XML para os mecanismos de autenticação e autorização. Os arquivos a serem configurados são:
- web.xml
- jGuardAuthentication.xml
- jGuardAuthorization.xml
- jGuardUsersPrincipals.xml
- jGuardPrincipalsPermissions.xml
- jGuardFilter.xml
<context-param>
<param-name>authenticationConfigurationLocation</param-name>
<param-value>/WEB-INF/conf/jGuard/jGuardAuthentication.xml</param-value>
</context-param>
<servlet>
<servlet-name>LoginForm</servlet-name>
<jsp-file>/WEB-INF/jsp/loginForm.jsp</jsp-file>
</servlet>
<!—- the URL ‘/LoginForm.do’ is specified in jGuardFilter.xml-->
<servlet-mapping>
<servlet-name>LoginForm</servlet-name>
<url-pattern>/LoginForm.do</url-pattern>
</servlet-mapping>Listagem 1. Exemplo de configuração do arquivo web.xml no jGuard
No arquivo jGuardAuthentication.xml devemos especificar quais gerenciadores de autenticação podemos usar, a localização da fonte de dados que contém as credenciais dos usuários, e o módulo de login que devemos utilizar. Abaixo especificamos o XmlAuthenticationManager como gerenciador de autenticação e o módulo de login é o XmlLoginModule. O arquivo da Listagem 2 mostra um exemplo de configuração para este arquivo.
<authenticationManager>
net.sf.jGuard.ext.authentication.manager.XmlAuthenticationManager
</authenticationManager>
<authenticationManagerOptions>
<option>
<name>authenticationXmlFileLocation</name>
<value>WEB-INF/conf/jGuard/jGuardUsersPrincipals.xml</value>
</option>
</authenticationManagerOptions>
<loginModules>
<loginModule>
<name>net.sf.jGuard.ext.authentication.loginmodules.XmlLoginModule</name>
<flag>REQUIRED</flag>
</loginModule>
</loginModules>Listagem 2. Exemplo de configuração padrão para o arquivo jGuardAuthentication.xml
O arquivo jGuardAuthorization.xml contém a especificação para o gerenciador de autorização utilizar e a localização do datasource que mapeia os papeis para as permissões. Os papeis são utilizados pelo jGuard para determinar se um usuário tem direito de acesso a um recurso particular. No exemplo da Listagem 3 o gerenciador de autorização é o XmlAuthorizationManager e o datasource é o jGuardPrincipalsPermissions.xml
Listagem 3. Exemplo de configuração do arquivo jGuardAuthorization.xml.
<authorizationManager>
net.sf.jGuard.ext.authorization.manager.XmlAuthorizationManager
</authorizationManager>
<authorizationManagerOptions>
<option>
<name>authorizationXmlFileLocation</name>
<value>WEB-INF/conf/jGuard/jGuardPrincipalsPermissions.xml</value>
</option>
</authorizationManagerOptions>
</authorizationManager>Listagem 1. NOME
O arquivo jGuardUsersPrincipals.xml define os papéis, modelos de usuários, e usuários concretos. Segue na Listagem 4 o XML de exemplo configurando um papel (role).
<principal>
<name>admin</name>
<class>net.sf.jGuard.core.principals.RolePrincipal</class>
<applicationName>Basic1</applicationName>
<!—este valor deve ser o mesmo que o display-name do arquivo web.xml -->
</principal>Listagem 4. Exemplo de configuração para o arquivo jGuardUsersPrincipals.xml
Na Listagem 5 configuramos os modelos de usuário e então criamos um usuário:
<users>
<userTemplate>
<name>default</name>
<privateRequiredCredentials>
<credTemplateId identity="true">login</credTemplateId>
<credTemplateId digestNeeded="true">password</credTemplateId>
</privateRequiredCredentials>
…
</userTemplate>
<user>
<privateCredentials>
<credential>
<id>login</id>
<value>admin</value>
</credential>
<credential>
<id>password</id>
<value>admin</value>
</credential>
</privateCredentials>
…
<principalsRef>
<principalRef name="admin" applicationName="Basic1"
definition="${subject.publicCredentials.location.contains('Paris')}"
active="true" />
</principalsRef>
</user>Listagem 5. Código para criação de modelos de usuários e usuários
O arquivo jGuardPrincipalsPermissions.xml declara quais recursos (arquivos JSP e Servlets) um papel particular pode acessar. O elemento XML mais importante neste arquivo é o que nos permite agrupar um número de permissões sobre um nome em comum. Segue na Listagem 6 o código de exemplo.
<permissions>
<domain>
<name>public</name>
<permission>
<name>LoginForm</name>
<class>net.sf.jGuard.core.authorization
.permissions.URLPermission </class>
<actions>
<action>/LoginForm.do</action>
<action>ANY</action>
</actions>
</permission>
<permission>
<name>LogonProcess</name>
<class>net.sf.jGuard.core.authorization
.permissions.URLPermission</class>
<actions>
<action>/LogonProcess.do</action>
<action>ANY</action>
</actions>
</permission>
</domain>
</permissions>Listagem 6. Exemplo de definição de acesso a recursos para diferentes perfis
No XML acima declaramos as permissões LoginForm e LoginProcess agrupadas sobre o nome "public". Portanto, se quisermos que um usuário tenha acesso a todos os recursos acima devemos apenas dar acesso ao domínio com nome "public". Para dar acesso a uma permissão particular, por exemplo LoginForm, podemos fazer como na Listagem 7.
<principal>
<name>guest</name>
<class>net.sf.jGuard.core.principals.RolePrincipal</class>
<permissionsRef>
<permissionRef name="LoginForm" />
<permissionRef name="LogonProcess" />
</permissionsRef>
</principal>Listagem 7. Definição de permissões agrupadas aos recursos
Por fim, o último XML a ser configurado é o jGuardFilter.xml que trata-se de um arquivo importante para o jGuard decidir onde o usuário deveria ser direcionado após um certo evento. Segue na Listagem 8 um XML exemplificando uma configuração para um filter.
<filter>
<indexURI>/Authenticated.do</indexURI>
<authenticationFailedURI>/AuthenticationFailed.do</authenticationFailedURI>
<logonURI>/LoginForm.do</logonURI>
<logonProcessURI>/LogonProcess.do</logonProcessURI>
<registerURI>/Registration.do</registerURI>
<registerProcessURI>/RegistrationProcess.do</registerProcessURI>
<logoffURIs>
<logoffURI>/LogOff.do</logoffURI>
</logoffURIs>
<accessDeniedURI>/AccessDenied.do</accessDeniedURI>
<authScheme>FORM</authScheme>
<loginField>login</loginField>
<passwordField>password</passwordField>
<goToLastAccessDeniedUriOnSuccess>true</goToLastAccessDeniedUriOnSuccess>
</filter>Listagem 8. Definição de redirecionamento para cada evento
O elemento especifica a URI para onde o usuário deveria ser redirecionado quando ele se autenticar. O segundo elemento especifica a URI onde o usuário deve ser redirecionado se a autenticação falhar. especifica a URI que processa as credenciais obtidas em que por sua vez indica a URI onde o formulário de login está presente. O elemento especifica a URI onde o usuário deveria ser redirecionado se ele não tem direitos de acesso à página. Por fim, especifica o URI do formulário de registro.
Na aplicação web devemos apenas criar uma página index.jsp de acordo com as configurações definidas no filtro. Um exemplo de formulário poderia ser como na Listagem 9.
<form action="/jGuard/LogonProcess.do">
Login: <input type="text" name="login"/>
Password: <input type="password" name="password"/>
<input type="submit" value="submit"/>
</form>Listagem 9. Exemplo de um formulário de login
O jGuard possui a classe AccessFilter que toma conta do processo de logon e logoff de acordo com as configurações nos arquivos.
Também podemos configurar o jGuard para trabalhar com Banco de Dados, o que é considerada uma boa prática e mais segura do que trabalhar com arquivos.
O leitor não precisa se preocupar se não entendeu as configurações dos arquivos, eles serão mais bem exercitados no exemplo prático mais abaixo, mas é importante saber para que serve cada um dos arquivos e entender o significados dos elementos presentes nesses arquivos.
Vantagens
Enquanto o JAAS é o framework oficial da especificação Java para tratar da segurança das aplicações, o jGuard oferece as mesmas funcionalidades do JAAS, inclusive sendo baseado no próprio JAAS, porém oferecendo diversas vantagens como simplicidade e rapidez.
O jGuard também é muito bem integrado ao framework Struts, não sendo nenhum pouco intrusivo e possui diversos exemplos na sua página oficial como fazer essa integração.
Desvantagens
O jGuard não possui um bom manual de apoio, deixando muito a desejar na sua documentação que por vezes é um pouco vaga demais. Outro problema do jGuard é que a sua integração com JSF costuma apresentar alguns problemas na autorização de chamadas de métodos de um Managed Bean, apesar disso existem formas de contornar o problema.
Por fim, o jGuard não cobre todos os tipos de aplicações, apenas aplicações web e standalone. Se quisermos implementar a segurança em webservices, ejb, etc, devemos procurar soluções que contemplam cada uma dessas aplicações.
Criando uma Aplicação com jGuard
Para utilizar o jGuard primeiramente devemos baixá-lo em aqui.
Agora no Eclipse crie um projeto do tipo “Dynamic Web Project”.
Para exemplificar o funcionamento do jGuard criaremos um projeto de login que acessa um recurso interno.
Primeiramente deveremos colocar uma série de bibliotecas do jGuard e outras que ele depende na pasta WEB-INF/lib do nosso projeto conforme podemos visualizar na Figura 1.
Além disso, deveremos criar outros artefatos como um Servlet controlador, vários arquivos de configuração exigidos pelo jGuard em WEB-INF/conf/jGuard, um arquivo web.xml com configurações do jGuard e por fim algumas páginas que exibirão ou solicitarão informações aos usuários. Veja como fica na Figura 2.
Agora que já sabemos tudo que devemos criar vamos primeiramente criar o Servlet que redireciona a solicitação para um recurso interno. Segue na Listagem 10 o código.
package servlets;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Controller extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
try {
RequestDispatcher d = request
.getRequestDispatcher("/recursointerno.jsp");
d.forward(request,response);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
}Listagem 10. Exemplo de um Servlet controlador que redireciona as solicitações para um recurso interno
Segue na Listagem 11 o arquivo web.xml com as configurações para o jGuard e uma configuração para o Servlet utilizado na aplicação. Não podemos esquecer que devemos seguir a ordem dos elementos no arquivo web.xml.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID"
version="2.5">
<display-name>TesteMongoDBjGuard</display-name>
<welcome-file-list>
<welcome-file>/index.jsp</welcome-file>
</welcome-file-list>
<context-param>
<param-name>authenticationConfigurationLocation
</param-name>
<param-value>/WEB-INF/conf/jGuard/jGuardAuthentication.xml
</param-value>
</context-param>
<context-param>
<param-name>authenticationScope</param-name>
<param-value>local</param-value>
</context-param>
<context-param>
<param-name>authorizationConfigurationLocation
</param-name>
<param-value>/WEB-INF/conf/jGuard/jGuardAuthorization.xml
</param-value>
</context-param>
<context-param>
<param-name>authorizationScope</param-name>
<param-value>local</param-value>
</context-param>
<context-param>
<param-name>enableJMX</param-name>
<param-value>false</param-value>
</context-param>
<filter>
<filter-name>AccessFilter</filter-name>
<filter-class>net.sf.jguard.jee.authentication
.http.AccessFilter</filter-class>
<init-param>
<param-name>configurationLocation</param-name>
<param-value>/WEB-INF/conf/jGuard/jGuardFilter.xml
</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>AccessFilter</filter-name>
<url-pattern>*</url-pattern>
</filter-mapping>
<listener>
<listener-class>net.sf.jguard.jee.listeners.SessionListener
</listener-class>
</listener>
<listener>
<listener-class>net.sf.jguard.jee.listeners.ContextListener
</listener-class>
</listener>
<servlet>
<servlet-name>frontcontroller</servlet-name>
<servlet-class>servlets.Controller</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>frontcontroller</servlet-name>
<url-pattern>/Controller</url-pattern>
</servlet-mapping>
</web-app>Listagem 11. Arquivo web.xml
Na Listagem 12 configuramos o arquivo jGuardAuthentication.xml. Uma observação importante é que não devemos esquecer-nos de colocar junto o arquivo jGuardAuthentication.dtd que vem junto com o jGuard que baixamos no site oficial anteriormente. As configurações do arquivo jGuardAuthentication.xml normalmente não mudam e seguem o padrão abaixo.
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE configuration SYSTEM "jGuardAuthentication.dtd">
<configuration>
<authentication>
<scope>local</scope>
<debug>true</debug>
<includeOldConfig>false</includeOldConfig>
<includeConfigFromJavaParam>false
</includeConfigFromJavaParam>
<includePolicyFromJavaParam>false
</includePolicyFromJavaParam>
<authenticationManager>net.sf.jguard.ext.authentication
.manager.XmlAuthenticationManager</authenticationManager>
<authenticationManagerOptions>
<option>
<name>authenticationXmlFileLocation</name>
<value>/WEB-INF/conf/jGuard/jGuardUsersPrincipals.xml</value>
</option>
</authenticationManagerOptions>
<loginModules>
<loginModule>
<name>net.sf.jguard.ext.authentication
.loginmodules.XmlLoginModule</name>
<flag>REQUIRED</flag>
<loginModuleOptions>
<option>
<name>debug</name>
<value>false</value>
</option>
</loginModuleOptions>
</loginModule>
</loginModules>
</authentication>
</configuration>Listagem 12. Configurações do arquivo jGuardAuthentication.xml
Na Listagem 13 configuramos o arquivo jGuardAuthorization.xml. que possui a configuração do arquivo jGuardPirncipalsPermissions.xml que contém as permissões relativas aos recursos. Neste arquivo e nos demais também devemos observar que estamos referenciando o arquivo jGuardAuthorization.dtd que deve também estar na mesma pasta de configuração do arquivo jGuardAuthorization.xml.
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE configuration SYSTEM "jGuardAuthorization.dtd">
<configuration>
<authorization>
<permissionResolutionCaching>true
</permissionResolutionCaching>
<authorizationManager>net.sf.jguard
.ext.authorization.manager.XmlAuthorizationManager
</authorizationManager>
<authorizationManagerOptions>
<option>
<name>authorizationXmlFileLocation</name>
<value>/WEB-INF/conf/jGuard/
jGuardPrincipalsPermissions.xml</value>
</option>
<option>
<name>debug</name>
<value>true</value>
</option>
</authorizationManagerOptions>
</authorization>
</configuration>Listagem 13. Configurações do arquivo jGuardAuthorization.xml
Outro arquivo muito importante que devemos configurar é o jGuardFilter.xml que possui todas as configurações relativa ao login, processamento, negação aos recursos, etc. No código da Listagem 14 estão incluídos comentários que explicam mais detalhadamente cada uma das linhas.
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE configuration SYSTEM "jGuardFilter.dtd">
<configuration>
<filter>
<!—Página principal da aplicação web. -->
<indexURI>/index.jsp</indexURI>
<!--Página quando a autenticação do usuário falha. -->
<authenticationFailedURI>/falhaautenticacao.jsp
</authenticationFailedURI>
<!—Página para acessar o formulário de autenticação -->
<logonURI>/loginForm.jsp</logonURI>
<!—Essa url deve ser a mesma configurada no
formulário acima e nunca deve ser j_security_check. -->
<logonProcessURI>/LogonProcess</logonProcessURI>
<registerURI>/Registro</registerURI>
<registerProcessURI>/RegistroProcess</registerProcessURI>
<!—Url utilizada para se deslogar da aplicação -->
<logoffURIs>
<logoffURI>/Logoff</logoffURI>
</logoffURIs>
<!--Url quando um recurso é negado -->
<accessDeniedURI>/loginForm.jsp</accessDeniedURI>
<authScheme>FORM</authScheme>
<!--Nome do parâmetro utilizado no formulário no campo de login -->
<loginField>login</loginField>
<!-- Nome do parâmetro utilizado no formulário no campo de senha -->
<passwordField>password</passwordField>
<goToLastAccessDeniedUriOnSuccess>true</goToLastAccessDeniedUriOnSuccess>
</filter>
</configuration>Listagem 14. Configurações do arquivo jGuardFilter.xml
Também precisamos configurar os usuários com seus respectivos login e senha para cada um deles. Segue na Listagem 15 um exemplo de configuração do arquivo jGuardUsersPrincipals.xml.
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE usersPrincipals SYSTEM "jGuardUsersPrincipals.dtd">
<usersPrincipals>
<principals>
<principal>
<name>admin</name>
<class>net.sf.jguard.core.principals.RolePrincipal</class>
<applicationName>TesteMongoDBjGuard</applicationName>
</principal>
<principal>
<name>guest</name>
<class>net.sf.jguard.core.principals.RolePrincipal</class>
<applicationName>TesteMongoDBjGuard</applicationName>
</principal>
</principals>
<users>
<userTemplate>
<name>default</name>
<privateRequiredCredentials>
<credTemplateId
identity="true">login</credTemplateId>
<credTemplateId
digestNeeded="true">password</credTemplateId>
</privateRequiredCredentials>
<publicRequiredCredentials>
</publicRequiredCredentials>
<privateOptionalCredentials>
</privateOptionalCredentials>
<publicOptionalCredentials>
</publicOptionalCredentials>
<genericPrincipals>
<principalRef name="admin"
applicationName="TesteMongoDBjGuard"/>
<principalRef name="guest"
applicationName="TesteMongoDBjGuard"/>
</genericPrincipals>
<specificPrincipalFactories/>
</userTemplate>
<user>
<privateCredentials>
<credential>
<id>login</id>
<value>admin</value>
</credential>
<credential>
<id>password</id>
<value>admin</value>
</credential>
</privateCredentials>
<publicCredentials>
</publicCredentials>
<principalsRef>
<principalRef name="admin"
applicationName="TesteMongoDBjGuard"
active="true"/>
</principalsRef>
</user>
<user>
<privateCredentials>
<credential>
<id>login</id>
<value>guest</value>
</credential>
<credential>
<id>password</id>
<value>guest</value>
</credential>
</privateCredentials>
<publicCredentials/>
<principalsRef>
<principalRef name="guest"
applicationName="TesteMongoDBjGuard" active="true"/>
</principalsRef>
</user>
</users>
</usersPrincipals>Listagem 15. Configurações do arquivo jGuardUsersPrincipals.xml
Por fim, configuramos o acesso de cada usuário a cada recurso do sistema. Segue na Listagem 16 um exemplo de configuração do arquivo jGuardPrincipalsPermissions.xml.
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE configuration SYSTEM "jGuardPrincipalsPermissions.dtd">
<configuration>
<permissions>
<domain>
<name>public</name>
<permission>
<name>paginaprincipal</name>
<class>net.sf.jguard.core.authorization
.permissions.URLPermission</class>
<actions>
<action>index.jsp</action>
</actions>
</permission>
<permission>
<name>registro</name>
<class>net.sf.jguard.core.authorization
.permissions.URLPermission</class>
<actions>
<action>loginForm.jsp</action>
</actions>
</permission>
</domain>
<domain>
<name>vip</name>
<permission>
<name>acessoTotal</name>
<class>net.sf.jguard.core.authorization
.permissions.URLPermission</class>
<actions>
<action>/*</action>
<action>acesso completo a
qualquer recurso</action>
</actions>
</permission>
</domain>
</permissions>
<principals>
<principal>
<name>guest</name>
<class>net.sf.jguard.core.principals.RolePrincipal
</class>
<permissionsRef>
<permissionRef name="paginaprincipal"/>
<permissionRef name="registro"/>
</permissionsRef>
</principal>
<principal>
<name>admin</name>
<class>net.sf.jguard.core.principals.RolePrincipal
</class>
<permissionsRef>
<domainRef name="public"/>
<domainRef name="vip"/>
</permissionsRef>
</principal>
</principals>
</configuration>Listagem 16. Configurações do arquivo jGuardPrincipalsPermissions.xml
Agora que o controlador está criado e todos os arquivos de configuração estão configurados devemos criar as JSPs que são os recursos da nossa aplicação. Segue na listagem 17 a JSP de entrada da nossa aplicação index.jsp:
<html>
<body>
<a href="/TesteMongoDBjGuard/Controller">Acesse um recurso interno aqui</a>
</body>
</html>Listagem 17. Arquivo index.jsp que possui um link de acesso a um recurso interno da aplicação
Na Listagem 18 criamos o arquivo que é acessado através do link acima:
<html>
<body>
Acessando um Recurso interno.
</body>
</html>Listagem 18. Arquivo recursointerno.jsp
Também precisamos da página de login que dá acesso aos usuários à aplicação. Segue na Listagem 19 o código referente ao formulário de autenticação:
<html>
<body>
Digite o nome de usuário e senha. <br/><br/>
<form action="/TesteMongoDBjGuard/LogonProcess" method="post">
Login: <input type="text" name="login"/> <br/>
Senha: <input type="password" name="password"/> <br/><br/>
<input type="submit" value="submit"/>
</form>
</body>
</html>Listagem 19. Arquivo loginForm.jsp para autenticação
Nas Listagens 20 e 21 seguem os códigos das páginas de negação de recurso e falha de autenticação:
<html>
<body>
Falha na Autenticação! <br/>
Volte e tente novamente.
</body>
</html>Listagem 20. Arquivo falhaautenticacao.jsp quando o usuário ou senha não correspondem aos arquivos de configuração
<html>
<body>
Recurso NEGADO! <br/>
Você não tem permissão para acessar este recurso.
</body>
</html>Listagem 21. Arquivo recursonegado.jsp quando usuário não tem permissão para acessar um recurso
Execute a aplicação e tente logar com um usuário que não existe, após tente com um usuário que tenha permissão (admin/admin), tente também criar um usuário sem acesso ao recurso interno. Modifique o exemplo e tente outras formas de proteger recursos e liberar outros como a página index para que todos os usuários tenham acesso a ela.
Referências:
Confira outros conteúdos:
Por
Higor
Em 2014
Veja os resultado dos nossos alunos
Conquistas reais de quem está aplicando o método
<Perguntas frequentes>
Carreira
Metodologia
Assinatura e Pagamentos
Cadastro