Botan::Roughtime Namespace Reference

Classes
class	Chain
class	Link
class	Nonce
class	Response
class	Roughtime_Error
struct	Server_Information

Functions
std::array< uint8_t, request_min_size >	encode_request (const Nonce &nonce)
Nonce	nonce_from_blind (const std::vector< uint8_t > &previous_response, const Nonce &blind)
std::vector< uint8_t >	online_request (std::string_view uri, const Nonce &nonce, std::chrono::milliseconds timeout)
std::vector< Server_Information >	servers_from_str (std::string_view str)

Variables
const unsigned	request_min_size = 1024

Function Documentation

encode_request()

std::array< uint8_t, request_min_size > Botan::Roughtime::encode_request

(

const Nonce &

nonce

)

An Roughtime request.

Parameters

nonce

the nonce to include in the request

Returns

the encoded request

Definition at line 174 of file roughtime.cpp.

                                                                       {
   std::array<uint8_t, request_min_size> buf = {{2, 0, 0, 0, 64, 0, 0, 0, 'N', 'O', 'N', 'C', 'P', 'A', 'D', 0xff}};
   std::memcpy(buf.data() + 16, nonce.get_nonce().data(), nonce.get_nonce().size());
   std::memset(buf.data() + 16 + nonce.get_nonce().size(), 0, buf.size() - 16 - nonce.get_nonce().size());
   return buf;
}

References Botan::Roughtime::Nonce::get_nonce().

Referenced by online_request().

nonce_from_blind()

Nonce Botan::Roughtime::nonce_from_blind	(	const std::vector< uint8_t > &	previous_response,
		const Nonce &	blind )

Derive a nonce from the previous response and a blind

Parameters

previous_response	the raw bytes of the previous response
blind	the blind to use

Returns

the derived nonce

Definition at line 242 of file roughtime.cpp.

                                                                                        {
   std::array<uint8_t, 64> ret{};
   const auto blind_arr = blind.get_nonce();
   auto hash = HashFunction::create_or_throw("SHA-512");
   hash->update(previous_response);
   hash->update(hash->final());
   hash->update(blind_arr.data(), blind_arr.size());
   hash->final(ret.data());
 
   return Nonce(ret);
}

References Botan::HashFunction::create_or_throw(), and Botan::Roughtime::Nonce::get_nonce().

Referenced by Botan::Roughtime::Chain::append(), Botan::Roughtime::Chain::next_nonce(), and Botan::Roughtime::Chain::responses().

online_request()

std::vector< uint8_t > Botan::Roughtime::online_request	(	std::string_view	url,
		const Nonce &	nonce,
		std::chrono::milliseconds	timeout = std::chrono::seconds(3) )

Makes an online Roughtime request via UDP and returns the Roughtime response.

Parameters

url	Roughtime server UDP endpoint (host:port)
nonce	the nonce to send to the server
timeout	a timeout on the UDP request

Returns

Roughtime response

Definition at line 355 of file roughtime.cpp.

                                                                                                         {
   const std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now();
   auto socket = OS::open_socket_udp(uri, timeout);
   if(!socket) {
      throw Not_Implemented("No socket support enabled in build");
   }
 
   const auto encoded = encode_request(nonce);
   socket->write(encoded.data(), encoded.size());
 
   if(std::chrono::system_clock::now() - start_time > timeout) {
      throw System_Error("Timeout during socket write");
   }
 
   std::vector<uint8_t> buffer;
   buffer.resize(360 + 64 * 10 + 1);  //response basic size is 360 bytes + 64 bytes for each level of merkle tree
                                      //add one additional byte to be able to differentiate if datagram got truncated
   const auto n = socket->read(buffer.data(), buffer.size());
 
   if(n == 0 || std::chrono::system_clock::now() - start_time > timeout) {
      throw System_Error("Timeout waiting for response");
   }
 
   if(n == buffer.size()) {
      throw System_Error("Buffer too small");
   }
 
   buffer.resize(n);
   return buffer;
}

References encode_request(), and Botan::OS::open_socket_udp().

servers_from_str()

std::vector< Server_Information > Botan::Roughtime::servers_from_str

(

std::string_view

str

)

Parse a list of server descriptions

Parameters

str	the server list to parse

Returns

the parsed servers

Definition at line 386 of file roughtime.cpp.

                                                                   {
   std::vector<Server_Information> servers;
   std::istringstream ss{std::string(str)};  // FIXME C++23 avoid copy
 
   const std::string ERROR_MESSAGE = "Line does not have at least 5 space separated fields";
   for(std::string s; std::getline(ss, s);) {
      size_t start = 0;
      size_t end = 0;
      end = s.find(' ', start);
      if(end == std::string::npos) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
      const auto name = s.substr(start, end - start);
 
      start = end + 1;
      end = s.find(' ', start);
      if(end == std::string::npos) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
      const auto publicKeyType = s.substr(start, end - start);
      if(publicKeyType != "ed25519") {
         throw Not_Implemented("Only ed25519 publicKeyType is implemented");
      }
 
      start = end + 1;
      end = s.find(' ', start);
 
      if(end == std::string::npos) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
      const auto publicKeyBase64 = s.substr(start, end - start);
      const auto publicKey = Ed25519_PublicKey(base64_decode(publicKeyBase64));
 
      start = end + 1;
      end = s.find(' ', start);
      if(end == std::string::npos) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
      const auto protocol = s.substr(start, end - start);
      if(protocol != "udp") {
         throw Not_Implemented("Only UDP protocol is implemented");
      }
 
      const auto addresses = [&]() {
         std::vector<std::string> addr;
         for(;;) {
            start = end + 1;
            end = s.find(' ', start);
            const auto address = s.substr(start, (end == std::string::npos) ? std::string::npos : end - start);
            if(address.empty()) {
               return addr;
            }
            addr.push_back(address);
            if(end == std::string::npos) {
               return addr;
            }
         }
      }();
      if(addresses.empty()) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
 
      servers.push_back({name, publicKey, addresses});
   }
   return servers;
}

References Botan::base64_decode().

Variable Documentation

request_min_size

const unsigned Botan::Roughtime::request_min_size = 1024

The fixed size of a Roughtime request

Definition at line 26 of file roughtime.h.