Botan 2.19.1
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
 
BigIntadd (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)
 
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)
 
BigIntmod_add (const BigInt &y, const BigInt &mod, secure_vector< word > &ws)
 
BigIntmod_mul (uint8_t y, const BigInt &mod, secure_vector< word > &ws)
 
BigIntmod_sub (const BigInt &y, const BigInt &mod, secure_vector< word > &ws)
 
BigIntmul (const BigInt &y, secure_vector< word > &ws)
 
word * mutable_data ()
 
bool operator! () const
 
BigIntoperator%= (const BigInt &y)
 
word operator%= (word y)
 
BigIntoperator*= (const BigInt &y)
 
BigIntoperator*= (word y)
 
BigIntoperator++ ()
 
BigInt operator++ (int)
 
BigIntoperator+= (const BigInt &y)
 
BigIntoperator+= (word y)
 
BigInt operator- () const
 
BigIntoperator-- ()
 
BigInt operator-- (int)
 
BigIntoperator-= (const BigInt &y)
 
BigIntoperator-= (word y)
 
BigIntoperator/= (const BigInt &y)
 
BigIntoperator<<= (size_t shift)
 
BigIntoperator= (BigInt &&other)
 
BigIntoperator= (const BigInt &)=default
 
BigIntoperator>>= (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)
 
BigIntrev_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
 
BigIntsquare (secure_vector< word > &ws)
 
BigIntsub (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)
 

Detailed Description

Arbitrary precision integer

Definition at line 24 of file bigint.h.

Member Enumeration Documentation

◆ 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 };
@ Hexadecimal
Definition: bigint.h:30

◆ 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 };

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
ninitial 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
otherthe 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
strthe string to parse for an integer value

Definition at line 51 of file bigint.cpp.

52 {
53 Base base = Decimal;
54 size_t markers = 0;
55 bool negative = false;
56
57 if(str.length() > 0 && str[0] == '-')
58 {
59 markers += 1;
60 negative = true;
61 }
62
63 if(str.length() > markers + 2 && str[markers ] == '0' &&
64 str[markers + 1] == 'x')
65 {
66 markers += 2;
67 base = Hexadecimal;
68 }
69
70 *this = decode(cast_char_ptr_to_uint8(str.data()) + markers,
71 str.length() - markers, base);
72
73 if(negative) set_sign(Negative);
74 else set_sign(Positive);
75 }
static BigInt decode(const uint8_t buf[], size_t length)
Definition: bigint.h:805
void set_sign(Sign sign)
Definition: bigint.h:563
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
bufthe byte array holding the value
lengthsize of buf

Definition at line 77 of file bigint.cpp.

78 {
79 binary_decode(input, length);
80 }
void binary_decode(const uint8_t buf[], size_t length)
Definition: bigint.cpp:432

References binary_decode().

◆ BigInt() [6/12]

template<typename Alloc >
Botan::BigInt::BigInt ( const std::vector< uint8_t, Alloc > &  vec)
inlineexplicit

Create a BigInt from an integer in a byte array

Parameters
vecthe byte vector holding the value

Definition at line 87 of file bigint.h.

87: BigInt(vec.data(), vec.size()) {}
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
bufthe byte array holding the value
lengthsize of buf
baseis the number base of the integer in buf

Definition at line 85 of file bigint.cpp.

86 {
87 *this = decode(input, length, base);
88 }

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
bufthe byte array holding the value
lengthsize of buf
max_bitsif the resulting integer is more than max_bits, it will be shifted so it is at most max_bits in length.

Definition at line 90 of file bigint.cpp.

91 {
92 if(8 * length > max_bits)
93 length = (max_bits + 7) / 8;
94
95 binary_decode(buf, length);
96
97 if(8 * length > max_bits)
98 *this >>= (8 - (max_bits % 8));
99 }

References binary_decode().

◆ BigInt() [9/12]

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

Create a BigInt from an array of words

Parameters
wordsthe words
lengthnumber 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
rngrandom number generator
bitssize in bits
set_high_bitif true, the highest bit is always set
See also
randomize

Definition at line 104 of file bigint.cpp.

105 {
106 randomize(rng, bits, set_high_bit);
107 }
void randomize(RandomNumberGenerator &rng, size_t bitsize, bool set_high_bit=true)
Definition: big_rand.cpp:17
size_t bits() const
Definition: bigint.cpp:296

References bits(), and randomize().

◆ BigInt() [11/12]

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

Create BigInt of specified size, all zeros

Parameters
signthe sign
nsize 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 }
size_t size() const
Definition: bigint.h:580

References size().

◆ BigInt() [12/12]

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

Move constructor

Definition at line 134 of file bigint.h.

135 {
136 this->swap(other);
137 }
void swap(BigInt &other)
Definition: bigint.h:161

◆ ~BigInt()

Botan::BigInt::~BigInt ( )
inline

Definition at line 139 of file bigint.h.

void const_time_unpoison() const
Definition: bigint.h:740

Member Function Documentation

◆ abs()

BigInt Botan::BigInt::abs ( ) const
Returns
absolute (positive) value of this

Definition at line 392 of file bigint.cpp.

393 {
394 BigInt x = (*this);
395 x.set_sign(Positive);
396 return x;
397 }

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)
45 }
46
47 return (*this);
48 }
size_t sig_words() const
Definition: bigint.h:586
word * mutable_data()
Definition: bigint.h:614
void grow_to(size_t n) const
Definition: bigint.h:636
const word * data() const
Definition: bigint.h:620
Sign sign() const
Definition: bigint.h:539
void bigint_sub2_rev(word x[], const word y[], size_t y_size)
Definition: mp_core.h:324
word bigint_sub2(word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:300
void bigint_add2(word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:280
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 }
void bigint_add3(word z[], const word x[], size_t x_size, const word y[], size_t y_size)
Definition: mp_core.h:289
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
bufthe vector to load from

Definition at line 692 of file bigint.h.

693 {
694 binary_decode(buf.data(), buf.size());
695 }

◆ 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
bufbyte array buffer containing the integer
lengthsize of buf

Definition at line 432 of file bigint.cpp.

433 {
434 clear();
435
436 const size_t full_words = length / sizeof(word);
437 const size_t extra_bytes = length % sizeof(word);
438
439 secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
440
441 for(size_t i = 0; i != full_words; ++i)
442 {
443 reg[i] = load_be<word>(buf + length - sizeof(word)*(i+1), 0);
444 }
445
446 if(extra_bytes > 0)
447 {
448 for(size_t i = 0; i != extra_bytes; ++i)
449 reg[full_words] = (reg[full_words] << 8) | buf[i];
450 }
451
452 m_data.swap(reg);
453 }
void clear()
Definition: bigint.h:366
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
bufdestination byte array for the integer value

Definition at line 399 of file bigint.cpp.

400 {
401 this->binary_encode(buf, bytes());
402 }
void binary_encode(uint8_t buf[]) const
Definition: bigint.cpp:399
size_t bytes() const
Definition: bigint.cpp:281

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
bufdestination byte array for the integer value
lenhow many bytes to write

Definition at line 407 of file bigint.cpp.

408 {
409 const size_t full_words = len / sizeof(word);
410 const size_t extra_bytes = len % sizeof(word);
411
412 for(size_t i = 0; i != full_words; ++i)
413 {
414 const word w = word_at(i);
415 store_be(w, output + (len - (i+1)*sizeof(word)));
416 }
417
418 if(extra_bytes > 0)
419 {
420 const word w = word_at(full_words);
421
422 for(size_t i = 0; i != extra_bytes; ++i)
423 {
424 output[extra_bytes - i - 1] = get_byte(sizeof(word) - i - 1, w);
425 }
426 }
427 }
word word_at(size_t n) const
Definition: bigint.h:508
void store_be(uint16_t in, uint8_t out[2])
Definition: loadstor.h:438
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

◆ byte_at()

uint8_t Botan::BigInt::byte_at ( size_t  n) const
Parameters
nthe offset to get a byte from
Returns
byte at offset n

Definition at line 109 of file bigint.cpp.

110 {
111 return get_byte(sizeof(word) - (n % sizeof(word)) - 1,
112 word_at(n / sizeof(word)));
113 }

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

◆ clear()

void Botan::BigInt::clear ( )
inline

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

Definition at line 366 of file bigint.h.

366{ 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
nbit position to clear

Definition at line 270 of file bigint.cpp.

271 {
272 const size_t which = n / BOTAN_MP_WORD_BITS;
273
274 if(which < size())
275 {
276 const word mask = ~(static_cast<word>(1) << (n % BOTAN_MP_WORD_BITS));
277 m_data.set_word_at(which, word_at(which) & mask);
278 }
279 }

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
nthe BigInt value to compare with
check_signsinclude 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 130 of file bigint.cpp.

131 {
132 if(check_signs)
133 {
134 if(other.is_positive() && this->is_negative())
135 return -1;
136
137 if(other.is_negative() && this->is_positive())
138 return 1;
139
140 if(other.is_negative() && this->is_negative())
141 return (-bigint_cmp(this->data(), this->size(),
142 other.data(), other.size()));
143 }
144
145 return bigint_cmp(this->data(), this->size(),
146 other.data(), other.size());
147 }

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
nthe 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 115 of file bigint.cpp.

116 {
117 if(is_negative())
118 return -1; // other is positive ...
119
120 const size_t sw = this->sig_words();
121 if(sw > 1)
122 return 1; // must be larger since other is just one word ...
123
124 return bigint_cmp(this->data(), sw, &other, 1);
125 }
bool is_negative() const
Definition: bigint.h:527

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 475 of file bigint.cpp.

476 {
477 // This code is assuming Negative == 0, Positive == 1
478
479 const auto mask = CT::Mask<uint8_t>::expand(predicate);
480
481 const uint8_t current_sign = static_cast<uint8_t>(sign());
482
483 const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);
484
485 set_sign(static_cast<Sign>(new_sign));
486 }
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
nbit position to set
set_itif the bit should be set

Definition at line 260 of file bigint.cpp.

261 {
262 const size_t which = n / BOTAN_MP_WORD_BITS;
263 const word mask = static_cast<word>(set_it) << (n % BOTAN_MP_WORD_BITS);
264 m_data.set_word_at(which, word_at(which) | mask);
265 }

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 523 of file bigint.cpp.

526 {
527 const size_t words = output.size();
528
529 clear_mem(output.data(), output.size());
530
531 CT::poison(&idx, sizeof(idx));
532
533 for(size_t i = 0; i != vec.size(); ++i)
534 {
535 BOTAN_ASSERT(vec[i].size() >= words,
536 "Word size as expected in const_time_lookup");
537
538 const auto mask = CT::Mask<word>::is_equal(i, idx);
539
540 for(size_t w = 0; w != words; ++w)
541 {
542 const word viw = vec[i].word_at(w);
543 output[w] = mask.if_set_return(viw);
544 }
545 }
546
547 CT::unpoison(idx);
548 CT::unpoison(output.data(), output.size());
549 }
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:55
static Mask< T > is_equal(T x, T y)
Definition: ct_utils.h:149
void poison(const T *p, size_t n)
Definition: ct_utils.h:48
void unpoison(const T *p, size_t n)
Definition: ct_utils.h:59
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 739 of file bigint.h.

739{}

Referenced by Botan::gcd().

◆ const_time_unpoison()

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

Definition at line 740 of file bigint.h.

740{}

Referenced by Botan::gcd().

◆ 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 455 of file bigint.cpp.

456 {
457 if(this->is_negative() || value.is_negative())
458 throw Invalid_Argument("BigInt::ct_cond_add requires both values to be positive");
459 this->grow_to(1 + value.sig_words());
460
461 bigint_cnd_add(static_cast<word>(predicate),
462 this->mutable_data(), this->size(),
463 value.data(), value.sig_words());
464 }
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::gcd(), and 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 488 of file bigint.cpp.

489 {
490 const size_t t_words = size();
491 const size_t o_words = other.size();
492
493 if(o_words < t_words)
494 grow_to(o_words);
495
496 const size_t r_words = std::max(t_words, o_words);
497
498 const auto mask = CT::Mask<word>::expand(predicate);
499
500 for(size_t i = 0; i != r_words; ++i)
501 {
502 const word o_word = other.word_at(i);
503 const word t_word = this->word_at(i);
504 this->set_word_at(i, mask.select(o_word, t_word));
505 }
506
507 const bool different_sign = sign() != other.sign();
508 cond_flip_sign(predicate && different_sign);
509 }
void set_word_at(size_t i, word w)
Definition: bigint.h:513
void cond_flip_sign(bool predicate)
Definition: bigint.cpp:475

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

Referenced by 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 466 of file bigint.cpp.

467 {
468 const size_t max_words = std::max(size(), other.size());
469 grow_to(max_words);
470 other.grow_to(max_words);
471
472 bigint_cnd_swap(predicate, this->mutable_data(), other.mutable_data(), max_words);
473 }
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(), Botan::ct_modulo(), and Botan::gcd().

◆ 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 366 of file bigint.cpp.

367 {
368 if(mod.is_negative() || this->is_negative())
369 throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");
370
371 const size_t mod_words = mod.sig_words();
372
373 grow_to(mod_words);
374
375 const size_t sz = size();
376
377 ws.resize(sz);
378
379 clear_mem(ws.data(), sz);
380
381 for(size_t i = 0; i != bound; ++i)
382 {
383 word borrow = bigint_sub3(ws.data(), data(), sz, mod.data(), mod_words);
384
385 CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), data(), sz);
386 }
387 }
static Mask< T > is_zero(T x)
Definition: ct_utils.h:141
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().

◆ data()

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

◆ decode() [1/4]

template<typename Alloc >
static BigInt Botan::BigInt::decode ( const std::vector< uint8_t, Alloc > &  buf)
inlinestatic

Create a BigInt from an integer in a byte array

Parameters
bufthe binary value to load
Returns
BigInt representing the integer in the byte array

Definition at line 816 of file bigint.h.

817 {
818 return BigInt(buf);
819 }

◆ decode() [2/4]

template<typename Alloc >
static BigInt Botan::BigInt::decode ( const std::vector< uint8_t, Alloc > &  buf,
Base  base 
)
inlinestatic

Create a BigInt from an integer in a byte array

Parameters
bufthe binary value to load
basenumber-base of the integer in buf
Returns
BigInt representing the integer in the byte array

Definition at line 878 of file bigint.h.

879 {
880 if(base == Binary)
881 return BigInt(buf);
882 return BigInt::decode(buf.data(), buf.size(), base);
883 }

References decode().

◆ decode() [3/4]

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

Create a BigInt from an integer in a byte array

Parameters
bufthe binary value to load
lengthsize of buf
Returns
BigInt representing the integer in the byte array

Definition at line 805 of file bigint.h.

806 {
807 return BigInt(buf, length);
808 }

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
bufthe binary value to load
lengthsize of buf
basenumber-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
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 }
bool is_digit(char c)
Definition: charset.cpp:210
bool is_space(char c)
Definition: charset.cpp:221
uint8_t char2digit(char c)
Definition: charset.cpp:231
secure_vector< uint8_t > hex_decode_locked(const char input[], size_t input_length, bool ignore_ws)
Definition: hex.cpp:168
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)
inlinestatic

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

Parameters
nthe BigInt to use as integer source
Returns
secure_vector of bytes containing the bytes of the integer

Definition at line 770 of file bigint.h.

771 {
772 std::vector<uint8_t> output(n.bytes());
773 n.binary_encode(output.data());
774 return output;
775 }

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
nthe BigInt to use as integer source
basenumber-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 }
static std::vector< uint8_t > encode(const BigInt &n)
Definition: bigint.h:770

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 
)
inlinestatic

Encode the integer value from a BigInt to a byte array

Parameters
bufdestination byte array for the encoded integer
nthe BigInt to use as integer source

Definition at line 794 of file bigint.h.

795 {
796 n.binary_encode(buf);
797 }

◆ 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
bufdestination byte array for the encoded integer value with given base
nthe BigInt to use as integer source
basenumber-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 }
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
nthe BigInt to encode
bytesthe 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
n1the first BigInt to encode
n2the second BigInt to encode
bytesthe 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)
inlinestatic

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

Parameters
nthe 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 secure_vector<uint8_t> output(n.bytes());
785 n.binary_encode(output.data());
786 return output;
787 }

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
nthe BigInt to use as integer source
basenumber-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 }
static secure_vector< uint8_t > encode_locked(const BigInt &n)
Definition: bigint.h:782

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 176 of file bigint.cpp.

177 {
178 const size_t words = sig_words();
179
180 if(words > size)
181 throw Encoding_Error("BigInt::encode_words value too large to encode");
182
183 clear_mem(out, size);
184 copy_mem(out, data(), words);
185 }

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
basethe 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 312 of file bigint.cpp.

313 {
314 static const double LOG_2_BASE_10 = 0.30102999566;
315
316 if(base == Binary)
317 return bytes();
318 else if(base == Hexadecimal)
319 return 2*bytes();
320 else if(base == Decimal)
321 return static_cast<size_t>((bits() * LOG_2_BASE_10) + 1);
322 else
323 throw Invalid_Argument("Unknown base for BigInt encoding");
324 }

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

◆ flip_sign()

void Botan::BigInt::flip_sign ( )
inline

Flip the sign of this BigInt

Definition at line 554 of file bigint.h.

555 {
557 }
Sign reverse_sign() const
Definition: bigint.h:544

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
nthe bit offset to test
Returns
true, if the bit at position n is set, false otherwise

Definition at line 465 of file bigint.h.

466 {
467 return ((word_at(n / BOTAN_MP_WORD_BITS) >> (n % BOTAN_MP_WORD_BITS)) & 1);
468 }

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
offsetthe offset to start extracting
lengthamount of bits to extract (starting at offset)
Returns
the integer extracted from the register starting at offset with specified length

Definition at line 213 of file bigint.cpp.

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

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 625 of file bigint.h.

625{ 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 630 of file bigint.h.

630{ return m_data.const_vector(); }

◆ grow_to()

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

◆ is_equal()

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

Compare this to another BigInt

Parameters
nthe BigInt value to compare with
Returns
true if this == n or false otherwise

Definition at line 149 of file bigint.cpp.

150 {
151 if(this->sign() != other.sign())
152 return false;
153
154 return bigint_ct_is_eq(this->data(), this->sig_words(),
155 other.data(), other.sig_words()).is_set();
156 }
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 403 of file bigint.h.

403{ return (get_bit(0) == 0); }
bool get_bit(size_t n) const
Definition: bigint.h:465

Referenced by Botan::almost_montgomery_inverse(), botan_mp_is_even(), Botan::gcd(), 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
nthe BigInt value to compare with
Returns
true if this < n or false otherwise

Definition at line 158 of file bigint.cpp.

159 {
160 if(this->is_negative() && other.is_positive())
161 return true;
162
163 if(this->is_positive() && other.is_negative())
164 return false;
165
166 if(other.is_negative() && this->is_negative())
167 {
168 return bigint_ct_is_lt(other.data(), other.sig_words(),
169 this->data(), this->sig_words()).is_set();
170 }
171
172 return bigint_ct_is_lt(this->data(), this->sig_words(),
173 other.data(), other.sig_words()).is_set();
174 }
bool is_positive() const
Definition: bigint.h:533
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

◆ 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 415 of file bigint.h.

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

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 409 of file bigint.h.

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

Referenced by botan_mp_is_odd(), Botan::gcd(), 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 533 of file bigint.h.

533{ 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

◆ mask_bits()

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

Clear all but the lowest n bits

Parameters
namount of bits to keep

Definition at line 455 of file bigint.h.

456 {
457 m_data.mask_bits(n);
458 }

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
ythe BigInt to add - assumed y >= 0 and y < mod
modthe positive modulus
wsa 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 }
#define BOTAN_DEBUG_ASSERT(expr)
Definition: assert.h:123
#define BOTAN_ARG_CHECK(expr, msg)
Definition: assert.h:37
void set_words(const word w[], size_t len)
Definition: bigint.h:518
Mask< T > conditional_copy_mem(T cnd, T *to, const T *from0, const T *from1, size_t elems)
Definition: ct_utils.h:363
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
ythe small integer to multiply by
modthe positive modulus
wsa 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 }
size_t reduce_below(const BigInt &mod, secure_vector< word > &ws)
Definition: bigint.cpp:336

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
ythe BigInt to subtract - assumed y >= 0 and y < mod
modthe positive modulus
wsa 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 }
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
ythe BigInt to multiply with this
wsa 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();
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 }
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:167
void bigint_linmul3(word z[], const word x[], size_t x_size, word y)
Definition: mp_core.h:504
word BOTAN_WARN_UNUSED_RESULT bigint_linmul2(word x[], size_t x_size, word y)
Definition: mp_core.h:489
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
void carry(int64_t &h0, int64_t &h1)

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

◆ operator!()

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

! operator

Returns
true iff this is zero, otherwise false

Definition at line 281 of file bigint.h.

281{ return (!is_nonzero()); }
bool is_nonzero() const
Definition: bigint.h:415

◆ operator%=() [1/2]

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

Modulo operator

Parameters
ythe 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
ythe 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);
275 return remainder;
276 }
word bigint_modop(word n1, word n0, word d)
Definition: mp_core.h:755
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
ythe 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 }
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
ythe word to multiply with this

Definition at line 214 of file big_ops2.cpp.

215 {
216 if(y == 0)
217 {
218 clear();
220 }
221
222 const word carry = bigint_linmul2(mutable_data(), size(), y);
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 254 of file bigint.h.

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

◆ operator++() [2/2]

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

Postfix increment operator

Definition at line 264 of file bigint.h.

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

◆ operator+=() [1/2]

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

+= operator

Parameters
ythe BigInt to add to this

Definition at line 177 of file bigint.h.

178 {
179 return add(y.data(), y.sig_words(), y.sign());
180 }
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
ythe word to add to this

Definition at line 186 of file bigint.h.

187 {
188 return add(&y, 1, Positive);
189 }

◆ operator-()

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

Unary negation operator

Returns
negative this

Definition at line 329 of file bigint.cpp.

330 {
331 BigInt x = (*this);
332 x.flip_sign();
333 return x;
334 }

References flip_sign().

◆ operator--() [1/2]

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

Decrement operator

Definition at line 259 of file bigint.h.

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

◆ operator--() [2/2]

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

Postfix decrement operator

Definition at line 269 of file bigint.h.

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

◆ operator-=() [1/2]

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

-= operator

Parameters
ythe BigInt to subtract from this

Definition at line 195 of file bigint.h.

196 {
197 return sub(y.data(), y.sig_words(), y.sign());
198 }
BigInt & sub(const word y[], size_t y_words, Sign sign)
Definition: bigint.h:287

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

◆ operator-=() [2/2]

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

-= operator

Parameters
ythe word to subtract from this

Definition at line 204 of file bigint.h.

205 {
206 return sub(&y, 1, Positive);
207 }

◆ operator/=()

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

/= operator

Parameters
ythe 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
shiftthe 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 }
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 144 of file bigint.h.

145 {
146 if(this != &other)
147 this->swap(other);
148
149 return (*this);
150 }

◆ operator=() [2/2]

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

Copy assignment

◆ operator>>=()

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

Right shift operator

Parameters
shiftthe 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())
310
311 return (*this);
312 }
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)
inlinestatic

Create a power of two

Parameters
nthe power of two to create
Returns
bigint representing 2^n

Definition at line 758 of file bigint.h.

759 {
760 BigInt b;
761 b.set_bit(n);
762 return b;
763 }

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
rnga random number generator
minthe minimum value (must be non-negative)
maxthe 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
rngthe random number generator to use
bitsizenumber of bits the created random value should have
set_high_bitif true, the highest bit is always set

Definition at line 17 of file big_rand.cpp.

19 {
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 336 of file bigint.cpp.

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

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 647 of file bigint.h.

647{ m_data.resize(s); }

Referenced by 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
ythe BigInt to subtract from as a sequence of words
y_wordslength of y in words
wsa 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 544 of file bigint.h.

545 {
546 if(sign() == Positive)
547 return Negative;
548 return Positive;
549 }

Referenced by Botan::operator-().

◆ set_bit()

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

Set bit at specified position

Parameters
nbit position to set

Definition at line 430 of file bigint.h.

431 {
432 conditionally_set_bit(n, true);
433 }
void conditionally_set_bit(size_t n, bool set_it)
Definition: bigint.cpp:260

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
signnew Sign to set

Definition at line 563 of file bigint.h.

564 {
565 if(sign == Negative && is_zero())
566 sign = Positive;
567
568 m_signedness = sign;
569 }

Referenced by abs(), add(), add2(), BigInt(), cond_flip_sign(), Botan::gcd(), 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 513 of file bigint.h.

514 {
515 m_data.set_word_at(i, w);
516 }

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 518 of file bigint.h.

519 {
520 m_data.set_words(w, len);
521 }

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 642 of file bigint.h.

643 {
644 m_data.shrink_to_fit(min_size);
645 }

◆ sig_words()

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

◆ sign()

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

Return the sign of the integer

Returns
the sign of the integer

Definition at line 539 of file bigint.h.

539{ 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

◆ square()

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

Square value of *this

Parameters
wsa 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);
210
211 return (*this);
212 }
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 287 of file bigint.h.

288 {
289 return add(y, y_words, sign == Positive ? Negative : Positive);
290 }

◆ swap()

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

Swap this value with another

Parameters
otherBigInt to swap values with

Definition at line 161 of file bigint.h.

162 {
163 m_data.swap(other.m_data);
164 std::swap(m_signedness, other.m_signedness);
165 }

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 167 of file bigint.h.

168 {
169 m_data.swap(reg);
170 // sign left unchanged
171 }

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 }
char digit2char(uint8_t b)
Definition: charset.cpp:253
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 }
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 244 of file bigint.cpp.

245 {
246 if(is_negative())
247 throw Encoding_Error("BigInt::to_u32bit: Number is negative");
248 if(bits() > 32)
249 throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");
250
251 uint32_t out = 0;
252 for(size_t i = 0; i != 4; ++i)
253 out = (out << 8) | byte_at(3-i);
254 return out;
255 }
uint8_t byte_at(size_t n) const
Definition: bigint.cpp:109

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 286 of file bigint.cpp.

287 {
288 const size_t words = sig_words();
289
290 const word top_word = word_at(words - 1);
291 const size_t bits_used = high_bit(top_word);
292 CT::unpoison(bits_used);
293 return BOTAN_MP_WORD_BITS - bits_used;
294 }
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().

◆ word_at()

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

Return the word at a specified position of the internal register

Parameters
nposition in the register
Returns
value at position n

Definition at line 508 of file bigint.h.

509 {
510 return m_data.get_word_at(n);
511 }

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: