diff --git a/configure.ac b/configure.ac
index 72acd4a..baa84a4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -71,6 +71,10 @@
 AS_IF([test "x$TLS_CACERT_FILE" == "x"], [TLS_CACERT_FILE="/etc/ssl/certs/Root-CA.pem"])
 AC_DEFINE_UNQUOTED([TLS_CACERT_FILE], ["$TLS_CACERT_FILE"], [Path of LDAP server's CA certificate])
 
+AC_ARG_VAR(TLS_CERT_FILE, [Path of LDAP's client certificate])
+AS_IF([test "x$TLS_CERT_FILE" == "x"], [TLS_CERT_FILE="/etc/nslcd/certs/cert.pem"])
+AC_DEFINE_UNQUOTED([TLS_CERT_FILE], ["$TLS_CERT_FILE"], [Path of LDAP's client certificate])
+
 AC_ARG_VAR(LDAP_CONFIG_ROOT, [LDAP configuration root])
 AS_IF([test "x$LDAP_CONFIG_ROOT" == "x"], [LDAP_CONFIG_ROOT="/xyz/openbmc_project/user/ldap"])
 AC_DEFINE_UNQUOTED([LDAP_CONFIG_ROOT], ["$LDAP_CONFIG_ROOT"], [LDAP configuration root])
diff --git a/phosphor-ldap-config/ldap_config.cpp b/phosphor-ldap-config/ldap_config.cpp
index b22d684..80b8c9c 100644
--- a/phosphor-ldap-config/ldap_config.cpp
+++ b/phosphor-ldap-config/ldap_config.cpp
@@ -27,6 +27,7 @@
 constexpr auto nscdService = "nscd.service";
 constexpr auto LDAPscheme = "ldap";
 constexpr auto LDAPSscheme = "ldaps";
+constexpr auto certObjPath = "/xyz/openbmc_project/certs/client/ldap";
 
 using namespace phosphor::logging;
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
@@ -44,7 +45,7 @@
 using ConfigInfo = std::map<Key, Val>;
 
 Config::Config(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
-               const char* caCertFile, bool secureLDAP,
+               const char* caCertFile, const char* certFile, bool secureLDAP,
                std::string lDAPServerURI, std::string lDAPBindDN,
                std::string lDAPBaseDN, std::string&& lDAPBindDNPassword,
                ConfigIface::SearchScope lDAPSearchScope,
@@ -53,8 +54,12 @@
                ConfigMgr& parent) :
     Ifaces(bus, path, true),
     secureLDAP(secureLDAP), lDAPBindPassword(std::move(lDAPBindDNPassword)),
-    tlsCacertFile(caCertFile), configFilePath(filePath), objectPath(path),
-    bus(bus), parent(parent)
+    tlsCacertFile(caCertFile), tlsCertFile(certFile), configFilePath(filePath),
+    objectPath(path), bus(bus), parent(parent),
+    certificateInstalledSignal(
+        bus, sdbusplus::bus::match::rules::interfacesAdded(certObjPath),
+        std::bind(std::mem_fn(&Config::certificateInstalled), this,
+                  std::placeholders::_1))
 {
     ConfigIface::lDAPServerURI(lDAPServerURI);
     ConfigIface::lDAPBindDN(lDAPBindDN);
@@ -96,7 +101,11 @@
                ConfigMgr& parent) :
     Ifaces(bus, path, true),
     tlsCacertFile(caCertFile), configFilePath(filePath), objectPath(path),
-    bus(bus), parent(parent)
+    bus(bus), parent(parent),
+    certificateInstalledSignal(
+        bus, sdbusplus::bus::match::rules::interfacesAdded(certObjPath),
+        std::bind(std::mem_fn(&Config::certificateInstalled), this,
+                  std::placeholders::_1))
 {
     ConfigIface::lDAPType(lDAPType);
 
@@ -115,6 +124,27 @@
     fs::permissions(configPersistPath, permission);
 }
 
+void Config::certificateInstalled(sdbusplus::message::message& msg)
+{
+    try
+    {
+        if (enabled())
+        {
+            writeConfig();
+        }
+        parent.startOrStopService(nslcdService, enabled());
+    }
+    catch (const InternalFailure& e)
+    {
+        throw;
+    }
+    catch (const std::exception& e)
+    {
+        log<level::ERR>(e.what());
+        elog<InternalFailure>();
+    }
+}
+
 void Config::writeConfig()
 {
     std::stringstream confData;
@@ -156,6 +186,11 @@
         confData << "ssl on\n";
         confData << "tls_reqcert hard\n";
         confData << "tls_cacertFile " << tlsCacertFile.c_str() << "\n";
+        if (fs::exists(tlsCertFile.c_str()))
+        {
+            confData << "tls_cert " << tlsCertFile.c_str() << "\n";
+            confData << "tls_key " << tlsCertFile.c_str() << "\n";
+        }
     }
     else
     {
diff --git a/phosphor-ldap-config/ldap_config.hpp b/phosphor-ldap-config/ldap_config.hpp
index cbd2e04..d2cc8de 100644
--- a/phosphor-ldap-config/ldap_config.hpp
+++ b/phosphor-ldap-config/ldap_config.hpp
@@ -36,6 +36,8 @@
     sdbusplus::server::object::object<ConfigIface, EnableIface, MapperIface>;
 using ObjectPath = sdbusplus::message::object_path;
 
+namespace sdbusRule = sdbusplus::bus::match::rules;
+
 class ConfigMgr;
 class MockConfigMgr;
 
@@ -59,6 +61,7 @@
      *  @param[in] path - The D-Bus object path to attach at.
      *  @param[in] filePath - LDAP configuration file.
      *  @param[in] caCertFile - LDAP's CA certificate file.
+     *  @param[in] certFile - LDAP's client certificate file.
      *  @param[in] secureLDAP - Specifies whether to use SSL or not.
      *  @param[in] lDAPServerURI - LDAP URI of the server.
      *  @param[in] lDAPBindDN - distinguished name with which to bind.
@@ -78,9 +81,9 @@
      */
 
     Config(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
-           const char* caCertFile, bool secureLDAP, std::string lDAPServerURI,
-           std::string lDAPBindDN, std::string lDAPBaseDN,
-           std::string&& lDAPBindDNPassword,
+           const char* caCertFile, const char* certFile, bool secureLDAP,
+           std::string lDAPServerURI, std::string lDAPBindDN,
+           std::string lDAPBaseDN, std::string&& lDAPBindDNPassword,
            ConfigIface::SearchScope lDAPSearchScope, ConfigIface::Type lDAPType,
            bool lDAPServiceEnabled, std::string groupNameAttribute,
            std::string userNameAttribute, ConfigMgr& parent);
@@ -246,6 +249,7 @@
     bool secureLDAP;
     std::string lDAPBindPassword{};
     std::string tlsCacertFile{};
+    std::string tlsCertFile{};
     std::string configFilePath{};
     std::string objectPath{};
     std::filesystem::path configPersistPath{};
@@ -270,6 +274,12 @@
     std::set<std::string> privMgr = {"priv-admin", "priv-operator", "priv-user",
                                      "priv-callback"};
 
+    /** @brief React to InterfaceAdded signal
+     *  @param[in] msg - sdbusplus message
+     */
+    void certificateInstalled(sdbusplus::message::message& msg);
+    sdbusplus::bus::match_t certificateInstalledSignal;
+
     friend class MockConfigMgr;
 };
 
diff --git a/phosphor-ldap-config/ldap_config_mgr.cpp b/phosphor-ldap-config/ldap_config_mgr.cpp
index 401aacc..1eb3798 100644
--- a/phosphor-ldap-config/ldap_config_mgr.cpp
+++ b/phosphor-ldap-config/ldap_config_mgr.cpp
@@ -134,8 +134,8 @@
         objPath = openLDAPDbusObjectPath;
         openLDAPConfigPtr = std::make_unique<Config>(
             bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
-            secureLDAP, lDAPServerURI, lDAPBindDN, lDAPBaseDN,
-            std::move(lDAPBindDNPassword),
+            tlsCertFile.c_str(), secureLDAP, lDAPServerURI, lDAPBindDN,
+            lDAPBaseDN, std::move(lDAPBindDNPassword),
             static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
             static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
             userNameAttribute, *this);
@@ -146,8 +146,8 @@
         objPath = ADDbusObjectPath;
         ADConfigPtr = std::make_unique<Config>(
             bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
-            secureLDAP, lDAPServerURI, lDAPBindDN, lDAPBaseDN,
-            std::move(lDAPBindDNPassword),
+            tlsCertFile.c_str(), secureLDAP, lDAPServerURI, lDAPBindDN,
+            lDAPBaseDN, std::move(lDAPBindDNPassword),
             static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
             static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
             userNameAttribute, *this);
diff --git a/phosphor-ldap-config/ldap_config_mgr.hpp b/phosphor-ldap-config/ldap_config_mgr.hpp
index dc04546..7186503 100644
--- a/phosphor-ldap-config/ldap_config_mgr.hpp
+++ b/phosphor-ldap-config/ldap_config_mgr.hpp
@@ -52,10 +52,11 @@
      *  @param[in] caCertFile - LDAP's CA certificate file.
      */
     ConfigMgr(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
-              const char* dbusPersistentPath, const char* caCertFile) :
+              const char* dbusPersistentPath, const char* caCertFile,
+              const char* certFile) :
         CreateIface(bus, path, true),
         dbusPersistentPath(dbusPersistentPath), configFilePath(filePath),
-        bus(bus)
+        tlsCacertFile(caCertFile), tlsCertFile(certFile), bus(bus)
     {
     }
 
@@ -116,6 +117,7 @@
   protected:
     std::string configFilePath{};
     std::string tlsCacertFile{};
+    std::string tlsCertFile{};
 
     /** @brief Persistent sdbusplus D-Bus bus connection. */
     sdbusplus::bus::bus& bus;
diff --git a/phosphor-ldap-config/main.cpp b/phosphor-ldap-config/main.cpp
index 3a2d5f5..31e0d46 100644
--- a/phosphor-ldap-config/main.cpp
+++ b/phosphor-ldap-config/main.cpp
@@ -26,7 +26,8 @@
     sdbusplus::server::manager::manager objManager(bus, LDAP_CONFIG_ROOT);
 
     phosphor::ldap::ConfigMgr mgr(bus, LDAP_CONFIG_ROOT, LDAP_CONFIG_FILE,
-                                  LDAP_CONF_PERSIST_PATH, TLS_CACERT_FILE);
+                                  LDAP_CONF_PERSIST_PATH, TLS_CACERT_FILE,
+                                  TLS_CERT_FILE);
     mgr.restore();
 
     bus.request_name(LDAP_CONFIG_BUSNAME);
diff --git a/test/ldap_config_test.cpp b/test/ldap_config_test.cpp
index 97c265d..ab354ff 100644
--- a/test/ldap_config_test.cpp
+++ b/test/ldap_config_test.cpp
@@ -41,8 +41,11 @@
         using namespace phosphor::ldap;
         char tmpldap[] = "/tmp/ldap_test.XXXXXX";
         dir = fs::path(mkdtemp(tmpldap));
-        fs::path tslCacertFilePath{TLS_CACERT_FILE};
-        tslCacertFile = tslCacertFilePath.filename().c_str();
+        fs::path tlsCacertFilePath{TLS_CACERT_FILE};
+        tlsCacertFile = tlsCacertFilePath.filename().c_str();
+        fs::path tlsCertFilePath{TLS_CERT_FILE};
+        tlsCertFile = tlsCertFilePath.filename().c_str();
+
         fs::path confFilePath{LDAP_CONFIG_FILE};
         ldapconfFile = confFilePath.filename().c_str();
         std::fstream fs;
@@ -50,6 +53,10 @@
         fs.close();
         fs.open(dir / nsSwitchFile, std::fstream::out);
         fs.close();
+        fs.open(dir / tlsCacertFile, std::fstream::out);
+        fs.close();
+        fs.open(dir / tlsCertFile, std::fstream::out);
+        fs.close();
     }
 
     void TearDown() override
@@ -59,7 +66,8 @@
 
   protected:
     fs::path dir;
-    std::string tslCacertFile;
+    std::string tlsCacertFile;
+    std::string tlsCertFile;
     std::string ldapconfFile;
     sdbusplus::bus::bus bus;
 };
@@ -69,9 +77,9 @@
   public:
     MockConfigMgr(sdbusplus::bus::bus& bus, const char* path,
                   const char* filePath, const char* dbusPersistentFile,
-                  const char* caCertFile) :
+                  const char* caCertFile, const char* certFile) :
         phosphor::ldap::ConfigMgr(bus, path, filePath, dbusPersistentFile,
-                                  caCertFile)
+                                  caCertFile, certFile)
     {
     }
     MOCK_METHOD1(restartService, void(const std::string& service));
@@ -107,7 +115,8 @@
 TEST_F(TestLDAPConfig, testCreate)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -116,8 +125,8 @@
     }
     EXPECT_FALSE(fs::exists(configFilePath));
     MockConfigMgr manager(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-                          dbusPersistentFilePath.c_str(),
-                          tlsCacertfile.c_str());
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
 
     EXPECT_CALL(manager, stopService("nslcd.service")).Times(2);
     EXPECT_CALL(manager, restartService("nslcd.service")).Times(2);
@@ -166,7 +175,8 @@
 TEST_F(TestLDAPConfig, testDefaultObject)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -176,8 +186,8 @@
     EXPECT_FALSE(fs::exists(configFilePath));
 
     MockConfigMgr manager(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-                          dbusPersistentFilePath.c_str(),
-                          tlsCacertfile.c_str());
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
 
     manager.createDefaultObjects();
 
@@ -192,7 +202,8 @@
 TEST_F(TestLDAPConfig, testRestores)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -200,9 +211,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nscd.service")).Times(1);
@@ -238,7 +250,8 @@
 TEST_F(TestLDAPConfig, testLDAPServerURI)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -246,9 +259,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
 
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(2);
@@ -265,6 +279,7 @@
     EXPECT_EQ(managerPtr->getADConfigPtr()->lDAPServerURI(),
               "ldap://9.194.251.139/");
 
+    fs::remove(tlsCacertfile.c_str());
     // Change LDAP Server URI to make it secure
     EXPECT_THROW(
         managerPtr->getADConfigPtr()->lDAPServerURI("ldaps://9.194.251.139/"),
@@ -284,7 +299,8 @@
 TEST_F(TestLDAPConfig, testLDAPBindDN)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -292,9 +308,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
 
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(2);
@@ -335,7 +352,8 @@
 TEST_F(TestLDAPConfig, testLDAPBaseDN)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -343,9 +361,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(2);
     EXPECT_CALL(*managerPtr, restartService("nscd.service")).Times(1);
@@ -383,7 +402,8 @@
 TEST_F(TestLDAPConfig, testSearchScope)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -391,9 +411,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(2);
     EXPECT_CALL(*managerPtr, restartService("nscd.service")).Times(1);
@@ -419,7 +440,8 @@
 TEST_F(TestLDAPConfig, testLDAPType)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -427,9 +449,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nscd.service")).Times(1);
@@ -457,7 +480,8 @@
 TEST_F(TestLDAPConfig, filePermission)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -465,9 +489,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(1);
     EXPECT_CALL(*managerPtr, restartService("nscd.service")).Times(1);
@@ -492,7 +517,8 @@
 TEST_F(TestLDAPConfig, ConditionalEnableConfig)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -500,9 +526,10 @@
         fs::remove(configFilePath);
     }
     EXPECT_FALSE(fs::exists(configFilePath));
-    MockConfigMgr* managerPtr = new MockConfigMgr(
-        bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-        dbusPersistentFilePath.c_str(), tlsCacertfile.c_str());
+    MockConfigMgr* managerPtr =
+        new MockConfigMgr(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     EXPECT_CALL(*managerPtr, stopService("nslcd.service")).Times(3);
     EXPECT_CALL(*managerPtr, restartService("nslcd.service")).Times(2);
     EXPECT_CALL(*managerPtr, restartService("nscd.service")).Times(2);
@@ -553,7 +580,8 @@
 TEST_F(TestLDAPConfig, createPrivMapping)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -562,8 +590,8 @@
     }
     EXPECT_FALSE(fs::exists(configFilePath));
     MockConfigMgr manager(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-                          dbusPersistentFilePath.c_str(),
-                          tlsCacertfile.c_str());
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     manager.createDefaultObjects();
     // Create the priv-mapping under the config.
     manager.getADConfigPtr()->create("admin", "priv-admin");
@@ -585,7 +613,8 @@
 TEST_F(TestLDAPConfig, deletePrivMapping)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -594,8 +623,8 @@
     }
     EXPECT_FALSE(fs::exists(configFilePath));
     MockConfigMgr manager(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-                          dbusPersistentFilePath.c_str(),
-                          tlsCacertfile.c_str());
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     manager.createDefaultObjects();
     // Create the priv-mapping under the config.
     manager.getADConfigPtr()->create("admin", "priv-admin");
@@ -625,7 +654,8 @@
 TEST_F(TestLDAPConfig, restorePrivMapping)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -634,8 +664,8 @@
     }
     EXPECT_FALSE(fs::exists(configFilePath));
     MockConfigMgr manager(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-                          dbusPersistentFilePath.c_str(),
-                          tlsCacertfile.c_str());
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     manager.createDefaultObjects();
     // Create the priv-mapping under the config.
     manager.getADConfigPtr()->create("admin", "priv-admin");
@@ -671,7 +701,8 @@
 TEST_F(TestLDAPConfig, testPrivileges)
 {
     auto configFilePath = std::string(dir.c_str()) + "/" + ldapconfFile;
-    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tslCacertFile;
+    auto tlsCacertfile = std::string(dir.c_str()) + "/" + tlsCacertFile;
+    auto tlsCertfile = std::string(dir.c_str()) + "/" + tlsCertFile;
     auto dbusPersistentFilePath = std::string(dir.c_str());
 
     if (fs::exists(configFilePath))
@@ -680,8 +711,8 @@
     }
     EXPECT_FALSE(fs::exists(configFilePath));
     MockConfigMgr manager(bus, LDAP_CONFIG_ROOT, configFilePath.c_str(),
-                          dbusPersistentFilePath.c_str(),
-                          tlsCacertfile.c_str());
+                          dbusPersistentFilePath.c_str(), tlsCacertfile.c_str(),
+                          tlsCertfile.c_str());
     manager.createDefaultObjects();
 
     std::string groupName = "admin";