Botan 2.19.5 Crypto and TLS for C&

Classes | Public Types | Public Member Functions | Static Public Member Functions | List of all members
Botan::BigInt Class Referencefinal

`#include <bigint.h>`

## Classes
class | DivideByZero

## Public Types
enum | Base { Decimal = 10 , Hexadecimal = 16 , Binary = 256 }
enum | Sign { Negative = 0 , Positive = 1 }

## Public Member Functions
BigInt | abs () const
BigInt & | add (const word y[], size_t y_words, Sign sign)
| BigInt ()=default
| BigInt (BigInt &&other)
| BigInt (const BigInt &other)=default
| BigInt (const std::string &str)
template<typename Alloc >
| BigInt (const std::vector< uint8_t, Alloc > &vec)
| BigInt (const uint8_t buf[], size_t length)
| BigInt (const uint8_t buf[], size_t length, Base base)
| BigInt (const uint8_t buf[], size_t length, size_t max_bits)
| BigInt (const word words[], size_t length)
| BigInt (RandomNumberGenerator &rng, size_t bits, bool set_high_bit=true)
| Create a random BigInt of the specified size. More...
| BigInt (Sign sign, size_t n)
| BigInt (uint64_t n)
template<typename Alloc >
void | binary_decode (const std::vector< uint8_t, Alloc > &buf)
void | binary_decode (const uint8_t buf[], size_t length)
void | binary_encode (uint8_t buf[]) const
void | binary_encode (uint8_t buf[], size_t len) const
size_t | bits () const
uint8_t | byte_at (size_t n) const
size_t | bytes () const
void | clear ()
void | clear_bit (size_t n)
int32_t | cmp (const BigInt &n, bool check_signs=true) const
int32_t | cmp_word (word n) const
void | cond_flip_sign (bool predicate)
void | conditionally_set_bit (size_t n, bool set_it)
void | const_time_poison () const
void | const_time_unpoison () const
void | ct_cond_add (bool predicate, const BigInt &value)
void | ct_cond_assign (bool predicate, const BigInt &other)
void | ct_cond_swap (bool predicate, BigInt &other)
void | ct_reduce_below (const BigInt &mod, secure_vector< word > &ws, size_t bound)
void | ct_shift_left (size_t shift)
const word * | data () const
void | encode_words (word out[], size_t size) const
size_t | encoded_size (Base base=Binary) const
void | flip_sign ()
bool | get_bit (size_t n) const
uint32_t | get_substring (size_t offset, size_t length) const
secure_vector< word > & | get_word_vector ()
const secure_vector< word > & | get_word_vector () const
void | grow_to (size_t n) const
bool | is_equal (const BigInt &n) const
bool | is_even () const
bool | is_less_than (const BigInt &n) const
bool | is_negative () const
bool | is_nonzero () const
bool | is_odd () const
bool | is_positive () const
bool | is_zero () const
void | mask_bits (size_t n)
BigInt & | mod_add (const BigInt &y, const BigInt &mod, secure_vector< word > &ws)
BigInt & | mod_mul (uint8_t y, const BigInt &mod, secure_vector< word > &ws)
BigInt & | mod_sub (const BigInt &y, const BigInt &mod, secure_vector< word > &ws)
BigInt & | mul (const BigInt &y, secure_vector< word > &ws)
word * | mutable_data ()
bool | operator! () const
BigInt & | operator%= (const BigInt &y)
word | operator%= (word y)
BigInt & | operator*= (const BigInt &y)
BigInt & | operator*= (word y)
BigInt & | operator++ ()
BigInt | operator++ (int)
BigInt & | operator+= (const BigInt &y)
BigInt & | operator+= (word y)
BigInt | operator- () const
BigInt & | operator-- ()
BigInt | operator-- (int)
BigInt & | operator-= (const BigInt &y)
BigInt & | operator-= (word y)
BigInt & | operator/= (const BigInt &y)
BigInt & | operator<<= (size_t shift)
BigInt & | operator= (BigInt &&other)
BigInt & | operator= (const BigInt &)=default
BigInt & | operator>>= (size_t shift)
void | randomize (RandomNumberGenerator &rng, size_t bitsize, bool set_high_bit=true)
size_t | reduce_below (const BigInt &mod, secure_vector< word > &ws)
void | resize (size_t s)
BigInt & | rev_sub (const word y[], size_t y_words, secure_vector< word > &ws)
Sign | reverse_sign () const
void | set_bit (size_t n)
void | set_sign (Sign sign)
void | set_word_at (size_t i, word w)
void | set_words (const word w[], size_t len)
void | shrink_to_fit (size_t min_size=0)
size_t | sig_words () const
Sign | sign () const
size_t | size () const
BigInt & | square (secure_vector< word > &ws)
BigInt & | sub (const word y[], size_t y_words, Sign sign)
void | swap (BigInt &other)
void | swap_reg (secure_vector< word > &reg)
std::string | to_dec_string () const
std::string | to_hex_string () const
uint32_t | to_u32bit () const
size_t | top_bits_free () const
word | word_at (size_t n) const
| ~BigInt ()

## Static Public Member Functions
static BigInt | add2 (const BigInt &x, const word y[], size_t y_words, Sign y_sign)
static void | const_time_lookup (secure_vector< word > &output, const std::vector< BigInt > &vec, size_t idx)
template<typename Alloc >
static BigInt | decode (const std::vector< uint8_t, Alloc > &buf)
template<typename Alloc >
static BigInt | decode (const std::vector< uint8_t, Alloc > &buf, Base base)
static BigInt | decode (const uint8_t buf[], size_t length)
static BigInt | decode (const uint8_t buf[], size_t length, Base base)
static std::vector< uint8_t > | encode (const BigInt &n)
static std::vector< uint8_t > | encode (const BigInt &n, Base base)
static void | encode (uint8_t buf[], const BigInt &n)
static void | encode (uint8_t buf[], const BigInt &n, Base base)
static secure_vector< uint8_t > | encode_1363 (const BigInt &n, size_t bytes)
static void | encode_1363 (uint8_t out[], size_t bytes, const BigInt &n)
static secure_vector< uint8_t > | encode_fixed_length_int_pair (const BigInt &n1, const BigInt &n2, size_t bytes)
static secure_vector< uint8_t > | encode_locked (const BigInt &n)
static secure_vector< uint8_t > | encode_locked (const BigInt &n, Base base)
static BigInt | power_of_2 (size_t n)
static BigInt | random_integer (RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)
static BigInt | with_capacity (size_t n)

## Detailed Description

Arbitrary precision integer

Definition at line 24 of file bigint.h.

## Member Enumeration Documentation

## ◆ Base

enum Botan::BigInt::Base

Base enumerator for encoding and decoding

Enumerator
Decimal |
Hexadecimal |
Binary |

Definition at line 30 of file bigint.h.

30{ Decimal = 10, Hexadecimal = 16, Binary = 256 };
Botan::BigInt::Binary
@ Binary
Definition: bigint.h:30
Botan::BigInt::Decimal
@ Decimal
Definition: bigint.h:30
Botan::BigInt::Hexadecimal
@ Hexadecimal
Definition: bigint.h:30

## ◆ Sign

enum Botan::BigInt::Sign

Sign symbol definitions for positive and negative numbers

Enumerator
Negative |
Positive |

Definition at line 35 of file bigint.h.

35{ Negative = 0, Positive = 1 };
Botan::BigInt::Positive
@ Positive
Definition: bigint.h:35
Botan::BigInt::Negative
@ Negative
Definition: bigint.h:35

## Constructor & Destructor Documentation

## ◆ BigInt() [1/12]

Botan::BigInt::BigInt | ( |  | ) |
| default

Create empty BigInt

## ◆ BigInt() [2/12]

Botan::BigInt::BigInt | ( | uint64_t | n | ) |

Create BigInt from 64 bit integer

Parameters

  n | initial value of this BigInt

Definition at line 25 of file bigint.cpp.

26 {
27 if(n > 0)
28 {
29#if BOTAN_MP_WORD_BITS == 32
30 m_data.set_word_at(0, static_cast<word>(n));
31 m_data.set_word_at(1, static_cast<word>(n >> 32));
32#else
33 m_data.set_word_at(0, n);
34#endif
35 }
36
37 }

## ◆ BigInt() [3/12]

Botan::BigInt::BigInt | ( | const BigInt & | other | ) |
| default

Copy Constructor

Parameters

  other | the BigInt to copy

## ◆ BigInt() [4/12]

Botan::BigInt::BigInt | ( | const std::string & | str | ) |
| explicit

Create BigInt from a string. If the string starts with 0x the rest of the string will be interpreted as hexadecimal digits. Otherwise, it will be interpreted as a decimal number.

Parameters

  str | the string to parse for an integer value

Definition at line 59 of file bigint.cpp.

60 {
61 Base base = Decimal;
62 size_t markers = 0;
63 bool negative = false;
64
65 if(str.length() > 0 && str[0] == '-')
66 {
67 markers += 1;
68 negative = true;
69 }
70
71 if(str.length() > markers + 2 && str[markers ] == '0' &&
72 str[markers + 1] == 'x')
73 {
74 markers += 2;
75 base = Hexadecimal;
76 }
77
78 *this = decode(cast_char_ptr_to_uint8(str.data()) + markers,
79 str.length() - markers, base);
80
81 if(negative) set_sign(Negative);
82 else set_sign(Positive);
83 }
Botan::BigInt::decode
static BigInt decode(const uint8_t buf[], size_t length)
Definition: bigint.h:817
Botan::BigInt::Base
Base
Definition: bigint.h:30
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:569
Botan::cast_char_ptr_to_uint8
const uint8_t * cast_char_ptr_to_uint8(const char *s)
Definition: mem_ops.h:190

References Botan::cast_char_ptr_to_uint8(), Decimal, decode(), Hexadecimal, Negative, Positive, and set_sign().

## ◆ BigInt() [5/12]

Botan::BigInt::BigInt | ( | const uint8_t | buf[],
|  | size_t | length
| ) |  |

Create a BigInt from an integer in a byte array

Parameters

  buf | the byte array holding the value
  length | size of buf

Definition at line 85 of file bigint.cpp.

86 {
87 binary_decode(input, length);
88 }
Botan::BigInt::binary_decode
void binary_decode(const uint8_t buf[], size_t length)
Definition: bigint.cpp:440

References binary_decode().

## ◆ BigInt() [6/12]

template<typename Alloc >

Botan::BigInt::BigInt | ( | const std::vector< uint8_t, Alloc > & | vec | ) |
| inline explicit

Create a BigInt from an integer in a byte array

Parameters

  vec | the byte vector holding the value

Definition at line 93 of file bigint.h.

93: BigInt(vec.data(), vec.size()) {}
Botan::BigInt::BigInt
BigInt()=default

## ◆ BigInt() [7/12]

Botan::BigInt::BigInt | ( | const uint8_t | buf[],
|  | size_t | length,
|  | Base | base
| ) |  |

Create a BigInt from an integer in a byte array

Parameters

  buf | the byte array holding the value
  length | size of buf
  base | is the number base of the integer in buf

Definition at line 93 of file bigint.cpp.

94 {
95 *this = decode(input, length, base);
96 }

References decode().

## ◆ BigInt() [8/12]

Botan::BigInt::BigInt | ( | const uint8_t | buf[],
|  | size_t | length,
|  | size_t | max_bits
| ) |  |

Create a BigInt from an integer in a byte array

Parameters

  buf | the byte array holding the value
  length | size of buf
  max_bits | if the resulting integer is more than max_bits, it will be shifted so it is at most max_bits in length.

Definition at line 98 of file bigint.cpp.

99 {
100 if(8 * length > max_bits)
101 length = (max_bits + 7) / 8;
102
103 binary_decode(buf, length);
104
105 if(8 * length > max_bits)
106 *this >>= (8 - (max_bits % 8));
107 }

References binary_decode().

## ◆ BigInt() [9/12]

Botan::BigInt::BigInt | ( | const word | words[],
|  | size_t | length
| ) |  |

Create a BigInt from an array of words

Parameters

  words | the words
  length | number of words

Definition at line 17 of file bigint.cpp.

18 {
19 m_data.set_words(words, length);
20 }

## ◆ BigInt() [10/12]

Botan::BigInt::BigInt | ( | RandomNumberGenerator & | rng,
|  | size_t | bits,
|  | bool | set_high_bit = `true`
| ) |  |

Create a random BigInt of the specified size.

Parameters

  rng | random number generator
  bits | size in bits
  set_high_bit | if true, the highest bit is always set

See also
  randomize

Definition at line 112 of file bigint.cpp.

113 {
114 randomize(rng, bits, set_high_bit);
115 }
Botan::BigInt::randomize
void randomize(RandomNumberGenerator &rng, size_t bitsize, bool set_high_bit=true)
Definition: big_rand.cpp:17
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:304

References bits(), and randomize().

## ◆ BigInt() [11/12]

Botan::BigInt::BigInt | ( | Sign | sign,
|  | size_t | n
| ) |  |

Create BigInt of specified size, all zeros

Parameters

  sign | the sign
  n | size of the internal register in words

Definition at line 42 of file bigint.cpp.

43 {
44 m_data.set_size(size);
45 m_signedness = s;
46 }
Botan::BigInt::size
size_t size() const
Definition: bigint.h:586

References size().

## ◆ BigInt() [12/12]

Botan::BigInt::BigInt | ( | BigInt && | other | ) |
| inline

Move constructor

Definition at line 140 of file bigint.h.

141 {
142 this->swap(other);
143 }
Botan::BigInt::swap
void swap(BigInt &other)
Definition: bigint.h:167

## ◆ ~BigInt()

Botan::BigInt::~BigInt | ( |  | ) |
| inline

Definition at line 145 of file bigint.h.

145{ const_time_unpoison(); }
Botan::BigInt::const_time_unpoison
void const_time_unpoison() const
Definition: bigint.h:752

## Member Function Documentation

## ◆ abs()

BigInt Botan::BigInt::abs | ( |  | ) | const

Returns
  absolute (positive) value of this

Definition at line 400 of file bigint.cpp.

401 {
402 BigInt x = (*this);
403 x.set_sign(Positive);
404 return x;
405 }

References Positive, and set_sign().

Referenced by Botan::abs().

## ◆ add()

BigInt & Botan::BigInt::add | ( | const word | y[],
|  | size_t | y_words,
|  | Sign | sign
| ) |  |

Definition at line 15 of file big_ops2.cpp.

16 {
17 const size_t x_sw = sig_words();
18
19 grow_to(std::max(x_sw, y_words) + 1);
20
21 if(sign() == y_sign)
22 {
23 bigint_add2(mutable_data(), size() - 1, y, y_words);
24 }
25 else
26 {
27 const int32_t relative_size = bigint_cmp(data(), x_sw, y, y_words);
28
29 if(relative_size >= 0)
30 {
31 // *this >= y
32 bigint_sub2(mutable_data(), x_sw, y, y_words);
33 }
34 else
35 {
36 // *this < y
37 bigint_sub2_rev(mutable_data(), y, y_words);
38 }
39
40 //this->sign_fixup(relative_size, y_sign);
41 if(relative_size < 0)
42 set_sign(y_sign);
43 else if(relative_size == 0)
44 set_sign(Positive);
45 }
46
47 return (*this);
48 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:592
Botan::BigInt::mutable_data
word * mutable_data()
Definition: bigint.h:620
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:642
Botan::BigInt::data
const word * data() const
Definition: bigint.h:626
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:545
Botan::bigint_sub2_rev
void bigint_sub2_rev(word x[], const word y[], size_t y_size)
Definition: mp_core.h:324
Botan::bigint_sub2
word bigint_sub2(word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:300
Botan::bigint_add2
void bigint_add2(word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:280
Botan::bigint_cmp
int32_t bigint_cmp(const word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:525

References Botan::bigint_add2(), Botan::bigint_cmp(), Botan::bigint_sub2(), Botan::bigint_sub2_rev(), data(), grow_to(), mutable_data(), Positive, set_sign(), sig_words(), sign(), and size().

Referenced by Botan::Modular_Reducer::reduce().

## ◆ add2()

BigInt Botan::BigInt::add2 | ( | const BigInt & | x,
|  | const word | y[],
|  | size_t | y_words,
|  | BigInt::Sign | y_sign
| ) |  |
| static

Definition at line 18 of file big_ops3.cpp.

19 {
20 const size_t x_sw = x.sig_words();
21
22 BigInt z(x.sign(), std::max(x_sw, y_words) + 1);
23
24 if(x.sign() == y_sign)
25 {
26 bigint_add3(z.mutable_data(), x.data(), x_sw, y, y_words);
27 }
28 else
29 {
30 const int32_t relative_size = bigint_sub_abs(z.mutable_data(), x.data(), x_sw, y, y_words);
31
32 //z.sign_fixup(relative_size, y_sign);
33 if(relative_size < 0)
34 z.set_sign(y_sign);
35 else if(relative_size == 0)
36 z.set_sign(BigInt::Positive);
37 }
38
39 return z;
40 }
Botan::bigint_add3
void bigint_add3(word z[], const word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:289
Botan::bigint_sub_abs
CT::Mask< word > bigint_sub_abs(word z[], const word x[], const word y[], size_t N, word ws[])
Definition: mp_core.h:377

References Botan::bigint_add3(), Botan::bigint_sub_abs(), data(), mutable_data(), Positive, set_sign(), sig_words(), and sign().

Referenced by Botan::operator+(), and Botan::operator-().

## ◆ binary_decode() [1/2]

template<typename Alloc >

void Botan::BigInt::binary_decode | ( | const std::vector< uint8_t, Alloc > & | buf | ) |
| inline

Read integer value from a byte vector

Parameters

  buf | the vector to load from

Definition at line 698 of file bigint.h.

699 {
700 binary_decode(buf.data(), buf.size());
701 }

## ◆ binary_decode() [2/2]

void Botan::BigInt::binary_decode | ( | const uint8_t | buf[],
|  | size_t | length
| ) |  |

Read integer value from a byte array with given size

Parameters

  buf | byte array buffer containing the integer
  length | size of buf

Definition at line 440 of file bigint.cpp.

441 {
442 clear();
443
444 const size_t full_words = length / sizeof(word);
445 const size_t extra_bytes = length % sizeof(word);
446
447 secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
448
449 for(size_t i = 0; i != full_words; ++i)
450 {
451 reg[i] = load_be<word>(buf + length - sizeof(word)*(i+1), 0);
452 }
453
454 if(extra_bytes > 0)
455 {
456 for(size_t i = 0; i != extra_bytes; ++i)
457 reg[full_words] = (reg[full_words] << 8) | buf[i];
458 }
459
460 m_data.swap(reg);
461 }
Botan::BigInt::clear
void clear()
Definition: bigint.h:372
Botan::round_up
size_t round_up(size_t n, size_t align_to)
Definition: rounding.h:21

References clear(), and Botan::round_up().

Referenced by BigInt(), botan_mp_from_bin(), decode(), Botan::generate_dsa_primes(), Botan::RFC6979_Nonce_Generator::nonce_for(), and randomize().

## ◆ binary_encode() [1/2]

void Botan::BigInt::binary_encode | ( | uint8_t | buf[] | ) | const

Store BigInt-value in a given byte array

Parameters

  buf | destination byte array for the integer value

Definition at line 407 of file bigint.cpp.

408 {
409 this->binary_encode(buf, bytes());
410 }
Botan::BigInt::binary_encode
void binary_encode(uint8_t buf[]) const
Definition: bigint.cpp:407
Botan::BigInt::bytes
size_t bytes() const
Definition: bigint.cpp:289

References binary_encode(), and bytes().

Referenced by Botan::base58_decode(), binary_encode(), botan_mp_to_bin(), encode(), Botan::DER_Encoder::encode(), encode_1363(), encode_fixed_length_int_pair(), encode_locked(), and Botan::GOST_3410_PublicKey::public_key_bits().

## ◆ binary_encode() [2/2]

void Botan::BigInt::binary_encode | ( | uint8_t | buf[],
|  | size_t | len
| ) |  | const

Store BigInt-value in a given byte array. If len is less than the size of the value, then it will be truncated. If len is greater than the size of the value, it will be zero-padded. If len exactly equals this->bytes(), this function behaves identically to binary_encode.

Parameters

  buf | destination byte array for the integer value
  len | how many bytes to write

Definition at line 415 of file bigint.cpp.

416 {
417 const size_t full_words = len / sizeof(word);
418 const size_t extra_bytes = len % sizeof(word);
419
420 for(size_t i = 0; i != full_words; ++i)
421 {
422 const word w = word_at(i);
423 store_be(w, output + (len - (i+1)*sizeof(word)));
424 }
425
426 if(extra_bytes > 0)
427 {
428 const word w = word_at(full_words);
429
430 for(size_t i = 0; i != extra_bytes; ++i)
431 {
432 output[extra_bytes - i - 1] = get_byte(sizeof(word) - i - 1, w);
433 }
434 }
435 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:514
Botan::store_be
void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:438
Botan::get_byte
constexpr uint8_t get_byte(size_t byte_num, T input)
Definition: loadstor.h:41

References Botan::get_byte(), Botan::store_be(), and word_at().

## ◆ bits()

size_t Botan::BigInt::bits | ( |  | ) | const

Get the bit length of the integer

Returns
  bit length of the represented integer value

Definition at line 304 of file bigint.cpp.

305 {
306 const size_t words = sig_words();
307
308 if(words == 0)
309 return 0;
310
311 const size_t full_words = (words - 1) * BOTAN_MP_WORD_BITS;
312 const size_t top_bits = BOTAN_MP_WORD_BITS - top_bits_free();
313
314 return full_words + top_bits;
315 }
Botan::BigInt::top_bits_free
size_t top_bits_free() const
Definition: bigint.cpp:294

References sig_words(), and top_bits_free().

Referenced by BigInt(), botan_mp_num_bits(), bytes(), Botan::ct_divide(), Botan::ct_divide_u8(), Botan::ct_modulo(), Botan::BER_Decoder::decode(), Botan::BER_Decoder::decode_constrained_integer(), Botan::DL_Group::DL_Group(), Botan::DER_Encoder::encode(), encoded_size(), Botan::generate_dsa_primes(), Botan::generate_rsa_prime(), Botan::generate_srp6_verifier(), Botan::inverse_mod(), Botan::is_lucas_probable_prime(), Botan::is_perfect_square(), Botan::is_prime(), Botan::TPM_PrivateKey::key_length(), Botan::monty_multi_exp(), Botan::PointGFp_Base_Point_Precompute::mul(), Botan::PointGFp_Var_Point_Precompute::mul(), Botan::PointGFp_Multi_Point_Precompute::multi_exp(), Botan::operator*(), operator/=(), Botan::passes_miller_rabin_test(), Botan::DL_Group::power_g_p(), Botan::power_mod(), random_integer(), Botan::random_prime(), Botan::RSA_PrivateKey::RSA_PrivateKey(), Botan::srp6_group_identifier(), to_hex_string(), and to_u32bit().

## ◆ byte_at()

uint8_t Botan::BigInt::byte_at | ( | size_t | n | ) | const

Parameters

  n | the offset to get a byte from

Returns
  byte at offset n

Definition at line 117 of file bigint.cpp.

118 {
119 return get_byte(sizeof(word) - (n % sizeof(word)) - 1,
120 word_at(n / sizeof(word)));
121 }

References Botan::get_byte(), and word_at().

Referenced by Botan::BER_Decoder::decode(), Botan::BER_Decoder::decode_constrained_integer(), and to_u32bit().

## ◆ bytes()

size_t Botan::BigInt::bytes | ( |  | ) | const

Give byte length of the integer

Returns
  byte length of the represented integer value

Definition at line 289 of file bigint.cpp.

290 {
291 return round_up(bits(), 8) / 8;
292 }

References bits(), and Botan::round_up().

Referenced by Botan::base58_decode(), binary_encode(), botan_mp_num_bytes(), Botan::ECIES_KA_Operation::derive_secret(), encode(), Botan::DER_Encoder::encode(), Botan::PointGFp::encode(), encode_1363(), encode_fixed_length_int_pair(), encode_locked(), encoded_size(), Botan::EC_PrivateKey::private_key_bits(), Botan::GOST_3410_PublicKey::public_key_bits(), and Botan::SRP6_Server_Session::step1().

## ◆ clear()

void Botan::BigInt::clear | ( |  | ) |
| inline

Zeroize the BigInt. The size of the underlying register is not modified.

Definition at line 372 of file bigint.h.

372{ m_data.set_to_zero(); m_signedness = Positive; }

Referenced by Botan::PointGFp::add(), Botan::PointGFp::add_affine(), binary_decode(), botan_mp_clear(), mul(), operator*=(), and randomize().

## ◆ clear_bit()

void Botan::BigInt::clear_bit | ( | size_t | n | ) |

Clear bit at specified position

Parameters

  n | bit position to clear

Definition at line 278 of file bigint.cpp.

279 {
280 const size_t which = n / BOTAN_MP_WORD_BITS;
281
282 if(which < size())
283 {
284 const word mask = ~(static_cast<word>(1) << (n % BOTAN_MP_WORD_BITS));
285 m_data.set_word_at(which, word_at(which) & mask);
286 }
287 }

References size(), and word_at().

Referenced by botan_mp_clear_bit().

## ◆ cmp()

int32_t Botan::BigInt::cmp | ( | const BigInt & | n,
|  | bool | check_signs = `true`
| ) |  | const

Compare this to another BigInt

Parameters

  n | the BigInt value to compare with
  check_signs | include sign in comparison?

Returns
  if (this<n) return -1, if (this>n) return 1, if both values are identical return 0 [like Perl's <=> operator]

Definition at line 138 of file bigint.cpp.

139 {
140 if(check_signs)
141 {
142 if(other.is_positive() && this->is_negative())
143 return -1;
144
145 if(other.is_negative() && this->is_positive())
146 return 1;
147
148 if(other.is_negative() && this->is_negative())
149 return (-bigint_cmp(this->data(), this->size(),
150 other.data(), other.size()));
151 }
152
153 return bigint_cmp(this->data(), this->size(),
154 other.data(), other.size());
155 }

References Botan::bigint_cmp(), data(), is_negative(), is_positive(), and size().

Referenced by botan_mp_cmp(), Botan::operator<=(), and Botan::operator>=().

## ◆ cmp_word()

int32_t Botan::BigInt::cmp_word | ( | word | n | ) | const

Compare this to an integer

Parameters

  n | the value to compare with

Returns
  if (this<n) return -1, if (this>n) return 1, if both values are identical return 0 [like Perl's <=> operator]

Definition at line 123 of file bigint.cpp.

124 {
125 if(is_negative())
126 return -1; // other is positive ...
127
128 const size_t sw = this->sig_words();
129 if(sw > 1)
130 return 1; // must be larger since other is just one word ...
131
132 return bigint_cmp(this->data(), sw, &other, 1);
133 }
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:533

References Botan::bigint_cmp(), data(), is_negative(), and sig_words().

Referenced by Botan::operator!=(), Botan::operator<(), Botan::operator<=(), Botan::operator==(), Botan::operator>(), and Botan::operator>=().

## ◆ cond_flip_sign()

void Botan::BigInt::cond_flip_sign | ( | bool | predicate | ) |

If predicate is true flip the sign of *this

Definition at line 517 of file bigint.cpp.

518 {
519 // This code is assuming Negative == 0, Positive == 1
520
521 const auto mask = CT::Mask<uint8_t>::expand(predicate);
522
523 const uint8_t current_sign = static_cast<uint8_t>(sign());
524
525 const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);
526
527 set_sign(static_cast<Sign>(new_sign));
528 }
Botan::BigInt::Sign
Sign
Definition: bigint.h:35
Botan::CT::Mask::expand
static Mask< T > expand(T v)
Definition: ct_utils.h:123

References Botan::CT::Mask< T >::expand(), set_sign(), and sign().

Referenced by ct_cond_assign(), Botan::operator*(), and rev_sub().

## ◆ conditionally_set_bit()

void Botan::BigInt::conditionally_set_bit | ( | size_t | n,
|  | bool | set_it
| ) |  |

Conditionally set bit at specified position. Note if set_it is false, nothing happens, and if the bit is already set, it remains set.

Parameters

  n | bit position to set
  set_it | if the bit should be set

Definition at line 268 of file bigint.cpp.

269 {
270 const size_t which = n / BOTAN_MP_WORD_BITS;
271 const word mask = static_cast<word>(set_it) << (n % BOTAN_MP_WORD_BITS);
272 m_data.set_word_at(which, word_at(which) | mask);
273 }

References word_at().

Referenced by Botan::ct_divide(), Botan::ct_divide_u8(), and Botan::ct_modulo().

## ◆ const_time_lookup()

void Botan::BigInt::const_time_lookup | ( | secure_vector< word > & | output,
|  | const std::vector< BigInt > & | vec,
|  | size_t | idx
| ) |  |
| static

Set output = vec[idx].m_reg in constant time

All elements of vec must have the same size, and output must be pre-allocated with the same size.

Definition at line 565 of file bigint.cpp.

568 {
569 const size_t words = output.size();
570
571 clear_mem(output.data(), output.size());
572
573 CT::poison(&idx, sizeof(idx));
574
575 for(size_t i = 0; i != vec.size(); ++i)
576 {
577 BOTAN_ASSERT(vec[i].size() >= words,
578 "Word size as expected in const_time_lookup");
579
580 const auto mask = CT::Mask<word>::is_equal(i, idx);
581
582 for(size_t w = 0; w != words; ++w)
583 {
584 const word viw = vec[i].word_at(w);
585 output[w] = mask.if_set_return(viw);
586 }
587 }
588
589 CT::unpoison(idx);
590 CT::unpoison(output.data(), output.size());
591 }
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:55
Botan::CT::Mask::is_equal
static Mask< T > is_equal(T x, T y)
Definition: ct_utils.h:149
Botan::CT::poison
void poison(const T *p, size_t n)
Definition: ct_utils.h:48
Botan::CT::unpoison
void unpoison(const T *p, size_t n)
Definition: ct_utils.h:59
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115

References BOTAN_ASSERT, Botan::clear_mem(), Botan::CT::Mask< T >::is_equal(), Botan::CT::poison(), size(), and Botan::CT::unpoison().

## ◆ const_time_poison()

void Botan::BigInt::const_time_poison | ( |  | ) | const
| inline

Definition at line 751 of file bigint.h.

751{}

Referenced by Botan::gcd().

## ◆ const_time_unpoison()

void Botan::BigInt::const_time_unpoison | ( |  | ) | const
| inline

Definition at line 752 of file bigint.h.

752{}

## ◆ ct_cond_add()

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

If predicate is true add value to *this

Definition at line 463 of file bigint.cpp.

464 {
465 if(this->is_negative() || value.is_negative())
466 throw Invalid_Argument("BigInt::ct_cond_add requires both values to be positive");
467 this->grow_to(1 + value.sig_words());
468
469 bigint_cnd_add(static_cast<word>(predicate),
470 this->mutable_data(), this->size(),
471 value.data(), value.sig_words());
472 }
Botan::bigint_cnd_add
word bigint_cnd_add(word cnd, word x[], word x_size, const word y[], size_t y_size)
Definition: mp_core.h:42

References Botan::bigint_cnd_add(), data(), grow_to(), is_negative(), mutable_data(), sig_words(), and size().

Referenced by Botan::is_lucas_probable_prime().

## ◆ ct_cond_assign()

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

If predicate is true assign other to *this Uses a masked operation to avoid side channels

Definition at line 530 of file bigint.cpp.

531 {
532 const size_t t_words = size();
533 const size_t o_words = other.size();
534
535 if(o_words < t_words)
536 grow_to(o_words);
537
538 const size_t r_words = std::max(t_words, o_words);
539
540 const auto mask = CT::Mask<word>::expand(predicate);
541
542 for(size_t i = 0; i != r_words; ++i)
543 {
544 const word o_word = other.word_at(i);
545 const word t_word = this->word_at(i);
546 this->set_word_at(i, mask.select(o_word, t_word));
547 }
548
549 const bool different_sign = sign() != other.sign();
550 cond_flip_sign(predicate && different_sign);
551 }
Botan::BigInt::set_word_at
void set_word_at(size_t i, word w)
Definition: bigint.h:519
Botan::BigInt::cond_flip_sign
void cond_flip_sign(bool predicate)
Definition: bigint.cpp:517

References cond_flip_sign(), Botan::CT::Mask< T >::expand(), grow_to(), set_word_at(), sign(), size(), and word_at().

Referenced by ct_shift_left(), Botan::inverse_mod(), Botan::is_lucas_probable_prime(), and Botan::power_mod().

## ◆ ct_cond_swap()

void Botan::BigInt::ct_cond_swap | ( | bool | predicate,
|  | BigInt & | other
| ) |  |

If predicate is true swap *this and other Uses a masked operation to avoid side channels

Definition at line 474 of file bigint.cpp.

475 {
476 const size_t max_words = std::max(size(), other.size());
477 grow_to(max_words);
478 other.grow_to(max_words);
479
480 bigint_cnd_swap(predicate, this->mutable_data(), other.mutable_data(), max_words);
481 }
Botan::bigint_cnd_swap
void bigint_cnd_swap(word cnd, word x[], word y[], size_t size)
Definition: mp_core.h:29

References Botan::bigint_cnd_swap(), grow_to(), mutable_data(), and size().

Referenced by Botan::ct_divide(), and Botan::ct_modulo().

## ◆ ct_reduce_below()

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

Return *this % mod

Assumes that *this is (if anything) only slightly larger than mod and performs repeated subtractions. It should not be used if *this is much larger than mod, instead use modulo operator.

Performs exactly bound subtractions, so if *this is >= bound*mod then the result will not be fully reduced. If bound is zero, nothing happens.

Definition at line 374 of file bigint.cpp.

375 {
376 if(mod.is_negative() || this->is_negative())
377 throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");
378
379 const size_t mod_words = mod.sig_words();
380
381 grow_to(mod_words);
382
383 const size_t sz = size();
384
385 ws.resize(sz);
386
387 clear_mem(ws.data(), sz);
388
389 for(size_t i = 0; i != bound; ++i)
390 {
391 word borrow = bigint_sub3(ws.data(), data(), sz, mod.data(), mod_words);
392
393 CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), data(), sz);
394 }
395 }
Botan::CT::Mask::is_zero
static Mask< T > is_zero(T x)
Definition: ct_utils.h:141
Botan::bigint_sub3
word bigint_sub3(word z[], const word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:342

References Botan::bigint_sub3(), Botan::clear_mem(), data(), grow_to(), is_negative(), Botan::CT::Mask< T >::is_zero(), mutable_data(), sig_words(), and size().

Referenced by Botan::Modular_Reducer::reduce().

## ◆ ct_shift_left()

void Botan::BigInt::ct_shift_left | ( | size_t | shift | ) |

Shift `shift` bits to the left, runtime is independent of the value of `shift`.

Definition at line 483 of file bigint.cpp.

483 {
484 auto shl_bit = [](const BigInt& a, BigInt& result) {
485 BOTAN_DEBUG_ASSERT(a.size() + 1 == result.size());
486 bigint_shl2(result.mutable_data(), a.data(), a.size(), 0, 1);
487 // shl2 may have shifted a bit into the next word, which must be dropped
488 clear_mem(result.mutable_data() + result.size() - 1, 1);
489 };
490
491 auto shl_word = [](const BigInt& a, BigInt& result) {
492 // the most significant word is not copied, aka. shifted out
493 bigint_shl2(result.mutable_data(), a.data(), a.size() - 1 /* ignore msw */, 1, 0);
494 // we left-shifted by a full word, the least significant word must be zero'ed
495 clear_mem(result.mutable_data(), 1);
496 };
497
498 BOTAN_ASSERT_NOMSG(size() > 0);
499
500 constexpr size_t bits_in_word = sizeof(word) * 8;
501 const size_t word_shift = shift >> ceil_log2(bits_in_word); // shift / bits_in_word
502 const size_t bit_shift = shift & ((1 << ceil_log2(bits_in_word)) - 1); // shift % bits_in_word
503 const size_t iterations = std::max(size(), bits_in_word) - 1; // uint64_t i; i << 64 is undefined behaviour
504
505 // In every iteration, shift one bit and one word to the left and use the
506 // shift results only when they are within the shift range.
507 BigInt tmp;
508 tmp.resize(size() + 1 /* to hold the shifted-out word */);
509 for(size_t i = 0; i < iterations; ++i) {
510 shl_bit(*this, tmp);
511 ct_cond_assign(i < bit_shift, tmp);
512 shl_word(*this, tmp);
513 ct_cond_assign(i < word_shift, tmp);
514 }
515}
BOTAN_ASSERT_NOMSG
#define BOTAN_ASSERT_NOMSG(expr)
Definition: assert.h:68
BOTAN_DEBUG_ASSERT
#define BOTAN_DEBUG_ASSERT(expr)
Definition: assert.h:123
Botan::BigInt::ct_cond_assign
void ct_cond_assign(bool predicate, const BigInt &other)
Definition: bigint.cpp:530
Botan::ceil_log2
uint8_t ceil_log2(T x)
Definition: bit_ops.h:119
Botan::bigint_shl2
void bigint_shl2(word y[], const word x[], size_t x_size, size_t word_shift, size_t bit_shift)
Definition: mp_core.h:449

References Botan::bigint_shl2(), BOTAN_ASSERT_NOMSG, BOTAN_DEBUG_ASSERT, Botan::ceil_log2(), Botan::clear_mem(), ct_cond_assign(), data(), resize(), and size().

## ◆ data()

const word * Botan::BigInt::data | ( |  | ) | const
| inline

Return a const pointer to the register

Returns
  a pointer to the start of the internal register

Definition at line 626 of file bigint.h.

626{ return m_data.const_data(); }

Referenced by Botan::PointGFp::add(), add(), add2(), Botan::PointGFp::add_affine(), cmp(), cmp_word(), ct_cond_add(), Botan::ct_divide(), Botan::ct_modulo(), ct_reduce_below(), ct_shift_left(), Botan::CurveGFp_Repr::curve_mul(), Botan::CurveGFp_Repr::curve_sqr(), encode_words(), is_equal(), is_less_than(), mod_add(), mod_sub(), Botan::Montgomery_Params::mul(), mul(), Botan::mul_add(), Botan::Montgomery_Params::mul_by(), Botan::operator*(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), Botan::operator<<(), Botan::operator>>(), Botan::Montgomery_Params::redc(), Botan::redc_p521(), Botan::Modular_Reducer::reduce(), reduce_below(), rev_sub(), Botan::Montgomery_Params::sqr(), square(), and Botan::Montgomery_Params::square_this().

## ◆ decode() [1/4]

template<typename Alloc >

static BigInt Botan::BigInt::decode | ( | const std::vector< uint8_t, Alloc > & | buf | ) |
| inline static

Create a BigInt from an integer in a byte array

Parameters

  buf | the binary value to load

Returns
  BigInt representing the integer in the byte array

Definition at line 828 of file bigint.h.

829 {
830 return BigInt(buf);
831 }

## ◆ decode() [2/4]

template<typename Alloc >

static BigInt Botan::BigInt::decode | ( | const std::vector< uint8_t, Alloc > & | buf,
|  | Base | base
| ) |  |
| inline static

Create a BigInt from an integer in a byte array

Parameters

  buf | the binary value to load
  base | number-base of the integer in buf

Returns
  BigInt representing the integer in the byte array

Definition at line 890 of file bigint.h.

891 {
892 if(base == Binary)
893 return BigInt(buf);
894 return BigInt::decode(buf.data(), buf.size(), base);
895 }

References decode().

## ◆ decode() [3/4]

static BigInt Botan::BigInt::decode | ( | const uint8_t | buf[],
|  | size_t | length
| ) |  |
| inline static

Create a BigInt from an integer in a byte array

Parameters

  buf | the binary value to load
  length | size of buf

Returns
  BigInt representing the integer in the byte array

Definition at line 817 of file bigint.h.

818 {
819 return BigInt(buf, length);
820 }

Referenced by BigInt(), Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), decode(), Botan::BER_Decoder::decode_octet_string_bigint(), Botan::CRL_Entry::encode_into(), Botan::TPM_PrivateKey::get_e(), Botan::TPM_PrivateKey::get_n(), Botan::OCSP::CertID::is_id_for(), Botan::OS2ECP(), and Botan::TLS::Callbacks::tls_dh_agree().

## ◆ decode() [4/4]

BigInt Botan::BigInt::decode | ( | const uint8_t | buf[],
|  | size_t | length,
|  | Base | base
| ) |  |
| static

Create a BigInt from an integer in a byte array

Parameters

  buf | the binary value to load
  length | size of buf
  base | number-base of the integer in buf

Returns
  BigInt representing the integer in the byte array

Definition at line 146 of file big_code.cpp.

147 {
148 BigInt r;
149 if(base == Binary)
150 {
151 r.binary_decode(buf, length);
152 }
153 else if(base == Hexadecimal)
154 {
155 secure_vector<uint8_t> binary;
156
157 if(length % 2)
158 {
159 // Handle lack of leading 0
160 const char buf0_with_leading_0[2] =
161 { '0', static_cast<char>(buf[0]) };
162
163 binary = hex_decode_locked(buf0_with_leading_0, 2);
164
165 binary += hex_decode_locked(cast_uint8_ptr_to_char(&buf[1]),
166 length - 1,
167 false);
168 }
169 else
170 binary = hex_decode_locked(cast_uint8_ptr_to_char(buf),
171 length, false);
172
173 r.binary_decode(binary.data(), binary.size());
174 }
175 else if(base == Decimal)
176 {
177 for(size_t i = 0; i != length; ++i)
178 {
179 if(Charset::is_space(buf[i]))
180 continue;
181
182 if(!Charset::is_digit(buf[i]))
183 throw Invalid_Argument("BigInt::decode: "
184 "Invalid character in decimal input");
185
186 const uint8_t x = Charset::char2digit(buf[i]);
187
188 if(x >= 10)
189 throw Invalid_Argument("BigInt: Invalid decimal string");
190
191 r *= 10;
192 r += x;
193 }
194 }
195 else
196 throw Invalid_Argument("Unknown BigInt decoding method");
197 return r;
198 }
Botan::Charset::is_digit
bool is_digit(char c)
Definition: charset.cpp:210
Botan::Charset::is_space
bool is_space(char c)
Definition: charset.cpp:221
Botan::Charset::char2digit
uint8_t char2digit(char c)
Definition: charset.cpp:231
Botan::hex_decode_locked
secure_vector< uint8_t > hex_decode_locked(const char input[], size_t input_length, bool ignore_ws)
Definition: hex.cpp:168
Botan::cast_uint8_ptr_to_char
const char * cast_uint8_ptr_to_char(const uint8_t *b)
Definition: mem_ops.h:195

References Binary, binary_decode(), Botan::cast_uint8_ptr_to_char(), Botan::Charset::char2digit(), Decimal, Botan::hex_decode_locked(), Hexadecimal, Botan::Charset::is_digit(), and Botan::Charset::is_space().

## ◆ encode() [1/4]

static std::vector< uint8_t > Botan::BigInt::encode | ( | const BigInt & | n | ) |
| inline static

Encode the integer value from a BigInt to a std::vector of bytes

Parameters

  n | the BigInt to use as integer source

Returns
  secure_vector of bytes containing the bytes of the integer

Definition at line 782 of file bigint.h.

783 {
784 std::vector<uint8_t> output(n.bytes());
785 n.binary_encode(output.data());
786 return output;
787 }

References binary_encode(), and bytes().

Referenced by Botan::TLS::Client_Key_Exchange::Client_Key_Exchange(), Botan::CRL_Entry::decode_from(), encode(), Botan::FPE_FE1::FPE_FE1(), Botan::TLS::Server_Key_Exchange::Server_Key_Exchange(), and to_hex_string().

## ◆ encode() [2/4]

std::vector< uint8_t > Botan::BigInt::encode | ( | const BigInt & | n,
|  | Base | base
| ) |  |
| static

Encode the integer value from a BigInt to a std::vector of bytes

Parameters

  n | the BigInt to use as integer source
  base | number-base of resulting byte array representation

Returns
  secure_vector of bytes containing the integer with given base

Deprecated. If you need Binary, call the version of encode that doesn't take a Base. If you need Hex or Decimal output, use to_hex_string or to_dec_string resp.

Definition at line 81 of file big_code.cpp.

82 {
83 if(base == Binary)
84 return BigInt::encode(n);
85 else if(base == Hexadecimal)
86 return str_to_vector(n.to_hex_string());
87 else if(base == Decimal)
88 return str_to_vector(n.to_dec_string());
89 else
90 throw Invalid_Argument("Unknown BigInt encoding base");
91 }
Botan::BigInt::encode
static std::vector< uint8_t > encode(const BigInt &n)
Definition: bigint.h:782

References Binary, Decimal, encode(), Hexadecimal, to_dec_string(), and to_hex_string().

## ◆ encode() [3/4]

static void Botan::BigInt::encode | ( | uint8_t | buf[],
|  | const BigInt & | n
| ) |  |
| inline static

Encode the integer value from a BigInt to a byte array

Parameters

  buf | destination byte array for the encoded integer
  n | the BigInt to use as integer source

Definition at line 806 of file bigint.h.

807 {
808 n.binary_encode(buf);
809 }

## ◆ encode() [4/4]

void Botan::BigInt::encode | ( | uint8_t | buf[],
|  | const BigInt & | n,
|  | Base | base
| ) |  |
| static

Encode the integer value from a BigInt to a byte array

Parameters

  buf | destination byte array for the encoded integer value with given base
  n | the BigInt to use as integer source
  base | number-base of resulting byte array representation

Deprecated. If you need Binary, call binary_encode. If you need Hex or Decimal output, use to_hex_string or to_dec_string resp.

Definition at line 54 of file big_code.cpp.

55 {
56 secure_vector<uint8_t> enc = n.encode_locked(base);
57 copy_mem(output, enc.data(), enc.size());
58 }
Botan::copy_mem
void copy_mem(T *out, const T *in, size_t n)
Definition: mem_ops.h:133

References Botan::copy_mem(), and encode_locked().

## ◆ encode_1363() [1/2]

secure_vector< uint8_t > Botan::BigInt::encode_1363 | ( | const BigInt & | n,
|  | size_t | bytes
| ) |  |
| static

Encode a BigInt to a byte array according to IEEE 1363

Parameters

  n | the BigInt to encode
  bytes | the length of the resulting secure_vector<uint8_t>

Returns
  a secure_vector<uint8_t> containing the encoded BigInt

Definition at line 111 of file big_code.cpp.

112 {
113 if(n.bytes() > bytes)
114 throw Encoding_Error("encode_1363: n is too large to encode properly");
115
116 secure_vector<uint8_t> output(bytes);
117 n.binary_encode(output.data(), output.size());
118 return output;
119 }

References binary_encode(), and bytes().

Referenced by Botan::PK_Verifier::check_signature(), Botan::EC_Group::DER_encode(), Botan::PointGFp::encode(), Botan::RFC6979_Nonce_Generator::nonce_for(), Botan::EC_PrivateKey::private_key_bits(), Botan::DH_PublicKey::public_value(), Botan::RFC6979_Nonce_Generator::RFC6979_Nonce_Generator(), Botan::Montgomery_Int::serialize(), Botan::sm2_compute_za(), Botan::srp6_client_agree(), and Botan::SRP6_Server_Session::step2().

## ◆ encode_1363() [2/2]

void Botan::BigInt::encode_1363 | ( | uint8_t | out[],
|  | size_t | bytes,
|  | const BigInt & | n
| ) |  |
| static

Definition at line 122 of file big_code.cpp.

123 {
124 if(n.bytes() > bytes)
125 throw Encoding_Error("encode_1363: n is too large to encode properly");
126
127 n.binary_encode(output, bytes);
128 }

References binary_encode(), and bytes().

## ◆ encode_fixed_length_int_pair()

secure_vector< uint8_t > Botan::BigInt::encode_fixed_length_int_pair | ( | const BigInt & | n1,
|  | const BigInt & | n2,
|  | size_t | bytes
| ) |  |
| static

Encode two BigInt to a byte array according to IEEE 1363

Parameters

  n1 | the first BigInt to encode
  n2 | the second BigInt to encode
  bytes | the length of the encoding of each single BigInt

Returns
  a secure_vector<uint8_t> containing the concatenation of the two encoded BigInt

Definition at line 133 of file big_code.cpp.

134 {
135 if(n1.bytes() > bytes || n2.bytes() > bytes)
136 throw Encoding_Error("encode_fixed_length_int_pair: values too large to encode properly");
137 secure_vector<uint8_t> output(2 * bytes);
138 n1.binary_encode(output.data() , bytes);
139 n2.binary_encode(output.data() + bytes, bytes);
140 return output;
141 }

References binary_encode(), and bytes().

## ◆ encode_locked() [1/2]

static secure_vector< uint8_t > Botan::BigInt::encode_locked | ( | const BigInt & | n | ) |
| inline static

Encode the integer value from a BigInt to a secure_vector of bytes

Parameters

  n | the BigInt to use as integer source

Returns
  secure_vector of bytes containing the bytes of the integer

Definition at line 794 of file bigint.h.

795 {
796 secure_vector<uint8_t> output(n.bytes());
797 n.binary_encode(output.data());
798 return output;
799 }

References binary_encode(), and bytes().

Referenced by encode(), and encode_locked().

## ◆ encode_locked() [2/2]

secure_vector< uint8_t > Botan::BigInt::encode_locked | ( | const BigInt & | n,
|  | Base | base
| ) |  |
| static

Encode the integer value from a BigInt to a secure_vector of bytes

Parameters

  n | the BigInt to use as integer source
  base | number-base of resulting byte array representation

Returns
  secure_vector of bytes containing the integer with given base

Deprecated. If you need Binary, call the version of encode_locked that doesn't take a Base. If you need Hex or Decimal output, use to_hex_string or to_dec_string resp.

Definition at line 96 of file big_code.cpp.

97 {
98 if(base == Binary)
99 return BigInt::encode_locked(n);
100 else if(base == Hexadecimal)
101 return str_to_lvector(n.to_hex_string());
102 else if(base == Decimal)
103 return str_to_lvector(n.to_dec_string());
104 else
105 throw Invalid_Argument("Unknown BigInt encoding base");
106 }
Botan::BigInt::encode_locked
static secure_vector< uint8_t > encode_locked(const BigInt &n)
Definition: bigint.h:794

References Binary, Decimal, encode_locked(), Hexadecimal, to_dec_string(), and to_hex_string().

## ◆ encode_words()

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

Place the value into out, zero-padding up to size words Throw if *this cannot be represented in size words

Definition at line 184 of file bigint.cpp.

185 {
186 const size_t words = sig_words();
187
188 if(words > size)
189 throw Encoding_Error("BigInt::encode_words value too large to encode");
190
191 clear_mem(out, size);
192 copy_mem(out, data(), words);
193 }

References Botan::clear_mem(), Botan::copy_mem(), data(), sig_words(), and size().

## ◆ encoded_size()

size_t Botan::BigInt::encoded_size | ( | Base | base = `Binary` | ) | const

Parameters

  base | the base to measure the size for

Returns
  size of this integer in base base

Deprecated. This is only needed when using the `encode` and `encode_locked` functions, which are also deprecated.

Definition at line 320 of file bigint.cpp.

321 {
322 static const double LOG_2_BASE_10 = 0.30102999566;
323
324 if(base == Binary)
325 return bytes();
326 else if(base == Hexadecimal)
327 return 2*bytes();
328 else if(base == Decimal)
329 return static_cast<size_t>((bits() * LOG_2_BASE_10) + 1);
330 else
331 throw Invalid_Argument("Unknown base for BigInt encoding");
332 }

References Binary, bits(), bytes(), Decimal, and Hexadecimal.

## ◆ flip_sign()

void Botan::BigInt::flip_sign | ( |  | ) |
| inline

Flip the sign of this BigInt

Definition at line 560 of file bigint.h.

561 {
562 set_sign(reverse_sign());
563 }
Botan::BigInt::reverse_sign
Sign reverse_sign() const
Definition: bigint.h:550

Referenced by botan_mp_flip_sign(), Botan::ct_divide_u8(), Botan::BER_Decoder::decode(), Botan::is_lucas_probable_prime(), and operator-().

## ◆ get_bit()

bool Botan::BigInt::get_bit | ( | size_t | n | ) | const
| inline

Return bit value at specified position

Parameters

  n | the bit offset to test

Returns
  true, if the bit at position n is set, false otherwise

Definition at line 471 of file bigint.h.

472 {
473 return ((word_at(n / BOTAN_MP_WORD_BITS) >> (n % BOTAN_MP_WORD_BITS)) & 1);
474 }

Referenced by Botan::ct_divide(), Botan::ct_divide_u8(), Botan::ct_modulo(), Botan::PointGFp::encode(), Botan::is_lucas_probable_prime(), Botan::operator*(), and Botan::power_mod().

## ◆ get_substring()

uint32_t Botan::BigInt::get_substring | ( | size_t | offset,
|  | size_t | length
| ) |  | const

Return (a maximum of) 32 bits of the complete value

Parameters

  offset | the offset to start extracting
  length | amount of bits to extract (starting at offset)

Returns
  the integer extracted from the register starting at offset with specified length

Definition at line 221 of file bigint.cpp.

222 {
223 if(length == 0 || length > 32)
224 throw Invalid_Argument("BigInt::get_substring invalid substring length");
225
226 const uint32_t mask = 0xFFFFFFFF >> (32 - length);
227
228 const size_t word_offset = offset / BOTAN_MP_WORD_BITS;
229 const size_t wshift = (offset % BOTAN_MP_WORD_BITS);
230
231 /*
232 * The substring is contained within one or at most two words. The
233 * offset and length are not secret, so we can perform conditional
234 * operations on those values.
235 */
236 const word w0 = word_at(word_offset);
237
238 if(wshift == 0 || (offset + length) / BOTAN_MP_WORD_BITS == word_offset)
239 {
240 return static_cast<uint32_t>(w0 >> wshift) & mask;
241 }
242 else
243 {
244 const word w1 = word_at(word_offset + 1);
245 return static_cast<uint32_t>((w0 >> wshift) | (w1 << (BOTAN_MP_WORD_BITS - wshift))) & mask;
246 }
247 }

References word_at().

Referenced by Botan::monty_multi_exp(), Botan::PointGFp_Base_Point_Precompute::mul(), Botan::PointGFp_Var_Point_Precompute::mul(), and Botan::PointGFp_Multi_Point_Precompute::multi_exp().

## ◆ get_word_vector() [1/2]

secure_vector< word > & Botan::BigInt::get_word_vector | ( |  | ) |
| inline

Don't use this function in application code

Definition at line 631 of file bigint.h.

631{ return m_data.mutable_vector(); }

## ◆ get_word_vector() [2/2]

const secure_vector< word > & Botan::BigInt::get_word_vector | ( |  | ) | const
| inline

Don't use this function in application code

Definition at line 636 of file bigint.h.

636{ return m_data.const_vector(); }

## ◆ grow_to()

void Botan::BigInt::grow_to | ( | size_t | n | ) | const
| inline

Increase internal register buffer to at least n words

Parameters

  n | new size of register

Definition at line 642 of file bigint.h.

642{ m_data.grow_to(n); }

Referenced by add(), ct_cond_add(), ct_cond_assign(), ct_cond_swap(), ct_reduce_below(), Botan::Montgomery_Int::fix_size(), mod_add(), mod_sub(), mul(), Botan::Montgomery_Params::mul_by(), Botan::Montgomery_Params::redc(), Botan::redc_p192(), Botan::redc_p224(), Botan::redc_p256(), Botan::redc_p384(), Botan::redc_p521(), reduce_below(), Botan::Montgomery_Params::square_this(), Botan::vartime_divide(), and with_capacity().

## ◆ is_equal()

bool Botan::BigInt::is_equal | ( | const BigInt & | n | ) | const

Compare this to another BigInt

Parameters

  n | the BigInt value to compare with

Returns
  true if this == n or false otherwise

Definition at line 157 of file bigint.cpp.

158 {
159 if(this->sign() != other.sign())
160 return false;
161
162 return bigint_ct_is_eq(this->data(), this->sig_words(),
163 other.data(), other.sig_words()).is_set();
164 }
Botan::bigint_ct_is_eq
CT::Mask< word > bigint_ct_is_eq(const word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:613

References Botan::bigint_ct_is_eq(), data(), sig_words(), and sign().

Referenced by Botan::operator!=().

## ◆ is_even()

bool Botan::BigInt::is_even | ( |  | ) | const
| inline

Test if the integer has an even value

Returns
  true if the integer is even, false otherwise

Definition at line 409 of file bigint.h.

409{ return (get_bit(0) == 0); }
Botan::BigInt::get_bit
bool get_bit(size_t n) const
Definition: bigint.h:471

Referenced by Botan::almost_montgomery_inverse(), botan_mp_is_even(), Botan::generate_rsa_prime(), Botan::inverse_mod(), Botan::is_lucas_probable_prime(), Botan::is_prime(), Botan::jacobi(), Botan::Montgomery_Params::Montgomery_Params(), Botan::random_prime(), and Botan::ressol().

## ◆ is_less_than()

bool Botan::BigInt::is_less_than | ( | const BigInt & | n | ) | const

Compare this to another BigInt

Parameters

  n | the BigInt value to compare with

Returns
  true if this < n or false otherwise

Definition at line 166 of file bigint.cpp.

167 {
168 if(this->is_negative() && other.is_positive())
169 return true;
170
171 if(this->is_positive() && other.is_negative())
172 return false;
173
174 if(other.is_negative() && this->is_negative())
175 {
176 return bigint_ct_is_lt(other.data(), other.sig_words(),
177 this->data(), this->sig_words()).is_set();
178 }
179
180 return bigint_ct_is_lt(this->data(), this->sig_words(),
181 other.data(), other.sig_words()).is_set();
182 }
Botan::BigInt::is_positive
bool is_positive() const
Definition: bigint.h:539
Botan::bigint_ct_is_lt
CT::Mask< word > bigint_ct_is_lt(const word x[], size_t x_size, const word y[], size_t y_size, bool lt_or_equal=false)
Definition: mp_core.h:576

References Botan::bigint_ct_is_lt(), data(), is_negative(), is_positive(), and sig_words().

Referenced by Botan::operator<(), and Botan::operator>().

## ◆ is_negative()

bool Botan::BigInt::is_negative | ( |  | ) | const
| inline

Tests if the sign of the integer is negative

Returns
  true, iff the integer has a negative sign

Definition at line 533 of file bigint.h.

533{ return (sign() == Negative); }

Referenced by botan_mp_is_negative(), cmp(), cmp_word(), ct_cond_add(), Botan::ct_divide_u8(), Botan::ct_modulo(), ct_reduce_below(), Botan::BER_Decoder::decode(), Botan::inverse_mod(), is_less_than(), Botan::is_lucas_probable_prime(), mod_add(), mod_mul(), mod_sub(), Botan::Montgomery_Params::Montgomery_Params(), Botan::monty_multi_exp(), Botan::PointGFp_Base_Point_Precompute::mul(), Botan::PointGFp_Var_Point_Precompute::mul(), Botan::mul_add(), Botan::mul_sub(), Botan::PointGFp_Multi_Point_Precompute::multi_exp(), Botan::operator%(), Botan::operator*(), Botan::operator>>(), operator>>=(), Botan::power_mod(), random_integer(), Botan::random_prime(), Botan::Modular_Reducer::reduce(), reduce_below(), Botan::Power_Mod::set_base(), Botan::Power_Mod::set_exponent(), Botan::sub_mul(), to_u32bit(), and Botan::vartime_divide().

## ◆ is_nonzero()

bool Botan::BigInt::is_nonzero | ( |  | ) | const
| inline

Test if the integer is not zero

Returns
  true if the integer is non-zero, false otherwise

Definition at line 421 of file bigint.h.

421{ return (!is_zero()); }
Botan::BigInt::is_zero
bool is_zero() const
Definition: bigint.h:427

Referenced by Botan::ct_modulo(), Botan::inverse_mod(), and Botan::Modular_Reducer::reduce().

## ◆ is_odd()

bool Botan::BigInt::is_odd | ( |  | ) | const
| inline

Test if the integer has an odd value

Returns
  true if the integer is odd, false otherwise

Definition at line 415 of file bigint.h.

415{ return (get_bit(0) == 1); }

Referenced by botan_mp_is_odd(), Botan::inverse_mod(), Botan::is_lucas_probable_prime(), Botan::normalized_montgomery_inverse(), Botan::power_mod(), and Botan::Power_Mod::set_modulus().

## ◆ is_positive()

bool Botan::BigInt::is_positive | ( |  | ) | const
| inline

Tests if the sign of the integer is positive

Returns
  true, iff the integer has a positive sign

Definition at line 539 of file bigint.h.

539{ return (sign() == Positive); }

Referenced by botan_mp_is_positive(), cmp(), is_less_than(), and Botan::operator%().

## ◆ is_zero()

bool Botan::BigInt::is_zero | ( |  | ) | const
| inline

Test if the integer is zero

Returns
  true if the integer is zero, false otherwise

Definition at line 427 of file bigint.h.

428 {
429 return (sig_words() == 0);
430 }

Referenced by Botan::PointGFp::add(), Botan::PointGFp::add_affine(), botan_mp_is_zero(), Botan::ct_modulo(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), Botan::gcd(), Botan::inverse_mod(), Botan::Montgomery_Int::is_zero(), Botan::jacobi(), Botan::mul_sub(), Botan::PointGFp::mult2(), Botan::PointGFp::mult2i(), Botan::operator%(), Botan::operator>>(), operator>>=(), Botan::DL_Group::PEM_for_named_group(), Botan::power_mod(), Botan::random_prime(), Botan::RSA_PrivateKey::RSA_PrivateKey(), Botan::vartime_divide(), and Botan::DL_Group::verify_public_element().

## ◆ mask_bits()

void Botan::BigInt::mask_bits | ( | size_t | n | ) |
| inline

Clear all but the lowest n bits

Parameters

  n | amount of bits to keep

Definition at line 461 of file bigint.h.

462 {
463 m_data.mask_bits(n);
464 }

Referenced by Botan::inverse_mod(), Botan::redc_p192(), Botan::redc_p224(), Botan::redc_p256(), Botan::redc_p384(), Botan::redc_p521(), and Botan::Modular_Reducer::reduce().

## ◆ mod_add()

BigInt & Botan::BigInt::mod_add | ( | const BigInt & | y,
|  | const BigInt & | mod,
|  | secure_vector< word > & | ws
| ) |  |

Set *this to (*this + y) % mod This function assumes *this is >= 0 && < mod

Parameters

  y | the BigInt to add - assumed y >= 0 and y < mod
  mod | the positive modulus
  ws | a temp workspace

Definition at line 50 of file big_ops2.cpp.

51 {
52 if(this->is_negative() || s.is_negative() || mod.is_negative())
53 throw Invalid_Argument("BigInt::mod_add expects all arguments are positive");
54
55 BOTAN_DEBUG_ASSERT(*this < mod);
56 BOTAN_DEBUG_ASSERT(s < mod);
57
58 /*
59 t + s or t + s - p == t - (p - s)
60
61 So first compute ws = p - s
62
63 Then compute t + s and t - ws
64
65 If t - ws does not borrow, then that is the correct valued
66 */
67
68 const size_t mod_sw = mod.sig_words();
69 BOTAN_ARG_CHECK(mod_sw > 0, "BigInt::mod_add modulus must be positive");
70
71 this->grow_to(mod_sw);
72 s.grow_to(mod_sw);
73
74 // First mod_sw for p - s, 2*mod_sw for bigint_addsub workspace
75 if(ws.size() < 3*mod_sw)
76 ws.resize(3*mod_sw);
77
78 word borrow = bigint_sub3(&ws[0], mod.data(), mod_sw, s.data(), mod_sw);
79 BOTAN_DEBUG_ASSERT(borrow == 0);
80
81 // Compute t - ws
82 borrow = bigint_sub3(&ws[mod_sw], this->data(), mod_sw, &ws[0], mod_sw);
83
84 // Compute t + s
85 bigint_add3_nc(&ws[mod_sw*2], this->data(), mod_sw, s.data(), mod_sw);
86
87 CT::conditional_copy_mem(borrow, &ws[0], &ws[mod_sw*2], &ws[mod_sw], mod_sw);
88 set_words(&ws[0], mod_sw);
89
90 return (*this);
91 }
BOTAN_ARG_CHECK
#define BOTAN_ARG_CHECK(expr, msg)
Definition: assert.h:37
Botan::BigInt::set_words
void set_words(const word w[], size_t len)
Definition: bigint.h:524
Botan::CT::conditional_copy_mem
Mask< T > conditional_copy_mem(T cnd, T *to, const T *from0, const T *from1, size_t elems)
Definition: ct_utils.h:363
Botan::bigint_add3_nc
word bigint_add3_nc(word z[], const word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:250

References Botan::bigint_add3_nc(), Botan::bigint_sub3(), BOTAN_ARG_CHECK, BOTAN_DEBUG_ASSERT, Botan::CT::conditional_copy_mem(), data(), grow_to(), is_negative(), set_words(), and sig_words().

Referenced by Botan::Montgomery_Int::add(), Botan::PointGFp::mult2(), and Botan::Montgomery_Int::operator+().

## ◆ mod_mul()

BigInt & Botan::BigInt::mod_mul | ( | uint8_t | y,
|  | const BigInt & | mod,
|  | secure_vector< word > & | ws
| ) |  |

Set *this to (*this * y) % mod This function assumes *this is >= 0 && < mod y should be small, less than 16

Parameters

  y | the small integer to multiply by
  mod | the positive modulus
  ws | a temp workspace

Definition at line 120 of file big_ops2.cpp.

121 {
122 BOTAN_ARG_CHECK(this->is_negative() == false, "*this must be positive");
123 BOTAN_ARG_CHECK(y < 16, "y too large");
124
125 BOTAN_DEBUG_ASSERT(*this < mod);
126
127 *this *= static_cast<word>(y);
128 this->reduce_below(mod, ws);
129 return (*this);
130 }
Botan::BigInt::reduce_below
size_t reduce_below(const BigInt &mod, secure_vector< word > &ws)
Definition: bigint.cpp:344

References BOTAN_ARG_CHECK, BOTAN_DEBUG_ASSERT, is_negative(), and reduce_below().

Referenced by Botan::Montgomery_Int::mul_by_2(), Botan::Montgomery_Int::mul_by_3(), Botan::Montgomery_Int::mul_by_4(), Botan::Montgomery_Int::mul_by_8(), and Botan::PointGFp::mult2().

## ◆ mod_sub()

BigInt & Botan::BigInt::mod_sub | ( | const BigInt & | y,
|  | const BigInt & | mod,
|  | secure_vector< word > & | ws
| ) |  |

Set *this to (*this - y) % mod This function assumes *this is >= 0 && < mod

Parameters

  y | the BigInt to subtract - assumed y >= 0 and y < mod
  mod | the positive modulus
  ws | a temp workspace

Definition at line 93 of file big_ops2.cpp.

94 {
95 if(this->is_negative() || s.is_negative() || mod.is_negative())
96 throw Invalid_Argument("BigInt::mod_sub expects all arguments are positive");
97
98 // We are assuming in this function that *this and s are no more than mod_sw words long
99 BOTAN_DEBUG_ASSERT(*this < mod);
100 BOTAN_DEBUG_ASSERT(s < mod);
101
102 const size_t mod_sw = mod.sig_words();
103
104 this->grow_to(mod_sw);
105 s.grow_to(mod_sw);
106
107 if(ws.size() < mod_sw)
108 ws.resize(mod_sw);
109
110 if(mod_sw == 4)
111 bigint_mod_sub_n<4>(mutable_data(), s.data(), mod.data(), ws.data());
112 else if(mod_sw == 6)
113 bigint_mod_sub_n<6>(mutable_data(), s.data(), mod.data(), ws.data());
114 else
115 bigint_mod_sub(mutable_data(), s.data(), mod.data(), mod_sw, ws.data());
116
117 return (*this);
118 }
Botan::bigint_mod_sub
void bigint_mod_sub(word t[], const word s[], const word mod[], size_t mod_sw, word ws[])
Definition: mp_core.h:687

References Botan::bigint_mod_sub(), BOTAN_DEBUG_ASSERT, data(), grow_to(), is_negative(), mutable_data(), and sig_words().

Referenced by Botan::PointGFp::add(), Botan::PointGFp::add_affine(), Botan::PointGFp::mult2(), Botan::Montgomery_Int::operator-(), and Botan::Montgomery_Int::sub().

## ◆ mul()

BigInt & Botan::BigInt::mul | ( | const BigInt & | y,
|  | secure_vector< word > & | ws
| ) |  |

Multiply this with y

Parameters

  y | the BigInt to multiply with this
  ws | a temp workspace

Definition at line 159 of file big_ops2.cpp.

160 {
161 const size_t x_sw = sig_words();
162 const size_t y_sw = y.sig_words();
163 set_sign((sign() == y.sign()) ? Positive : Negative);
164
165 if(x_sw == 0 || y_sw == 0)
166 {
167 clear();
168 set_sign(Positive);
169 }
170 else if(x_sw == 1 && y_sw)
171 {
172 grow_to(y_sw + 1);
173 bigint_linmul3(mutable_data(), y.data(), y_sw, word_at(0));
174 }
175 else if(y_sw == 1 && x_sw)
176 {
177 word carry = bigint_linmul2(mutable_data(), x_sw, y.word_at(0));
178 set_word_at(x_sw, carry);
179 }
180 else
181 {
182 const size_t new_size = x_sw + y_sw + 1;
183 ws.resize(new_size);
184 secure_vector<word> z_reg(new_size);
185
186 bigint_mul(z_reg.data(), z_reg.size(),
187 data(), size(), x_sw,
188 y.data(), y.size(), y_sw,
189 ws.data(), ws.size());
190
191 this->swap_reg(z_reg);
192 }
193
194 return (*this);
195 }
Botan::BigInt::swap_reg
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:173
Botan::bigint_linmul3
void bigint_linmul3(word z[], const word x[], size_t x_size, word y)
Definition: mp_core.h:504
Botan::bigint_linmul2
word BOTAN_WARN_UNUSED_RESULT bigint_linmul2(word x[], size_t x_size, word y)
Definition: mp_core.h:489
Botan::bigint_mul
void bigint_mul(word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, const word y[], size_t y_size, size_t y_sw, word workspace[], size_t ws_size)
Definition: mp_karat.cpp:298
Botan::carry
void carry(int64_t &h0, int64_t &h1)
Definition: ed25519_internal.h:32

References Botan::bigint_linmul2(), Botan::bigint_linmul3(), Botan::bigint_mul(), Botan::carry(), clear(), data(), grow_to(), mutable_data(), Negative, Positive, set_sign(), set_word_at(), sig_words(), sign(), size(), swap_reg(), and word_at().

Referenced by operator*=(), and Botan::Modular_Reducer::reduce().

## ◆ mutable_data()

word * Botan::BigInt::mutable_data | ( |  | ) |
| inline

Return a mutable pointer to the register

Returns
  a pointer to the start of the internal register

Definition at line 620 of file bigint.h.

620{ return m_data.mutable_data(); }

Referenced by add(), add2(), ct_cond_add(), ct_cond_swap(), Botan::ct_divide(), Botan::ct_modulo(), ct_reduce_below(), mod_sub(), Botan::Montgomery_Params::mul(), mul(), Botan::mul_add(), Botan::Montgomery_Params::mul_by(), Botan::operator*(), operator*=(), Botan::operator<<(), Botan::operator>>(), Botan::Montgomery_Params::redc(), Botan::redc_p192(), Botan::redc_p224(), Botan::redc_p256(), Botan::redc_p384(), Botan::redc_p521(), Botan::Montgomery_Params::sqr(), Botan::Montgomery_Params::square_this(), and Botan::vartime_divide().

## ◆ operator!()

bool Botan::BigInt::operator! | ( |  | ) | const
| inline

! operator

Returns
  true iff this is zero, otherwise false

Definition at line 287 of file bigint.h.

287{ return (!is_nonzero()); }
Botan::BigInt::is_nonzero
bool is_nonzero() const
Definition: bigint.h:421

## ◆ operator%=() [1/2]

BigInt & Botan::BigInt::operator%= | ( | const BigInt & | y | ) |

Modulo operator

Parameters

  y | the modulus to reduce this by

Definition at line 243 of file big_ops2.cpp.

244 {
245 return (*this = (*this) % mod);
246 }

## ◆ operator%=() [2/2]

word Botan::BigInt::operator%= | ( | word | y | ) |

Modulo operator

Parameters

  y | the modulus (word) to reduce this by

Definition at line 251 of file big_ops2.cpp.

252 {
253 if(mod == 0)
254 throw BigInt::DivideByZero();
255
256 word remainder = 0;
257
258 if(is_power_of_2(mod))
259 {
260 remainder = (word_at(0) & (mod - 1));
261 }
262 else
263 {
264 const size_t sw = sig_words();
265 for(size_t i = sw; i > 0; --i)
266 remainder = bigint_modop(remainder, word_at(i-1), mod);
267 }
268
269 if(remainder && sign() == BigInt::Negative)
270 remainder = mod - remainder;
271
272 m_data.set_to_zero();
273 m_data.set_word_at(0, remainder);
274 set_sign(BigInt::Positive);
275 return remainder;
276 }
Botan::bigint_modop
word bigint_modop(word n1, word n0, word d)
Definition: mp_core.h:755
Botan::is_power_of_2
constexpr bool is_power_of_2(T arg)
Definition: bit_ops.h:43

References Botan::bigint_modop(), Botan::is_power_of_2(), Negative, Positive, set_sign(), sig_words(), sign(), and word_at().

## ◆ operator*=() [1/2]

BigInt & Botan::BigInt::operator*= | ( | const BigInt & | y | ) |

*= operator

Parameters

  y | the BigInt to multiply with this

Definition at line 153 of file big_ops2.cpp.

154 {
155 secure_vector<word> ws;
156 return this->mul(y, ws);
157 }
Botan::BigInt::mul
BigInt & mul(const BigInt &y, secure_vector< word > &ws)
Definition: big_ops2.cpp:159

References mul().

## ◆ operator*=() [2/2]

BigInt & Botan::BigInt::operator*= | ( | word | y | ) |

*= operator

Parameters

  y | the word to multiply with this

Definition at line 214 of file big_ops2.cpp.

215 {
216 if(y == 0)
217 {
218 clear();
219 set_sign(Positive);
220 }
221
222 const word carry = bigint_linmul2(mutable_data(), size(), y);
223 set_word_at(size(), carry);
224
225 return (*this);
226 }

References Botan::bigint_linmul2(), Botan::carry(), clear(), mutable_data(), Positive, set_sign(), set_word_at(), and size().

## ◆ operator++() [1/2]

BigInt & Botan::BigInt::operator++ | ( |  | ) |
| inline

Increment operator

Definition at line 260 of file bigint.h.

260{ return (*this += 1); }

## ◆ operator++() [2/2]

BigInt Botan::BigInt::operator++ | ( | int |  | ) |
| inline

Postfix increment operator

Definition at line 270 of file bigint.h.

270{ BigInt x = (*this); ++(*this); return x; }

## ◆ operator+=() [1/2]

BigInt & Botan::BigInt::operator+= | ( | const BigInt & | y | ) |
| inline

+= operator

Parameters

  y | the BigInt to add to this

Definition at line 183 of file bigint.h.

184 {
185 return add(y.data(), y.sig_words(), y.sign());
186 }
Botan::BigInt::add
BigInt & add(const word y[], size_t y_words, Sign sign)
Definition: big_ops2.cpp:15

References data(), sig_words(), and sign().

## ◆ operator+=() [2/2]

BigInt & Botan::BigInt::operator+= | ( | word | y | ) |
| inline

+= operator

Parameters

  y | the word to add to this

Definition at line 192 of file bigint.h.

193 {
194 return add(&y, 1, Positive);
195 }

## ◆ operator-()

BigInt Botan::BigInt::operator- | ( |  | ) | const

Unary negation operator

Returns
  negative this

Definition at line 337 of file bigint.cpp.

338 {
339 BigInt x = (*this);
340 x.flip_sign();
341 return x;
342 }

References flip_sign().

## ◆ operator--() [1/2]

BigInt & Botan::BigInt::operator-- | ( |  | ) |
| inline

Decrement operator

Definition at line 265 of file bigint.h.

265{ return (*this -= 1); }

## ◆ operator--() [2/2]

BigInt Botan::BigInt::operator-- | ( | int |  | ) |
| inline

Postfix decrement operator

Definition at line 275 of file bigint.h.

275{ BigInt x = (*this); --(*this); return x; }

## ◆ operator-=() [1/2]

BigInt & Botan::BigInt::operator-= | ( | const BigInt & | y | ) |
| inline

-= operator

Parameters

  y | the BigInt to subtract from this

Definition at line 201 of file bigint.h.

202 {
203 return sub(y.data(), y.sig_words(), y.sign());
204 }
Botan::BigInt::sub
BigInt & sub(const word y[], size_t y_words, Sign sign)
Definition: bigint.h:293

References data(), sig_words(), and sign().

## ◆ operator-=() [2/2]

BigInt & Botan::BigInt::operator-= | ( | word | y | ) |
| inline

-= operator

Parameters

  y | the word to subtract from this

Definition at line 210 of file bigint.h.

211 {
212 return sub(&y, 1, Positive);
213 }

## ◆ operator/=()

BigInt & Botan::BigInt::operator/= | ( | const BigInt & | y | ) |

/= operator

Parameters

  y | the BigInt to divide this by

Definition at line 231 of file big_ops2.cpp.

232 {
233 if(y.sig_words() == 1 && is_power_of_2(y.word_at(0)))
234 (*this) >>= (y.bits() - 1);
235 else
236 (*this) = (*this) / y;
237 return (*this);
238 }

References bits(), Botan::is_power_of_2(), sig_words(), and word_at().

## ◆ operator<<=()

BigInt & Botan::BigInt::operator<<= | ( | size_t | shift | ) |

Left shift operator

Parameters

  shift | the number of bits to shift this left by

Definition at line 281 of file big_ops2.cpp.

282 {
283 const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
284 const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
285 const size_t size = sig_words();
286
287 const size_t bits_free = top_bits_free();
288
289 const size_t new_size = size + shift_words + (bits_free < shift_bits);
290
291 m_data.grow_to(new_size);
292
293 bigint_shl1(m_data.mutable_data(), new_size, size, shift_words, shift_bits);
294
295 return (*this);
296 }
Botan::bigint_shl1
void bigint_shl1(word x[], size_t x_size, size_t x_words, size_t word_shift, size_t bit_shift)
Definition: mp_core.h:409

References Botan::bigint_shl1(), sig_words(), size(), and top_bits_free().

## ◆ operator=() [1/2]

BigInt & Botan::BigInt::operator= | ( | BigInt && | other | ) |
| inline

Move assignment

Definition at line 150 of file bigint.h.

151 {
152 if(this != &other)
153 this->swap(other);
154
155 return (*this);
156 }

## ◆ operator=() [2/2]

BigInt & Botan::BigInt::operator= | ( | const BigInt & |  | ) |
| default

Copy assignment

## ◆ operator>>=()

BigInt & Botan::BigInt::operator>>= | ( | size_t | shift | ) |

Right shift operator

Parameters

  shift | the number of bits to shift this right by

Definition at line 301 of file big_ops2.cpp.

302 {
303 const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
304 const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
305
306 bigint_shr1(m_data.mutable_data(), m_data.size(), shift_words, shift_bits);
307
308 if(is_negative() && is_zero())
309 set_sign(Positive);
310
311 return (*this);
312 }
Botan::bigint_shr1
void bigint_shr1(word x[], size_t x_size, size_t word_shift, size_t bit_shift)
Definition: mp_core.h:427

References Botan::bigint_shr1(), is_negative(), is_zero(), Positive, and set_sign().

## ◆ power_of_2()

static BigInt Botan::BigInt::power_of_2 | ( | size_t | n | ) |
| inline static

Create a power of two

Parameters

  n | the power of two to create

Returns
  bigint representing 2^n

Definition at line 770 of file bigint.h.

771 {
772 BigInt b;
773 b.set_bit(n);
774 return b;
775 }

References set_bit().

Referenced by Botan::inverse_mod(), Botan::is_perfect_square(), Botan::Montgomery_Params::Montgomery_Params(), and Botan::ressol().

## ◆ random_integer()

BigInt Botan::BigInt::random_integer | ( | RandomNumberGenerator & | rng,
|  | const BigInt & | min,
|  | const BigInt & | max
| ) |  |
| static

Parameters

  rng | a random number generator
  min | the minimum value (must be non-negative)
  max | the maximum value (must be non-negative and > min)

Returns
  random integer in [min,max)

Definition at line 45 of file big_rand.cpp.

47 {
48 if(min.is_negative() || max.is_negative() || max <= min)
49 throw Invalid_Argument("BigInt::random_integer invalid range");
50
51 BigInt r;
52
53 const size_t bits = max.bits();
54
55 do
56 {
57 r.randomize(rng, bits, false);
58 }
59 while(r < min || r >= max);
60
61 return r;
62 }

References bits(), is_negative(), and randomize().

Referenced by botan_mp_rand_range(), Botan::DSA_PrivateKey::DSA_PrivateKey(), Botan::is_miller_rabin_probable_prime(), Botan::EC_Group::random_scalar(), and Botan::PointGFp::randomize_repr().

## ◆ randomize()

void Botan::BigInt::randomize | ( | RandomNumberGenerator & | rng,
|  | size_t | bitsize,
|  | bool | set_high_bit = `true`
| ) |  |

Fill BigInt with a random number with size of bitsize

If `set_high_bit` is true, the highest bit will be set, which causes the entropy to be bits-1. Otherwise the highest bit is randomly chosen by the rng, causing the entropy to be bits.

Parameters

  rng | the random number generator to use
  bitsize | number of bits the created random value should have
  set_high_bit | if true, the highest bit is always set

Definition at line 17 of file big_rand.cpp.

19 {
20 set_sign(Positive);
21
22 if(bitsize == 0)
23 {
24 clear();
25 }
26 else
27 {
28 secure_vector<uint8_t> array = rng.random_vec(round_up(bitsize, 8) / 8);
29
30 // Always cut unwanted bits
31 if(bitsize % 8)
32 array[0] &= 0xFF >> (8 - (bitsize % 8));
33
34 // Set the highest bit if wanted
35 if (set_high_bit)
36 array[0] |= 0x80 >> ((bitsize % 8) ? (8 - bitsize % 8) : 0);
37
38 binary_decode(array);
39 }
40 }

References binary_decode(), clear(), Positive, Botan::RandomNumberGenerator::random_vec(), Botan::round_up(), and set_sign().

Referenced by BigInt(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), and random_integer().

## ◆ reduce_below()

size_t Botan::BigInt::reduce_below | ( | const BigInt & | mod,
|  | secure_vector< word > & | ws
| ) |  |

Return *this % mod

Assumes that *this is (if anything) only slightly larger than mod and performs repeated subtractions. It should not be used if *this is much larger than mod, instead use modulo operator.

Definition at line 344 of file bigint.cpp.

345 {
346 if(p.is_negative() || this->is_negative())
347 throw Invalid_Argument("BigInt::reduce_below both values must be positive");
348
349 const size_t p_words = p.sig_words();
350
351 if(size() < p_words + 1)
352 grow_to(p_words + 1);
353
354 if(ws.size() < p_words + 1)
355 ws.resize(p_words + 1);
356
357 clear_mem(ws.data(), ws.size());
358
359 size_t reductions = 0;
360
361 for(;;)
362 {
363 word borrow = bigint_sub3(ws.data(), data(), p_words + 1, p.data(), p_words);
364 if(borrow)
365 break;
366
367 ++reductions;
368 swap_reg(ws);
369 }
370
371 return reductions;
372 }

References Botan::bigint_sub3(), Botan::clear_mem(), data(), grow_to(), is_negative(), sig_words(), size(), and swap_reg().

Referenced by mod_mul(), and Botan::vartime_divide().

## ◆ resize()

void Botan::BigInt::resize | ( | size_t | s | ) |
| inline

Definition at line 653 of file bigint.h.

653{ m_data.resize(s); }

Referenced by ct_shift_left(), and Botan::PointGFp::force_all_affine().

## ◆ rev_sub()

BigInt & Botan::BigInt::rev_sub | ( | const word | y[],
|  | size_t | y_words,
|  | secure_vector< word > & | ws
| ) |  |

Set *this to y - *this

Parameters

  y | the BigInt to subtract from as a sequence of words
  y_words | length of y in words
  ws | a temp workspace

Definition at line 132 of file big_ops2.cpp.

133 {
134 if(this->sign() != BigInt::Positive)
135 throw Invalid_State("BigInt::sub_rev requires this is positive");
136
137 const size_t x_sw = this->sig_words();
138
139 ws.resize(std::max(x_sw, y_sw));
140 clear_mem(ws.data(), ws.size());
141
142 const int32_t relative_size = bigint_sub_abs(ws.data(), data(), x_sw, y, y_sw);
143
144 this->cond_flip_sign(relative_size > 0);
145 this->swap_reg(ws);
146
147 return (*this);
148 }

References Botan::bigint_sub_abs(), Botan::clear_mem(), cond_flip_sign(), data(), Positive, sig_words(), sign(), and swap_reg().

Referenced by Botan::Modular_Reducer::reduce().

## ◆ reverse_sign()

Sign Botan::BigInt::reverse_sign | ( |  | ) | const
| inline

Returns
  the opposite sign of the represented integer value

Definition at line 550 of file bigint.h.

551 {
552 if(sign() == Positive)
553 return Negative;
554 return Positive;
555 }

Referenced by Botan::operator-().

## ◆ set_bit()

void Botan::BigInt::set_bit | ( | size_t | n | ) |
| inline

Set bit at specified position

Parameters

  n | bit position to set

Definition at line 436 of file bigint.h.

437 {
438 conditionally_set_bit(n, true);
439 }
Botan::BigInt::conditionally_set_bit
void conditionally_set_bit(size_t n, bool set_it)
Definition: bigint.cpp:268

Referenced by botan_mp_set_bit(), Botan::generate_dsa_primes(), Botan::generate_rsa_prime(), Botan::Modular_Reducer::Modular_Reducer(), power_of_2(), and Botan::random_prime().

## ◆ set_sign()

void Botan::BigInt::set_sign | ( | Sign | sign | ) |
| inline

Set sign of the integer

Parameters

  sign | new Sign to set

Definition at line 569 of file bigint.h.

570 {
571 if(sign == Negative && is_zero())
572 sign = Positive;
573
574 m_signedness = sign;
575 }

Referenced by abs(), add(), add2(), BigInt(), cond_flip_sign(), Botan::inverse_mod(), mul(), operator%=(), Botan::operator*(), operator*=(), Botan::operator>>(), operator>>=(), randomize(), Botan::Modular_Reducer::reduce(), square(), to_dec_string(), and Botan::vartime_divide().

## ◆ set_word_at()

void Botan::BigInt::set_word_at | ( | size_t | i,
|  | word | w
| ) |  |
| inline

Definition at line 519 of file bigint.h.

520 {
521 m_data.set_word_at(i, w);
522 }

Referenced by ct_cond_assign(), mul(), and operator*=().

## ◆ set_words()

void Botan::BigInt::set_words | ( | const word | w[],
|  | size_t | len
| ) |  |
| inline

Definition at line 524 of file bigint.h.

525 {
526 m_data.set_words(w, len);
527 }

Referenced by Botan::PointGFp::add(), Botan::PointGFp::add_affine(), and mod_add().

## ◆ shrink_to_fit()

void Botan::BigInt::shrink_to_fit | ( | size_t | min_size = `0` | ) |
| inline

Resize the vector to the minimum word size to hold the integer, or min_size words, whichever is larger

Definition at line 648 of file bigint.h.

649 {
650 m_data.shrink_to_fit(min_size);
651 }

## ◆ sig_words()

size_t Botan::BigInt::sig_words | ( |  | ) | const
| inline

Return how many words we need to hold this value

Returns
  significant words of the represented integer value

Definition at line 592 of file bigint.h.

593 {
594 return m_data.sig_words();
595 }

Referenced by add(), add2(), bits(), cmp_word(), ct_cond_add(), Botan::ct_divide(), Botan::ct_divide_u8(), Botan::ct_modulo(), ct_reduce_below(), Botan::CurveGFp_Repr::curve_mul(), Botan::CurveGFp_Repr::curve_sqr(), encode_words(), Botan::Montgomery_Int::fix_size(), Botan::gcd(), is_equal(), is_less_than(), mod_add(), mod_sub(), Botan::Modular_Reducer::Modular_Reducer(), Botan::Montgomery_Params::Montgomery_Params(), Botan::Montgomery_Params::mul(), mul(), Botan::mul_add(), Botan::Montgomery_Params::mul_by(), Botan::operator%(), operator%=(), Botan::operator*(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), Botan::operator/(), operator/=(), Botan::operator<<(), operator<<=(), Botan::operator>>(), Botan::Modular_Reducer::reduce(), reduce_below(), rev_sub(), Botan::Montgomery_Params::sqr(), square(), Botan::Montgomery_Params::square_this(), top_bits_free(), and Botan::vartime_divide().

## ◆ sign()

Sign Botan::BigInt::sign | ( |  | ) | const
| inline

Return the sign of the integer

Returns
  the sign of the integer

Definition at line 545 of file bigint.h.

545{ return (m_signedness); }

Referenced by add(), add2(), cond_flip_sign(), ct_cond_assign(), is_equal(), mul(), Botan::mul_add(), Botan::operator%(), operator%=(), Botan::operator*(), Botan::operator+(), operator+=(), operator-=(), Botan::operator<<(), Botan::operator>>(), and rev_sub().

## ◆ size()

size_t Botan::BigInt::size | ( |  | ) | const
| inline

Give size of internal register

Returns
  size of internal register in words

Definition at line 586 of file bigint.h.

586{ return m_data.size(); }

Referenced by Botan::PointGFp::add(), add(), Botan::PointGFp::add_affine(), BigInt(), clear_bit(), cmp(), const_time_lookup(), ct_cond_add(), ct_cond_assign(), ct_cond_swap(), Botan::ct_divide(), Botan::ct_modulo(), ct_reduce_below(), ct_shift_left(), Botan::CurveGFp_Repr::curve_mul(), Botan::CurveGFp_Repr::curve_sqr(), encode_words(), Botan::low_zero_bits(), Botan::Montgomery_Params::mul(), mul(), Botan::mul_add(), Botan::Montgomery_Params::mul_by(), Botan::operator*(), operator*=(), operator<<=(), Botan::redc_p192(), Botan::redc_p224(), Botan::redc_p256(), Botan::redc_p384(), Botan::redc_p521(), Botan::Modular_Reducer::reduce(), reduce_below(), Botan::Montgomery_Params::sqr(), square(), Botan::Montgomery_Params::square_this(), and with_capacity().

## ◆ square()

BigInt & Botan::BigInt::square | ( | secure_vector< word > & | ws | ) |

Square value of *this

Parameters

  ws | a temp workspace

Definition at line 197 of file big_ops2.cpp.

198 {
199 const size_t sw = sig_words();
200
201 secure_vector<word> z(2*sw);
202 ws.resize(z.size());
203
204 bigint_sqr(z.data(), z.size(),
205 data(), size(), sw,
206 ws.data(), ws.size());
207
208 swap_reg(z);
209 set_sign(BigInt::Positive);
210
211 return (*this);
212 }
Botan::bigint_sqr
void bigint_sqr(word z[], size_t z_size, const word x[], size_t x_size, size_t x_sw, word workspace[], size_t ws_size)
Definition: mp_karat.cpp:357

References Botan::bigint_sqr(), data(), Positive, set_sign(), sig_words(), size(), and swap_reg().

Referenced by Botan::square().

## ◆ sub()

BigInt & Botan::BigInt::sub | ( | const word | y[],
|  | size_t | y_words,
|  | Sign | sign
| ) |  |
| inline

Definition at line 293 of file bigint.h.

294 {
295 return add(y, y_words, sign == Positive ? Negative : Positive);
296 }

## ◆ swap()

void Botan::BigInt::swap | ( | BigInt & | other | ) |
| inline

Swap this value with another

Parameters

  other | BigInt to swap values with

Definition at line 167 of file bigint.h.

168 {
169 m_data.swap(other.m_data);
170 std::swap(m_signedness, other.m_signedness);
171 }

Referenced by Botan::PointGFp::add_affine(), botan_mp_swap(), Botan::PointGFp::mult2(), Botan::PointGFp::swap(), and std::swap< Botan::BigInt >().

## ◆ swap_reg()

void Botan::BigInt::swap_reg | ( | secure_vector< word > & | reg | ) |
| inline

Definition at line 173 of file bigint.h.

174 {
175 m_data.swap(reg);
176 // sign left unchanged
177 }

Referenced by mul(), reduce_below(), rev_sub(), and square().

## ◆ to_dec_string()

std::string Botan::BigInt::to_dec_string | ( |  | ) | const

Convert this value to a decimal string. Warning: decimal conversions are relatively slow

Definition at line 15 of file big_code.cpp.

16 {
17 BigInt copy = *this;
18 copy.set_sign(Positive);
19
20 uint8_t remainder;
21 std::vector<uint8_t> digits;
22
23 while(copy > 0)
24 {
25 ct_divide_u8(copy, 10, copy, remainder);
26 digits.push_back(remainder);
27 }
28
29 std::string s;
30
31 for(auto i = digits.rbegin(); i != digits.rend(); ++i)
32 {
33 s.push_back(Charset::digit2char(*i));
34 }
35
36 if(s.empty())
37 s += "0";
38
39 return s;
40 }
Botan::Charset::digit2char
char digit2char(uint8_t b)
Definition: charset.cpp:253
Botan::ct_divide_u8
void ct_divide_u8(const BigInt &x, uint8_t y, BigInt &q_out, uint8_t &r_out)
Definition: divide.cpp:82

References Botan::ct_divide_u8(), Botan::Charset::digit2char(), Positive, and set_sign().

Referenced by encode(), encode_locked(), and Botan::operator<<().

## ◆ to_hex_string()

std::string Botan::BigInt::to_hex_string | ( |  | ) | const

Convert this value to a hexadecimal string.

Definition at line 42 of file big_code.cpp.

43 {
44 const std::vector<uint8_t> bits = BigInt::encode(*this);
45 if(bits.empty())
46 return "00";
47 else
48 return hex_encode(bits);
49 }
Botan::hex_encode
void hex_encode(char output[], const uint8_t input[], size_t input_length, bool uppercase)
Definition: hex.cpp:31

References bits(), encode(), and Botan::hex_encode().

Referenced by botan_mp_to_hex(), encode(), encode_locked(), and Botan::operator<<().

## ◆ to_u32bit()

uint32_t Botan::BigInt::to_u32bit | ( |  | ) | const

Convert this value into a uint32_t, if it is in the range [0 ... 2**32-1], or otherwise throw an exception.

Returns
  the value as a uint32_t if conversion is possible

Definition at line 252 of file bigint.cpp.

253 {
254 if(is_negative())
255 throw Encoding_Error("BigInt::to_u32bit: Number is negative");
256 if(bits() > 32)
257 throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");
258
259 uint32_t out = 0;
260 for(size_t i = 0; i != 4; ++i)
261 out = (out << 8) | byte_at(3-i);
262 return out;
263 }
Botan::BigInt::byte_at
uint8_t byte_at(size_t n) const
Definition: bigint.cpp:117

References bits(), byte_at(), and is_negative().

Referenced by botan_mp_to_uint32().

## ◆ top_bits_free()

size_t Botan::BigInt::top_bits_free | ( |  | ) | const

Get the number of high bits unset in the top (allocated) word of this integer. Returns BOTAN_MP_WORD_BITS only iff *this is zero. Ignores sign.

Definition at line 294 of file bigint.cpp.

295 {
296 const size_t words = sig_words();
297
298 const word top_word = word_at(words - 1);
299 const size_t bits_used = high_bit(top_word);
300 CT::unpoison(bits_used);
301 return BOTAN_MP_WORD_BITS - bits_used;
302 }
Botan::high_bit
size_t high_bit(T n)
Definition: bit_ops.h:55

References Botan::high_bit(), sig_words(), Botan::CT::unpoison(), and word_at().

Referenced by bits(), operator<<=(), and Botan::vartime_divide().

## ◆ with_capacity()

BigInt Botan::BigInt::with_capacity | ( | size_t | n | ) |
| static

Create BigInt of specified size, all zeros

Parameters

  n | size of the internal register in words

Definition at line 49 of file bigint.cpp.

50 {
51 BigInt bn;
52 bn.grow_to(size);
53 return bn;
54 }

References grow_to(), and size().

Referenced by Botan::gcd().

## ◆ word_at()

word Botan::BigInt::word_at | ( | size_t | n | ) | const
| inline

Return the word at a specified position of the internal register

Parameters

  n | position in the register

Returns
  value at position n

Definition at line 514 of file bigint.h.

515 {
516 return m_data.get_word_at(n);
517 }

Referenced by binary_encode(), byte_at(), clear_bit(), conditionally_set_bit(), ct_cond_assign(), get_substring(), Botan::is_prime(), Botan::low_zero_bits(), Botan::Montgomery_Params::Montgomery_Params(), mul(), Botan::operator%(), operator%=(), Botan::operator*(), Botan::operator/(), operator/=(), Botan::redc_p521(), top_bits_free(), and Botan::vartime_divide().

The documentation for this class was generated from the following files:

- src/lib/math/bigint/bigint.h
- src/lib/math/bigint/big_code.cpp
- src/lib/math/bigint/big_ops2.cpp
- src/lib/math/bigint/big_ops3.cpp
- src/lib/math/bigint/big_rand.cpp
- src/lib/math/bigint/bigint.cpp