Botan 2.13.0 Crypto and TLS for C++11

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

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 (uint64_t n)
| BigInt (const BigInt &other)=default
| BigInt (const std::string &str)
| BigInt (const uint8_t buf[], size_t length)
template<typename Alloc >
| BigInt (const std::vector< uint8_t, Alloc > &vec)
| 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 (BigInt &&other)
void | binary_decode (const uint8_t buf[], size_t length)
template<typename Alloc >
void | binary_decode (const std::vector< uint8_t, Alloc > &buf)
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_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)
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

## 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)
static BigInt | decode (const uint8_t buf[], size_t length)
template<typename Alloc >
static BigInt | decode (const std::vector< uint8_t, Alloc > &buf)
static BigInt | decode (const uint8_t buf[], size_t length, Base base)
template<typename Alloc >
static BigInt | decode (const std::vector< uint8_t, Alloc > &buf, Base base)
static std::vector< uint8_t > | encode (const BigInt &n)
static void | encode (uint8_t buf[], const BigInt &n)
static std::vector< uint8_t > | encode (const BigInt &n, Base base)
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

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::Hexadecimal
Definition: bigint.h:30
Botan::BigInt::Decimal
Definition: bigint.h:30
Botan::BigInt::Binary
Definition: bigint.h:30

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
Definition: bigint.h:35
Botan::BigInt::Negative
Definition: bigint.h:35

## Constructor & Destructor Documentation

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

Create empty BigInt

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 }

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

Copy Constructor

Parameters

  other | the BigInt to copy

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

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

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 }
Botan::BigInt::Hexadecimal
Definition: bigint.h:30
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::Decimal
Definition: bigint.h:30
Botan::cast_char_ptr_to_uint8
const uint8_t * cast_char_ptr_to_uint8(const char *s)
Definition: mem_ops.h:189
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::BigInt::Base
Base
Definition: bigint.h:30
Botan::BigInt::decode
static BigInt decode(const uint8_t buf[], size_t length)
Definition: bigint.h:798
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561

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

References binary_decode().

78 {
79 binary_decode(input, length);
80 }
Botan::BigInt::binary_decode
void binary_decode(const uint8_t buf[], size_t length)
Definition: bigint.cpp:424
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 87 of file bigint.h.

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

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

References decode().

86 {
87 *this = decode(input, length, base);
88 }
Botan::BigInt::decode
static BigInt decode(const uint8_t buf[], size_t length)
Definition: bigint.h:798

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

References binary_decode(), and bits().

91 {
92 const size_t max_bytes = std::min(length, (max_bits + 7) / 8);
93 binary_decode(buf, max_bytes);
94
95 const size_t b = this->bits();
96 if(b > max_bits)
97 {
98 *this >>= (b - max_bits);
99 }
100 }
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:288
Botan::BigInt::binary_decode
void binary_decode(const uint8_t buf[], size_t length)
Definition: bigint.cpp:424

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 }

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

References randomize().

106 {
107 randomize(rng, bits, set_high_bit);
108 }
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:288

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:578

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

Move constructor

Definition at line 134 of file bigint.h.

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

## Member Function Documentation

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

Returns
  absolute (positive) value of this

Definition at line 384 of file bigint.cpp.

References Positive, and set_sign().

Referenced by Botan::abs().

385 {
386 BigInt x = (*this);
387 x.set_sign(Positive);
388 return x;
389 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::BigInt
BigInt()=default

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

Definition at line 15 of file big_ops2.cpp.

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().

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_sub2_rev
void bigint_sub2_rev(word x[], const word y[], size_t y_size)
Definition: mp_core.h:324
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::Positive
Definition: bigint.h:35
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:523
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::mutable_data
word * mutable_data()
Definition: bigint.h:612
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
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::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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.

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

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

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::Positive
Definition: bigint.h:35
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
Botan::BigInt::BigInt
BigInt()=default
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

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

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().

425 {
426 clear();
427
428 const size_t full_words = length / sizeof(word);
429 const size_t extra_bytes = length % sizeof(word);
430
431 secure_vector<word> reg((round_up(full_words + (extra_bytes > 0 ? 1 : 0), 8)));
432
433 for(size_t i = 0; i != full_words; ++i)
434 {
435 reg[i] = load_be<word>(buf + length - sizeof(word)*(i+1), 0);
436 }
437
438 if(extra_bytes > 0)
439 {
440 for(size_t i = 0; i != extra_bytes; ++i)
441 reg[full_words] = (reg[full_words] << 8) | buf[i];
442 }
443
444 m_data.swap(reg);
445 }
Botan::BigInt::clear
void clear()
Definition: bigint.h:364
Botan::round_up
size_t round_up(size_t n, size_t align_to)
Definition: rounding.h:21
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 690 of file bigint.h.

691 {
692 binary_decode(buf.data(), buf.size());
693 }
Botan::BigInt::binary_decode
void binary_decode(const uint8_t buf[], size_t length)
Definition: bigint.cpp:424

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

References bytes().

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

392 {
393 this->binary_encode(buf, bytes());
394 }
Botan::BigInt::binary_encode
void binary_encode(uint8_t buf[]) const
Definition: bigint.cpp:391
Botan::BigInt::bytes
size_t bytes() const
Definition: bigint.cpp:273

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

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

400 {
401 const size_t full_words = len / sizeof(word);
402 const size_t extra_bytes = len % sizeof(word);
403
404 for(size_t i = 0; i != full_words; ++i)
405 {
406 const word w = word_at(i);
407 store_be(w, output + (len - (i+1)*sizeof(word)));
408 }
409
410 if(extra_bytes > 0)
411 {
412 const word w = word_at(full_words);
413
414 for(size_t i = 0; i != extra_bytes; ++i)
415 {
416 output[extra_bytes - i - 1] = get_byte(sizeof(word) - i - 1, w);
417 }
418 }
419 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
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

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

Get the bit length of the integer

Returns
  bit length of the represented integer value

Definition at line 288 of file bigint.cpp.

References sig_words(), and top_bits_free().

Referenced by BigInt(), botan_mp_num_bits(), bytes(), Botan::ct_divide(), Botan::ct_divide_u8(), Botan::ct_inverse_mod_odd_modulus(), 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::gcd(), Botan::generate_dsa_primes(), Botan::generate_rsa_prime(), Botan::generate_srp6_verifier(), 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*(), Botan::operator/(), operator/=(), Botan::passes_miller_rabin_test(), Botan::PointGFp_Base_Point_Precompute::PointGFp_Base_Point_Precompute(), Botan::PointGFp_Var_Point_Precompute::PointGFp_Var_Point_Precompute(), 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().

289 {
290 const size_t words = sig_words();
291
292 if(words == 0)
293 return 0;
294
295 const size_t full_words = (words - 1) * BOTAN_MP_WORD_BITS;
296 const size_t top_bits = BOTAN_MP_WORD_BITS - top_bits_free();
297
298 return full_words + top_bits;
299 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::top_bits_free
size_t top_bits_free() const
Definition: bigint.cpp:278

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

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

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

111 {
112 return get_byte(sizeof(word) - (n % sizeof(word)) - 1,
113 word_at(n / sizeof(word)));
114 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
Botan::get_byte
constexpr uint8_t get_byte(size_t byte_num, T input)
Definition: loadstor.h:41

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

Give byte length of the integer

Returns
  byte length of the represented integer value

Definition at line 273 of file bigint.cpp.

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

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

274 {
275 return round_up(bits(), 8) / 8;
276 }
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:288
Botan::round_up
size_t round_up(size_t n, size_t align_to)
Definition: rounding.h:21

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

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

Definition at line 364 of file bigint.h.

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

364 { m_data.set_to_zero(); m_signedness = Positive; }
Botan::BigInt::Positive
Definition: bigint.h:35

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

Clear bit at specified position

Parameters

  n | bit position to clear

Definition at line 262 of file bigint.cpp.

References size(), and word_at().

Referenced by botan_mp_clear_bit().

263 {
264 const size_t which = n / BOTAN_MP_WORD_BITS;
265
266 if(which < size())
267 {
268 const word mask = ~(static_cast<word>(1) << (n % BOTAN_MP_WORD_BITS));
269 m_data.set_word_at(which, word_at(which) & mask);
270 }
271 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578

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

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

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

132 {
133 if(check_signs)
134 {
135 if(other.is_positive() && this->is_negative())
136 return -1;
137
138 if(other.is_negative() && this->is_positive())
139 return 1;
140
141 if(other.is_negative() && this->is_negative())
142 return (-bigint_cmp(this->data(), this->size(),
143 other.data(), other.size()));
144 }
145
146 return bigint_cmp(this->data(), this->size(),
147 other.data(), other.size());
148 }
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:523
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::is_positive
bool is_positive() const
Definition: bigint.h:531

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

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>=().

117 {
118 if(is_negative())
119 return -1; // other is positive ...
120
121 const size_t sw = this->sig_words();
122 if(sw > 1)
123 return 1; // must be larger since other is just one word ...
124
125 return bigint_cmp(this->data(), sw, &other, 1);
126 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
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:523
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618

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

If predicate is true flip the sign of *this

Definition at line 456 of file bigint.cpp.

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

Referenced by ct_cond_assign(), Botan::inverse_euclid(), and rev_sub().

457 {
458 // This code is assuming Negative == 0, Positive == 1
459
460 const auto mask = CT::Mask<uint8_t>::expand(predicate);
461
462 const uint8_t current_sign = static_cast<uint8_t>(sign());
463
464 const uint8_t new_sign = mask.select(current_sign ^ 1, current_sign);
465
466 set_sign(static_cast<Sign>(new_sign));
467 }
Botan::CT::Mask::expand
static Mask< T > expand(T v)
Definition: ct_utils.h:123
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

References word_at().

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

253 {
254 const size_t which = n / BOTAN_MP_WORD_BITS;
255 const word mask = static_cast<word>(set_it) << (n % BOTAN_MP_WORD_BITS);
256 m_data.set_word_at(which, word_at(which) | mask);
257 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506

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

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

509 {
510 const size_t words = output.size();
511
512 clear_mem(output.data(), output.size());
513
514 CT::poison(&idx, sizeof(idx));
515
516 for(size_t i = 0; i != vec.size(); ++i)
517 {
518 BOTAN_ASSERT(vec[i].size() >= words,
519 "Word size as expected in const_time_lookup");
520
521 const auto mask = CT::Mask<word>::is_equal(i, idx);
522
523 for(size_t w = 0; w != words; ++w)
524 {
525 const word viw = vec[i].word_at(w);
526 output[w] = mask.if_set_return(viw);
527 }
528 }
529
530 CT::unpoison(idx);
531 CT::unpoison(output.data(), output.size());
532 }
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:112
Botan::CT::poison
void poison(const T *p, size_t n)
Definition: ct_utils.h:48
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
BOTAN_ASSERT
#define BOTAN_ASSERT(expr, assertion_made)
Definition: assert.h:55
Botan::CT::unpoison
void unpoison(const T *p, size_t n)
Definition: ct_utils.h:59
Botan::CT::Mask::is_equal
static Mask< T > is_equal(T x, T y)
Definition: ct_utils.h:149

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

Definition at line 732 of file bigint.h.

732 {}

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

Definition at line 733 of file bigint.h.

733 {}

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

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

Referenced by Botan::gcd(), Botan::inverse_euclid(), Botan::is_lucas_probable_prime(), and Botan::power_mod().

470 {
471 const size_t t_words = size();
472 const size_t o_words = other.size();
473
474 if(o_words < t_words)
475 grow_to(o_words);
476
477 const size_t r_words = std::max(t_words, o_words);
478
479 const auto mask = CT::Mask<word>::expand(predicate);
480
481 for(size_t i = 0; i != r_words; ++i)
482 {
483 const word o_word = other.word_at(i);
484 const word t_word = this->word_at(i);
485 this->set_word_at(i, mask.select(o_word, t_word));
486 }
487
488 if(sign() != other.sign())
489 {
490 cond_flip_sign(predicate);
491 }
492 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::CT::Mask::expand
static Mask< T > expand(T v)
Definition: ct_utils.h:123
Botan::BigInt::cond_flip_sign
void cond_flip_sign(bool predicate)
Definition: bigint.cpp:456
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634
Botan::BigInt::set_word_at
void set_word_at(size_t i, word w)
Definition: bigint.h:511
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

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

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

448 {
449 const size_t max_words = std::max(size(), other.size());
450 grow_to(max_words);
451 other.grow_to(max_words);
452
453 bigint_cnd_swap(predicate, this->mutable_data(), other.mutable_data(), max_words);
454 }
Botan::BigInt::mutable_data
word * mutable_data()
Definition: bigint.h:612
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::bigint_cnd_swap
void bigint_cnd_swap(word cnd, word x[], word y[], size_t size)
Definition: mp_core.h:29
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634

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

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().

359 {
360 if(mod.is_negative() || this->is_negative())
361 throw Invalid_Argument("BigInt::ct_reduce_below both values must be positive");
362
363 const size_t mod_words = mod.sig_words();
364
365 grow_to(mod_words);
366
367 const size_t sz = size();
368
369 ws.resize(sz);
370
371 clear_mem(ws.data(), sz);
372
373 for(size_t i = 0; i != bound; ++i)
374 {
375 word borrow = bigint_sub3(ws.data(), data(), sz, mod.data(), mod_words);
376
377 CT::Mask<word>::is_zero(borrow).select_n(mutable_data(), ws.data(), data(), sz);
378 }
379 }
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:112
Botan::BigInt::mutable_data
word * mutable_data()
Definition: bigint.h:612
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
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
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634
Botan::CT::Mask::is_zero
static Mask< T > is_zero(T x)
Definition: ct_utils.h:141

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

Referenced by Botan::PointGFp::add(), add(), add2(), Botan::PointGFp::add_affine(), cmp(), cmp_word(), Botan::ct_divide(), Botan::ct_inverse_mod_odd_modulus(), Botan::ct_modulo(), ct_reduce_below(), Botan::CurveGFp_Repr::curve_mul(), Botan::CurveGFp_Repr::curve_sqr(), encode_words(), Botan::FPE::fe1_decrypt(), Botan::FPE::fe1_encrypt(), 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().

618 { return m_data.const_data(); }

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

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().

799 {
800 return BigInt(buf, length);
801 }
Botan::BigInt::BigInt
BigInt()=default
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 809 of file bigint.h.

810 {
811 return BigInt(buf);
812 }
Botan::BigInt::BigInt
BigInt()=default

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.

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().

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::BigInt::Hexadecimal
Definition: bigint.h:30
Botan::BigInt::Decimal
Definition: bigint.h:30
Botan::hex_decode_locked
secure_vector< uint8_t > hex_decode_locked(const char input[], size_t input_length, bool ignore_ws)
Definition: hex.cpp:165
Botan::Charset::char2digit
uint8_t char2digit(char c)
Definition: charset.cpp:231
Botan::Charset::is_space
bool is_space(char c)
Definition: charset.cpp:221
Botan::BigInt::Binary
Definition: bigint.h:30
Botan::cast_uint8_ptr_to_char
const char * cast_uint8_ptr_to_char(const uint8_t *b)
Definition: mem_ops.h:194
Botan::Charset::is_digit
bool is_digit(char c)
Definition: charset.cpp:210
Botan::BigInt::BigInt
BigInt()=default
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 871 of file bigint.h.

References decode().

872 {
873 if(base == Binary)
874 return BigInt(buf);
875 return BigInt::decode(buf.data(), buf.size(), base);
876 }
Botan::BigInt::Binary
Definition: bigint.h:30
Botan::BigInt::decode
static BigInt decode(const uint8_t buf[], size_t length)
Definition: bigint.h:798
Botan::BigInt::BigInt
BigInt()=default

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

References binary_encode(), and bytes().

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

764 {
765 std::vector<uint8_t> output(n.bytes());
766 n.binary_encode(output.data());
767 return output;
768 }

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

788 {
789 n.binary_encode(buf);
790 }

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.

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

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::Hexadecimal
Definition: bigint.h:30
Botan::BigInt::Decimal
Definition: bigint.h:30
Botan::BigInt::encode
static std::vector< uint8_t > encode(const BigInt &n)
Definition: bigint.h:763
Botan::BigInt::Binary
Definition: bigint.h:30

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.

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

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:132

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.

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().

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 }
Botan::BigInt::bytes
size_t bytes() const
Definition: bigint.cpp:273

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

Definition at line 122 of file big_code.cpp.

References binary_encode(), and bytes().

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 }
Botan::BigInt::bytes
size_t bytes() const
Definition: bigint.cpp:273

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.

References binary_encode(), and bytes().

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 }
Botan::BigInt::bytes
size_t bytes() const
Definition: bigint.cpp:273

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

References binary_encode(), and bytes().

Referenced by encode(), and encode_locked().

776 {
777 secure_vector<uint8_t> output(n.bytes());
778 n.binary_encode(output.data());
779 return output;
780 }

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.

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

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::Hexadecimal
Definition: bigint.h:30
Botan::BigInt::Decimal
Definition: bigint.h:30
Botan::BigInt::encode_locked
static secure_vector< uint8_t > encode_locked(const BigInt &n)
Definition: bigint.h:775
Botan::BigInt::Binary
Definition: bigint.h:30

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

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

178 {
179 const size_t words = sig_words();
180
181 if(words > size)
182 throw Encoding_Error("BigInt::encode_words value too large to encode");
183
184 clear_mem(out, size);
185 copy_mem(out, data(), words);
186 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:112
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::copy_mem
void copy_mem(T *out, const T *in, size_t n)
Definition: mem_ops.h:132

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

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

305 {
306 static const double LOG_2_BASE_10 = 0.30102999566;
307
308 if(base == Binary)
309 return bytes();
310 else if(base == Hexadecimal)
311 return 2*bytes();
312 else if(base == Decimal)
313 return static_cast<size_t>((bits() * LOG_2_BASE_10) + 1);
314 else
315 throw Invalid_Argument("Unknown base for BigInt encoding");
316 }
Botan::BigInt::Hexadecimal
Definition: bigint.h:30
Botan::BigInt::Decimal
Definition: bigint.h:30
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:288
Botan::BigInt::Binary
Definition: bigint.h:30
Botan::BigInt::bytes
size_t bytes() const
Definition: bigint.cpp:273

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

Flip the sign of this BigInt

Definition at line 552 of file bigint.h.

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

553 {
554 set_sign(reverse_sign());
555 }
Botan::BigInt::reverse_sign
Sign reverse_sign() const
Definition: bigint.h:542
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561

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

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().

464 {
465 return ((word_at(n / BOTAN_MP_WORD_BITS) >> (n % BOTAN_MP_WORD_BITS)) & 1);
466 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506

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

References byte_at(), and Botan::make_uint64().

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().

215 {
216 if(length == 0 || length > 32)
217 throw Invalid_Argument("BigInt::get_substring invalid substring length");
218
219 const size_t byte_offset = offset / 8;
220 const size_t shift = (offset % 8);
221 const uint32_t mask = 0xFFFFFFFF >> (32 - length);
222
223 const uint8_t b0 = byte_at(byte_offset);
224 const uint8_t b1 = byte_at(byte_offset + 1);
225 const uint8_t b2 = byte_at(byte_offset + 2);
226 const uint8_t b3 = byte_at(byte_offset + 3);
227 const uint8_t b4 = byte_at(byte_offset + 4);
228 const uint64_t piece = make_uint64(0, 0, 0, b4, b3, b2, b1, b0);
229
230 return static_cast<uint32_t>((piece >> shift) & mask);
231 }
Botan::make_uint64
constexpr uint64_t make_uint64(uint8_t i0, uint8_t i1, uint8_t i2, uint8_t i3, uint8_t i4, uint8_t i5, uint8_t i6, uint8_t i7)
Definition: loadstor.h:87
Botan::BigInt::byte_at
uint8_t byte_at(size_t n) const
Definition: bigint.cpp:110

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

Don't use this function in application code

Definition at line 623 of file bigint.h.

Referenced by Botan::PointGFp::add_affine(), Botan::ct_inverse_mod_odd_modulus(), Botan::Montgomery_Int::fix_size(), and Botan::PointGFp_Var_Point_Precompute::PointGFp_Var_Point_Precompute().

623 { return m_data.mutable_vector(); }

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

Don't use this function in application code

Definition at line 628 of file bigint.h.

628 { return m_data.const_vector(); }

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

Referenced by add(), ct_cond_assign(), ct_cond_swap(), Botan::ct_inverse_mod_odd_modulus(), ct_reduce_below(), Botan::divide(), mod_add(), mod_sub(), mul(), Botan::Montgomery_Params::mul_by(), Botan::Montgomery_Params::redc(), Botan::redc_p521(), reduce_below(), and Botan::Montgomery_Params::square_this().

634 { m_data.grow_to(n); }

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

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

Referenced by Botan::operator!=().

151 {
152 if(this->sign() != other.sign())
153 return false;
154
155 return bigint_ct_is_eq(this->data(), this->sig_words(),
156 other.data(), other.sig_words()).is_set();
157 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
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:611
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

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

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

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

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

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

160 {
161 if(this->is_negative() && other.is_positive())
162 return true;
163
164 if(this->is_positive() && other.is_negative())
165 return false;
166
167 if(other.is_negative() && this->is_negative())
168 {
169 return !bigint_ct_is_lt(other.data(), other.sig_words(),
170 this->data(), this->sig_words(), true).is_set();
171 }
172
173 return bigint_ct_is_lt(this->data(), this->sig_words(),
174 other.data(), other.sig_words()).is_set();
175 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
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:574
Botan::BigInt::is_positive
bool is_positive() const
Definition: bigint.h:531

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

Referenced by botan_mp_is_negative(), cmp(), cmp_word(), Botan::ct_divide_u8(), Botan::ct_inverse_mod_odd_modulus(), Botan::ct_modulo(), ct_reduce_below(), Botan::BER_Decoder::decode(), Botan::divide(), Botan::inverse_euclid(), 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(), and to_u32bit().

525 { return (sign() == Negative); }
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

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

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

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

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

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

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

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

531 { return (sign() == Positive); }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

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

420 {
421 return (sig_words() == 0);
422 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584

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

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

454 {
455 m_data.mask_bits(n);
456 }

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.

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+().

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::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
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
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
BOTAN_DEBUG_ASSERT
#define BOTAN_DEBUG_ASSERT(expr)
Definition: assert.h:123
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::set_words
void set_words(const word w[], size_t len)
Definition: bigint.h:516
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:339
BOTAN_ARG_CHECK
#define BOTAN_ARG_CHECK(expr, msg)
Definition: assert.h:37
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634

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 139 of file big_ops2.cpp.

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().

140 {
141 BOTAN_ARG_CHECK(this->is_negative() == false, "*this must be positive");
142 BOTAN_ARG_CHECK(y < 16, "y too large");
143
144 BOTAN_DEBUG_ASSERT(*this < mod);
145
146 *this *= static_cast<word>(y);
147 this->reduce_below(mod, ws);
148 return (*this);
149 }
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
BOTAN_DEBUG_ASSERT
#define BOTAN_DEBUG_ASSERT(expr)
Definition: assert.h:123
BOTAN_ARG_CHECK
#define BOTAN_ARG_CHECK(expr, msg)
Definition: assert.h:37
Botan::BigInt::reduce_below
size_t reduce_below(const BigInt &mod, secure_vector< word > &ws)
Definition: bigint.cpp:328

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.

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

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

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 0
111 //Faster but not const time:
112
113 // Compute t - s
114 word borrow = bigint_sub3(ws.data(), data(), mod_sw, s.data(), mod_sw);
115
116 if(borrow)
117 {
118 // If t < s, instead compute p - (s - t)
119 bigint_sub2_rev(mutable_data(), s.data(), mod_sw);
120 bigint_sub2_rev(mutable_data(), mod.data(), mod_sw);
121 }
122 else
123 {
124 // No borrow so we already have the result we need
125 swap_reg(ws);
126 }
127 #else
128 if(mod_sw == 4)
129 bigint_mod_sub_n<4>(mutable_data(), s.data(), mod.data(), ws.data());
130 else if(mod_sw == 6)
131 bigint_mod_sub_n<6>(mutable_data(), s.data(), mod.data(), ws.data());
132 else
133 bigint_mod_sub(mutable_data(), s.data(), mod.data(), mod_sw, ws.data());
134 #endif
135
136 return (*this);
137 }
Botan::bigint_sub2_rev
void bigint_sub2_rev(word x[], const word y[], size_t y_size)
Definition: mp_core.h:324
Botan::BigInt::mutable_data
word * mutable_data()
Definition: bigint.h:612
Botan::BigInt::swap_reg
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:165
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
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
BOTAN_DEBUG_ASSERT
#define BOTAN_DEBUG_ASSERT(expr)
Definition: assert.h:123
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634
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:685

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 178 of file big_ops2.cpp.

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().

179 {
180 const size_t x_sw = sig_words();
181 const size_t y_sw = y.sig_words();
182 set_sign((sign() == y.sign()) ? Positive : Negative);
183
184 if(x_sw == 0 || y_sw == 0)
185 {
186 clear();
187 set_sign(Positive);
188 }
189 else if(x_sw == 1 && y_sw)
190 {
191 grow_to(y_sw + 1);
192 bigint_linmul3(mutable_data(), y.data(), y_sw, word_at(0));
193 }
194 else if(y_sw == 1 && x_sw)
195 {
196 word carry = bigint_linmul2(mutable_data(), x_sw, y.word_at(0));
197 set_word_at(x_sw, carry);
198 }
199 else
200 {
201 const size_t new_size = x_sw + y_sw + 1;
202 ws.resize(new_size);
203 secure_vector<word> z_reg(new_size);
204
205 bigint_mul(z_reg.data(), z_reg.size(),
206 data(), size(), x_sw,
207 y.data(), y.size(), y_sw,
208 ws.data(), ws.size());
209
210 this->swap_reg(z_reg);
211 }
212
213 return (*this);
214 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::carry
void carry(int64_t &h0, int64_t &h1)
Definition: ed25519_internal.h:32
Botan::bigint_linmul2
word BOTAN_WARN_UNUSED_RESULT bigint_linmul2(word x[], size_t x_size, word y)
Definition: mp_core.h:487
Botan::BigInt::mutable_data
word * mutable_data()
Definition: bigint.h:612
Botan::BigInt::swap_reg
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:165
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::bigint_linmul3
void bigint_linmul3(word z[], const word x[], size_t x_size, word y)
Definition: mp_core.h:502
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
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::BigInt::clear
void clear()
Definition: bigint.h:364
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634
Botan::BigInt::set_word_at
void set_word_at(size_t i, word w)
Definition: bigint.h:511
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

Referenced by add(), ct_cond_swap(), Botan::ct_divide(), Botan::ct_modulo(), ct_reduce_below(), Botan::divide(), mod_sub(), Botan::Montgomery_Params::mul(), mul(), Botan::mul_add(), Botan::Montgomery_Params::mul_by(), Botan::operator*(), 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(), and Botan::Montgomery_Params::square_this().

612 { return m_data.mutable_data(); }

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

! operator

Returns
  true iff this is zero, otherwise false

Definition at line 279 of file bigint.h.

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

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

Modulo operator

Parameters

  y | the modulus to reduce this by

Definition at line 262 of file big_ops2.cpp.

263 {
264 return (*this = (*this) % mod);
265 }

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

Modulo operator

Parameters

  y | the modulus (word) to reduce this by

Definition at line 270 of file big_ops2.cpp.

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

271 {
272 if(mod == 0)
273 throw BigInt::DivideByZero();
274
275 word remainder = 0;
276
277 if(is_power_of_2(mod))
278 {
279 remainder = (word_at(0) & (mod - 1));
280 }
281 else
282 {
283 const size_t sw = sig_words();
284 for(size_t i = sw; i > 0; --i)
285 remainder = bigint_modop(remainder, word_at(i-1), mod);
286 }
287
288 if(remainder && sign() == BigInt::Negative)
289 remainder = mod - remainder;
290
291 m_data.set_to_zero();
292 m_data.set_word_at(0, remainder);
293 set_sign(BigInt::Positive);
294 return remainder;
295 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::is_power_of_2
constexpr bool is_power_of_2(T arg)
Definition: bit_ops.h:43
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561
Botan::bigint_modop
word bigint_modop(word n1, word n0, word d)
Definition: mp_core.h:753
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

*= operator

Parameters

  y | the BigInt to multiply with this

Definition at line 172 of file big_ops2.cpp.

References mul().

173 {
174 secure_vector<word> ws;
175 return this->mul(y, ws);
176 }
Botan::BigInt::mul
BigInt & mul(const BigInt &y, secure_vector< word > &ws)
Definition: big_ops2.cpp:178

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

*= operator

Parameters

  y | the word to multiply with this

Definition at line 233 of file big_ops2.cpp.

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

234 {
235 if(y == 0)
236 {
237 clear();
238 set_sign(Positive);
239 }
240
241 const word carry = bigint_linmul2(mutable_data(), size(), y);
242 set_word_at(size(), carry);
243
244 return (*this);
245 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::carry
void carry(int64_t &h0, int64_t &h1)
Definition: ed25519_internal.h:32
Botan::bigint_linmul2
word BOTAN_WARN_UNUSED_RESULT bigint_linmul2(word x[], size_t x_size, word y)
Definition: mp_core.h:487
Botan::BigInt::mutable_data
word * mutable_data()
Definition: bigint.h:612
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::BigInt::clear
void clear()
Definition: bigint.h:364
Botan::BigInt::set_word_at
void set_word_at(size_t i, word w)
Definition: bigint.h:511
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561

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

Increment operator

Definition at line 252 of file bigint.h.

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

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

Postfix increment operator

Definition at line 262 of file bigint.h.

262 { BigInt x = (*this); ++(*this); return x; }
Botan::BigInt::BigInt
BigInt()=default

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

+= operator

Parameters

  y | the BigInt to add to this

Definition at line 175 of file bigint.h.

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

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

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

+= operator

Parameters

  y | the word to add to this

Definition at line 184 of file bigint.h.

185 {
186 return add(&y, 1, Positive);
187 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::add
BigInt & add(const word y[], size_t y_words, Sign sign)
Definition: big_ops2.cpp:15

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

Unary negation operator

Returns
  negative this

Definition at line 321 of file bigint.cpp.

References flip_sign().

322 {
323 BigInt x = (*this);
324 x.flip_sign();
325 return x;
326 }
Botan::BigInt::BigInt
BigInt()=default

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

Decrement operator

Definition at line 257 of file bigint.h.

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

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

Postfix decrement operator

Definition at line 267 of file bigint.h.

267 { BigInt x = (*this); --(*this); return x; }
Botan::BigInt::BigInt
BigInt()=default

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

-= operator

Parameters

  y | the BigInt to subtract from this

Definition at line 193 of file bigint.h.

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

194 {
195 return sub(y.data(), y.sig_words(), y.sign());
196 }
Botan::BigInt::sub
BigInt & sub(const word y[], size_t y_words, Sign sign)
Definition: bigint.h:285

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

-= operator

Parameters

  y | the word to subtract from this

Definition at line 202 of file bigint.h.

203 {
204 return sub(&y, 1, Positive);
205 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::sub
BigInt & sub(const word y[], size_t y_words, Sign sign)
Definition: bigint.h:285

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

/= operator

Parameters

  y | the BigInt to divide this by

Definition at line 250 of file big_ops2.cpp.

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

251 {
252 if(y.sig_words() == 1 && is_power_of_2(y.word_at(0)))
253 (*this) >>= (y.bits() - 1);
254 else
255 (*this) = (*this) / y;
256 return (*this);
257 }
Botan::is_power_of_2
constexpr bool is_power_of_2(T arg)
Definition: bit_ops.h:43

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

Left shift operator

Parameters

  shift | the number of bits to shift this left by

Definition at line 300 of file big_ops2.cpp.

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

301 {
302 const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
303 const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
304 const size_t size = sig_words();
305
306 const size_t bits_free = top_bits_free();
307
308 const size_t new_size = size + shift_words + (bits_free < shift_bits);
309
310 m_data.grow_to(new_size);
311
312 bigint_shl1(m_data.mutable_data(), new_size, size, shift_words, shift_bits);
313
314 return (*this);
315 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
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
Botan::BigInt::top_bits_free
size_t top_bits_free() const
Definition: bigint.cpp:278

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

Move assignment

Definition at line 142 of file bigint.h.

143 {
144 if(this != &other)
145 this->swap(other);
146
147 return (*this);
148 }
Botan::BigInt::swap
void swap(BigInt &other)
Definition: bigint.h:159

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

Copy assignment

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

Right shift operator

Parameters

  shift | the number of bits to shift this right by

Definition at line 320 of file big_ops2.cpp.

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

321 {
322 const size_t shift_words = shift / BOTAN_MP_WORD_BITS;
323 const size_t shift_bits = shift % BOTAN_MP_WORD_BITS;
324
325 bigint_shr1(m_data.mutable_data(), m_data.size(), shift_words, shift_bits);
326
327 if(is_negative() && is_zero())
328 set_sign(Positive);
329
330 return (*this);
331 }
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
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
Botan::BigInt::is_zero
bool is_zero() const
Definition: bigint.h:419
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561

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

References set_bit().

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

752 {
753 BigInt b;
754 b.set_bit(n);
755 return b;
756 }
Botan::BigInt::BigInt
BigInt()=default

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.

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().

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 }
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:288
Botan::BigInt::BigInt
BigInt()=default

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.

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

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

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 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::clear
void clear()
Definition: bigint.h:364
Botan::BigInt::binary_decode
void binary_decode(const uint8_t buf[], size_t length)
Definition: bigint.cpp:424
Botan::round_up
size_t round_up(size_t n, size_t align_to)
Definition: rounding.h:21
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561

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

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

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

329 {
330 if(p.is_negative() || this->is_negative())
331 throw Invalid_Argument("BigInt::reduce_below both values must be positive");
332
333 const size_t p_words = p.sig_words();
334
335 if(size() < p_words + 1)
336 grow_to(p_words + 1);
337
338 if(ws.size() < p_words + 1)
339 ws.resize(p_words + 1);
340
341 clear_mem(ws.data(), ws.size());
342
343 size_t reductions = 0;
344
345 for(;;)
346 {
347 word borrow = bigint_sub3(ws.data(), data(), p_words + 1, p.data(), p_words);
348 if(borrow)
349 break;
350
351 ++reductions;
352 swap_reg(ws);
353 }
354
355 return reductions;
356 }
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:112
Botan::BigInt::swap_reg
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:165
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
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
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::grow_to
void grow_to(size_t n) const
Definition: bigint.h:634

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

Definition at line 645 of file bigint.h.

Referenced by Botan::PointGFp::force_all_affine(), Botan::redc_p192(), Botan::redc_p224(), Botan::redc_p256(), and Botan::redc_p384().

645 { m_data.resize(s); }

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 151 of file big_ops2.cpp.

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().

152 {
153 if(this->sign() != BigInt::Positive)
154 throw Invalid_State("BigInt::sub_rev requires this is positive");
155
156 const size_t x_sw = this->sig_words();
157
158 ws.resize(std::max(x_sw, y_sw));
159 clear_mem(ws.data(), ws.size());
160
161 const int32_t relative_size = bigint_sub_abs(ws.data(), data(), x_sw, y, y_sw);
162
163 this->cond_flip_sign(relative_size > 0);
164 this->swap_reg(ws);
165
166 return (*this);
167 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:112
Botan::BigInt::swap_reg
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:165
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
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::cond_flip_sign
void cond_flip_sign(bool predicate)
Definition: bigint.cpp:456
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

Returns
  the opposite sign of the represented integer value

Definition at line 542 of file bigint.h.

Referenced by Botan::operator-().

543 {
544 if(sign() == Positive)
545 return Negative;
546 return Positive;
547 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

Set bit at specified position

Parameters

  n | bit position to set

Definition at line 428 of file bigint.h.

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

429 {
430 conditionally_set_bit(n, true);
431 }
Botan::BigInt::conditionally_set_bit
void conditionally_set_bit(size_t n, bool set_it)
Definition: bigint.cpp:252

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

Set sign of the integer

Parameters

  sign | new Sign to set

Definition at line 561 of file bigint.h.

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

562 {
563 if(sign == Negative && is_zero())
564 sign = Positive;
565
566 m_signedness = sign;
567 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::BigInt::is_zero
bool is_zero() const
Definition: bigint.h:419
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

Definition at line 511 of file bigint.h.

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

512 {
513 m_data.set_word_at(i, w);
514 }

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

Definition at line 516 of file bigint.h.

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

517 {
518 m_data.set_words(w, len);
519 }

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

Referenced by Botan::gcd().

641 {
642 m_data.shrink_to_fit(min_size);
643 }

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

Referenced by add(), add2(), bits(), cmp_word(), Botan::ct_divide(), Botan::ct_divide_u8(), Botan::ct_inverse_mod_odd_modulus(), Botan::ct_modulo(), ct_reduce_below(), Botan::CurveGFp_Repr::curve_mul(), Botan::CurveGFp_Repr::curve_sqr(), Botan::divide(), encode_words(), Botan::Montgomery_Int::fix_size(), 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(), and top_bits_free().

585 {
586 return m_data.sig_words();
587 }

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

Return the sign of the integer

Returns
  the sign of the integer

Definition at line 537 of file bigint.h.

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().

537 { return (m_signedness); }

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

Give size of internal register

Returns
  size of internal register in words

Definition at line 578 of file bigint.h.

Referenced by Botan::PointGFp::add(), add(), Botan::PointGFp::add_affine(), clear_bit(), cmp(), const_time_lookup(), ct_cond_assign(), ct_cond_swap(), Botan::ct_divide(), Botan::ct_modulo(), ct_reduce_below(), Botan::CurveGFp_Repr::curve_mul(), Botan::CurveGFp_Repr::curve_sqr(), 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(), and Botan::Montgomery_Params::square_this().

578 { return m_data.size(); }

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

Square value of *this

Parameters

  ws | a temp workspace

Definition at line 216 of file big_ops2.cpp.

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

Referenced by Botan::square().

217 {
218 const size_t sw = sig_words();
219
220 secure_vector<word> z(2*sw);
221 ws.resize(z.size());
222
223 bigint_sqr(z.data(), z.size(),
224 data(), size(), sw,
225 ws.data(), ws.size());
226
227 swap_reg(z);
228 set_sign(BigInt::Positive);
229
230 return (*this);
231 }
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::swap_reg
void swap_reg(secure_vector< word > &reg)
Definition: bigint.h:165
Botan::BigInt::size
size_t size() const
Definition: bigint.h:578
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
Botan::BigInt::data
const word * data() const
Definition: bigint.h:618
Botan::BigInt::set_sign
void set_sign(Sign sign)
Definition: bigint.h:561

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

Definition at line 285 of file bigint.h.

286 {
287 return add(y, y_words, sign == Positive ? Negative : Positive);
288 }
Botan::BigInt::Positive
Definition: bigint.h:35
Botan::BigInt::Negative
Definition: bigint.h:35
Botan::BigInt::add
BigInt & add(const word y[], size_t y_words, Sign sign)
Definition: big_ops2.cpp:15
Botan::BigInt::sign
Sign sign() const
Definition: bigint.h:537

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

Swap this value with another

Parameters

  other | BigInt to swap values with

Definition at line 159 of file bigint.h.

Referenced by Botan::PointGFp::add_affine(), botan_mp_swap(), Botan::PointGFp::mult2(), and Botan::PointGFp::swap().

160 {
161 m_data.swap(other.m_data);
162 std::swap(m_signedness, other.m_signedness);
163 }

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

Definition at line 165 of file bigint.h.

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

166 {
167 m_data.swap(reg);
168 // sign left unchanged
169 }

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.

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

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

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::BigInt::Positive
Definition: bigint.h:35
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
Botan::Charset::digit2char
char digit2char(uint8_t b)
Definition: charset.cpp:253
Botan::BigInt::BigInt
BigInt()=default

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

Convert this value to a hexadecimal string.

Definition at line 42 of file big_code.cpp.

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

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

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:14
Botan::BigInt::encode
static std::vector< uint8_t > encode(const BigInt &n)
Definition: bigint.h:763
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:288

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

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

Referenced by botan_mp_to_uint32().

237 {
238 if(is_negative())
239 throw Encoding_Error("BigInt::to_u32bit: Number is negative");
240 if(bits() > 32)
241 throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");
242
243 uint32_t out = 0;
244 for(size_t i = 0; i != 4; ++i)
245 out = (out << 8) | byte_at(3-i);
246 return out;
247 }
Botan::BigInt::is_negative
bool is_negative() const
Definition: bigint.h:525
Botan::BigInt::bits
size_t bits() const
Definition: bigint.cpp:288
Botan::BigInt::byte_at
uint8_t byte_at(size_t n) const
Definition: bigint.cpp:110

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

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

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

279 {
280 const size_t words = sig_words();
281
282 const word top_word = word_at(words - 1);
283 const size_t bits_used = high_bit(top_word);
284 CT::unpoison(bits_used);
285 return BOTAN_MP_WORD_BITS - bits_used;
286 }
Botan::BigInt::word_at
word word_at(size_t n) const
Definition: bigint.h:506
Botan::BigInt::sig_words
size_t sig_words() const
Definition: bigint.h:584
Botan::high_bit
size_t high_bit(T n)
Definition: bit_ops.h:55
Botan::CT::unpoison
void unpoison(const T *p, size_t n)
Definition: ct_utils.h:59

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

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

507 {
508 return m_data.get_word_at(n);
509 }

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