Creating Authentication Providers

To create an implementation that allows for the authentication of users, implement the authenticate method. User Management passes the following user and configuration values to the authenticate method when a user attempts to log in:

• credential: A java.util.Map object containing a set of property/value pairs required to authenticate a user.

• authConfigs: A java.util.List object containing configuration information.

The authenticate method returns a com.adobe.idp.um.spi.authentication.AuthResponse object that specifies whether the user was authenticated.

The sample authentication provider consists of two classes:

• SampleAuthenticationManager: Handles the requests from LiveCycle to authenticate users. This class implements the AuthProvider class and contains the following methods: authenticate and getConfigName.

• AuthenticationController: Interacts with the MySQL database to ensure that the specified user credentials are valid. This class retrieves data from the MySQL database by using classes located in the java.sql.* package.

The method located in the AuthenticationController class that interacts with the users table is named isValidUser. This method returns a Boolean value that specifies whether user credentials are valid. The following code example shows the application logic of this method.

private boolean isValidUser(String userName, String password) { 
boolean valid = false; 
try{ 
//Create connection to mySQL server 
Class.forName("com.mysql.jdbc.Driver"); 
Connection con = DriverManager.getConnection("jdbc:mysql://hsmithk-380:3306/spi", "root", "password"); 
Statement statement = con.createStatement(); 
 
/*Compare the username and password, return the amount of matches 
*If using a plain text password, you can compare the password without using the PASSWORD() function 
*/ 
ResultSet res = statement.executeQuery("SELECT COUNT(*) FROM users where userid='"+userName+"' AND user_password=PASSWORD('"+password+"')"); 
 
//Go to the first result 
res.next(); 
             
//If a positive number of matches was returned, the username/password values are valid 
if (res.getInt("COUNT(*)") > 0){ 
valid=true; 
} 
 
}catch(Exception e){ 
    e.printStackTrace(); 
} 
return valid; 
}

Your implementation of the AuthProvider interface must include a getConfigName method. This method provides the name of the configuration node whose first-level children are extracted from the configuration file. The getConfigName method does not require any input parameters and returns a string value.

This example contains a sample implementation of the getConfigName() method.

public String getConfigName() { 
    return "SampleAuthenticationManager"; 
}

The following application logic represents the SampleAuthenticationManager class.

package com.adobe.livecycle.samples.authentication; 
 
import java.util.List; 
import java.util.Map; 
 
import com.adobe.idp.um.spi.authentication.AuthConfigBO; 
import com.adobe.idp.um.spi.authentication.AuthProvider; 
import com.adobe.idp.um.spi.authentication.AuthResponse; 
import com.adobe.idp.um.spi.authentication.AuthScheme; 
import com.adobe.livecycle.samples.authentication.AuthenticationController; 
 
/** 
    * This class is a sample implementation of a authentication providers.  
    * It interacts with a MySQL database named spi.users to determine  
    * if user credentials are valid.  
    *  
    * For information about the MySQL database, see "Creating Authentication Provider" 
    * in "Programming with LiveCycle." 
    */ 
 
public class SampleAuthenticationManager implements AuthProvider { 
 
    private static AuthenticationController sampleAuthentication = new AuthenticationController(); 
 
    public AuthResponse authenticate(Map credential, List authConfigs) { 
        String userName = null; 
        String password = null; 
        String authType = null; 
 
        AuthResponse authResponse = null; 
 
        // check the credential map to find out what the credentials are 
        if (credential.containsKey(AuthProvider.USER_NAME)) 
            userName = (String) credential.get(AuthProvider.USER_NAME); 
        if (credential.containsKey(AuthProvider.PASSWORD)) 
            password = (String) credential.get(AuthProvider.PASSWORD); 
        if (credential.containsKey(AuthProvider.AUTH_TYPE)) 
            authType = (String) credential.get(AuthProvider.AUTH_TYPE); 
 
        if (authType == null || authType.equals(AuthScheme.AUTHTYPE_USERNAME_PWD)) { 
             
            for (int i = 0;i < authConfigs.size();i++) { 
                AuthConfigBO authConfigBO = (AuthConfigBO)authConfigs.get(i); 
                System.out.println(authConfigBO.getCustomConfiguration()); 
                authResponse = sampleAuthentication.doAuth(userName, password, authConfigBO.getDomainName()); 
                if (AuthResponse.AUTH_SUCCESS.equals(authResponse.getAuthStatus())) { 
                    return authResponse; 
                } 
            } 
        } 
 
        return authResponse; 
    } 
 
    /** 
     * This method returns the config name of this Provider. This name would be the configuration node whose first-level  
     * children are extracted from the configuration file. 
     */ 
    public String getConfigName() { 
        return "SampleAuthenticationManager"; 
    } 
 
}

The following application logic represents the AuthenticationController class.

package com.adobe.livecycle.samples.authentication; 
 
import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.ResultSet; 
import java.sql.Statement; 
import com.adobe.idp.um.spi.authentication.AuthResponse; 
import com.adobe.idp.um.spi.authentication.AuthResponseImpl; 
import com.adobe.idp.um.spi.authentication.AuthScheme; 
 
public class AuthenticationController { 
 
    /** 
     * This method returns an object of type 
     * com.adobe.idp.um.spi.authentication.AuthResponse, which contains the 
     * information about the success/failure of the authentication operation. 
     */ 
    public AuthResponse doAuth(String userName, String password, 
            String domainName) { 
        AuthResponse response = new AuthResponseImpl(); 
        response.setAuthType(AuthScheme.AUTHTYPE_USERNAME_PWD); 
        response.setUsername(userName); 
 
        if (userName == null || "".equals(userName) || password == null 
                || "".equals(password)) { 
            System.out.println("User Name or Password is null"); 
            response 
            .setErrorMessage("Sorry!! User Name and Password could not be empty! Please provide User Name & Password!"); 
            return response; 
        } 
 
        if (isValidUser(userName, password)) { 
            response.setAuthStatus(AuthResponse.AUTH_SUCCESS); 
            response.setDomain(domainName); 
            System.out.println("User " + userName + " is valid !!!"); 
        } else { 
            response.setAuthStatus(AuthResponse.AUTH_FAILED); 
            response.setDomain(domainName); 
            System.out.println("User " + userName + " is not a valid user!!!"); 
        } 
        return response; 
    } 
 
    /** 
     * The method authenticates a user by interacting with the spi.users MySQL database  
     */ 
    private boolean isValidUser(String userName, String password) { 
         
        boolean valid = false; 
         
        try{ 
            //Create connection to mySQL server 
            Class.forName("com.mysql.jdbc.Driver"); 
            Connection con = DriverManager.getConnection("jdbc:mysql://hsmithk-380:3306/spi", "root", "password"); 
            Statement statement = con.createStatement(); 
 
            /*   
             * Compare the username and password, return the amount of matches 
             * If using a plain text password, you can compare the password without using the PASSWORD() function 
             */ 
            ResultSet res = statement.executeQuery("SELECT COUNT(*) FROM users where userid='"+userName+"' AND user_password=PASSWORD('"+password+"')"); 
 
            //Go to the first result 
            res.next(); 
             
            //If a positive number of matches was returned, the username/password values are valid 
            if (res.getInt("COUNT(*)") > 0){ 
                valid=true; 
            } 
 
        }catch(Exception e){ 
            e.printStackTrace(); 
        } 
 
        return valid; 
    } 
}