16293079084

Committed 15 Jul 2025 12:20PM UTC coverage: 90.627% (+0.003%) from 90.624%

Build # 16293079084

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4990 from randombit/jack/string-and-span

Improve string<->span conversions

Run Details

99640 of 109945 relevant lines covered (90.63%)

12253617.72 hits per line

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

88.52

/src/tests/test_ecc_h2c.cpp

/*
* (C) 2019,2020 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "tests.h"

#if defined(BOTAN_HAS_ECC_GROUP)
   #include <botan/ec_group.h>
#endif

#if defined(BOTAN_HAS_XMD)
   #include <botan/internal/mem_utils.h>
   #include <botan/internal/xmd.h>
#endif

namespace Botan_Tests {

namespace {

#if defined(BOTAN_HAS_XMD)

class ECC_H2C_XMD_Tests final : public Text_Based_Test {
   public:
      ECC_H2C_XMD_Tests() : Text_Based_Test("pubkey/ec_h2c_xmd.vec", "Domain,Input,Output") {}

      bool clear_between_callbacks() const override { return false; }

      Test::Result run_one_test(const std::string& hash, const VarMap& vars) override {
         Test::Result result("ECC hash to curve XMD " + hash);

         const std::string domain = vars.get_req_str("Domain");
         const std::string input = vars.get_req_str("Input");
         const std::vector<uint8_t> expected = vars.get_req_bin("Output");

         std::vector<uint8_t> output(expected.size());
         Botan::expand_message_xmd(hash, output, Botan::as_span_of_bytes(input), Botan::as_span_of_bytes(domain));

         result.test_eq("XMD output", output, expected);
         return result;
      }
};

BOTAN_REGISTER_TEST("ec_h2c", "ec_h2c_xmd", ECC_H2C_XMD_Tests);

#endif

#if defined(BOTAN_HAS_XMD) && defined(BOTAN_HAS_ECC_GROUP)

class ECC_H2S_Tests final : public Text_Based_Test {
   public:
      ECC_H2S_Tests() : Text_Based_Test("pubkey/ec_h2s.vec", "Hash,Domain,Input,Output") {}

      bool clear_between_callbacks() const override { return false; }

      bool skip_this_test(const std::string& group_id, const VarMap& /*vars*/) override {
         return !Botan::EC_Group::supports_named_group(group_id);
      }

      Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {
         Test::Result result("ECC hash to scalar " + group_id);

         const std::string hash_fn = vars.get_req_str("Hash");
         const std::string domain_str = vars.get_req_str("Domain");
         const std::string input_str = vars.get_req_str("Input");
         const std::vector<uint8_t> expected_value = vars.get_req_bin("Output");

         auto input = std::span{reinterpret_cast<const uint8_t*>(input_str.data()), input_str.size()};
         auto domain = std::span{reinterpret_cast<const uint8_t*>(domain_str.data()), domain_str.size()};

         const auto group = Botan::EC_Group::from_name(group_id);

         try {
            auto scalar = Botan::EC_Scalar::hash(group, hash_fn, input, domain).serialize();
            result.test_eq("output", scalar, expected_value);
         } catch(Botan::Not_Implemented&) {
            result.test_note("Skipping due to not implemented");
         }

         return result;
      }
};

BOTAN_REGISTER_TEST("ec_h2c", "ec_h2s_kat", ECC_H2S_Tests);

#endif

#if defined(BOTAN_HAS_EC_HASH_TO_CURVE)

class ECC_H2C_Tests final : public Text_Based_Test {
   public:
      ECC_H2C_Tests() : Text_Based_Test("pubkey/ec_h2c.vec", "Group,Hash,Domain,Input,Point") {}

      bool clear_between_callbacks() const override { return false; }

      bool skip_this_test(const std::string& /*header*/, const VarMap& vars) override {
         return !Botan::EC_Group::supports_named_group(vars.get_req_str("Group"));
      }

      Test::Result run_one_test(const std::string& method, const VarMap& vars) override {
         const std::string group_id = vars.get_req_str("Group");

         Test::Result result("ECC hash to curve " + method + " " + group_id);

         const std::string hash_fn = vars.get_req_str("Hash");
         const std::string domain_str = vars.get_req_str("Domain");
         const std::vector<uint8_t> input = vars.get_req_bin("Input");
         const std::vector<uint8_t> expected_point = vars.get_req_bin("Point");
         const bool random_oracle = method.find("-RO") != std::string::npos;

         auto domain = std::span{reinterpret_cast<const uint8_t*>(domain_str.data()), domain_str.size()};

         const auto group = Botan::EC_Group::from_name(group_id);

         try {
            std::vector<uint8_t> pt;
            if(random_oracle) {
               pt = Botan::EC_AffinePoint::hash_to_curve_ro(group, hash_fn, input, domain).serialize_uncompressed();
            } else {
               pt = Botan::EC_AffinePoint::hash_to_curve_nu(group, hash_fn, input, domain).serialize_uncompressed();
            }

            result.test_eq("Generated point serialization", pt, expected_point);
         } catch(Botan::Not_Implemented&) {
            result.test_note("Skipping due to not implemented");
         }

         return result;
      }
};

BOTAN_REGISTER_TEST("ec_h2c", "ec_h2c_kat", ECC_H2C_Tests);

#endif

}  // namespace

}  // namespace Botan_Tests

1	/*
2	* (C) 2019,2020 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include "tests.h"
8
9	#if defined(BOTAN_HAS_ECC_GROUP)
10	#include <botan/ec_group.h>
11	#endif
12
13	#if defined(BOTAN_HAS_XMD)
14	#include <botan/internal/mem_utils.h>
15	#include <botan/internal/xmd.h>
16	#endif
17
18	namespace Botan_Tests {
19
20	namespace {
21
22	#if defined(BOTAN_HAS_XMD)
23
24	class ECC_H2C_XMD_Tests final : public Text_Based_Test {	×
25	public:
26	ECC_H2C_XMD_Tests() : Text_Based_Test("pubkey/ec_h2c_xmd.vec", "Domain,Input,Output") {}	2✔
27
28	bool clear_between_callbacks() const override { return false; }	20✔
29
30	Test::Result run_one_test(const std::string& hash, const VarMap& vars) override {	20✔
31	Test::Result result("ECC hash to curve XMD " + hash);	20✔
32
33	const std::string domain = vars.get_req_str("Domain");	20✔
34	const std::string input = vars.get_req_str("Input");	20✔
35	const std::vector<uint8_t> expected = vars.get_req_bin("Output");	20✔
36
37	std::vector<uint8_t> output(expected.size());	20✔
38	Botan::expand_message_xmd(hash, output, Botan::as_span_of_bytes(input), Botan::as_span_of_bytes(domain));	20✔
39
40	result.test_eq("XMD output", output, expected);	40✔
41	return result;	20✔
42	}	40✔
43	};
44
45	BOTAN_REGISTER_TEST("ec_h2c", "ec_h2c_xmd", ECC_H2C_XMD_Tests);
46
47	#endif
48
49	#if defined(BOTAN_HAS_XMD) && defined(BOTAN_HAS_ECC_GROUP)
50
51	class ECC_H2S_Tests final : public Text_Based_Test {	×
52	public:
53	ECC_H2S_Tests() : Text_Based_Test("pubkey/ec_h2s.vec", "Hash,Domain,Input,Output") {}	2✔
54
55	bool clear_between_callbacks() const override { return false; }	18✔
56
57	bool skip_this_test(const std::string& group_id, const VarMap& /vars/) override {	18✔
58	return !Botan::EC_Group::supports_named_group(group_id);	18✔
59	}
60
61	Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {	18✔
62	Test::Result result("ECC hash to scalar " + group_id);	18✔
63
64	const std::string hash_fn = vars.get_req_str("Hash");	18✔
65	const std::string domain_str = vars.get_req_str("Domain");	18✔
66	const std::string input_str = vars.get_req_str("Input");	18✔
67	const std::vector<uint8_t> expected_value = vars.get_req_bin("Output");	18✔
68
69	auto input = std::span{reinterpret_cast<const uint8_t*>(input_str.data()), input_str.size()};	18✔
70	auto domain = std::span{reinterpret_cast<const uint8_t*>(domain_str.data()), domain_str.size()};	18✔
71
72	const auto group = Botan::EC_Group::from_name(group_id);	18✔
73
74	try {	18✔
75	auto scalar = Botan::EC_Scalar::hash(group, hash_fn, input, domain).serialize();	18✔
76	result.test_eq("output", scalar, expected_value);	36✔
77	} catch(Botan::Not_Implemented&) {	18✔
78	result.test_note("Skipping due to not implemented");	×
79	}	×
80
81	return result;	36✔
82	}	36✔
83	};
84
85	BOTAN_REGISTER_TEST("ec_h2c", "ec_h2s_kat", ECC_H2S_Tests);
86
87	#endif
88
89	#if defined(BOTAN_HAS_EC_HASH_TO_CURVE)
90
91	class ECC_H2C_Tests final : public Text_Based_Test {	×
92	public:
93	ECC_H2C_Tests() : Text_Based_Test("pubkey/ec_h2c.vec", "Group,Hash,Domain,Input,Point") {}	2✔
94
95	bool clear_between_callbacks() const override { return false; }	43✔
96
97	bool skip_this_test(const std::string& /header/, const VarMap& vars) override {	43✔
98	return !Botan::EC_Group::supports_named_group(vars.get_req_str("Group"));	43✔
99	}
100
101	Test::Result run_one_test(const std::string& method, const VarMap& vars) override {	43✔
102	const std::string group_id = vars.get_req_str("Group");	43✔
103
104	Test::Result result("ECC hash to curve " + method + " " + group_id);	129✔
105
106	const std::string hash_fn = vars.get_req_str("Hash");	43✔
107	const std::string domain_str = vars.get_req_str("Domain");	43✔
108	const std::vector<uint8_t> input = vars.get_req_bin("Input");	43✔
109	const std::vector<uint8_t> expected_point = vars.get_req_bin("Point");	43✔
110	const bool random_oracle = method.find("-RO") != std::string::npos;	43✔
111
112	auto domain = std::span{reinterpret_cast<const uint8_t*>(domain_str.data()), domain_str.size()};	43✔
113
114	const auto group = Botan::EC_Group::from_name(group_id);	43✔
115
116	try {	43✔
117	std::vector<uint8_t> pt;	43✔
118	if(random_oracle) {	43✔
119	pt = Botan::EC_AffinePoint::hash_to_curve_ro(group, hash_fn, input, domain).serialize_uncompressed();	40✔
120	} else {
121	pt = Botan::EC_AffinePoint::hash_to_curve_nu(group, hash_fn, input, domain).serialize_uncompressed();	46✔
122	}
123
124	result.test_eq("Generated point serialization", pt, expected_point);	86✔
125	} catch(Botan::Not_Implemented&) {	43✔
126	result.test_note("Skipping due to not implemented");	×
127	}	×
128
129	return result;	86✔
130	}	129✔
131	};
132
133	BOTAN_REGISTER_TEST("ec_h2c", "ec_h2c_kat", ECC_H2C_Tests);
134
135	#endif
136
137	} // namespace
138
139	} // namespace Botan_Tests

randombit / botan / 16293079084

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