Botan 3.14.1
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< 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
strthe chain to parse

Definition at line 259 of file roughtime.cpp.

259 {
260 std::istringstream ss{std::string(str)}; // FIXME C++23 avoid copy
261 const std::string ERROR_MESSAGE = "Line does not have 4 space separated fields";
262 for(std::string s; std::getline(ss, s);) {
263 size_t start = 0;
264 size_t end = 0;
265 end = s.find(' ', start);
266 if(end == std::string::npos) {
267 throw Decoding_Error(ERROR_MESSAGE);
268 }
269 const auto publicKeyType = s.substr(start, end - start);
270 if(publicKeyType != "ed25519") {
271 throw Not_Implemented("Only ed25519 publicKeyType is implemented");
272 }
273
274 start = end + 1;
275 end = s.find(' ', start);
276 if(end == std::string::npos) {
277 throw Decoding_Error(ERROR_MESSAGE);
278 }
279 const auto serverPublicKey = Ed25519_PublicKey(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 if((end - start) != 88) {
287 throw Decoding_Error("Nonce has invalid length");
288 }
289 const auto vec = base64_decode(s.substr(start, end - start));
290 const auto nonceOrBlind = Nonce(vector_to_array<64>(base64_decode(s.substr(start, end - start))));
291
292 start = end + 1;
293 end = s.find(' ', start);
294 if(end != std::string::npos) {
295 throw Decoding_Error(ERROR_MESSAGE);
296 }
297 const auto response = unlock(base64_decode(s.substr(start)));
298
299 m_links.push_back({response, serverPublicKey, nonceOrBlind});
300 }
301}
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:203
std::vector< T > unlock(const secure_vector< T > &in)
Definition secmem.h:155

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_linkthe link to append
max_chain_sizethe maximum number of links to retain

Definition at line 321 of file roughtime.cpp.

321 {
322 if(max_chain_size <= 0) {
323 throw Invalid_Argument("Max chain size must be positive");
324 }
325
326 while(m_links.size() >= max_chain_size) {
327 if(m_links.size() == 1) {
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 m_links[1].nonce_or_blind() =
337 nonce_from_blind(m_links[0].response(), m_links[1].nonce_or_blind()); //we need to convert blind to nonce
338 }
339 m_links.erase(m_links.begin());
340 }
341 m_links.push_back(new_link);
342}
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

Access the links of this chain

Returns
the links

Definition at line 224 of file roughtime.h.

224{ 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
blindthe blind to use
Returns
the next nonce

Definition at line 317 of file roughtime.cpp.

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

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

303 {
304 std::vector<Response> responses;
305 for(size_t i = 0; i < m_links.size(); ++i) {
306 const auto& l = m_links[i];
307 const auto nonce = i > 0 ? nonce_from_blind(m_links[i - 1].response(), l.nonce_or_blind()) : l.nonce_or_blind();
308 const auto response = Response::from_bits(l.response(), nonce);
309 if(!response.validate(l.public_key())) {
310 throw Roughtime_Error("Invalid signature or public key");
311 }
312 responses.push_back(response);
313 }
314 return responses;
315}
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

Format this chain as a string

Returns
the string representation of the chain

Definition at line 344 of file roughtime.cpp.

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

References Botan::base64_encode().


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