Você pode especificar o provedor de autorização da sua preferência em seu arquivo de configuração XML do Spring. Você pode fazer isso ao configurar authentication-manager como definido no esquema http://www.springframework.org/schema/security/spring-security-3.1.xsd do Spring.
1: <xs:element name="authentication-manager">
2: <xs:complexType>
3: <xs:choice minOccurs="0" maxOccurs="unbounded">
4: <xs:element name="authentication-provider">
5: <xs:complexType>
6: <xs:choice minOccurs="0" maxOccurs="unbounded">
7: <xs:element ref="security:any-user-service"/>
8: <xs:element name="password-encoder">...</xs:element>
9: </xs:choice>
10: <xs:attributeGroup ref="security:ap.attlist"/>
11: </xs:complexType>
12: </xs:element>
13: <!-- This is BIG -->
14: <xs:element name="ldap-authentication-provider">...</xs:element>
15: </xs:choice>
16: <xs:attributeGroup ref="security:authman.attlist"/>
17: </xs:complexType>
18: </xs:element>
Isso significa, por exemplo, que você pode usar qualquer provedor de autenticação, incluindo autenticação simples e JDBC, como mostrado no snippet abaixo:
1: <authentication-manager alias="authenticationManager">
2: <authentication-provider>
3: <user-service>
4: <user authorities="ROLE_GUEST" name="guest" password=""/>
5: </user-service>
6: </authentication-provider>
7: <authentication-provider>
8: <jdbc-user-service data-source-ref="dataSource"/>
9: </authentication-provider>
10: </authentication-manager>
Dois
Você pode configurar as regras de autenticação em seu arquivo XML do Spring ao lincar as URLs às regras do usuário utilizando o elemento intercept-url. O elemento intercept-url é um elemento filho do elemento http, cuja definição resumida parece com isto:
1: <xs:element name="http">
2: <xs:complexType>
3: <xs:choice minOccurs="0" maxOccurs="unbounded">
4: <xs:element name="intercept-url">
5: <xs:complexType>
6: <xs:attributeGroup ref="security:intercept-url.attlist"/>
7: </xs:complexType>
8: </xs:element>
9: <!-- Details omitted for clarity -->
10: <xs:element name="access-denied-handler">...</xs:element>
11: <xs:element name="form-login">...</xs:element>
12: <xs:element name="openid-login">...</xs:element>
13: <xs:element name="x509">...</xs:element>
14: <xs:element ref="security:jee"/>
15: <xs:element name="http-basic">...</xs:element>
16: <xs:element name="logout">...</xs:element>
17: <xs:element name="session-management">...</xs:element>
18: <xs:element name="remember-me">...</xs:element>
19: <xs:element name="anonymous">...</xs:element>
20: <xs:element name="port-mappings">...</xs:element>
21: <xs:element ref="security:custom-filter"/>
22: <xs:element ref="security:request-cache"/>
23: <xs:element name="expression-handler">...</xs:element>
24: </xs:choice>
25: <xs:attributeGroup ref="security:http.attlist"/>
26: </xs:complexType>
27: </xs:element>
Exemplo de uso:
1: <security:http>
2: <security:intercept-url pattern="/admin/**" access="hasRole('ROLE_ADMIN')"/>
3: <security:intercept-url pattern="/account/**" access="hasRole('ROLE_USER')" />
4: <security:intercept-url pattern="/**" access="hasRole('ROLE_ANONYMOUS')" />
5: <!-- other elements removed for clarity -->
6: </security:http>
Três
Você pode codificar e validar a senha utilizando diversas classes que implementam a interface org.springframework.security.authentication.encoding.PasswordEncoder do Spring. Ela tem apenas dois métodos: encodePassword e isPasswordValid. Suas muitas implementações incluem:
- BaseDigestPasswordEncoder
- BasePasswordEncoder
- LdapShaPasswordEncoder
- Md4PasswordEncoder,
- Md5PasswordEncoder
- MessageDigestPasswordEncoder
- MessageDigestPasswordEncoder
- PlaintextPasswordEncoder
- ShaPasswordEncoder
Você pode restringir o acesso a elementos da página utilizando a tag da biblioteca do Spring Security. Para utilizar essa biblioteca, deve incluir a seguinte definição de taglib em seu JSP:
<%@ taglib prefix=”sec” uri=”http://www.springframework.org/security/tags” %>
A taglib contém três tags úteis:
- authorize
- authentication
- accesscontrollist
1: <sec:authorize access="hasRole('supervisor')">
2: This content will only be visible to users who have
3: the "supervisor" authority in their list of <tt>GrantedAuthority</tt>s.
4: </sec:authorize>
e autorizar através de URLs
1: <sec:authorize url="/admin">
2: This content will only be visible to users who are authorized to send requests to the "/admin" URL.
3: </sec:authorize>
A URL especificada deve estar amarrada à tag intercept-url descrita no item 2.
Cinco
Você pode realizar autorização no nível de método utilizando as anotações do Spring.
@PreAuthorize(“spEL expression”)
@PostAuthorize(“spEL expression”)
@Secure
onde a expressão spEL pode ser qualquer coisa, mas normalmente é algo como: hasRole(‘ROLE_USER’).
Para permitir @PreAuthorize(…) e @PostAuthorize(…), adicione o seguinte ao arquivo de configuração XML:
1: <global-method-security pre-post-annotations="”enabled”"></global-method-security>
@PreAuthorize(…) é utilizado como mostrado no exemplo a seguir:
1: @PreAuthorize("hasRole('ROLE_ADMIN')")
2: public void deleteUser(String username);
Para permitir @Secure, adicione o texto a seguir ao arquivo de configuração do Spring:
1: <global-method-security pre-post-annotations=”enabled” />
Seis
Você pode realizar segurança pelo nível de método utilizando a implementação JSR-250 do Spring ao acrescentar a configuração seguinte ao arquivo do Spring:
1: <global-method-security jsr250-annotations=”enabled”/>
As anotações da segurança JSR-250 são um subconjunto das anotações do JSR-250 e incluem:
- @RolesAllowed({“ROLE_USER”,”ROLE_ADMIN”})
- @PermitAll
- @DenyAll
1: @RolesAllowed({"ROLE_ADMIN","ROLE_USER"})
2: public void deleteUser(String username);
Sete
Você pode integrar o Spring Security com a autenticação OpenID em pouco passos. O primeiro deles é escrever um formulário JSP simples onde o valor de ação está configurado para j_spring_openid_security_check, que, no mínimo, parece com algo deste tipo:
1: <form action="j_spring-openid-security-check" method="post">
2: <label for="openid_idenifier">Login</label>:
3: <input id="openid_identifier" name="openid_identifier" type="text"/>
4: <input type="submit" value="Login" />
5: </form>
O próximo passo é acrescentar o elemento openid-login ao http:
1: <xs:element name="http">
2: <xs:complexType>
3: <xs:choice minOccurs="0" maxOccurs="unbounded">
4: <xs:element name="openid-login">
5: <xs:annotation>
6: <xs:documentation>
7: Sets up form login for authentication with an
8: Open ID identity
9: </xs:documentation>
10: </xs:annotation>
11: <xs:complexType>
12: <xs:sequence>
13: <xs:element minOccurs="0" maxOccurs="unbounded"
14: ref="security:attribute-exchange" />
15: </xs:sequence>
16: <xs:attributeGroup ref="security:form-login.attlist" />
17: <xs:attribute name="user-service-ref" type="xs:token">
18: <xs:annotation>
19: <xs:documentation>
20: A reference to a user-service (or
21: UserDetailsService bean) Id
22: </xs:documentation>
23: </xs:annotation>
24: </xs:attribute>
25: </xs:complexType>
26: </xs:element>
27: <!-- Other elements omitted for clarity -->
28: </xs:choice>
29: </xs:complexType>
30: </xs:element>
Como todos os elementos filhos do openid-login são opcionais, o jeito mais simples de dar permissão ao OpenID é escrever:
1: <http auto-config="true">
2: <openid-login/>
3: <!-- other tags and attributes omitted for clarity -->
4: </http>
Por último, você irá precisar acrescentar o spring-security-openid.jar ao seu projeto.
Oito
Você pode configurar o seu aplicativo para autenticar ao usuários com um servidor LDAP (Lightweight Directory Access Protocol) embutido utilizando a configuração XML. Isso está descrito no esquema XML resumido abaixo:
1: <xs:element name="ldap-server">
2: <xs:complexType>
3: <xs:attributeGroup ref="security:ldap-server.attlist" />
4: </xs:complexType>
5: </xs:element>
6: <xs:attributeGroup name="ldap-server.attlist">
7: <xs:attribute name="id" type="xs:token">
8: <xs:annotation>
9: <xs:documentation>
10: A bean identifier, used for referring to the bean elsewhere in the context.
11: </xs:documentation>
12: </xs:annotation>
13: </xs:attribute>
14: <xs:attribute name="port" type="xs:positiveInteger"/>
15: <xs:attribute name="ldif" type="xs:string">
16: <xs:annotation>
17: <xs:documentation>
18: Explicitly specifies an ldif file resource to load
19: into an embedded LDAP
20: server. The default is classpath*:*.ldiff
21: </xs:documentation>
22: </xs:annotation>
23: </xs:attribute>
24: <xs:attribute name="root" type="xs:string">
25: <xs:annotation>
26: <xs:documentation>
27: Optional root suffix for the embedded LDAP server. Default is
28: "dc=springframework,dc=org"
29: </xs:documentation>
30: </xs:annotation>
31: </xs:attribute>
32: </xs:attributeGroup>
O arquivo LDIF, onde LDIF significa “LDAP Interchange Format”, é um arquivo em formato texto puro utilizado para descrever um conjunto de registros LDAP.
Um exemplo de uso do elemento ldap-server poderia ser:
1: <ldap-server ldif=”classpath:my-ldif-file.ldif” id=”localserver” />
Para utilizar a integração do LDAP com o Spring Security, lembre-se de incluir o arquivo spring-security-ldap.jar no POM.XML do seu projeto.
Nove
Você pode configurar o seu aplicativo para autenticar usuários com um servidor LDAP remoto utilizando a configuração XML. Isto está descrito no esquema XML exibido abaixo:
1: <xs:element name="ldap-server">
2: <xs:complexType>
3: <xs:attributeGroup ref="security:ldap-server.attlist" />
4: </xs:complexType>
5: </xs:element>
6: <xs:attributeGroup name="ldap-server.attlist">
7: <xs:attribute name="id" type="xs:token">
8: <xs:annotation>
9: <xs:documentation>
10: A bean identifier, used for referring to the bean elsewhere
11: in the context.
12: </xs:documentation>
13: </xs:annotation>
14: </xs:attribute>
15: <xs:attribute name="url" type="xs:token"/>
16: <xs:attribute name="port" type="xs:positiveInteger"/>
17: <xs:attribute name="manager-dn" type="xs:string">
18: <xs:annotation>
19: <xs:documentation>
20: Username (DN) of the "manager" user identity which will be used to
21: authenticate to a (non-embedded) LDAP server. If omitted, anonymous
22: access will be used.
23: </xs:documentation>
24: </xs:annotation>
25: </xs:attribute>
26: <xs:attribute name="manager-password" type="xs:string">
27: <xs:annotation>
28: <xs:documentation>
29: The password for the manager DN. This is required
30: if the manager-dn is specified.
31: </xs:documentation>
32: </xs:annotation>
33: </xs:attribute>
34: </xs:attributeGroup>
A documentação afirma que o elemento ldap-server “Define a localização de um servidor LDAP ou inicia um servidor embutido. A url indica a localização do servidor remoto. Se nenhuma url for fornecida, um servidor embutido será iniciado, e ficará escutando no número da porta fornecida. A porta é opcionalm e a porta padrão 33389 é utilizada. O bean LDAP ContextSource do Spring será registrado pelo servidor com o id fornecido”.
Este é o exemplo de uma configuração realmente mínima:
1: <ldap-server url=”ldap://myServer/dc=captaindebug,dc=com:389″ id=”ldapExternal”
2: manager-dn=”uid=admin,ou=users,ou=systems” manager-password=”s3cret”/>
Uma vez tendo o servidor configurado, você também precisa configurar o fornecedor da autenticação LDAP. Parece haver vários métodos para fazer isso, e não é algo tão objetivo, portanto, possivelmente falarei mais sobre isso mais tarde…
Dez
Você pode adicionar o atributo requires-channel=”https” ao elemento
1: <http auto-config="true" use-expressions="true">
2: <intercept-url pattern="/login" requires-channel="https"/>
3: <!-- Other attributes and elements omitted -->
4: </https>
Talvez você tenha percebido que eu utilizei o arquivo de esquema XML do Spring Security (http://www.springframework.org/schema/security/spring-security-3.1.xsd) para explicar alguns dos recursos na minha lista de coisas que você pode fazer com o Spring Security.
Em novembro de 2011, escrevi um artigo sobre a anotação @PostConstruct do JSR-250 do Spring que continha um erro (sim, de fato acontece), que foi corretamente apontado pelo Chris Beam – @Cbeam, que deixou um comentário na versão JavaLobby do meu blog. Decidi checar os esquemas e percebi que ambos estavam incorretos (apesar de estar bem mais errado do que o Chris) – o artigo do Captain Debug está agora, até onde sei, correto.
Segurança em aplicativos é um tema complexo e, caso seja alguma coisa que você esteja querendo olhar mais de perto, sugiro adquirir uma cópia do Spring Security 3, de Peter Mularien – que também é recomendado pelo pessoal do Spring.
Finalmente, se há uma ideia importante para apreciar sobre o Spring Security é que, como uma ferramenta de aplicativo, ele permite uma riqueza recursos de ajustes de segurança. Você deveria, portanto, permitir que o Spring Security lidasse com o máximo de detalhes de segurança possível, em vez de desnecessariamente escrever seu próprio código.
Publicado originalmente em http://www.captaindebug.com/2012/11/a-list-of-things-you-can-do-with-spring.html#.UX_9REBDs25