Botan 3.5.0
Crypto and TLS for C&
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 (std::string_view 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 103 of file roughtime.h.

Constructor & Destructor Documentation

◆ Chain() [1/2]

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

◆ Chain() [2/2]

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

Definition at line 249 of file roughtime.cpp.

249 {
250 std::istringstream ss{std::string(str)}; // FIXME C++23 avoid copy
251 const std::string ERROR_MESSAGE = "Line does not have 4 space separated fields";
252 for(std::string s; std::getline(ss, s);) {
253 size_t start = 0, end = 0;
254 end = s.find(' ', start);
255 if(end == std::string::npos) {
256 throw Decoding_Error(ERROR_MESSAGE);
257 }
258 const auto publicKeyType = s.substr(start, end - start);
259 if(publicKeyType != "ed25519") {
260 throw Not_Implemented("Only ed25519 publicKeyType is implemented");
261 }
262
263 start = end + 1;
264 end = s.find(' ', start);
265 if(end == std::string::npos) {
266 throw Decoding_Error(ERROR_MESSAGE);
267 }
268 const auto serverPublicKey = Ed25519_PublicKey(base64_decode(s.substr(start, end - start)));
269
270 start = end + 1;
271 end = s.find(' ', start);
272 if(end == std::string::npos) {
273 throw Decoding_Error(ERROR_MESSAGE);
274 }
275 if((end - start) != 88) {
276 throw Decoding_Error("Nonce has invalid length");
277 }
278 const auto vec = base64_decode(s.substr(start, end - start));
279 const auto nonceOrBlind = Nonce(vector_to_array<64>(base64_decode(s.substr(start, end - start))));
280
281 start = end + 1;
282 end = s.find(' ', start);
283 if(end != std::string::npos) {
284 throw Decoding_Error(ERROR_MESSAGE);
285 }
286 const auto response = unlock(base64_decode(s.substr(start)));
287
288 m_links.push_back({response, serverPublicKey, nonceOrBlind});
289 }
290}
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:154
std::vector< T > unlock(const secure_vector< T > &in)
Definition secmem.h:75

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 310 of file roughtime.cpp.

310 {
311 if(max_chain_size <= 0) {
312 throw Invalid_Argument("Max chain size must be positive");
313 }
314
315 while(m_links.size() >= max_chain_size) {
316 if(m_links.size() == 1) {
317 auto new_link_updated = new_link;
318 new_link_updated.nonce_or_blind() =
319 nonce_from_blind(m_links[0].response(), new_link.nonce_or_blind()); //we need to convert blind to nonce
320 m_links.clear();
321 m_links.push_back(new_link_updated);
322 return;
323 }
324 if(m_links.size() >= 2) {
325 m_links[1].nonce_or_blind() =
326 nonce_from_blind(m_links[0].response(), m_links[1].nonce_or_blind()); //we need to convert blind to nonce
327 }
328 m_links.erase(m_links.begin());
329 }
330 m_links.push_back(new_link);
331}
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)

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.

108{ return m_links; }

◆ next_nonce()

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

Definition at line 306 of file roughtime.cpp.

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

References Botan::Roughtime::nonce_from_blind().

◆ responses()

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

Definition at line 292 of file roughtime.cpp.

292 {
293 std::vector<Response> responses;
294 for(unsigned i = 0; i < m_links.size(); ++i) {
295 const auto& l = m_links[i];
296 const auto nonce = i ? nonce_from_blind(m_links[i - 1].response(), l.nonce_or_blind()) : l.nonce_or_blind();
297 const auto response = Response::from_bits(l.response(), nonce);
298 if(!response.validate(l.public_key())) {
299 throw Roughtime_Error("Invalid signature or public key");
300 }
301 responses.push_back(response);
302 }
303 return responses;
304}
std::vector< Response > responses() const
static Response from_bits(const std::vector< uint8_t > &response, const Nonce &nonce)

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 333 of file roughtime.cpp.

333 {
334 std::string s;
335 s.reserve((7 + 1 + 88 + 1 + 44 + 1 + 480) * m_links.size());
336 for(const auto& link : m_links) {
337 s += "ed25519";
338 s += ' ';
339 s += base64_encode(link.public_key().get_public_key());
340 s += ' ';
341 s += base64_encode(link.nonce_or_blind().get_nonce().data(), link.nonce_or_blind().get_nonce().size());
342 s += ' ';
343 s += base64_encode(link.response());
344 s += '\n';
345 }
346 return s;
347}
size_t base64_encode(char out[], const uint8_t in[], size_t input_length, size_t &input_consumed, bool final_inputs)
Definition base64.cpp:146

References Botan::base64_encode().


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