Introduction to J2EE Security
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
Security means different things to different people, but most will agree that securing an Information Technology system means controlling access to the underlying data so that only authorized users can read and modify the data.
There are several components of security that are needed to achieve this simple aim:
Authentication is a means whereby users can identify themselves and be validated by the system. The most common form of IT authentication involves providing a username and password, but other techniques—such as digital certificates, smart cards and pin numbers, and biometrics (fingerprints, etc.)—are alternatives that can be used in some systems.
Authorization is the process by which an authenticated user is granted access to various items of data. Authorization allows some users to read data; whereas others can read, modify, or update the data.
Confidentiality means that only authorized users can view the data, and typically requires encryption of the data as it is transferred around the network.
Integrity means that the data the user views is the same as the data stored in the system. In other words, the data has not been corrupted or changed when transferred from the server to the client. Data integrity is usually achieved by using data encryption. Integrity also means that when a user changes an item of data, that change is permanently made and cannot subsequently be lost. An audit log is used to support this aspect of integrity.
Non repudiation means that if a user changes a piece of data, the system can prove who made the change and when, even if the user subsequently denies making the change. Audit trails and logging are used to support non repudiation.
Security is a large and complex area, involving many different technologies. The authors of the J2EE specification have adopted a pragmatic approach when defining J2EE security. Rather than address all possible aspects of security, the specification focuses on authorization within the J2EE components. The specification assumes that a J2EE application will be integrated into an existing security framework that implements features such as authorization, data encryption, and so on. By not defining these aspects of security, the J2EE specification makes it easier to incorporate existing standard security components into the J2EE framework.
The downside to not defining all aspects of security is that the specification is vague and incomplete when addressing some security issues. As the J2EE specification has evolved, the scope of the security requirements have been expanded and the details further refined. This tightening up of the security requirements reflects the maturing of the security standards and the adoption of these standards by industry-standard components such as web browsers. This refinement of the specification will undoubtedly continue as newer J2EE standards are developed based on empirical use of J2EE applications.
The J2EE specification requires an environment to support Secure Sockets (SSL) for data encryption. At a minimum, the specification also requires support for basic HTTP authentication of web-based applications.
Basic HTTP authentication is the simple login form supported by all web browsers. The J2EE specification acknowledges the fact that basic HTTP authentication is inherently weak because usernames and passwords are transmitted in plain text over the network, but it is the only widely supported mechanism available. If and when alternative techniques such as HTTP Digest Authentication become widely supported, they will almost certainly become a required component of a J2EE-compliant implementation. Authentication is also supported by the use of the Java Authentication and Authorization Service (JAAS).
In order to integrate authorization into an unknown authentication mechanism, the J2EE specification defines a number of terms for talking about security:
A realm is the J2EE term for the security policy domain that is a definition of the way in which a user is authenticated. In its simplest form, a realm is a list of users and a mechanism for authenticating those users. Basic HTTP authentication is known as the HTTP realm; a public key certificate (PKC) authentication such as SSL is a different realm.
A principal is the name of a user within the authentication realm. Although the J2EE specification does not require the principal name to be the same as the user's login name, most (if not all) J2EE implementations use the username as the principal name.
A role is a definition of the way a user will use the system. Typical roles will be user, administrator, manager, developer, researcher, and so on. Outside the J2EE domain, a role is usually implemented by assigning users to one or more authentication groups or granting privileges to user accounts.
A role reference is the name of a role used within the code of a J2EE application. As part of the J2EE application environment definition (known as the deployment descriptor), every role reference must be mapped onto a real role. The decoupling of the coded role reference from the actual role helps improve portability of a J2EE component.
J2EE authorization is enforced using roles, principals, or both identities and can be applied using declarative or programmatic constructs. Roles are the preferred method of enforcing authorization as the coded name (the role reference) is mapped onto the real roles when the J2EE is deployed (made available for use within an IT system). The mapping of users, or principals, onto roles is entirely under the control of the system administrator.
Principal names are less portable because they must reflect the real usernames in the target environment. If developers use a hard-coded principal name to reflect a particular user, then they have reduced the portability of their J2EE component. It is tempting, but wrong, for a developer to utilize a special username such as "root" or "Administrator" to identify a user with unique authorization requirements. Using hard-coded names is incorrect because authorization requirements should be based on roles, not principal names. The use of principal names should be restricted to matching users to their own data. A simple example would be to retrieve all the rows in a database table in which a particular column contains the user's principal name. Using this approach, the principal name is defined entirely within the target environment, and the administrator can ensure that the user login name matches the data stored in the database.
J2EE uses the same authorization model for both web-based components (servlets and JSPs) and enterprise components (EJBs). The specification requires transparent propagation of security credentials within the J2EE environment, so that once users have authenticated themselves to any J2EE component, the same security information is used by all other components. In other words, if users log on to access a web page, they will not have to log on again to access a different web page or use a component EJB.
Declarative security is applied in the deployment descriptor, and can be used to authorize roles for access to an EJB or a web page URL. Declarative security can be applied down to the level of an individual method of an EJB. As an example, consider an EJB that accesses a database for select and update operations. Methods that select data from the database will be authorized for one role, and methods that update the database will be authorized for another role.
Role access to web pages is based on URL pattern matching. Roles can be authorized to access a specific web page (a static page, a servlet, or an EJB) or an HTTP request that matches a URL pattern. By using web page URL mappings (or aliases) in the deployment descriptor, the physical web pages can be grouped together under logically similar names to simplify security authorization.
Declarative authorization is sufficient for many J2EE components, and has the major benefit of being independent of the code algorithms used with the component. Changes to a security policy can be made without having to change the underlying Java or JSP code. Furthermore, several components from different sources can be integrated to form a complete application and then security can be applied to the application as a whole rather than the individual components.
Programmatic security supports more fine-grained authorization than declarative security, but can restrict the reusability of a component. Assembling an application from several components that use programmatic security will be difficult or impossible if the programmed security model is not consistent between the components. An additional drawback to programmatic security occurs when the security policy changes. Every component must be revisited to verify and possibly update the security authorization.
Programmatic security uses four methods, two for EJBs and two for web components:
boolean EJBContext.isCallerInRole(String role)
Principal EJBContext.getCallerPrincipal()
boolean HttpServletRequest.isUserInRole(String role)
Principal HttpServletRequest.getUserPrincipal()
The isCallerInRole() and isUserInRole() methods return true if the caller is in the role reference specified as a parameter (the role reference will be mapped onto a real role within the deployment descriptor). The getCallerPrincipal() and getUserPrincipal() methods return a java.security.Principal object, and the Principal.getName() method for this object returns the corresponding principal name.
As an example of programmatic security, the following servlet code fragment (without the exception handling code) will select all rows of data from a database table if the caller is in the administrator role; otherwise, only the rows matching the caller's principal name will be retrieved.
DataSource ds = (DataSource) context.lookup("jdbc/database");
Connection con = ds.getConnection();
PreparedStatement select =
con.prepareStatement("SELECT * FROM table WHERE username like ?");
if (context.isCallerInRole("administrator")
select.setString(1,"%");
else
select.setString(1,context.getUserPrincipal().getName());
ResultSet results = select.executeQuery();
This example shows how programmatic security can be used to change the behaviour of a component based on the security credentials of the user. This is something that cannot be achieved by declarative security.
Summary
In summary, J2EE security attempts to integrate J2EE applications into an existing security infrastructure. As far as possible, J2EE applications make use of existing security technologies, such as authentication and data encryption, to support the security requirements of the J2EE components. The J2EE specification concentrates on defining the authorization support within the J2EE component technologies and how to integrate the authorization process into existing security products. J2EE security can be applied in a declarative manner in the deployment descriptor by adding authorization to EJB methods and web page URLs. When declarative security isn't sufficient to capture the business logic requirements, then programmatic security can be used for a more fine-grained approach. Programmatic security is considered less flexible because changes to the security policy will require changes to the component Java or JSP code.