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

21

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

352,809✔

22

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

352,809✔

24

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

354,398✔

25

      q -= 1;

1,585✔

26

      r = y.abs() - r;

1,585✔

28

352,809✔

30

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

2,813,908✔

36

   word y3 = 0;

2,813,908✔

37

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

2,813,908✔

38

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

2,813,908✔

40

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

2,813,908✔

41

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

2,813,908✔

43

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

2,813,908✔

48

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

6,658✔

49

   if(y.is_zero()) {

11,281✔

53

   const size_t x_words = x.sig_words();

6,658✔

54

   const size_t y_words = y.sig_words();

6,658✔

56

   const size_t x_bits = x.bits();

6,658✔

58

   BigInt q = BigInt::with_capacity(x_words);

6,658✔

59

   BigInt r = BigInt::with_capacity(y_words);

6,658✔

60

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

6,658✔

62

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

6,090,831✔

63

      const size_t b = x_bits - 1 - i;

6,084,173✔

64

      const bool x_b = x.get_bit(b);

6,084,173✔

66

      r <<= 1;

6,084,173✔

67

      r.conditionally_set_bit(0, x_b);

6,084,173✔

69

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

6,084,173✔

71

      q.conditionally_set_bit(b, r_gte_y);

6,084,173✔

72

      r.ct_cond_swap(r_gte_y, t);

6,084,173✔

75

   sign_fixup(x, y, q, r);

6,658✔

76

   r_out = r;

6,658✔

77

   q_out = q;

6,658✔

78

6,658✔

80

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

116,085✔

81

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

116,463✔

82

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

116,085✔

83

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

116,085✔

85

   const size_t x_bits = k + 1;

116,085✔

86

   const size_t y_bits = y.bits();

116,085✔

88

   if(x_bits < y_bits) {

116,085✔

89

      return BigInt::zero();

257✔

92

   BOTAN_ASSERT_NOMSG(y_bits >= 1);

115,828✔

93

   const size_t x_words = (x_bits + WordInfo<word>::bits - 1) / WordInfo<word>::bits;

115,828✔

94

   const size_t y_words = y.sig_words();

115,828✔

96

   BigInt q = BigInt::with_capacity(x_words);

115,828✔

97

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

115,828✔

98

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

115,828✔

100

   r.set_bit(y_bits - 1);

115,828✔

101

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

35,019,276✔

102

      const size_t b = x_bits - 1 - i;

34,903,448✔

104

      if(i >= y_bits) {

34,903,448✔

105

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

34,787,620✔

108

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

34,903,448✔

110

      q.conditionally_set_bit(b, r_gte_y);

34,903,448✔

112

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

34,903,448✔

117

   return q;

115,828✔

118

115,828✔

120

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

590,837✔

121

   if(y == 0) {

590,837✔

125

   const size_t x_words = x.sig_words();

590,837✔

126

   const size_t x_bits = x.bits();

590,837✔

128

   BigInt q = BigInt::with_capacity(x_words);

590,837✔

131

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

58,796,447✔

132

      const size_t b = x_bits - 1 - i;

58,205,610✔

133

      const bool x_b = x.get_bit(b);

58,205,610✔

135

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

58,205,610✔

137

      r <<= 1;

58,205,610✔

138

      r += x_b;

58,205,610✔

140

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

58,205,610✔

141

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

58,205,610✔

142

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

58,205,610✔

145

   if(x.is_negative()) {

590,837✔

146

      q.flip_sign();

19✔

147

      if(r != 0) {

19✔

148

         --q;

15✔

149

         r = y - r;

15✔

153

   r_out = r;

590,837✔

154

   q_out = q;

590,837✔

155

590,837✔

157

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

4,331✔

158

   BigInt q;

4,331✔

159

   word r;

4,331✔

160

   ct_divide_word(x, y, q, r);

4,331✔

161

   BOTAN_UNUSED(r);

4,331✔

162

   return q;

4,331✔

165

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

4,331✔

166

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

4,331✔

167

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

4,331✔

169

   const size_t x_bits = x.bits();

4,331✔

171

   word r = 0;

4,331✔

173

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

3,040,780✔

174

      const size_t b = x_bits - 1 - i;

3,036,449✔

175

      const bool x_b = x.get_bit(b);

3,036,449✔

177

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

3,036,449✔

179

      r <<= 1;

3,036,449✔

180

      r += x_b;

3,036,449✔

182

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

3,036,449✔

183

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

3,036,449✔

186

   return r;

4,331✔

189

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

5,540✔

190

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

11,080✔

194

   const size_t y_words = y.sig_words();

5,540✔

196

   const size_t x_bits = x.bits();

5,540✔

198

   BigInt r = BigInt::with_capacity(y_words);

5,540✔

199

   BigInt t = BigInt::with_capacity(y_words);

5,540✔

201

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

7,638,298✔

202

      const size_t b = x_bits - 1 - i;

7,632,758✔

203

      const bool x_b = x.get_bit(b);

7,632,758✔

205

      r <<= 1;

7,632,758✔

206

      r.conditionally_set_bit(0, x_b);

7,632,758✔

208

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

7,632,758✔

210

      r.ct_cond_swap(r_gte_y, t);

7,632,758✔

213

   if(x.is_negative()) {

5,540✔

214

      if(r.is_nonzero()) {

1,262✔

215

         r = y - r;

629✔

219

   return r;

5,540✔

220

5,540✔

227

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

346,151✔

228

   if(y_arg.is_zero()) {

346,228✔

232

   const size_t y_words = y_arg.sig_words();

346,151✔

234

   BOTAN_ASSERT_NOMSG(y_words > 0);

346,151✔

236

   BigInt y = y_arg;

346,151✔

238

   BigInt r = x;

346,151✔

239

   BigInt q = BigInt::zero();

346,151✔

240

   secure_vector<word> ws;

346,151✔

242

   r.set_sign(BigInt::Positive);

346,151✔

243

   y.set_sign(BigInt::Positive);

346,151✔

246

   const size_t shifts = y.top_bits_free();

346,151✔

248

   y <<= shifts;

346,151✔

249

   r <<= shifts;

346,151✔

252

   const size_t t = y_words - 1;

346,151✔

253

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

692,302✔

255

   BOTAN_ASSERT_NOMSG(n >= t);

346,151✔

257

   q.grow_to(n - t + 1);

346,151✔

259

   word* q_words = q.mutable_data();

346,151✔

261

   BigInt shifted_y = y << (WordInfo<word>::bits * (n - t));

346,151✔

264

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

346,151✔

266

   const word y_t0 = y.word_at(t);

346,151✔

267

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

346,151✔

268

   BOTAN_DEBUG_ASSERT((y_t0 >> (WordInfo<word>::bits - 1)) == 1);

346,151✔

270

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

1,753,105✔

271

      const word x_j0 = r.word_at(j);

1,406,954✔

272

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

1,406,954✔

273

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

1,406,954✔

275

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

1,406,954✔

277

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

1,406,954✔

280

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

1,406,954✔

281

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

1,406,954✔

282

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

1,406,954✔

284

      shifted_y >>= WordInfo<word>::bits;

1,406,954✔

288

      r -= qjt * shifted_y;

1,406,954✔

289

      qjt -= r.is_negative();

1,406,954✔

290

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

1,406,954✔

292

      q_words[j - t - 1] = qjt;

1,406,954✔

295

   r >>= shifts;

346,151✔

297

   sign_fixup(x, y_arg, q, r);

346,151✔

299

   r_out = r;

346,151✔

300

   q_out = q;

346,151✔

301

692,302✔

randombit / botan / 13217016155

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) {	352,809✔
22	q.cond_flip_sign(x.sign() != y.sign());	352,809✔
23
24	if(x.is_negative() && r.is_nonzero()) {	354,398✔
25	q -= 1;	1,585✔
26	r = y.abs() - r;	1,585✔
27	}
28	}	352,809✔
29
30	inline bool division_check(word q, word y2, word y1, word x3, word x2, word x1) {	2,813,908✔
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,813,908✔
37	y1 = word_madd2(q, y1, &y3);	2,813,908✔
38	y2 = word_madd2(q, y2, &y3);	2,813,908✔
39
40	const word x[3] = {x1, x2, x3};	2,813,908✔
41	const word y[3] = {y1, y2, y3};	2,813,908✔
42
43	return bigint_ct_is_lt(x, 3, y, 3).as_bool();	2,813,908✔
44	}
45
46	} // namespace
47
48	void ct_divide(const BigInt& x, const BigInt& y, BigInt& q_out, BigInt& r_out) {	6,658✔
49	if(y.is_zero()) {	11,281✔
50	throw Invalid_Argument("ct_divide: cannot divide by zero");	×
51	}
52
53	const size_t x_words = x.sig_words();	6,658✔
54	const size_t y_words = y.sig_words();	6,658✔
55
56	const size_t x_bits = x.bits();	6,658✔
57
58	BigInt q = BigInt::with_capacity(x_words);	6,658✔
59	BigInt r = BigInt::with_capacity(y_words);	6,658✔
60	BigInt t = BigInt::with_capacity(y_words); // a temporary	6,658✔
61
62	for(size_t i = 0; i != x_bits; ++i) {	6,090,831✔
63	const size_t b = x_bits - 1 - i;	6,084,173✔
64	const bool x_b = x.get_bit(b);	6,084,173✔
65
66	r <<= 1;	6,084,173✔
67	r.conditionally_set_bit(0, x_b);	6,084,173✔
68
69	const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;	6,084,173✔
70
71	q.conditionally_set_bit(b, r_gte_y);	6,084,173✔
72	r.ct_cond_swap(r_gte_y, t);	6,084,173✔
73	}
74
75	sign_fixup(x, y, q, r);	6,658✔
76	r_out = r;	6,658✔
77	q_out = q;	6,658✔
78	}	6,658✔
79
80	BigInt ct_divide_pow2k(size_t k, const BigInt& y) {	116,085✔
81	BOTAN_ARG_CHECK(!y.is_zero(), "Cannot divide by zero");	116,463✔
82	BOTAN_ARG_CHECK(!y.is_negative(), "Negative divisor not supported");	116,085✔
83	BOTAN_ARG_CHECK(k > 1, "Invalid k");	116,085✔
84
85	const size_t x_bits = k + 1;	116,085✔
86	const size_t y_bits = y.bits();	116,085✔
87
88	if(x_bits < y_bits) {	116,085✔
89	return BigInt::zero();	257✔
90	}
91
92	BOTAN_ASSERT_NOMSG(y_bits >= 1);	115,828✔
93	const size_t x_words = (x_bits + WordInfo<word>::bits - 1) / WordInfo<word>::bits;	115,828✔
94	const size_t y_words = y.sig_words();	115,828✔
95
96	BigInt q = BigInt::with_capacity(x_words);	115,828✔
97	BigInt r = BigInt::with_capacity(y_words + 1);	115,828✔
98	BigInt t = BigInt::with_capacity(y_words + 1); // a temporary	115,828✔
99
100	r.set_bit(y_bits - 1);	115,828✔
101	for(size_t i = y_bits - 1; i != x_bits; ++i) {	35,019,276✔
102	const size_t b = x_bits - 1 - i;	34,903,448✔
103
104	if(i >= y_bits) {	34,903,448✔
105	bigint_shl1(r.mutable_data(), r.size(), r.size(), 1);	34,787,620✔
106	}
107
108	const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;	34,903,448✔
109
110	q.conditionally_set_bit(b, r_gte_y);	34,903,448✔
111
112	bigint_cnd_swap(static_cast<word>(r_gte_y), r.mutable_data(), t.mutable_data(), y_words + 1);	34,903,448✔
113	}
114
115	// No need for sign fixup
116
117	return q;	115,828✔
118	}	115,828✔
119
120	void ct_divide_word(const BigInt& x, word y, BigInt& q_out, word& r_out) {	590,837✔
121	if(y == 0) {	590,837✔
122	throw Invalid_Argument("ct_divide_word: cannot divide by zero");	×
123	}
124
125	const size_t x_words = x.sig_words();	590,837✔
126	const size_t x_bits = x.bits();	590,837✔
127
128	BigInt q = BigInt::with_capacity(x_words);	590,837✔
129	word r = 0;
130
131	for(size_t i = 0; i != x_bits; ++i) {	58,796,447✔
132	const size_t b = x_bits - 1 - i;	58,205,610✔
133	const bool x_b = x.get_bit(b);	58,205,610✔
134
135	const auto r_carry = CT::Mask<word>::expand_top_bit(r);	58,205,610✔
136
137	r <<= 1;	58,205,610✔
138	r += x_b;	58,205,610✔
139
140	const auto r_gte_y = CT::Mask<word>::is_gte(r, y) \| r_carry;	58,205,610✔
141	q.conditionally_set_bit(b, r_gte_y.as_bool());	58,205,610✔
142	r = r_gte_y.select(r - y, r);	58,205,610✔
143	}
144
145	if(x.is_negative()) {	590,837✔
146	q.flip_sign();	19✔
147	if(r != 0) {	19✔
148	--q;	15✔
149	r = y - r;	15✔
150	}
151	}
152
153	r_out = r;	590,837✔
154	q_out = q;	590,837✔
155	}	590,837✔
156
157	BigInt ct_divide_word(const BigInt& x, word y) {	4,331✔
158	BigInt q;	4,331✔
159	word r;	4,331✔
160	ct_divide_word(x, y, q, r);	4,331✔
161	BOTAN_UNUSED(r);	4,331✔
162	return q;	4,331✔
163	}	×
164
165	word ct_mod_word(const BigInt& x, word y) {	4,331✔
166	BOTAN_ARG_CHECK(x.is_positive(), "The argument x must be positive");	4,331✔
167	BOTAN_ARG_CHECK(y != 0, "Cannot divide by zero");	4,331✔
168
169	const size_t x_bits = x.bits();	4,331✔
170
171	word r = 0;	4,331✔
172
173	for(size_t i = 0; i != x_bits; ++i) {	3,040,780✔
174	const size_t b = x_bits - 1 - i;	3,036,449✔
175	const bool x_b = x.get_bit(b);	3,036,449✔
176
177	const auto r_carry = CT::Mask<word>::expand_top_bit(r);	3,036,449✔
178
179	r <<= 1;	3,036,449✔
180	r += x_b;	3,036,449✔
181
182	const auto r_gte_y = CT::Mask<word>::is_gte(r, y) \| r_carry;	3,036,449✔
183	r = r_gte_y.select(r - y, r);	3,036,449✔
184	}
185
186	return r;	4,331✔
187	}
188
189	BigInt ct_modulo(const BigInt& x, const BigInt& y) {	5,540✔
190	if(y.is_negative() \|\| y.is_zero()) {	11,080✔
191	throw Invalid_Argument("ct_modulo requires y > 0");	×
192	}
193
194	const size_t y_words = y.sig_words();	5,540✔
195
196	const size_t x_bits = x.bits();	5,540✔
197
198	BigInt r = BigInt::with_capacity(y_words);	5,540✔
199	BigInt t = BigInt::with_capacity(y_words);	5,540✔
200
201	for(size_t i = 0; i != x_bits; ++i) {	7,638,298✔
202	const size_t b = x_bits - 1 - i;	7,632,758✔
203	const bool x_b = x.get_bit(b);	7,632,758✔
204
205	r <<= 1;	7,632,758✔
206	r.conditionally_set_bit(0, x_b);	7,632,758✔
207
208	const bool r_gte_y = bigint_sub3(t.mutable_data(), r._data(), r.size(), y._data(), y_words) == 0;	7,632,758✔
209
210	r.ct_cond_swap(r_gte_y, t);	7,632,758✔
211	}
212
213	if(x.is_negative()) {	5,540✔
214	if(r.is_nonzero()) {	1,262✔
215	r = y - r;	629✔
216	}
217	}
218
219	return r;	5,540✔
220	}	5,540✔
221
222	/*
223	* Solve x = q * y + r
224	*
225	* See Handbook of Applied Cryptography section 14.2.5
226	*/
227	void vartime_divide(const BigInt& x, const BigInt& y_arg, BigInt& q_out, BigInt& r_out) {	346,151✔
228	if(y_arg.is_zero()) {	346,228✔
229	throw Invalid_Argument("vartime_divide: cannot divide by zero");	×
230	}
231
232	const size_t y_words = y_arg.sig_words();	346,151✔
233
234	BOTAN_ASSERT_NOMSG(y_words > 0);	346,151✔
235
236	BigInt y = y_arg;	346,151✔
237
238	BigInt r = x;	346,151✔
239	BigInt q = BigInt::zero();	346,151✔
240	secure_vector<word> ws;	346,151✔
241
242	r.set_sign(BigInt::Positive);	346,151✔
243	y.set_sign(BigInt::Positive);	346,151✔
244
245	// Calculate shifts needed to normalize y with high bit set
246	const size_t shifts = y.top_bits_free();	346,151✔
247
248	y <<= shifts;	346,151✔
249	r <<= shifts;	346,151✔
250
251	// we know y has not changed size, since we only shifted up to set high bit
252	const size_t t = y_words - 1;	346,151✔
253	const size_t n = std::max(y_words, r.sig_words()) - 1; // r may have changed size however	692,302✔
254
255	BOTAN_ASSERT_NOMSG(n >= t);	346,151✔
256
257	q.grow_to(n - t + 1);	346,151✔
258
259	word* q_words = q.mutable_data();	346,151✔
260
261	BigInt shifted_y = y << (WordInfo<word>::bits * (n - t));	346,151✔
262
263	// Set q_{n-t} to number of times r > shifted_y
264	q_words[n - t] = r.reduce_below(shifted_y, ws);	346,151✔
265
266	const word y_t0 = y.word_at(t);	346,151✔
267	const word y_t1 = y.word_at(t - 1);	346,151✔
268	BOTAN_DEBUG_ASSERT((y_t0 >> (WordInfo<word>::bits - 1)) == 1);	346,151✔
269
270	for(size_t j = n; j != t; --j) {	1,753,105✔
271	const word x_j0 = r.word_at(j);	1,406,954✔
272	const word x_j1 = r.word_at(j - 1);	1,406,954✔
273	const word x_j2 = r.word_at(j - 2);	1,406,954✔
274
275	word qjt = bigint_divop_vartime(x_j0, x_j1, y_t0);	1,406,954✔
276
277	qjt = CT::Mask<word>::is_equal(x_j0, y_t0).select(WordInfo<word>::max, qjt);	1,406,954✔
278
279	// Per HAC 14.23, this operation is required at most twice
280	qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);	1,406,954✔
281	qjt -= division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2);	1,406,954✔
282	BOTAN_DEBUG_ASSERT(division_check(qjt, y_t0, y_t1, x_j0, x_j1, x_j2) == false);	1,406,954✔
283
284	shifted_y >>= WordInfo<word>::bits;	1,406,954✔
285	// Now shifted_y == y << (WordInfo<word>::bits * (j-t-1))
286
287	// TODO this sequence could be better
288	r -= qjt * shifted_y;	1,406,954✔
289	qjt -= r.is_negative();	1,406,954✔
290	r += static_cast<word>(r.is_negative()) * shifted_y;	1,406,954✔
291
292	q_words[j - t - 1] = qjt;	1,406,954✔
293	}
294
295	r >>= shifts;	346,151✔
296
297	sign_fixup(x, y_arg, q, r);	346,151✔
298
299	r_out = r;	346,151✔
300	q_out = q;	346,151✔
301	}	692,302✔
302
303	} // namespace Botan

randombit / botan / 13217016155

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