Botan::Roughtime::Response Class Reference

#include <roughtime.h>

Public Types
using	microseconds32 = std::chrono::duration<uint32_t, std::micro>
using	microseconds64 = std::chrono::duration<uint64_t, std::micro>
using	sys_microseconds64 = std::chrono::time_point<std::chrono::system_clock, microseconds64>

Public Member Functions
sys_microseconds64	utc_midpoint () const
microseconds32	utc_radius () const
bool	validate (const Ed25519_PublicKey &pk) const

Static Public Member Functions
static Response	from_bits (const std::vector< uint8_t > &response, const Nonce &nonce)

Detailed Description

An Roughtime response.

Definition at line 103 of file roughtime.h.

Member Typedef Documentation

microseconds32

using Botan::Roughtime::Response::microseconds32 = std::chrono::duration<uint32_t, std::micro>

A 32 bit microsecond duration

Definition at line 108 of file roughtime.h.

microseconds64

using Botan::Roughtime::Response::microseconds64 = std::chrono::duration<uint64_t, std::micro>

A 64 bit microsecond duration

Definition at line 113 of file roughtime.h.

sys_microseconds64

using Botan::Roughtime::Response::sys_microseconds64 = std::chrono::time_point<std::chrono::system_clock, microseconds64>

A system clock time point with microsecond resolution

Definition at line 118 of file roughtime.h.

Member Function Documentation

from_bits()

Response Botan::Roughtime::Response::from_bits ( const std::vector< uint8_t > & response, const Nonce & nonce )

static

Parse a Roughtime response

Parameters

response	the raw response bytes
nonce	the nonce which was sent in the request

Returns

the parsed response

Definition at line 181 of file roughtime.cpp.

                                                                                   {
   const auto response_v = unpack_roughtime_packet(response);
   const auto cert = unpack_roughtime_packet(get_v(response_v, "CERT"));
   const auto cert_dele = get<std::array<uint8_t, 72>>(cert, "DELE");
   const auto cert_sig = get<std::array<uint8_t, 64>>(cert, "SIG");
   const auto cert_dele_v = unpack_roughtime_packet(cert_dele);
   const auto srep = get_v(response_v, "SREP");
   const auto srep_v = unpack_roughtime_packet(srep);
 
   const auto cert_dele_pubk = get<std::array<uint8_t, 32>>(cert_dele_v, "PUBK");
   const auto sig = get<std::array<uint8_t, 64>>(response_v, "SIG");
   if(!verify_signature(cert_dele_pubk, srep, sig)) {
      throw Roughtime_Error("Response signature invalid");
   }
 
   const auto indx = get<uint32_t>(response_v, "INDX");
   const auto path = get_v(response_v, "PATH");
   const auto srep_root = get<std::array<uint8_t, 64>>(srep_v, "ROOT");
   const size_t size = path.size();
   const size_t levels = size / 64;
 
   if(size % 64 != 0) {
      throw Roughtime_Error("Merkle tree path size must be multiple of 64 bytes");
   }
   if(levels >= 32 || indx >= (uint32_t(1) << levels)) {
      throw Roughtime_Error("Merkle tree path is too short");
   }
 
   BufferSlicer slicer(path);
   auto hash = hashLeaf(nonce.get_nonce());
   auto index = indx;
   for(std::size_t level = 0; level < levels; ++level) {
      hashNode(hash, slicer.take<64>(), index % 2 == 1);
      index >>= 1;
   }
 
   if(srep_root != hash) {
      throw Roughtime_Error("Nonce verification failed");
   }
 
   const auto cert_dele_maxt = sys_microseconds64(get<microseconds64>(cert_dele_v, "MAXT"));
   const auto cert_dele_mint = sys_microseconds64(get<microseconds64>(cert_dele_v, "MINT"));
   const auto srep_midp = sys_microseconds64(get<microseconds64>(srep_v, "MIDP"));
   const auto srep_radi = get<microseconds32>(srep_v, "RADI");
   if(srep_midp < cert_dele_mint) {
      throw Roughtime_Error("Midpoint earlier than delegation start");
   }
   if(srep_midp > cert_dele_maxt) {
      throw Roughtime_Error("Midpoint later than delegation end");
   }
   return {cert_dele, cert_sig, srep_midp, srep_radi};
}

References Botan::Roughtime::Nonce::get_nonce(), Botan::BufferSlicer::take(), and Botan::verify_signature().

Referenced by Botan::Roughtime::Chain::responses().

utc_midpoint()

sys_microseconds64 Botan::Roughtime::Response::utc_midpoint ( ) const

inline

Return the midpoint of the time interval reported by the server

Returns

the UTC midpoint

Definition at line 139 of file roughtime.h.

{ return m_utc_midpoint; }

utc_radius()

microseconds32 Botan::Roughtime::Response::utc_radius ( ) const

inline

Return the radius of the time interval reported by the server

Returns

the UTC radius

Definition at line 145 of file roughtime.h.

{ return m_utc_radius; }

validate()

bool Botan::Roughtime::Response::validate

(

const Ed25519_PublicKey &

pk

)

const

Check the signatures on this response

Parameters

pk	the long term public key of the server

Returns

true if the response is valid

Definition at line 234 of file roughtime.cpp.

                                                         {
   constexpr std::string_view context("RoughTime v1 delegation signature--\0", 36);
   PK_Verifier verifier(pk, "Pure");
   verifier.update(context);
   verifier.update(m_cert_dele.data(), m_cert_dele.size());
   return verifier.check_signature(m_cert_sig.data(), m_cert_sig.size());
}

References Botan::PK_Verifier::check_signature(), and Botan::PK_Verifier::update().

---

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

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