12661312886

Committed 07 Jan 2025 11:55PM UTC coverage: 91.251% (-0.02%) from 91.267%

Build # 12661312886

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4518 from randombit/jack/ec-point-cleanups

Move EC_Point and related code to deprecated submodule

Run Details

93407 of 102363 relevant lines covered (91.25%)

11518305.49 hits per line

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

93.29

/src/tests/test_ecc_pointmul.cpp

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

#include "tests.h"

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

namespace Botan_Tests {

namespace {

#if defined(BOTAN_HAS_ECC_GROUP)

class ECC_Basepoint_Mul_Tests final : public Text_Based_Test {
   public:
      ECC_Basepoint_Mul_Tests() : Text_Based_Test("pubkey/ecc_base_point_mul.vec", "k,P") {}

      Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {
         Test::Result result("ECC base point multiply " + group_id);

         const auto k_bytes = vars.get_req_bin("k");
         const auto P_bytes = vars.get_req_bin("P");

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

         const Botan::BigInt k(k_bytes);
         std::vector<Botan::BigInt> ws;

   #if defined(BOTAN_HAS_LEGACY_EC_POINT)
         const auto pt = group.OS2ECP(P_bytes);

         const Botan::EC_Point& base_point = group.get_base_point();

         const Botan::EC_Point p1 = base_point * k;
         result.test_eq("mul with *", p1, pt);

         const Botan::EC_Point p2 = group.blinded_base_point_multiply(k, this->rng(), ws);
         result.test_eq("blinded_base_point_multiply", p2, pt);

         const Botan::EC_Point p3 = group.blinded_var_point_multiply(base_point, k, this->rng(), ws);
         result.test_eq("blinded_var_point_multiply", p3, pt);
   #endif

         const auto scalar = Botan::EC_Scalar::from_bigint(group, k);
         const auto apg = Botan::EC_AffinePoint::g_mul(scalar, this->rng(), ws);
         result.test_eq("AffinePoint::g_mul", apg.serialize_uncompressed(), P_bytes);

         const auto ag = Botan::EC_AffinePoint::generator(group);
         const auto ap = ag.mul(scalar, this->rng(), ws);
         result.test_eq("AffinePoint::mul", ap.serialize_uncompressed(), P_bytes);

         return result;
      }
};

BOTAN_REGISTER_TEST("pubkey", "ecc_basemul", ECC_Basepoint_Mul_Tests);

class ECC_Varpoint_Mul_Tests final : public Text_Based_Test {
   public:
      ECC_Varpoint_Mul_Tests() : Text_Based_Test("pubkey/ecc_var_point_mul.vec", "P,k,Z") {}

      Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {
         Test::Result result("ECC var point multiply " + group_id);

         const auto p = vars.get_req_bin("P");
         const Botan::BigInt k = vars.get_req_bn("k");
         const auto z = vars.get_req_bin("Z");

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

         std::vector<Botan::BigInt> ws;

   #if defined(BOTAN_HAS_LEGACY_EC_POINT)
         const Botan::EC_Point pt = group.OS2ECP(p);

         result.confirm("Input point is on the curve", pt.on_the_curve());

         const Botan::EC_Point p1 = pt * k;
         result.test_eq("p * k", p1.encode(Botan::EC_Point::Compressed), z);

         result.confirm("Output point is on the curve", p1.on_the_curve());

         const Botan::EC_Point p2 = group.blinded_var_point_multiply(pt, k, this->rng(), ws);
         result.test_eq("p * k (blinded)", p2.encode(Botan::EC_Point::Compressed), z);
   #endif

         const auto s_k = Botan::EC_Scalar::from_bigint(group, k);
         const auto apt = Botan::EC_AffinePoint::deserialize(group, p).value();
         const auto apt_k = apt.mul(s_k, this->rng(), ws);
         result.test_eq("p * k (AffinePoint)", apt_k.serialize_compressed(), z);

         const auto apt_k_neg = apt.negate().mul(s_k.negate(), this->rng(), ws);
         result.test_eq("-p * -k (AffinePoint)", apt_k_neg.serialize_compressed(), z);

         const auto neg_apt_neg_k = apt.mul(s_k.negate(), this->rng(), ws).negate();
         result.test_eq("-(p * -k) (AffinePoint)", neg_apt_neg_k.serialize_compressed(), z);

         return result;
      }
};

BOTAN_REGISTER_TEST("pubkey", "ecc_varmul", ECC_Varpoint_Mul_Tests);

class ECC_Mul2_Tests final : public Text_Based_Test {
   public:
      ECC_Mul2_Tests() : Text_Based_Test("pubkey/ecc_var_point_mul2.vec", "P,x,Q,y,Z") {}

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

         const auto Z_bytes = vars.get_req_bin("Z");

         const auto check_px_qy = [&](const char* what,
                                      const Botan::EC_AffinePoint& p,
                                      const Botan::EC_Scalar& x,
                                      const Botan::EC_AffinePoint& q,
                                      const Botan::EC_Scalar& y,
                                      bool with_final_negation = false) {
            if(const auto z = Botan::EC_AffinePoint::mul_px_qy(p, x, q, y, rng())) {
               if(with_final_negation) {
                  result.test_eq(what, z->negate().serialize_compressed(), Z_bytes);
               } else {
                  result.test_eq(what, z->serialize_compressed(), Z_bytes);
               }
            } else {
               result.test_failure("EC_AffinePoint::mul_px_qy failed to produce a result");
            }

            // Now check the same using naive multiply and add:
            std::vector<BigInt> ws;
            auto z = p.mul(x, rng(), ws).add(q.mul(y, rng(), ws));
            if(with_final_negation) {
               z = z.negate();
            }
            result.test_eq("p*x + q*y naive", z.serialize_compressed(), Z_bytes);
         };

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

         const auto p = Botan::EC_AffinePoint::deserialize(group, vars.get_req_bin("P")).value();
         const auto q = Botan::EC_AffinePoint::deserialize(group, vars.get_req_bin("Q")).value();
         const auto x = Botan::EC_Scalar::from_bigint(group, vars.get_req_bn("x"));
         const auto y = Botan::EC_Scalar::from_bigint(group, vars.get_req_bn("y"));

         const auto np = p.negate();
         const auto nq = q.negate();
         const auto nx = x.negate();
         const auto ny = y.negate();

         check_px_qy("p*x + q*y", p, x, q, y);
         check_px_qy("-p*-x + -q*-y", np, nx, nq, ny);
         check_px_qy("-(p*-x + q*-y)", p, nx, q, ny, true);
         check_px_qy("-(-p*x + -q*y)", np, x, nq, y, true);

         return result;
      }
};

BOTAN_REGISTER_TEST("pubkey", "ecc_mul2", ECC_Mul2_Tests);

class ECC_Mul2_Inf_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         std::vector<Test::Result> results;

         for(const auto& group_id : Botan::EC_Group::known_named_groups()) {
            Test::Result result("ECC mul2 inf " + group_id);

            const auto check_px_qy = [&](const char* what,
                                         const Botan::EC_AffinePoint& p,
                                         const Botan::EC_Scalar& x,
                                         const Botan::EC_AffinePoint& q,
                                         const Botan::EC_Scalar& y) {
               if(const auto z = Botan::EC_AffinePoint::mul_px_qy(p, x, q, y, rng())) {
                  result.test_failure(Botan::fmt("EC_AffinePoint::mul_px_qy {} unexpectedly produced a result", what));
               } else {
                  result.test_success(Botan::fmt("EC_AffinePoint::mul_px_qy {} returned nullopt as expected", what));
               }
            };

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

            const auto g = Botan::EC_AffinePoint::generator(group);

            // Choose some other random point z
            std::vector<Botan::BigInt> ws;
            const auto z = g.mul(Botan::EC_Scalar::random(group, rng()), rng(), ws);

            const auto r = Botan::EC_Scalar::random(group, rng());
            const auto neg_r = r.negate();
            const auto neg_r2 = neg_r + neg_r;

            const auto zero = r - r;
            result.confirm("Computed EC_Scalar is zero", zero.is_zero());

            const auto g2 = g.add(g);

            const auto id = Botan::EC_AffinePoint::identity(group);

            check_px_qy("0*g + r*id", g, zero, id, r);
            check_px_qy("0*id + r*id", id, zero, id, r);
            check_px_qy("0*g + 0*z", g, zero, z, zero);
            check_px_qy("r*g + -r*g", g, r, g, neg_r);
            check_px_qy("-r*g + r*g", g, neg_r, g, r);
            check_px_qy("r*g + r*-g", g, r, g.negate(), r);
            check_px_qy("r*g2 + -r2*g", g2, r, g, neg_r2);

            results.push_back(result);
         }

         return results;
      }
};

BOTAN_REGISTER_TEST("pubkey", "ecc_mul2_inf", ECC_Mul2_Inf_Tests);

class ECC_Addition_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         std::vector<Test::Result> results;

         for(const auto& group_id : Botan::EC_Group::known_named_groups()) {
            Test::Result result("ECC addition " + group_id);

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

            const auto g = Botan::EC_AffinePoint::generator(group);
            result.test_eq("g is not the identity element", g.is_identity(), false);

            // Choose some other random point z
            std::vector<Botan::BigInt> ws;
            const auto z = g.mul(Botan::EC_Scalar::random(group, rng()), rng(), ws);
            result.test_eq("z is not the identity element", z.is_identity(), false);

            const auto id = Botan::EC_AffinePoint::identity(group);
            result.test_eq("id is the identity element", id.is_identity(), true);

            const auto g_bytes = g.serialize_uncompressed();

            auto check_expr_is_g = [&](const char* msg, const Botan::EC_AffinePoint& pt) {
               result.test_eq(Botan::fmt("{} is g", msg), pt.serialize_uncompressed(), g_bytes);
            };

            const auto nz = z.negate();

            check_expr_is_g("g + id", g.add(id));
            check_expr_is_g("id + g", id.add(g));
            check_expr_is_g("g + id", g.add(id));
            check_expr_is_g("g + -id", g.add(id.negate()));
            check_expr_is_g("g + g + -g", g.add(g).add(g.negate()));
            check_expr_is_g("-id + g", id.negate().add(g));
            check_expr_is_g("z + g - z", z.add(g).add(nz));
            check_expr_is_g("z - z + g", z.add(nz).add(g));
            check_expr_is_g("z + z + g - z - z", z.add(z).add(g).add(nz).add(nz));
            check_expr_is_g("z + id + g + z - z - z", z.add(id).add(g).add(z).add(nz).add(nz));

            results.push_back(result);
         }

         return results;
      }
};

BOTAN_REGISTER_TEST("pubkey", "ecc_addition", ECC_Addition_Tests);

#endif

}  // namespace

}  // namespace Botan_Tests

1	/*
2	* (C) 2014,2015,2019 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/bigint.h>
11	#include <botan/ec_group.h>
12	#include <botan/internal/fmt.h>
13	#endif
14
15	namespace Botan_Tests {
16
17	namespace {
18
19	#if defined(BOTAN_HAS_ECC_GROUP)
20
21	class ECC_Basepoint_Mul_Tests final : public Text_Based_Test {	×
22	public:
23	ECC_Basepoint_Mul_Tests() : Text_Based_Test("pubkey/ecc_base_point_mul.vec", "k,P") {}	2✔
24
25	Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {	533✔
26	Test::Result result("ECC base point multiply " + group_id);	533✔
27
28	const auto k_bytes = vars.get_req_bin("k");	533✔
29	const auto P_bytes = vars.get_req_bin("P");	533✔
30
31	const auto group = Botan::EC_Group::from_name(group_id);	533✔
32
33	const Botan::BigInt k(k_bytes);	533✔
34	std::vector<Botan::BigInt> ws;	533✔
35
36	#if defined(BOTAN_HAS_LEGACY_EC_POINT)
37	const auto pt = group.OS2ECP(P_bytes);	533✔
38
39	const Botan::EC_Point& base_point = group.get_base_point();	533✔
40
41	const Botan::EC_Point p1 = base_point * k;	533✔
42	result.test_eq("mul with *", p1, pt);	533✔
43
44	const Botan::EC_Point p2 = group.blinded_base_point_multiply(k, this->rng(), ws);	533✔
45	result.test_eq("blinded_base_point_multiply", p2, pt);	533✔
46
47	const Botan::EC_Point p3 = group.blinded_var_point_multiply(base_point, k, this->rng(), ws);	533✔
48	result.test_eq("blinded_var_point_multiply", p3, pt);	533✔
49	#endif
50
51	const auto scalar = Botan::EC_Scalar::from_bigint(group, k);	533✔
52	const auto apg = Botan::EC_AffinePoint::g_mul(scalar, this->rng(), ws);	533✔
53	result.test_eq("AffinePoint::g_mul", apg.serialize_uncompressed(), P_bytes);	1,066✔
54
55	const auto ag = Botan::EC_AffinePoint::generator(group);	533✔
56	const auto ap = ag.mul(scalar, this->rng(), ws);	533✔
57	result.test_eq("AffinePoint::mul", ap.serialize_uncompressed(), P_bytes);	1,066✔
58
59	return result;	1,066✔
60	}	2,132✔
61	};
62
63	BOTAN_REGISTER_TEST("pubkey", "ecc_basemul", ECC_Basepoint_Mul_Tests);
64
65	class ECC_Varpoint_Mul_Tests final : public Text_Based_Test {	×
66	public:
67	ECC_Varpoint_Mul_Tests() : Text_Based_Test("pubkey/ecc_var_point_mul.vec", "P,k,Z") {}	2✔
68
69	Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {	829✔
70	Test::Result result("ECC var point multiply " + group_id);	829✔
71
72	const auto p = vars.get_req_bin("P");	829✔
73	const Botan::BigInt k = vars.get_req_bn("k");	829✔
74	const auto z = vars.get_req_bin("Z");	829✔
75
76	const auto group = Botan::EC_Group::from_name(group_id);	829✔
77
78	std::vector<Botan::BigInt> ws;	829✔
79
80	#if defined(BOTAN_HAS_LEGACY_EC_POINT)
81	const Botan::EC_Point pt = group.OS2ECP(p);	829✔
82
83	result.confirm("Input point is on the curve", pt.on_the_curve());	1,658✔
84
85	const Botan::EC_Point p1 = pt * k;	829✔
86	result.test_eq("p * k", p1.encode(Botan::EC_Point::Compressed), z);	1,658✔
87
88	result.confirm("Output point is on the curve", p1.on_the_curve());	1,658✔
89
90	const Botan::EC_Point p2 = group.blinded_var_point_multiply(pt, k, this->rng(), ws);	829✔
91	result.test_eq("p * k (blinded)", p2.encode(Botan::EC_Point::Compressed), z);	1,658✔
92	#endif
93
94	const auto s_k = Botan::EC_Scalar::from_bigint(group, k);	829✔
95	const auto apt = Botan::EC_AffinePoint::deserialize(group, p).value();	1,658✔
96	const auto apt_k = apt.mul(s_k, this->rng(), ws);	829✔
97	result.test_eq("p * k (AffinePoint)", apt_k.serialize_compressed(), z);	1,658✔
98
99	const auto apt_k_neg = apt.negate().mul(s_k.negate(), this->rng(), ws);	829✔
100	result.test_eq("-p * -k (AffinePoint)", apt_k_neg.serialize_compressed(), z);	1,658✔
101
102	const auto neg_apt_neg_k = apt.mul(s_k.negate(), this->rng(), ws).negate();	829✔
103	result.test_eq("-(p * -k) (AffinePoint)", neg_apt_neg_k.serialize_compressed(), z);	1,658✔
104
105	return result;	1,658✔
106	}	3,316✔
107	};
108
109	BOTAN_REGISTER_TEST("pubkey", "ecc_varmul", ECC_Varpoint_Mul_Tests);
110
111	class ECC_Mul2_Tests final : public Text_Based_Test {	×
112	public:
113	ECC_Mul2_Tests() : Text_Based_Test("pubkey/ecc_var_point_mul2.vec", "P,x,Q,y,Z") {}	2✔
114
115	Test::Result run_one_test(const std::string& group_id, const VarMap& vars) override {	819✔
116	Test::Result result("ECC mul2 " + group_id);	819✔
117
118	const auto Z_bytes = vars.get_req_bin("Z");	819✔
119
120	const auto check_px_qy = [&](const char* what,	4,095✔
121	const Botan::EC_AffinePoint& p,
122	const Botan::EC_Scalar& x,
123	const Botan::EC_AffinePoint& q,
124	const Botan::EC_Scalar& y,
125	bool with_final_negation = false) {
126	if(const auto z = Botan::EC_AffinePoint::mul_px_qy(p, x, q, y, rng())) {	3,276✔
127	if(with_final_negation) {	3,276✔
128	result.test_eq(what, z->negate().serialize_compressed(), Z_bytes);	4,914✔
129	} else {
130	result.test_eq(what, z->serialize_compressed(), Z_bytes);	4,914✔
131	}
132	} else {
133	result.test_failure("EC_AffinePoint::mul_px_qy failed to produce a result");	×
134	}	×
135
136	// Now check the same using naive multiply and add:
137	std::vector<BigInt> ws;	3,276✔
138	auto z = p.mul(x, rng(), ws).add(q.mul(y, rng(), ws));	3,276✔
139	if(with_final_negation) {	3,276✔
140	z = z.negate();	1,638✔
141	}
142	result.test_eq("px + qy naive", z.serialize_compressed(), Z_bytes);	6,552✔
143	};	3,276✔
144
145	const auto group = Botan::EC_Group::from_name(group_id);	819✔
146
147	const auto p = Botan::EC_AffinePoint::deserialize(group, vars.get_req_bin("P")).value();	3,276✔
148	const auto q = Botan::EC_AffinePoint::deserialize(group, vars.get_req_bin("Q")).value();	3,276✔
149	const auto x = Botan::EC_Scalar::from_bigint(group, vars.get_req_bn("x"));	1,638✔
150	const auto y = Botan::EC_Scalar::from_bigint(group, vars.get_req_bn("y"));	1,638✔
151
152	const auto np = p.negate();	819✔
153	const auto nq = q.negate();	819✔
154	const auto nx = x.negate();	819✔
155	const auto ny = y.negate();	819✔
156
157	check_px_qy("px + qy", p, x, q, y);	819✔
158	check_px_qy("-p-x + -q-y", np, nx, nq, ny);	819✔
159	check_px_qy("-(p-x + q-y)", p, nx, q, ny, true);	819✔
160	check_px_qy("-(-px + -qy)", np, x, nq, y, true);	819✔
161
162	return result;	1,638✔
163	}	1,638✔
164	};
165
166	BOTAN_REGISTER_TEST("pubkey", "ecc_mul2", ECC_Mul2_Tests);
167
168	class ECC_Mul2_Inf_Tests final : public Test {	×
169	public:
170	std::vector<Test::Result> run() override {	1✔
171	std::vector<Test::Result> results;	1✔
172
173	for(const auto& group_id : Botan::EC_Group::known_named_groups()) {	29✔
174	Test::Result result("ECC mul2 inf " + group_id);	28✔
175
176	const auto check_px_qy = [&](const char* what,	224✔
177	const Botan::EC_AffinePoint& p,
178	const Botan::EC_Scalar& x,
179	const Botan::EC_AffinePoint& q,
180	const Botan::EC_Scalar& y) {
181	if(const auto z = Botan::EC_AffinePoint::mul_px_qy(p, x, q, y, rng())) {	196✔
182	result.test_failure(Botan::fmt("EC_AffinePoint::mul_px_qy {} unexpectedly produced a result", what));	×
183	} else {
184	result.test_success(Botan::fmt("EC_AffinePoint::mul_px_qy {} returned nullopt as expected", what));	196✔
185	}	196✔
186	};	196✔
187
188	const auto group = Botan::EC_Group::from_name(group_id);	28✔
189
190	const auto g = Botan::EC_AffinePoint::generator(group);	28✔
191
192	// Choose some other random point z
193	std::vector<Botan::BigInt> ws;	28✔
194	const auto z = g.mul(Botan::EC_Scalar::random(group, rng()), rng(), ws);	28✔
195
196	const auto r = Botan::EC_Scalar::random(group, rng());	28✔
197	const auto neg_r = r.negate();	28✔
198	const auto neg_r2 = neg_r + neg_r;	28✔
199
200	const auto zero = r - r;	28✔
201	result.confirm("Computed EC_Scalar is zero", zero.is_zero());	56✔
202
203	const auto g2 = g.add(g);	28✔
204
205	const auto id = Botan::EC_AffinePoint::identity(group);	28✔
206
207	check_px_qy("0g + rid", g, zero, id, r);	28✔
208	check_px_qy("0id + rid", id, zero, id, r);	28✔
209	check_px_qy("0g + 0z", g, zero, z, zero);	28✔
210	check_px_qy("rg + -rg", g, r, g, neg_r);	28✔
211	check_px_qy("-rg + rg", g, neg_r, g, r);	28✔
212	check_px_qy("rg + r-g", g, r, g.negate(), r);	28✔
213	check_px_qy("rg2 + -r2g", g2, r, g, neg_r2);	28✔
214
215	results.push_back(result);	28✔
216	}	28✔
217
218	return results;	1✔
219	}	×
220	};
221
222	BOTAN_REGISTER_TEST("pubkey", "ecc_mul2_inf", ECC_Mul2_Inf_Tests);
223
224	class ECC_Addition_Tests final : public Test {	×
225	public:
226	std::vector<Test::Result> run() override {	1✔
227	std::vector<Test::Result> results;	1✔
228
229	for(const auto& group_id : Botan::EC_Group::known_named_groups()) {	29✔
230	Test::Result result("ECC addition " + group_id);	28✔
231
232	const auto group = Botan::EC_Group::from_name(group_id);	28✔
233
234	const auto g = Botan::EC_AffinePoint::generator(group);	28✔
235	result.test_eq("g is not the identity element", g.is_identity(), false);	28✔
236
237	// Choose some other random point z
238	std::vector<Botan::BigInt> ws;	28✔
239	const auto z = g.mul(Botan::EC_Scalar::random(group, rng()), rng(), ws);	28✔
240	result.test_eq("z is not the identity element", z.is_identity(), false);	28✔
241
242	const auto id = Botan::EC_AffinePoint::identity(group);	28✔
243	result.test_eq("id is the identity element", id.is_identity(), true);	28✔
244
245	const auto g_bytes = g.serialize_uncompressed();	28✔
246
247	auto check_expr_is_g = [&](const char* msg, const Botan::EC_AffinePoint& pt) {	308✔
248	result.test_eq(Botan::fmt("{} is g", msg), pt.serialize_uncompressed(), g_bytes);	560✔
249	};	280✔
250
251	const auto nz = z.negate();	28✔
252
253	check_expr_is_g("g + id", g.add(id));	28✔
254	check_expr_is_g("id + g", id.add(g));	28✔
255	check_expr_is_g("g + id", g.add(id));	28✔
256	check_expr_is_g("g + -id", g.add(id.negate()));	28✔
257	check_expr_is_g("g + g + -g", g.add(g).add(g.negate()));	28✔
258	check_expr_is_g("-id + g", id.negate().add(g));	28✔
259	check_expr_is_g("z + g - z", z.add(g).add(nz));	28✔
260	check_expr_is_g("z - z + g", z.add(nz).add(g));	28✔
261	check_expr_is_g("z + z + g - z - z", z.add(z).add(g).add(nz).add(nz));	28✔
262	check_expr_is_g("z + id + g + z - z - z", z.add(id).add(g).add(z).add(nz).add(nz));	28✔
263
264	results.push_back(result);	28✔
265	}	56✔
266
267	return results;	1✔
268	}	×
269	};
270
271	BOTAN_REGISTER_TEST("pubkey", "ecc_addition", ECC_Addition_Tests);
272
273	#endif
274
275	} // namespace
276
277	} // namespace Botan_Tests

randombit / botan / 12661312886

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