diff --git a/src/ca-module.cpp b/src/ca-module.cpp
index c662617..5e6c40f 100644
--- a/src/ca-module.cpp
+++ b/src/ca-module.cpp
@@ -302,7 +302,9 @@
                                        "Error computing the request ID."));
     return;
   }
-  CaState requestState(m_config.m_caItem.m_caPrefix, toHex(requestIdData, 32),
+  RequestID id;
+  std::memcpy(id.data(), requestIdData, id.size());
+  CaState requestState(m_config.m_caItem.m_caPrefix, id,
                        requestType, Status::BEFORE_CHALLENGE, *clientCert,
                        makeBinaryBlock(ndn::tlv::ContentType_Key, aesKey, sizeof(aesKey)));
   try {
@@ -318,9 +320,9 @@
   result.setName(request.getName());
   result.setFreshnessPeriod(DEFAULT_DATA_FRESHNESS_PERIOD);
   result.setContent(NewRenewRevokeEncoder::encodeDataContent(myEcdhPubKeyBase64,
-                                                        std::to_string(saltInt),
-                                                        requestState,
-                                                        m_config.m_caItem.m_supportedChallenges));
+                                                             std::to_string(saltInt),
+                                                             requestState,
+                                                             m_config.m_caItem.m_supportedChallenges));
   m_keyChain.sign(result, signingByIdentity(m_config.m_caItem.m_caPrefix));
   m_face.put(result);
   if (m_config.m_statusUpdateCallback) {
@@ -332,15 +334,15 @@
 CaModule::onChallenge(const Interest& request)
 {
   // get certificate request state
-  CaState requestState = getCertificateRequest(request);
-  if (requestState.m_requestId == "") {
+  auto requestState = getCertificateRequest(request);
+  if (requestState== nullptr) {
     NDN_LOG_ERROR("No certificate request state can be found.");
     m_face.put(generateErrorDataPacket(request.getName(), ErrorCode::INVALID_PARAMETER,
                                        "No certificate request state can be found."));
     return;
   }
   // verify signature
-  if (!security::verifySignature(request, requestState.m_cert)) {
+  if (!security::verifySignature(request, requestState->m_cert)) {
     NDN_LOG_ERROR("Invalid Signature in the Interest packet.");
     m_face.put(generateErrorDataPacket(request.getName(), ErrorCode::BAD_SIGNATURE,
                                        "Invalid Signature in the Interest packet."));
@@ -350,20 +352,20 @@
   Buffer paramTLVPayload;
   try {
     paramTLVPayload = decodeBlockWithAesGcm128(request.getApplicationParameters(),
-                                               requestState.m_encryptionKey.value(),
-                                               (const uint8_t*)requestState.m_requestId.c_str(),
-                                               requestState.m_requestId.size());
+                                               requestState->m_encryptionKey.value(),
+                                               requestState->m_requestId.data(),
+                                               requestState->m_requestId.size());
   }
   catch (const std::exception& e) {
     NDN_LOG_ERROR("Interest paramaters decryption failed: " << e.what());
-    m_storage->deleteRequest(requestState.m_requestId);
+    m_storage->deleteRequest(requestState->m_requestId);
     m_face.put(generateErrorDataPacket(request.getName(), ErrorCode::INVALID_PARAMETER,
                                        "Interest paramaters decryption failed."));
     return;
   }
   if (paramTLVPayload.size() == 0) {
     NDN_LOG_ERROR("No parameters are found after decryption.");
-    m_storage->deleteRequest(requestState.m_requestId);
+    m_storage->deleteRequest(requestState->m_requestId);
     m_face.put(generateErrorDataPacket(request.getName(), ErrorCode::INVALID_PARAMETER,
                                        "No parameters are found after decryption."));
     return;
@@ -376,69 +378,68 @@
   auto challenge = ChallengeModule::createChallengeModule(challengeType);
   if (challenge == nullptr) {
     NDN_LOG_TRACE("Unrecognized challenge type: " << challengeType);
-    m_storage->deleteRequest(requestState.m_requestId);
+    m_storage->deleteRequest(requestState->m_requestId);
     m_face.put(generateErrorDataPacket(request.getName(), ErrorCode::INVALID_PARAMETER, "Unrecognized challenge type."));
     return;
   }
 
   NDN_LOG_TRACE("CHALLENGE module to be load: " << challengeType);
-  auto errorInfo = challenge->handleChallengeRequest(paramTLV, requestState);
+  auto errorInfo = challenge->handleChallengeRequest(paramTLV, *requestState);
   if (std::get<0>(errorInfo) != ErrorCode::NO_ERROR) {
-    m_storage->deleteRequest(requestState.m_requestId);
+    m_storage->deleteRequest(requestState->m_requestId);
     m_face.put(generateErrorDataPacket(request.getName(), std::get<0>(errorInfo), std::get<1>(errorInfo)));
     return;
   }
 
   Block payload;
-  if (requestState.m_status == Status::PENDING) {
+  if (requestState->m_status == Status::PENDING) {
     // if challenge succeeded
-    if (requestState.m_requestType == RequestType::NEW) {
-      auto issuedCert = issueCertificate(requestState);
-      requestState.m_cert = issuedCert;
-      requestState.m_status = Status::SUCCESS;
-      m_storage->deleteRequest(requestState.m_requestId);
+    if (requestState->m_requestType == RequestType::NEW) {
+      auto issuedCert = issueCertificate(*requestState);
+      requestState->m_cert = issuedCert;
+      requestState->m_status = Status::SUCCESS;
+      m_storage->deleteRequest(requestState->m_requestId);
 
-      payload = ChallengeEncoder::encodeDataContent(requestState);
+      payload = ChallengeEncoder::encodeDataContent(*requestState);
       payload.parse();
       payload.push_back(makeNestedBlock(tlv::IssuedCertName, issuedCert.getName()));
       payload.encode();
       NDN_LOG_TRACE("Challenge succeeded. Certificate has been issued: " << issuedCert.getName());
     }
-    else if (requestState.m_requestType == RequestType::REVOKE) {
-      requestState.m_status = Status::SUCCESS;
-      m_storage->deleteRequest(requestState.m_requestId);
+    else if (requestState->m_requestType == RequestType::REVOKE) {
+      requestState->m_status = Status::SUCCESS;
+      m_storage->deleteRequest(requestState->m_requestId);
 
-      payload = ChallengeEncoder::encodeDataContent(requestState);
+      payload = ChallengeEncoder::encodeDataContent(*requestState);
       NDN_LOG_TRACE("Challenge succeeded. Certificate has been revoked");
     }
   }
   else {
-    m_storage->updateRequest(requestState);
-    payload = ChallengeEncoder::encodeDataContent(requestState);
+    m_storage->updateRequest(*requestState);
+    payload = ChallengeEncoder::encodeDataContent(*requestState);
     NDN_LOG_TRACE("No failure no success. Challenge moves on");
   }
 
   Data result;
   result.setName(request.getName());
   result.setFreshnessPeriod(DEFAULT_DATA_FRESHNESS_PERIOD);
-  auto contentBlock = encodeBlockWithAesGcm128(ndn::tlv::Content, requestState.m_encryptionKey.value(),
+  auto contentBlock = encodeBlockWithAesGcm128(ndn::tlv::Content, requestState->m_encryptionKey.value(),
                                                payload.value(), payload.value_size(),
-                                               (const uint8_t*)requestState.m_requestId.c_str(),
-                                               requestState.m_requestId.size(),
-                                               requestState.m_aesBlockCounter);
+                                               requestState->m_requestId.data(),
+                                               requestState->m_requestId.size(),
+                                               requestState->m_aesBlockCounter);
   result.setContent(contentBlock);
   m_keyChain.sign(result, signingByIdentity(m_config.m_caItem.m_caPrefix));
   m_face.put(result);
   if (m_config.m_statusUpdateCallback) {
-    m_config.m_statusUpdateCallback(requestState);
+    m_config.m_statusUpdateCallback(*requestState);
   }
 }
 
 security::Certificate
 CaModule::issueCertificate(const CaState& requestState)
 {
-  auto expectedPeriod =
-      requestState.m_cert.getValidityPeriod().getPeriod();
+  auto expectedPeriod = requestState.m_cert.getValidityPeriod().getPeriod();
   security::ValidityPeriod period(expectedPeriod.first, expectedPeriod.second);
   security::Certificate newCert;
 
@@ -457,25 +458,26 @@
   return newCert;
 }
 
-CaState
+std::unique_ptr<CaState>
 CaModule::getCertificateRequest(const Interest& request)
 {
-  std::string requestId;
-  CaState requestState;
+  RequestID requestId;
   try {
-    requestId = readString(request.getName().at(m_config.m_caItem.m_caPrefix.size() + 2));
+    auto& component = request.getName().at(m_config.m_caItem.m_caPrefix.size() + 2);
+    std::memcpy(requestId.data(), component.value(), component.value_size());
   }
   catch (const std::exception& e) {
     NDN_LOG_ERROR("Cannot read the request ID out from the request: " << e.what());
+    return nullptr;
   }
   try {
-    NDN_LOG_TRACE("Request Id to query the database " << requestId);
-    requestState = m_storage->getRequest(requestId);
+    NDN_LOG_TRACE("Request Id to query the database " << toHex(requestId.data(), requestId.size()));
+    return std::make_unique<CaState>(m_storage->getRequest(requestId));
   }
   catch (const std::exception& e) {
     NDN_LOG_ERROR("Cannot get certificate request record from the storage: " << e.what());
+    return nullptr;
   }
-  return requestState;
 }
 
 void
diff --git a/src/ca-module.hpp b/src/ca-module.hpp
index d29f49b..22c53fc 100644
--- a/src/ca-module.hpp
+++ b/src/ca-module.hpp
@@ -70,7 +70,7 @@
   void
   onRegisterFailed(const std::string& reason);
 
-  CaState
+  std::unique_ptr<CaState>
   getCertificateRequest(const Interest& request);
 
   security::Certificate
diff --git a/src/detail/ca-memory.cpp b/src/detail/ca-memory.cpp
index b647dba..b054cc0 100644
--- a/src/detail/ca-memory.cpp
+++ b/src/detail/ca-memory.cpp
@@ -35,11 +35,11 @@
 }
 
 CaState
-CaMemory::getRequest(const std::string& requestId)
+CaMemory::getRequest(const RequestID& requestId)
 {
   auto search = m_requests.find(requestId);
   if (search == m_requests.end()) {
-    NDN_THROW(std::runtime_error("Request " + requestId + " doest not exists"));
+    NDN_THROW(std::runtime_error("Request " + toHex(requestId.data(), requestId.size()) + " doest not exists"));
   }
   return search->second;
 }
@@ -52,7 +52,7 @@
     m_requests[request.m_requestId] = request;
   }
   else {
-    NDN_THROW(std::runtime_error("Request " + request.m_requestId + " already exists"));
+    NDN_THROW(std::runtime_error("Request " + toHex(request.m_requestId.data(), request.m_requestId.size()) + " already exists"));
   }
 }
 
@@ -64,7 +64,7 @@
 }
 
 void
-CaMemory::deleteRequest(const std::string& requestId)
+CaMemory::deleteRequest(const RequestID& requestId)
 {
   auto search = m_requests.find(requestId);
   auto keyName = search->second.m_cert.getKeyName();
diff --git a/src/detail/ca-memory.hpp b/src/detail/ca-memory.hpp
index 842121b..0c2fa34 100644
--- a/src/detail/ca-memory.hpp
+++ b/src/detail/ca-memory.hpp
@@ -37,7 +37,7 @@
    * @throw if request cannot be fetched from underlying data storage
    */
   CaState
-  getRequest(const std::string& requestId) override;
+  getRequest(const RequestID& requestId) override;
 
   /**
    * @throw if there is an existing request with the same request ID
@@ -49,7 +49,7 @@
   updateRequest(const CaState& request) override;
 
   void
-  deleteRequest(const std::string& requestId) override;
+  deleteRequest(const RequestID& requestId) override;
 
   std::list<CaState>
   listAllRequests() override;
@@ -58,7 +58,7 @@
   listAllRequests(const Name& caName) override;
 
 private:
-  std::map<Name, CaState> m_requests;
+  std::map<RequestID, CaState> m_requests;
 };
 
 } // namespace ndncert
diff --git a/src/detail/ca-sqlite.cpp b/src/detail/ca-sqlite.cpp
index 468fd2c..8371cf4 100644
--- a/src/detail/ca-sqlite.cpp
+++ b/src/detail/ca-sqlite.cpp
@@ -55,7 +55,7 @@
 CREATE TABLE IF NOT EXISTS
   CaStates(
     id INTEGER PRIMARY KEY,
-    request_id TEXT NOT NULL,
+    request_id BLOB NOT NULL,
     ca_name BLOB NOT NULL,
     request_type INTEGER NOT NULL,
     status INTEGER NOT NULL,
@@ -123,7 +123,7 @@
 }
 
 CaState
-CaSqlite::getRequest(const std::string& requestId)
+CaSqlite::getRequest(const RequestID& requestId)
 {
   Sqlite3Statement statement(m_database,
                              R"_SQLTEXT_(SELECT id, ca_name, status,
@@ -132,7 +132,7 @@
                              challenge_tp, remaining_tries, remaining_time,
                              request_type, encryption_key, aes_block_counter
                              FROM CaStates where request_id = ?)_SQLTEXT_");
-  statement.bind(1, requestId, SQLITE_TRANSIENT);
+  statement.bind(1, requestId.data(), requestId.size(), SQLITE_TRANSIENT);
 
   if (statement.step() == SQLITE_ROW) {
     Name caName(statement.getBlock(1));
@@ -158,7 +158,7 @@
     }
   }
   else {
-    NDN_THROW(std::runtime_error("Request " + requestId + " cannot be fetched from database"));
+    NDN_THROW(std::runtime_error("Request " + toHex(requestId.data(), requestId.size()) + " cannot be fetched from database"));
   }
 }
 
@@ -171,7 +171,7 @@
                   cert_request, challenge_type, challenge_status, challenge_secrets,
                   challenge_tp, remaining_tries, remaining_time, encryption_key, aes_block_counter)
                   values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?))_SQLTEXT_");
-  statement.bind(1, request.m_requestId, SQLITE_TRANSIENT);
+  statement.bind(1, request.m_requestId.data(), request.m_requestId.size(), SQLITE_TRANSIENT);
   statement.bind(2, request.m_caPrefix.wireEncode(), SQLITE_TRANSIENT);
   statement.bind(3, static_cast<int>(request.m_status));
   statement.bind(4, static_cast<int>(request.m_requestType));
@@ -188,7 +188,7 @@
     statement.bind(11, request.m_challengeState->m_remainingTime.count());
   }
   if (statement.step() != SQLITE_DONE) {
-    NDN_THROW(std::runtime_error("Request " + request.m_requestId + " cannot be added to database"));
+    NDN_THROW(std::runtime_error("Request " + toHex(request.m_requestId.data(), request.m_requestId.size()) + " cannot be added to database"));
   }
 }
 
@@ -217,7 +217,7 @@
     statement.bind(7, 0);
   }
   statement.bind(8, request.m_aesBlockCounter);
-  statement.bind(9, request.m_requestId, SQLITE_TRANSIENT);
+  statement.bind(9, request.m_requestId.data(), request.m_requestId.size(), SQLITE_TRANSIENT);
 
   if (statement.step() != SQLITE_DONE) {
     addRequest(request);
@@ -234,7 +234,8 @@
                              encryption_key, aes_block_counter
                              FROM CaStates)_SQLTEXT_");
   while (statement.step() == SQLITE_ROW) {
-    auto requestId = statement.getString(1);
+    RequestID requestId;
+    std::memcpy(requestId.data(), statement.getBlob(1), statement.getSize(1));
     Name caName(statement.getBlock(2));
     auto status = static_cast<Status>(statement.getInt(3));
     auto challengeStatus = statement.getString(4);
@@ -273,7 +274,8 @@
   statement.bind(1, caName.wireEncode(), SQLITE_TRANSIENT);
 
   while (statement.step() == SQLITE_ROW) {
-    auto requestId = statement.getString(1);
+    RequestID requestId;
+    std::memcpy(requestId.data(), statement.getBlob(1), statement.getSize(1));
     Name caName(statement.getBlock(2));
     auto status = static_cast<Status>(statement.getInt(3));
     auto challengeStatus = statement.getString(4);
@@ -300,11 +302,11 @@
 }
 
 void
-CaSqlite::deleteRequest(const std::string& requestId)
+CaSqlite::deleteRequest(const RequestID& requestId)
 {
   Sqlite3Statement statement(m_database,
                              R"_SQLTEXT_(DELETE FROM CaStates WHERE request_id = ?)_SQLTEXT_");
-  statement.bind(1, requestId, SQLITE_TRANSIENT);
+  statement.bind(1, requestId.data(), requestId.size(), SQLITE_TRANSIENT);
   statement.step();
 }
 
diff --git a/src/detail/ca-sqlite.hpp b/src/detail/ca-sqlite.hpp
index 5d12188..f0ffe1f 100644
--- a/src/detail/ca-sqlite.hpp
+++ b/src/detail/ca-sqlite.hpp
@@ -43,7 +43,7 @@
    * @throw if request cannot be fetched from underlying data storage
    */
   CaState
-  getRequest(const std::string& requestId) override;
+  getRequest(const RequestID& requestId) override;
 
   /**
    * @throw if there is an existing request with the same request ID
@@ -55,7 +55,7 @@
   updateRequest(const CaState& request) override;
 
   void
-  deleteRequest(const std::string& requestId) override;
+  deleteRequest(const RequestID& requestId) override;
 
   std::list<CaState>
   listAllRequests() override;
diff --git a/src/detail/ca-state.cpp b/src/detail/ca-state.cpp
index 334429a..4dad34d 100644
--- a/src/detail/ca-state.cpp
+++ b/src/detail/ca-state.cpp
@@ -64,7 +64,7 @@
 {
 }
 
-CaState::CaState(const Name& caName, const std::string& requestId, RequestType requestType, Status status,
+CaState::CaState(const Name& caName, const RequestID& requestId, RequestType requestType, Status status,
                  const security::Certificate& cert, Block encryptionKey, uint32_t aesBlockCounter)
     : m_caPrefix(caName)
     , m_requestId(requestId)
@@ -76,7 +76,7 @@
 {
 }
 
-CaState::CaState(const Name& caName, const std::string& requestId, RequestType requestType, Status status,
+CaState::CaState(const Name& caName, const RequestID& requestId, RequestType requestType, Status status,
                  const security::Certificate& cert, const std::string& challengeType,
                  const std::string& challengeStatus, const time::system_clock::TimePoint& challengeTp,
                  size_t remainingTries, time::seconds remainingTime, JsonSection&& challengeSecrets,
@@ -97,7 +97,7 @@
 operator<<(std::ostream& os, const CaState& request)
 {
   os << "Request's CA name: " << request.m_caPrefix << "\n";
-  os << "Request's request ID: " << request.m_requestId << "\n";
+  os << "Request's request ID: " << toHex(request.m_requestId.data(), request.m_requestId.size()) << "\n";
   os << "Request's status: " << statusToString(request.m_status) << "\n";
   os << "Request's challenge type: " << request.m_challengeType << "\n";
   if (request.m_challengeState) {
diff --git a/src/detail/ca-state.hpp b/src/detail/ca-state.hpp
index 9f30b6d..897d98d 100644
--- a/src/detail/ca-state.hpp
+++ b/src/detail/ca-state.hpp
@@ -22,10 +22,13 @@
 #define NDNCERT_CA_STATE_HPP
 
 #include "detail/ndncert-common.hpp"
+#include <array>
 
 namespace ndn {
 namespace ndncert {
 
+typedef std::array<uint8_t, 8> RequestID;
+
 // NDNCERT Request status enumeration
 enum class Status : uint16_t {
   BEFORE_CHALLENGE = 0,
@@ -65,9 +68,9 @@
 {
 public:
   CaState();
-  CaState(const Name& caName, const std::string& requestId, RequestType requestType, Status status,
+  CaState(const Name& caName, const RequestID& requestId, RequestType requestType, Status status,
           const security::Certificate& cert, Block m_encryptionKey, uint32_t aesBlockCounter = 0);
-  CaState(const Name& caName, const std::string& requestId, RequestType requestType, Status status,
+  CaState(const Name& caName, const RequestID& requestId, RequestType requestType, Status status,
           const security::Certificate& cert, const std::string& challengeType,
           const std::string& challengeStatus, const time::system_clock::TimePoint& challengeTp,
           size_t remainingTries, time::seconds remainingTime, JsonSection&& challengeSecrets,
@@ -75,7 +78,7 @@
 
 public:
   Name m_caPrefix;
-  std::string m_requestId;
+  RequestID m_requestId;
   RequestType m_requestType;
   Status m_status;
   security::Certificate m_cert;
diff --git a/src/detail/ca-storage.hpp b/src/detail/ca-storage.hpp
index 70a0ac9..b5c2ce7 100644
--- a/src/detail/ca-storage.hpp
+++ b/src/detail/ca-storage.hpp
@@ -33,7 +33,7 @@
    * @throw if request cannot be fetched from underlying data storage
    */
   virtual CaState
-  getRequest(const std::string& requestId) = 0;
+  getRequest(const RequestID& requestId) = 0;
 
   /**
    * @throw if there is an existing request with the same request ID
@@ -45,7 +45,7 @@
   updateRequest(const CaState& request) = 0;
 
   virtual void
-  deleteRequest(const std::string& requestId) = 0;
+  deleteRequest(const RequestID& requestId) = 0;
 
   virtual std::list<CaState>
   listAllRequests() = 0;
diff --git a/src/detail/new-renew-revoke-encoder.cpp b/src/detail/new-renew-revoke-encoder.cpp
index 3afe2ad..ef67146 100644
--- a/src/detail/new-renew-revoke-encoder.cpp
+++ b/src/detail/new-renew-revoke-encoder.cpp
@@ -55,7 +55,8 @@
 
 void
 NewRenewRevokeEncoder::decodeApplicationParameters(const Block& payload, RequestType requestType, std::string& ecdhPub,
-                                              shared_ptr<security::Certificate>& clientCert) {
+                                                   shared_ptr<security::Certificate>& clientCert)
+{
   payload.parse();
 
   ecdhPub = readString(payload.get(tlv::EcdhPub));
@@ -74,13 +75,13 @@
 
 Block
 NewRenewRevokeEncoder::encodeDataContent(const std::string& ecdhKey, const std::string& salt,
-                                    const CaState& request,
-                                    const std::list<std::string>& challenges)
+                                         const CaState& request,
+                                         const std::list<std::string>& challenges)
 {
   Block response = makeEmptyBlock(ndn::tlv::Content);
   response.push_back(makeStringBlock(tlv::EcdhPub, ecdhKey));
   response.push_back(makeStringBlock(tlv::Salt, salt));
-  response.push_back(makeStringBlock(tlv::RequestId, request.m_requestId));
+  response.push_back(makeBinaryBlock(tlv::RequestId, request.m_requestId.data(), request.m_requestId.size()));
   response.push_back(makeNonNegativeIntegerBlock(tlv::Status, static_cast<size_t>(request.m_status)));
   for (const auto& entry: challenges) {
     response.push_back(makeStringBlock(tlv::Challenge, entry));
@@ -97,7 +98,8 @@
   const auto& salt = readString(content.get(tlv::Salt));
   uint64_t saltInt = std::stoull(salt);
   const auto& requestStatus = static_cast<Status>(readNonNegativeInteger(content.get(tlv::Status)));
-  const auto& requestId = readString(content.get(tlv::RequestId));
+  RequestID requestId;
+  std::memcpy(requestId.data(), content.get(tlv::RequestId).value(), content.get(tlv::RequestId).size());
   std::list<std::string> challenges;
   for (auto const& element : content.elements()) {
     if (element.type() == tlv::Challenge) {
diff --git a/src/detail/new-renew-revoke-encoder.hpp b/src/detail/new-renew-revoke-encoder.hpp
index 70e69aa..8b083d6 100644
--- a/src/detail/new-renew-revoke-encoder.hpp
+++ b/src/detail/new-renew-revoke-encoder.hpp
@@ -37,12 +37,13 @@
 
   static Block
   encodeDataContent(const std::string& ecdhKey, const std::string& salt,
-                             const CaState& request,
-                             const std::list<std::string>& challenges);
+                    const CaState& request,
+                    const std::list<std::string>& challenges);
+
   struct DecodedData {
     std::string ecdhKey;
     uint64_t salt;
-    std::string requestId;
+    RequestID requestId;
     Status requestStatus;
     std::list<std::string> challenges;
   };
diff --git a/src/identity-challenge/challenge-credential.cpp b/src/identity-challenge/challenge-credential.cpp
index 3ad014a..da47469 100644
--- a/src/identity-challenge/challenge-credential.cpp
+++ b/src/identity-challenge/challenge-credential.cpp
@@ -112,12 +112,11 @@
   for (auto anchor : m_trustAnchors) {
     if (anchor.getKeyName() == signingKeyName) {
       if (security::verifySignature(credential, anchor) &&
-          security::verifySignature((uint8_t*)request.m_requestId.c_str(), request.m_requestId.size(), signature, signatureLen, key)) {
+          security::verifySignature(request.m_requestId.data(), request.m_requestId.size(), signature, signatureLen, key)) {
         return returnWithSuccess(request);
       }
     }
   }
-
   NDN_LOG_TRACE("Cannot verify the proof of private key against credential");
   return returnWithError(request, ErrorCode::INVALID_PARAMETER, "Cannot verify the proof of private key against credential.");
 }
@@ -173,13 +172,13 @@
 
 void
 ChallengeCredential::fulfillParameters(std::vector<std::tuple<std::string, std::string>>& params,
-                                       KeyChain& keyChain, const Name& issuedCertName, const std::string& requestId)
+                                       KeyChain& keyChain, const Name& issuedCertName, const RequestID& requestId)
 {
   auto& pib = keyChain.getPib();
   auto id = pib.getIdentity(security::extractIdentityFromCertName(issuedCertName));
   auto issuedCert = id.getKey(security::extractKeyNameFromCertName(issuedCertName)).getCertificate(issuedCertName);
   auto issuedCertTlv = issuedCert.wireEncode();
-  auto signatureTlv = keyChain.sign((uint8_t*)requestId.c_str(), requestId.length(), security::signingByCertificate(issuedCertName));
+  auto signatureTlv = keyChain.sign(requestId.data(), requestId.size(), security::signingByCertificate(issuedCertName));
   for (auto& item : params) {
     if (std::get<0>(item) == PARAMETER_KEY_CREDENTIAL_CERT) {
       std::get<1>(item) = std::string((char*)issuedCertTlv.wire(), issuedCertTlv.size());
diff --git a/src/identity-challenge/challenge-credential.hpp b/src/identity-challenge/challenge-credential.hpp
index 49670f6..0a80a17 100644
--- a/src/identity-challenge/challenge-credential.hpp
+++ b/src/identity-challenge/challenge-credential.hpp
@@ -65,7 +65,7 @@
 
   static void
   fulfillParameters(std::vector<std::tuple<std::string, std::string>>& params,
-                    KeyChain& keyChain, const Name& issuedCertName, const std::string& requestId);
+                    KeyChain& keyChain, const Name& issuedCertName, const RequestID& requestId);
 
   // challenge parameters
   static const std::string PARAMETER_KEY_CREDENTIAL_CERT;
diff --git a/src/identity-challenge/challenge-email.cpp b/src/identity-challenge/challenge-email.cpp
index 0c65c69..cc141dc 100644
--- a/src/identity-challenge/challenge-email.cpp
+++ b/src/identity-challenge/challenge-email.cpp
@@ -62,7 +62,7 @@
     secretJson.add(PARAMETER_KEY_CODE, emailCode);
     // send out the email
     sendEmail(emailAddress, emailCode, request);
-    NDN_LOG_TRACE("Secret for request " << request.m_requestId << " : " << emailCode);
+    NDN_LOG_TRACE("Secret for request " << toHex(request.m_requestId.data(), request.m_requestId.size())  << " : " << emailCode);
     return returnWithNewChallengeStatus(request, NEED_CODE, std::move(secretJson), m_maxAttemptTimes, m_secretLifetime);
   }
   if (request.m_challengeState) {
diff --git a/src/identity-challenge/challenge-pin.cpp b/src/identity-challenge/challenge-pin.cpp
index fe17cd1..c9f98ba 100644
--- a/src/identity-challenge/challenge-pin.cpp
+++ b/src/identity-challenge/challenge-pin.cpp
@@ -48,7 +48,7 @@
     std::string secretCode = generateSecretCode();
     JsonSection secretJson;
     secretJson.add(PARAMETER_KEY_CODE, secretCode);
-    NDN_LOG_TRACE("Secret for request " << request.m_requestId << " : " << secretCode);
+    NDN_LOG_TRACE("Secret for request " << toHex(request.m_requestId.data(), request.m_requestId.size()) << " : " << secretCode);
     return returnWithNewChallengeStatus(request, NEED_CODE, std::move(secretJson), m_maxAttemptTimes, m_secretLifetime);
   }
   if (request.m_challengeState) {
diff --git a/src/requester-state.hpp b/src/requester-state.hpp
index 73f6737..ffebd8f 100644
--- a/src/requester-state.hpp
+++ b/src/requester-state.hpp
@@ -21,7 +21,7 @@
 #ifndef NDNCERT_REQUESTER_STATE_HPP
 #define NDNCERT_REQUESTER_STATE_HPP
 
-#include "detail/ndncert-common.hpp"
+#include "detail/ca-state.hpp"
 #include "detail/crypto-helper.hpp"
 #include "configuration.hpp"
 
@@ -55,7 +55,7 @@
   /**
    * @brief The CA-generated request ID for the request.
    */
-  std::string m_requestId;
+  RequestID m_requestId;
   /**
    * @brief The current status of the request.
    */
diff --git a/src/requester.cpp b/src/requester.cpp
index 1e503d5..412b7f3 100644
--- a/src/requester.cpp
+++ b/src/requester.cpp
@@ -237,7 +237,7 @@
   auto challengeParams = challenge->genChallengeRequestTLV(state.m_status, state.m_challengeStatus, std::move(parameters));
 
   Name interestName = state.m_caItem.m_caPrefix;
-  interestName.append("CA").append("CHALLENGE").append(state.m_requestId);
+  interestName.append("CA").append("CHALLENGE").append(state.m_requestId.data(), state.m_requestId.size());
   auto interest =std::make_shared<Interest>(interestName);
   interest->setMustBeFresh(true);
   interest->setCanBePrefix(false);
@@ -245,7 +245,7 @@
   // encrypt the Interest parameters
   auto paramBlock = encodeBlockWithAesGcm128(ndn::tlv::ApplicationParameters, state.m_aesKey,
                                              challengeParams.value(), challengeParams.value_size(),
-                                             (const uint8_t*)state.m_requestId.c_str(),
+                                             state.m_requestId.data(),
                                              state.m_requestId.size(),
                                              state.m_aesBlockCounter);
   interest->setApplicationParameters(paramBlock);
@@ -262,7 +262,7 @@
   }
   processIfError(reply);
   auto result = decodeBlockWithAesGcm128(reply.getContent(), state.m_aesKey,
-                                         (const uint8_t*)state.m_requestId.c_str(),
+                                         state.m_requestId.data(),
                                          state.m_requestId.size());
   Block contentTLV = makeBinaryBlock(tlv::EncryptedPayload, result.data(), result.size());
   ChallengeEncoder::decodeDataContent(contentTLV, state);
diff --git a/tests/unit-tests/bench.t.cpp b/tests/unit-tests/bench.t.cpp
index 1fe853b..b5fc5ab 100644
--- a/tests/unit-tests/bench.t.cpp
+++ b/tests/unit-tests/bench.t.cpp
@@ -143,7 +143,7 @@
 
       auto paramList = Requester::selectOrContinueChallenge(state, "pin");
       auto request = ca.getCertificateRequest(*challengeInterest2);
-      auto secret = request.m_challengeState->m_secrets.get(ChallengePin::PARAMETER_KEY_CODE, "");
+      auto secret = request->m_challengeState->m_secrets.get(ChallengePin::PARAMETER_KEY_CODE, "");
       std::get<1>(paramList[0]) = secret;
       challengeInterest3 = Requester::genChallengeInterest(state, std::move(paramList));
       std::cout << "CHALLENGE Interest Size: " << challengeInterest3->wireEncode().size() << std::endl;
diff --git a/tests/unit-tests/ca-memory.t.cpp b/tests/unit-tests/ca-memory.t.cpp
index 0dcbd03..9774610 100644
--- a/tests/unit-tests/ca-memory.t.cpp
+++ b/tests/unit-tests/ca-memory.t.cpp
@@ -37,11 +37,12 @@
   auto cert1 = key1.getDefaultCertificate();
 
   // add operation
-  CaState request1(Name("/ndn/site1"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, cert1, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request1(Name("/ndn/site1"), requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, cert1, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
   BOOST_CHECK_NO_THROW(storage.addRequest(request1));
 
   // get operation
-  auto result = storage.getRequest("123");
+  auto result = storage.getRequest(requestId);
   BOOST_CHECK_EQUAL(request1.m_cert, result.m_cert);
   BOOST_CHECK(request1.m_status == result.m_status);
   BOOST_CHECK_EQUAL(request1.m_caPrefix, result.m_caPrefix);
@@ -51,11 +52,11 @@
   json.put("code", "1234");
 
   // update operation
-  CaState request2(Name("/ndn/site1"), "123", RequestType::NEW, Status::CHALLENGE, cert1,
+  CaState request2(Name("/ndn/site1"), requestId, RequestType::NEW, Status::CHALLENGE, cert1,
                    "email", "test", time::system_clock::now(), 3, time::seconds(3600),
                    std::move(json), makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"), 0);
   storage.updateRequest(request2);
-  result = storage.getRequest("123");
+  result = storage.getRequest(requestId);
   BOOST_CHECK_EQUAL(request2.m_cert, result.m_cert);
   BOOST_CHECK(request2.m_status == result.m_status);
   BOOST_CHECK_EQUAL(request2.m_caPrefix, result.m_caPrefix);
@@ -63,14 +64,15 @@
   auto identity2 = addIdentity(Name("/ndn/site2"));
   auto key2 = identity2.getDefaultKey();
   auto cert2 = key2.getDefaultCertificate();
-  CaState request3(Name("/ndn/site2"), "456", RequestType::NEW, Status::BEFORE_CHALLENGE, cert2, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
+  RequestID requestId2 = {8,7,6,5,4,3,2,1};
+  CaState request3(Name("/ndn/site2"), requestId2, RequestType::NEW, Status::BEFORE_CHALLENGE, cert2, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
   storage.addRequest(request3);
 
   // list operation
   auto allRequests = storage.listAllRequests();
   BOOST_CHECK_EQUAL(allRequests.size(), 2);
 
-  storage.deleteRequest("456");
+  storage.deleteRequest(requestId2);
   allRequests = storage.listAllRequests();
   BOOST_CHECK_EQUAL(allRequests.size(), 1);
 }
diff --git a/tests/unit-tests/ca-module.t.cpp b/tests/unit-tests/ca-module.t.cpp
index 1dd39f4..ff2dcd3 100644
--- a/tests/unit-tests/ca-module.t.cpp
+++ b/tests/unit-tests/ca-module.t.cpp
@@ -255,7 +255,9 @@
     BOOST_CHECK(challengeBlockCount != 0);
 
     auto challengeList = Requester::onNewRenewRevokeResponse(state, response);
-    auto ca_encryption_key = ca.getCaStorage()->getRequest(readString(contentBlock.get(tlv::RequestId))).m_encryptionKey;
+    RequestID requestId;
+    std::memcpy(requestId.data(), contentBlock.get(tlv::RequestId).value(), contentBlock.get(tlv::RequestId).value_size());
+    auto ca_encryption_key = ca.getCaStorage()->getRequest(requestId).m_encryptionKey;
     BOOST_CHECK_EQUAL_COLLECTIONS(state.m_aesKey, state.m_aesKey + sizeof(state.m_aesKey),
                                   ca_encryption_key.value(), ca_encryption_key.value() + ca_encryption_key.value_size());
   });
@@ -418,7 +420,7 @@
 
       auto paramList = Requester::selectOrContinueChallenge(state, "pin");
       auto request = ca.getCertificateRequest(*challengeInterest2);
-      auto secret = request.m_challengeState->m_secrets.get(ChallengePin::PARAMETER_KEY_CODE, "");
+      auto secret = request->m_challengeState->m_secrets.get(ChallengePin::PARAMETER_KEY_CODE, "");
       std::get<1>(paramList[0]) = secret;
       challengeInterest3 = Requester::genChallengeInterest(state, std::move(paramList));
       std::cout << "CHALLENGE Interest Size: " << challengeInterest3->wireEncode().size() << std::endl;
@@ -464,7 +466,8 @@
   signatureInfo.setValidityPeriod(security::ValidityPeriod(time::system_clock::now(),
                                                            time::system_clock::now() + time::hours(10)));
   m_keyChain.sign(clientCert, signingByKey(clientKey.getName()).setSignatureInfo(signatureInfo));
-  CaState certRequest(Name("/ndn"), "122", RequestType::NEW, Status::SUCCESS, clientCert, makeEmptyBlock(ndn::tlv::ContentType_Key));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState certRequest(Name("/ndn"), requestId, RequestType::NEW, Status::SUCCESS, clientCert, makeEmptyBlock(ndn::tlv::ContentType_Key));
   auto issuedCert = ca.issueCertificate(certRequest);
 
   CaProfile item;
@@ -495,7 +498,9 @@
     BOOST_CHECK(challengeBlockCount != 0);
 
     auto challengeList = Requester::onNewRenewRevokeResponse(state, response);
-    auto ca_encryption_key = ca.getCaStorage()->getRequest(readString(contentBlock.get(tlv::RequestId))).m_encryptionKey;
+    RequestID requestId;
+    std::memcpy(requestId.data(), contentBlock.get(tlv::RequestId).value(), contentBlock.get(tlv::RequestId).value_size());
+    auto ca_encryption_key = ca.getCaStorage()->getRequest(requestId).m_encryptionKey;
     BOOST_CHECK_EQUAL_COLLECTIONS(state.m_aesKey, state.m_aesKey + sizeof(state.m_aesKey),
                                   ca_encryption_key.value(), ca_encryption_key.value() + ca_encryption_key.value_size());
   });
diff --git a/tests/unit-tests/ca-sqlite.t.cpp b/tests/unit-tests/ca-sqlite.t.cpp
index 9bdc30e..a2c0542 100644
--- a/tests/unit-tests/ca-sqlite.t.cpp
+++ b/tests/unit-tests/ca-sqlite.t.cpp
@@ -36,11 +36,12 @@
   auto cert1 = key1.getDefaultCertificate();
 
   // add operation
-  CaState request1(Name("/ndn/site1"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, cert1, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request1(Name("/ndn/site1"), requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, cert1, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
   storage.addRequest(request1);
 
   // get operation
-  auto result = storage.getRequest("123");
+  auto result = storage.getRequest(requestId);
   BOOST_CHECK_EQUAL(request1.m_cert, result.m_cert);
   BOOST_CHECK(request1.m_status == result.m_status);
   BOOST_CHECK_EQUAL(request1.m_caPrefix, result.m_caPrefix);
@@ -49,11 +50,11 @@
   // update operation
   JsonSection json;
   json.put("test", "4567");
-  CaState request2(Name("/ndn/site1"), "123", RequestType::NEW, Status::CHALLENGE, cert1,
+  CaState request2(Name("/ndn/site1"), requestId, RequestType::NEW, Status::CHALLENGE, cert1,
                    "email", "test", time::system_clock::now(), 3, time::seconds(3600),
                   std::move(json), makeEmptyBlock(ndn::tlv::ContentType_Key), 0);
   storage.updateRequest(request2);
-  result = storage.getRequest("123");
+  result = storage.getRequest(requestId);
   BOOST_CHECK_EQUAL(request2.m_cert, result.m_cert);
   BOOST_CHECK(request2.m_status == result.m_status);
   BOOST_CHECK_EQUAL(request2.m_caPrefix, result.m_caPrefix);
@@ -61,18 +62,19 @@
   auto identity2 = addIdentity(Name("/ndn/site2"));
   auto key2 = identity2.getDefaultKey();
   auto cert2 = key2.getDefaultCertificate();
-  CaState request3(Name("/ndn/site2"), "456", RequestType::NEW, Status::BEFORE_CHALLENGE, cert2, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
+  RequestID requestId2 = {8,7,6,5,4,3,2,1};
+  CaState request3(Name("/ndn/site2"), requestId2, RequestType::NEW, Status::BEFORE_CHALLENGE, cert2, makeStringBlock(ndn::tlv::ContentType_Key, "PretendItIsAKey"));
   storage.addRequest(request3);
 
   // list operation
   auto allRequests = storage.listAllRequests();
   BOOST_CHECK_EQUAL(allRequests.size(), 2);
 
-  storage.deleteRequest("456");
+  storage.deleteRequest(requestId2);
   allRequests = storage.listAllRequests();
   BOOST_CHECK_EQUAL(allRequests.size(), 1);
 
-  storage.deleteRequest("123");
+  storage.deleteRequest(requestId);
   allRequests = storage.listAllRequests();
   BOOST_CHECK_EQUAL(allRequests.size(), 0);
 }
@@ -86,7 +88,8 @@
     auto cert1 = key1.getDefaultCertificate();
 
     // add operation
-    CaState request1(Name("/ndn/site1"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, cert1, makeEmptyBlock(ndn::tlv::ContentType_Key));
+    RequestID requestId = {1,2,3,4,5,6,7,8};
+    CaState request1(Name("/ndn/site1"),requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, cert1, makeEmptyBlock(ndn::tlv::ContentType_Key));
     BOOST_CHECK_NO_THROW(storage.addRequest(request1));
     // add again
     BOOST_CHECK_THROW(storage.addRequest(request1), std::runtime_error);
diff --git a/tests/unit-tests/challenge-credential.t.cpp b/tests/unit-tests/challenge-credential.t.cpp
index efe956b..00333ab 100644
--- a/tests/unit-tests/challenge-credential.t.cpp
+++ b/tests/unit-tests/challenge-credential.t.cpp
@@ -53,7 +53,8 @@
   auto identityA = addIdentity(Name("/example"));
   auto keyA = identityA.getDefaultKey();
   auto certA = key.getDefaultCertificate();
-  CaState state(Name("/example"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, certA, makeEmptyBlock(ndn::tlv::ContentType_Key));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState state(Name("/example"), requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, certA, makeEmptyBlock(ndn::tlv::ContentType_Key));
 
   // create requester's credential
   auto identityB = addIdentity(Name("/trust/cert"));
@@ -69,7 +70,7 @@
 
   // using private key to sign cert request
   auto params = challenge.getRequestedParameterList(state.m_status, "");
-  ChallengeCredential::fulfillParameters(params, m_keyChain, credential.getName(), "123");
+  ChallengeCredential::fulfillParameters(params, m_keyChain, credential.getName(), requestId);
   Block paramsTlv = challenge.genChallengeRequestTLV(state.m_status, "", std::move(params));
   challenge.handleChallengeRequest(paramsTlv, state);
   BOOST_CHECK_EQUAL(statusToString(state.m_status), statusToString(Status::PENDING));
diff --git a/tests/unit-tests/challenge-email.t.cpp b/tests/unit-tests/challenge-email.t.cpp
index b73d22e..3435a00 100644
--- a/tests/unit-tests/challenge-email.t.cpp
+++ b/tests/unit-tests/challenge-email.t.cpp
@@ -45,7 +45,8 @@
   auto identity = addIdentity(Name("/ndn/site1"));
   auto key = identity.getDefaultKey();
   auto cert = key.getDefaultCertificate();
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, cert, makeEmptyBlock(ndn::tlv::ContentType_Key));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, cert, makeEmptyBlock(ndn::tlv::ContentType_Key));
 
   Block paramTLV = makeEmptyBlock(tlv::EncryptedPayload);
   paramTLV.push_back(makeStringBlock(tlv::ParameterKey, ChallengeEmail::PARAMETER_KEY_EMAIL));
@@ -94,7 +95,8 @@
   auto identity = addIdentity(Name("/ndn/site1"));
   auto key = identity.getDefaultKey();
   auto cert = key.getDefaultCertificate();
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, cert, makeEmptyBlock(ndn::tlv::ContentType_Key));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, cert, makeEmptyBlock(ndn::tlv::ContentType_Key));
 
   Block paramTLV = makeEmptyBlock(tlv::EncryptedPayload);
   paramTLV.push_back(makeStringBlock(tlv::ParameterKey, ChallengeEmail::PARAMETER_KEY_EMAIL));
@@ -115,7 +117,8 @@
   auto cert = key.getDefaultCertificate();
   JsonSection json;
   json.put(ChallengeEmail::PARAMETER_KEY_CODE, "4567");
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::CHALLENGE, cert,
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::CHALLENGE, cert,
                   "email", ChallengeEmail::NEED_CODE, time::system_clock::now(),
                   3, time::seconds(3600), std::move(json), makeEmptyBlock(ndn::tlv::ContentType_Key), 0);
 
@@ -137,7 +140,8 @@
   auto cert = key.getDefaultCertificate();
   JsonSection json;
   json.put(ChallengeEmail::PARAMETER_KEY_CODE, "4567");
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::CHALLENGE, cert,
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::CHALLENGE, cert,
                   "email", ChallengeEmail::NEED_CODE, time::system_clock::now(),
                   3, time::seconds(3600), std::move(json), makeEmptyBlock(ndn::tlv::ContentType_Key), 0);
 
diff --git a/tests/unit-tests/challenge-pin.t.cpp b/tests/unit-tests/challenge-pin.t.cpp
index fd61bef..772bc2e 100644
--- a/tests/unit-tests/challenge-pin.t.cpp
+++ b/tests/unit-tests/challenge-pin.t.cpp
@@ -38,7 +38,8 @@
   auto identity = addIdentity(Name("/ndn/site1"));
   auto key = identity.getDefaultKey();
   auto cert = key.getDefaultCertificate();
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::BEFORE_CHALLENGE, cert, makeEmptyBlock(ndn::tlv::ContentType_Key));
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::BEFORE_CHALLENGE, cert, makeEmptyBlock(ndn::tlv::ContentType_Key));
 
   ChallengePin challenge;
   challenge.handleChallengeRequest(makeEmptyBlock(tlv::EncryptedPayload), request);
@@ -55,7 +56,8 @@
   auto cert = key.getDefaultCertificate();
   JsonSection secret;
   secret.add(ChallengePin::PARAMETER_KEY_CODE, "12345");
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::CHALLENGE, cert,
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::CHALLENGE, cert,
                   "pin", ChallengePin::NEED_CODE, time::system_clock::now(),
                   3, time::seconds(3600), std::move(secret), makeEmptyBlock(ndn::tlv::ContentType_Key), 0);
 
@@ -77,7 +79,8 @@
   auto cert = key.getDefaultCertificate();
   JsonSection secret;
   secret.add(ChallengePin::PARAMETER_KEY_CODE, "12345");
-  CaState request(Name("/ndn/site1"), "123", RequestType::NEW, Status::CHALLENGE, cert,
+  RequestID requestId = {1,2,3,4,5,6,7,8};
+  CaState request(Name("/ndn/site1"), requestId, RequestType::NEW, Status::CHALLENGE, cert,
                   "pin", ChallengePin::NEED_CODE, time::system_clock::now(),
                   3, time::seconds(3600), std::move(secret), makeEmptyBlock(ndn::tlv::ContentType_Key), 0);
 
diff --git a/tests/unit-tests/protocol-detail.t.cpp b/tests/unit-tests/protocol-detail.t.cpp
index 6157d61..e3aa143 100644
--- a/tests/unit-tests/protocol-detail.t.cpp
+++ b/tests/unit-tests/protocol-detail.t.cpp
@@ -70,6 +70,32 @@
   BOOST_CHECK_EQUAL(decodedRedirectionItems[0], config.m_redirection->at(0)->getFullName());
 }
 
+BOOST_AUTO_TEST_CASE(TestNewRenewRevoke)
+{
+  auto identity = addIdentity(Name("/ndn"));
+  auto key = identity.getDefaultKey();
+  auto cert = key.getDefaultCertificate();
+
+  ECDHState ecdhState;
+  auto block = NewRenewRevokeEncoder::encodeApplicationParameters(RequestType::NEW,
+                                                                  ecdhState.getBase64PubKey(),
+                                                                  cert);
+  std::string ecdhPub;
+  shared_ptr<security::Certificate> clientCert;
+  NewRenewRevokeEncoder::decodeApplicationParameters(block, RequestType::NEW, ecdhPub, clientCert);
+  BOOST_CHECK_EQUAL(ecdhState.getBase64PubKey(), ecdhPub);
+  BOOST_CHECK_EQUAL(cert, *clientCert);
+
+  block = NewRenewRevokeEncoder::encodeApplicationParameters(RequestType::REVOKE,
+                                                             ecdhState.getBase64PubKey(),
+                                                             cert);
+  NewRenewRevokeEncoder::decodeApplicationParameters(block, RequestType::REVOKE, ecdhPub, clientCert);
+  BOOST_CHECK_EQUAL(ecdhState.getBase64PubKey(), ecdhPub);
+  BOOST_CHECK_EQUAL(cert, *clientCert);
+
+  // NewRenewRevokeEncoder::encodeDataContent(ecdhState.getBase64PubKey(), "")
+}
+
 BOOST_AUTO_TEST_SUITE_END() // TestProtocolDetail
 
 } // namespace tests