Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Spring Security 3.1 – "How Tos" Demystified

Spring Security 3.1 – "How Tos" Demystified

Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Like all Spring projects, the real power of Spring Security is found in how easily it can be extended to meet custom requirements. In this presentation we will incrementally apply Spring Security to an existing application to demonstrate how it can meet our authentication and authorization needs. It will also answer many of the common "How To" questions that are found on the forums. This will ensure that you can not only secure your application quickly, but ensure you understand Spring Security well enough to extend it to meet your custom requirements.

More Decks by Clarence J M Tauro (Couchbase)

Other Decks in Programming

Transcript

  1. Copyright 2005-2008 SpringSource. Copying, publishing or distributing without express written

    permission is prohibited. Spring Security 3.1 "How Tos" Demystified Addressing Common Web Application Security Requirements
  2. 2 Who am I? • Clarence J M Tauro –

    [email protected] • Instructor at SpringSource – a division of Pivotal • ~9 Years Professional Teaching and Instructional Design Experience • Guest faculty to various Colleges and Universities • Masters of Science in Information Technology • Masters of Technology in Computer Science • Masters of Philosophy in Computer Science • Doctor of Philosophy in Computer Science [expected to graduate by August 2014]
  3. 3 Topics in this Session • High-Level Security Overview •

    Motivations of Spring Security • Spring Security in a Web Environment • Configuring Web Authentication • Using Spring Security's Tag Libraries • Method security • Advanced security: working with filters
  4. 4 Security Concepts • Principal – User, device or system

    that performs an action • Authentication – Establishing that a principal’s credentials are valid • Authorization – Deciding if a principal is allowed to perform an action • Secured item – Resource that is being secured
  5. 5 Authentication •There are many authentication mechanisms –e.g. basic, digest,

    form, X.509 •There are many storage options for credential and authority information –e.g. Database, LDAP, in-memory (development)
  6. 6 Authorization •Authorization depends on authentication –Before deciding if a

    user can perform an action, user identity must be established •The decision process is often based on roles –ADMIN can cancel orders –MEMBER can place orders –GUEST can browse the catalog
  7. 7 Topics in this Session •High-Level Security Overview •Motivations of

    Spring Security •Spring Security in a Web Environment •Configuring Web Authentication •Using Spring Security's Tag Libraries •Method security •Advanced security: working with filters
  8. 8 Motivations: Portability •Servlet-Spec security is not portable –Requires container

    specific adapters and role mappings •Spring Security is portable across containers –Secured archive (e.g. WAR) can be deployed as-is –Also runs in standalone environments
  9. 9 Motivations: Flexibility •Supports all common authentication mechanisms –Basic, Form,

    X.509, Cookies, Single-Sign-On, etc. •Provides configurable storage options for user details (credentials and authorities) –RDBMS, LDAP, Properties file, custom DAOs, etc. •Uses Spring for configuration
  10. 10 Motivations: Extensibility •Security requirements often require customization •With Spring

    Security, all of the following are extensible –How a principal is defined –Where authentication information is stored –How authorization decisions are made –Where security constraints are stored
  11. 11 Motivations: Separation of Concerns •Business logic is decoupled from

    security concerns –Leverages Servlet Filters and Spring AOP for an interceptor-based approach •Authentication and Authorization are decoupled –Changes to the authentication process have no impact on authorization
  12. 12 Motivations: Consistency •The goal of authentication is always the

    same regardless of the mechanism –Establish a security context with the authenticated principal’s information •The process of authorization is always the same regardless of resource type –Consult the attributes of the secured resource –Obtain principal information from security context –Grant or deny access
  13. 13 Spring Security: the Big Picture Security Context Authentication (Principal

    + Authorities) Secured Resource Authentication Manager populates thread of execution obtains AccessDecision Manager delegates Config Attributes describes consults protects Security Interceptor Voters polls
  14. 14 Topics in this Session •High-Level Security Overview •Motivations of

    Spring Security •Spring Security in a Web Environment – Authorization by URL •Configuring Web Authentication •Using Spring Security's Tag Libraries •Method security •Advanced security: working with filters
  15. 15 Configuration in the Application Context •Spring configuration •Using Spring

    Security's "Security" namespace <beans> <security:http> <security:intercept-url pattern="/accounts/**" access="IS_AUTHENTICATED_FULLY" /> <security:form-login login-page="/login.htm"/> <security:logout logout-success-url="/index.html"/> </security:http> </beans> Match all URLs starting with /accounts/ (ANT-style path) Spring configuration file
  16. 16 Configuration in web.xml •Define the single proxy filter –springSecurityFilterChain

    is a mandatory name –Refers to an existing Spring bean with same name <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> web.xml
  17. 17 intercept-url •intercept-urls are evaluated in the order listed –the

    first match will be used –specific matches should be put on top <beans> <security:http> <security:intercept-url pattern="/accounts/edit*" access="ROLE_ADMIN" /> <security:intercept-url pattern="/accounts/account*" access="ROLE_ADMIN,ROLE_USER" /> <security:intercept-url pattern="/accounts/**" access="IS_AUTHENTICATED_FULLY" /> <security:intercept-url pattern="/customers/**" access="IS_AUTHENTICATED_ANONYMOUSLY" /> </security:http> </beans> Syntax available from Spring Security 2.0
  18. 18 Security EL expressions • hasRole('role') – Checks whether the

    principal has the given role • hasAnyRole('role1', 'role2', …) – Checks whether the principal has any of the given roles • isAnonymous() – Allows access for unauthenticated principals • isAuthenticated() – Allows access for authenticated or remembered principals Available from Spring Security 3.0 Previous syntax still works in Spring Security 3.0
  19. 19 Intercept-url and Expression Language •Expression Language provides more flexibility

    – Many built-in expressions available <beans> <security:http use-expressions="true"> <security:intercept-url pattern="/accounts/edit*" access="hasRole('ROLE_ADMIN')" /> <security:intercept-url pattern="/accounts/account*" access="hasAnyRole('ROLE_ADMIN', 'ROLE_USER')" /> <security:intercept-url pattern="/accounts/**" access="isAuthenticated() and hasIpAddress('192.168.1.0/24')" /> </security:http> </beans> Expression Language needs to be enabled explicitly Spring configuration file
  20. 20 Working with roles • Checking if the user has

    one single role • “or” clause • “and” clause • Previous and new syntax can't be mixed <security:intercept-url pattern="/accounts/update*" access="hasRole('ROLE_ADMIN')" /> <security:intercept-url pattern="/accounts/update*" access="hasAnyRole('ROLE_ADMIN', 'ROLE_MANAGER')" /> <security:intercept-url pattern="/accounts/update*" access="hasRole('ROLE_ADMIN') and hasRole('ROLE_MANAGER')" /> <security:intercept-url pattern="/accounts/update*" access="hasRole('ROLE_MANAGER')" /> <security:intercept-url pattern="/accounts/update*" access="ROLE_ADMIN" /> Not correct!!
  21. 21 <beans ...> <security:http pattern="/accounts/login" security="none"/> <security:http use-expressions="true"> <security:form-login login-page="/accounts/login"

    default-target-url="/accounts.home"/> <security:intercept-url pattern="/accounts/update*" access="hasAnyRole('ROLE_ADMIN', 'ROLE_MANAGER')" /> <security:intercept-url pattern="/accounts/**" access="hasRole('ROLE_ADMIN')" /> <security:logout logout-success-url="/home.html" </security:http> ... </beans> Spring configuration file Specifying login and logout Specify login options Must be declared explicitly or no logout possible Exempt login page (Spring Security 3.1)
  22. 22 Topics in this Session •High-Level Security Overview •Motivations of

    Spring Security •Spring Security in a Web Environment •Configuring Web Authentication •Using Spring Security's Tag Libraries •Method security •Advanced security: working with filters
  23. 23 Setting up User Login • Default auth. provider assumes

    form-based login – This is web security after all – Must specify form-login element – A basic form is provided – Configure to use your own login-page <security:http> <security:form-login/> … </security:http> <security:authentication-manager> <security:authentication-provider> ... </security:authentication-provider> <security:authentication-manager>
  24. 24 An Example Login Page <form action=“<c:url value=’j_spring_security_check’/>” method=“POST”> <input

    type=“text” name=“j_username”/> <br/> <input type=“password” name=“j_password”/> <br/> <input type=“submit” name=“submit” value=“LOGIN”/> </form> The expected keys for generation of an authentication request token URL that indicates an authentication request Above example shows default values (j_spring_security_check, j_username, j_password). All of them can be redefined using <security:form-login/> login-example.jsp
  25. 25 The In-Memory User Service •Useful for development and testing

    – Note: must restart system to reload properties <security:authentication-manager> <security:authentication-provider> <security:user-service properties="/WEB-INF/users.properties" /> </security:authentication-provider> <security:authentication-manager> Spring configuration file admin=secret,ROLE_ADMIN,ROLE_MEMBER,ROLE_GUEST testuser1=pass,ROLE_MEMBER,ROLE_GUEST testuser2=pass,ROLE_MEMBER guest=guest,ROLE_GUEST List of roles separated by commas login password
  26. 26 The JDBC user service (1/2) Queries RDBMS for users

    and their authorities •Provides default queries –SELECT username, password, enabled FROM users WHERE username = ? –SELECT username, authority FROM authorities WHERE username = ? • Groups also supported – groups, group_members, group_authorities tables – See online documentation for details • Advantage – Can modify user info whilst system is running
  27. 27 The JDBC user service (2/2) • Configuration: <beans> <security:http>

    … <security:http> <security:authentication-manager> <security:authentication-provider> <security:jdbc-user-service data-source-ref="myDatasource" /> </security:authentication-provider> <security:authentication-manager> </beans> Spring configuration file Can customize queries using attributes: users-by-username-query authorities-by-username-query group-authorities-by-username-query
  28. 28 Password Encoding • Can encode passwords using a hash

    – sha, md5, … • Secure passwords using a well-known string – Known as a 'salt' – Makes brute force attacks against passwords harder <security:authentication-provider> <security:password-encoder hash="md5"> <security:salt-source system-wide="MySalt" /> </security:password-encoder> <security:user-service properties="/WEB-INF/users.properties" /> </security:authentication-provider> <security:authentication-provider> <security:password-encoder hash="md5" /> <security:user-service properties="/WEB-INF/users.properties" /> </security:authentication-provider> simple md5 encoding md5 encoding with salt
  29. 29 Other Authentication Options •Implement a custom UserDetailsService –Delegate to

    an existing User repository or DAO •LDAP •X.509 Certificates •JAAS Login Module •Single-Sign-On –SiteMinder –Kerberos –JA-SIG Central Authentication Service Authorization is not affected by changes to Authentication!
  30. 30 Topics in this Session •High-Level Security Overview •Motivations of

    Spring Security •Spring Security in a Web Environment •Configuring Web Authentication •Using Spring Security's Tag Libraries •Method security •Advanced security: working with filters
  31. 31 Tag library declaration •The Spring Security tag library is

    declared as follows •Facelet tags for JSF are also available – You need to define and install them manually – See “Using the Spring Security Facelets Tag Library” in the Spring Webflow documentation – Principle is available in SpEL: #{principle.username} <%@ taglib prefix="security" uri="http://www.springframework.org/security/tags" %> available since Spring Security 2.0 jsp
  32. 32 Spring Security’s Tag Library •Display properties of the Authentication

    object •Hide sections of output based on role You are logged in as: <security:authentication property=“principal.username”/> <security:authorize access=“hasRole('ROLE_MANAGER')”> TOP-SECRET INFORMATION Click <a href=“/admin/deleteAll”>HERE</a> to delete all records. </security:authorize> jsp jsp
  33. 33 Authorization in JSP based on intercept-url •Role declaration can

    be centralized in Spring config files <security:authorize url=“/admin/deleteAll”> TOP-SECRET INFORMATION Click <a href=“/admin/deleteAll”>HERE</a> </security:authorize> <security:intercept-url pattern="/admin/*" access="hasAnyRole('ROLE_MANAGER', 'ROLE_ADMIN')" /> URL to protect Spring configuration file jsp Matching roles Pattern that matches the URL to be protected
  34. 34 Topics in this Session •High-Level Security Overview •Motivations of

    Spring Security •Spring Security in a Web Environment •Configuring Web Authentication •Using Spring Security's Tag Libraries •Method security •Advanced security: working with filters
  35. 35 Method Security •Spring Security uses AOP for security at

    the method level –xml configuration with the Spring Security namespace –annotations based on Spring annotations or JSR-250 annotations • Typically secure your services – Do not access repositories directly, bypasses security (and transactions)
  36. 36 Method Security using XML •Can apply security to multiple

    beans with only a simple declaration <security:global-method-security> <security:protect-pointcut expression="execution(* com.springsource..*Service.*(..))" access="ROLE_USER,ROLE_MEMBER" /> </security:global-method-security> Spring configuration file Spring Security 2 syntax only. SpEL not supported here.
  37. 37 Method Security - JSR-250 •JSR-250 annotations should be enabled

    <security:global-method-security jsr250-annotations="enabled" /> import javax.annotation.security.RolesAllowed; public class ItemManager { @RolesAllowed("ROLE_MEMBER") public Item findItem(long itemNumber) { ... } } @RolesAllowed({"ROLE_MEMBER", "ROLE_USER"}) Only supports role-based security – hence the name
  38. 38 Topics in this Session •High-Level Security Overview •Motivations of

    Spring Security •Spring Security in a Web Environment •Configuring Web Authentication •Using Spring Security's Tag Libraries •Method security •Advanced security: working with filters
  39. 39 Spring Security in a Web Environment •springSecurityFilterChain is declared

    in web.xml •This single proxy filter delegates to a chain of Spring-managed filters –Drive authentication –Enforce authorization –Manage logout –Maintain SecurityContext in HttpSession –and more
  40. 40 Web Security Filter Configuration Web User Servlet Servlet Container

    Spring ApplicationContext Filter 2 … Filter N DelegatingFilterProxy springSecurityFilterChain Filter 1
  41. 41 The Filter chain •With ACEGI Security 1.x –Filters were

    manually configured as individual <bean> elements –Led to verbose and error-prone XML •Spring Security 2.x and 3.x –Filters are initialized with correct values by default –Manual configuration is not required unless you want to customize Spring Security's behavior –It is still important to understand how they work underneath
  42. 42 Access Unsecured Resource Prior to Login Web Browser UnsecuredResource

    FilterSecurityInterceptor ExceptionTranslationFilter UsernamePasswordProcessingFilter SecurityContextPersistenceFilter LogoutFilter No context in session Establishes empty security context Not a logout request does nothing Not an authentication request does nothing Does nothing on request side Resource has no security attributes does nothing Resource has no security attributes does nothing No exceptions thrown does nothing Does nothing on response side Does nothing on response side Context did not change so no need to store in session Clears context
  43. 43 Access Secured Resource Prior to Login Web Browser SecuredResource

    FilterSecurityInterceptor ExceptionTranslationFilter UsernamePasswordProcessingFilter SecurityContextPersistenceFilter LogoutFilter No context in session Establishes empty security context Does nothing Does nothing Does nothing Resource is secured THROWS NOT AUTHENTICATED EXCEPTION Authentication exception! • Saves current request in session •Clears context •Redirects to authentication entry point x Login Form
  44. 44 Submit Login Request Web Browser SecuredResource FilterSecurityInterceptor ExceptionTranslationFilter UsernamePasswordProcessingFilter

    SecurityContextPersistenceFilter LogoutFilter No context in session Establishes empty security context Does nothing Creates request and delegates to the Authentication Manager •SUCCESS populates context redirects to target url •FAILURE redirects to failure url
  45. 45 Access Resource With Required Role Web Browser SecuredResource FilterSecurityInterceptor

    ExceptionTranslationFilter UsernamePasswordProcessingFilter SecurityContextPersistenceFilter LogoutFilter Finds context in session and sets for current thread Does nothing Does nothing Does nothing Consults attributes, obtains context, and delegates to access decision manager Does nothing Does nothing Stores context back into session Does nothing Does nothing
  46. 46 Access Resource Without Required Role Web Browser SecuredResource FilterSecurityInterceptor

    ExceptionTranslationFilter UsernamePasswordProcessingFilter SecurityContextPersistenceFilter LogoutFilter Finds context in session and sets for current thread Does nothing Does nothing Does nothing Throws ACCESS DENIED EXCEPTION x Consults attributes, obtains context, and delegates to access decision manager Access Denied Exception! • Puts exception in request scope • Forwards to the error page Error Page
  47. 47 Submit Logout Request Web Browser SecuredResource FilterSecurityInterceptor ExceptionTranslationFilter UsernamePasswordProcessingFilter

    SecurityContextPersistenceFilter LogoutFilter Finds context in session and sets for current thread • Clears context • Redirects to logout success url Logout Success
  48. 48 The Filter Chain: Summary # Filter Name Main Purpose

    1 SecurityContext IntegrationFilter Establishes SecurityContext and maintains between HTTP requests formerly: HttpSessionContextIntegrationFilter 2 LogoutFilter Clears SecurityContextHolder when logout requested 3 UsernamePassword Processing Filter Puts Authentication into the SecurityContext on login request formerly: AuthenticationProcessingFilter 4 Exception TranslationFilter Converts SpringSecurity exceptions into HTTP response or redirect 5 FilterSecurity Interceptor Authorizes web requests based on on config attributes and authorities
  49. Copyright 2005-2008 SpringSource. Copying, publishing or distributing without express written

    permission is prohibited. Questions? Applying Security to a Web Application