5111374265

Committed 29 May 2023 11:19AM UTC coverage: 92.227% (+0.5%) from 91.723%

Build # 5111374265

Build Type

push

github

Committed by

randombit

Commit Message

Next release will be 3.1.0. Update release notes

Run Details

75588 of 81959 relevant lines covered (92.23%)

11886470.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.16

/src/tests/test_roughtime.cpp

/*
* (C) 2019 Nuno Goncalves <nunojpg@gmail.com>
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "test_rng.h"
#include "tests.h"

#if defined(BOTAN_HAS_BIGINT)
   #include <botan/bigint.h>
#endif

#if defined(BOTAN_HAS_ROUGHTIME)
   #include <botan/base64.h>
   #include <botan/ed25519.h>
   #include <botan/hex.h>
   #include <botan/roughtime.h>
#endif

namespace Botan_Tests {

#if defined(BOTAN_HAS_ROUGHTIME)

class Roughtime_Request_Tests final : public Text_Based_Test {
   public:
      Roughtime_Request_Tests() : Text_Based_Test("roughtime/roughtime_request.vec", "Nonce,Request") {}

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         Test::Result result("Roughtime request");

         const auto nonce = vars.get_req_bin("Nonce");
         const auto request_v = vars.get_req_bin("Request");

         const auto request = Botan::Roughtime::encode_request(nonce);
         result.test_eq(
            "encode", type == "Valid", request == Botan::typecast_copy<std::array<uint8_t, 1024>>(request_v.data()));

         return result;
      }
};

BOTAN_REGISTER_TEST("roughtime", "roughtime_request", Roughtime_Request_Tests);

class Roughtime_Response_Tests final : public Text_Based_Test {
   public:
      Roughtime_Response_Tests() :
            Text_Based_Test(
               "roughtime/roughtime_response.vec", "Response", "Nonce,Pubkey,MidpointMicroSeconds,RadiusMicroSeconds") {
      }

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         Test::Result result("Roughtime response");

         const auto response_v = vars.get_req_bin("Response");
         const auto nonce_bits = vars.has_key("Nonce") ? vars.get_opt_bin("Nonce") : std::vector<uint8_t>(64);

         const Botan::Roughtime::Nonce nonce(nonce_bits);
         try {
            const auto response = Botan::Roughtime::Response::from_bits(response_v, nonce);

            const auto pubkey = vars.get_req_bin("Pubkey");
            if(pubkey.size() != 32)
               throw Test_Error("Unexpected Roughtime Ed25519 pubkey size");

            if(!response.validate(Botan::Ed25519_PublicKey(pubkey))) {
               result.confirm("fail_validation", type == "Invalid");
            } else {
               const auto midpoint = Botan::Roughtime::Response::sys_microseconds64(
                  std::chrono::microseconds(vars.get_req_u64("MidpointMicroSeconds")));
               const auto radius = std::chrono::microseconds(vars.get_req_u32("RadiusMicroSeconds"));

               result.confirm("midpoint", response.utc_midpoint() == midpoint);
               result.confirm("radius", response.utc_radius() == radius);
               result.confirm("OK", type == "Valid");
            }
         } catch(const Botan::Roughtime::Roughtime_Error& e) { result.confirm(e.what(), type == "Invalid"); }

         return result;
      }
};

BOTAN_REGISTER_TEST("roughtime", "roughtime_response", Roughtime_Response_Tests);

class Roughtime_nonce_from_blind_Tests final : public Text_Based_Test {
   public:
      Roughtime_nonce_from_blind_Tests() :
            Text_Based_Test("roughtime/roughtime_nonce_from_blind.vec", "Response,Blind,Nonce") {}

      Test::Result run_one_test(const std::string& type, const VarMap& vars) override {
         Test::Result result("roughtime nonce_from_blind");

         const auto response = vars.get_req_bin("Response");
         const auto blind = vars.get_req_bin("Blind");
         const auto nonce = vars.get_req_bin("Nonce");

         result.test_eq(
            "fail_validation", Botan::Roughtime::nonce_from_blind(response, blind) == nonce, type == "Valid");

         return result;
      }
};

BOTAN_REGISTER_TEST("roughtime", "roughtime_nonce_from_blind", Roughtime_nonce_from_blind_Tests);

class Roughtime final : public Test {
      static Test::Result test_nonce() {
         Test::Result result("roughtime nonce");

         auto rand64 = Botan::unlock(Test::rng().random_vec(64));
         Botan::Roughtime::Nonce nonce_v(rand64);
         result.confirm("nonce from vector",
                        nonce_v.get_nonce() == Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));
         Botan::Roughtime::Nonce nonce_a(Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));
         result.confirm("nonce from array",
                        nonce_v.get_nonce() == Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));
         rand64.push_back(10);
         result.test_throws("vector oversize", [&rand64]() { Botan::Roughtime::Nonce nonce_v2(rand64); });  //size 65
         rand64.pop_back();
         rand64.pop_back();
         result.test_throws("vector undersize", [&rand64]() { Botan::Roughtime::Nonce nonce_v2(rand64); });  //size 63

         return result;
      }

      static Test::Result test_chain() {
         Test::Result result("roughtime chain");

         Botan::Roughtime::Chain c1;
         result.confirm("default constructed is empty", c1.links().empty() && c1.responses().empty());

         auto rand64 = Botan::unlock(Test::rng().random_vec(64));
         Botan::Roughtime::Nonce nonce_v(rand64);
         result.confirm(
            "empty chain nonce is blind",
            c1.next_nonce(nonce_v).get_nonce() == Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));

         const std::string chain_str =
            "ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA\n"
            "ed25519 gD63hSj3ScS+wuOeGrubXlq35N1c5Lby/S+T7MNTjxo= uLeTON9D+2HqJMzK6sYWLNDEdtBl9t/9yw1cVAOm0/sONH5Oqdq9dVPkC9syjuWbglCiCPVF+FbOtcxCkrgMmA== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWOw1jl0uSiBEH9HE8/6r7zxoSc01f48vw+UzH8+VJoPelnvVJBj4lnH8uRLh5Aw0i4Du7XM1dp2u0r/I5PzhMQoDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AUBo+tEqPBQC47l77to7ESFTVhlw1SC74P5ssx6gpuJ6eP+1916GuUiySGE/x3Fp0c3otUGAdsRQou5p9PDTeane/YEeVq4/8AgAAAEAAAABTSUcAREVMRe5T1ml8wHyWAcEtHP/U5Rg/jFXTEXOSglngSa4aI/CECVdy4ZNWeP6vv+2//ZW7lQsrWo7ZkXpvm9BdBONRSQIDAAAAIAAAACgAAABQVUJLTUlOVE1BWFQpXlenV0OfVisvp9jDHXLw8vymZVK9Pgw9k6Edf8ZEhUgSGEc5jwUASHLvZE2PBQAAAAAA\n";

         Botan::Roughtime::Chain c2(chain_str);
         result.confirm("have two elements", c2.links().size() == 2 && c2.responses().size() == 2);
         result.confirm("serialize loopback", c2.to_string() == chain_str);

         c1.append(c2.links()[0], 1);
         result.confirm("append ok", c1.links().size() == 1 && c1.responses().size() == 1);
         c1.append(c2.links()[1], 1);
         result.confirm("max size", c1.links().size() == 1 && c1.responses().size() == 1);

         result.test_throws("non-positive max chain size", [&]() { c1.append(c2.links()[1], 0); });
         result.test_throws("1 field", [&]() { Botan::Roughtime::Chain a("ed25519"); });
         result.test_throws(
            "2 fields", [&]() { Botan::Roughtime::Chain a("ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE="); });
         result.test_throws("3 fields", [&]() {
            Botan::Roughtime::Chain a(
               "ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw==");
         });
         result.test_throws("5 fields", [&]() {
            Botan::Roughtime::Chain a(
               "ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA abc");
         });
         result.test_throws("invalid key type", [&]() {
            Botan::Roughtime::Chain a(
               "rsa bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA");
         });
         result.test_throws("invalid key", [&]() {
            Botan::Roughtime::Chain a(
               "ed25519 bbT+RPS7zKX6wssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA");
         });
         result.test_throws("invalid nonce", [&]() {
            Botan::Roughtime::Chain a(
               "ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2UByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA");
         });

         return result;
      }

      static Test::Result test_server_information() {
         Test::Result result("roughtime server_information");

         const auto servers = Botan::Roughtime::servers_from_str(
            "Chainpoint-Roughtime ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp roughtime.chainpoint.org:2002\n"
            "Cloudflare-Roughtime ed25519 gD63hSj3ScS+wuOeGrubXlq35N1c5Lby/S+T7MNTjxo= udp roughtime.cloudflare.com:2002\n"
            "Google-Sandbox-Roughtime ed25519 etPaaIxcBMY1oUeGpwvPMCJMwlRVNxv51KK/tktoJTQ= udp roughtime.sandbox.google.com:2002\n"
            "int08h-Roughtime ed25519 AW5uAoTSTDfG5NfY1bTh08GUnOqlRb+HVhbJ3ODJvsE= udp roughtime.int08h.com:2002\n"
            "ticktock ed25519 cj8GsiNlRkqiDElAeNMSBBMwrAl15hYPgX50+GWX/lA= udp ticktock.mixmin.net:5333\n");

         result.confirm("size", servers.size() == 5);
         result.test_eq("name", servers[0].name(), "Chainpoint-Roughtime");
         result.test_eq("name", servers[4].name(), "ticktock");
         result.confirm(
            "public key",
            servers[0].public_key().get_public_key() ==
               Botan::Ed25519_PublicKey(Botan::base64_decode("bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE="))
                  .get_public_key());
         result.confirm("single address", servers[0].addresses().size() == 1);
         result.test_eq("address", servers[0].addresses()[0], "roughtime.chainpoint.org:2002");

         result.test_throws("1 field", [&]() { Botan::Roughtime::servers_from_str("A"); });
         result.test_throws("2 fields", [&]() { Botan::Roughtime::servers_from_str("A ed25519"); });
         result.test_throws("3 fields", [&]() {
            Botan::Roughtime::servers_from_str("A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE=");
         });
         result.test_throws("4 fields", [&]() {
            Botan::Roughtime::servers_from_str("A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp");
         });
         result.test_throws("invalid address", [&]() {
            Botan::Roughtime::servers_from_str("A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp ");
         });
         result.test_throws("invalid key type", [&]() {
            Botan::Roughtime::servers_from_str(
               "A rsa bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp roughtime.chainpoint.org:2002");
         });
         result.test_throws("invalid key", [&]() {
            Botan::Roughtime::servers_from_str(
               "A ed25519 bbT+RP7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp roughtime.chainpoint.org:2002");
         });
         result.test_throws("invalid protocol", [&]() {
            Botan::Roughtime::servers_from_str(
               "A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= tcp roughtime.chainpoint.org:2002");
         });

         return result;
      }

      static Test::Result test_request_online() {
         Test::Result result("roughtime request online");

         Botan::Roughtime::Nonce nonce(Test::rng());
         try {
            const auto response_raw =
               Botan::Roughtime::online_request("roughtime.cloudflare.com:2002", nonce, std::chrono::seconds(5));
            const auto now = std::chrono::system_clock::now();
            const auto response = Botan::Roughtime::Response::from_bits(response_raw, nonce);
            std::chrono::milliseconds local_clock_max_error(1000);
            const auto diff_abs =
               now >= response.utc_midpoint() ? now - response.utc_midpoint() : response.utc_midpoint() - now;
            result.confirm("online", diff_abs <= (response.utc_radius() + local_clock_max_error));
         } catch(const std::exception& e) { result.test_failure(e.what()); }
         return result;
      }

   public:
      std::vector<Test::Result> run() override {
         std::vector<Test::Result> results;
         results.push_back(test_nonce());
         results.push_back(test_chain());
         results.push_back(test_server_information());

         if(Test::options().run_online_tests()) {
            results.push_back(test_request_online());
         }

         return results;
      }
};

BOTAN_REGISTER_TEST("roughtime", "roughtime_tests", Roughtime);

#endif

}  // namespace Botan_Tests

1	/*
2	* (C) 2019 Nuno Goncalves <nunojpg@gmail.com>
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include "test_rng.h"
8	#include "tests.h"
9
10	#if defined(BOTAN_HAS_BIGINT)
11	#include <botan/bigint.h>
12	#endif
13
14	#if defined(BOTAN_HAS_ROUGHTIME)
15	#include <botan/base64.h>
16	#include <botan/ed25519.h>
17	#include <botan/hex.h>
18	#include <botan/roughtime.h>
19	#endif
20
21	namespace Botan_Tests {
22
23	#if defined(BOTAN_HAS_ROUGHTIME)
24
25	class Roughtime_Request_Tests final : public Text_Based_Test {	×
26	public:
27	Roughtime_Request_Tests() : Text_Based_Test("roughtime/roughtime_request.vec", "Nonce,Request") {}	2✔
28
29	Test::Result run_one_test(const std::string& type, const VarMap& vars) override {	2✔
30	Test::Result result("Roughtime request");	2✔
31
32	const auto nonce = vars.get_req_bin("Nonce");	2✔
33	const auto request_v = vars.get_req_bin("Request");	2✔
34
35	const auto request = Botan::Roughtime::encode_request(nonce);	2✔
36	result.test_eq(	2✔
37	"encode", type == "Valid", request == Botan::typecast_copy<std::array<uint8_t, 1024>>(request_v.data()));	2✔
38
39	return result;	2✔
40	}	4✔
41	};
42
43	BOTAN_REGISTER_TEST("roughtime", "roughtime_request", Roughtime_Request_Tests);
44
45	class Roughtime_Response_Tests final : public Text_Based_Test {	×
46	public:
47	Roughtime_Response_Tests() :	1✔
48	Text_Based_Test(
49	"roughtime/roughtime_response.vec", "Response", "Nonce,Pubkey,MidpointMicroSeconds,RadiusMicroSeconds") {	2✔
50	}	1✔
51
52	Test::Result run_one_test(const std::string& type, const VarMap& vars) override {	17✔
53	Test::Result result("Roughtime response");	17✔
54
55	const auto response_v = vars.get_req_bin("Response");	17✔
56	const auto nonce_bits = vars.has_key("Nonce") ? vars.get_opt_bin("Nonce") : std::vector<uint8_t>(64);	40✔
57
58	const Botan::Roughtime::Nonce nonce(nonce_bits);	17✔
59	try {	17✔
60	const auto response = Botan::Roughtime::Response::from_bits(response_v, nonce);	17✔
61
62	const auto pubkey = vars.get_req_bin("Pubkey");	4✔
63	if(pubkey.size() != 32)	4✔
64	throw Test_Error("Unexpected Roughtime Ed25519 pubkey size");	×
65
66	if(!response.validate(Botan::Ed25519_PublicKey(pubkey))) {	4✔
67	result.confirm("fail_validation", type == "Invalid");	2✔
68	} else {
69	const auto midpoint = Botan::Roughtime::Response::sys_microseconds64(	3✔
70	std::chrono::microseconds(vars.get_req_u64("MidpointMicroSeconds")));	3✔
71	const auto radius = std::chrono::microseconds(vars.get_req_u32("RadiusMicroSeconds"));	3✔
72
73	result.confirm("midpoint", response.utc_midpoint() == midpoint);	6✔
74	result.confirm("radius", response.utc_radius() == radius);	6✔
75	result.confirm("OK", type == "Valid");	6✔
76	}
77	} catch(const Botan::Roughtime::Roughtime_Error& e) { result.confirm(e.what(), type == "Invalid"); }	43✔
78
79	return result;	17✔
80	}	34✔
81	};
82
83	BOTAN_REGISTER_TEST("roughtime", "roughtime_response", Roughtime_Response_Tests);
84
85	class Roughtime_nonce_from_blind_Tests final : public Text_Based_Test {	×
86	public:
87	Roughtime_nonce_from_blind_Tests() :	1✔
88	Text_Based_Test("roughtime/roughtime_nonce_from_blind.vec", "Response,Blind,Nonce") {}	3✔
89
90	Test::Result run_one_test(const std::string& type, const VarMap& vars) override {	2✔
91	Test::Result result("roughtime nonce_from_blind");	2✔
92
93	const auto response = vars.get_req_bin("Response");	2✔
94	const auto blind = vars.get_req_bin("Blind");	2✔
95	const auto nonce = vars.get_req_bin("Nonce");	2✔
96
97	result.test_eq(	4✔
98	"fail_validation", Botan::Roughtime::nonce_from_blind(response, blind) == nonce, type == "Valid");	2✔
99
100	return result;	2✔
101	}	6✔
102	};
103
104	BOTAN_REGISTER_TEST("roughtime", "roughtime_nonce_from_blind", Roughtime_nonce_from_blind_Tests);
105
106	class Roughtime final : public Test {	×
107	static Test::Result test_nonce() {	1✔
108	Test::Result result("roughtime nonce");	1✔
109
110	auto rand64 = Botan::unlock(Test::rng().random_vec(64));	2✔
111	Botan::Roughtime::Nonce nonce_v(rand64);	1✔
112	result.confirm("nonce from vector",	2✔
113	nonce_v.get_nonce() == Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));	1✔
114	Botan::Roughtime::Nonce nonce_a(Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));	1✔
115	result.confirm("nonce from array",	1✔
116	nonce_v.get_nonce() == Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));	1✔
117	rand64.push_back(10);	1✔
118	result.test_throws("vector oversize", [&rand64]() { Botan::Roughtime::Nonce nonce_v2(rand64); }); //size 65	3✔
119	rand64.pop_back();	1✔
120	rand64.pop_back();	1✔
121	result.test_throws("vector undersize", [&rand64]() { Botan::Roughtime::Nonce nonce_v2(rand64); }); //size 63	3✔
122
123	return result;	1✔
124	}	1✔
125
126	static Test::Result test_chain() {	1✔
127	Test::Result result("roughtime chain");	1✔
128
129	Botan::Roughtime::Chain c1;	1✔
130	result.confirm("default constructed is empty", c1.links().empty() && c1.responses().empty());	3✔
131
132	auto rand64 = Botan::unlock(Test::rng().random_vec(64));	2✔
133	Botan::Roughtime::Nonce nonce_v(rand64);	1✔
134	result.confirm(	2✔
135	"empty chain nonce is blind",
136	c1.next_nonce(nonce_v).get_nonce() == Botan::typecast_copy<std::array<uint8_t, 64>>(rand64.data()));	1✔
137
138	const std::string chain_str =	1✔
139	"ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA\n"
140	"ed25519 gD63hSj3ScS+wuOeGrubXlq35N1c5Lby/S+T7MNTjxo= uLeTON9D+2HqJMzK6sYWLNDEdtBl9t/9yw1cVAOm0/sONH5Oqdq9dVPkC9syjuWbglCiCPVF+FbOtcxCkrgMmA== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWOw1jl0uSiBEH9HE8/6r7zxoSc01f48vw+UzH8+VJoPelnvVJBj4lnH8uRLh5Aw0i4Du7XM1dp2u0r/I5PzhMQoDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AUBo+tEqPBQC47l77to7ESFTVhlw1SC74P5ssx6gpuJ6eP+1916GuUiySGE/x3Fp0c3otUGAdsRQou5p9PDTeane/YEeVq4/8AgAAAEAAAABTSUcAREVMRe5T1ml8wHyWAcEtHP/U5Rg/jFXTEXOSglngSa4aI/CECVdy4ZNWeP6vv+2//ZW7lQsrWo7ZkXpvm9BdBONRSQIDAAAAIAAAACgAAABQVUJLTUlOVE1BWFQpXlenV0OfVisvp9jDHXLw8vymZVK9Pgw9k6Edf8ZEhUgSGEc5jwUASHLvZE2PBQAAAAAA\n";	1✔
141
142	Botan::Roughtime::Chain c2(chain_str);	1✔
143	result.confirm("have two elements", c2.links().size() == 2 && c2.responses().size() == 2);	3✔
144	result.confirm("serialize loopback", c2.to_string() == chain_str);	3✔
145
146	c1.append(c2.links()[0], 1);	1✔
147	result.confirm("append ok", c1.links().size() == 1 && c1.responses().size() == 1);	2✔
148	c1.append(c2.links()[1], 1);	1✔
149	result.confirm("max size", c1.links().size() == 1 && c1.responses().size() == 1);	2✔
150
151	result.test_throws("non-positive max chain size", [&]() { c1.append(c2.links()[1], 0); });	3✔
152	result.test_throws("1 field", [&]() { Botan::Roughtime::Chain a("ed25519"); });	3✔
153	result.test_throws(	2✔
154	"2 fields", [&]() { Botan::Roughtime::Chain a("ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE="); });	1✔
155	result.test_throws("3 fields", [&]() {	2✔
156	Botan::Roughtime::Chain a(	1✔
157	"ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw==");	1✔
158	});	×
159	result.test_throws("5 fields", [&]() {	2✔
160	Botan::Roughtime::Chain a(	1✔
161	"ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA abc");	1✔
162	});	×
163	result.test_throws("invalid key type", [&]() {	2✔
164	Botan::Roughtime::Chain a(	1✔
165	"rsa bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA");	1✔
166	});	×
167	result.test_throws("invalid key", [&]() {	2✔
168	Botan::Roughtime::Chain a(	1✔
169	"ed25519 bbT+RPS7zKX6wssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2YVmrIktUByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA");	1✔
170	});	×
171	result.test_throws("invalid nonce", [&]() {	2✔
172	Botan::Roughtime::Chain a(	1✔
173	"ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= eu9yhsJfVfguVSqGZdE8WKIxaBBM0ZG3Vmuc+IyZmG2UByDdwIFw6F4rZqmSFsBO85ljoVPz5bVPCOw== BQAAAEAAAABAAAAApAAAADwBAABTSUcAUEFUSFNSRVBDRVJUSU5EWBnGOEajOwPA6G7oL47seBP4C7eEpr57H43C2/fK/kMA0UGZVUdf4KNX8oxOK6JIcsbVk8qhghTwA70qtwpYmQkDAAAABAAAAAwAAABSQURJTUlEUFJPT1RAQg8AJrA8tEqPBQAqisiuAxgy2Pj7UJAiWbCdzGz1xcCnja3T+AqhC8fwpeIwW4GPy/vEb/awXW2DgSLKJfzWIAz+2lsR7t4UjNPvAgAAAEAAAABTSUcAREVMRes9Ch4X0HIw5KdOTB8xK4VDFSJBD/G9t7Et/CU7UW61OiTBXYYQTG2JekWZmGa0OHX1JPGG+APkpbsNw0BKUgYDAAAAIAAAACgAAABQVUJLTUlOVE1BWFR/9BWjpsWTQ1f6iUJea3EfZ1MkX3ftJiV3ABqNLpncFwAAAAAAAAAA//////////8AAAAA");	1✔
174	});	×
175
176	return result;	1✔
177	}	3✔
178
179	static Test::Result test_server_information() {	1✔
180	Test::Result result("roughtime server_information");	1✔
181
182	const auto servers = Botan::Roughtime::servers_from_str(	1✔
183	"Chainpoint-Roughtime ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp roughtime.chainpoint.org:2002\n"
184	"Cloudflare-Roughtime ed25519 gD63hSj3ScS+wuOeGrubXlq35N1c5Lby/S+T7MNTjxo= udp roughtime.cloudflare.com:2002\n"
185	"Google-Sandbox-Roughtime ed25519 etPaaIxcBMY1oUeGpwvPMCJMwlRVNxv51KK/tktoJTQ= udp roughtime.sandbox.google.com:2002\n"
186	"int08h-Roughtime ed25519 AW5uAoTSTDfG5NfY1bTh08GUnOqlRb+HVhbJ3ODJvsE= udp roughtime.int08h.com:2002\n"
187	"ticktock ed25519 cj8GsiNlRkqiDElAeNMSBBMwrAl15hYPgX50+GWX/lA= udp ticktock.mixmin.net:5333\n");	1✔
188
189	result.confirm("size", servers.size() == 5);	2✔
190	result.test_eq("name", servers[0].name(), "Chainpoint-Roughtime");	4✔
191	result.test_eq("name", servers[4].name(), "ticktock");	3✔
192	result.confirm(	3✔
193	"public key",
194	servers[0].public_key().get_public_key() ==	1✔
195	Botan::Ed25519_PublicKey(Botan::base64_decode("bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE="))	3✔
196	.get_public_key());
197	result.confirm("single address", servers[0].addresses().size() == 1);	2✔
198	result.test_eq("address", servers[0].addresses()[0], "roughtime.chainpoint.org:2002");	2✔
199
200	result.test_throws("1 field", [&]() { Botan::Roughtime::servers_from_str("A"); });	3✔
201	result.test_throws("2 fields", [&]() { Botan::Roughtime::servers_from_str("A ed25519"); });	3✔
202	result.test_throws("3 fields", [&]() {	2✔
203	Botan::Roughtime::servers_from_str("A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE=");	1✔
204	});	×
205	result.test_throws("4 fields", [&]() {	2✔
206	Botan::Roughtime::servers_from_str("A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp");	1✔
207	});	×
208	result.test_throws("invalid address", [&]() {	2✔
209	Botan::Roughtime::servers_from_str("A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp ");	1✔
210	});	×
211	result.test_throws("invalid key type", [&]() {	2✔
212	Botan::Roughtime::servers_from_str(	1✔
213	"A rsa bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp roughtime.chainpoint.org:2002");
214	});	×
215	result.test_throws("invalid key", [&]() {	2✔
216	Botan::Roughtime::servers_from_str(	1✔
217	"A ed25519 bbT+RP7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= udp roughtime.chainpoint.org:2002");
218	});	×
219	result.test_throws("invalid protocol", [&]() {	2✔
220	Botan::Roughtime::servers_from_str(	1✔
221	"A ed25519 bbT+RPS7zKX6w71ssPibzmwWqU9ffRV5oj2OresSmhE= tcp roughtime.chainpoint.org:2002");
222	});	×
223
224	return result;	1✔
225	}	1✔
226
227	static Test::Result test_request_online() {	1✔
228	Test::Result result("roughtime request online");	1✔
229
230	Botan::Roughtime::Nonce nonce(Test::rng());	1✔
231	try {	1✔
232	const auto response_raw =	1✔
233	Botan::Roughtime::online_request("roughtime.cloudflare.com:2002", nonce, std::chrono::seconds(5));	1✔
234	const auto now = std::chrono::system_clock::now();	1✔
235	const auto response = Botan::Roughtime::Response::from_bits(response_raw, nonce);	1✔
236	std::chrono::milliseconds local_clock_max_error(1000);	1✔
237	const auto diff_abs =	1✔
238	now >= response.utc_midpoint() ? now - response.utc_midpoint() : response.utc_midpoint() - now;	2✔
239	result.confirm("online", diff_abs <= (response.utc_radius() + local_clock_max_error));	3✔
240	} catch(const std::exception& e) { result.test_failure(e.what()); }	1✔
241	return result;	1✔
242	}	×
243
244	public:
245	std::vector<Test::Result> run() override {	1✔
246	std::vector<Test::Result> results;	1✔
247	results.push_back(test_nonce());	2✔
248	results.push_back(test_chain());	2✔
249	results.push_back(test_server_information());	2✔
250
251	if(Test::options().run_online_tests()) {	1✔
252	results.push_back(test_request_online());	2✔
253	}
254
255	return results;	1✔
256	}	×
257	};
258
259	BOTAN_REGISTER_TEST("roughtime", "roughtime_tests", Roughtime);
260
261	#endif
262
263	} // namespace Botan_Tests

randombit / botan / 5111374265

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous