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 (const std::string &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 109 of file roughtime.h.

Constructor & Destructor Documentation

Chain() [1/2]

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

default

Chain() [2/2]

Botan::Roughtime::Chain::Chain

(

const std::string &

str

)

Definition at line 252 of file roughtime.cpp.

   {
   std::stringstream ss(str);
   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, 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 = Botan::Ed25519_PublicKey(Botan::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 = Botan::base64_decode(s.substr(start, end-start));
      const auto nonceOrBlind = Nonce(vector_to_array<64>(Botan::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 = Botan::unlock(Botan::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 320 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 114 of file roughtime.h.

{ return m_links; }

next_nonce()

Nonce Botan::Roughtime::Chain::next_nonce

(

const Nonce &

blind

)

const

Definition at line 314 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 300 of file roughtime.cpp.

   {
   std::vector<Response> responses;
   for(unsigned i = 0; i < m_links.size(); ++i)
      {
      const auto& l = m_links[i];
      const auto nonce = i ? 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 346 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 += Botan::base64_encode(link.public_key().get_public_key());
      s += ' ';
      s += Botan::base64_encode(link.nonce_or_blind().get_nonce().data(), link.nonce_or_blind().get_nonce().size());
      s += ' ';
      s += Botan::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