Oracle® Fusion Middleware Developer's Guide for Oracle Adaptive Access Manager Release 11g (11.1.1) E15480-06 |
|
Previous |
Next |
Oracle Adaptive Access Manager provides APIs to fingerprint devices, collect authentication and transaction logs, run security rules, challenge the user to answer pre-registered questions correctly, and generate virtual authentication devices such as KeyPad, TextPad, or QuestionPad.
Native Oracle Adaptive Access Manager integration involves customizing your application to include OAAM API calls at various stages of the login process. The application invokes Oracle Adaptive Access Manager directly and the application itself manages the authentication and challenge flows.
Using the Oracle Adaptive Access Manager APIs, you can:
Change the default user registration flow
Control and manage the authentication process flow
This chapter contains guidelines to integrate a client application with Oracle Adaptive Access Manager using the APIs the server exposes.
The typical process flows for the authentication and challenge scenarios are presented in this chapter. Within these flow sections, there are details about which API should be called at each stage.
The integration options are presented in the following sections:
Example Application
The example application is available as a form of documentation to illustrate how to call the product APIs. It is not intended as production code. For example, the sample application does not have proper error handling; it only provides basic elements of API usage. Customers implementing a native integration should develop their own application using the sample application as a reference only.
Note: Custom applications developed for these deployments are not supported directly. However, Oracle Support Services can assist customers with product issues, such as if customers encounter problems when using the provided APIs. |
To integrate with Oracle Adaptive Access Manager, the application can use the native API. Choose one of the following native API options:
SOAP service wrapper API for Java or .NET applications.
Refer to "Using Web Services and SOAP API".
Link libraries statically for Java applications only
Refer to "Using Static Linking".
In this scenario, the application communicates with Oracle Adaptive Access Manager using the Oracle Adaptive Access Manager native client API (SOAP service wrapper API) or via Web services.
The SOAP service wrapper API enables you to create SOAP objects and invoke SOAP calls and abstracts the SOAP Web Service Definition Language (WSDL) and other Web services details from the application code. Libraries for this API are available for the following languages: Java, .NET, and C++.
Using this API is recommended over making direct SOAP calls. The reasons are as follows:
The client library constructs the SOAP objects, and the details involved in SOAP calls is abstracted from the client application.
A SOAP API signature change does not require any change in the client code.
The API provides higher-level utility methods to extract parameters directly from the HTTP request and HTTP session objects.
It provides methods to encode and decode fingerprint data.
This integration requires adding lightweight client libraries (JARs or DLLs) to the client library. Figure 2-1 illustrates how an application communicates with Oracle Adaptive Access Manager using Web services and the server API.
Java applications can be static-linked. This scenario only involves local API calls and therefore no remote server risk engine calls (SOAP calls). The integration imbeds the processing engine for Oracle Adaptive Access Manager with the application and enables it to leverage the underlying database directly for processing. In this scenario, the application must include the server JARs and configured properties, as appropriate.
Even though static linking may provide slightly better performance, it is not suitable for all Java clients. Static linking is recommended for clients developing their own applications with Oracle Adaptive Access Manager built in their J2EE or application.
Static-linking an application has several advantages:
The application makes no SOAP calls, thus eliminating the need to create and delete TCP/IP connections.
It experiences no network latencies.
It does not require a load balancer.
This section describes the following integration options:
This integration consolidates virtual authentication devices and knowledge-based authentication. Globalized virtual authentication device image files including registration flows must be developed by the deployment team.
Figure 2-2 illustrates an authentication flow example that uses these three solutions (virtual authentication devices, knowledge-based authentication, One-Time Password). Note that the flow illustrated is an example and that other authentication flows are possible.
The details of the stages in the Figure 2-2 are explained in the following sections:
When the application uses a custom login page, the login page must be split into two pages. The user inputs the login ID (user name) in the first page, and this data is stored in the HTTP session. The second login page is a transient page to capture the flash and secure cookies and for fingerprinting the user device. Figure 2-3 shows a sample of the first page.
The device fingerprint stage involves fingerprinting the user device. The APIs used for this purpose are detailed in Table 2-1.
Table 2-1 Device Fingerprinting APIs
Module | APIs | Description |
---|---|---|
Server |
APIs that construct the fingerprint are:
|
For method details on updateLog(), see Section 4.5.6, "updateLog." |
Oracle Adaptive Access Manager Sample |
Sets the client's time zone Sets a secure cookie Sets the browser fingerprint Sets the status to pending Calls the pre-authentication rules; expects "allow" to allow the user to proceed or "block" or "error" to stop the user from continuing Stores bharosaSession Forwards the user to the password.jps page |
|
Oracle Adaptive Access Manager Sample |
Sets the flashCookie if the browser is flash-enabled |
Cookies in Device Identification
Oracle Adaptive Access Manager uses two types of cookies to perform device identification.
One is the browser cookie (also known as secure cookie) and the other is the flash cookie (also known as digital cookie).
The browser cookie value is constructed using the browser user agent string. The flash cookie value is constructed using data from the OAAM flash movie.
The following is sample code to fingerprint the device using browser and flash cookies. Refer to code in handleFlash.jsp
for details:
//Get Browse/Secure cookie String secureCookie = getCookie(request, "bharosa"); Locale locale = request.getLocale(); String browserFp = VCryptServletUtil.getBrowserFingerPrint(request.getHeader("user-agent"), locale.getLanguage(), locale.getCountry(), locale.getVariant()); String client = request.getParameter("client"); String fpStr = request.getParameter("fp"); String flashFp = bharosaHelper.constructFlashFingerPrint( client, fpStr ); //Get the flash cookie String flashCookie = request.getParameter("v"); CookieSet cookieSet = bharosaHelper.fingerPrintFlash(bharosaSession, bharosaSession.getRemoteIPAddr(), request.getRemoteHost(), BharosaEnumAuthStatus.PENDING, secureCookie, browserFp, flashCookie, flashFp);
Pre-authentication rules are run before the user is authenticated. Common values returned by the pre-authentication checkpoint include:
Allow to allow the user to proceed forward.
Block to block the user from proceeding forward.
The APIs used for pre-authentication are listed in Table 2-2.
Table 2-2 Pre-Authentication Rules Reference APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.6.1, "processRules." |
|
Oracle Adaptive Access Manager Sample |
Invokes the pre-authentication rules; returns "allow" to proceed forward to password.jsp or "block" or "error" to signal an error Stores bharosaSession |
|
BharosaHelper |
This stage determines the virtual authentication device to use. If the user has not registered an image and a phrase, the rule returns the Generic TextPad; otherwise, if the user has registered, the rule returns either the personalized TextPad or KeyPad. Common values returned by virtual authentication devices include:
Generic TextPad to use the default generic TextPad.
TextPad to use a personalized TextPad.
KeyPad to use a personalized KeyPad.
The APIs used to run virtual authentication device rules are listed inTable 2-3.
Table 2-3 Virtual Authentication Device Rules APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.6.1, "processRules." |
|
Oracle Adaptive Access Manager Sample |
Invokes rules to identify the user's virtual authentication device type Creates the virtual authentication device, names it, and sets all initial background frames Invokes kbimage.jsp as configured Forwards to page handlePassword.jsp |
|
BharosaHelper |
A generic, non-personalized TextPad is used for users who have not yet registered with Oracle Adaptive Access Manager. Figure 2-4 illustrates a generic TextPad.
Table 2-4 lists the APIs used to generate a generic TextPad.
Table 2-4 Generation of a Generic TextPad APIs
Module | APIs | Description |
---|---|---|
Server |
VCryptAuth::getUserByLoginId() You can obtain an instance of VCryptAuth by calling VCryptAuthUtil.getVCryptAuthInstance(). |
For method details, see Section 4.5.7, "getUserByLoginId." |
Oracle Adaptive Access Manager Sample |
Password.jsp |
Invokes rules to identify the virtual authentication device type to use; the default is KeyPad Creates the virtual authentication device, names it, and sets all initial background frames Invokes kbimage.jsp as configured Forwards to page handlePassword.jsp |
BharosaHelper |
||
Client |
A personalized TextPad is used for users who have registered with Oracle Adaptive Access Manager. Figure 2-5 andFigure 2-6 illustrate personalized text and key virtual authentication devices.
Table 2-5 lists the APIs used to generate a personalized TextPad or KeyPad.
Table 2-5 Generating a Personalized TextPad or KeyPad APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.5.7, "getUserByLoginId." |
|
Oracle Adaptive Access Manager Sample |
Invokes rules to identify the virtual authentication device type to use; the default is KeyPad Creates the virtual authentication device, names it, and sets all initial background frames Forwards to page handlePassword.jsp Invokes kbimage.jsp as configured |
|
BharosaHelper |
||
Client |
The HTML code example to display TextPad and KeyPad should be embedded in the password page. This HTML renders the TextPad or KeyPad using JavaScript, and it includes an <img>
tag, which makes a HTTP request to the server to get the TextPad or KeyPad image.
Table 2-6 lists the APIs used to display TextPad and KeyPad.
Table 2-6 Displaying TextPad and KeyPad APIs
In this stage, the chosen virtual authentication device decodes the data the user supplies to it; the decoded value is in raw text format, and it is recommended that it be saved in the HTTP Session. The virtual authentication device object is serialized and stored in the database or the file system.
The virtual authentication device is stored in session because it is used to decode the input. This is needed for virtual authentication devices like PinPad and KeyPad where the user input is not clear text. For consistency it is performed for all virtual authentication devices since they are designed to be able to be used interchangeably.
Table 2-7 lists the APIs used to decode user input.
This stage represents the client's existing process in which the client invokes the local API to authenticate the user and the authentication result is passed on to OAAM Server. The API used is detailed in Table 2-8.
Table 2-8 Validating User and Password API
Module | API | Description |
---|---|---|
Oracle Adaptive Access Manager Sample |
Retrieves the password Decodes the password Updates the status to "success" (if user is valid), or to "invalid," "error," or "bad password" (if the user is invalid) Runs post-authentication rules and returns one of the following values: REGISTER_USER_OPTIONAL REGISTER_QUESTIONS REGISTER_USER CHALLENGE |
After validating the user password, the status is updated with the APIs detailed in Table 2-9.
Table 2-9 Updating Authentication Status APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.5.9, "updateAuthStatus." |
|
Oracle Adaptive Access Manager Sample |
Retrieves the password Decodes the password Validates the user Forwards to registerImageandPhrase, or challenges a registered user |
|
BharosaHelper |
These rules are run after the user password has been authenticated. Common actions returned by post-authentication include:
Allow to allow the user to proceed forward.
Block to block the user from proceeding forward.
Challenge to challenge the user.
The APIs used for post-authentication are listed in Table 2-10.
Table 2-10 Post-Authentication Rules Reference APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.6.1, "processRules." |
|
Oracle Adaptive Access Manager Sample |
Calls BharosaHelper::runPostAuthRules which returns: ALLOW BLOCK CHALLENGE If ALLOW: BharosaHelper::runRegistrationRules returns ALLOW REGISTER_QUESTIONS REGISTER_USER_INFO REGISTER_USER SYSTEM_ERROR If CHALLENGE: forward_challengePage |
|
BharosaHelper |
Rules are run to check registration; if the user is not registered, he is directed to do so.
The registration is required depending on business and security requirements, which specify whether the registration is mandatory or optional. Values returned by registration rules include the following:
Register to require user registration.
Registration Optional to make user registration optional.
Skip Registration to skip registration for this session.
Table 2-11 lists the APIs used to run registration rules.
Table 2-11 Registration Required Rules Reference APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.6.1, "processRules." |
|
Oracle Adaptive Access Manager Sample |
Invokes rules to identify the virtual authentication device type to use; the default is KeyPad Creates the virtual authentication device, names it, and sets all initial background frames Invokes kbimage.jsp as configured Forwards to page handlePassword.jsp |
|
BharosaHelper |
The Registration Flow allows you to register a new image and caption, questions, and so on as described in the table below:
Table 2-12 Registration Flow
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.6.1, "processRules." |
|
Oracle Adaptive Access Manager Sample |
registerImagePhrase.jsp |
Assigns new image and caption to user Assigns new image and caption to user Forwards to page handleRegisterImagePhrase.jsp |
registerQuestions.jsp |
Gets question pick set for the user Displays question selection user interface and inputs for answers Forwards to page handleRegisterQuestions.jsp |
|
registerContactInfo.jsp |
Presents user with inputs for OTP registration information Forwards to page handleRegisterContactInfo.jsp |
|
BharosaHelper |
BharosaHelper::getAuthentiPad() BharosaHelper::createSampleAuthentiPad BharosaHelper::assignRandomImageAndCaption BharosaHelper::saveNewImageAndOrCaption BharosaHelper::getQuestions BharosaHelper::isDeviceRegistered BharosaHelper::setContactInfo |
The challenge rules are invoked to determine which type of challenge to display to the user. Values returned by the challenge rules include the following:
ChallengeQuestion to challenge the user with question.
ChallengeSMS to challenge user with OTP via SMS, to challenge user with OTP
ChallengeEmail to challenge user with OTP via email
Block to block the user.
Table 2-13 lists the APIs used to run the challenge rules.
Table 2-13 Run Challenge Rules APIs
Module | APIs | Description |
---|---|---|
Server |
For method details, see Section 4.6.1, "processRules." |
|
Oracle Adaptive Access Manager Sample |
handleChallenge.jsp calls BharosaHelper::validateAnswer If that method returns BharosaEnumChallengeResult.SUCCESS, status is updated to "success" and the user is allowed to move forward; otherwise if BharosaEnumChallengeResult.WRONG_ANSWER is returned then challenge rules are run again to determine the next step. |
|
BharosaHelper |
BharosaHelper::getAuthentiPad
is used to create an authentication device. That method in turn calls the Authentication Device Rules to determine the device to use.
If the user is to be challenged with a question, the rule returns the QuestionPad. If the user is to be challenge with an OTP, the rule returns the TextPad.
If appropriate, the user is challenged with either Knowledge Based Authentication (KBA) or OTP (One Time Password).
KBA is an extension to existing User ID/password authentication and secures an application using a challenge/response process where users are challenged with questions. The user must answer the question correctly to proceed with his requested sign-on, transaction, service, and so on.
OTP is an extension to existing User ID/password authentication as well and adds an extra security layer to protect applications. OTP is generated after verifying the user ID and password and then delivered to users via e-mail or mobile phone if the application deems it to be necessary. Users then use the OTP to sign-in to the application.
Table 2-14 lists the APIs to challenge the user with registered questions.
Table 2-14 Challenge User APIs
Module | APIs | Description |
---|---|---|
Server |
VCryptAuth::getSecretQuestion() VCryptTracker::generateOTP() |
|
Oracle Adaptive Access Manager Sample |
Determine type of challenge to use. BharosaHelper::runChallengeRules If challenge type returned is KBA (ChallengeQuestion) then get user question with VCryptAuth:getUserQuestion If challenge type is OTP (ChallengeSMS, ChallengeEmail, ...) then generate, store, and send OTP code.
Use authentication pad rules to determine authentipad to display to the user. See Section 2.2.1.4, "Run Virtual Authentication Device Rules (R2).". Submits the answer to handleChallenge.jps handleChallenge.jsp collects user input and calls BharosaHelper::validateAnswer - used to validate user answer for challenge (same as question challenge) |
|
BharosaHelper |
BharosaHelper:: createPersonalizedAuthentiPad () BharosaHelper::createAuthentiPad() BharosaHelper::generateOTP BharosaHelper::sendCode BharosaHelper::getUserQuestion |
|
Client |
This stage involves validating the user's input to the challenge:
For KBA, calling Oracle Adaptive Access Manager Server to determine whether the answer the user has supplied matches the registered reply.
For OTP, validating the entered value to the OTP generated and sent to the user.
Table 2-15 lists the APIs used to validate a challenge.
Table 2-15 Validate Answer to a Challenge
Module | APIs | Description |
---|---|---|
Server |
VCryptAuth::authenticateQuestion() |
For method details, see Section 4.6.1, "processRules," and Section 4.5.9, "updateAuthStatus." |
Oracle Adaptive Access Manager Sample |
Calls BharosaHelper::validateAnswer If that method returns BharosaEnumChallengeResult.SUCCESS, status is updated to "success" and the user is allowed to move forward; otherwise if BharosaEnumChallengeResult.WRONG_ANSWER is returned then challenge rules are run again to determine the next step. |
|
BharosaHelper |
If the type of challenge being validated is KBA (ChallengeQuestion), then VCryptAuth::authenticateQuestion is called to validate the users input against the registered answer for the question presented. If the type of challenge being validated is OTP (ChallengeSMS, ChallengeEmail, and so on), then the users input is compared to the value stored when OTP code was generated. If the answer is correct, the OTP challenge counter is reset by calling BharosaHelper::resetOTPCounter. Otherwise if the answer is incorrect, the OTP challenge counter is incremented (BharosaHelper::incrementOTPCounter). Method returns a BharosaEnumAuthStatus of either BharosaEnumAuthStatus.SUCCESS or BharosaEnumAuthStatus.WRONG_ANSWER |
The Lock Out page is the page to which the user is redirected when the post-authorization rules return Block.
This scenario is a subset of the scenario described in Section 2.2.1, "Integrating with Virtual Authentication Devices and Knowledge-Based Authentication." This scenario does not have a split login flow and does not include personalizations or virtual authentication devices.
Figure 2-7 illustrates a flow of authentication that uses this solution. For details about the stages of this flow, see the following sections:
The User/Password Page is the existing page currently used by the client. It contains the text box for both the username and password. There are no changes required for this page; however, the post from this page should display a transient (intermediate) refresh page.
For information on the other stages, see the following sections: