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 57 of file roughtime.h.

Member Typedef Documentation

microseconds32

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

Definition at line 59 of file roughtime.h.

microseconds64

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

Definition at line 60 of file roughtime.h.

sys_microseconds64

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

Definition at line 61 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

Definition at line 175 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) {
      throw Roughtime_Error("Merkle tree path size must be multiple of 64 bytes");
   }
   if(indx >= (1U << levels)) {
      throw Roughtime_Error("Merkle tree path is too short");
   }
 
   auto hash = hashLeaf(nonce.get_nonce());
   auto index = indx;
   size_t level = 0;
   while(level < levels) {
      hashNode(hash, typecast_copy<std::array<uint8_t, 64>>(path.data() + level * 64), index & 1);
      ++level;
      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::typecast_copy(), and Botan::verify_signature().

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

utc_midpoint()

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

inline

Definition at line 67 of file roughtime.h.

{ return m_utc_midpoint; }

utc_radius()

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

inline

Definition at line 69 of file roughtime.h.

{ return m_utc_radius; }

validate()

bool Botan::Roughtime::Response::validate

(

const Ed25519_PublicKey &

pk

)

const

Definition at line 229 of file roughtime.cpp.

                                                         {
   const char context[] = "RoughTime v1 delegation signature--";
   PK_Verifier verifier(pk, "Pure");
   verifier.update(cast_char_ptr_to_uint8(context), sizeof(context));  //add context including \0
   verifier.update(m_cert_dele.data(), m_cert_dele.size());
   return verifier.check_signature(m_cert_sig.data(), m_cert_sig.size());
}

References Botan::cast_char_ptr_to_uint8(), 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