Botan::Roughtime::Chain Class Reference

#include <roughtime.h>

Public Member Functions
void	append (const Link &new_link, size_t max_chain_size)
	Chain ()=default
	Chain (std::string_view str)
const std::vector< Link > &	links () const
Nonce	next_nonce (const Nonce &blind) const
std::vector< Response >	responses () const
std::string	to_string () const

Detailed Description

A chain of Roughtime responses

Definition at line 207 of file roughtime.h.

Constructor & Destructor Documentation

Chain() [1/2]

Botan::Roughtime::Chain::Chain ( )

default

Create an empty chain

References Chain().

Referenced by Chain().

Chain() [2/2]

Botan::Roughtime::Chain::Chain ( std::string_view str )

explicit

Parse a chain from its string representation

Parameters

str	the chain to parse

Definition at line 254 of file roughtime.cpp.

                               {
   std::istringstream ss{std::string(str)};  // FIXME C++23 avoid copy
   const std::string ERROR_MESSAGE = "Line does not have 4 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 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 serverPublicKey = Ed25519_PublicKey(base64_decode(s.substr(start, end - start)));
 
      start = end + 1;
      end = s.find(' ', start);
      if(end == std::string::npos) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
      if((end - start) != 88) {
         throw Decoding_Error("Nonce has invalid length");
      }
      const auto vec = base64_decode(s.substr(start, end - start));
      const auto nonceOrBlind = Nonce(vector_to_array<64>(base64_decode(s.substr(start, end - start))));
 
      start = end + 1;
      end = s.find(' ', start);
      if(end != std::string::npos) {
         throw Decoding_Error(ERROR_MESSAGE);
      }
      const auto response = unlock(base64_decode(s.substr(start)));
 
      m_links.push_back({response, serverPublicKey, nonceOrBlind});
   }
}

References Botan::base64_decode(), and Botan::unlock().

Member Function Documentation

append()

void Botan::Roughtime::Chain::append	(	const Link &	new_link,
		size_t	max_chain_size )

Append a link, dropping the oldest links if needed

Parameters

new_link	the link to append
max_chain_size	the maximum number of links to retain

Definition at line 316 of file roughtime.cpp.

                                                              {
   if(max_chain_size <= 0) {
      throw Invalid_Argument("Max chain size must be positive");
   }
 
   while(m_links.size() >= max_chain_size) {
      if(m_links.size() == 1) {
         auto new_link_updated = new_link;
         new_link_updated.nonce_or_blind() =
            nonce_from_blind(m_links[0].response(), new_link.nonce_or_blind());  //we need to convert blind to nonce
         m_links.clear();
         m_links.push_back(new_link_updated);
         return;
      }
      if(m_links.size() >= 2) {
         m_links[1].nonce_or_blind() =
            nonce_from_blind(m_links[0].response(), m_links[1].nonce_or_blind());  //we need to convert blind to nonce
      }
      m_links.erase(m_links.begin());
   }
   m_links.push_back(new_link);
}

References Botan::Roughtime::nonce_from_blind(), and Botan::Roughtime::Link::nonce_or_blind().

links()

const std::vector< Link > & Botan::Roughtime::Chain::links ( ) const

inline

Access the links of this chain

Returns

the links

Definition at line 224 of file roughtime.h.

{ return m_links; }

next_nonce()

Nonce Botan::Roughtime::Chain::next_nonce

(

const Nonce &

blind

)

const

Compute the nonce to use for the next request

Parameters

blind

the blind to use

Returns

the next nonce

Definition at line 312 of file roughtime.cpp.

                                                {
   return m_links.empty() ? blind : nonce_from_blind(m_links.back().response(), blind);
}

References Botan::Roughtime::nonce_from_blind().

responses()

std::vector< Response > Botan::Roughtime::Chain::responses

(

)

const

Parse and validate every response in the chain

Returns

the parsed responses

Definition at line 298 of file roughtime.cpp.

                                           {
   std::vector<Response> responses;
   for(size_t i = 0; i < m_links.size(); ++i) {
      const auto& l = m_links[i];
      const auto nonce = i > 0 ? nonce_from_blind(m_links[i - 1].response(), l.nonce_or_blind()) : l.nonce_or_blind();
      const auto response = Response::from_bits(l.response(), nonce);
      if(!response.validate(l.public_key())) {
         throw Roughtime_Error("Invalid signature or public key");
      }
      responses.push_back(response);
   }
   return responses;
}

References Botan::Roughtime::Response::from_bits(), Botan::Roughtime::nonce_from_blind(), and responses().

Referenced by responses().

to_string()

std::string Botan::Roughtime::Chain::to_string

(

)

const

Format this chain as a string

Returns

the string representation of the chain

Definition at line 339 of file roughtime.cpp.

                                 {
   std::string s;
   s.reserve((7 + 1 + 88 + 1 + 44 + 1 + 480) * m_links.size());
   for(const auto& link : m_links) {
      s += "ed25519";
      s += ' ';
      s += base64_encode(link.public_key().get_public_key());
      s += ' ';
      s += base64_encode(link.nonce_or_blind().get_nonce().data(), link.nonce_or_blind().get_nonce().size());
      s += ' ';
      s += base64_encode(link.response());
      s += '\n';
   }
   return s;
}

References Botan::base64_encode().

---

The documentation for this class was generated from the following files:

• src/lib/misc/roughtime/roughtime.h
• src/lib/misc/roughtime/roughtime.cpp