Botan  2.15.0
Crypto and TLS for C++11
Public Member Functions | List of all members
Botan::Roughtime::Chain Class Referencefinal

#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< Responseresponses () 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 251 of file roughtime.cpp.

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

252  {
253  std::stringstream ss(str);
254  const std::string ERROR_MESSAGE = "Line does not have 4 space separated fields";
255  for(std::string s; std::getline(ss, s);)
256  {
257  size_t start = 0, end = 0;
258  end = s.find(' ', start);
259  if(end == std::string::npos)
260  {
261  throw Decoding_Error(ERROR_MESSAGE);
262  }
263  const auto publicKeyType = s.substr(start, end-start);
264  if(publicKeyType != "ed25519")
265  { throw Not_Implemented("Only ed25519 publicKeyType is implemented"); }
266 
267  start = end + 1;
268  end = s.find(' ', start);
269  if(end == std::string::npos)
270  {
271  throw Decoding_Error(ERROR_MESSAGE);
272  }
273  const auto serverPublicKey = Botan::Ed25519_PublicKey(Botan::base64_decode(s.substr(start, end-start)));
274 
275  start = end + 1;
276  end = s.find(' ', start);
277  if(end == std::string::npos)
278  {
279  throw Decoding_Error(ERROR_MESSAGE);
280  }
281  if((end - start) != 88)
282  {
283  throw Decoding_Error("Nonce has invalid length");
284  }
285  const auto vec = Botan::base64_decode(s.substr(start, end-start));
286  const auto nonceOrBlind = Nonce(vector_to_array<64>(Botan::base64_decode(s.substr(start, end-start))));
287 
288  start = end + 1;
289  end = s.find(' ', start);
290  if(end != std::string::npos)
291  {
292  throw Decoding_Error(ERROR_MESSAGE);
293  }
294  const auto response = Botan::unlock(Botan::base64_decode(s.substr(start)));
295 
296  m_links.push_back({response, serverPublicKey, nonceOrBlind});
297  }
298  }
std::vector< T > unlock(const secure_vector< T > &in)
Definition: secmem.h:72
size_t base64_decode(uint8_t out[], const char in[], size_t input_length, size_t &input_consumed, bool final_inputs, bool ignore_ws)
Definition: base64.cpp:181

Member Function Documentation

◆ append()

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

Definition at line 319 of file roughtime.cpp.

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

320  {
321  if(max_chain_size <= 0)
322  { throw Invalid_Argument("Max chain size must be positive"); }
323 
324  while(m_links.size() >= max_chain_size)
325  {
326  if(m_links.size() == 1)
327  {
328  auto new_link_updated = new_link;
329  new_link_updated.nonce_or_blind() =
330  nonce_from_blind(m_links[0].response(), new_link.nonce_or_blind()); //we need to convert blind to nonce
331  m_links.clear();
332  m_links.push_back(new_link_updated);
333  return;
334  }
335  if(m_links.size() >= 2)
336  {
337  m_links[1].nonce_or_blind() =
338  nonce_from_blind(m_links[0].response(), m_links[1].nonce_or_blind()); //we need to convert blind to nonce
339  }
340  m_links.erase(m_links.begin());
341  }
342  m_links.push_back(new_link);
343  }
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)
Definition: roughtime.cpp:237

◆ links()

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

Definition at line 114 of file roughtime.h.

114 { return m_links; }

◆ next_nonce()

Nonce Botan::Roughtime::Chain::next_nonce ( const Nonce blind) const

Definition at line 313 of file roughtime.cpp.

References Botan::Roughtime::nonce_from_blind().

314  {
315  return m_links.empty()
316  ? blind
317  : nonce_from_blind(m_links.back().response(), blind);
318  }
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)
Definition: roughtime.cpp:237

◆ responses()

std::vector< Response > Botan::Roughtime::Chain::responses ( ) const

Definition at line 299 of file roughtime.cpp.

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

300  {
301  std::vector<Response> responses;
302  for(unsigned i = 0; i < m_links.size(); ++i)
303  {
304  const auto& l = m_links[i];
305  const auto nonce = i ? nonce_from_blind(m_links[i-1].response(), l.nonce_or_blind()) : l.nonce_or_blind();
306  const auto response = Response::from_bits(l.response(), nonce);
307  if(!response.validate(l.public_key()))
308  { throw Roughtime_Error("Invalid signature or public key"); }
309  responses.push_back(response);
310  }
311  return responses;
312  }
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)
Definition: roughtime.cpp:237
std::vector< Response > responses() const
Definition: roughtime.cpp:299
static Response from_bits(const std::vector< uint8_t > &response, const Nonce &nonce)
Definition: roughtime.cpp:177

◆ to_string()

std::string Botan::Roughtime::Chain::to_string ( ) const

Definition at line 345 of file roughtime.cpp.

References Botan::base64_encode().

346  {
347  std::string s;
348  s.reserve((7+1 + 88+1 + 44+1 + 480)*m_links.size());
349  for(const auto& link : m_links)
350  {
351  s += "ed25519";
352  s += ' ';
353  s += Botan::base64_encode(link.public_key().get_public_key());
354  s += ' ';
355  s += Botan::base64_encode(link.nonce_or_blind().get_nonce().data(), link.nonce_or_blind().get_nonce().size());
356  s += ' ';
357  s += Botan::base64_encode(link.response());
358  s += '\n';
359  }
360  return s;
361  }
size_t base64_encode(char out[], const uint8_t in[], size_t input_length, size_t &input_consumed, bool final_inputs)
Definition: base64.cpp:166

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