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

Definition at line 103 of file roughtime.h.

Constructor & Destructor Documentation

Chain() [1/2]

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

default

References Chain().

Referenced by Chain().

Chain() [2/2]

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

explicit

Definition at line 247 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 )

Definition at line 309 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

Definition at line 108 of file roughtime.h.

{ return m_links; }

next_nonce()

Nonce Botan::Roughtime::Chain::next_nonce

(

const Nonce &

blind

)

const

Definition at line 305 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

Definition at line 291 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

Definition at line 332 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