diff --git a/catalogue/TapePool.cpp b/catalogue/TapePool.cpp
index cf17204aa1ed4ea22867e07adb558a1722908d6e..869fa46ed974f691b2d517bdedd5f3c11f4828d9 100644
--- a/catalogue/TapePool.cpp
+++ b/catalogue/TapePool.cpp
@@ -42,6 +42,7 @@ std::ostream &operator<<(std::ostream &os, const TapePool &obj) {
      << " vo=" << obj.vo.name
      << " nbPartialTapes=" << obj.nbPartialTapes
      << " encryption=" << obj.encryption
+     << " encryptionKeyName=" << obj.encryptionKeyName.value_or("")
      << " nbTapes=" << obj.nbTapes
      << " nbEmptyTapes=" << obj.nbEmptyTapes
      << " nbDisabledTapes=" << obj.nbDisabledTapes
diff --git a/catalogue/TapePool.hpp b/catalogue/TapePool.hpp
index bf0fbe2c70dea5d1429b3304631e924e6aa236b1..0484a683acd277d4956a94474cceb72a9dc38549 100644
--- a/catalogue/TapePool.hpp
+++ b/catalogue/TapePool.hpp
@@ -74,6 +74,11 @@ struct TapePool {
    */
   bool encryption = false;
 
+  /**
+   * Tape pool encryption key name.
+   */
+  std::optional<std::string> encryptionKeyName;
+
   /**
    * The total number of tapes in the pool.
    */
diff --git a/catalogue/TapePoolSearchCriteria.hpp b/catalogue/TapePoolSearchCriteria.hpp
index 4549665b1bded07f9279f9b0a2d148dabac517aa..41a409db121d1cbf7685d15935d10e75a997f384 100644
--- a/catalogue/TapePoolSearchCriteria.hpp
+++ b/catalogue/TapePoolSearchCriteria.hpp
@@ -49,6 +49,11 @@ struct TapePoolSearchCriteria {
     */
     std::optional<bool> encrypted;
 
+    /**
+    * The encryption key name.
+    */
+    std::optional<std::string> encryptionKeyName;
+
 }; // struct TapePoolSearchCriteria
 
 } // namespace cta::catalogue
diff --git a/catalogue/dummy/DummyTapePoolCatalogue.cpp b/catalogue/dummy/DummyTapePoolCatalogue.cpp
index 12d17d056e00901b888df73c9b1da4b326051f49..cabadb114fc6de372b0fcd4328fc98248a4701e8 100644
--- a/catalogue/dummy/DummyTapePoolCatalogue.cpp
+++ b/catalogue/dummy/DummyTapePoolCatalogue.cpp
@@ -29,7 +29,7 @@ void DummyTapePoolCatalogue::createTapePool(const common::dataStructures::Securi
                                             const std::string& name,
                                             const std::string& vo,
                                             const uint64_t nbPartialTapes,
-                                            const bool encryptionValue,
+                                            const std::optional<std::string>& encryptionKeyNameOpt,
                                             const std::list<std::string>& supply_list,
                                             const std::string& comment) {
   throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented");
@@ -63,7 +63,7 @@ void DummyTapePoolCatalogue::modifyTapePoolComment(const common::dataStructures:
 }
 
 void DummyTapePoolCatalogue::setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin,
-  const std::string &name, const bool encryptionValue) {
+                                                   const std::string &name, const std::string &encryptionKeyName) {
   throw exception::Exception(std::string("In ")+__PRETTY_FUNCTION__+": not implemented");
 }
 
diff --git a/catalogue/dummy/DummyTapePoolCatalogue.hpp b/catalogue/dummy/DummyTapePoolCatalogue.hpp
index d45b165fce7e0bd711761c07e81f09f0c3aa94e3..f1527e3dbae36b2a51f21bda0d2614f2f5af81a8 100644
--- a/catalogue/dummy/DummyTapePoolCatalogue.hpp
+++ b/catalogue/dummy/DummyTapePoolCatalogue.hpp
@@ -30,7 +30,7 @@ public:
                       const std::string& name,
                       const std::string& vo,
                       const uint64_t nbPartialTapes,
-                      const bool encryptionValue,
+                      const std::optional<std::string>& encryptionKeyNameOpt,
                       const std::list<std::string>& supply_list,
                       const std::string& comment) override;
 
@@ -50,7 +50,7 @@ public:
     const std::string &comment) override;
 
   void setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin, const std::string &name,
-    const bool encryptionValue) override;
+                             const std::string &encryptionKeyName) override;
 
   void modifyTapePoolSupply(const common::dataStructures::SecurityIdentity& admin,
                             const std::string& name,
diff --git a/catalogue/interfaces/TapePoolCatalogue.hpp b/catalogue/interfaces/TapePoolCatalogue.hpp
index cb7c1045bc6bfd0128ee1d10860a413d092607be..955bbb7c087fedbd85d9239f8c517b06508036dc 100644
--- a/catalogue/interfaces/TapePoolCatalogue.hpp
+++ b/catalogue/interfaces/TapePoolCatalogue.hpp
@@ -47,7 +47,7 @@ public:
                               const std::string& name,
                               const std::string& vo,
                               const uint64_t nbPartialTapes,
-                              const bool encryptionValue,
+                              const std::optional<std::string>& encryptionKeyNameOpt,
                               const std::list<std::string>& supply_list,
                               const std::string& comment) = 0;
 
@@ -68,7 +68,7 @@ public:
     const std::string &comment) = 0;
 
   virtual void setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin, const std::string &name,
-    const bool encryptionValue) = 0;
+                                     const std::string &encryptionKeyName) = 0;
 
   virtual void modifyTapePoolSupply(const common::dataStructures::SecurityIdentity& admin,
                                     const std::string& name,
diff --git a/catalogue/rdbms/RdbmsTapePoolCatalogue.cpp b/catalogue/rdbms/RdbmsTapePoolCatalogue.cpp
index 402768d0976614c57d29bc383d773767bfbdcb5c..980bdb50c9da9212ecd2fb0c3af7d82070f5c5c5 100644
--- a/catalogue/rdbms/RdbmsTapePoolCatalogue.cpp
+++ b/catalogue/rdbms/RdbmsTapePoolCatalogue.cpp
@@ -46,7 +46,7 @@ void RdbmsTapePoolCatalogue::createTapePool(const common::dataStructures::Securi
                                             const std::string& name,
                                             const std::string& vo,
                                             const uint64_t nbPartialTapes,
-                                            const bool encryptionValue,
+                                            const std::optional<std::string>& encryptionKeyNameOpt,
                                             const std::list<std::string>& supply_list,
                                             const std::string& comment) {
   if(name.empty()) {
@@ -100,6 +100,7 @@ void RdbmsTapePoolCatalogue::createTapePool(const common::dataStructures::Securi
       VIRTUAL_ORGANIZATION_ID,
       NB_PARTIAL_TAPES,
       IS_ENCRYPTED,
+      ENCRYPTION_KEY_NAME,
       SUPPLY,
 
       USER_COMMENT,
@@ -117,6 +118,7 @@ void RdbmsTapePoolCatalogue::createTapePool(const common::dataStructures::Securi
       VIRTUAL_ORGANIZATION_ID,
       :NB_PARTIAL_TAPES,
       :IS_ENCRYPTED,
+      :ENCRYPTION_KEY_NAME,
       :SUPPLY,
 
       :USER_COMMENT,
@@ -139,7 +141,8 @@ void RdbmsTapePoolCatalogue::createTapePool(const common::dataStructures::Securi
   stmt.bindString(":TAPE_POOL_NAME", name);
   stmt.bindString(":VO", vo);
   stmt.bindUint64(":NB_PARTIAL_TAPES", nbPartialTapes);
-  stmt.bindBool(":IS_ENCRYPTED", encryptionValue);
+  stmt.bindBool(":IS_ENCRYPTED", encryptionKeyNameOpt.has_value());
+  stmt.bindString(":ENCRYPTION_KEY_NAME", encryptionKeyNameOpt);
   stmt.bindString(":SUPPLY", optionalSupplyString);
 
   stmt.bindString(":USER_COMMENT", trimmedComment);
@@ -279,6 +282,7 @@ std::list<TapePool> RdbmsTapePoolCatalogue::getTapePools(rdbms::Conn &conn,
       VIRTUAL_ORGANIZATION.VIRTUAL_ORGANIZATION_NAME AS VO,
       TAPE_POOL.NB_PARTIAL_TAPES AS NB_PARTIAL_TAPES,
       TAPE_POOL.IS_ENCRYPTED AS IS_ENCRYPTED,
+      TAPE_POOL.ENCRYPTION_KEY_NAME AS ENCRYPTION_KEY_NAME,
       TAPE_POOL.SUPPLY AS SUPPLY,
 
       COALESCE(COUNT(TAPE.VID), 0) AS NB_TAPES,
@@ -309,7 +313,7 @@ std::list<TapePool> RdbmsTapePoolCatalogue::getTapePools(rdbms::Conn &conn,
       TAPE.MEDIA_TYPE_ID = MEDIA_TYPE.MEDIA_TYPE_ID
   )SQL";
 
-  if (searchCriteria.name || searchCriteria.vo || searchCriteria.encrypted) {
+  if (searchCriteria.name || searchCriteria.vo || searchCriteria.encrypted || searchCriteria.encryptionKeyName) {
     sql += R"SQL(
       WHERE
     )SQL";
@@ -339,6 +343,22 @@ std::list<TapePool> RdbmsTapePoolCatalogue::getTapePools(rdbms::Conn &conn,
     sql += R"SQL(
       TAPE_POOL.IS_ENCRYPTED = :ENCRYPTED
     )SQL";
+    addedAWhereConstraint = true;
+  }
+
+  if (searchCriteria.encryptionKeyName) {
+    if (addedAWhereConstraint) {
+      sql += R"SQL( AND )SQL";
+    }
+    if (searchCriteria.encryptionKeyName.value().empty()) {
+      sql += R"SQL(
+        TAPE_POOL.ENCRYPTION_KEY_NAME IS NULL
+      )SQL";
+    } else {
+      sql += R"SQL(
+        TAPE_POOL.ENCRYPTION_KEY_NAME = :ENCRYPTION_KEY_NAME
+      )SQL";
+    }
   }
 
   sql += R"SQL(
@@ -347,6 +367,7 @@ std::list<TapePool> RdbmsTapePoolCatalogue::getTapePools(rdbms::Conn &conn,
       VIRTUAL_ORGANIZATION.VIRTUAL_ORGANIZATION_NAME,
       TAPE_POOL.NB_PARTIAL_TAPES,
       TAPE_POOL.IS_ENCRYPTED,
+      TAPE_POOL.ENCRYPTION_KEY_NAME,
       TAPE_POOL.SUPPLY,
       TAPE_POOL.USER_COMMENT,
       TAPE_POOL.CREATION_LOG_USER_NAME,
@@ -375,6 +396,10 @@ std::list<TapePool> RdbmsTapePoolCatalogue::getTapePools(rdbms::Conn &conn,
     stmt.bindBool(":ENCRYPTED", searchCriteria.encrypted.value());
   }
 
+  if(searchCriteria.encryptionKeyName && !searchCriteria.encryptionKeyName.value().empty()) {
+    stmt.bindString(":ENCRYPTION_KEY_NAME", searchCriteria.encryptionKeyName.value());
+  }
+
   auto rset = stmt.executeQuery();
   while (rset.next()) {
     TapePool pool;
@@ -382,6 +407,7 @@ std::list<TapePool> RdbmsTapePoolCatalogue::getTapePools(rdbms::Conn &conn,
     pool.vo.name = rset.columnString("VO");
     pool.nbPartialTapes = rset.columnUint64("NB_PARTIAL_TAPES");
     pool.encryption = rset.columnBool("IS_ENCRYPTED");
+    pool.encryptionKeyName = rset.columnOptionalString("ENCRYPTION_KEY_NAME");
     pool.supply = rset.columnOptionalString("SUPPLY");
     pool.nbTapes = rset.columnUint64("NB_TAPES");
     pool.nbEmptyTapes = rset.columnUint64("NB_EMPTY_TAPES");
@@ -426,6 +452,7 @@ std::optional<TapePool> RdbmsTapePoolCatalogue::getTapePool(const std::string &t
       VIRTUAL_ORGANIZATION.VIRTUAL_ORGANIZATION_NAME AS VO,
       TAPE_POOL.NB_PARTIAL_TAPES AS NB_PARTIAL_TAPES,
       TAPE_POOL.IS_ENCRYPTED AS IS_ENCRYPTED,
+      TAPE_POOL.ENCRYPTION_KEY_NAME AS ENCRYPTION_KEY_NAME,
       TAPE_POOL.SUPPLY AS SUPPLY,
 
       COALESCE(COUNT(TAPE.VID), 0) AS NB_TAPES,
@@ -459,6 +486,7 @@ std::optional<TapePool> RdbmsTapePoolCatalogue::getTapePool(const std::string &t
       VIRTUAL_ORGANIZATION.VIRTUAL_ORGANIZATION_NAME,
       TAPE_POOL.NB_PARTIAL_TAPES,
       TAPE_POOL.IS_ENCRYPTED,
+      TAPE_POOL.ENCRYPTION_KEY_NAME,
       TAPE_POOL.SUPPLY,
       TAPE_POOL.USER_COMMENT,
       TAPE_POOL.CREATION_LOG_USER_NAME,
@@ -490,6 +518,7 @@ std::optional<TapePool> RdbmsTapePoolCatalogue::getTapePool(const std::string &t
     pool.vo.name = rset.columnString("VO");
     pool.nbPartialTapes = rset.columnUint64("NB_PARTIAL_TAPES");
     pool.encryption = rset.columnBool("IS_ENCRYPTED");
+    pool.encryptionKeyName = rset.columnOptionalString("ENCRYPTION_KEY_NAME");
     pool.supply = rset.columnOptionalString("SUPPLY");
     pool.nbTapes = rset.columnUint64("NB_TAPES");
     pool.nbEmptyTapes = rset.columnUint64("NB_EMPTY_TAPES");
@@ -627,10 +656,16 @@ void RdbmsTapePoolCatalogue::modifyTapePoolComment(const common::dataStructures:
 }
 
 void RdbmsTapePoolCatalogue::setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin,
-  const std::string &name, const bool encryptionValue) {
+                                                   const std::string &name, const std::string &encryptionKeyName) {
+
   const time_t now = time(nullptr);
+  std::optional<std::string> encryptionKeyNameOpt;
+  if (!encryptionKeyName.empty()) {
+    encryptionKeyNameOpt = encryptionKeyName;
+  }
   const char* const sql = R"SQL(
-    UPDATE TAPE_POOL SET 
+    UPDATE TAPE_POOL SET
+      ENCRYPTION_KEY_NAME = :ENCRYPTION_KEY_NAME,
       IS_ENCRYPTED = :IS_ENCRYPTED,
       LAST_UPDATE_USER_NAME = :LAST_UPDATE_USER_NAME,
       LAST_UPDATE_HOST_NAME = :LAST_UPDATE_HOST_NAME,
@@ -638,9 +673,11 @@ void RdbmsTapePoolCatalogue::setTapePoolEncryption(const common::dataStructures:
     WHERE 
       TAPE_POOL_NAME = :TAPE_POOL_NAME
   )SQL";
+
   auto conn = m_connPool->getConn();
   auto stmt = conn.createStmt(sql);
-  stmt.bindBool(":IS_ENCRYPTED", encryptionValue);
+  stmt.bindString(":ENCRYPTION_KEY_NAME", encryptionKeyNameOpt);
+  stmt.bindBool(":IS_ENCRYPTED", encryptionKeyNameOpt.has_value());
   stmt.bindString(":LAST_UPDATE_USER_NAME", admin.username);
   stmt.bindString(":LAST_UPDATE_HOST_NAME", admin.host);
   stmt.bindUint64(":LAST_UPDATE_TIME", now);
diff --git a/catalogue/rdbms/RdbmsTapePoolCatalogue.hpp b/catalogue/rdbms/RdbmsTapePoolCatalogue.hpp
index 5312753fd5b38a4aca1bdf1fdf681c527d754e97..81bd57441635ff9b564fd96ecd35ce212af27470 100644
--- a/catalogue/rdbms/RdbmsTapePoolCatalogue.hpp
+++ b/catalogue/rdbms/RdbmsTapePoolCatalogue.hpp
@@ -45,7 +45,7 @@ public:
                       const std::string& name,
                       const std::string& vo,
                       const uint64_t nbPartialTapes,
-                      const bool encryptionValue,
+                      const std::optional<std::string>& encryptionKeyNameOpt,
                       const std::list<std::string>& supply_list,
                       const std::string& comment) override;
 
@@ -65,7 +65,7 @@ public:
     const std::string &comment) override;
 
   void setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin, const std::string &name,
-    const bool encryptionValue) override;
+                             const std::string &encryptionKeyName) override;
 
   void modifyTapePoolSupply(const common::dataStructures::SecurityIdentity& admin,
                             const std::string& name,
diff --git a/catalogue/retrywrappers/TapePoolCatalogueRetryWrapper.hpp b/catalogue/retrywrappers/TapePoolCatalogueRetryWrapper.hpp
index 4cb95971a3f5dbdd61d2901aeef04fdef06d40ff..524ac6cf141a87e1e7cf84ec9fc0590866524efa 100644
--- a/catalogue/retrywrappers/TapePoolCatalogueRetryWrapper.hpp
+++ b/catalogue/retrywrappers/TapePoolCatalogueRetryWrapper.hpp
@@ -38,7 +38,7 @@ public:
                       const std::string& name,
                       const std::string& vo,
                       const uint64_t nbPartialTapes,
-                      const bool encryptionValue,
+                      const std::optional<std::string>& encryptionKeyNameOpt,
                       const std::list<std::string>& supply_list,
                       const std::string& comment) override;
 
@@ -58,7 +58,7 @@ public:
     const std::string &comment) override;
 
   void setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin, const std::string &name,
-    const bool encryptionValue) override;
+                             const std::string &encryptionKeyName) override;
 
   void modifyTapePoolSupply(const common::dataStructures::SecurityIdentity& admin,
                             const std::string& name,
diff --git a/catalogue/retrywrappers/TapePoolRetryCatalogueWrapper.cpp b/catalogue/retrywrappers/TapePoolRetryCatalogueWrapper.cpp
index d96f9f56e32514f0b4144d8bb0effcacf707b0b3..5e998838623fdad45cf02939a5b971ec79434b96 100644
--- a/catalogue/retrywrappers/TapePoolRetryCatalogueWrapper.cpp
+++ b/catalogue/retrywrappers/TapePoolRetryCatalogueWrapper.cpp
@@ -33,13 +33,13 @@ void TapePoolCatalogueRetryWrapper::createTapePool(const common::dataStructures:
                                                    const std::string& name,
                                                    const std::string& vo,
                                                    const uint64_t nbPartialTapes,
-                                                   const bool encryptionValue,
+                                                   const std::optional<std::string>& encryptionKeyNameOpt,
                                                    const std::list<std::string>& supply_list,
                                                    const std::string& comment) {
   return retryOnLostConnection(
     m_log,
-    [this, &admin, &name, &vo, &nbPartialTapes, &encryptionValue, &supply_list, &comment] {
-      return m_catalogue->TapePool()->createTapePool(admin, name, vo, nbPartialTapes, encryptionValue, supply_list,
+    [this, &admin, &name, &vo, &nbPartialTapes, &encryptionKeyNameOpt, &supply_list, &comment] {
+      return m_catalogue->TapePool()->createTapePool(admin, name, vo, nbPartialTapes, encryptionKeyNameOpt, supply_list,
                                                      comment);
     },
     m_maxTriesToConnect);
@@ -85,9 +85,9 @@ void TapePoolCatalogueRetryWrapper::modifyTapePoolComment(const common::dataStru
 }
 
 void TapePoolCatalogueRetryWrapper::setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin,
-  const std::string &name, const bool encryptionValue) {
-  return retryOnLostConnection(m_log, [this,&admin,&name,&encryptionValue] {
-    return m_catalogue->TapePool()->setTapePoolEncryption(admin, name, encryptionValue);
+                                                          const std::string &name, const std::string &encryptionKeyName) {
+  return retryOnLostConnection(m_log, [this,&admin,&name,&encryptionKeyName] {
+    return m_catalogue->TapePool()->setTapePoolEncryption(admin, name, encryptionKeyName);
   }, m_maxTriesToConnect);
 }
 
diff --git a/catalogue/tests/modules/ArchiveFileCatalogueTest.cpp b/catalogue/tests/modules/ArchiveFileCatalogueTest.cpp
index c443f2864f85d0bbe13e8e498de4e2047e8a18f2..7ad78e9e3be9238c0c1ae9ee1925f926972442d8 100644
--- a/catalogue/tests/modules/ArchiveFileCatalogueTest.cpp
+++ b/catalogue/tests/modules/ArchiveFileCatalogueTest.cpp
@@ -111,9 +111,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, checkAndGetNextArchiveFileId_no_mount_rule
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   const uint32_t copyNb = 1;
@@ -177,9 +177,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, checkAndGetNextArchiveFileId_after_cached_
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   const uint32_t copyNb = 1;
@@ -255,9 +255,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, checkAndGetNextArchiveFileId_requester_mou
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string archiveRouteComment = "Create archive route";
@@ -325,9 +325,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, checkAndGetNextArchiveFileId_requester_gro
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string archiveRouteComment = "Create archive route";
@@ -395,9 +395,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, checkAndGetNextArchiveFileId_after_cached_
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string archiveRouteComment = "Create archive route";
@@ -491,9 +491,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, checkAndGetNextArchiveFileId_requester_mou
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   const uint32_t copyNb = 1;
@@ -598,9 +598,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, getArchiveFileQueueCriteria_requester_moun
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string archiveRouteComment = "Create archive route";
@@ -661,9 +661,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, getArchiveFileQueueCriteria_requester_grou
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string archiveRouteComment = "Create archive route";
@@ -740,9 +740,9 @@ TEST_P(cta_catalogue_ArchiveFileTest, getArchiveFileQueueCriteria_requester_moun
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string archiveRouteComment = "Create archive route";
@@ -840,7 +840,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, getArchiveFiles_non_existent_vid) {
 TEST_P(cta_catalogue_ArchiveFileTest, updateDiskFileId) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -851,7 +851,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, updateDiskFileId) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
@@ -988,7 +988,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_many_archive_files) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -998,7 +998,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_many_archive_files) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -1015,7 +1015,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_many_archive_files) {
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
 
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(2, pools.size());
@@ -2121,7 +2121,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, DISABLED_concurrent_filesWrittenToTape_man
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -2131,7 +2131,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, DISABLED_concurrent_filesWrittenToTape_man
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2148,7 +2148,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, DISABLED_concurrent_filesWrittenToTape_man
     ASSERT_EQ(0, pool.nbPhysicalFiles);
   }
 
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(2, pools.size());
@@ -2815,7 +2815,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, DISABLED_concurrent_filesWrittenToTape_man
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_1_tape_copy) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -2824,7 +2824,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_1_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
   {
@@ -2932,7 +2932,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_1_tape_c
   const std::string diskInstance = m_diskInstance.name;
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   std::optional<std::string> physicalLibraryName;
 
@@ -2940,7 +2940,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_1_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -3053,7 +3053,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_file_recycle_log_dele
   const std::string diskInstance = m_diskInstance.name;
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   std::optional<std::string> physicalLibraryName;
 
@@ -3061,7 +3061,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_file_recycle_log_dele
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -3138,7 +3138,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_file_recycle_log_dele
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -3147,7 +3147,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
@@ -3349,7 +3349,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies_same_copy_number) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -3358,7 +3358,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
 
@@ -3547,7 +3547,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies_same_copy_number_same_tape) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -3556,7 +3556,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -3721,7 +3721,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies_same_fseq_same_tape) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -3730,7 +3730,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
@@ -3855,7 +3855,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies_different_sizes) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -3864,7 +3864,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
@@ -4017,7 +4017,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies_different_checksum_types) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -4026,7 +4026,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
@@ -4179,7 +4179,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_copies_different_checksum_values) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -4188,7 +4188,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
@@ -4340,7 +4340,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, filesWrittenToTape_1_archive_file_2_tape_c
 TEST_P(cta_catalogue_ArchiveFileTest, deleteArchiveFile) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -4349,7 +4349,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, deleteArchiveFile) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
@@ -4625,7 +4625,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, deleteArchiveFile) {
 TEST_P(cta_catalogue_ArchiveFileTest, deleteArchiveFile_by_archive_file_id_of_another_disk_instance) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -4634,7 +4634,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, deleteArchiveFile_by_archive_file_id_of_an
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
@@ -4929,11 +4929,11 @@ TEST_P(cta_catalogue_ArchiveFileTest, getArchiveFileQueueCriteria_ignore_repack_
   const std::string tapePoolName_repack_1 = "tape_pool_repack_1";
   const std::string tapePoolName_default_2 = "tape_pool_default_2";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_default_1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool for default 1");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_repack_1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool for repack 1");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_default_2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool for default 2");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_default_1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool for default 1");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_repack_1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool for repack 1");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_default_2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool for default 2");
 
   ASSERT_TRUE(m_catalogue->ArchiveRoute()->getArchiveRoutes().empty());
 
@@ -4991,7 +4991,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, getArchiveFileQueueCriteria_ignore_repack_
 TEST_P(cta_catalogue_ArchiveFileTest, getTapesWithMissingTapeFileCopies) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -5000,7 +5000,7 @@ TEST_P(cta_catalogue_ArchiveFileTest, getTapesWithMissingTapeFileCopies) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
   m_catalogue->Tape()->createTape(m_admin, m_tape3);
diff --git a/catalogue/tests/modules/ArchiveRouteCatalogueTest.cpp b/catalogue/tests/modules/ArchiveRouteCatalogueTest.cpp
index b6ff1e11d2041e39e6ed33d8b8873f0775896523..84690c672b914a126ffd30d612da4c64416d015f 100644
--- a/catalogue/tests/modules/ArchiveRouteCatalogueTest.cpp
+++ b/catalogue/tests/modules/ArchiveRouteCatalogueTest.cpp
@@ -54,9 +54,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute) {
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -111,9 +111,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_emptyStringStorageClas
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const std::string storageClassName = "";
   const uint32_t copyNb = 1;
@@ -128,9 +128,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_zeroCopyNb) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 0;
   const std::string comment = "Create archive route";
@@ -156,9 +156,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_emptyStringComment) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "";
@@ -170,11 +170,11 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_non_existent_storage_c
   const std::string storageClassName = "storage_class";
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -200,9 +200,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_same_twice) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -216,9 +216,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_two_routes_same_pool)
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb1 = 1;
   const std::string comment1 = "Create archive route for copy 1";
@@ -235,9 +235,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, deleteArchiveRoute) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -275,9 +275,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, createArchiveRoute_deleteStorageClass) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -310,12 +310,12 @@ TEST_P(cta_catalogue_ArchiveRouteTest, modifyArchiveRouteTapePoolName) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const std::string anotherTapePoolName = "another_tape_pool";
-  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create another tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create another tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -365,12 +365,12 @@ TEST_P(cta_catalogue_ArchiveRouteTest, modifyArchiveRouteTapePoolName_nonExisten
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const std::string anotherTapePoolName = "another_tape_pool";
-  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create another tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create another tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -404,9 +404,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, modifyArchiveRouteTapePoolName_nonExisten
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   ASSERT_THROW(m_catalogue->ArchiveRoute()->modifyArchiveRouteTapePoolName(m_admin, m_storageClassSingleCopy.name, copyNb, cta::common::dataStructures::ArchiveRouteType::DEFAULT, m_tape1.tapePoolName), cta::catalogue::UserSpecifiedANonExistentArchiveRoute);
@@ -418,9 +418,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, modifyArchiveRouteComment) {
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Create archive route";
@@ -471,9 +471,9 @@ TEST_P(cta_catalogue_ArchiveRouteTest, modifyArchiveRouteComment_nonExistentArch
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t copyNb = 1;
   const std::string comment = "Comment";
diff --git a/catalogue/tests/modules/FileRecycleLogCatalogueTest.cpp b/catalogue/tests/modules/FileRecycleLogCatalogueTest.cpp
index 9af572802f8b9a79abae9d0b856d0c8fcd89a76f..611a22ae8d1dff5da92d4ece2332243bfba6b0fc 100644
--- a/catalogue/tests/modules/FileRecycleLogCatalogueTest.cpp
+++ b/catalogue/tests/modules/FileRecycleLogCatalogueTest.cpp
@@ -71,7 +71,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, reclaimTapeRemovesFilesFromRecycleLog)
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   std::optional<std::string> physicalLibraryName;
@@ -81,12 +81,12 @@ TEST_P(cta_catalogue_FileRecycleLogTest, reclaimTapeRemovesFilesFromRecycleLog)
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
   const std::string tapeDrive = "tape_drive";
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   auto tape1 = m_tape1;
@@ -190,7 +190,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, filesArePutInTheFileRecycleLogInsteadOf
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -201,9 +201,9 @@ TEST_P(cta_catalogue_FileRecycleLogTest, filesArePutInTheFileRecycleLogInsteadOf
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -423,7 +423,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, sameFileWrittenToSameTapePutThePrevious
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -434,9 +434,9 @@ TEST_P(cta_catalogue_FileRecycleLogTest, sameFileWrittenToSameTapePutThePrevious
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -502,7 +502,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreTapeFileCopy) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -514,9 +514,9 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreTapeFileCopy) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
@@ -656,7 +656,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreRewrittenTapeFileCopyFails) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -668,9 +668,9 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreRewrittenTapeFileCopyFails) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
@@ -833,7 +833,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreTapeFileCopyDeletedTwice) {
   const std::string tapePoolNameA = "tape_pool_name_A";
   const std::string tapePoolNameB = "tape_pool_name_B";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -846,9 +846,9 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreTapeFileCopyDeletedTwice) {
                                                       "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolNameA, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolNameA, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
                                           "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolNameB, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolNameB, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
                                           "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
@@ -1055,7 +1055,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreVariousDeletedTapeFileCopies) {
   const std::string tapePoolName2 = "tape_pool_name_2";
   const std::string tapePoolName3 = "tape_pool_name_3";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -1067,11 +1067,11 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreVariousDeletedTapeFileCopies) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName3, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName3, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassTripleCopy);
 
@@ -1246,7 +1246,7 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreArchiveFileAndCopy) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -1257,8 +1257,8 @@ TEST_P(cta_catalogue_FileRecycleLogTest, RestoreArchiveFileAndCopy) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
   auto tape1 = m_tape1;
diff --git a/catalogue/tests/modules/LogicalLibraryCatalogueTest.cpp b/catalogue/tests/modules/LogicalLibraryCatalogueTest.cpp
index 08cfbef77731f696e54e19868e987316c906f598..696f24bddde492488af98c3b376545942128315e 100644
--- a/catalogue/tests/modules/LogicalLibraryCatalogueTest.cpp
+++ b/catalogue/tests/modules/LogicalLibraryCatalogueTest.cpp
@@ -289,7 +289,7 @@ TEST_P(cta_catalogue_LogicalLibraryTest, setLogicalLibraryDisabled_false) {
 TEST_P(cta_catalogue_LogicalLibraryTest, deleteLogicalLibrary) {
   const bool libNotToDeleteIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string libNotToDeleteComment = "Create logical library to NOT be deleted";
   std::optional<std::string> physicalLibraryName;
@@ -313,7 +313,7 @@ TEST_P(cta_catalogue_LogicalLibraryTest, deleteLogicalLibrary) {
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -425,7 +425,7 @@ TEST_P(cta_catalogue_LogicalLibraryTest, deleteLogicalLibrary_non_empty) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -434,7 +434,7 @@ TEST_P(cta_catalogue_LogicalLibraryTest, deleteLogicalLibrary_non_empty) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -816,7 +816,7 @@ TEST_P(cta_catalogue_LogicalLibraryTest, createTape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -825,7 +825,7 @@ TEST_P(cta_catalogue_LogicalLibraryTest, createTape) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
diff --git a/catalogue/tests/modules/MediaTypeCatalogueTest.cpp b/catalogue/tests/modules/MediaTypeCatalogueTest.cpp
index 9c4f91b63486c4f723e1f85e9d723432c3520d5a..45db3401dee2775154293521739f47260c420ac3 100644
--- a/catalogue/tests/modules/MediaTypeCatalogueTest.cpp
+++ b/catalogue/tests/modules/MediaTypeCatalogueTest.cpp
@@ -166,7 +166,7 @@ TEST_P(cta_catalogue_MediaTypeTest, deleteMediaType_usedByTapes) {
   cta::log::LogContext dummyLc(m_dummyLog);
   const bool logicalLibraryIsDisabled = false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   std::optional<std::string> physicalLibraryName;
 
@@ -175,7 +175,7 @@ TEST_P(cta_catalogue_MediaTypeTest, deleteMediaType_usedByTapes) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -760,7 +760,7 @@ TEST_P(cta_catalogue_MediaTypeTest, getMediaTypeByVid_nonExistentTape) {
 TEST_P(cta_catalogue_MediaTypeTest, getMediaTypeByVid) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   std::optional<std::string> physicalLibraryName;
 
@@ -770,7 +770,7 @@ TEST_P(cta_catalogue_MediaTypeTest, getMediaTypeByVid) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
diff --git a/catalogue/tests/modules/TapeCatalogueTest.cpp b/catalogue/tests/modules/TapeCatalogueTest.cpp
index 66a60fd03931319bc62a3df5b6244461490b2bbb..d5e44f8a4c6340810e3198854ceb0162be7d691e 100644
--- a/catalogue/tests/modules/TapeCatalogueTest.cpp
+++ b/catalogue/tests/modules/TapeCatalogueTest.cpp
@@ -90,13 +90,13 @@ TEST_P(cta_catalogue_TapeTest, createTape_1_tape_with_write_log_1_tape_without)
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName,
     "Create logical library");
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   {
@@ -261,7 +261,7 @@ TEST_P(cta_catalogue_TapeTest, deleteTape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -269,7 +269,7 @@ TEST_P(cta_catalogue_TapeTest, deleteTape) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -315,14 +315,14 @@ TEST_P(cta_catalogue_TapeTest, writeToTapeAndCheckMasterBytesAndFiles) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName,
     "Create logical library");
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -443,14 +443,14 @@ TEST_P(cta_catalogue_TapeTest, deleteNonEmptyTape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName,
     "Create logical library");
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -577,7 +577,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeMediaType) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -592,7 +592,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeMediaType) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -662,7 +662,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeVendor) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -671,7 +671,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeVendor) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -740,7 +740,7 @@ TEST_P(cta_catalogue_TapeTest, modifyPurchaseOrder) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -749,7 +749,7 @@ TEST_P(cta_catalogue_TapeTest, modifyPurchaseOrder) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -773,7 +773,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesSearchCriteriaByEmptyPurchaseOrder) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -782,7 +782,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesSearchCriteriaByEmptyPurchaseOrder) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -806,7 +806,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesSearchCriteriaByPurchaseOrder) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -815,7 +815,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesSearchCriteriaByPurchaseOrder) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -839,7 +839,7 @@ TEST_P(cta_catalogue_TapeTest, modifyToEmptyPurchaseOrder) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -848,7 +848,7 @@ TEST_P(cta_catalogue_TapeTest, modifyToEmptyPurchaseOrder) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -873,7 +873,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeLogicalLibraryName) {
   std::optional<std::string> physicalLibraryName;
   const std::string anotherLogicalLibraryName = "another_logical_library_name";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -884,7 +884,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeLogicalLibraryName) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -962,7 +962,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeTapePoolName) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string anotherTapePoolName = "another_tape_pool_name";
 
@@ -972,9 +972,9 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeTapePoolName) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create another tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1041,14 +1041,14 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeTapePoolName_nonExistentTape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName,
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   ASSERT_THROW(m_catalogue->Tape()->modifyTapeTapePoolName(m_admin, m_tape1.vid, m_tape1.tapePoolName),
@@ -1059,7 +1059,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeEncryptionKeyName) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1068,7 +1068,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeEncryptionKeyName) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1137,7 +1137,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeEncryptionKeyName_emptyStringEncryption
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1146,7 +1146,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeEncryptionKeyName_emptyStringEncryption
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1215,7 +1215,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeVerificationStatus) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1224,7 +1224,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeVerificationStatus) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1319,7 +1319,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState_nonExistentState) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1328,7 +1328,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState_nonExistentState) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1342,14 +1342,14 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState_nonExistentPrevState) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName,
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   cta::common::dataStructures::Tape::State state = cta::common::dataStructures::Tape::State::ACTIVE;
@@ -1362,14 +1362,14 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState_wrongPrevState) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName,
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   cta::common::dataStructures::Tape::State prevState = cta::common::dataStructures::Tape::State::ACTIVE;
@@ -1386,7 +1386,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState_noReasonWhenNotActive) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1395,7 +1395,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState_noReasonWhenNotActive) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1414,7 +1414,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1423,7 +1423,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeState) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1475,7 +1475,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeStateResetReasonWhenBackToActiveState)
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1484,7 +1484,7 @@ TEST_P(cta_catalogue_TapeTest, modifyTapeStateResetReasonWhenBackToActiveState)
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1513,7 +1513,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesSearchCriteriaByState) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1522,7 +1522,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesSearchCriteriaByState) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1573,7 +1573,7 @@ TEST_P(cta_catalogue_TapeTest, tapeLabelled) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1582,7 +1582,7 @@ TEST_P(cta_catalogue_TapeTest, tapeLabelled) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1657,7 +1657,7 @@ TEST_P(cta_catalogue_TapeTest, tapeMountedForArchive) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1666,7 +1666,7 @@ TEST_P(cta_catalogue_TapeTest, tapeMountedForArchive) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1778,7 +1778,7 @@ TEST_P(cta_catalogue_TapeTest, tapeMountedForRetrieve) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1787,7 +1787,7 @@ TEST_P(cta_catalogue_TapeTest, tapeMountedForRetrieve) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1899,7 +1899,7 @@ TEST_P(cta_catalogue_TapeTest, setTapeFull) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1908,7 +1908,7 @@ TEST_P(cta_catalogue_TapeTest, setTapeFull) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -1979,7 +1979,7 @@ TEST_P(cta_catalogue_TapeTest, setTapeDirty) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1988,7 +1988,7 @@ TEST_P(cta_catalogue_TapeTest, setTapeDirty) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -2061,7 +2061,7 @@ TEST_P(cta_catalogue_TapeTest, noSpaceLeftOnTape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2070,7 +2070,7 @@ TEST_P(cta_catalogue_TapeTest, noSpaceLeftOnTape) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -2141,7 +2141,7 @@ TEST_P(cta_catalogue_TapeTest, setTapeIsFromCastorInUnitTests) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2150,7 +2150,7 @@ TEST_P(cta_catalogue_TapeTest, setTapeIsFromCastorInUnitTests) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -2250,7 +2250,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWriting) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2258,7 +2258,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWriting) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -2284,7 +2284,7 @@ TEST_P(cta_catalogue_TapeTest, getTapeLabelFormat) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2292,7 +2292,7 @@ TEST_P(cta_catalogue_TapeTest, getTapeLabelFormat) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -2311,7 +2311,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWritingOrderedByDataInBytesDesc) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2319,7 +2319,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWritingOrderedByDataInBytesDesc) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -2376,7 +2376,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWriting_disabled_tape) {
   const bool logicalLibraryIsDisabled = false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2384,7 +2384,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWriting_disabled_tape) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   auto tape = m_tape1;
@@ -2403,7 +2403,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWriting_full_tape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   auto tape1 = m_tape1;
@@ -2415,7 +2415,7 @@ TEST_P(cta_catalogue_TapeTest, getTapesForWriting_full_tape) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, tape1);
@@ -2431,7 +2431,7 @@ TEST_P(cta_catalogue_TapeTest, DISABLED_getTapesForWriting_no_labelled_tapes) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2439,7 +2439,7 @@ TEST_P(cta_catalogue_TapeTest, DISABLED_getTapesForWriting_no_labelled_tapes) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -2454,7 +2454,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTapeActiveState) {
   std::optional<std::string> physicalLibraryName;
   const std::string tapePoolName1 = "tape_pool_name_1";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
 
@@ -2465,7 +2465,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTapeActiveState) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -2486,7 +2486,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTapeDisabledState) {
   std::optional<std::string> physicalLibraryName;
   const std::string tapePoolName1 = "tape_pool_name_1";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
 
@@ -2497,7 +2497,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTapeDisabledState) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -2518,7 +2518,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTapeNotAllowedStates) {
   std::optional<std::string> physicalLibraryName;
   const std::string tapePoolName1 = "tape_pool_name_1";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
 
@@ -2529,7 +2529,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTapeNotAllowedStates) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -2580,14 +2580,14 @@ TEST_P(cta_catalogue_TapeTest, getTapes_non_existent_tape_pool) {
   const bool logicalLibraryIsDisabled = false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
   {
@@ -2608,14 +2608,14 @@ TEST_P(cta_catalogue_TapeTest, createTape_emptyStringVid) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2638,12 +2638,12 @@ TEST_P(cta_catalogue_TapeTest, createTape_emptyStringVid) {
 
 TEST_P(cta_catalogue_TapeTest, createTape_emptyStringMediaType) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2664,14 +2664,14 @@ TEST_P(cta_catalogue_TapeTest, createTape_emptyStringMediaType) {
 
 TEST_P(cta_catalogue_TapeTest, createTape_emptyStringVendor) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2692,14 +2692,14 @@ TEST_P(cta_catalogue_TapeTest, createTape_emptyStringVendor) {
 
 TEST_P(cta_catalogue_TapeTest, createTape_emptyStringLogicalLibraryName) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2731,13 +2731,13 @@ TEST_P(cta_catalogue_TapeTest, createTape_emptyStringTapePoolName) {
 
 TEST_P(cta_catalogue_TapeTest, createTape_non_existent_logical_library) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   ASSERT_THROW(m_catalogue->Tape()->createTape(m_admin, m_tape1), cta::exception::UserError);
 }
 
@@ -2753,7 +2753,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_9_exabytes_capacity) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2761,7 +2761,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_9_exabytes_capacity) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2826,7 +2826,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_same_twice) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2834,7 +2834,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_same_twice) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -2883,7 +2883,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_StateDoesNotExist) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2891,7 +2891,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_StateDoesNotExist) {
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   auto tape = m_tape1;
   tape.state = (cta::common::dataStructures::Tape::State)42;
@@ -2902,7 +2902,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_StateNotActiveWithoutReasonShouldThrow
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -2910,7 +2910,7 @@ TEST_P(cta_catalogue_TapeTest, createTape_StateNotActiveWithoutReasonShouldThrow
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   auto tape1 = m_tape1;
   tape1.state = cta::common::dataStructures::Tape::DISABLED;
@@ -2938,14 +2938,14 @@ TEST_P(cta_catalogue_TapeTest, createTape_many_tapes) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
     ASSERT_EQ(1, pools.size());
@@ -3266,14 +3266,14 @@ TEST_P(cta_catalogue_TapeTest, getTapesByVid_1_tape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t nbTapes = 1;
   std::set<std::string, std::less<>> allVids;
@@ -3322,14 +3322,14 @@ TEST_P(cta_catalogue_TapeTest, getTapesByVid_350_tapes) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t nbTapes = 310;
   std::set<std::string, std::less<>> allVids;
@@ -3384,14 +3384,14 @@ TEST_P(cta_catalogue_TapeTest, getVidToLogicalLibrary_1_tape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t nbTapes = 1;
   std::set<std::string, std::less<>> allVids;
@@ -3427,14 +3427,14 @@ TEST_P(cta_catalogue_TapeTest, getVidToLogicalLibrary_310_tapes) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   const uint32_t nbTapes = 310;
   std::set<std::string, std::less<>> allVids;
@@ -3470,14 +3470,14 @@ TEST_P(cta_catalogue_TapeTest, getNbFilesOnTape_no_tape_files) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -3521,14 +3521,14 @@ TEST_P(cta_catalogue_TapeTest, getNbFilesOnTape_one_tape_file) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -3623,14 +3623,14 @@ TEST_P(cta_catalogue_TapeTest, checkTapeForLabel_no_tape_files) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -3674,14 +3674,14 @@ TEST_P(cta_catalogue_TapeTest, checkTapeForLabel_one_tape_file) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -3777,14 +3777,14 @@ TEST_P(cta_catalogue_TapeTest, checkTapeForLabel_one_tape_file_reclaimed_tape) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -3900,14 +3900,14 @@ TEST_P(cta_catalogue_TapeTest, reclaimTape_full_lastFSeq_0_no_tape_files) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -3981,14 +3981,14 @@ TEST_P(cta_catalogue_TapeTest, reclaimTape_not_full_lastFSeq_0_no_tape_files) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
 
@@ -4033,14 +4033,14 @@ TEST_P(cta_catalogue_TapeTest, reclaimTape_full_lastFSeq_1_no_tape_files) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -4237,14 +4237,14 @@ TEST_P(cta_catalogue_TapeTest, reclaimTape_full_lastFSeq_1_one_tape_file) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -4376,7 +4376,7 @@ TEST_P(cta_catalogue_TapeTest, reclaimTape_full_lastFSeq_1_one_tape_file) {
 TEST_P(cta_catalogue_TapeTest, get_tape_with_related_physical_library) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const auto physicalLibrary1 = CatalogueTestUtils::getPhysicalLibrary1();
 
@@ -4386,7 +4386,7 @@ TEST_P(cta_catalogue_TapeTest, get_tape_with_related_physical_library) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -4426,7 +4426,7 @@ TEST_P(cta_catalogue_TapeTest, get_tape_with_related_physical_library) {
 TEST_P(cta_catalogue_TapeTest, get_tape_with_physical_library_search_criteria) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const auto physicalLibrary1 = CatalogueTestUtils::getPhysicalLibrary1();
 
@@ -4436,7 +4436,7 @@ TEST_P(cta_catalogue_TapeTest, get_tape_with_physical_library_search_criteria) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -4478,7 +4478,7 @@ TEST_P(cta_catalogue_TapeTest, get_tape_with_physical_library_search_criteria) {
 TEST_P(cta_catalogue_TapeTest, get_no_tape_with_non_existent_physical_library_search_criteria) {
   const bool logicalLibraryIsDisabled= false;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   std::optional<std::string> physicalLibraryName;
 
@@ -4487,7 +4487,7 @@ TEST_P(cta_catalogue_TapeTest, get_no_tape_with_non_existent_physical_library_se
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
diff --git a/catalogue/tests/modules/TapeFileCatalogueTest.cpp b/catalogue/tests/modules/TapeFileCatalogueTest.cpp
index 4201697f8d3bbb9a12aea2648f8dc50e8736968f..e38267333bf5774ad33a0d7e648b73280b44fdd9 100644
--- a/catalogue/tests/modules/TapeFileCatalogueTest.cpp
+++ b/catalogue/tests/modules/TapeFileCatalogueTest.cpp
@@ -65,7 +65,7 @@ TEST_P(cta_catalogue_TapeFileTest, moveFilesToRecycleLog) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -75,9 +75,9 @@ TEST_P(cta_catalogue_TapeFileTest, moveFilesToRecycleLog) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassSingleCopy);
 
@@ -196,7 +196,7 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyUsingArchiveID) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -206,8 +206,8 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyUsingArchiveID) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
   auto tape1 = m_tape1;
@@ -338,7 +338,7 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyWithDisallowedTapeStates) {
   const std::string tapePoolName2 = "tape_pool_name_2";
   const std::string tapePoolName3 = "tape_pool_name_3";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -348,9 +348,9 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyWithDisallowedTapeStates) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName3, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName3, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
   auto tape1 = m_tape1;
@@ -539,7 +539,7 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyDoesNotExist) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -549,8 +549,8 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyDoesNotExist) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
   auto tape1 = m_tape1;
@@ -580,7 +580,7 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyUsingFXID) {
   const std::string tapePoolName1 = "tape_pool_name_1";
   const std::string tapePoolName2 = "tape_pool_name_2";
   const uint64_t nbPartialTapes = 1;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string diskInstance = m_diskInstance.name;
   const std::string tapeDrive = "tape_drive";
@@ -590,8 +590,8 @@ TEST_P(cta_catalogue_TapeFileTest, DeleteTapeFileCopyUsingFXID) {
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName1, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName2, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
   m_catalogue->StorageClass()->createStorageClass(m_admin, m_storageClassDualCopy);
 
   auto tape1 = m_tape1;
@@ -725,7 +725,7 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId_repac
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   std::string repackingReason = "repackingReason";
@@ -735,7 +735,7 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId_repac
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
@@ -998,7 +998,7 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -1006,7 +1006,7 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId) {
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, diskInstanceName1, "comment");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, diskInstanceName2, "comment");
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
@@ -1218,7 +1218,7 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId_disab
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   std::string disabledReason = "disabledReason";
@@ -1227,7 +1227,7 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId_disab
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
@@ -1492,14 +1492,14 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId_retur
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
@@ -1610,14 +1610,14 @@ TEST_P(cta_catalogue_TapeFileTest, prepareToRetrieveFileUsingArchiveFileId_Activ
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
   m_catalogue->LogicalLibrary()->createLogicalLibrary(m_admin, m_tape1.logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   m_catalogue->Tape()->createTape(m_admin, m_tape1);
   m_catalogue->Tape()->createTape(m_admin, m_tape2);
diff --git a/catalogue/tests/modules/TapePoolCatalogueTest.cpp b/catalogue/tests/modules/TapePoolCatalogueTest.cpp
index b0ec5ac97cf1e0f1a71ce6157ea32746c33b8880..2b6500d0624ddb2b2f01b21d5626b93d657d323d 100644
--- a/catalogue/tests/modules/TapePoolCatalogueTest.cpp
+++ b/catalogue/tests/modules/TapePoolCatalogueTest.cpp
@@ -76,12 +76,12 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool) {
   ASSERT_FALSE(m_catalogue->TapePool()->tapePoolExists(tapePoolName));
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
 
   ASSERT_TRUE(m_catalogue->TapePool()->tapePoolExists(tapePoolName));
@@ -95,7 +95,8 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -118,7 +119,8 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool) {
     ASSERT_EQ(tapePoolName, pool->name);
     ASSERT_EQ(m_vo.name, pool->vo.name);
     ASSERT_EQ(nbPartialTapes, pool->nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool->encryption);
+    ASSERT_EQ(true, pool->encryption);
+    ASSERT_EQ(encryptionKeyName, pool->encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool->supply);
     ASSERT_EQ(0, pool->nbTapes);
     ASSERT_EQ(0, pool->capacityBytes);
@@ -141,12 +143,12 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_null_supply) {
   ASSERT_FALSE(m_catalogue->TapePool()->tapePoolExists(tapePoolName));
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
 
   ASSERT_TRUE(m_catalogue->TapePool()->tapePoolExists(tapePoolName));
@@ -159,7 +161,8 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_null_supply) {
   ASSERT_EQ(tapePoolName, pool.name);
   ASSERT_EQ(m_vo.name, pool.vo.name);
   ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-  ASSERT_EQ(isEncrypted, pool.encryption);
+  ASSERT_EQ(true, pool.encryption);
+  ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
   ASSERT_EQ(std::nullopt, pool.supply);
   ASSERT_EQ(0, pool.nbTapes);
   ASSERT_EQ(0, pool.capacityBytes);
@@ -179,32 +182,32 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_null_supply) {
 TEST_P(cta_catalogue_TapePoolTest, createTapePool_same_twice) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes,
-    isEncrypted, supply, comment), cta::exception::UserError);
+    encryptionKeyName, supply, comment), cta::exception::UserError);
 }
 
 TEST_P(cta_catalogue_TapePoolTest, createTapePool_vo_does_not_exist) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes,
-    isEncrypted, supply, comment), cta::exception::UserError);
+    encryptionKeyName, supply, comment), cta::exception::UserError);
 }
 
 TEST_P(cta_catalogue_TapePoolTest, createTapePool_tapes_of_mixed_state) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -213,7 +216,7 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_tapes_of_mixed_state) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -341,14 +344,14 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_tapes_of_mixed_state) {
 
 TEST_P(cta_catalogue_TapePoolTest, deleteTapePool) {
   const uint64_t tapePoolNbPartialTapes = 2;
-  const bool tapePoolIsEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::string tapePoolComment = "Create tape pool";
   {
     const std::list<std::string> supply;
     m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
     m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
     m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, tapePoolNbPartialTapes,
-      tapePoolIsEncrypted, supply, tapePoolComment);
+      encryptionKeyName, supply, tapePoolComment);
   }
 
   {
@@ -360,7 +363,8 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool) {
     ASSERT_EQ(m_tape1.tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(tapePoolNbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(tapePoolIsEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -381,13 +385,13 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool) {
   const std::string anotherTapePoolName = "another_tape_pool";
   const uint64_t anotherNbPartialTapes = 4;
   const std::string anotherTapePoolComment = "Create another tape pool";
-  const bool anotherTapePoolIsEncrypted = false;
+  const std::optional<std::string> encryptionKeyNull = std::nullopt;
   {
     m_catalogue->StorageClass()->createStorageClass(m_admin, m_anotherStorageClass);
     const std::list<std::string> supply;
     m_catalogue->VO()->createVirtualOrganization(m_admin, m_anotherVo);
     m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePoolName, m_anotherVo.name, anotherNbPartialTapes,
-      anotherTapePoolIsEncrypted, supply, anotherTapePoolComment);
+      encryptionKeyNull, supply, anotherTapePoolComment);
     const uint32_t copyNb = 1;
     const std::string comment = "Create a separate archive route";
     m_catalogue->ArchiveRoute()->createArchiveRoute(m_admin, m_anotherStorageClass.name, copyNb, cta::common::dataStructures::ArchiveRouteType::DEFAULT, anotherTapePoolName, comment);
@@ -406,7 +410,8 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool) {
       ASSERT_EQ(m_tape1.tapePoolName, pool.name);
       ASSERT_EQ(m_vo.name, pool.vo.name);
       ASSERT_EQ(tapePoolNbPartialTapes, pool.nbPartialTapes);
-      ASSERT_EQ(tapePoolIsEncrypted, pool.encryption);
+      ASSERT_EQ(true, pool.encryption);
+      ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
       ASSERT_EQ(0, pool.nbTapes);
       ASSERT_EQ(0, pool.capacityBytes);
       ASSERT_EQ(0, pool.dataBytes);
@@ -429,7 +434,8 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool) {
       ASSERT_EQ(anotherTapePoolName, pool.name);
       ASSERT_EQ(m_anotherVo.name, pool.vo.name);
       ASSERT_EQ(anotherNbPartialTapes, pool.nbPartialTapes);
-      ASSERT_EQ(anotherTapePoolIsEncrypted, pool.encryption);
+      ASSERT_EQ(false, pool.encryption);
+      ASSERT_EQ(encryptionKeyNull, pool.encryptionKeyName);
       ASSERT_EQ(0, pool.nbTapes);
       ASSERT_EQ(0, pool.capacityBytes);
       ASSERT_EQ(0, pool.dataBytes);
@@ -454,7 +460,7 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool_notEmpty) {
   const bool logicalLibraryIsDisabled= false;
   std::optional<std::string> physicalLibraryName;
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   m_catalogue->MediaType()->createMediaType(m_admin, m_mediaType);
@@ -463,7 +469,7 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool_notEmpty) {
     "Create logical library");
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -532,22 +538,22 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool_notEmpty) {
 TEST_P(cta_catalogue_TapePoolTest, createTapePool_emptyStringTapePoolName) {
   const std::string tapePoolName = "";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName, m_vo.name, nbPartialTapes, isEncrypted,
+  ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName,
     supply, comment), cta::catalogue::UserSpecifiedAnEmptyStringTapePoolName);
 }
 
 TEST_P(cta_catalogue_TapePoolTest, createTapePool_emptyStringVO) {
   const std::string vo = "";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
-  ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, "", nbPartialTapes, isEncrypted,
+  ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, "", nbPartialTapes, encryptionKeyName,
     supply, comment), cta::catalogue::UserSpecifiedAnEmptyStringVo);
 }
 
@@ -557,13 +563,13 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_emptyStringComment) {
   ASSERT_FALSE(m_catalogue->TapePool()->tapePoolExists(tapePoolName));
 
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
   ASSERT_THROW(m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes,
-    isEncrypted, supply, comment), cta::catalogue::UserSpecifiedAnEmptyStringComment);
+    encryptionKeyName, supply, comment), cta::catalogue::UserSpecifiedAnEmptyStringComment);
 }
 
 TEST_P(cta_catalogue_TapePoolTest, deleteTapePool_non_existent) {
@@ -577,9 +583,9 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool_used_in_an_archive_route) {
 
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   const uint32_t copyNb = 1;
@@ -632,13 +638,13 @@ TEST_P(cta_catalogue_TapePoolTest, deleteTapePool_used_in_an_archive_route) {
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
 
   {
@@ -650,7 +656,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -679,7 +686,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(modifiedVo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -702,13 +710,13 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_emptyStringTapePool) {
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_emptyStringVo) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -719,7 +727,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_emptyStringVo) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -742,12 +751,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_emptyStringVo) {
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_VoDoesNotExist) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -758,7 +767,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_VoDoesNotExist) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -781,12 +791,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolVo_VoDoesNotExist) {
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolNbPartialTapes) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -797,7 +807,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolNbPartialTapes) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -824,7 +835,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolNbPartialTapes) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(modifiedNbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -854,12 +866,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolNbPartialTapes_nonExistentTapeP
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -870,7 +882,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -897,7 +910,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -920,12 +934,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment_emptyStringTapePoolName
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment_emptyStringComment) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -936,7 +950,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment_emptyStringComment) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -966,12 +981,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolComment_nonExistentTapePool) {
 TEST_P(cta_catalogue_TapePoolTest, setTapePoolEncryption) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -982,7 +997,8 @@ TEST_P(cta_catalogue_TapePoolTest, setTapePoolEncryption) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -997,8 +1013,7 @@ TEST_P(cta_catalogue_TapePoolTest, setTapePoolEncryption) {
     ASSERT_EQ(creationLog, lastModificationLog);
   }
 
-  const bool modifiedIsEncrypted = !isEncrypted;
-  m_catalogue->TapePool()->setTapePoolEncryption(m_admin, tapePoolName, modifiedIsEncrypted);
+  m_catalogue->TapePool()->setTapePoolEncryption(m_admin, tapePoolName, "");
 
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -1009,7 +1024,8 @@ TEST_P(cta_catalogue_TapePoolTest, setTapePoolEncryption) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(modifiedIsEncrypted, pool.encryption);
+    ASSERT_EQ(false, pool.encryption);
+    ASSERT_EQ(std::nullopt, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -1024,8 +1040,7 @@ TEST_P(cta_catalogue_TapePoolTest, setTapePoolEncryption) {
 
 TEST_P(cta_catalogue_TapePoolTest, setTapePoolEncryption_nonExistentTapePool) {
   const std::string tapePoolName = "tape_pool";
-  const bool isEncrypted = false;
-  ASSERT_THROW(m_catalogue->TapePool()->setTapePoolEncryption(m_admin, tapePoolName, isEncrypted),
+  ASSERT_THROW(m_catalogue->TapePool()->setTapePoolEncryption(m_admin, tapePoolName, ""),
     cta::exception::UserError);
 }
 
@@ -1033,14 +1048,14 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolSupply) {
   const std::string tapePoolName_1 = "tape_pool_1";
   const std::string tapePoolName_2 = "tape_pool_2";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;  // empty string is acceptable value
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_1, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_1, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
-  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_2, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName_2, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
                                           comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -1098,12 +1113,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolSupply_emptyStringTapePoolName)
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolSupply_emptyStringSupply) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -1114,7 +1129,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolSupply_emptyStringSupply) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -1142,7 +1158,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolSupply_emptyStringSupply) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -1169,8 +1186,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterName) {
   const uint64_t nbFirstPoolPartialTapes = 2;
   const uint64_t nbSecondPoolPartialTapes = 3;
 
-  const bool firstPoolIsEncrypted = true;
-  const bool secondPoolIsEncrypted = false;
+  const std::optional<std::string> firstPoolEncryptionKeyName = "encryption_key_name";
+  const std::optional<std::string> secondPoolEncryptionKeyNull = std::nullopt;
 
   const std::list<std::string> firstPoolSupply;
   const std::list<std::string> secondPoolSupply;
@@ -1183,9 +1200,9 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterName) {
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_anotherVo);
 
   m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName, m_vo.name, nbFirstPoolPartialTapes,
-    firstPoolIsEncrypted, firstPoolSupply, firstPoolComment);
+    firstPoolEncryptionKeyName, firstPoolSupply, firstPoolComment);
   m_catalogue->TapePool()->createTapePool(m_admin, secondTapePoolName, m_anotherVo.name, nbSecondPoolPartialTapes,
-    secondPoolIsEncrypted, secondPoolSupply, secondPoolComment);
+    secondPoolEncryptionKeyNull, secondPoolSupply, secondPoolComment);
 
 
   {
@@ -1198,7 +1215,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterName) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbFirstPoolPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(firstPoolIsEncrypted, pool.encryption);
+    ASSERT_EQ(firstPoolEncryptionKeyName.has_value(), pool.encryption);
+    ASSERT_EQ(firstPoolEncryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -1221,8 +1239,9 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterName) {
     ASSERT_EQ(secondTapePoolName, pool.name);
     ASSERT_EQ(m_anotherVo.name, pool.vo.name);
     ASSERT_EQ(nbSecondPoolPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(secondPoolIsEncrypted, pool.encryption);
-    ASSERT_FALSE((bool) pool.supply);
+    ASSERT_EQ(secondPoolEncryptionKeyNull.has_value(), pool.encryption);
+    ASSERT_EQ(secondPoolEncryptionKeyNull, pool.encryptionKeyName);
+    ASSERT_FALSE(pool.supply.has_value());
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -1256,8 +1275,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterVO) {
   const uint64_t nbFirstPoolPartialTapes = 2;
   const uint64_t nbSecondPoolPartialTapes = 3;
 
-  const bool firstPoolIsEncrypted = true;
-  const bool secondPoolIsEncrypted = false;
+  const std::optional<std::string> firstPoolEncryptionKeyName = "encryption_key_name";
+  const std::optional<std::string> secondPoolEncryptionKeyNull = std::nullopt;
 
   const std::list<std::string> firstPoolSupply;
   const std::list<std::string> secondPoolSupply;
@@ -1270,9 +1289,9 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterVO) {
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_anotherVo);
 
   m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName, m_vo.name, nbFirstPoolPartialTapes,
-    firstPoolIsEncrypted, firstPoolSupply, firstPoolComment);
+    firstPoolEncryptionKeyName, firstPoolSupply, firstPoolComment);
   m_catalogue->TapePool()->createTapePool(m_admin, secondTapePoolName, m_anotherVo.name, nbSecondPoolPartialTapes,
-    secondPoolIsEncrypted, secondPoolSupply, secondPoolComment);
+    secondPoolEncryptionKeyNull, secondPoolSupply, secondPoolComment);
   {
     cta::catalogue::TapePoolSearchCriteria criteria;
     criteria.vo = m_vo.name;
@@ -1283,7 +1302,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterVO) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbFirstPoolPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(firstPoolIsEncrypted, pool.encryption);
+    ASSERT_EQ(firstPoolEncryptionKeyName.has_value(), pool.encryption);
+    ASSERT_EQ(firstPoolEncryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -1306,7 +1326,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterVO) {
     ASSERT_EQ(secondTapePoolName, pool.name);
     ASSERT_EQ(m_anotherVo.name, pool.vo.name);
     ASSERT_EQ(nbSecondPoolPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(secondPoolIsEncrypted, pool.encryption);
+    ASSERT_EQ(secondPoolEncryptionKeyNull.has_value(), pool.encryption);
+    ASSERT_EQ(secondPoolEncryptionKeyNull, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -1342,8 +1363,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterEncrypted) {
   const uint64_t nbFirstPoolPartialTapes = 2;
   const uint64_t nbSecondPoolPartialTapes = 3;
 
-  const bool firstPoolIsEncrypted = true;
-  const bool secondPoolIsEncrypted = false;
+  const std::optional<std::string> firstPoolEncryptionKeyName = "encryption_key_name";
+  const std::optional<std::string> secondPoolEncryptionKeyNull = std::nullopt;
 
   const std::list<std::string> firstPoolSupply;
   const std::list<std::string> secondPoolSupply;
@@ -1356,9 +1377,9 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterEncrypted) {
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_anotherVo);
 
   m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName, m_vo.name, nbFirstPoolPartialTapes,
-    firstPoolIsEncrypted, firstPoolSupply, firstPoolComment);
+    firstPoolEncryptionKeyName, firstPoolSupply, firstPoolComment);
   m_catalogue->TapePool()->createTapePool(m_admin, secondTapePoolName, m_anotherVo.name, nbSecondPoolPartialTapes,
-    secondPoolIsEncrypted, secondPoolSupply, secondPoolComment);
+    secondPoolEncryptionKeyNull, secondPoolSupply, secondPoolComment);
 
 
   {
@@ -1371,7 +1392,8 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterEncrypted) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbFirstPoolPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(firstPoolIsEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(firstPoolEncryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(std::nullopt, pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
@@ -1394,8 +1416,84 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterEncrypted) {
     ASSERT_EQ(secondTapePoolName, pool.name);
     ASSERT_EQ(m_anotherVo.name, pool.vo.name);
     ASSERT_EQ(nbSecondPoolPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(secondPoolIsEncrypted, pool.encryption);
-    ASSERT_FALSE((bool) pool.supply);
+    ASSERT_EQ(false, pool.encryption);
+    ASSERT_EQ(secondPoolEncryptionKeyNull, pool.encryptionKeyName);
+    ASSERT_FALSE(pool.supply);
+    ASSERT_EQ(0, pool.nbTapes);
+    ASSERT_EQ(0, pool.capacityBytes);
+    ASSERT_EQ(0, pool.dataBytes);
+    ASSERT_EQ(0, pool.nbPhysicalFiles);
+    ASSERT_EQ(secondPoolComment, pool.comment);
+
+    const cta::common::dataStructures::EntryLog creationLog = pool.creationLog;
+    ASSERT_EQ(m_admin.username, creationLog.username);
+    ASSERT_EQ(m_admin.host, creationLog.host);
+  }
+}
+
+TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterEncryptionKeyName) {
+  const std::string tapePoolName = "tape_pool";
+  const std::string secondTapePoolName = "tape_pool_2";
+
+  const uint64_t nbFirstPoolPartialTapes = 2;
+  const uint64_t nbSecondPoolPartialTapes = 3;
+
+  const std::optional<std::string> firstPoolEncryptionKeyName = "encryption_key_name";
+  const std::optional<std::string> secondPoolEncryptionKeyNull = std::nullopt;
+
+  const std::list<std::string> firstPoolSupply;
+  const std::list<std::string> secondPoolSupply;
+
+  const std::string firstPoolComment = "Create first tape pool";
+  const std::string secondPoolComment = "Create second tape pool";
+
+  m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
+  m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
+  m_catalogue->VO()->createVirtualOrganization(m_admin, m_anotherVo);
+
+  m_catalogue->TapePool()->createTapePool(m_admin, tapePoolName, m_vo.name, nbFirstPoolPartialTapes,
+    firstPoolEncryptionKeyName, firstPoolSupply, firstPoolComment);
+  m_catalogue->TapePool()->createTapePool(m_admin, secondTapePoolName, m_anotherVo.name, nbSecondPoolPartialTapes,
+    secondPoolEncryptionKeyNull, secondPoolSupply, secondPoolComment);
+
+
+  {
+    cta::catalogue::TapePoolSearchCriteria criteria;
+    criteria.encryptionKeyName = firstPoolEncryptionKeyName;
+    const auto pools = m_catalogue->TapePool()->getTapePools(criteria);
+    ASSERT_EQ(1, pools.size());
+
+    const auto &pool = pools.front();
+    ASSERT_EQ(tapePoolName, pool.name);
+    ASSERT_EQ(m_vo.name, pool.vo.name);
+    ASSERT_EQ(nbFirstPoolPartialTapes, pool.nbPartialTapes);
+    ASSERT_EQ(firstPoolEncryptionKeyName.has_value(), pool.encryption);
+    ASSERT_EQ(firstPoolEncryptionKeyName, pool.encryptionKeyName);
+    ASSERT_EQ(std::nullopt, pool.supply);
+    ASSERT_EQ(0, pool.nbTapes);
+    ASSERT_EQ(0, pool.capacityBytes);
+    ASSERT_EQ(0, pool.dataBytes);
+    ASSERT_EQ(0, pool.nbPhysicalFiles);
+    ASSERT_EQ(firstPoolComment, pool.comment);
+
+    const cta::common::dataStructures::EntryLog creationLog = pool.creationLog;
+    ASSERT_EQ(m_admin.username, creationLog.username);
+    ASSERT_EQ(m_admin.host, creationLog.host);
+  }
+
+  {
+    cta::catalogue::TapePoolSearchCriteria criteria;
+    criteria.encryptionKeyName = "";
+    const auto pools = m_catalogue->TapePool()->getTapePools(criteria);
+    ASSERT_EQ(1, pools.size());
+
+    const auto &pool = pools.front();
+    ASSERT_EQ(secondTapePoolName, pool.name);
+    ASSERT_EQ(m_anotherVo.name, pool.vo.name);
+    ASSERT_EQ(nbSecondPoolPartialTapes, pool.nbPartialTapes);
+    ASSERT_EQ(secondPoolEncryptionKeyNull.has_value(), pool.encryption);
+    ASSERT_EQ(secondPoolEncryptionKeyNull, pool.encryptionKeyName);
+    ASSERT_FALSE(pool.supply);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -1411,12 +1509,12 @@ TEST_P(cta_catalogue_TapePoolTest, getTapePools_filterEncrypted) {
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolName) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
 
   {
@@ -1428,7 +1526,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolName) {
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -1455,7 +1554,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolName) {
     ASSERT_EQ(newTapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -1478,12 +1578,12 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolName_emptyStringCurrentTapePool
 TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolName_emptyStringNewTapePoolName) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply,
     comment);
   {
     const auto pools = m_catalogue->TapePool()->getTapePools();
@@ -1494,7 +1594,8 @@ TEST_P(cta_catalogue_TapePoolTest, modifyTapePoolName_emptyStringNewTapePoolName
     ASSERT_EQ(tapePoolName, pool.name);
     ASSERT_EQ(m_vo.name, pool.vo.name);
     ASSERT_EQ(nbPartialTapes, pool.nbPartialTapes);
-    ASSERT_EQ(isEncrypted, pool.encryption);
+    ASSERT_EQ(true, pool.encryption);
+    ASSERT_EQ(encryptionKeyName, pool.encryptionKeyName);
     ASSERT_EQ(0, pool.nbTapes);
     ASSERT_EQ(0, pool.capacityBytes);
     ASSERT_EQ(0, pool.dataBytes);
@@ -1522,8 +1623,8 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_usingTapePoolSupplyTable) {
   const uint64_t nbFirstPoolPartialTapes = 2;
   const uint64_t nbSecondPoolPartialTapes = 3;
 
-  const bool firstPoolIsEncrypted = true;
-  const bool secondPoolIsEncrypted = false;
+  const std::optional<std::string> firstPoolEncryptionKeyName = "encryption_key_name";
+  const std::optional<std::string> secondPoolEncryptionKeyNull = std::nullopt;
 
   const std::list<std::string> firstPoolSupply;
   const std::list<std::string> secondPoolSupply = {"tape_pool"};
@@ -1536,10 +1637,10 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_usingTapePoolSupplyTable) {
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_anotherVo);
 
   m_catalogue->TapePool()->createTapePool(m_admin, firstTapePoolName, m_vo.name, nbFirstPoolPartialTapes,
-                                          firstPoolIsEncrypted, firstPoolSupply, firstPoolComment);
+                                          firstPoolEncryptionKeyName, firstPoolSupply, firstPoolComment);
 
   m_catalogue->TapePool()->createTapePool(m_admin, secondTapePoolName, m_anotherVo.name, nbSecondPoolPartialTapes,
-                                          secondPoolIsEncrypted, secondPoolSupply, secondPoolComment);
+                                          secondPoolEncryptionKeyNull, secondPoolSupply, secondPoolComment);
 
   auto pools_map = CatalogueTestUtils::tapePoolListToMap(m_catalogue->TapePool()->getTapePools());
   auto pools = m_catalogue->TapePool()->getTapePools();
@@ -1572,10 +1673,10 @@ TEST_P(cta_catalogue_TapePoolTest, createTapePool_usingTapePoolSupplyTable) {
   std::string thirdTapePoolName("tape_pool_3");
   std::list<std::string> thirdTapePoolSupply = {"tape_pool", "tape_pool_2"};
   const uint64_t nbThirdPoolPartialTapes = 3;
-  const bool thirdPoolIsEncrypted = false;
+  const std::optional<std::string> thirdPoolEncryptionKeyNull = std::nullopt;
   const std::string thirdPoolComment = "Create third tape pool";
   m_catalogue->TapePool()->createTapePool(m_admin, thirdTapePoolName, m_anotherVo.name, nbThirdPoolPartialTapes,
-                                          thirdPoolIsEncrypted, thirdTapePoolSupply, thirdPoolComment);
+                                          thirdPoolEncryptionKeyNull, thirdTapePoolSupply, thirdPoolComment);
 
   {
     const auto pools3_map = CatalogueTestUtils::tapePoolListToMap(m_catalogue->TapePool()->getTapePools());
diff --git a/catalogue/tests/modules/VirtualOrganizationCatalogueTest.cpp b/catalogue/tests/modules/VirtualOrganizationCatalogueTest.cpp
index d61602f4ce8970e577d94a9a9eafb63dc85c1759..24dea39cee8bb67b38f26f95fdc66385311f1ca9 100644
--- a/catalogue/tests/modules/VirtualOrganizationCatalogueTest.cpp
+++ b/catalogue/tests/modules/VirtualOrganizationCatalogueTest.cpp
@@ -116,13 +116,13 @@ TEST_P(cta_catalogue_VirtualOrganizationTest, deleteVirtualOrganization) {
 TEST_P(cta_catalogue_VirtualOrganizationTest, deleteVirtualOrganizationUsedByTapePool) {
   const std::string tapePoolName = "tape_pool";
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
   const std::string comment = "Create tape pool";
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin, m_vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, isEncrypted, supply, comment);
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, m_vo.name, nbPartialTapes, encryptionKeyName, supply, comment);
 
   ASSERT_THROW(m_catalogue->VO()->deleteVirtualOrganization(m_vo.name), cta::exception::UserError);
 }
@@ -316,14 +316,14 @@ TEST_P(cta_catalogue_VirtualOrganizationTest, modifyVirtualOrganizationDiskInsta
 
 TEST_P(cta_catalogue_VirtualOrganizationTest, getVirtualOrganizationOfTapepool) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   cta::common::dataStructures::VirtualOrganization vo = CatalogueTestUtils::getVo();
 
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin,vo);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, vo.name, nbPartialTapes, isEncrypted, supply,
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, vo.name, nbPartialTapes, encryptionKeyName, supply,
     "Create tape pool");
 
   cta::common::dataStructures::VirtualOrganization voFromTapepool =
@@ -335,7 +335,7 @@ TEST_P(cta_catalogue_VirtualOrganizationTest, getVirtualOrganizationOfTapepool)
 
 TEST_P(cta_catalogue_VirtualOrganizationTest, getDefaultVirtualOrganizationForRepacking) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   cta::common::dataStructures::VirtualOrganization repackVo = CatalogueTestUtils::getDefaultRepackVo();
@@ -347,8 +347,8 @@ TEST_P(cta_catalogue_VirtualOrganizationTest, getDefaultVirtualOrganizationForRe
   m_catalogue->VO()->createVirtualOrganization(m_admin,userVo1);
   m_catalogue->VO()->createVirtualOrganization(m_admin,repackVo);
   m_catalogue->VO()->createVirtualOrganization(m_admin,userVo2);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, userVo1.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePool, userVo2.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, userVo1.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePool, userVo2.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   std::optional<cta::common::dataStructures::VirtualOrganization> defaultVoForRepacking =
           m_catalogue->VO()->getDefaultVirtualOrganizationForRepack();
@@ -362,7 +362,7 @@ TEST_P(cta_catalogue_VirtualOrganizationTest, getDefaultVirtualOrganizationForRe
 
 TEST_P(cta_catalogue_VirtualOrganizationTest, getDefaultVirtualOrganizationForRepackingNoValue) {
   const uint64_t nbPartialTapes = 2;
-  const bool isEncrypted = true;
+  const std::string encryptionKeyName = "encryption_key_name";
   const std::list<std::string> supply;
 
   cta::common::dataStructures::VirtualOrganization userVo1 = CatalogueTestUtils::getVo();
@@ -372,8 +372,8 @@ TEST_P(cta_catalogue_VirtualOrganizationTest, getDefaultVirtualOrganizationForRe
   m_catalogue->DiskInstance()->createDiskInstance(m_admin, m_diskInstance.name, m_diskInstance.comment);
   m_catalogue->VO()->createVirtualOrganization(m_admin,userVo1);
   m_catalogue->VO()->createVirtualOrganization(m_admin,userVo2);
-  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, userVo1.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
-  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePool, userVo2.name, nbPartialTapes, isEncrypted, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, m_tape1.tapePoolName, userVo1.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
+  m_catalogue->TapePool()->createTapePool(m_admin, anotherTapePool, userVo2.name, nbPartialTapes, encryptionKeyName, supply, "Create tape pool");
 
   auto defaultVoForRepacking = m_catalogue->VO()->getDefaultVirtualOrganizationForRepack();
   ASSERT_FALSE(defaultVoForRepacking.has_value());
diff --git a/cmdline/CtaAdminCmdParse.hpp b/cmdline/CtaAdminCmdParse.hpp
index c73e72adf2f0b948f400f57534b85db3dcf0e99b..ce7350ccbc9659e203b43d5e47eeb7944f256fdf 100644
--- a/cmdline/CtaAdminCmdParse.hpp
+++ b/cmdline/CtaAdminCmdParse.hpp
@@ -1092,17 +1092,27 @@ tapepool (tp)
     **ls** shows statistics such as the total number of tapes in the pool and number of free tapes.
   */
   {{AdminCmd::CMD_TAPEPOOL, AdminCmd::SUBCMD_ADD},
-   {opt_tapepool_alias, opt_vo, opt_partialtapes, opt_encrypted, opt_supply.optional(), opt_comment}                         },
+   {opt_tapepool_alias,
+    opt_vo,
+    opt_partialtapes,
+    opt_encrypted.optional(),
+    opt_encryptionkeyname.optional(),
+    opt_supply.optional(),
+    opt_comment}                                                                                                             },
   {{AdminCmd::CMD_TAPEPOOL, AdminCmd::SUBCMD_CH},
    {opt_tapepool_alias,
     opt_vo.optional(),
     opt_partialtapes.optional(),
     opt_encrypted.optional(),
+    opt_encryptionkeyname.optional(),
     opt_supply.optional(),
     opt_comment.optional()}                                                                                                  },
   {{AdminCmd::CMD_TAPEPOOL, AdminCmd::SUBCMD_RM},             {opt_tapepool_alias}                                           },
   {{AdminCmd::CMD_TAPEPOOL, AdminCmd::SUBCMD_LS},
-   {opt_tapepool_alias.optional(), opt_vo.optional(), opt_encrypted.optional()}                                              },
+   {opt_tapepool_alias.optional(),
+    opt_vo.optional(),
+    opt_encrypted.optional(),
+    opt_encryptionkeyname.optional()}                                                                                        },
 
   /**md
 version (v)
diff --git a/continuousintegration/orchestration/tests/cta_admin.sh b/continuousintegration/orchestration/tests/cta_admin.sh
index e97113ef219cc7bac5c96b0d05a7615cc40f828d..17850dc4e7e55e8ec56925cebe15a94b46b070b5 100755
--- a/continuousintegration/orchestration/tests/cta_admin.sh
+++ b/continuousintegration/orchestration/tests/cta_admin.sh
@@ -336,11 +336,11 @@ test_assert || exit 1
 
 # Tape Pool (tp)
 test_start "tape pool" "tp"
-test_and_check_cmd "Adding tape pool 'cta_admin_test'" "${command}" "add" "-n 'cta_admin_test' --vo vo -p 0 -e false -m 'Test tp cmd'"\
-  'select(.name=="cta_admin_test" and .vo=="vo" and .numPartialTapes=="0" and .encrypt==false and .comment=="Test tp cmd") | .vo'\
+test_and_check_cmd "Adding tape pool 'cta_admin_test'" "${command}" "add" "-n 'cta_admin_test' --vo vo -p 0 -m 'Test tp cmd'"\
+  'select(.name=="cta_admin_test" and .vo=="vo" and .numPartialTapes=="0" and .encrypt==false and .encryptionKeyName=="" and .comment=="Test tp cmd") | .vo'\
   "1" "adding tape pool 'cta_admin_test'" || exit 1
-test_and_check_cmd "Changing tape pool 'cta_admin_test'" "${command}" "ch" "-n 'cta_admin_test' -e true"\
-  'select(.name=="cta_admin_test" and .encrypt==true) | .vo'\
+test_and_check_cmd "Changing tape pool 'cta_admin_test'" "${command}" "ch" "-n 'cta_admin_test' -k encrypt_key_name"\
+  'select(.name=="cta_admin_test" and .encrypt==true and .encryptionKeyName=="encrypt_key_name") | .vo'\
   "1" "changing tape pool 'cta_admin_test'" || exit 1
 test_command "Removing tape pool 'cta_admin_test'" "${command}" "rm" "-n 'cta_admin_test'" || exit 1
 test_assert|| exit 1
diff --git a/continuousintegration/orchestration/tests/postrun_checks.sh b/continuousintegration/orchestration/tests/postrun_checks.sh
index fc5ae637fe82e2d62b4e48aefa4ef195ad7914a1..a62601ce70ba1b25d72a74b66f87ee76aeae2d22 100755
--- a/continuousintegration/orchestration/tests/postrun_checks.sh
+++ b/continuousintegration/orchestration/tests/postrun_checks.sh
@@ -78,7 +78,7 @@ for pod in $(echo "${pods}" | jq -r '.metadata.name'); do
     # We ignore core dumps of xrdcp on the client pod (see #1113)
     coredumpfiles=$(kubectl --namespace "${NAMESPACE}" exec "${pod}" -c "${container}" -- \
                       bash -c "find /var/log/tmp/ -type f -name '*.core' 2>/dev/null \
-                               | grep -v -E 'client-0-[0-9]+-xrdcp-.*\.core$'
+                               | grep -v -E 'client-0-[0-9]+-xrdcp-.*\.core$' \
                                || true")
     if [ -n "${coredumpfiles}" ]; then
       num_files=$(wc -l <<< "${coredumpfiles}")
diff --git a/continuousintegration/orchestration/tests/prepare_tests.sh b/continuousintegration/orchestration/tests/prepare_tests.sh
index cdead1d00b66d366499a894e67a85cdd3e1f1a1c..5c8d96196f6d30723819325e69d598069f6efdb9 100755
--- a/continuousintegration/orchestration/tests/prepare_tests.sh
+++ b/continuousintegration/orchestration/tests/prepare_tests.sh
@@ -176,7 +176,6 @@ kubectl --namespace ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tap
   --name ctasystest                                                    \
   --vo vo                                                              \
   --partialtapesnumber 5                                               \
-  --encrypted false                                                    \
   --comment "ctasystest"
 
 kubectl --namespace ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin storageclass add \
@@ -195,19 +194,16 @@ kubectl --namespace ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tap
   --name ctasystest_A                                                  \
   --vo vo                                                              \
   --partialtapesnumber 5                                               \
-  --encrypted false                                                    \
   --comment "ctasystest_A"
 kubectl --namespace ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add \
   --name ctasystest_B                                                  \
   --vo vo                                                              \
   --partialtapesnumber 5                                               \
-  --encrypted false                                                    \
   --comment "ctasystest_B"
 kubectl --namespace ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add \
   --name ctasystest_C                                                  \
   --vo vo                                                              \
   --partialtapesnumber 5                                               \
-  --encrypted false                                                    \
   --comment "ctasystest_C"
 
 kubectl --namespace ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin storageclass add \
diff --git a/continuousintegration/orchestration/tests/test_repack.sh b/continuousintegration/orchestration/tests/test_repack.sh
index 35b9191b3c04fd4b8899a6770d6cea2b891d6abc..b95bce5bfdc7d098e4b23dbb1b145a2775ab19bd 100755
--- a/continuousintegration/orchestration/tests/test_repack.sh
+++ b/continuousintegration/orchestration/tests/test_repack.sh
@@ -432,12 +432,12 @@ repackMoveAndAddCopies() {
   tapepoolDestination2_repack="systest3_repack"
 
   echo "Creating 2 destination tapepools : $tapepoolDestination1_default and $tapepoolDestination2_default"
-  kubectl -n ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add --name $tapepoolDestination1_default --vo vo --partialtapesnumber 2 --encrypted false --comment "$tapepoolDestination1_default tapepool"
-  kubectl -n ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add --name $tapepoolDestination2_default --vo vo --partialtapesnumber 2 --encrypted false --comment "$tapepoolDestination2_default tapepool"
+  kubectl -n ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add --name $tapepoolDestination1_default --vo vo --partialtapesnumber 2 --comment "$tapepoolDestination1_default tapepool"
+  kubectl -n ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add --name $tapepoolDestination2_default --vo vo --partialtapesnumber 2 --comment "$tapepoolDestination2_default tapepool"
   echo "OK"
 
   echo "Creating 1 destination tapepool for repack : $tapepoolDestination2_repack (will override $tapepoolDestination2_default)"
-  kubectl -n ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add --name $tapepoolDestination2_repack --vo vo --partialtapesnumber 2 --encrypted false --comment "$tapepoolDestination2_repack tapepool"
+  kubectl -n ${NAMESPACE} exec ${CTA_CLI_POD} -c cta-cli -- cta-admin tapepool add --name $tapepoolDestination2_repack --vo vo --partialtapesnumber 2 --comment "$tapepoolDestination2_repack tapepool"
   echo "OK"
 
   echo "Creating archive routes for adding two copies of the file"
diff --git a/frontend/common/AdminCmd.cpp b/frontend/common/AdminCmd.cpp
index 79d0402fcb440b5fdddde0f7bd655149f1434eab..67d7ee6ee6efea225e397f17770e1abfb86158ee 100644
--- a/frontend/common/AdminCmd.cpp
+++ b/frontend/common/AdminCmd.cpp
@@ -1222,19 +1222,27 @@ void AdminCmd::processTapeFile_Rm(xrd::Response& response) {
 void AdminCmd::processTapePool_Add(xrd::Response& response) {
   using namespace cta::admin;
 
-  auto& name      = getRequired(OptionString::TAPE_POOL);
-  auto& vo        = getRequired(OptionString::VO);
-  auto& ptn       = getRequired(OptionUInt64::PARTIAL_TAPES_NUMBER);
-  auto& comment   = getRequired(OptionString::COMMENT);
-  auto& encrypted = getRequired(OptionBoolean::ENCRYPTED);
-  auto  supply    = getOptional(OptionString::SUPPLY);
+  auto& name             = getRequired(OptionString::TAPE_POOL);
+  auto& vo               = getRequired(OptionString::VO);
+  auto& ptn              = getRequired(OptionUInt64::PARTIAL_TAPES_NUMBER);
+  auto& comment          = getRequired(OptionString::COMMENT);
+  auto encrypted         = getOptional(OptionBoolean::ENCRYPTED);
+  auto encryptionKeyName = getOptional(OptionString::ENCRYPTION_KEY_NAME);
+  auto supply            = getOptional(OptionString::SUPPLY);
+
+  if(encrypted) {
+    throw exception::UserError("The parameter '--encrypted' has been deprecated. Use '--encryptionkeyname'.");
+  }
 
   std::list<std::string> supply_list;
   if (supply) {
     supply_list = cta::utils::commaSeparatedStringToList(supply.value());
   }
 
-  m_catalogue.TapePool()->createTapePool(m_cliIdentity, name, vo, ptn, encrypted, supply_list, comment);
+  if (encryptionKeyName && encryptionKeyName.value().empty()) {
+    encryptionKeyName = std::nullopt;
+  }
+  m_catalogue.TapePool()->createTapePool(m_cliIdentity, name, vo, ptn, encryptionKeyName, supply_list, comment);
 
   response.set_type(xrd::Response::RSP_SUCCESS);
 }
@@ -1242,13 +1250,17 @@ void AdminCmd::processTapePool_Add(xrd::Response& response) {
 void AdminCmd::processTapePool_Ch(xrd::Response& response) {
   using namespace cta::admin;
 
-  auto& name      = getRequired(OptionString::TAPE_POOL);
-  auto  vo        = getOptional(OptionString::VO);
-  auto  ptn       = getOptional(OptionUInt64::PARTIAL_TAPES_NUMBER);
-  auto  comment   = getOptional(OptionString::COMMENT);
-  auto  encrypted = getOptional(OptionBoolean::ENCRYPTED);
-  auto  supply    = getOptional(OptionString::SUPPLY);
+  auto& name              = getRequired(OptionString::TAPE_POOL);
+  auto  vo                = getOptional(OptionString::VO);
+  auto  ptn               = getOptional(OptionUInt64::PARTIAL_TAPES_NUMBER);
+  auto  comment           = getOptional(OptionString::COMMENT);
+  auto  encrypted         = getOptional(OptionBoolean::ENCRYPTED);
+  auto  encryptionKeyName = getOptional(OptionString::ENCRYPTION_KEY_NAME);
+  auto  supply            = getOptional(OptionString::SUPPLY);
 
+  if(encrypted) {
+    throw exception::UserError("The parameter '--encrypted' has been deprecated. Use '--encryptionkeyname'.");
+  }
   if(comment) {
     m_catalogue.TapePool()->modifyTapePoolComment(m_cliIdentity, name, comment.value());
   }
@@ -1258,8 +1270,8 @@ void AdminCmd::processTapePool_Ch(xrd::Response& response) {
   if(ptn) {
     m_catalogue.TapePool()->modifyTapePoolNbPartialTapes(m_cliIdentity, name, ptn.value());
   }
-  if(encrypted) {
-    m_catalogue.TapePool()->setTapePoolEncryption(m_cliIdentity, name, encrypted.value());
+  if(encryptionKeyName) {
+    m_catalogue.TapePool()->setTapePoolEncryption(m_cliIdentity, name, encryptionKeyName.value());
   }
   if(supply) {
     m_catalogue.TapePool()->modifyTapePoolSupply(m_cliIdentity, name,
diff --git a/scheduler/SchedulerTest.cpp b/scheduler/SchedulerTest.cpp
index b0eae65fc4afdfa2d49d14903d4af5ec9e9e2ce8..a1af26d7504511947c969ac7587de809fffd82be 100644
--- a/scheduler/SchedulerTest.cpp
+++ b/scheduler/SchedulerTest.cpp
@@ -279,19 +279,19 @@ public:
 
     const uint16_t nbPartialTapes = 1;
     const std::string tapePoolComment = "Tape-pool comment";
-    const bool tapePoolEncryption = false;
+    const std::optional<std::string> encryptionKeyNull = std::nullopt;
     const std::list<std::string> tapePoolSupply;
     const uint32_t copyNb = 1;
 
     // Tape pool for default archive route
-    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, s_tapePoolName_default, vo.name, nbPartialTapes, tapePoolEncryption,
+    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, s_tapePoolName_default, vo.name, nbPartialTapes, encryptionKeyNull,
                                          tapePoolSupply, tapePoolComment);
     const std::string archiveRouteComment_default = "Archive-route comment - default";
     catalogue.ArchiveRoute()->createArchiveRoute(s_adminOnAdminHost, s_storageClassName, copyNb, cta::common::dataStructures::ArchiveRouteType::DEFAULT,
                                                  s_tapePoolName_default, archiveRouteComment_default);
 
     // Tape pool for repack archive route
-    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, s_tapePoolName_repack, vo.name, nbPartialTapes, tapePoolEncryption,
+    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, s_tapePoolName_repack, vo.name, nbPartialTapes, encryptionKeyNull,
                                          tapePoolSupply, tapePoolComment);
     const std::string archiveRouteComment_repack = "Archive-route comment - repack";
     catalogue.ArchiveRoute()->createArchiveRoute(s_adminOnAdminHost, s_storageClassName, copyNb, cta::common::dataStructures::ArchiveRouteType::REPACK,
@@ -1262,11 +1262,11 @@ TEST_P(SchedulerTest, archive_report_and_retrieve_new_dual_copy_file) {
     const uint16_t nbPartialTapes = 1;
     const std::string tapePool1Comment = "Tape-pool for copy number 1";
     const std::string tapePool2Comment = "Tape-pool for copy number 2";
-    const bool tapePoolEncryption = false;
+    const std::optional<std::string> encryptionKeyNull = std::nullopt;
     const std::list<std::string> tapePoolSupplyList;
-    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, tapePool1Name, vo.name, nbPartialTapes, tapePoolEncryption,
+    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, tapePool1Name, vo.name, nbPartialTapes, encryptionKeyNull,
                                          tapePoolSupplyList, tapePool1Comment);
-    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, tapePool2Name, vo.name, nbPartialTapes, tapePoolEncryption,
+    catalogue.TapePool()->createTapePool(s_adminOnAdminHost, tapePool2Name, vo.name, nbPartialTapes, encryptionKeyNull,
                                          tapePoolSupplyList, tapePool2Comment);
 
     const std::string archiveRoute1Comment = "Archive-route for copy number 1";
@@ -4692,10 +4692,10 @@ TEST_P(SchedulerTest, expandRepackRequestAddCopiesOnly) {
   //Create two different destination tapepool
   std::string tapepool2Name = "tapepool2";
   const std::list<std::string> supplyList;
-  catalogue.TapePool()->createTapePool(admin, tapepool2Name, "vo", 1, false, supplyList, "comment");
+  catalogue.TapePool()->createTapePool(admin, tapepool2Name, "vo", 1, std::nullopt, supplyList, "comment");
 
   std::string tapepool3Name = "tapepool3";
-  catalogue.TapePool()->createTapePool(admin, tapepool3Name, "vo", 1, false, supplyList, "comment");
+  catalogue.TapePool()->createTapePool(admin, tapepool3Name, "vo", 1, std::nullopt, supplyList, "comment");
 
   //Create a storage class in the catalogue
   common::dataStructures::StorageClass storageClass;
@@ -4945,7 +4945,7 @@ TEST_P(SchedulerTest, expandRepackRequestShouldFailIfArchiveRouteMissing) {
   //Create two different destination tapepool
   std::string tapepool2Name = "tapepool2";
   const std::list<std::string> supplyList;
-  catalogue.TapePool()->createTapePool(admin, tapepool2Name, "vo", 1, false, supplyList, "comment");
+  catalogue.TapePool()->createTapePool(admin, tapepool2Name, "vo", 1, std::nullopt, supplyList, "comment");
 
   //Create a storage class in the catalogue
   common::dataStructures::StorageClass storageClass;
@@ -5128,10 +5128,10 @@ TEST_P(SchedulerTest, expandRepackRequestMoveAndAddCopies){
   //Create two different destination tapepool
   std::string tapepool2Name = "tapepool2";
   const std::list<std::string> supplyList;
-  catalogue.TapePool()->createTapePool(admin, tapepool2Name, "vo", 1, false, supplyList, "comment");
+  catalogue.TapePool()->createTapePool(admin, tapepool2Name, "vo", 1, std::nullopt, supplyList, "comment");
 
   std::string tapepool3Name = "tapepool3";
-  catalogue.TapePool()->createTapePool(admin, tapepool3Name, "vo", 1, false, supplyList, "comment");
+  catalogue.TapePool()->createTapePool(admin, tapepool3Name, "vo", 1, std::nullopt, supplyList, "comment");
 
   //Create a storage class in the catalogue
   common::dataStructures::StorageClass storageClass;
@@ -6664,7 +6664,7 @@ TEST_P(SchedulerTest, retrieveArchiveAllTypesMaxDrivesVoInFlightChangeScheduleMo
 
   //Create a new tapepool on the same VO
   std::string newTapepool = "new_tapepool";
-  catalogue.TapePool()->createTapePool(s_adminOnAdminHost, newTapepool, s_vo, 1, false, std::list<std::string>(),
+  catalogue.TapePool()->createTapePool(s_adminOnAdminHost, newTapepool, s_vo, 1, std::nullopt, std::list<std::string>(),
                                        "Test");
 
   //Create the third tape in the new tapepool
diff --git a/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp b/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
index 90e387658c2485a0cfc8fcc031451955e2cc7ec8..352e015b97452a667d950ccf8a6f61edd97953ca 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/DataTransferSessionTest.cpp
@@ -379,11 +379,11 @@ public:
 
     const uint16_t nbPartialTapes = 1;
     const std::string tapePoolComment = "Tape-pool comment";
-    const bool tapePoolEncryption = false;
+    const std::optional<std::string> encryptionKeyName = std::nullopt;
     const std::list<std::string> tapePoolSupplyList;
 
     ASSERT_NO_THROW(catalogue.TapePool()->createTapePool(s_adminOnAdminHost, s_tapePoolName, vo.name, nbPartialTapes,
-                                                         tapePoolEncryption, tapePoolSupplyList, tapePoolComment));
+                                                           encryptionKeyName, tapePoolSupplyList, tapePoolComment));
     const uint32_t copyNb = 1;
     const std::string archiveRouteComment = "Archive-route comment";
     catalogue.ArchiveRoute()->createArchiveRoute(s_adminOnAdminHost, s_storageClassName, copyNb, cta::common::dataStructures::ArchiveRouteType::DEFAULT,
diff --git a/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.cpp b/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.cpp
index c7307ffc254d5e4989369d23bbc1e1e535e21b98..5c742124ec3fc4ae601f6e35b823eca6b3130beb 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.cpp
@@ -68,15 +68,16 @@ auto EncryptionControl::enable(castor::tape::tapeserver::drive::DriveInterface &
 
   // Write session with no encryption key name and encryption is disabled for the tape pool
   // Tape is guaranteed to be unencrypted, no need to run external script
-  if (isWriteSession && !pool->encryption && !volInfo.encryptionKeyName.has_value()) {
+  if (isWriteSession && !pool->encryptionKeyName && !pool->encryption && !volInfo.encryptionKeyName.has_value()) {
     encStatus = {false, "", "", ""};
     disable(m_drive);
     return encStatus;
   }
 
   // In other cases we call external script to get the key value from the JSON data store
+  std::string encryptionKeyName = volInfo.encryptionKeyName ? volInfo.encryptionKeyName.value() : pool->encryptionKeyName.value_or("");
   std::list<std::string> args(
-    {m_path, "--encryption-key-name", volInfo.encryptionKeyName.value_or(""), "--pool-name", volInfo.tapePool});
+    {m_path, "--encryption-key-name", encryptionKeyName, "--pool-name", volInfo.tapePool});
 
   cta::threading::SubProcess sp(m_path, args);
   sp.wait();
@@ -98,7 +99,7 @@ auto EncryptionControl::enable(castor::tape::tapeserver::drive::DriveInterface &
 
   // In write session check if we need to set the key name for the new tape
   // If tape pool encryption is enabled and key name is empty, it means we are writing to the new tape
-  if (isWriteSession && pool->encryption && !volInfo.encryptionKeyName.has_value()) {
+  if (isWriteSession && (pool->encryptionKeyName || pool->encryption) && !volInfo.encryptionKeyName.has_value()) {
     catalogue.Tape()->modifyTapeEncryptionKeyName({"ctaops", cta::utils::getShortHostname()}, volInfo.vid,
                                                   encStatus.keyName);
     encStatus.on = true;
@@ -124,6 +125,10 @@ bool EncryptionControl::disable(castor::tape::tapeserver::drive::DriveInterface&
   return m_drive.clearEncryptionKey();
 }
 
+const std::string & EncryptionControl::getScriptPath() const {
+  return m_path;
+};
+
 namespace {
 struct JsonObjectDeleter {
   void operator()(json_object *jo) { json_object_put(jo); }
diff --git a/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.hpp b/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.hpp
index 4b6ad5101c408381d730a18948b53a947e53a02f..a1ce9c69d727a40d2da38070d4f4b0cbe57ddb36 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.hpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/EncryptionControl.hpp
@@ -66,6 +66,12 @@ class EncryptionControl {
    */
   bool disable(castor::tape::tapeserver::drive::DriveInterface &m_drive);
 
+  /**
+   * Get script path
+   * @return The script path.
+   */
+  const std::string & getScriptPath() const;
+
  private:
   bool m_useEncryption; // Wether encryption must be enabled for the tape
   
diff --git a/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp b/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
index b727ba07e59299fa16e2ab076403e8856864f714..8fecc52e2ea288fe09b82b78ecc288fbae08b6ee 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/MigrationReportPackerTest.cpp
@@ -154,6 +154,7 @@ const uint32_t TEST_GROUP_2 = 9754;
     const bool logicalLibraryIsDisabled = false;
     std::optional<std::string> physicalLibraryName;
     const std::string tapePoolName = "tape_pool_name";
+    const std::string encryptionKeyName = "encryption_key_name";
     const std::list<std::string> supply_list;
     const bool fullValue = false;
     const std::string createTapeComment = "Create tape";
@@ -164,7 +165,7 @@ const uint32_t TEST_GROUP_2 = 9754;
     m_catalogue->VO()->createVirtualOrganization(admin,vo);
 
     m_catalogue->LogicalLibrary()->createLogicalLibrary(admin, logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
-    m_catalogue->TapePool()->createTapePool(admin, tapePoolName, vo.name, 2, true, supply_list, "Create tape pool");
+    m_catalogue->TapePool()->createTapePool(admin, tapePoolName, vo.name, 2, encryptionKeyName, supply_list, "Create tape pool");
     createMediaType(mediaType);
 
     {
@@ -315,7 +316,7 @@ const uint32_t TEST_GROUP_2 = 9754;
     std::optional<std::string> physicalLibraryName;
     const std::string tapePoolName = "tape_pool_name";
     const uint64_t nbPartialTapes = 2;
-    const bool isEncrypted = true;
+    const std::string encryptionKeyName = "encryption_key_name";
     const std::list<std::string> supply_list;
     const bool fullValue = false;
     const std::string createTapeComment = "Create tape";
@@ -327,7 +328,7 @@ const uint32_t TEST_GROUP_2 = 9754;
     m_catalogue->VO()->createVirtualOrganization(admin,vo);
 
     m_catalogue->LogicalLibrary()->createLogicalLibrary(admin, logicalLibraryName, logicalLibraryIsDisabled, physicalLibraryName, "Create logical library");
-    m_catalogue->TapePool()->createTapePool(admin, tapePoolName, vo.name, nbPartialTapes, isEncrypted, supply_list,
+    m_catalogue->TapePool()->createTapePool(admin, tapePoolName, vo.name, nbPartialTapes, encryptionKeyName, supply_list,
                                             "Create tape pool");
     createMediaType(mediaType);
 
diff --git a/tapeserver/castor/tape/tapeserver/daemon/TapeReadSingleThread.cpp b/tapeserver/castor/tape/tapeserver/daemon/TapeReadSingleThread.cpp
index b21ae7e1a130d6643b92a7680bb6520c762702bd..6bfdec4d5f206ee44021470baf22b9e7283e15fd 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/TapeReadSingleThread.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/TapeReadSingleThread.cpp
@@ -330,6 +330,7 @@ void castor::tape::tapeserver::daemon::TapeReadSingleThread::run() {
           if (encryptionStatus.on) {
             encryptionLogParams.add("encryption", "on")
                                .add("encryptionKeyName", encryptionStatus.keyName)
+                               .add("scriptPath", m_encryptionControl.getScriptPath())
                                .add("stdout", encryptionStatus.stdout);
             m_logContext.log(cta::log::INFO, "Drive encryption enabled for this mount");
           } else {
diff --git a/tapeserver/castor/tape/tapeserver/daemon/TapeWriteSingleThread.cpp b/tapeserver/castor/tape/tapeserver/daemon/TapeWriteSingleThread.cpp
index d9de8ca11417bd3f4314faea0be77ffc6019eaf8..ec15a5a0566802fbf8bfe00c0f44d1cf101fd20a 100644
--- a/tapeserver/castor/tape/tapeserver/daemon/TapeWriteSingleThread.cpp
+++ b/tapeserver/castor/tape/tapeserver/daemon/TapeWriteSingleThread.cpp
@@ -369,6 +369,7 @@ void castor::tape::tapeserver::daemon::TapeWriteSingleThread::run() {
           if (encryptionStatus.on) {
             encryptionLogParams.add("encryption", "on")
               .add("encryptionKeyName", encryptionStatus.keyName)
+              .add("scriptPath", m_encryptionControl.getScriptPath())
               .add("stdout", encryptionStatus.stdout);
             m_logContext.log(cta::log::INFO, "Drive encryption enabled for this mount");
           } else {
diff --git a/tapeserver/readtp/ReadtpCmd.cpp b/tapeserver/readtp/ReadtpCmd.cpp
index f729af0ca6e0ee9d41d582fb9d608c3e15d016c2..8a9a8eaa231089ac59a53684804833043002d6d9 100644
--- a/tapeserver/readtp/ReadtpCmd.cpp
+++ b/tapeserver/readtp/ReadtpCmd.cpp
@@ -583,6 +583,7 @@ void ReadtpCmd::configureEncryption(castor::tape::tapeserver::daemon::VolumeInfo
       if (encryptionStatus.on) {
         params.push_back(cta::log::Param("encryption", "on"));
         params.push_back(cta::log::Param("encryptionKeyName", encryptionStatus.keyName));
+        params.push_back(cta::log::Param("scriptPath", m_encryptionControl->getScriptPath()));
         params.push_back(cta::log::Param("stdout", encryptionStatus.stdout));
         m_log(cta::log::INFO, "Drive encryption enabled for this mount", params);
       } else {
diff --git a/xroot_plugins/XrdCtaTapePoolLs.hpp b/xroot_plugins/XrdCtaTapePoolLs.hpp
index e31707d0202d0f632b8b6ada569aede6cc8332e7..bde13c106806a34c0564cec5986079c573b23181 100644
--- a/xroot_plugins/XrdCtaTapePoolLs.hpp
+++ b/xroot_plugins/XrdCtaTapePoolLs.hpp
@@ -69,6 +69,11 @@ TapePoolLsStream::TapePoolLsStream(const frontend::AdminCmdStream& requestMsg, c
   searchCriteria.name = requestMsg.getOptional(OptionString::TAPE_POOL);
   searchCriteria.vo = requestMsg.getOptional(OptionString::VO);
   searchCriteria.encrypted = requestMsg.getOptional(OptionBoolean::ENCRYPTED);
+  searchCriteria.encryptionKeyName = requestMsg.getOptional(OptionString::ENCRYPTION_KEY_NAME);
+
+  if(searchCriteria.encrypted && searchCriteria.encryptionKeyName) {
+    throw exception::UserError("Do not request both '--encrypted' and '--encryptionkeyname' at same time.");
+  }
 
   m_tapePoolList = m_catalogue.TapePool()->getTapePools(searchCriteria);
 }
@@ -88,6 +93,7 @@ int TapePoolLsStream::fillBuffer(XrdSsiPb::OStreamBuffer<Data> *streambuf) {
     tp_item->set_capacity_bytes(tp.capacityBytes);
     tp_item->set_data_bytes(tp.dataBytes);
     tp_item->set_encrypt(tp.encryption);
+    tp_item->set_encryption_key_name(tp.encryptionKeyName.value_or(""));
     tp_item->set_supply(tp.supply ? tp.supply.value() : "");
     tp_item->mutable_created()->set_username(tp.creationLog.username);
     tp_item->mutable_created()->set_host(tp.creationLog.host);
diff --git a/xrootd-ssi-protobuf-interface b/xrootd-ssi-protobuf-interface
index f59e44742c6436a421157e76e5ee062c88d813bf..ad2bd6c3914bee772ec15b664e0863715d101d70 160000
--- a/xrootd-ssi-protobuf-interface
+++ b/xrootd-ssi-protobuf-interface
@@ -1 +1 @@
-Subproject commit f59e44742c6436a421157e76e5ee062c88d813bf
+Subproject commit ad2bd6c3914bee772ec15b664e0863715d101d70