{"id":616,"date":"2011-10-19T14:56:00","date_gmt":"2011-10-19T14:56:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/apache-shiro-application-security-made-easy.html"},"modified":"2012-10-21T20:26:36","modified_gmt":"2012-10-21T20:26:36","slug":"apache-shiro-application-security-made","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/10\/apache-shiro-application-security-made.html","title":{"rendered":"Apache Shiro : Application Security Made Easy"},"content":{"rendered":"
Considering that JAVA is over 10+ years old, the number of choices for application developers that need to build authentication and authorization into their applications is shockingly low.<\/p>\n

In JAVA & J2EE, the JAAS specification was an attempt to address security. While JAAS works for authentication, the authorization part is just too cumbersome to use. The EJB and Servlet specifications offer coarse grained authorization at a method and resource level. But these are too coarse to be of any use in real world applications. For Spring users, Spring Security is an alternative. But it is a little complicated to use, especially the authorization model. A majority of applications end up building their home grown solutions for authentication and authorization.<\/p>\n

Apache Shiro<\/a> is a open source JAVA security framework that addresses this problem. It is an elegant framework that lets you add authentication, authorization and session management to your application with ease.<\/p>\n

The highlights of Shiro are: <\/h3>\n

It is a pure java framework. It works with all kinds of JAVA applications: J2SE, J2EE, Web, standalone or distributed.<\/p>\n

It can integrate easily with various repositories that may host user and permissions metadata such as RDBMs, LDAPs.<\/p>\n

It has a simple and intuitive permissions model that can apply to wide variety of problem domains. It is a model that lets you focus on your problem domain without getting you bogged down in the framework.<\/p>\n

It has built in support for session management.<\/p>\n

It has built in support for caching metadata.<\/p>\n

It integrates very easily with Spring. Same applies to any J2EE application server.<\/p>\n

Most importantly, it is very easy to use. Most of the time, all you will need to do to integrate Shiro, will be to implement a REALM that ties Shiro to your User and Permissions metadata.<\/p>\n

Shiro Concepts<\/h3>\n

The SecurityManager encapsulates the security configuration of an application that uses Shiro.<\/p>\n

Subject is the runtimes view of a user that is using the system. When the subject is created, it is not authenticated. For authentication, the login method must be called, passing in the proper credentials. <\/p>\n

Session represents the session associated with an authenticated Subject. The session has a session id. Applications can store arbitrary data in the session. The session is valid until the user logs out or the session times out.<\/p>\n

A permission represents what actions a subject may perform on a resource in the application. Out of the box Shiro supports permissions represented by colon separated tokens. Each token has some logical meaning. For example, my application may define a permission as ResourceType:actions:ResourceInstance. More concretely File:read:contacts.doc represents a permission to read a file contacts.doc. The permission must be associated with a user, to grant that permission to the user.

<\/div> <\/div><\/p>\n

A Role is a collection of permissions that might represent ability to perform some organizational function. Roles make the association between users and permissions more manageable.<\/p>\n

A Realm abstracts your user, permission and role metadata for Shiro. You make this data available to Shiro by implementing a realm and plugging it into Shiro. Typical realms use either a relational database or LDAP to store user data.<\/p>\n

Tutorial<\/h3>\n

Let us build a simple java application that does some authentication and authorization. For this tutorial you will need:<\/p>\n

    \n
  1. Apache Shiro<\/a><\/li>\n
  2. A java development environment. I use Eclipse. But you can use other IDEs or command line tools as well.<\/li>\n
  3. You may download the source code for this example at simpleshiro.zip<\/a><\/li>\n<\/ol>\n

    Step 1: Create a Shiro.ini configuration file<\/h4>\n

    We will use the default file base realm that comes with Shiro. This reads the user\/permission metadata from the shiro.ini file. In a subsequent tutorial, I will show how to build a realm that gets data from a relational database.<\/p>\n

    In the Ini file, let us define some users and associate some roles to them.<\/p>\n

    # Simple shiro.ini file\r\n[users]\r\n# user admin with password 123456 and role Administrator\r\nadmin = 123456, Administrator\r\n# user mike with password abcdef and role Reader\r\nmike = abcdef, Reader\r\n# user joe with password !23abC2 and role Writer\r\njoe = !23abC2, Writer\r\n# -----------------------------------------------------------------------------\r\n# Roles with assigned permissions\r\n[roles]\r\n# A permission is modeled as Resourcetype:actions:resourceinstances\r\n# Administrator has permission to do all actions on all resources\r\nAdministrator = *:*:*\r\n# Reader has permission to read all files\r\nReader = File:read:*\r\n# Writer role has permission to read and write all files\r\nWriter = File:read,write:*\r\n<\/pre>\n
    In the above shiro.ini we have defined 3 users and 3 roles. The permission is modeled
    \nas colon separated tokens. Each token can have multiple comma separated parts. Each domain and part grants permission to some application specific domain.<\/p>\n
     Step 2: BootStrap shiro into you application<\/h4>\n
    Factory factory = new IniSecurityManagerFactory(\"classpath:shiro.ini\");\r\nSecurityManager securityManager = factory.getInstance();\r\nSecurityUtils.setSecurityManager(securityManager);\r\n<\/pre>\n
    IniSecurityManagerFactory loads the configuration from shiro.ini and creates a singleton SecurityManager for the application. For simplicity, Our shiro.ini goes with the default SecurityManager configuration which uses a Text based realm and gets user,permission,role metadata from the shiro.ini file. <\/p>\n
     Step 3: Login<\/h4>\n
    Subject usr = SecurityUtils.getSubject();\r\nUsernamePasswordToken token = new UsernamePasswordToken(\"mike\", \"abcdef\");\r\ntry {\r\n    usr.login(token);\r\n} \r\ncatch (AuthenticationException ae) {\r\n    log.error(ae.toString()) ;\r\n    return ;\r\n}\r\nlog.info(\"User [\" + usr.getPrincipal() + \"] logged in successfully.\");\r\n<\/pre>\n
    SecurityUtils is a factory class for getting an existing subject or creating a new one. Credentials are passed in using an AuthenticationToken. In this case, we want to pass in a username and password and hence use the UsernamePasswordToken. Then we call the login method on the Subject passing in the authentication token.<\/p>\n
     Step 4: Check if the user has permission<\/h4>\n
    if (usr.isPermitted(\"File:write:xyz.doc\")) {\r\n    log.info(usr.getPrincipal() + \" has permission to write xyz.doc \");\r\n} else {\r\n    log.info(usr.getPrincipal() + \" does not have permission to write xyz.doc \");\r\n}\r\nif (usr.isPermitted(\"File:read:xyz.doc\")) {\r\n    log.info(usr.getPrincipal() + \" has permission to read xyz.doc \");\r\n} else {\r\n    log.info(usr.getPrincipal() + \" does not have permission to read xyz.doc \");\r\n}\r\n<\/pre>\n
    Subject has a isPermitted method that takes a permission string as parameter and returns true\/false. <\/p>\n
     Step 5: Logout<\/h4>\n
    usr.logout();\r\n<\/pre>\n
    The logout method logs the user out.
    \nTo get familiar with Shiro, try changing the UsernamePasswordToken and login as a different user. Check some other permissions. Modify the Shiro.ini file to create new users and roles with different permissions. Run the program a few times with different metadata and different input.<\/p>\n
    In a production environment, you will not want users and roles in an ini file. You want them in a secure repository like a relational database or LDAP. In the next part, I will show you how to build a Shiro Realm that can use user,role, permission metadata from a relational database.<\/p>\n
    Reference: <\/i><\/strong>Apache Shiro : Application Security Made Easy<\/a> by our JCG partner<\/a> Manoj at the The Khangaonkar Report<\/a> blog<\/p>\n
    Related Articles:<\/strong><\/p>\n