randombit/botan | Build 12939720817 | source/src/lib/math/bigint/divide.cpp | Coveralls

21

void sign_fixup(const BigInt& x, const BigInt& y, BigInt& q, BigInt& r) {

288,968✔

22

   q.cond_flip_sign(x.sign() != y.sign());

288,968✔

24

   if(x.is_negative() && r.is_nonzero()) {

290,585✔

25

      q -= 1;

1,613✔

26

      r = y.abs() - r;

4,839✔

28

288,968✔

30

inline bool division_check(word q, word y2, word y1, word x3, word x2, word x1) {

2,538,374✔

36

   word y3 = 0;

2,538,374✔

37

   y1 = word_madd2(q, y1, &y3);

2,538,374✔

38

   y2 = word_madd2(q, y2, &y3);

2,538,374✔

40

   const word x[3] = {x1, x2, x3};

2,538,374✔

41

   const word y[3] = {y1, y2, y3};

2,538,374✔

43

   return bigint_ct_is_lt(x, 3, y, 3).as_bool();

2,538,374✔

48

void ct_divide(const BigInt& x, const BigInt& y, BigInt& q_out, BigInt& r_out) {

6,622✔

49

   if(y.is_zero()) {

11,243✔

53

   const size_t x_words = x.sig_words();

6,622✔

54

   const size_t y_words = y.sig_words();

6,622✔

56

   const size_t x_bits = x.bits();

6,622✔

58

   BigInt q = BigInt::with_capacity(x_words);

6,622✔

59

   BigInt r = BigInt::with_capacity(y_words);

6,622✔

60

   BigInt t = BigInt::with_capacity(y_words);  // a temporary

6,622✔

62

   for(size_t i = 0; i != x_bits; ++i) {

6,050,910✔

63

      const size_t b = x_bits - 1 - i;

6,044,288✔

64

      const bool x_b = x.get_bit(b);

6,044,288✔

66

      r <<= 1;

6,044,288✔

67

      r.conditionally_set_bit(0, x_b);

6,044,288✔

69

      const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;

6,044,288✔

71

      q.conditionally_set_bit(b, r_gte_y);

6,044,288✔

72

      r.ct_cond_swap(r_gte_y, t);

6,044,288✔

75

   sign_fixup(x, y, q, r);

6,622✔

76

   r_out = r;

6,622✔

77

   q_out = q;

6,622✔

78

19,861✔

80

BigInt ct_divide_pow2k(size_t k, const BigInt& y) {

46,685✔

81

   BOTAN_ARG_CHECK(!y.is_zero(), "Cannot divide by zero");

46,685✔

82

   BOTAN_ARG_CHECK(!y.is_negative(), "Negative divisor not supported");

46,685✔

83

   BOTAN_ARG_CHECK(k > 1, "Invalid k");

46,685✔

85

   const size_t x_bits = k + 1;

46,685✔

86

   const size_t y_bits = y.bits();

46,685✔

87

   BOTAN_ASSERT_NOMSG(y_bits > 1);

46,685✔

88

   const size_t x_words = (x_bits + BOTAN_MP_WORD_BITS - 1) / BOTAN_MP_WORD_BITS;

46,685✔

89

   const size_t y_words = y.sig_words();

46,685✔

91

   BigInt q = BigInt::with_capacity(x_words);

46,685✔

92

   BigInt r = BigInt::with_capacity(y_words + 1);

46,685✔

93

   BigInt t = BigInt::with_capacity(y_words + 1);  // a temporary

46,685✔

95

   r.set_bit(y_bits - 1);

46,685✔

96

   for(size_t i = y_bits; i != x_bits; ++i) {

27,284,288✔

97

      const size_t b = x_bits - 1 - i;

27,237,603✔

99

      bigint_shl1(r.mutable_data(), r.size(), r.size(), 1);

27,237,603✔

101

      const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;

27,237,603✔

103

      q.conditionally_set_bit(b, r_gte_y);

27,237,603✔

105

      bigint_cnd_swap(static_cast<word>(r_gte_y), r.mutable_data(), t.mutable_data(), y_words + 1);

27,237,603✔

110

   return q;

46,685✔

111

93,370✔

113

void ct_divide_word(const BigInt& x, word y, BigInt& q_out, word& r_out) {

592,037✔

114

   if(y == 0) {

592,037✔

118

   const size_t x_words = x.sig_words();

592,037✔

119

   const size_t x_bits = x.bits();

592,037✔

121

   BigInt q = BigInt::with_capacity(x_words);

592,037✔

124

   for(size_t i = 0; i != x_bits; ++i) {

59,079,813✔

125

      const size_t b = x_bits - 1 - i;

58,487,776✔

126

      const bool x_b = x.get_bit(b);

58,487,776✔

128

      const auto r_carry = CT::Mask<word>::expand_top_bit(r);

58,487,776✔

130

      r <<= 1;

58,487,776✔

131

      r += x_b;

58,487,776✔

133

      const auto r_gte_y = CT::Mask<word>::is_gte(r, y) | r_carry;

58,487,776✔

134

      q.conditionally_set_bit(b, r_gte_y.as_bool());

58,487,776✔

135

      r = r_gte_y.select(r - y, r);

58,487,776✔

138

   if(x.is_negative()) {

592,037✔

139

      q.flip_sign();

19✔

140

      if(r != 0) {

19✔

141

         --q;

15✔

142

         r = y - r;

15✔

146

   r_out = r;

592,037✔

147

   q_out = q;

592,037✔

148

592,037✔

150

word ct_mod_word(const BigInt& x, word y) {

4,337✔

151

   BOTAN_ARG_CHECK(x.is_positive(), "The argument x must be positive");

4,337✔

152

   BOTAN_ARG_CHECK(y != 0, "Cannot divide by zero");

4,337✔

154

   const size_t x_bits = x.bits();

4,337✔

156

   word r = 0;

4,337✔

158

   for(size_t i = 0; i != x_bits; ++i) {

3,026,614✔

159

      const size_t b = x_bits - 1 - i;

3,022,277✔

160

      const bool x_b = x.get_bit(b);

3,022,277✔

162

      const auto r_carry = CT::Mask<word>::expand_top_bit(r);

3,022,277✔

164

      r <<= 1;

3,022,277✔

165

      r += x_b;

3,022,277✔

167

      const auto r_gte_y = CT::Mask<word>::is_gte(r, y) | r_carry;

3,022,277✔

168

      r = r_gte_y.select(r - y, r);

3,022,277✔

171

   return r;

4,337✔

174

BigInt ct_modulo(const BigInt& x, const BigInt& y) {

4,377✔

175

   if(y.is_negative() || y.is_zero()) {

8,754✔

179

   const size_t y_words = y.sig_words();

4,377✔

181

   const size_t x_bits = x.bits();

4,377✔

183

   BigInt r = BigInt::with_capacity(y_words);

4,377✔

184

   BigInt t = BigInt::with_capacity(y_words);

4,377✔

186

   for(size_t i = 0; i != x_bits; ++i) {

6,423,564✔

187

      const size_t b = x_bits - 1 - i;

6,419,187✔

188

      const bool x_b = x.get_bit(b);

6,419,187✔

190

      r <<= 1;

6,419,187✔

191

      r.conditionally_set_bit(0, x_b);

6,419,187✔

193

      const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;

6,419,187✔

195

      r.ct_cond_swap(r_gte_y, t);

6,419,187✔

198

   if(x.is_negative()) {

4,377✔

199

      if(r.is_nonzero()) {

1,206✔

200

         r = y - r;

1,202✔

204

   return r;

4,377✔

205

4,377✔

212

void vartime_divide(const BigInt& x, const BigInt& y_arg, BigInt& q_out, BigInt& r_out) {

282,346✔

213

   if(y_arg.is_zero()) {

282,422✔

217

   const size_t y_words = y_arg.sig_words();

282,346✔

219

   BOTAN_ASSERT_NOMSG(y_words > 0);

282,346✔

221

   BigInt y = y_arg;

282,346✔

223

   BigInt r = x;

282,346✔

224

   BigInt q = BigInt::zero();

282,346✔

225

   secure_vector<word> ws;

282,346✔

227

   r.set_sign(BigInt::Positive);

282,346✔

228

   y.set_sign(BigInt::Positive);

282,346✔

231

   const size_t shifts = y.top_bits_free();

282,346✔

233

   y <<= shifts;

282,346✔

234

   r <<= shifts;

282,346✔

237

   const size_t t = y_words - 1;

282,346✔

238

   const size_t n = std::max(y_words, r.sig_words()) - 1;  // r may have changed size however

564,692✔

240

   BOTAN_ASSERT_NOMSG(n >= t);

282,346✔

242

   q.grow_to(n - t + 1);

282,346✔

244

   word* q_words = q.mutable_data();

282,346✔

246

   BigInt shifted_y = y << (BOTAN_MP_WORD_BITS * (n - t));

282,346✔

249

   q_words[n - t] = r.reduce_below(shifted_y, ws);

282,346✔

251

   const word y_t0 = y.word_at(t);

282,346✔

252

   const word y_t1 = y.word_at(t - 1);

282,346✔

253

   BOTAN_DEBUG_ASSERT((y_t0 >> (BOTAN_MP_WORD_BITS - 1)) == 1);

282,346✔

255

   for(size_t j = n; j != t; --j) {

1,551,533✔

256

      const word x_j0 = r.word_at(j);

1,269,187✔

257

      const word x_j1 = r.word_at(j - 1);

1,269,187✔

258

      const word x_j2 = r.word_at(j - 2);

1,269,187✔

260

      word qjt = bigint_divop_vartime(x_j0, x_j1, y_t0);

1,269,187✔

262

      qjt = CT::Mask<word>::is_equal(x_j0, y_t0).select(WordInfo<word>::max, qjt);

1,269,187✔

265

      qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);

1,269,187✔

266

      qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);

1,269,187✔

267

      BOTAN_DEBUG_ASSERT(division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2) == false);

1,269,187✔

269

      shifted_y >>= BOTAN_MP_WORD_BITS;

1,269,187✔

273

      r -= qjt * shifted_y;

1,269,187✔

274

      qjt -= r.is_negative();

1,269,187✔

275

      r += static_cast<word>(r.is_negative()) * shifted_y;

1,269,187✔

277

      q_words[j - t - 1] = qjt;

1,269,187✔

280

   r >>= shifts;

282,346✔

282

   sign_fixup(x, y_arg, q, r);

282,346✔

284

   r_out = r;

282,346✔

285

   q_out = q;

282,346✔

286

1,411,730✔

randombit / botan / 12939720817

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

1	/*
2	* Division Algorithms
3	* (C) 1999-2007,2012,2018,2021 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/internal/divide.h>
9
10	#include <botan/internal/bit_ops.h>
11	#include <botan/internal/ct_utils.h>
12	#include <botan/internal/mp_core.h>
13
14	namespace Botan {
15
16	namespace {
17
18	/*
19	* Handle signed operands, if necessary
20	*/
21	void sign_fixup(const BigInt& x, const BigInt& y, BigInt& q, BigInt& r) {	288,968✔
22	q.cond_flip_sign(x.sign() != y.sign());	288,968✔
23
24	if(x.is_negative() && r.is_nonzero()) {	290,585✔
25	q -= 1;	1,613✔
26	r = y.abs() - r;	4,839✔
27	}
28	}	288,968✔
29
30	inline bool division_check(word q, word y2, word y1, word x3, word x2, word x1) {	2,538,374✔
31	/*
32	Compute (y3,y2,y1) = (y2,y1) * q
33	and return true if (y3,y2,y1) > (x3,x2,x1)
34	*/
35
36	word y3 = 0;	2,538,374✔
37	y1 = word_madd2(q, y1, &y3);	2,538,374✔
38	y2 = word_madd2(q, y2, &y3);	2,538,374✔
39
40	const word x[3] = {x1, x2, x3};	2,538,374✔
41	const word y[3] = {y1, y2, y3};	2,538,374✔
42
43	return bigint_ct_is_lt(x, 3, y, 3).as_bool();	2,538,374✔
44	}
45
46	} // namespace
47
48	void ct_divide(const BigInt& x, const BigInt& y, BigInt& q_out, BigInt& r_out) {	6,622✔
49	if(y.is_zero()) {	11,243✔
50	throw Invalid_Argument("ct_divide: cannot divide by zero");	×
51	}
52
53	const size_t x_words = x.sig_words();	6,622✔
54	const size_t y_words = y.sig_words();	6,622✔
55
56	const size_t x_bits = x.bits();	6,622✔
57
58	BigInt q = BigInt::with_capacity(x_words);	6,622✔
59	BigInt r = BigInt::with_capacity(y_words);	6,622✔
60	BigInt t = BigInt::with_capacity(y_words); // a temporary	6,622✔
61
62	for(size_t i = 0; i != x_bits; ++i) {	6,050,910✔
63	const size_t b = x_bits - 1 - i;	6,044,288✔
64	const bool x_b = x.get_bit(b);	6,044,288✔
65
66	r <<= 1;	6,044,288✔
67	r.conditionally_set_bit(0, x_b);	6,044,288✔
68
69	const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;	6,044,288✔
70
71	q.conditionally_set_bit(b, r_gte_y);	6,044,288✔
72	r.ct_cond_swap(r_gte_y, t);	6,044,288✔
73	}
74
75	sign_fixup(x, y, q, r);	6,622✔
76	r_out = r;	6,622✔
77	q_out = q;	6,622✔
78	}	19,861✔
79
80	BigInt ct_divide_pow2k(size_t k, const BigInt& y) {	46,685✔
81	BOTAN_ARG_CHECK(!y.is_zero(), "Cannot divide by zero");	46,685✔
82	BOTAN_ARG_CHECK(!y.is_negative(), "Negative divisor not supported");	46,685✔
83	BOTAN_ARG_CHECK(k > 1, "Invalid k");	46,685✔
84
85	const size_t x_bits = k + 1;	46,685✔
86	const size_t y_bits = y.bits();	46,685✔
87	BOTAN_ASSERT_NOMSG(y_bits > 1);	46,685✔
88	const size_t x_words = (x_bits + BOTAN_MP_WORD_BITS - 1) / BOTAN_MP_WORD_BITS;	46,685✔
89	const size_t y_words = y.sig_words();	46,685✔
90
91	BigInt q = BigInt::with_capacity(x_words);	46,685✔
92	BigInt r = BigInt::with_capacity(y_words + 1);	46,685✔
93	BigInt t = BigInt::with_capacity(y_words + 1); // a temporary	46,685✔
94
95	r.set_bit(y_bits - 1);	46,685✔
96	for(size_t i = y_bits; i != x_bits; ++i) {	27,284,288✔
97	const size_t b = x_bits - 1 - i;	27,237,603✔
98
99	bigint_shl1(r.mutable_data(), r.size(), r.size(), 1);	27,237,603✔
100
101	const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;	27,237,603✔
102
103	q.conditionally_set_bit(b, r_gte_y);	27,237,603✔
104
105	bigint_cnd_swap(static_cast<word>(r_gte_y), r.mutable_data(), t.mutable_data(), y_words + 1);	27,237,603✔
106	}
107
108	// No need for sign fixup
109
110	return q;	46,685✔
111	}	93,370✔
112
113	void ct_divide_word(const BigInt& x, word y, BigInt& q_out, word& r_out) {	592,037✔
114	if(y == 0) {	592,037✔
115	throw Invalid_Argument("ct_divide_word: cannot divide by zero");	×
116	}
117
118	const size_t x_words = x.sig_words();	592,037✔
119	const size_t x_bits = x.bits();	592,037✔
120
121	BigInt q = BigInt::with_capacity(x_words);	592,037✔
122	word r = 0;
123
124	for(size_t i = 0; i != x_bits; ++i) {	59,079,813✔
125	const size_t b = x_bits - 1 - i;	58,487,776✔
126	const bool x_b = x.get_bit(b);	58,487,776✔
127
128	const auto r_carry = CT::Mask<word>::expand_top_bit(r);	58,487,776✔
129
130	r <<= 1;	58,487,776✔
131	r += x_b;	58,487,776✔
132
133	const auto r_gte_y = CT::Mask<word>::is_gte(r, y) \| r_carry;	58,487,776✔
134	q.conditionally_set_bit(b, r_gte_y.as_bool());	58,487,776✔
135	r = r_gte_y.select(r - y, r);	58,487,776✔
136	}
137
138	if(x.is_negative()) {	592,037✔
139	q.flip_sign();	19✔
140	if(r != 0) {	19✔
141	--q;	15✔
142	r = y - r;	15✔
143	}
144	}
145
146	r_out = r;	592,037✔
147	q_out = q;	592,037✔
148	}	592,037✔
149
150	word ct_mod_word(const BigInt& x, word y) {	4,337✔
151	BOTAN_ARG_CHECK(x.is_positive(), "The argument x must be positive");	4,337✔
152	BOTAN_ARG_CHECK(y != 0, "Cannot divide by zero");	4,337✔
153
154	const size_t x_bits = x.bits();	4,337✔
155
156	word r = 0;	4,337✔
157
158	for(size_t i = 0; i != x_bits; ++i) {	3,026,614✔
159	const size_t b = x_bits - 1 - i;	3,022,277✔
160	const bool x_b = x.get_bit(b);	3,022,277✔
161
162	const auto r_carry = CT::Mask<word>::expand_top_bit(r);	3,022,277✔
163
164	r <<= 1;	3,022,277✔
165	r += x_b;	3,022,277✔
166
167	const auto r_gte_y = CT::Mask<word>::is_gte(r, y) \| r_carry;	3,022,277✔
168	r = r_gte_y.select(r - y, r);	3,022,277✔
169	}
170
171	return r;	4,337✔
172	}
173
174	BigInt ct_modulo(const BigInt& x, const BigInt& y) {	4,377✔
175	if(y.is_negative() \|\| y.is_zero()) {	8,754✔
176	throw Invalid_Argument("ct_modulo requires y > 0");	×
177	}
178
179	const size_t y_words = y.sig_words();	4,377✔
180
181	const size_t x_bits = x.bits();	4,377✔
182
183	BigInt r = BigInt::with_capacity(y_words);	4,377✔
184	BigInt t = BigInt::with_capacity(y_words);	4,377✔
185
186	for(size_t i = 0; i != x_bits; ++i) {	6,423,564✔
187	const size_t b = x_bits - 1 - i;	6,419,187✔
188	const bool x_b = x.get_bit(b);	6,419,187✔
189
190	r <<= 1;	6,419,187✔
191	r.conditionally_set_bit(0, x_b);	6,419,187✔
192
193	const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;	6,419,187✔
194
195	r.ct_cond_swap(r_gte_y, t);	6,419,187✔
196	}
197
198	if(x.is_negative()) {	4,377✔
199	if(r.is_nonzero()) {	1,206✔
200	r = y - r;	1,202✔
201	}
202	}
203
204	return r;	4,377✔
205	}	4,377✔
206
207	/*
208	* Solve x = q * y + r
209	*
210	* See Handbook of Applied Cryptography section 14.2.5
211	*/
212	void vartime_divide(const BigInt& x, const BigInt& y_arg, BigInt& q_out, BigInt& r_out) {	282,346✔
213	if(y_arg.is_zero()) {	282,422✔
214	throw Invalid_Argument("vartime_divide: cannot divide by zero");	×
215	}
216
217	const size_t y_words = y_arg.sig_words();	282,346✔
218
219	BOTAN_ASSERT_NOMSG(y_words > 0);	282,346✔
220
221	BigInt y = y_arg;	282,346✔
222
223	BigInt r = x;	282,346✔
224	BigInt q = BigInt::zero();	282,346✔
225	secure_vector<word> ws;	282,346✔
226
227	r.set_sign(BigInt::Positive);	282,346✔
228	y.set_sign(BigInt::Positive);	282,346✔
229
230	// Calculate shifts needed to normalize y with high bit set
231	const size_t shifts = y.top_bits_free();	282,346✔
232
233	y <<= shifts;	282,346✔
234	r <<= shifts;	282,346✔
235
236	// we know y has not changed size, since we only shifted up to set high bit
237	const size_t t = y_words - 1;	282,346✔
238	const size_t n = std::max(y_words, r.sig_words()) - 1; // r may have changed size however	564,692✔
239
240	BOTAN_ASSERT_NOMSG(n >= t);	282,346✔
241
242	q.grow_to(n - t + 1);	282,346✔
243
244	word* q_words = q.mutable_data();	282,346✔
245
246	BigInt shifted_y = y << (BOTAN_MP_WORD_BITS * (n - t));	282,346✔
247
248	// Set q_{n-t} to number of times r > shifted_y
249	q_words[n - t] = r.reduce_below(shifted_y, ws);	282,346✔
250
251	const word y_t0 = y.word_at(t);	282,346✔
252	const word y_t1 = y.word_at(t - 1);	282,346✔
253	BOTAN_DEBUG_ASSERT((y_t0 >> (BOTAN_MP_WORD_BITS - 1)) == 1);	282,346✔
254
255	for(size_t j = n; j != t; --j) {	1,551,533✔
256	const word x_j0 = r.word_at(j);	1,269,187✔
257	const word x_j1 = r.word_at(j - 1);	1,269,187✔
258	const word x_j2 = r.word_at(j - 2);	1,269,187✔
259
260	word qjt = bigint_divop_vartime(x_j0, x_j1, y_t0);	1,269,187✔
261
262	qjt = CT::Mask<word>::is_equal(x_j0, y_t0).select(WordInfo<word>::max, qjt);	1,269,187✔
263
264	// Per HAC 14.23, this operation is required at most twice
265	qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);	1,269,187✔
266	qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);	1,269,187✔
267	BOTAN_DEBUG_ASSERT(division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2) == false);	1,269,187✔
268
269	shifted_y >>= BOTAN_MP_WORD_BITS;	1,269,187✔
270	// Now shifted_y == y << (BOTAN_MP_WORD_BITS * (j-t-1))
271
272	// TODO this sequence could be better
273	r -= qjt * shifted_y;	1,269,187✔
274	qjt -= r.is_negative();	1,269,187✔
275	r += static_cast<word>(r.is_negative()) * shifted_y;	1,269,187✔
276
277	q_words[j - t - 1] = qjt;	1,269,187✔
278	}
279
280	r >>= shifts;	282,346✔
281
282	sign_fixup(x, y_arg, q, r);	282,346✔
283
284	r_out = r;	282,346✔
285	q_out = q;	282,346✔
286	}	1,411,730✔
287
288	} // namespace Botan

randombit / botan / 12939720817

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