CRUD for LDAP (UnboundID JDK, ApacheDS)

A raw implementation.
---Two ways to create, use CreateRequest or @LDAPObject
---Retrieve all sub entries or single entry based on DN. If want to retrieve all the entries including sub-entries under one dn, pass in the dn, and set filter as 'objectClass=*'.
---Support recursively delete all entries including sub entries.
     ApacheDS does not implement the tree delete function, so the SubtreeDeleteRequestControl in the jdk is not useful. So to support tree delete for ApacheDS, we need to implement recursively delete ourselves.
---ApacheDS seems does not support ModifyDSRequest with deleteOldRDN set to true.(Old RDN will still be left over, but as attribute instead of rdn, rdn is updated.)

TestService.java

package test.common.ldap.service;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.security.KeyFactory;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.Security;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import javax.naming.NamingException;

import test.common.ldap.entity.User;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang.StringUtils;

import com.unboundid.ldap.sdk.AddRequest;
import com.unboundid.ldap.sdk.Attribute;
import com.unboundid.ldap.sdk.DeleteRequest;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPConnection;
import com.unboundid.ldap.sdk.LDAPConnectionOptions;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.LDAPSearchException;
import com.unboundid.ldap.sdk.ModifyDNRequest;
import com.unboundid.ldap.sdk.SearchRequest;
import com.unboundid.ldap.sdk.SearchResult;
import com.unboundid.ldap.sdk.SearchResultEntry;
import com.unboundid.ldap.sdk.SearchScope;
import com.unboundid.ldap.sdk.controls.SubtreeDeleteRequestControl;
import com.unboundid.ldap.sdk.persist.LDAPPersistException;
import com.unboundid.ldap.sdk.persist.LDAPPersister;
import com.unboundid.ldif.LDIFException;

public class TestService {

   private String host;
   private String portString;
   private int port;
   private String psw;
   private int OPERATION_TIMEOUT_MILLIS = 1000;

   static {

       Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
   }

   public TestService() {

       // String confPath = "..\\conf";
       // String name = confPath + "\\conf.properties";

       String name = "C:\\Projects\\LDAPTestTool\\conf\\conf.properties";

       InputStream in = null;
       try {
           in = new BufferedInputStream(new FileInputStream(name));
       } catch (FileNotFoundException e) {
           e.printStackTrace();
       }
       Properties p = new Properties();
       try {
           p.load(in);
       } catch (IOException e) {
           e.printStackTrace();
       }

       host = p.getProperty("host");
       System.out.println("host read from propery file.");

       portString = p.getProperty("port");
       System.out.println("port read from propery file.");
       port = Integer.parseInt(portString);

       psw = p.getProperty("password");
       System.out.println("password read from propery file.");

   }

   public void create(String entryDN, String cn, byte[] p12Cert,
           byte[] publicKey, byte[] privateKey) {

       byte[] encodedPrivateCert = Base64.encodeBase64(privateKey);
       byte[] encodedP12Cert = Base64.encodeBase64(p12Cert);

       String[] ldifLines = { "dn: " + "cn=" + cn + "," + entryDN,
               "objectClass: top", "objectClass: tlsKeyInfo",
               "objectClass: person", "objectClass: organizationalPerson",
               "objectClass: inetOrgPerson", "changetype: add", "cn: " + cn,
               "sn: " + cn, "mail: " + cn, "keyAlgorithm: RSA",
               // "privateKey: " + new String(encodedp12Cert),
               "privateKeyFormat: PKCS#8",
               // "publicKey: " + new String(publicKey),
               "publicKeyFormat: X.509",
       // "userCertificate: " + new String(publicKey),
       };

       LDAPConnectionOptions connectionOptions = new LDAPConnectionOptions();
       connectionOptions.setAbandonOnTimeout(true);
       connectionOptions.setConnectTimeoutMillis(OPERATION_TIMEOUT_MILLIS);

       int result;
       LDAPResult ldapResult = null;
       try {

           // Connect to the server.
           LDAPConnection ldapConnection = new LDAPConnection(
                   connectionOptions, host, port);
           try {

               // Create the AddRequest object using the LDIF lines.
               AddRequest addRequest = new AddRequest(ldifLines);

               addRequest.addAttribute("privateKey", encodedPrivateCert);
               addRequest.addAttribute("publicKey", publicKey);
               addRequest.addAttribute("userCertificate", publicKey);
               addRequest.addAttribute("userPKCS12", encodedP12Cert);

               // Transmit the AddRequest to the server.
               ldapResult = ldapConnection.add(addRequest);

               System.out.println(ldapResult);

           } catch (final LDIFException e) {
               System.err.println(e);
           } finally {
               ldapConnection.close();

               // Convert the result code to an integer for use in the exit
               // method.
               result = ldapResult == null ? 1 : ldapResult.getResultCode()
                       .intValue();
           }
       } catch (final LDAPException e) {
           System.err.println(e);
           result = 1;
       }

       // System.exit(result);

   }

   public void createWithPersistObject(String entryDN, String cn,
           byte[] p12Cert, byte[] publicKey, byte[] privateKey) {

       byte[] encodedPrivateCert = Base64.encodeBase64(privateKey);
       byte[] encodedP12Cert = Base64.encodeBase64(p12Cert);

       LDAPPersister<User> persister = null;
       try {
           persister = LDAPPersister.getInstance(User.class);
       } catch (LDAPPersistException e2) {
           // TODO Auto-generated catch block
           e2.printStackTrace();
       }

       // Create a new MyObject instance and add it to the directory. We can
       // use
       // a parent DN of null to indicate that it should use the default
       // defined
       // in the @LDAPObject annotation.
       LDAPConnection ldapConnection = null;
       try {
           ldapConnection = getLdapConnection();
       } catch (LDAPException e1) {
           // TODO Auto-generated catch block
           e1.printStackTrace();
       }

       User user = new User();
       user.setDn("cn=" + cn + "," + entryDN);
       user.setCn(cn);
       user.setSn(cn);
       user.setMail(cn);
       user.setPrivateKey(encodedPrivateCert);
       user.setPublicKey(publicKey);
       user.setUserCertificate(publicKey);
       user.setUserPKCS12(encodedP12Cert);

       LDAPResult ldapResult = null;
       int result;
       try {
           ldapResult = persister.add(user, ldapConnection, null);

           System.out.println(ldapResult);

       } catch (Exception e) {
           System.err.println(e);
       } finally {
           ldapConnection.close();

           // Convert the result code to an integer for use in the exit method.
           result = ldapResult == null ? 1 : ldapResult.getResultCode()
                   .intValue();
       }

       // System.exit(result);

   }

   @SuppressWarnings({ "unchecked", "rawtypes" })
   public void search(String dn, String psw, String filter)
           throws NamingException {

       LDAPConnection ldapConnection = null;
       try {
           ldapConnection = getAuthLdapConnection(psw);
       } catch (LDAPException e1) {
           // TODO Auto-generated catch block
           e1.printStackTrace();
       }

       if (StringUtils.isNotEmpty(filter)) {
           SearchRequest searchRequest = null;
           try {
               searchRequest = new SearchRequest(dn, SearchScope.SUB, filter);
           } catch (LDAPException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }

           System.out
                   .println("========================================================");
           System.out.println("Search Result: ");

           try {
               SearchResult searchResult = ldapConnection
                       .search(searchRequest);

               for (SearchResultEntry entry : searchResult.getSearchEntries()) {
                   // String name = entry.getAttributeValue("cn");
                   // String mail = entry.getAttributeValue("mail");
                   /*
                    * StringBuilder buffer = new StringBuilder();
                    * 
                    * entry.toString(buffer);
                    * System.out.println(buffer.toString());
                    */
                   System.out.println();
                   System.out.println("Entry DN: " + entry.getDN());
                   List<Attribute> attributes = new ArrayList(
                           entry.getAttributes());
                   System.out
                           .println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
                   System.out.println("Entry content: ");

                   for (Attribute att : attributes) {

                       System.out.print(att.getName() + ": ");

                       String[] values = att.getValues();

                       for (int i = 0; i < values.length - 1; i++) {
                           System.out.print(values[i]);
                           System.out.print(",");
                       }
                       System.out.print(values[values.length - 1]);

                       System.out.println();

                   }
               }
               System.out
                       .println("========================================================");
               System.out.println("Search end.");
           } catch (LDAPSearchException lse) {
               System.err.println("The search failed.");
           }
       } else {

           Entry groupEntry = null;
           try {
               groupEntry = ldapConnection.getEntry(dn);
           } catch (LDAPException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
           }

           List<Attribute> attributes = new ArrayList(
                   groupEntry.getAttributes());
           System.out
                   .println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
           System.out.println("Entry content: ");

           for (Attribute att : attributes) {

               System.out.print(att.getName() + ": ");

               String[] values = att.getValues();

               for (int i = 0; i < values.length - 1; i++) {
                   System.out.print(values[i]);
                   System.out.print(",");
               }
               System.out.print(values[values.length - 1]);

               System.out.println();

           }

           System.out.println("End Search.");

           /*
            * String[] memberValues = groupEntry.getAttributeValues("member");
            * 
            * if (memberValues != null)
            * 
            * {
            * 
            * DNEntrySource entrySource = new DNEntrySource(ldapConnection,
            * memberValues, "cn");
            * 
            * while (true) { Entry memberEntry = entrySource.nextEntry(); if
            * (memberEntry == null) { break; }
            * 
            * System.out.println("Retrieved member entry:  " +
            * memberEntry.getAttributeValue("cn")); } }
            */
       }

   }

   public void update(String psw, String entryDN, String cn, String newDn,
           String newCn, byte[] p12Cert, byte[] publicKey, byte[] privateKey) {

       LDAPConnection ldapConnection = null;
       String fullDn = "cn=" + cn + "," + entryDN;

       if (StringUtils.isNotEmpty(newDn) || StringUtils.isNotEmpty(newCn)) {

           ModifyDNRequest modifyDNRequest = null;

           if (StringUtils.isEmpty(newDn)) {
               newDn = entryDN;
               modifyDNRequest = new ModifyDNRequest(fullDn, "cn=" + newCn,
                       true);
           }
           if (StringUtils.isEmpty(newCn)) {
               newCn = cn;
               modifyDNRequest = new ModifyDNRequest(fullDn, "cn=" + newCn,
                       true, newDn);
           }
           if (StringUtils.isNotEmpty(newDn) && StringUtils.isNotEmpty(newCn)) {

               modifyDNRequest = new ModifyDNRequest(fullDn, "cn=" + newCn,
                       true, newDn);
           }

           fullDn = "cn=" + newCn + "," + newDn;

           try {
               ldapConnection = null;
               try {
                   ldapConnection = getAuthLdapConnection(psw);
               } catch (LDAPException e1) {
                   // TODO Auto-generated catch block
                   e1.printStackTrace();
               }
               modifyDNRequest.setDeleteOldRDN(true);
               LDAPResult modifyDNResult = ldapConnection
                       .modifyDN(modifyDNRequest);

               System.out.println("The entry was renamed successfully.");
           } catch (LDAPException le) {
               le.printStackTrace();
               System.err.println("The modify DN operation failed.");
           }
       }

       if (StringUtils.isNotEmpty(newCn) || p12Cert != null
               || publicKey != null || privateKey != null) {

           LDAPPersister<User> persister = null;
           try {
               persister = LDAPPersister.getInstance(User.class);
           } catch (LDAPPersistException e2) {
               // TODO Auto-generated catch block
               e2.printStackTrace();
           }

           // Create a new MyObject instance and add it to the directory. We
           // can
           // use
           // a parent DN of null to indicate that it should use the default
           // defined
           // in the @LDAPObject annotation.

           try {
               ldapConnection = getAuthLdapConnection(psw);
           } catch (LDAPException e1) {
               // TODO Auto-generated catch block
               e1.printStackTrace();
           }

           User user = new User();
           user.setDn(fullDn);
           if (StringUtils.isEmpty(newCn)) {
               user.setCn(cn);
               user.setSn(cn);
               user.setMail(cn);
           } else {
               user.setCn(newCn);
               user.setSn(newCn);
               user.setMail(newCn);
           }

           if (p12Cert != null) {
               byte[] encodedP12Cert = Base64.encodeBase64(p12Cert);
               user.setUserPKCS12(encodedP12Cert);
           }
           if (privateKey != null) {
               byte[] encodedPrivateCert = Base64.encodeBase64(privateKey);
               user.setPrivateKey(encodedPrivateCert);
           }

           if (publicKey != null) {
               user.setPublicKey(publicKey);
               user.setUserCertificate(publicKey);
           }

           LDAPResult ldapResult = null;
           int result;
           try {
               ldapResult = persister
                       .modify(user, ldapConnection, null, false);

               System.out.println(ldapResult);

           } catch (Exception e) {
               System.err.println(e);
           } finally {
               ldapConnection.close();

               // Convert the result code to an integer for use in the exit
               // method.
               result = ldapResult == null ? 1 : ldapResult.getResultCode()
                       .intValue();
           }
       }

       // System.exit(result);

   }

   public void deleteOneLevel(String psw, String entryDN) {

       LDAPConnection ldapConnection = null;
       try {
           ldapConnection = getAuthLdapConnection(psw);
       } catch (LDAPException e1) {
           // TODO Auto-generated catch block
           e1.printStackTrace();
       }

       DeleteRequest deleteRequest = new DeleteRequest(entryDN);
       deleteRequest.addControl(new SubtreeDeleteRequestControl());

       LDAPResult ldapResult = null;
       int result;
       try {
           ldapResult = ldapConnection.delete(deleteRequest);

           System.out.println("The entry was successfully deleted.");
       } catch (LDAPException le) {
           le.printStackTrace();
           System.err.println("The delete operation failed.");
       } finally {
           ldapConnection.close();

           // Convert the result code to an integer for use in the exit method.
           result = ldapResult == null ? 1 : ldapResult.getResultCode()
                   .intValue();
       }

       // System.exit(result);
   }

   public void delete(String psw, String entryDN) throws LDAPException {

       LDAPConnection ldapConnection = null;
       try {
           ldapConnection = getAuthLdapConnection(psw);
       } catch (LDAPException e1) {
           // TODO Auto-generated catch block
           e1.printStackTrace();
       }

       deleteSubEntry(entryDN, ldapConnection);

       return;
   }

   public void deleteSubEntry(String entry, LDAPConnection ldapConnection)
           throws LDAPException {

       // System.out.println("deleteSubEntry '"+entry+"' start.");

       SearchRequest searchRequest = null;
       String filter = "objectClass=*";

       searchRequest = new SearchRequest(entry, SearchScope.ONE, filter);

       SearchResult searchResult = null;

       // System.out.println("search sub-entry for entry '"+entry+"' start.");
       searchResult = ldapConnection.search(searchRequest);

       if (searchResult.getEntryCount() == 0) {
           // System.out.println("No sub entry.");
           deleteEntry(entry, ldapConnection);
       } else {
           // System.out.println("Sub entries exist.");
           for (SearchResultEntry entryResult : searchResult
                   .getSearchEntries()) {

               if (!entryResult.getDN().equalsIgnoreCase(entry)) {
                   // System.out.println("Get sub entry: " +
                   // entryResult.getDN());
                   deleteSubEntry(entryResult.getDN(), ldapConnection);
               }

           }
           // System.out.println("Start delete parent entry " + entry);
           deleteEntry(entry, ldapConnection);
       }

       // return;
   }

   public void deleteEntry(String entry, LDAPConnection ldapConnection) {

       DeleteRequest deleteRequest = new DeleteRequest(entry);

       LDAPResult ldapResult = null;
       int result;
       try {
           ldapResult = ldapConnection.delete(deleteRequest);

           System.out.println("The entry '" + entry
                   + "' was successfully deleted.");
       } catch (LDAPException le) {
           le.printStackTrace();
           System.err.println("The delete operation for entry '" + entry
                   + "' failed.");
       } finally {

           // Convert the result code to an integer for use in the exit method.
           result = ldapResult == null ? 1 : ldapResult.getResultCode()
                   .intValue();
       }
   }

   public LDAPConnection getLdapConnection() throws LDAPException {

       LDAPConnectionOptions connectionOptions = new LDAPConnectionOptions();
       connectionOptions.setAbandonOnTimeout(true);
       connectionOptions.setConnectTimeoutMillis(OPERATION_TIMEOUT_MILLIS);

       LDAPConnection ldapConnection = new LDAPConnection(connectionOptions,
               host, port);

       return ldapConnection;
   }

   public LDAPConnection getAuthLdapConnection(String psw)
           throws LDAPException {

       LDAPConnectionOptions connectionOptions = new LDAPConnectionOptions();
       connectionOptions.setAbandonOnTimeout(true);
       connectionOptions.setConnectTimeoutMillis(OPERATION_TIMEOUT_MILLIS);

       LDAPConnection ldapConnection = new LDAPConnection(connectionOptions,
               host, port, "uid=admin,ou=system", psw);

       return ldapConnection;
   }

   public byte[] readDataFromFile(String path) {

       InputStream is = null;
       ByteArrayOutputStream out = new ByteArrayOutputStream();

       try {
           is = new BufferedInputStream(new FileInputStream(path));
           byte[] b = new byte[1024];
           int n;
           while ((n = is.read(b)) != -1) {
               out.write(b, 0, n);
           }

       } catch (Exception e) {
           // e.printStackTrace();
           return null;
       } finally {
           if (is != null) {
               try {
                   is.close();
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
       }
       return out.toByteArray();
   }

   private byte[] InputStreamToByte(InputStream is) throws IOException {

       ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
       int ch;
       while ((ch = is.read()) != -1) {
           bytestream.write(ch);
       }
       byte imgdata[] = bytestream.toByteArray();
       bytestream.close();
       return imgdata;

   }
}

App.java

package test.common.ldap.tool;

import java.util.Scanner;

import javax.naming.NamingException;

import test.common.ldap.service.TestService;

import org.apache.commons.lang.StringUtils;

import com.unboundid.ldap.sdk.LDAPException;

/**
*
*/
public class App
{
   public static void main( String[] args )
   {  
       TestService service = new TestService();
       manu(service);
   }
 
   public static void manu(TestService service){
       System.out.println("----------------------------------------");
       System.out.println("----------------MODE--------------------");
       System.out.println("1: create");
       System.out.println("2: retrieve");
       System.out.println("3: update");
       System.out.println("4: delete");
     
       Scanner input = new Scanner(System.in);
       System.out.print("Key in the selection : ");
     
       String selectionString = input.next();
     
       boolean isValid = StringUtils.isNumeric(selectionString);
       if(isValid) {
           int option = Integer.parseInt(selectionString);
           if(option==1){
             
               System.out.print("Please input the entry dn: ");
               Scanner inputScanner = new Scanner(System.in);
               String dn = inputScanner.next();
               //String dn = "ou=users,ou=system";
               System.out.println("entry dn: " + dn);
             
               System.out.print("Please input the entry cn: ");
               inputScanner = new Scanner(System.in);
               String cn = inputScanner.next();
             
               System.out.println("entry cn: " + cn);
             
               System.out.print("Please input the p12 cert location: ");
               byte[] p12certData = getCertDataFromPath(service);
             
               System.out.println("p12 cert data read: " + new String(p12certData) );
             
             
             
               System.out.print("Please input the public cert location: ");
               byte[] publicCertData =getCertDataFromPath(service);
             
               System.out.println("public cert data read: " + new String(publicCertData));
             
             
             
               System.out.print("Please input the private cert location: ");
               byte[] privateCertData = getCertDataFromPath(service);
             
               System.out.println("private cert data read: " + new String(privateCertData));
             
             
             
               service.createWithPersistObject(dn, cn, p12certData, publicCertData, privateCertData);
           }else if(option ==2){
             
               System.out.print("Please input the entry dn: ");
               Scanner inputScanner = new Scanner(System.in);
               String dn = inputScanner.next();
               //String dn = "ou=system";
               System.out.println("entry dn: " + dn);
             
               System.out.print("Please input the password: ");
               inputScanner = new Scanner(System.in);
               String psw = inputScanner.next();
             
               System.out.println("password: " + psw);
             
               System.out.print("Please input the filter(if do not have, input n): ");
               inputScanner = new Scanner(System.in);
               String filter = inputScanner.next();
             
               if(filter.equalsIgnoreCase("n")){
                   filter = null;
               }else{
                   System.out.println("entry filter: " + filter);
               }
             
             
               try {
                   service.search(dn, psw, filter);
               } catch (NamingException e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }
             
           }else if(option ==3){
             
               System.out.print("Please input the entry dn: ");
               Scanner inputScanner = new Scanner(System.in);
               String dn = inputScanner.next();
               //String dn = "ou=users,ou=system";
               System.out.println("entry dn: " + dn);
             
               System.out.print("Please input the password: ");
               inputScanner = new Scanner(System.in);
               String psw = inputScanner.next();
             
               System.out.println("password: " + psw);
             
               System.out.print("Please input the entry cn: ");
               inputScanner = new Scanner(System.in);
               String cn = inputScanner.next();
             
               System.out.println("entry cn: " + cn);
             
               System.out.print("Please input the new entry dn(if do not want to update, input n): ");
               inputScanner = new Scanner(System.in);
               String newDn = inputScanner.next();
               //String newDn = "ou=system";
               if(newDn.equalsIgnoreCase("n")){
                   newDn = null;
               }else{
                   System.out.println("New entry dn: " + newDn);
               }
             
               System.out.print("Please input the new cn(if do not want to update, input n): ");
               inputScanner = new Scanner(System.in);
               String newCn = inputScanner.next();
             
               if(newCn.equalsIgnoreCase("n")){
                   newCn = null;
               }else{
                   System.out.println("New cn: " + newCn);
               }
             
             
               System.out.println("For below options, if no update, please input n or any other invalid path");

               System.out.print("Please input the p12 cert location: ");
               inputScanner = new Scanner(System.in);
               String certLocation = inputScanner.next();
               byte[] p12certData = getCertData(service,certLocation);
               if(p12certData!=null){
                   System.out.println("p12 cert data read: " + new String(p12certData) );
               }
             
             
             
             
               System.out.print("Please input the public cert location: ");
               inputScanner = new Scanner(System.in);
               certLocation = inputScanner.next();
               byte[] publicCertData = getCertData(service,certLocation);

               if(publicCertData!=null){
                   System.out.println("public cert data read: " + new String(publicCertData));
               }
             
               System.out.print("Please input the private cert location: ");
               inputScanner = new Scanner(System.in);
               certLocation = inputScanner.next();
               byte[] privateCertData = getCertData(service,certLocation);

               if(privateCertData!=null){
                   System.out.println("private cert data read: " + new String(privateCertData));
               }
             
             

               service.update(psw, dn, cn, newDn, newCn, p12certData, publicCertData, privateCertData);
             
           }else if(option ==4){
               System.out.println("WARN: DELETE will delete all the sub-entries too, if exist.");
               System.out.print("Please input the entry dn: ");
               Scanner inputScanner = new Scanner(System.in);
               String dn = inputScanner.next();

               System.out.println("entry dn: " + dn);
             
               System.out.print("Please input the password: ");
               inputScanner = new Scanner(System.in);
               String psw = inputScanner.next();

               System.out.println("password: " + psw);
             
               try {
                   service.delete(psw, dn);
               } catch (LDAPException e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }
             
           }else{
               System.out.println("Invalid option: " + selectionString);
               manu(service);
           }
       } else {
           System.out.println("Invalid option: " + selectionString);
           manu(service);
       }
     
       manu(service);
   }
 
   public static byte[] getCertDataFromPath(TestService service){
     
       Scanner inputScanner = new Scanner(System.in);
       String certLocation = inputScanner.next();
     
       byte[] data = null;
       try{
           data = service.readDataFromFile(certLocation);
         
       }catch(Exception e){
           e.printStackTrace();
           data = null;
       }
       if(data==null){
           System.out.println("Invalid cert path: " + certLocation);
           System.out.print("Please enter again: ");
           return getCertDataFromPath(service);
       }
     
       return data;
   }

   static byte[] getCertData(TestService service, String certLocation){
     
       byte[] data = null;
       try{
           data = service.readDataFromFile(certLocation);
       }catch(Exception e){
           e.printStackTrace();
           data = null;
       }
       return data;
   }
 
 
}

User.java

package test.common.ldap.entity;

import com.unboundid.ldap.sdk.persist.FilterUsage;
import com.unboundid.ldap.sdk.persist.LDAPDNField;
import com.unboundid.ldap.sdk.persist.LDAPField;
import com.unboundid.ldap.sdk.persist.LDAPObject;

@LDAPObject(structuralClass = "inetOrgPerson", auxiliaryClass = "tlsKeyInfo", defaultParentDN = "ou=users,ou=system")
public class User {

   @LDAPDNField
   private String dn;
 
   // The field used for RDN attribute myStringAttr.
   @LDAPField(attribute = "cn", inRDN = true, filterUsage = FilterUsage.ALWAYS_ALLOWED, requiredForEncode = true)
   private String cn;

   @LDAPField(attribute = "sn")
   private String sn;
 
   @LDAPField(attribute = "mail")
   private String mail;

   @LDAPField(attribute = "keyAlgorithm")
   private String keyAlgorithm = "RSA";

   @LDAPField(attribute = "privateKeyFormat")
   private String privateKeyFormat = "PKCS#8";

   @LDAPField(attribute = "publicKeyFormat")
   private String publicKeyFormat = "X.509";

   @LDAPField(attribute = "privateKey")
   private byte[] privateKey;

   @LDAPField(attribute = "publicKey")
   private byte[] publicKey;

   @LDAPField(attribute = "userCertificate")
   private byte[] userCertificate;

   @LDAPField(attribute = "userPKCS12")
   private byte[] userPKCS12;

 
   public String getDn() {
       return dn;
   }

   public void setDn(String dn) {
       this.dn = dn;
   }
 
   public String getCn() {
       return cn;
   }

   public void setCn(String cn) {
       this.cn = cn;
   }

   public String getSn() {
       return sn;
   }

   public void setSn(String sn) {
       this.sn = sn;
   }

   public String getMail() {
       return mail;
   }

   public void setMail(String mail) {
       this.mail = mail;
   }

   public String getKeyAlgorithm() {
       return keyAlgorithm;
   }

   public void setKeyAlgorithm(String keyAlgorithm) {
       this.keyAlgorithm = keyAlgorithm;
   }

   public String getPrivateKeyFormat() {
       return privateKeyFormat;
   }

   public void setPrivateKeyFormat(String privateKeyFormat) {
       this.privateKeyFormat = privateKeyFormat;
   }

   public String getPublicKeyFormat() {
       return publicKeyFormat;
   }

   public void setPublicKeyFormat(String publicKeyFormat) {
       this.publicKeyFormat = publicKeyFormat;
   }

   public byte[] getPrivateKey() {
       return privateKey;
   }

   public void setPrivateKey(byte[] privateKey) {
       this.privateKey = privateKey;
   }

   public byte[] getPublicKey() {
       return publicKey;
   }

   public void setPublicKey(byte[] publicKey) {
       this.publicKey = publicKey;
   }

   public byte[] getUserCertificate() {
       return userCertificate;
   }

   public void setUserCertificate(byte[] userCertificate) {
       this.userCertificate = userCertificate;
   }

   public byte[] getUserPKCS12() {
       return userPKCS12;
   }

   public void setUserPKCS12(byte[] userPKCS12) {
       this.userPKCS12 = userPKCS12;
   }
}