Botan 2.13.0 Crypto and TLS for C++11

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

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< Response > | responses () const
std::string | to_string () const

## Detailed Description

Definition at line 109 of file roughtime.h.

## Constructor & Destructor Documentation

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

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 }
Botan::Ed25519_PublicKey
Definition: ed25519.h:18
Botan::unlock
std::vector< T > unlock(const secure_vector< T > &in)
Definition: secmem.h:72
Botan::base64_decode
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

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 }
Botan::Roughtime::nonce_from_blind
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)
Definition: roughtime.cpp:237

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

Definition at line 114 of file roughtime.h.

114 { return m_links; }

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 }
Botan::Roughtime::nonce_from_blind
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)
Definition: roughtime.cpp:237

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 }
Botan::Roughtime::nonce_from_blind
Nonce nonce_from_blind(const std::vector< uint8_t > &previous_response, const Nonce &blind)
Definition: roughtime.cpp:237
Botan::Roughtime::Response::from_bits
static Response from_bits(const std::vector< uint8_t > &response, const Nonce &nonce)
Definition: roughtime.cpp:177
Botan::Roughtime::Chain::responses
std::vector< Response > responses() const
Definition: roughtime.cpp:299

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 }
Botan::base64_encode
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:

- src/lib/misc/roughtime/roughtime.h
- src/lib/misc/roughtime/roughtime.cpp