Metacat

/**

 *  '$RCSfile$'

 *    Purpose: An implementation of the AuthInterface interface that

 *             allows Metacat to use the LDAP protocol for

 *             directory services

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *    Release: @release@

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

package edu.ucsb.nceas.metacat;

import java.net.ConnectException;

import javax.naming.AuthenticationException;

import javax.naming.Context;

import javax.naming.NamingException;

import javax.naming.directory.Attributes;

import javax.naming.directory.BasicAttributes;

import javax.naming.directory.DirContext;

import javax.naming.directory.InitialDirContext;

import javax.naming.directory.SearchResult;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Vector;

/**

 * An implementation of the AuthInterface interface that

 * allows Metacat to use the LDAP protocol for directory services.

 * The LDAP authentication service is used to determine if a user

 * is authenticated, and whether they are a member of a particular group.

 */

   * Construct an AuthLdap

   */

  public AuthLdap() {

    // Read LDAP URI for directory service information

    this.ldapsUrl = MetaCatUtil.getOption("ldapsurl");

    this.ldapBase = MetaCatUtil.getOption("ldapbase");

    //System.out.println("LDAPBASE is: " + ldapBase);

   * Determine if a user/password are valid according to the authentication

   * service.

   *

   * @param user the name of the principal to authenticate

   * @param password the password to use for authentication

   * @returns boolean true if authentication successful, false otherwise

   */

  public boolean authenticate(String user, String password)

                    throws ConnectException

  {

    try {

        authenticated = ldapAuthenticate(identifier, password);

        if (!authenticated) {

            identifier = getIdentifyingName(identifier,ldapUrl,ldapBase);

            authenticated = ldapAuthenticate(identifier+","+ldapBase, password);

      util.debugMessage("NullPointerException b' password is null");

      util.debugMessage("NullPointerException while authenticating in " +

                        "AuthLdap.authenticate: " + e);

      throw new ConnectException(

      "NullPointerException while authenticating in " +

                        "AuthLdap.authenticate: " + e);

                        "AuthLdap.authenticate: " + e);

      System.out.println(e.getMessage());

    return authenticated;

  }

  /**

   * username and password as passed into the routine.

   *

   * @param identifier the distinguished name to check against LDAP

   * @param password the password for authentication

   */

  private boolean ldapAuthenticate(String identifier, String password)

            throws ConnectException, NamingException, NullPointerException

  {

    if (identifier != null && !password.equals("")) {

        // Identify service provider to use

        Hashtable env = new Hashtable(11);

        env.put(Context.INITIAL_CONTEXT_FACTORY,

            "com.sun.jndi.ldap.LdapCtxFactory");

        // authenticate this time when opening the DirContext

          variable.  it is hard coded to 'throw'.  Matt: Is it ok to do this

          only here and not in every method?

        */

        //System.out.println("ldapsUrl: " + ldapsUrl + " ldapBase: " + ldapBase);

        if ( !ldapsUrl.equals(ldapUrl) ) {

          // ldap is set on default port 389

          // ldaps is set on second port - 636 by default

          env.put(Context.SECURITY_PROTOCOL, "ssl");

        }

        env.put(Context.SECURITY_AUTHENTICATION, "simple");

        env.put(Context.SECURITY_PRINCIPAL, identifier);

        // If our auth credentials are invalid, an exception will be thrown

        DirContext ctx = null;

        try {

          double startTime = System.currentTimeMillis();

          ctx = new InitialDirContext(env);

//          // StartTLS support from LDAPv3 with X.509 cert and with JSDKv1.4+

//          LdapContext ctx = new InitialLdapContext(env, null);

//          StartTlsResponse tls =

//            (StartTlsResponse)ctx.extendedOperation(new StartTlsRequest());

//          tls.negotiate();

          double stopTime = System.currentTimeMillis();

          System.out.println("Connection time thru " + ldapsUrl + " was: " +

                             (stopTime-startTime)/1000 + " seconds.");

          authenticated = true;

          //tls.close();

          ctx.close();

          this.ldapUrl = ldapUrl;

          this.ldapBase = ldapBase;

          //break;

        } catch (AuthenticationException ae) {

          authenticated = false;

//          if ( tls != null ) {

//            tls.close();

//          }

          if ( ctx != null ) {

            ctx.close();

          }

        catch (javax.naming.InvalidNameException ine)

        {

        catch(javax.naming.ReferralException re)

        {

	        try

          {

            Context c = handleReferral(env, re);

            authenticated = true;

          }

          catch(Exception e)

          {

            authenticated = false;

          }

        }

        util.debugMessage("User not found");

    }

    System.out.println("total ldap authentication time: " +

                      (totStopTime - totStartTime)/1000 + " seconds");

  }

  /**

   * handles a referral exception.  this method should be called from

   * within the catch statement of a ReferralException

   */

  private Context handleReferral(Hashtable env, ReferralException re)

                  throws Exception

  {

    System.out.println("referral to : " + re.getReferralInfo().toString());

    boolean referralSuccess = false;

    while(referralSuccess != true)

    {

      try

      {

        /*

         Matt, I think this is right but I'm not sure...please check me to make

         sure I didn't do something wrong here.

        */

        double refStartTime = System.currentTimeMillis();

        Context refctx = re.getReferralContext(env);

        referralSuccess = true;

        refctx.close();

        this.ldapUrl = ldapUrl;

        this.ldapBase = ldapBase;

        double refStopTime = System.currentTimeMillis();

        System.out.println("total referral time: " +

                          (refStopTime - refStartTime)/1000 + " seconds");

        return refctx;

      }

      catch(ReferralException e)

      {

          System.out.println("Referring to: " +

                             re.getReferralInfo().toString());

      }

      catch(Exception e)

      {

        throw e;

      }

    }

    return null; //this should never get called

  }

  /**

   * that is used in conjunction withthe LDAP BaseDN to create a

   * distinguished name (dn) for the record

   *

   * @param user the user for which the identifying name is requested

   * @returns String the identifying name for the user,

   *          or null if not found

   */

  private String getIdentifyingName(String user, String ldapUrl, String ldapBase)

         throws NamingException

  {

    String identifier = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

            "com.sun.jndi.ldap.LdapCtxFactory");

    //    env.put(Context.SECURITY_PROTOCOL, "ssl");

      // distinguished name (dn) based on userid (uid) or common name (cn)

      DirContext ctx = new InitialDirContext(env);

      SearchControls ctls = new SearchControls();

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      // Search for the user id or name using the uid, then cn and sn attributes

      // If we find a record, determine the dn for the record

      NamingEnumeration answer;

      try {

        answer = ctx.search("", filter, ctls);

        if (answer.hasMore()) {

          SearchResult sr = (SearchResult)answer.next();

          identifier = sr.getName();

          if ( !sr.isRelative() ) {

            this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

            this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

            identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                              identifier.indexOf(","));

          }

          util.debugMessage("Found: " + identifier);

          return identifier;

        }

      } catch (InvalidSearchFilterException e) {}

      filter = "(uid=" + user + ")";

      answer = ctx.search("", filter, ctls);

        SearchResult sr = (SearchResult)answer.next();

        identifier = sr.getName();

        if ( !sr.isRelative() ) {

          this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

          this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

          identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                            identifier.indexOf(","));

        }

        util.debugMessage("Found: " + identifier);

      } else {

        //Attributes matchAttrs2 = new BasicAttributes(true);

        //matchAttrs2.put(new BasicAttribute("cn", user));

        //NamingEnumeration answer2 = ctx.search("", matchAttrs2);

        filter = "(cn=" + user + ")";

        NamingEnumeration answer2 = ctx.search("", filter, ctls);

        if (answer2.hasMore()) {

          SearchResult sr = (SearchResult)answer2.next();

          identifier = sr.getName();

          if ( !sr.isRelative() ) {

            this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

            this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

            identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                              identifier.indexOf(","));

          }

          util.debugMessage("Found: " + identifier);

        } else {

          //Attributes matchAttrs3 = new BasicAttributes(true);

          //matchAttrs3.put(new BasicAttribute("sn", user));

          //NamingEnumeration answer3 = ctx.search("", matchAttrs3);

          filter = "(sn=" + user + ")";

          NamingEnumeration answer3 = ctx.search("", filter, ctls);

          if (answer3.hasMore()) {

            SearchResult sr = (SearchResult)answer3.next();

            identifier = sr.getName();

            if ( !sr.isRelative() ) {

              this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

              this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

              identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                                identifier.indexOf(","));

            }

            util.debugMessage("Found: " + identifier);

          }

        }

      }

      // Close the context when we're done the initial search

      ctx.close();

    } catch (NamingException e) {

      util.debugMessage("Naming exception while getting dn: " + e);

      throw new NamingException(

      "Naming exception in AuthLdap.getIdentifyingName: " + e);

    }

    return identifier;

  }

  /**

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns string array of all of the user names

         throws ConnectException

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

            "com.sun.jndi.ldap.LdapCtxFactory");

    try {

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Users are objects that have the attribute objectclass=InetOrgPerson.

        String[] attrIDs = {"dn"};

        ctls.setReturningAttributes(attrIDs);

        ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

        String filter = "(objectClass=inetOrgPerson)";

        NamingEnumeration enum = ctx.search(ldapBase, filter, ctls);

        Vector uvec = new Vector();

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

        // initialize users[]; fill users[]

        users = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          users[i] = (String)uvec.elementAt(i);

        }

        // Close the context when we're done

        ctx.close();

    } catch (NamingException e) {

      System.err.println("Problem getting users in AuthLdap.getUsers:" + e);

    return users;

  /**

   * Get the users for a particular group from the authentication service

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @param group the group whose user list should be returned

   * @returns string array of the user names belonging to the group

         throws ConnectException

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

            "com.sun.jndi.ldap.LdapCtxFactory");

    try {

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        Vector uvec = new Vector();

            Attribute attr = (Attribute)ae.next();

            for (NamingEnumeration e = attr.getAll(); e.hasMore();

                 uvec.add(e.next())

                 );

        // initialize users[]; fill users[]

        users = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          users[i] = (String)uvec.elementAt(i);

        }

        // Close the context when we're done

        ctx.close();

    } catch (NamingException e) {

              "AuthLdap.getUsers:" + e);

    return users;

  /**

   * Get all groups from the authentication service

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns string array of the group names

         throws ConnectException

  /**

   * Get the groups for a particular user from the authentication service

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @param foruser the user whose group list should be returned

   * @returns string array of the group names

         throws ConnectException

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

            "com.sun.jndi.ldap.LdapCtxFactory");

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        ctls.setReturningAttributes(attrIDs);

        ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

        String filter = null;

        String gfilter = "(objectClass=groupOfUniqueNames)";

        if (null == foruser) {

            filter = gfilter;

        } else {

            filter = "(& " + gfilter + "(uniqueMember=" + foruser + "))";

        }

        NamingEnumeration enum = ctx.search(ldapBase, filter, ctls);

        // Print the groups

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

        // initialize groups[] and fill it

        groups = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          groups[i] = (String)uvec.elementAt(i);

        }

        // Close the context when we're done

        ctx.close();

    } catch (NamingException e) {

      e.printStackTrace(System.err);

    return groups;

  /**

   * Get attributes describing a user or group

   *

   */

  {

  /**

   * Get attributes describing a user or group

   *

   */

  {

    HashMap attributes = new HashMap();

    String ldapBase = this.ldapBase;

    String userident = foruser;

      this.ldapBase = userident.substring(userident.indexOf(",")+1);

      userident = userident.substring(0,userident.indexOf(","));

    } catch (StringIndexOutOfBoundsException e) {}

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

        "com.sun.jndi.ldap.LdapCtxFactory");

    try {

      DirContext ctx = new InitialDirContext(env);

      Attributes attrs = ctx.getAttributes(foruser);

      NamingEnumeration en = attrs.getAll();

      while (en.hasMore()) {

        Attribute att = (Attribute)en.next();

        Vector values = new Vector();

        String attName = att.getID();

        NamingEnumeration attvalues = att.getAll();

        while (attvalues.hasMore()) {

          String value = (String)attvalues.next();

          values.add(value);

        }

        attributes.put(attName, values);

      }

      // Close the context when we're done

      ctx.close();

    } catch (NamingException e) {

              "AuthLdap.getAttributes:" + e);

      "Problem getting attributes in AuthLdap.getAttributes:" + e);

    return attributes;

  }

  /**

   * starting from the Metacat LDAP root,

   * i.e. ldap://dev.nceas.ucsb.edu/dc=ecoinformatics,dc=org

                                String ldapUrl, String ldapBase)

                throws ConnectException

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    try {

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"o","ref"};

        SearchControls ctls = new SearchControls();

        ctls.setReturningAttributes(attrIDs);

        ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

        // Specify the attributes to match.

        // Subtrees from the main server are found as objects with attribute

        // objectclass=organization or objectclass=referral to the subtree

        // resided on other server.

        String filter = "(|(objectclass=organization)(objectclass=referral))";

        // Search for objects in the current context

        NamingEnumeration enum = ctx.search("", filter, ctls);

        // Print the subtrees' <ldapURL, baseDN>

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

          Attributes attrs = sr.getAttributes();

          NamingEnumeration enum1 = attrs.getAll(); // "dc" and "ref" attrs

          if (enum1.hasMore()) {

            Attribute attr = (Attribute)enum1.next();

            String attrValue = (String)attr.get();

            String attrName = (String)attr.getID();

              attr = (Attribute)enum1.next();

              String refValue = (String)attr.get();

              String refName = (String)attr.getID();