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

18

BigInt::BigInt(uint64_t n) {

554,951✔

19

   if constexpr(sizeof(word) == 8) {

554,951✔

20

      m_data.set_word_at(0, static_cast<word>(n));

554,951✔

25

554,951✔

28

BigInt BigInt::from_u64(uint64_t n) {

134,689✔

29

   return BigInt(n);

134,689✔

33

BigInt BigInt::from_word(word n) {

462,123✔

34

   BigInt bn;

462,123✔

35

   bn.set_word_at(0, n);

462,123✔

36

   return bn;

462,123✔

40

BigInt BigInt::from_s32(int32_t n) {

116✔

41

   if(n >= 0) {

116✔

42

      return BigInt::from_u64(static_cast<uint64_t>(n));

2✔

44

      return -BigInt::from_u64(static_cast<uint64_t>(-n));

114✔

49

BigInt BigInt::with_capacity(size_t size) {

17,447,263✔

50

   BigInt bn;

17,447,263✔

51

   bn.grow_to(size);

17,447,263✔

52

   return bn;

17,447,263✔

58

BigInt::BigInt(std::string_view str) {

46,602✔

59

   Base base = Decimal;

46,602✔

60

   size_t markers = 0;

46,602✔

61

   bool negative = false;

46,602✔

63

   if(!str.empty() && str[0] == '-') {

46,602✔

68

   if(str.length() > markers + 2 && str[markers] == '0' && str[markers + 1] == 'x') {

46,602✔

73

   *this = decode(cast_char_ptr_to_uint8(str.data()) + markers, str.length() - markers, base);

46,602✔

75

   if(negative) {

46,602✔

76

      set_sign(Negative);

890✔

78

      set_sign(Positive);

46,157✔

80

46,602✔

86

BigInt BigInt::from_bytes(std::span<const uint8_t> input) {

115,719✔

87

   BigInt r;

115,719✔

88

   r.assign_from_bytes(input);

115,719✔

89

   return r;

115,719✔

95

BigInt::BigInt(const uint8_t input[], size_t length, Base base) {

4✔

96

   *this = decode(input, length, base);

4✔

97

4✔

100

BigInt BigInt::from_bytes_with_max_bits(const uint8_t input[], size_t length, size_t max_bits) {

6,914✔

101

   const size_t input_bits = 8 * length;

6,914✔

103

   auto bn = BigInt::from_bytes(std::span{input, length});

6,914✔

105

   if(input_bits > max_bits) {

6,914✔

106

      const size_t bits_to_shift = input_bits - max_bits;

3,733✔

108

      bn >>= bits_to_shift;

3,733✔

111

   return bn;

6,914✔

117

BigInt::BigInt(RandomNumberGenerator& rng, size_t bits, bool set_high_bit) {

110,400✔

118

   randomize(rng, bits, set_high_bit);

110,400✔

119

110,400✔

121

uint8_t BigInt::byte_at(size_t n) const {

319,610✔

122

   return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));

319,610✔

125

int32_t BigInt::cmp_word(word other) const {

3,241,313✔

126

   if(is_negative()) {

3,241,313✔

130

   const size_t sw = this->sig_words();

3,210,208✔

131

   if(sw > 1) {

3,210,208✔

135

   return bigint_cmp(this->_data(), sw, &other, 1);

2,330,818✔

141

int32_t BigInt::cmp(const BigInt& other, bool check_signs) const {

1,415,024✔

142

   if(check_signs) {

1,415,024✔

143

      if(other.is_positive() && this->is_negative()) {

1,414,897✔

147

      if(other.is_negative() && this->is_positive()) {

1,414,829✔

151

      if(other.is_negative() && this->is_negative()) {

1,414,765✔

152

         return (-bigint_cmp(this->_data(), this->size(), other._data(), other.size()));

74✔

156

   return bigint_cmp(this->_data(), this->size(), other._data(), other.size());

1,414,818✔

159

bool BigInt::is_equal(const BigInt& other) const {

552,684✔

160

   if(this->sign() != other.sign()) {

552,684✔

164

   return bigint_ct_is_eq(this->_data(), this->sig_words(), other._data(), other.sig_words()).as_bool();

871,958✔

167

bool BigInt::is_less_than(const BigInt& other) const {

2,251,804✔

168

   if(this->is_negative() && other.is_positive()) {

2,251,804✔

172

   if(this->is_positive() && other.is_negative()) {

2,251,738✔

176

   if(other.is_negative() && this->is_negative()) {

2,251,674✔

177

      return bigint_ct_is_lt(other._data(), other.sig_words(), this->_data(), this->sig_words()).as_bool();

73✔

180

   return bigint_ct_is_lt(this->_data(), this->sig_words(), other._data(), other.sig_words()).as_bool();

4,269,119✔

183

void BigInt::encode_words(word out[], size_t size) const {

830,504✔

184

   const size_t words = sig_words();

830,504✔

186

   if(words > size) {

830,504✔

190

   clear_mem(out, size);

830,504✔

191

   copy_mem(out, _data(), words);

830,504✔

192

830,504✔

194

void BigInt::Data::set_to_zero() {

4,287,124✔

195

   m_reg.resize(m_reg.capacity());

4,287,124✔

196

   clear_mem(m_reg.data(), m_reg.size());

4,287,124✔

197

   m_sig_words = 0;

4,287,124✔

198

4,287,124✔

200

void BigInt::Data::mask_bits(size_t n) {

9,052,038✔

201

   if(n == 0) {

9,052,038✔

205

   const size_t top_word = n / WordInfo<word>::bits;

9,052,038✔

208

   if(top_word < size()) {

9,052,038✔

209

      const word mask = (static_cast<word>(1) << (n % WordInfo<word>::bits)) - 1;

9,012,752✔

210

      const size_t len = size() - (top_word + 1);

9,012,752✔

211

      if(len > 0) {

9,012,752✔

212

         clear_mem(&m_reg[top_word + 1], len);

8,905,501✔

214

      m_reg[top_word] &= mask;

9,012,752✔

215

      invalidate_sig_words();

9,012,752✔

219

size_t BigInt::Data::calc_sig_words() const {

112,187,787✔

220

   const size_t sz = m_reg.size();

112,187,787✔

221

   size_t sig = sz;

112,187,787✔

223

   word sub = 1;

112,187,787✔

225

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

2,142,420,729✔

226

      const word w = m_reg[sz - i - 1];

2,030,232,942✔

227

      sub &= ct_is_zero(w);

2,030,232,942✔

228

      sig -= sub;

2,030,232,942✔

235

   CT::unpoison(sig);

112,187,787✔

237

   return sig;

112,187,787✔

243

uint32_t BigInt::get_substring(size_t offset, size_t length) const {

18,350,472✔

244

   if(length == 0 || length > 32) {

18,350,472✔

248

   const uint32_t mask = 0xFFFFFFFF >> (32 - length);

18,350,472✔

250

   const size_t word_offset = offset / WordInfo<word>::bits;

18,350,472✔

251

   const size_t wshift = (offset % WordInfo<word>::bits);

18,350,472✔

258

   const word w0 = word_at(word_offset);

18,350,472✔

260

   if(wshift == 0 || (offset + length) / WordInfo<word>::bits == word_offset) {

18,350,472✔

261

      return static_cast<uint32_t>(w0 >> wshift) & mask;

17,418,079✔

263

      const word w1 = word_at(word_offset + 1);

932,393✔

264

      return static_cast<uint32_t>((w0 >> wshift) | (w1 << (WordInfo<word>::bits - wshift))) & mask;

932,393✔

271

uint32_t BigInt::to_u32bit() const {

34,950✔

272

   if(is_negative()) {

34,950✔

275

   if(bits() > 32) {

34,950✔

276

      throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");

15✔

280

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

174,675✔

281

      out = (out << 8) | byte_at(3 - i);

139,740✔

283

   return out;

34,935✔

289

void BigInt::clear_bit(size_t n) {

75✔

290

   const size_t which = n / WordInfo<word>::bits;

75✔

292

   if(which < size()) {

75✔

293

      const word mask = ~(static_cast<word>(1) << (n % WordInfo<word>::bits));

75✔

294

      m_data.set_word_at(which, word_at(which) & mask);

75✔

296

75✔

298

size_t BigInt::bytes() const {

430,489✔

299

   return round_up(bits(), 8) / 8;

430,489✔

302

size_t BigInt::top_bits_free() const {

2,545,606✔

303

   const size_t words = sig_words();

2,545,606✔

305

   const word top_word = word_at(words - 1);

2,545,606✔

306

   const size_t bits_used = high_bit(CT::value_barrier(top_word));

2,545,606✔

307

   CT::unpoison(bits_used);

2,545,606✔

308

   return WordInfo<word>::bits - bits_used;

2,545,606✔

311

size_t BigInt::bits() const {

2,221,043✔

312

   const size_t words = sig_words();

2,221,043✔

314

   if(words == 0) {

2,221,043✔

318

   const size_t full_words = (words - 1) * WordInfo<word>::bits;

2,201,235✔

319

   const size_t top_bits = WordInfo<word>::bits - top_bits_free();

2,201,235✔

321

   return full_words + top_bits;

2,201,235✔

327

BigInt BigInt::operator-() const {

7,474✔

328

   BigInt x = (*this);

7,474✔

329

   x.flip_sign();

7,474✔

330

   return x;

7,474✔

333

size_t BigInt::reduce_below(const BigInt& p, secure_vector<word>& ws) {

21,604,067✔

334

   if(p.is_negative() || this->is_negative()) {

21,604,067✔

338

   const size_t p_words = p.sig_words();

21,604,067✔

340

   if(size() < p_words + 1) {

21,604,067✔

341

      grow_to(p_words + 1);

9,354✔

344

   if(ws.size() < p_words + 1) {

21,604,067✔

345

      ws.resize(p_words + 1);

344,371✔

348

   clear_mem(ws.data(), ws.size());

21,604,067✔

350

   size_t reductions = 0;

21,604,067✔

352

   for(;;) {

34,543,969✔

353

      word borrow = bigint_sub3(ws.data(), _data(), p_words + 1, p._data(), p_words);

56,148,036✔

354

      if(borrow) {

56,148,036✔

358

      ++reductions;

34,543,969✔

359

      swap_reg(ws);

34,543,969✔

362

   return reductions;

21,604,067✔

365

void BigInt::ct_reduce_below(const BigInt& mod, secure_vector<word>& ws, size_t bound) {

9,006,061✔

366

   if(mod.is_negative() || this->is_negative()) {

9,006,061✔

370

   const size_t mod_words = mod.sig_words();

9,006,061✔

372

   grow_to(mod_words);

9,006,061✔

374

   const size_t sz = size();

9,006,061✔

376

   ws.resize(sz);

9,006,061✔

378

   clear_mem(ws.data(), sz);

9,006,061✔

380

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

27,018,183✔

381

      word borrow = bigint_sub3(ws.data(), _data(), sz, mod._data(), mod_words);

18,012,122✔

383

      CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), _data(), sz);

36,024,244✔

385

9,006,061✔

390

BigInt BigInt::abs() const {

1,675✔

391

   BigInt x = (*this);

1,675✔

392

   x.set_sign(Positive);

1,675✔

393

   return x;

1,675✔

399

void BigInt::serialize_to(std::span<uint8_t> output) const {

296,433✔

400

   BOTAN_ARG_CHECK(this->bytes() <= output.size(), "Insufficient output space");

296,433✔

402

   this->binary_encode(output.data(), output.size());

296,209✔

403

296,209✔

408

void BigInt::binary_encode(uint8_t output[], size_t len) const {

296,214✔

409

   const size_t full_words = len / sizeof(word);

296,214✔

410

   const size_t extra_bytes = len % sizeof(word);

296,214✔

412

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

2,241,341✔

413

      const word w = word_at(i);

1,945,127✔

414

      store_be(w, output + (len - (i + 1) * sizeof(word)));

1,945,127✔

417

   if(extra_bytes > 0) {

296,214✔

418

      const word w = word_at(full_words);

158,996✔

420

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

775,035✔

421

         output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);

616,039✔

424

296,214✔

429

void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {

955,345✔

430

   clear();

955,345✔

432

   const size_t length = bytes.size();

955,345✔

433

   const size_t full_words = length / sizeof(word);

955,345✔

434

   const size_t extra_bytes = length % sizeof(word);

955,345✔

436

   secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));

1,280,035✔

438

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

5,844,291✔

439

      reg[i] = load_be<word>(bytes.last<sizeof(word)>());

4,888,946✔

440

      bytes = bytes.first(bytes.size() - sizeof(word));

4,888,946✔

443

   if(!bytes.empty()) {

955,345✔

444

      BOTAN_ASSERT_NOMSG(extra_bytes == bytes.size());

630,655✔

445

      std::array<uint8_t, sizeof(word)> last_partial_word = {0};

630,655✔

446

      copy_mem(std::span{last_partial_word}.last(extra_bytes), bytes);

630,655✔

447

      reg[full_words] = load_be<word>(last_partial_word);

630,655✔

450

   m_data.swap(reg);

955,345✔

451

955,345✔

453

void BigInt::ct_cond_add(bool predicate, const BigInt& value) {

3,175,016✔

454

   if(this->is_negative() || value.is_negative()) {

3,175,016✔

457

   this->grow_to(1 + value.sig_words());

3,175,016✔

459

   bigint_cnd_add(static_cast<word>(predicate), this->mutable_data(), this->size(), value._data(), value.sig_words());

3,175,016✔

460

3,175,016✔

462

void BigInt::ct_shift_left(size_t shift) {

30,721✔

463

   auto shl_bit = [](const BigInt& a, BigInt& result) {

3,833,920✔

464

      BOTAN_DEBUG_ASSERT(a.size() + 1 == result.size());

3,803,199✔

465

      bigint_shl2(result.mutable_data(), a._data(), a.size(), 1);

3,803,199✔

467

      clear_mem(result.mutable_data() + result.size() - 1, 1);

3,803,199✔

468

};

3,803,199✔

470

   auto shl_word = [](const BigInt& a, BigInt& result) {

3,833,920✔

472

      bigint_shl2(result.mutable_data(), a._data(), a.size() - 1 /* ignore msw */, WordInfo<word>::bits);

3,803,199✔

474

      clear_mem(result.mutable_data(), 1);

3,803,199✔

475

};

3,803,199✔

477

   BOTAN_ASSERT_NOMSG(size() > 0);

30,721✔

479

   constexpr size_t bits_in_word = sizeof(word) * 8;

30,721✔

480

   const size_t word_shift = shift >> ceil_log2(bits_in_word);             // shift / bits_in_word

30,721✔

481

   const size_t bit_shift = shift & ((1 << ceil_log2(bits_in_word)) - 1);  // shift % bits_in_word

30,721✔

482

   const size_t iterations = std::max(size(), bits_in_word) - 1;           // uint64_t i; i << 64 is undefined behaviour

30,721✔

486

   BigInt tmp;

30,721✔

487

   tmp.resize(size() + 1 /* to hold the shifted-out word */);

30,721✔

488

   for(size_t i = 0; i < iterations; ++i) {

3,833,920✔

489

      shl_bit(*this, tmp);

3,803,199✔

490

      ct_cond_assign(i < bit_shift, tmp);

3,803,199✔

491

      shl_word(*this, tmp);

3,803,199✔

492

      ct_cond_assign(i < word_shift, tmp);

3,803,199✔

494

30,721✔

496

void BigInt::ct_cond_swap(bool predicate, BigInt& other) {

15,234,879✔

497

   const size_t max_words = std::max(size(), other.size());

15,234,879✔

498

   grow_to(max_words);

15,234,879✔

499

   other.grow_to(max_words);

15,234,879✔

501

   bigint_cnd_swap(static_cast<word>(predicate), this->mutable_data(), other.mutable_data(), max_words);

15,234,879✔

502

15,234,879✔

504

void BigInt::cond_flip_sign(bool predicate) {

54,317,004✔

507

   const auto mask = CT::Mask<uint8_t>::expand(predicate);

54,317,004✔

509

   const uint8_t current_sign = static_cast<uint8_t>(sign());

54,317,004✔

511

   const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);

54,317,004✔

513

   set_sign(static_cast<Sign>(new_sign));

54,317,004✔

514

54,317,004✔

516

void BigInt::ct_cond_assign(bool predicate, const BigInt& other) {

32,542,906✔

517

   const size_t t_words = size();

32,542,906✔

518

   const size_t o_words = other.size();

32,542,906✔

520

   if(o_words < t_words) {

32,542,906✔

521

      grow_to(o_words);

56,742✔

524

   const size_t r_words = std::max(t_words, o_words);

32,542,906✔

526

   const auto mask = CT::Mask<word>::expand(predicate);

32,542,906✔

528

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

2,147,483,647✔

529

      const word o_word = other.word_at(i);

2,147,483,647✔

530

      const word t_word = this->word_at(i);

2,147,483,647✔

531

      this->set_word_at(i, mask.select(o_word, t_word));

2,147,483,647✔

534

   const auto same_sign = CT::Mask<word>::is_equal(sign(), other.sign()).as_choice();

32,542,906✔

535

   cond_flip_sign((mask.as_choice() && !same_sign).as_bool());

32,542,906✔

536

32,542,906✔

538

void BigInt::_const_time_poison() const {

3,110,594✔

539

   CT::poison(m_data.const_data(), m_data.size());

3,110,594✔

540

3,110,594✔

542

void BigInt::_const_time_unpoison() const {

47,560,402✔

543

   CT::unpoison(m_data.const_data(), m_data.size());

47,560,402✔

544

47,560,402✔

randombit / botan / 13230468750

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

1	/*
2	* BigInt Base
3	* (C) 1999-2011,2012,2014,2019 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/bigint.h>
9
10	#include <botan/internal/bit_ops.h>
11	#include <botan/internal/ct_utils.h>
12	#include <botan/internal/loadstor.h>
13	#include <botan/internal/mp_core.h>
14	#include <botan/internal/rounding.h>
15
16	namespace Botan {
17
18	BigInt::BigInt(uint64_t n) {	554,951✔
19	if constexpr(sizeof(word) == 8) {	554,951✔
20	m_data.set_word_at(0, static_cast<word>(n));	554,951✔
21	} else {
22	m_data.set_word_at(1, static_cast<word>(n >> 32));
23	m_data.set_word_at(0, static_cast<word>(n));
24	}
25	}	554,951✔
26
27	//static
28	BigInt BigInt::from_u64(uint64_t n) {	134,689✔
29	return BigInt(n);	134,689✔
30	}
31
32	//static
33	BigInt BigInt::from_word(word n) {	462,123✔
34	BigInt bn;	462,123✔
35	bn.set_word_at(0, n);	462,123✔
36	return bn;	462,123✔
37	}	×
38
39	//static
40	BigInt BigInt::from_s32(int32_t n) {	116✔
41	if(n >= 0) {	116✔
42	return BigInt::from_u64(static_cast<uint64_t>(n));	2✔
43	} else {
44	return -BigInt::from_u64(static_cast<uint64_t>(-n));	114✔
45	}
46	}
47
48	//static
49	BigInt BigInt::with_capacity(size_t size) {	17,447,263✔
50	BigInt bn;	17,447,263✔
51	bn.grow_to(size);	17,447,263✔
52	return bn;	17,447,263✔
53	}	×
54
55	/*
56	* Construct a BigInt from a string
57	*/
58	BigInt::BigInt(std::string_view str) {	46,602✔
59	Base base = Decimal;	46,602✔
60	size_t markers = 0;	46,602✔
61	bool negative = false;	46,602✔
62
63	if(!str.empty() && str[0] == '-') {	46,602✔
64	markers += 1;
65	negative = true;
66	}
67
68	if(str.length() > markers + 2 && str[markers] == '0' && str[markers + 1] == 'x') {	46,602✔
69	markers += 2;
70	base = Hexadecimal;
71	}
72
73	*this = decode(cast_char_ptr_to_uint8(str.data()) + markers, str.length() - markers, base);	46,602✔
74
75	if(negative) {	46,602✔
76	set_sign(Negative);	890✔
77	} else {
78	set_sign(Positive);	46,157✔
79	}
80	}	46,602✔
81
82	BigInt BigInt::from_string(std::string_view str) {	×
83	return BigInt(str);	×
84	}
85
86	BigInt BigInt::from_bytes(std::span<const uint8_t> input) {	115,719✔
87	BigInt r;	115,719✔
88	r.assign_from_bytes(input);	115,719✔
89	return r;	115,719✔
90	}	×
91
92	/*
93	* Construct a BigInt from an encoded BigInt
94	*/
95	BigInt::BigInt(const uint8_t input[], size_t length, Base base) {	4✔
96	*this = decode(input, length, base);	4✔
97	}	4✔
98
99	//static
100	BigInt BigInt::from_bytes_with_max_bits(const uint8_t input[], size_t length, size_t max_bits) {	6,914✔
101	const size_t input_bits = 8 * length;	6,914✔
102
103	auto bn = BigInt::from_bytes(std::span{input, length});	6,914✔
104
105	if(input_bits > max_bits) {	6,914✔
106	const size_t bits_to_shift = input_bits - max_bits;	3,733✔
107
108	bn >>= bits_to_shift;	3,733✔
109	}
110
111	return bn;	6,914✔
112	}	×
113
114	/*
115	* Construct a BigInt from an encoded BigInt
116	*/
117	BigInt::BigInt(RandomNumberGenerator& rng, size_t bits, bool set_high_bit) {	110,400✔
118	randomize(rng, bits, set_high_bit);	110,400✔
119	}	110,400✔
120
121	uint8_t BigInt::byte_at(size_t n) const {	319,610✔
122	return get_byte_var(sizeof(word) - (n % sizeof(word)) - 1, word_at(n / sizeof(word)));	319,610✔
123	}
124
125	int32_t BigInt::cmp_word(word other) const {	3,241,313✔
126	if(is_negative()) {	3,241,313✔
127	return -1; // other is positive ...
128	}
129
130	const size_t sw = this->sig_words();	3,210,208✔
131	if(sw > 1) {	3,210,208✔
132	return 1; // must be larger since other is just one word ...
133	}
134
135	return bigint_cmp(this->_data(), sw, &other, 1);	2,330,818✔
136	}
137
138	/*
139	* Comparison Function
140	*/
141	int32_t BigInt::cmp(const BigInt& other, bool check_signs) const {	1,415,024✔
142	if(check_signs) {	1,415,024✔
143	if(other.is_positive() && this->is_negative()) {	1,414,897✔
144	return -1;
145	}
146
147	if(other.is_negative() && this->is_positive()) {	1,414,829✔
148	return 1;
149	}
150
151	if(other.is_negative() && this->is_negative()) {	1,414,765✔
152	return (-bigint_cmp(this->_data(), this->size(), other._data(), other.size()));	74✔
153	}
154	}
155
156	return bigint_cmp(this->_data(), this->size(), other._data(), other.size());	1,414,818✔
157	}
158
159	bool BigInt::is_equal(const BigInt& other) const {	552,684✔
160	if(this->sign() != other.sign()) {	552,684✔
161	return false;
162	}
163
164	return bigint_ct_is_eq(this->_data(), this->sig_words(), other._data(), other.sig_words()).as_bool();	871,958✔
165	}
166
167	bool BigInt::is_less_than(const BigInt& other) const {	2,251,804✔
168	if(this->is_negative() && other.is_positive()) {	2,251,804✔
169	return true;
170	}
171
172	if(this->is_positive() && other.is_negative()) {	2,251,738✔
173	return false;
174	}
175
176	if(other.is_negative() && this->is_negative()) {	2,251,674✔
177	return bigint_ct_is_lt(other._data(), other.sig_words(), this->_data(), this->sig_words()).as_bool();	73✔
178	}
179
180	return bigint_ct_is_lt(this->_data(), this->sig_words(), other._data(), other.sig_words()).as_bool();	4,269,119✔
181	}
182
183	void BigInt::encode_words(word out[], size_t size) const {	830,504✔
184	const size_t words = sig_words();	830,504✔
185
186	if(words > size) {	830,504✔
187	throw Encoding_Error("BigInt::encode_words value too large to encode");	×
188	}
189
190	clear_mem(out, size);	830,504✔
191	copy_mem(out, _data(), words);	830,504✔
192	}	830,504✔
193
194	void BigInt::Data::set_to_zero() {	4,287,124✔
195	m_reg.resize(m_reg.capacity());	4,287,124✔
196	clear_mem(m_reg.data(), m_reg.size());	4,287,124✔
197	m_sig_words = 0;	4,287,124✔
198	}	4,287,124✔
199
200	void BigInt::Data::mask_bits(size_t n) {	9,052,038✔
201	if(n == 0) {	9,052,038✔
202	return set_to_zero();	×
203	}
204
205	const size_t top_word = n / WordInfo<word>::bits;	9,052,038✔
206
207	// if(top_word < sig_words()) ?
208	if(top_word < size()) {	9,052,038✔
209	const word mask = (static_cast<word>(1) << (n % WordInfo<word>::bits)) - 1;	9,012,752✔
210	const size_t len = size() - (top_word + 1);	9,012,752✔
211	if(len > 0) {	9,012,752✔
212	clear_mem(&m_reg[top_word + 1], len);	8,905,501✔
213	}
214	m_reg[top_word] &= mask;	9,012,752✔
215	invalidate_sig_words();	9,012,752✔
216	}
217	}
218
219	size_t BigInt::Data::calc_sig_words() const {	112,187,787✔
220	const size_t sz = m_reg.size();	112,187,787✔
221	size_t sig = sz;	112,187,787✔
222
223	word sub = 1;	112,187,787✔
224
225	for(size_t i = 0; i != sz; ++i) {	2,142,420,729✔
226	const word w = m_reg[sz - i - 1];	2,030,232,942✔
227	sub &= ct_is_zero(w);	2,030,232,942✔
228	sig -= sub;	2,030,232,942✔
229	}
230
231	/*
232	* This depends on the data so is poisoned, but unpoison it here as
233	* later conditionals are made on the size.
234	*/
235	CT::unpoison(sig);	112,187,787✔
236
237	return sig;	112,187,787✔
238	}
239
240	/*
241	* Return bits {offset...offset+length}
242	*/
243	uint32_t BigInt::get_substring(size_t offset, size_t length) const {	18,350,472✔
244	if(length == 0 \|\| length > 32) {	18,350,472✔
245	throw Invalid_Argument("BigInt::get_substring invalid substring length");	×
246	}
247
248	const uint32_t mask = 0xFFFFFFFF >> (32 - length);	18,350,472✔
249
250	const size_t word_offset = offset / WordInfo<word>::bits;	18,350,472✔
251	const size_t wshift = (offset % WordInfo<word>::bits);	18,350,472✔
252
253	/*
254	* The substring is contained within one or at most two words. The
255	* offset and length are not secret, so we can perform conditional
256	* operations on those values.
257	*/
258	const word w0 = word_at(word_offset);	18,350,472✔
259
260	if(wshift == 0 \|\| (offset + length) / WordInfo<word>::bits == word_offset) {	18,350,472✔
261	return static_cast<uint32_t>(w0 >> wshift) & mask;	17,418,079✔
262	} else {
263	const word w1 = word_at(word_offset + 1);	932,393✔
264	return static_cast<uint32_t>((w0 >> wshift) \| (w1 << (WordInfo<word>::bits - wshift))) & mask;	932,393✔
265	}
266	}
267
268	/*
269	* Convert this number to a uint32_t, if possible
270	*/
271	uint32_t BigInt::to_u32bit() const {	34,950✔
272	if(is_negative()) {	34,950✔
273	throw Encoding_Error("BigInt::to_u32bit: Number is negative");	×
274	}
275	if(bits() > 32) {	34,950✔
276	throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");	15✔
277	}
278
279	uint32_t out = 0;
280	for(size_t i = 0; i != 4; ++i) {	174,675✔
281	out = (out << 8) \| byte_at(3 - i);	139,740✔
282	}
283	return out;	34,935✔
284	}
285
286	/*
287	* Clear bit number n
288	*/
289	void BigInt::clear_bit(size_t n) {	75✔
290	const size_t which = n / WordInfo<word>::bits;	75✔
291
292	if(which < size()) {	75✔
293	const word mask = ~(static_cast<word>(1) << (n % WordInfo<word>::bits));	75✔
294	m_data.set_word_at(which, word_at(which) & mask);	75✔
295	}
296	}	75✔
297
298	size_t BigInt::bytes() const {	430,489✔
299	return round_up(bits(), 8) / 8;	430,489✔
300	}
301
302	size_t BigInt::top_bits_free() const {	2,545,606✔
303	const size_t words = sig_words();	2,545,606✔
304
305	const word top_word = word_at(words - 1);	2,545,606✔
306	const size_t bits_used = high_bit(CT::value_barrier(top_word));	2,545,606✔
307	CT::unpoison(bits_used);	2,545,606✔
308	return WordInfo<word>::bits - bits_used;	2,545,606✔
309	}
310
311	size_t BigInt::bits() const {	2,221,043✔
312	const size_t words = sig_words();	2,221,043✔
313
314	if(words == 0) {	2,221,043✔
315	return 0;
316	}
317
318	const size_t full_words = (words - 1) * WordInfo<word>::bits;	2,201,235✔
319	const size_t top_bits = WordInfo<word>::bits - top_bits_free();	2,201,235✔
320
321	return full_words + top_bits;	2,201,235✔
322	}
323
324	/*
325	* Return the negation of this number
326	*/
327	BigInt BigInt::operator-() const {	7,474✔
328	BigInt x = (*this);	7,474✔
329	x.flip_sign();	7,474✔
330	return x;	7,474✔
331	}	×
332
333	size_t BigInt::reduce_below(const BigInt& p, secure_vector<word>& ws) {	21,604,067✔
334	if(p.is_negative() \|\| this->is_negative()) {	21,604,067✔
335	throw Invalid_Argument("BigInt::reduce_below both values must be positive");	×
336	}
337
338	const size_t p_words = p.sig_words();	21,604,067✔
339
340	if(size() < p_words + 1) {	21,604,067✔
341	grow_to(p_words + 1);	9,354✔
342	}
343
344	if(ws.size() < p_words + 1) {	21,604,067✔
345	ws.resize(p_words + 1);	344,371✔
346	}
347
348	clear_mem(ws.data(), ws.size());	21,604,067✔
349
350	size_t reductions = 0;	21,604,067✔
351
352	for(;;) {	34,543,969✔
353	word borrow = bigint_sub3(ws.data(), _data(), p_words + 1, p._data(), p_words);	56,148,036✔
354	if(borrow) {	56,148,036✔
355	break;
356	}
357
358	++reductions;	34,543,969✔
359	swap_reg(ws);	34,543,969✔
360	}
361
362	return reductions;	21,604,067✔
363	}
364
365	void BigInt::ct_reduce_below(const BigInt& mod, secure_vector<word>& ws, size_t bound) {	9,006,061✔
366	if(mod.is_negative() \|\| this->is_negative()) {	9,006,061✔
367	throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");	×
368	}
369
370	const size_t mod_words = mod.sig_words();	9,006,061✔
371
372	grow_to(mod_words);	9,006,061✔
373
374	const size_t sz = size();	9,006,061✔
375
376	ws.resize(sz);	9,006,061✔
377
378	clear_mem(ws.data(), sz);	9,006,061✔
379
380	for(size_t i = 0; i != bound; ++i) {	27,018,183✔
381	word borrow = bigint_sub3(ws.data(), _data(), sz, mod._data(), mod_words);	18,012,122✔
382
383	CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), _data(), sz);	36,024,244✔
384	}
385	}	9,006,061✔
386
387	/*
388	* Return the absolute value of this number
389	*/
390	BigInt BigInt::abs() const {	1,675✔
391	BigInt x = (*this);	1,675✔
392	x.set_sign(Positive);	1,675✔
393	return x;	1,675✔
394	}
395
396	/*
397	* Encode this number into bytes
398	*/
399	void BigInt::serialize_to(std::span<uint8_t> output) const {	296,433✔
400	BOTAN_ARG_CHECK(this->bytes() <= output.size(), "Insufficient output space");	296,433✔
401
402	this->binary_encode(output.data(), output.size());	296,209✔
403	}	296,209✔
404
405	/*
406	* Encode this number into bytes
407	*/
408	void BigInt::binary_encode(uint8_t output[], size_t len) const {	296,214✔
409	const size_t full_words = len / sizeof(word);	296,214✔
410	const size_t extra_bytes = len % sizeof(word);	296,214✔
411
412	for(size_t i = 0; i != full_words; ++i) {	2,241,341✔
413	const word w = word_at(i);	1,945,127✔
414	store_be(w, output + (len - (i + 1) * sizeof(word)));	1,945,127✔
415	}
416
417	if(extra_bytes > 0) {	296,214✔
418	const word w = word_at(full_words);	158,996✔
419
420	for(size_t i = 0; i != extra_bytes; ++i) {	775,035✔
421	output[extra_bytes - i - 1] = get_byte_var(sizeof(word) - i - 1, w);	616,039✔
422	}
423	}
424	}	296,214✔
425
426	/*
427	* Set this number to the value in buf
428	*/
429	void BigInt::assign_from_bytes(std::span<const uint8_t> bytes) {	955,345✔
430	clear();	955,345✔
431
432	const size_t length = bytes.size();	955,345✔
433	const size_t full_words = length / sizeof(word);	955,345✔
434	const size_t extra_bytes = length % sizeof(word);	955,345✔
435
436	secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));	1,280,035✔
437
438	for(size_t i = 0; i != full_words; ++i) {	5,844,291✔
439	reg[i] = load_be<word>(bytes.last<sizeof(word)>());	4,888,946✔
440	bytes = bytes.first(bytes.size() - sizeof(word));	4,888,946✔
441	}
442
443	if(!bytes.empty()) {	955,345✔
444	BOTAN_ASSERT_NOMSG(extra_bytes == bytes.size());	630,655✔
445	std::array<uint8_t, sizeof(word)> last_partial_word = {0};	630,655✔
446	copy_mem(std::span{last_partial_word}.last(extra_bytes), bytes);	630,655✔
447	reg[full_words] = load_be<word>(last_partial_word);	630,655✔
448	}
449
450	m_data.swap(reg);	955,345✔
451	}	955,345✔
452
453	void BigInt::ct_cond_add(bool predicate, const BigInt& value) {	3,175,016✔
454	if(this->is_negative() \|\| value.is_negative()) {	3,175,016✔
455	throw Invalid_Argument("BigInt::ct_cond_add requires both values to be positive");	×
456	}
457	this->grow_to(1 + value.sig_words());	3,175,016✔
458
459	bigint_cnd_add(static_cast<word>(predicate), this->mutable_data(), this->size(), value._data(), value.sig_words());	3,175,016✔
460	}	3,175,016✔
461
462	void BigInt::ct_shift_left(size_t shift) {	30,721✔
463	auto shl_bit = [](const BigInt& a, BigInt& result) {	3,833,920✔
464	BOTAN_DEBUG_ASSERT(a.size() + 1 == result.size());	3,803,199✔
465	bigint_shl2(result.mutable_data(), a._data(), a.size(), 1);	3,803,199✔
466	// shl2 may have shifted a bit into the next word, which must be dropped
467	clear_mem(result.mutable_data() + result.size() - 1, 1);	3,803,199✔
468	};	3,803,199✔
469
470	auto shl_word = [](const BigInt& a, BigInt& result) {	3,833,920✔
471	// the most significant word is not copied, aka. shifted out
472	bigint_shl2(result.mutable_data(), a._data(), a.size() - 1 /* ignore msw */, WordInfo<word>::bits);	3,803,199✔
473	// we left-shifted by a full word, the least significant word must be zero'ed
474	clear_mem(result.mutable_data(), 1);	3,803,199✔
475	};	3,803,199✔
476
477	BOTAN_ASSERT_NOMSG(size() > 0);	30,721✔
478
479	constexpr size_t bits_in_word = sizeof(word) * 8;	30,721✔
480	const size_t word_shift = shift >> ceil_log2(bits_in_word); // shift / bits_in_word	30,721✔
481	const size_t bit_shift = shift & ((1 << ceil_log2(bits_in_word)) - 1); // shift % bits_in_word	30,721✔
482	const size_t iterations = std::max(size(), bits_in_word) - 1; // uint64_t i; i << 64 is undefined behaviour	30,721✔
483
484	// In every iteration, shift one bit and one word to the left and use the
485	// shift results only when they are within the shift range.
486	BigInt tmp;	30,721✔
487	tmp.resize(size() + 1 /* to hold the shifted-out word */);	30,721✔
488	for(size_t i = 0; i < iterations; ++i) {	3,833,920✔
489	shl_bit(*this, tmp);	3,803,199✔
490	ct_cond_assign(i < bit_shift, tmp);	3,803,199✔
491	shl_word(*this, tmp);	3,803,199✔
492	ct_cond_assign(i < word_shift, tmp);	3,803,199✔
493	}
494	}	30,721✔
495
496	void BigInt::ct_cond_swap(bool predicate, BigInt& other) {	15,234,879✔
497	const size_t max_words = std::max(size(), other.size());	15,234,879✔
498	grow_to(max_words);	15,234,879✔
499	other.grow_to(max_words);	15,234,879✔
500
501	bigint_cnd_swap(static_cast<word>(predicate), this->mutable_data(), other.mutable_data(), max_words);	15,234,879✔
502	}	15,234,879✔
503
504	void BigInt::cond_flip_sign(bool predicate) {	54,317,004✔
505	// This code is assuming Negative == 0, Positive == 1
506
507	const auto mask = CT::Mask<uint8_t>::expand(predicate);	54,317,004✔
508
509	const uint8_t current_sign = static_cast<uint8_t>(sign());	54,317,004✔
510
511	const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);	54,317,004✔
512
513	set_sign(static_cast<Sign>(new_sign));	54,317,004✔
514	}	54,317,004✔
515
516	void BigInt::ct_cond_assign(bool predicate, const BigInt& other) {	32,542,906✔
517	const size_t t_words = size();	32,542,906✔
518	const size_t o_words = other.size();	32,542,906✔
519
520	if(o_words < t_words) {	32,542,906✔
521	grow_to(o_words);	56,742✔
522	}
523
524	const size_t r_words = std::max(t_words, o_words);	32,542,906✔
525
526	const auto mask = CT::Mask<word>::expand(predicate);	32,542,906✔
527
528	for(size_t i = 0; i != r_words; ++i) {	2,147,483,647✔
529	const word o_word = other.word_at(i);	2,147,483,647✔
530	const word t_word = this->word_at(i);	2,147,483,647✔
531	this->set_word_at(i, mask.select(o_word, t_word));	2,147,483,647✔
532	}
533
534	const auto same_sign = CT::Mask<word>::is_equal(sign(), other.sign()).as_choice();	32,542,906✔
535	cond_flip_sign((mask.as_choice() && !same_sign).as_bool());	32,542,906✔
536	}	32,542,906✔
537
538	void BigInt::_const_time_poison() const {	3,110,594✔
539	CT::poison(m_data.const_data(), m_data.size());	3,110,594✔
540	}	3,110,594✔
541
542	void BigInt::_const_time_unpoison() const {	47,560,402✔
543	CT::unpoison(m_data.const_data(), m_data.size());	47,560,402✔
544	}	47,560,402✔
545
546	} // namespace Botan

randombit / botan / 13230468750

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