diff --git a/services/tunnelbroker/src/Amqp/AmqpManager.cpp b/services/tunnelbroker/src/Amqp/AmqpManager.cpp
index b1081ccc9..2f1373ff4 100644
--- a/services/tunnelbroker/src/Amqp/AmqpManager.cpp
+++ b/services/tunnelbroker/src/Amqp/AmqpManager.cpp
@@ -1,144 +1,143 @@
 #include "AmqpManager.h"
 #include "ConfigManager.h"
 #include "Constants.h"
 #include "DeliveryBroker.h"
 #include "GlobalTools.h"
-#include "Tools.h"
 
 #include <glog/logging.h>
 
 #include <uv.h>
 
 namespace comm {
 namespace network {
 
 AmqpManager &AmqpManager::getInstance() {
   static AmqpManager instance;
   return instance;
 }
 
 void AmqpManager::connectInternal() {
   const std::string amqpUri = config::ConfigManager::getInstance().getParameter(
       config::ConfigManager::OPTION_AMQP_URI);
   const std::string tunnelbrokerID =
       config::ConfigManager::getInstance().getParameter(
           config::ConfigManager::OPTION_TUNNELBROKER_ID);
   const std::string fanoutExchangeName =
       config::ConfigManager::getInstance().getParameter(
           config::ConfigManager::OPTION_AMQP_FANOUT_EXCHANGE);
   LOG(INFO) << "AMQP: Connecting to " << amqpUri;
 
   auto *loop = uv_default_loop();
   AMQP::LibUvHandler handler(loop);
   AMQP::TcpConnection connection(&handler, AMQP::Address(amqpUri));
 
   this->amqpChannel = std::make_unique<AMQP::TcpChannel>(&connection);
   this->amqpChannel->onError([this](const char *message) {
     LOG(ERROR) << "AMQP: channel error: " << message
                << ", will try to reconnect";
     this->amqpReady = false;
   });
 
   AMQP::Table arguments;
   arguments["x-message-ttl"] = (uint64_t)AMQP_MESSAGE_TTL;
   arguments["x-expires"] = (uint64_t)AMQP_QUEUE_TTL;
   this->amqpChannel->declareExchange(fanoutExchangeName, AMQP::fanout);
   this->amqpChannel->declareQueue(tunnelbrokerID, AMQP::durable, arguments)
       .onSuccess([this, tunnelbrokerID, fanoutExchangeName](
                      const std::string &name,
                      uint32_t messagecount,
                      uint32_t consumercount) {
         LOG(INFO) << "AMQP: Queue " << name << " created";
         this->amqpChannel->bindQueue(fanoutExchangeName, tunnelbrokerID, "")
             .onError([this, tunnelbrokerID, fanoutExchangeName](
                          const char *message) {
               LOG(ERROR) << "AMQP: Failed to bind queue:  " << tunnelbrokerID
                          << " to exchange: " << fanoutExchangeName;
               this->amqpReady = false;
             });
         this->amqpReady = true;
         this->amqpChannel->consume(tunnelbrokerID)
             .onReceived([](const AMQP::Message &message,
                            uint64_t deliveryTag,
                            bool redelivered) {
               try {
                 AMQP::Table headers = message.headers();
                 const std::string payload(message.body(), message.bodySize());
                 const std::string messageID(headers[AMQP_HEADER_MESSAGEID]);
                 const std::string toDeviceID(headers[AMQP_HEADER_TO_DEVICEID]);
                 const std::string fromDeviceID(
                     headers[AMQP_HEADER_FROM_DEVICEID]);
                 LOG(INFO) << "AMQP: Message consumed for deviceID: "
                           << toDeviceID;
                 DeliveryBroker::getInstance().push(
                     messageID, deliveryTag, toDeviceID, fromDeviceID, payload);
               } catch (const std::exception &e) {
                 LOG(ERROR) << "AMQP: Message parsing exception: " << e.what();
               }
             })
             .onError([](const char *message) {
               LOG(ERROR) << "AMQP: Error on message consume:  " << message;
             });
       })
       .onError([](const char *message) {
         throw std::runtime_error(
             "AMQP: Queue creation error: " + std::string(message));
       });
   uv_run(loop, UV_RUN_DEFAULT);
 };
 
 void AmqpManager::connect() {
   while (true) {
     int64_t currentTimestamp = tools::getCurrentTimestamp();
     if (this->lastConnectionTimestamp &&
         currentTimestamp - this->lastConnectionTimestamp <
             AMQP_SHORTEST_RECONNECTION_ATTEMPT_INTERVAL) {
       throw std::runtime_error(
           "AMQP reconnection attempt interval too short, tried to reconnect "
           "after " +
           std::to_string(currentTimestamp - this->lastConnectionTimestamp) +
           "ms, the shortest allowed interval is " +
           std::to_string(AMQP_SHORTEST_RECONNECTION_ATTEMPT_INTERVAL) + "ms");
     }
     this->lastConnectionTimestamp = currentTimestamp;
     this->connectInternal();
   }
 }
 
 bool AmqpManager::send(const database::MessageItem *message) {
   if (!this->amqpReady) {
     LOG(ERROR) << "AMQP: Message send error: channel not ready";
     return false;
   }
   try {
     const std::string messagePayload = message->getPayload();
     AMQP::Envelope env(messagePayload.c_str(), messagePayload.size());
     AMQP::Table headers;
     headers[AMQP_HEADER_MESSAGEID] = message->getMessageID();
     headers[AMQP_HEADER_FROM_DEVICEID] = message->getFromDeviceID();
     headers[AMQP_HEADER_TO_DEVICEID] = message->getToDeviceID();
     // Set delivery mode to: Durable (2)
     env.setDeliveryMode(2);
     env.setHeaders(std::move(headers));
     this->amqpChannel->publish(
         config::ConfigManager::getInstance().getParameter(
             config::ConfigManager::OPTION_AMQP_FANOUT_EXCHANGE),
         "",
         env);
   } catch (std::runtime_error &e) {
     LOG(ERROR) << "AMQP: Error while publishing message:  " << e.what();
     return false;
   }
   return true;
 };
 
 void AmqpManager::ack(uint64_t deliveryTag) {
   if (!this->amqpReady) {
     LOG(ERROR) << "AMQP: Message ACK error: channel not ready";
     return;
   }
   this->amqpChannel->ack(deliveryTag);
 }
 
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Tools/CryptoTools.cpp b/services/tunnelbroker/src/Tools/CryptoTools.cpp
index b702c7290..ef3d766a2 100644
--- a/services/tunnelbroker/src/Tools/CryptoTools.cpp
+++ b/services/tunnelbroker/src/Tools/CryptoTools.cpp
@@ -1,45 +1,42 @@
 #include "CryptoTools.h"
 
 #include <cryptopp/base64.h>
-#include <cryptopp/cryptlib.h>
 #include <cryptopp/filters.h>
-#include <cryptopp/modes.h>
-#include <cryptopp/pssr.h>
 #include <cryptopp/rsa.h>
 #include <glog/logging.h>
 
 namespace comm {
 namespace network {
 namespace crypto {
 
 bool rsaVerifyString(
     const std::string &publicKeyBase64,
     const std::string &message,
     const std::string &signatureBase64) {
   CryptoPP::RSA::PublicKey publicKey;
   std::string decodedSignature;
   try {
     publicKey.Load(CryptoPP::StringSource(
                        publicKeyBase64, true, new CryptoPP::Base64Decoder())
                        .Ref());
     CryptoPP::StringSource stringSource(
         signatureBase64,
         true,
         new CryptoPP::Base64Decoder(
             new CryptoPP::StringSink(decodedSignature)));
     CryptoPP::RSASSA_PKCS1v15_SHA_Verifier verifierSha256(publicKey);
     return verifierSha256.VerifyMessage(
         reinterpret_cast<const unsigned char *>(message.c_str()),
         message.length(),
         reinterpret_cast<const unsigned char *>(decodedSignature.c_str()),
         decodedSignature.length());
   } catch (const std::exception &e) {
     LOG(ERROR) << "CryptoTools: "
                << "Got an exception " << e.what();
     return false;
   }
 }
 
 } // namespace crypto
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Tools/Tools.cpp b/services/tunnelbroker/src/Tools/Tools.cpp
index 576fa3711..9da825d0f 100644
--- a/services/tunnelbroker/src/Tools/Tools.cpp
+++ b/services/tunnelbroker/src/Tools/Tools.cpp
@@ -1,71 +1,70 @@
 #include "Tools.h"
 #include "ConfigManager.h"
 #include "Constants.h"
 
 #include <glog/logging.h>
-#include <boost/lexical_cast.hpp>
 
 #include <chrono>
 #include <random>
 #include <regex>
 
 namespace comm {
 namespace network {
 namespace tools {
 
 std::string generateRandomString(std::size_t length) {
   const std::string CHARACTERS =
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
   thread_local std::random_device generator;
   std::uniform_int_distribution<> distribution(0, CHARACTERS.size() - 1);
   std::string random_string;
   for (std::size_t i = 0; i < length; ++i) {
     random_string += CHARACTERS[distribution(generator)];
   }
   return random_string;
 }
 
 bool validateDeviceID(std::string deviceID) {
   try {
     static const std::regex deviceIDKeyserverRegexp("^ks:.*");
     if (std::regex_match(deviceID, deviceIDKeyserverRegexp)) {
       return (
           deviceID ==
           config::ConfigManager::getInstance().getParameter(
               config::ConfigManager::OPTION_DEFAULT_KEYSERVER_ID));
     }
     return std::regex_match(deviceID, DEVICEID_FORMAT_REGEX);
   } catch (const std::exception &e) {
     LOG(ERROR) << "Tools: "
                << "Got an exception at `validateDeviceID`: " << e.what();
     return false;
   }
 }
 
 bool validateSessionID(std::string sessionID) {
   try {
     return std::regex_match(sessionID, SESSION_ID_FORMAT_REGEX);
   } catch (const std::exception &e) {
     LOG(ERROR) << "Tools: "
                << "Got an exception at `validateSessionId`: " << e.what();
     return false;
   }
 }
 
 void checkIfNotEmpty(std::string fieldName, std::string stringToCheck) {
   if (stringToCheck.empty()) {
     throw std::runtime_error(
         "Error: Required text field " + fieldName + " is empty.");
   }
 }
 
 void checkIfNotZero(std::string fieldName, uint64_t numberToCheck) {
   if (numberToCheck == 0) {
     throw std::runtime_error(
         "Error: Required number " + fieldName + " is zero.");
   }
 }
 
 } // namespace tools
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/server.cpp b/services/tunnelbroker/src/server.cpp
index 9312a4aa4..cde07b943 100644
--- a/services/tunnelbroker/src/server.cpp
+++ b/services/tunnelbroker/src/server.cpp
@@ -1,50 +1,49 @@
 #include "AmqpManager.h"
 #include "ConfigManager.h"
-#include "Constants.h"
 #include "GlobalTools.h"
 #include "TunnelbrokerServiceImpl.h"
 
 #include "GlobalConstants.h"
 
 #include <glog/logging.h>
 #include <grpcpp/grpcpp.h>
 
 #include <string>
 #include <thread>
 
 namespace comm {
 namespace network {
 
 void RunServer() {
   TunnelBrokerServiceImpl service;
   grpc::EnableDefaultHealthCheckService(true);
   grpc::ServerBuilder builder;
   // Listen on the given address without any authentication mechanism.
   builder.AddListeningPort(
       SERVER_LISTEN_ADDRESS, grpc::InsecureServerCredentials());
   // Register "service" as the instance through which we'll communicate with
   // clients. In this case it corresponds to an *synchronous* service.
   builder.RegisterService(&service);
   std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
   LOG(INFO) << "server listening at :" << SERVER_LISTEN_ADDRESS;
   // Wait for the server to shutdown. Note that some other thread must be
   // responsible for shutting down the server for this call to ever return.
   server->Wait();
 }
 
 void RunAmqpClient() {
   AmqpManager::getInstance().connect();
 }
 
 } // namespace network
 } // namespace comm
 
 int main(int argc, char **argv) {
   comm::network::tools::InitLogging("tunnelbroker");
   comm::network::config::ConfigManager::getInstance().load();
   std::thread amqpThread(comm::network::RunAmqpClient);
   std::thread grpcThread(comm::network::RunServer);
   amqpThread.join();
   grpcThread.join();
   return 0;
 }