Botan::BigInt Class Reference

#include <bigint.h>

Classes
struct	DivideByZero

Public Types
enum	Base { Octal = 8 , Decimal = 10 , Hexadecimal = 16 , Binary = 256 }
enum	NumberType { Power2 }
enum	Sign { Negative = 0 , Positive = 1 }

Public Member Functions
BigInt	abs () const
void	assign (const word x[], size_t length)
	BigInt ()
	BigInt (const BigInt &other)
	BigInt (const byte buf[], size_t length, Base base=Binary)
	BigInt (const std::string &str)
	BigInt (NumberType type, size_t n)
	BigInt (RandomNumberGenerator &rng, size_t bits)
	BigInt (Sign sign, size_t n)
	BigInt (u64bit n)
void	binary_decode (const byte buf[], size_t length)
void	binary_decode (const MemoryRegion< byte > &buf)
void	binary_encode (byte buf[]) const
size_t	bits () const
byte	byte_at (size_t n) const
size_t	bytes () const
void	clear ()
void	clear_bit (size_t n)
s32bit	cmp (const BigInt &n, bool check_signs=true) const
const word *	data () const
size_t	encoded_size (Base base=Binary) const
void	flip_sign ()
bool	get_bit (size_t n) const
SecureVector< word > &	get_reg ()
const SecureVector< word > &	get_reg () const
u32bit	get_substring (size_t offset, size_t length) const
void	grow_reg (size_t n)
void	grow_to (size_t n)
bool	is_even () 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)
bool	operator! () const
BigInt &	operator%= (const BigInt &y)
word	operator%= (word y)
BigInt &	operator*= (const BigInt &y)
BigInt &	operator++ ()
BigInt	operator++ (int)
BigInt &	operator+= (const BigInt &y)
BigInt	operator- () const
BigInt &	operator-- ()
BigInt	operator-- (int)
BigInt &	operator-= (const BigInt &y)
BigInt &	operator/= (const BigInt &y)
BigInt &	operator<<= (size_t shift)
BigInt &	operator>>= (size_t shift)
word &	operator[] (size_t i)
const word &	operator[] (size_t i) const
void	randomize (RandomNumberGenerator &rng, size_t bitsize=0)
Sign	reverse_sign () const
void	set_bit (size_t n)
void	set_sign (Sign sign)
void	shrink_to_fit ()
size_t	sig_words () const
Sign	sign () const
size_t	size () const
void	swap (BigInt &other)
u32bit	to_u32bit () const
word	word_at (size_t n) const

Static Public Member Functions
static void	const_time_lookup (SecureVector< word > &output, const std::vector< BigInt > &vec, size_t idx)
static BigInt	decode (const byte buf[], size_t length, Base base=Binary)
static BigInt	decode (const MemoryRegion< byte > &buf, Base base=Binary)
static void	encode (byte buf[], const BigInt &n, Base base=Binary)
static SecureVector< byte >	encode (const BigInt &n, Base base=Binary)
static SecureVector< byte >	encode_1363 (const BigInt &n, size_t bytes)
static BigInt	random_integer (RandomNumberGenerator &rng, const BigInt &min, const BigInt &max)

Detailed Description

Arbitrary precision integer

Definition at line 22 of file bigint.h.

Member Enumeration Documentation

Base

enum Botan::BigInt::Base

Base enumerator for encoding and decoding

Enumerator
Octal
Decimal
Hexadecimal
Binary

Definition at line 28 of file bigint.h.

{ Octal = 8, Decimal = 10, Hexadecimal = 16, Binary = 256 };

NumberType

enum Botan::BigInt::NumberType

Number types (currently only power-of-2 supported)

Enumerator
Power2

Definition at line 38 of file bigint.h.

{ Power2 };

Sign

enum Botan::BigInt::Sign

Sign symbol definitions for positive and negative numbers

Enumerator
Negative
Positive

Definition at line 33 of file bigint.h.

{ Negative = 0, Positive = 1 };

Constructor & Destructor Documentation

BigInt() [1/8]

Botan::BigInt::BigInt ( )

inline

Create empty BigInt

Definition at line 446 of file bigint.h.

{ signedness = Positive; }

References Positive.

Referenced by abs(), BigInt(), cmp(), Botan::BER_Decoder::decode(), decode(), decode(), encode(), encode(), encode_1363(), Botan::Modular_Reducer::Modular_Reducer(), operator%=(), operator*=(), operator++(), operator++(), operator+=(), operator-(), operator--(), operator--(), operator-=(), operator/=(), operator<<=(), Botan::operator>>(), operator>>=(), random_integer(), Botan::ressol(), and swap().

BigInt() [2/8]

Botan::BigInt::BigInt

(

u64bit

n

)

Create BigInt from 64 bit integer

Parameters

n	initial value of this BigInt

Definition at line 20 of file bigint.cpp.

   {
   set_sign(Positive);
 
   if(n == 0)
      return;
 
   const size_t limbs_needed = sizeof(u64bit) / sizeof(word);
 
   reg.resize(4*limbs_needed);
   for(size_t i = 0; i != limbs_needed; ++i)
      reg[i] = ((n >> (i*MP_WORD_BITS)) & MP_WORD_MASK);
   }

References Botan::MP_WORD_BITS, Botan::MP_WORD_MASK, Positive, and set_sign().

BigInt() [3/8]

Botan::BigInt::BigInt

(

const BigInt &

other

)

Copy Constructor

Parameters

other

the BigInt to copy

Definition at line 46 of file bigint.cpp.

   {
   const size_t b_words = b.sig_words();
 
   if(b_words)
      {
      reg.resize(round_up<size_t>(b_words, 8));
      reg.copy(b.data(), b_words);
      set_sign(b.sign());
      }
   else
      {
      reg.resize(2);
      set_sign(Positive);
      }
   }

References BigInt(), data(), Positive, Botan::round_up(), set_sign(), sig_words(), and sign().

BigInt() [4/8]

Botan::BigInt::BigInt

(

const std::string &

str

)

Create BigInt from a string. If the string starts with 0x the rest of the string will be interpreted as hexadecimal digits. If the string starts with 0 and the second character is NOT an 'x' the string will be interpreted as octal digits. If the string starts with non-zero digit, it will be interpreted as a decimal number.

Parameters

str	the string to parse for an integer value

Definition at line 66 of file bigint.cpp.

   {
   Base base = Decimal;
   size_t markers = 0;
   bool negative = false;
   if(str.length() > 0 && str[0] == '-') { markers += 1; negative = true; }
 
   if(str.length() > markers + 2 && str[markers    ] == '0' &&
                                    str[markers + 1] == 'x')
      { markers += 2; base = Hexadecimal; }
   else if(str.length() > markers + 1 && str[markers] == '0')
      { markers += 1; base = Octal; }
 
   *this = decode(reinterpret_cast<const byte*>(str.data()) + markers,
                  str.length() - markers, base);
 
   if(negative) set_sign(Negative);
   else         set_sign(Positive);
   }

References Decimal, decode(), Hexadecimal, Negative, Octal, Positive, and set_sign().

BigInt() [5/8]

Botan::BigInt::BigInt	(	const byte	buf[],
		size_t	length,
		Base	base = Binary )

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

   {
   set_sign(Positive);
   *this = decode(input, length, base);
   }

References decode(), Positive, and set_sign().

BigInt() [6/8]

Botan::BigInt::BigInt	(	RandomNumberGenerator &	rng,
		size_t	bits )

Create a random BigInt of the specified size

Parameters

rng	random number generator
bits	size in bits

Definition at line 98 of file bigint.cpp.

   {
   set_sign(Positive);
   randomize(rng, bits);
   }

References bits(), Positive, randomize(), and set_sign().

BigInt() [7/8]

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

   {
   reg.resize(round_up<size_t>(size, 8));
   signedness = s;
   }

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

BigInt() [8/8]

Botan::BigInt::BigInt	(	NumberType	type,
		size_t	n )

Create a number of the specified type and size

Parameters

type	the type of number to create. For Power2, will create the integer 2^n
n	a size/length parameter, interpretation depends upon the value of type

Definition at line 16 of file big_rand.cpp.

   {
   set_sign(Positive);
 
   if(type == Power2)
      set_bit(bits);
   else
      throw Invalid_Argument("BigInt(NumberType): Unknown type");
   }

References bits(), Positive, Power2, set_bit(), and set_sign().

Member Function Documentation

abs()

BigInt Botan::BigInt::abs

(

)

const

Returns

absolute (positive) value of this

Definition at line 331 of file bigint.cpp.

   {
   BigInt x = (*this);
   x.set_sign(Positive);
   return x;
   }

References BigInt(), Positive, and set_sign().

Referenced by Botan::abs(), and Botan::PointGFp::operator*.

assign()

void Botan::BigInt::assign ( const word x[], size_t length )

inline

Assign using a plain word array

Definition at line 337 of file bigint.h.

        {
        reg.resize(length);
        copy_mem(&reg[0], x, length);
        }

References Botan::copy_mem().

Referenced by Botan::Montgomery_Exponentiator::execute().

binary_decode() [1/2]

void Botan::BigInt::binary_decode	(	const byte	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 351 of file bigint.cpp.

   {
   const size_t WORD_BYTES = sizeof(word);
 
   clear();
   reg.resize(round_up<size_t>((length / WORD_BYTES) + 1, 8));
 
   for(size_t i = 0; i != length / WORD_BYTES; ++i)
      {
      const size_t top = length - WORD_BYTES*i;
      for(size_t j = WORD_BYTES; j > 0; --j)
         reg[i] = (reg[i] << 8) | buf[top - j];
      }
 
   for(size_t i = 0; i != length % WORD_BYTES; ++i)
      reg[length / WORD_BYTES] = (reg[length / WORD_BYTES] << 8) | buf[i];
   }

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

Referenced by binary_decode(), decode(), Botan::generate_dsa_primes(), and randomize().

binary_decode() [2/2]

void Botan::BigInt::binary_decode

(

const MemoryRegion< byte > &

buf

)

Read integer value from a byte array (MemoryRegion<byte>)

Parameters

buf	the array to load from

Definition at line 372 of file bigint.cpp.

   {
   binary_decode(buf, buf.size());
   }

References binary_decode(), and Botan::MemoryRegion< T >::size().

binary_encode()

void Botan::BigInt::binary_encode

(

byte

buf[]

)

const

Store BigInt-value in a given byte array

Parameters

buf	destination byte array for the integer value

Definition at line 341 of file bigint.cpp.

   {
   const size_t sig_bytes = bytes();
   for(size_t i = 0; i != sig_bytes; ++i)
      output[sig_bytes-i-1] = byte_at(i);
   }

References byte_at(), and bytes().

Referenced by encode(), Botan::ElGamal_Encryption_Operation::encrypt(), Botan::DSA_Signature_Operation::sign(), Botan::ECDSA_Signature_Operation::sign(), and Botan::NR_Signature_Operation::sign().

bits()

size_t Botan::BigInt::bits

(

)

const

Get the bit length of the integer

Returns

bit length of the represented integer value

Definition at line 254 of file bigint.cpp.

   {
   const size_t words = sig_words();
 
   if(words == 0)
      return 0;
 
   size_t full_words = words - 1, top_bits = MP_WORD_BITS;
   word top_word = word_at(full_words), mask = MP_WORD_TOP_BIT;
 
   while(top_bits && ((top_word & mask) == 0))
      { mask >>= 1; top_bits--; }
 
   return (full_words * MP_WORD_BITS + top_bits);
   }

References Botan::MP_WORD_BITS, Botan::MP_WORD_TOP_BIT, sig_words(), and word_at().

Referenced by BigInt(), BigInt(), bytes(), Botan::BER_Decoder::decode(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::ElGamal_Decryption_Operation::ElGamal_Decryption_Operation(), Botan::DER_Encoder::encode(), encoded_size(), Botan::ElGamal_Encryption_Operation::encrypt(), Botan::generate_dsa_primes(), mask_bits(), Botan::PointGFp::multi_exponentiate, Botan::PointGFp::operator*, operator/=(), Botan::operator>>(), Botan::primality_test(), random_integer(), Botan::random_prime(), Botan::RSA_PrivateKey::RSA_PrivateKey(), Botan::RW_PrivateKey::RW_PrivateKey(), Botan::Fixed_Window_Exponentiator::set_base(), Botan::Montgomery_Exponentiator::set_base(), Botan::Montgomery_Exponentiator::set_exponent(), Botan::srp6_group_identifier(), and to_u32bit().

byte_at()

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

   {
   const size_t WORD_BYTES = sizeof(word);
   size_t word_num = n / WORD_BYTES, byte_num = n % WORD_BYTES;
   if(word_num >= size())
      return 0;
   else
      return get_byte(WORD_BYTES - byte_num - 1, reg[word_num]);
   }

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

Referenced by binary_encode(), Botan::BER_Decoder::decode(), get_substring(), Botan::PointGFp::operator*, and to_u32bit().

bytes()

size_t Botan::BigInt::bytes

(

)

const

Give byte length of the integer

Returns

byte length of the represented integer value

Definition at line 246 of file bigint.cpp.

   {
   return (bits() + 7) / 8;
   }

References bits().

Referenced by Botan::DH_KA_Operation::agree(), Botan::ECDH_KA_Operation::agree(), binary_encode(), Botan::ElGamal_Decryption_Operation::decrypt(), Botan::EC2OSP(), Botan::DER_Encoder::encode(), encode_1363(), encoded_size(), Botan::ElGamal_Encryption_Operation::encrypt(), Botan::EC_PrivateKey::pkcs8_private_key(), Botan::DSA_Signature_Operation::sign(), Botan::ECDSA_Signature_Operation::sign(), Botan::NR_Signature_Operation::sign(), Botan::RSA_Private_Operation::sign(), Botan::RW_Signature_Operation::sign(), Botan::srp6_client_agree(), and Botan::SRP6_Server_Session::step1().

clear()

void Botan::BigInt::clear ( )

inline

Zeroize the BigInt

Definition at line 143 of file bigint.h.

{ zeroise(reg); }

References Botan::zeroise().

Referenced by binary_decode(), mask_bits(), operator%=(), operator*=(), operator-=(), and randomize().

clear_bit()

void Botan::BigInt::clear_bit

(

size_t

n

)

Clear bit at specified position

Parameters

n	bit position to clear

Definition at line 217 of file bigint.cpp.

   {
   const size_t which = n / MP_WORD_BITS;
   const word mask = static_cast<word>(1) << (n % MP_WORD_BITS);
   if(which < size())
      reg[which] &= ~mask;
   }

References Botan::MP_WORD_BITS, and size().

cmp()

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

   {
   if(check_signs)
      {
      if(n.is_positive() && this->is_negative()) return -1;
      if(n.is_negative() && this->is_positive()) return 1;
      if(n.is_negative() && this->is_negative())
         return (-bigint_cmp(data(), sig_words(), n.data(), n.sig_words()));
      }
   return bigint_cmp(data(), sig_words(), n.data(), n.sig_words());
   }

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

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

const_time_lookup()

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

static

Definition at line 382 of file bigint.cpp.

   {
   const size_t words = output.size();
 
   clear_mem(output.data(), output.size());
 
   for(size_t i = 0; i != vec.size(); ++i)
      {
      for(size_t w = 0; w != words; ++w)
         output[w] |= CT::select<word>(CT::is_equal(i, idx), vec[i].word_at(w), 0);
      }
   }

References Botan::clear_mem(), Botan::MemoryRegion< T >::data(), Botan::CT::is_equal(), Botan::CT::select(), Botan::MemoryRegion< T >::size(), and word_at().

Referenced by Botan::Montgomery_Exponentiator::execute().

data()

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

inline

Return a pointer to the big integer word register

Returns

a pointer to the start of the internal register of the integer value

Definition at line 317 of file bigint.h.

{ return &reg[0]; }

Referenced by BigInt(), cmp(), Botan::Montgomery_Exponentiator::execute(), Botan::GMP_MPZ::GMP_MPZ(), Botan::mul_add(), Botan::operator*(), operator*=(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), Botan::operator<<(), Botan::operator>>(), Botan::Montgomery_Exponentiator::set_base(), and Botan::square().

decode() [1/2]

BigInt Botan::BigInt::decode ( const byte buf[], size_t length, Base base = Binary )

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 102 of file big_code.cpp.

   {
   BigInt r;
   if(base == Binary)
      r.binary_decode(buf, length);
   else if(base == Hexadecimal)
      {
      SecureVector<byte> binary;
 
      if(length % 2)
         {
         // Handle lack of leading 0
         const char buf0_with_leading_0[2] = { '0', static_cast<char>(buf[0]) };
         binary = hex_decode(buf0_with_leading_0, 2);
 
         binary += hex_decode(reinterpret_cast<const char*>(&buf[1]),
                              length - 1,
                              false);
         }
      else
         binary = hex_decode(reinterpret_cast<const char*>(buf),
                             length, false);
 
      r.binary_decode(&binary[0], binary.size());
      }
   else if(base == Decimal || base == Octal)
      {
      const size_t RADIX = ((base == Decimal) ? 10 : 8);
      for(size_t j = 0; j != length; ++j)
         {
         if(Charset::is_space(buf[j]))
            continue;
 
         if(!Charset::is_digit(buf[j]))
            throw Invalid_Argument("BigInt::decode: "
                                   "Invalid character in decimal input");
 
         byte x = Charset::char2digit(buf[j]);
         if(x >= RADIX)
            {
            if(RADIX == 10)
               throw Invalid_Argument("BigInt: Invalid decimal string");
            else
               throw Invalid_Argument("BigInt: Invalid octal string");
            }
 
         r *= RADIX;
         r += x;
         }
      }
   else
      throw Invalid_Argument("Unknown BigInt decoding method");
   return r;
   }

References BigInt(), Binary, binary_decode(), Botan::Charset::char2digit(), Decimal, Botan::hex_decode(), Hexadecimal, Botan::Charset::is_digit(), Botan::Charset::is_space(), Octal, and Botan::MemoryRegion< T >::size().

Referenced by Botan::DH_KA_Operation::agree(), BigInt(), BigInt(), decode(), Botan::decode_concatenation(), Botan::BER_Decoder::decode_octet_string_bigint(), Botan::CRL_Entry::encode_into(), Botan::OS2ECP(), Botan::Server_Key_Exchange::Server_Key_Exchange(), and Botan::OSSL_BN::to_bigint().

decode() [2/2]

BigInt Botan::BigInt::decode ( const MemoryRegion< byte > & buf, Base base = Binary )

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 94 of file big_code.cpp.

   {
   return BigInt::decode(&buf[0], buf.size(), base);
   }

References BigInt(), decode(), and Botan::MemoryRegion< T >::size().

encode() [1/2]

void Botan::BigInt::encode ( byte buf[], const BigInt & n, Base base = Binary )

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

Definition at line 18 of file big_code.cpp.

   {
   if(base == Binary)
      n.binary_encode(output);
   else if(base == Hexadecimal)
      {
      SecureVector<byte> binary(n.encoded_size(Binary));
      n.binary_encode(&binary[0]);
 
      hex_encode(reinterpret_cast<char*>(output),
                 &binary[0], binary.size());
      }
   else if(base == Octal)
      {
      BigInt copy = n;
      const size_t output_size = n.encoded_size(Octal);
      for(size_t j = 0; j != output_size; ++j)
         {
         output[output_size - 1 - j] =
            Charset::digit2char(static_cast<byte>(copy % 8));
 
         copy /= 8;
         }
      }
   else if(base == Decimal)
      {
      BigInt copy = n;
      BigInt remainder;
      copy.set_sign(Positive);
      const size_t output_size = n.encoded_size(Decimal);
      for(size_t j = 0; j != output_size; ++j)
         {
         divide(copy, 10, copy, remainder);
         output[output_size - 1 - j] =
            Charset::digit2char(static_cast<byte>(remainder.word_at(0)));
         if(copy.is_zero())
            break;
         }
      }
   else
      throw Invalid_Argument("Unknown BigInt encoding method");
   }

References BigInt(), Binary, binary_encode(), Decimal, Botan::Charset::digit2char(), Botan::divide(), encoded_size(), Botan::hex_encode(), Hexadecimal, is_zero(), Octal, Positive, set_sign(), Botan::MemoryRegion< T >::size(), and word_at().

encode() [2/2]

SecureVector< byte > Botan::BigInt::encode ( const BigInt & n, Base base = Binary )

static

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

Parameters

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

Returns

SecureVector of bytes containing the integer with given base

Definition at line 64 of file big_code.cpp.

   {
   SecureVector<byte> output(n.encoded_size(base));
   encode(&output[0], n, base);
   if(base != Binary)
      for(size_t j = 0; j != output.size(); ++j)
         if(output[j] == 0)
            output[j] = '0';
   return output;
   }

References BigInt(), Binary, encode(), encoded_size(), and Botan::MemoryRegion< T >::size().

Referenced by Botan::CRL_Entry::decode_from(), Botan::ElGamal_Decryption_Operation::decrypt(), Botan::RSA_Private_Operation::decrypt(), encode(), Botan::DER_Encoder::encode(), encode_1363(), Botan::operator<<(), Botan::OSSL_BN::OSSL_BN(), Botan::GMP_MPZ::to_bytes(), Botan::OSSL_BN::to_bytes(), Botan::NR_Verification_Operation::verify_mr(), Botan::RSA_Public_Operation::verify_mr(), and Botan::RW_Verification_Operation::verify_mr().

encode_1363()

SecureVector< byte > 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 SecureVector<byte>

Returns

a SecureVector<byte> containing the encoded BigInt

Definition at line 78 of file big_code.cpp.

   {
   const size_t n_bytes = n.bytes();
   if(n_bytes > bytes)
      throw Encoding_Error("encode_1363: n is too large to encode properly");
 
   const size_t leading_0s = bytes - n_bytes;
 
   SecureVector<byte> output(bytes);
   encode(&output[leading_0s], n, Binary);
   return output;
   }

References BigInt(), Binary, bytes(), encode(), and Botan::Encoding_Error::Encoding_Error().

Referenced by Botan::DH_KA_Operation::agree(), Botan::ECDH_KA_Operation::agree(), Botan::PK_Verifier::check_signature(), Botan::EC_Group::DER_encode(), Botan::EC2OSP(), Botan::RSA_Public_Operation::encrypt(), Botan::ECDSA_Signature::get_concatenation(), Botan::EC_PrivateKey::pkcs8_private_key(), Botan::DH_PublicKey::public_value(), Botan::RSA_Private_Operation::sign(), Botan::RW_Signature_Operation::sign(), Botan::srp6_client_agree(), and Botan::SRP6_Server_Session::step2().

encoded_size()

size_t Botan::BigInt::encoded_size

(

Base

base = Binary

)

const

Parameters

base	the base to measure the size for

Returns

size of this integer in base base

Definition at line 273 of file bigint.cpp.

   {
   static const double LOG_2_BASE_10 = 0.30102999566;
 
   if(base == Binary)
      return bytes();
   else if(base == Hexadecimal)
      return 2*bytes();
   else if(base == Octal)
      return ((bits() + 2) / 3);
   else if(base == Decimal)
      return static_cast<size_t>((bits() * LOG_2_BASE_10) + 1);
   else
      throw Invalid_Argument("Unknown base for BigInt encoding");
   }

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

Referenced by encode(), and encode().

flip_sign()

void Botan::BigInt::flip_sign

(

)

Flip the sign of this BigInt

Definition at line 303 of file bigint.cpp.

   {
   set_sign(reverse_sign());
   }

References reverse_sign(), and set_sign().

Referenced by Botan::BER_Decoder::decode(), Botan::operator*(), operator-(), and Botan::GMP_MPZ::to_bigint().

get_bit()

bool Botan::BigInt::get_bit

(

size_t

n

)

const

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

   {
   return ((word_at(n / MP_WORD_BITS) >> (n % MP_WORD_BITS)) & 1);
   }

References Botan::MP_WORD_BITS, and word_at().

Referenced by Botan::EC2OSP(), is_even(), is_odd(), Botan::PointGFp::multi_exponentiate, and Botan::PointGFp::operator*.

get_reg() [1/2]

SecureVector< word > & Botan::BigInt::get_reg ( )

inline

return a reference to the internal register containing the value

Returns

a reference to the word-array (SecureVector<word>) with the internal register value (containing the integer value)

Definition at line 325 of file bigint.h.

{ return reg; }

Referenced by Botan::divide(), Botan::Montgomery_Exponentiator::execute(), Botan::mul_add(), operator%=(), Botan::operator*(), operator*=(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), Botan::operator<<(), operator<<=(), Botan::operator>>(), operator>>=(), size(), Botan::square(), and Botan::GMP_MPZ::to_bigint().

get_reg() [2/2]

const SecureVector< word > & Botan::BigInt::get_reg ( ) const

inline

return a const reference to the internal register containing the value

Returns

a const reference to the word-array (SecureVector<word>) with the internal register value (containing the integer value)

Definition at line 332 of file bigint.h.

{ return reg; }

get_substring()

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

   {
   if(length > 32)
      throw Invalid_Argument("BigInt::get_substring: Substring size too big");
 
   u64bit piece = 0;
   for(size_t i = 0; i != 8; ++i)
      {
      const byte part = byte_at((offset / 8) + (7-i));
      piece = (piece << 8) | part;
      }
 
   const u64bit mask = (static_cast<u64bit>(1) << length) - 1;
   const size_t shift = (offset % 8);
 
   return static_cast<u32bit>((piece >> shift) & mask);
   }

References byte_at().

Referenced by Botan::PointGFp::operator*.

grow_reg()

void Botan::BigInt::grow_reg

(

size_t

n

)

Increase internal register buffer by n words

Parameters

n	increase by n words

Definition at line 116 of file bigint.cpp.

   {
   reg.resize(round_up<size_t>(size() + n, 8));
   }

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

grow_to()

void Botan::BigInt::grow_to

(

size_t

n

)

Definition at line 124 of file bigint.cpp.

   {
   if(n > size())
      reg.resize(round_up<size_t>(n, 8));
   }

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

Referenced by operator%=(), operator*=(), operator+=(), operator-=(), operator<<=(), and set_bit().

is_even()

bool Botan::BigInt::is_even ( ) const

inline

Test if the integer has an even value

Returns

true if the integer is even, false otherwise

Definition at line 158 of file bigint.h.

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

References get_bit().

Referenced by Botan::IF_Scheme_PrivateKey::check_key(), Botan::IF_Scheme_PublicKey::check_key(), Botan::IF_Scheme_PrivateKey::IF_Scheme_PrivateKey(), Botan::inverse_mod(), Botan::jacobi(), Botan::Montgomery_Exponentiator::Montgomery_Exponentiator(), and Botan::primality_test().

is_negative()

bool Botan::BigInt::is_negative ( ) const

inline

Tests if the sign of the integer is negative

Returns

true, iff the integer has a negative sign

Definition at line 245 of file bigint.h.

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

References Negative, and sign().

Referenced by cmp(), Botan::divide(), Botan::inverse_mod(), Botan::jacobi(), Botan::mul_add(), Botan::PointGFp::multi_exponentiate, Botan::operator%(), Botan::PointGFp::operator*, Botan::Modular_Reducer::reduce(), Botan::Power_Mod::set_base(), Botan::Power_Mod::set_exponent(), Botan::sub_mul(), to_u32bit(), and Botan::RW_Verification_Operation::verify_mr().

is_nonzero()

bool Botan::BigInt::is_nonzero ( ) const

inline

Test if the integer is not zero

Returns

true if the integer is non-zero, false otherwise

Definition at line 170 of file bigint.h.

{ return (!is_zero()); }

References is_zero().

Referenced by Botan::gcd(), Botan::IF_Scheme_PrivateKey::IF_Scheme_PrivateKey(), Botan::low_zero_bits(), and operator!().

is_odd()

bool Botan::BigInt::is_odd ( ) const

inline

Test if the integer has an odd value

Returns

true if the integer is odd, false otherwise

Definition at line 164 of file bigint.h.

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

References get_bit().

Referenced by Botan::inverse_mod(), and Botan::Core_Engine::mod_exp().

is_positive()

bool Botan::BigInt::is_positive ( ) const

inline

Tests if the sign of the integer is positive

Returns

true, iff the integer has a positive sign

Definition at line 251 of file bigint.h.

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

References Positive, and sign().

Referenced by cmp(), Botan::low_zero_bits(), Botan::Montgomery_Exponentiator::Montgomery_Exponentiator(), Botan::operator%(), and Botan::Modular_Reducer::reduce().

is_zero()

bool Botan::BigInt::is_zero ( ) const

inline

Test if the integer is zero

Returns

true if the integer is zero, false otherwise

Definition at line 176 of file bigint.h.

        {
        const size_t sw = sig_words();
 
        for(size_t i = 0; i != sw; ++i)
           if(reg[i])
              return false;
        return true;
        }

References sig_words().

Referenced by Botan::divide(), encode(), Botan::gcd(), Botan::inverse_mod(), is_nonzero(), Botan::jacobi(), Botan::mul_add(), Botan::operator%(), Botan::PointGFp::operator*, operator>>=(), Botan::Power_Mod::set_base(), set_sign(), and Botan::NR_Verification_Operation::verify_mr().

mask_bits()

void Botan::BigInt::mask_bits

(

size_t

n

)

Clear all but the lowest n bits

Parameters

n	amount of bits to keep

Definition at line 228 of file bigint.cpp.

   {
   if(n == 0) { clear(); return; }
   if(n >= bits()) return;
 
   const size_t top_word = n / MP_WORD_BITS;
   const word mask = (static_cast<word>(1) << (n % MP_WORD_BITS)) - 1;
 
   if(top_word < size())
      for(size_t i = top_word + 1; i != size(); ++i)
         reg[i] = 0;
 
   reg[top_word] &= mask;
   }

References bits(), clear(), Botan::MP_WORD_BITS, and size().

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

operator!()

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

inline

! operator

Returns

true iff this is zero, otherwise false

Definition at line 124 of file bigint.h.

{ return (!is_nonzero()); }

References is_nonzero().

operator%=() [1/2]

BigInt & Botan::BigInt::operator%=

(

const BigInt &

y

)

Modulo operator

Parameters

y	the modulus to reduce this by

Definition at line 145 of file big_ops2.cpp.

   {
   return (*this = (*this) % mod);
   }

References BigInt().

operator%=() [2/2]

word Botan::BigInt::operator%=

(

word

y

)

Modulo operator

Parameters

y	the modulus (word) to reduce this by

Definition at line 153 of file big_ops2.cpp.

   {
   if(mod == 0)
      throw BigInt::DivideByZero();
   if(power_of_2(mod))
       {
       word result = (word_at(0) & (mod - 1));
       clear();
       grow_to(2);
       get_reg()[0] = result;
       return result;
       }
 
   word remainder = 0;
 
   for(size_t j = sig_words(); j > 0; --j)
      remainder = bigint_modop(remainder, word_at(j-1), mod);
   clear();
   grow_to(2);
 
   if(remainder && sign() == BigInt::Negative)
      get_reg()[0] = mod - remainder;
   else
      get_reg()[0] = remainder;
 
   set_sign(BigInt::Positive);
 
   return word_at(0);
   }

References Botan::bigint_modop(), clear(), get_reg(), grow_to(), Negative, Positive, Botan::power_of_2(), set_sign(), sig_words(), sign(), and word_at().

operator*=()

BigInt & Botan::BigInt::operator*=

(

const BigInt &

y

)

*= operator

Parameters

y	the BigInt to multiply with this

Definition at line 95 of file big_ops2.cpp.

   {
   const size_t x_sw = sig_words(), y_sw = y.sig_words();
   set_sign((sign() == y.sign()) ? Positive : Negative);
 
   if(x_sw == 0 || y_sw == 0)
      {
      clear();
      set_sign(Positive);
      }
   else if(x_sw == 1 && y_sw)
      {
      grow_to(y_sw + 2);
      bigint_linmul3(get_reg(), y.data(), y_sw, word_at(0));
      }
   else if(y_sw == 1 && x_sw)
      {
      grow_to(x_sw + 2);
      bigint_linmul2(get_reg(), x_sw, y.word_at(0));
      }
   else
      {
      grow_to(size() + y.size());
 
      SecureVector<word> z(data(), x_sw);
      SecureVector<word> workspace(size());
 
      bigint_mul(get_reg(), size(), workspace,
                 z, z.size(), x_sw,
                 y.data(), y.size(), y_sw);
      }
 
   return (*this);
   }

References BigInt(), Botan::bigint_linmul2(), Botan::bigint_linmul3(), Botan::bigint_mul(), clear(), data(), get_reg(), grow_to(), Negative, Positive, set_sign(), sig_words(), sign(), size(), Botan::MemoryRegion< T >::size(), and word_at().

operator++() [1/2]

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

inline

Increment operator

Definition at line 97 of file bigint.h.

{ return (*this += 1); }

References BigInt().

operator++() [2/2]

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

inline

Postfix increment operator

Definition at line 107 of file bigint.h.

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

References BigInt().

operator+=()

BigInt & Botan::BigInt::operator+=

(

const BigInt &

y

)

+= operator

Parameters

y	the BigInt to add to this

Definition at line 18 of file big_ops2.cpp.

   {
   const size_t x_sw = sig_words(), y_sw = y.sig_words();
 
   const size_t reg_size = std::max(x_sw, y_sw) + 1;
   grow_to(reg_size);
 
   if(sign() == y.sign())
      bigint_add2(get_reg(), reg_size - 1, y.data(), y_sw);
   else
      {
      s32bit relative_size = bigint_cmp(data(), x_sw, y.data(), y_sw);
 
      if(relative_size < 0)
         {
         SecureVector<word> z(reg_size - 1);
         bigint_sub3(z, y.data(), reg_size - 1, data(), x_sw);
         copy_mem(&reg[0], &z[0], z.size());
         set_sign(y.sign());
         }
      else if(relative_size == 0)
         {
         zeroise(reg);
         set_sign(Positive);
         }
      else if(relative_size > 0)
         bigint_sub2(get_reg(), x_sw, y.data(), y_sw);
      }
 
   return (*this);
   }

References BigInt(), Botan::bigint_add2(), Botan::bigint_cmp(), Botan::bigint_sub2(), Botan::bigint_sub3(), Botan::copy_mem(), data(), get_reg(), grow_to(), Positive, set_sign(), sig_words(), sign(), Botan::MemoryRegion< T >::size(), and Botan::zeroise().

operator-()

BigInt Botan::BigInt::operator-

(

)

const

Unary negation operator

Returns

negative this

Definition at line 321 of file bigint.cpp.

   {
   BigInt x = (*this);
   x.flip_sign();
   return x;
   }

References BigInt(), and flip_sign().

operator--() [1/2]

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

inline

Decrement operator

Definition at line 102 of file bigint.h.

{ return (*this -= 1); }

References BigInt().

operator--() [2/2]

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

inline

Postfix decrement operator

Definition at line 112 of file bigint.h.

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

References BigInt().

operator-=()

BigInt & Botan::BigInt::operator-=

(

const BigInt &

y

)

-= operator

Parameters

y	the BigInt to subtract from this

Definition at line 53 of file big_ops2.cpp.

   {
   const size_t x_sw = sig_words(), y_sw = y.sig_words();
 
   s32bit relative_size = bigint_cmp(data(), x_sw, y.data(), y_sw);
 
   const size_t reg_size = std::max(x_sw, y_sw) + 1;
   grow_to(reg_size);
 
   if(relative_size < 0)
      {
      if(sign() == y.sign())
         bigint_sub2_rev(get_reg(), y.data(), y_sw);
      else
         bigint_add2(get_reg(), reg_size - 1, y.data(), y_sw);
 
      set_sign(y.reverse_sign());
      }
   else if(relative_size == 0)
      {
      if(sign() == y.sign())
         {
         clear();
         set_sign(Positive);
         }
      else
         bigint_shl1(get_reg(), x_sw, 0, 1);
      }
   else if(relative_size > 0)
      {
      if(sign() == y.sign())
         bigint_sub2(get_reg(), x_sw, y.data(), y_sw);
      else
         bigint_add2(get_reg(), reg_size - 1, y.data(), y_sw);
      }
 
   return (*this);
   }

References BigInt(), Botan::bigint_add2(), Botan::bigint_cmp(), Botan::bigint_shl1(), Botan::bigint_sub2(), Botan::bigint_sub2_rev(), clear(), data(), get_reg(), grow_to(), Positive, reverse_sign(), set_sign(), sig_words(), and sign().

operator/=()

BigInt & Botan::BigInt::operator/=

(

const BigInt &

y

)

/= operator

Parameters

y	the BigInt to divide this by

Definition at line 133 of file big_ops2.cpp.

   {
   if(y.sig_words() == 1 && power_of_2(y.word_at(0)))
      (*this) >>= (y.bits() - 1);
   else
      (*this) = (*this) / y;
   return (*this);
   }

References BigInt(), bits(), Botan::power_of_2(), sig_words(), and word_at().

operator<<=()

BigInt & Botan::BigInt::operator<<=

(

size_t

shift

)

Left shift operator

Parameters

shift

the number of bits to shift this left by

Definition at line 186 of file big_ops2.cpp.

   {
   if(shift)
      {
      const size_t shift_words = shift / MP_WORD_BITS,
                   shift_bits  = shift % MP_WORD_BITS,
                   words = sig_words();
 
      grow_to(words + shift_words + (shift_bits ? 1 : 0));
      bigint_shl1(get_reg(), words, shift_words, shift_bits);
      }
 
   return (*this);
   }

References BigInt(), Botan::bigint_shl1(), get_reg(), grow_to(), Botan::MP_WORD_BITS, and sig_words().

operator>>=()

BigInt & Botan::BigInt::operator>>=

(

size_t

shift

)

Right shift operator

Parameters

shift

the number of bits to shift this right by

Definition at line 204 of file big_ops2.cpp.

   {
   if(shift)
      {
      const size_t shift_words = shift / MP_WORD_BITS,
                   shift_bits  = shift % MP_WORD_BITS;
 
      bigint_shr1(get_reg(), sig_words(), shift_words, shift_bits);
 
      if(is_zero())
         set_sign(Positive);
      }
 
   return (*this);
   }

References BigInt(), Botan::bigint_shr1(), get_reg(), is_zero(), Botan::MP_WORD_BITS, Positive, set_sign(), and sig_words().

operator[]() [1/2]

word & Botan::BigInt::operator[] ( size_t i )

inline

[] operator (array access)

Parameters

i	a word index

Returns

the word at index i

Definition at line 131 of file bigint.h.

{ return reg[i]; }

operator[]() [2/2]

const word & Botan::BigInt::operator[] ( size_t i ) const

inline

[] operator (array access)

Parameters

i	a word index

Returns

the word at index i

Definition at line 138 of file bigint.h.

{ return reg[i]; }

random_integer()

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

static

Parameters

rng	a random number generator
min	the minimum value
max	the maximum value

Returns

random integer between min and max

Definition at line 50 of file big_rand.cpp.

   {
   BigInt range = max - min;
 
   if(range <= 0)
      throw Invalid_Argument("random_integer: invalid min/max values");
 
   return (min + (BigInt(rng, range.bits() + 2) % range));
   }

References BigInt(), and bits().

Referenced by Botan::DSA_PrivateKey::DSA_PrivateKey(), Botan::EC_PrivateKey::EC_PrivateKey(), and Botan::NR_PrivateKey::NR_PrivateKey().

randomize()

void Botan::BigInt::randomize	(	RandomNumberGenerator &	rng,
		size_t	bitsize = 0 )

Fill BigInt with a random number with size of bitsize

Parameters

rng	the random number generator to use
bitsize	number of bits the created random value should have

Definition at line 29 of file big_rand.cpp.

   {
   set_sign(Positive);
 
   if(bitsize == 0)
      clear();
   else
      {
      SecureVector<byte> array = rng.random_vec((bitsize + 7) / 8);
 
      if(bitsize % 8)
         array[0] &= 0xFF >> (8 - (bitsize % 8));
      array[0] |= 0x80 >> ((bitsize % 8) ? (8 - bitsize % 8) : 0);
      binary_decode(&array[0], array.size());
      }
   }

References binary_decode(), clear(), Positive, Botan::RandomNumberGenerator::random_vec(), set_sign(), and Botan::MemoryRegion< T >::size().

Referenced by BigInt(), Botan::DH_PrivateKey::DH_PrivateKey(), Botan::DL_Group::DL_Group(), Botan::ElGamal_PrivateKey::ElGamal_PrivateKey(), Botan::primality_test(), Botan::DSA_Signature_Operation::sign(), Botan::ECDSA_Signature_Operation::sign(), and Botan::NR_Signature_Operation::sign().

reverse_sign()

BigInt::Sign Botan::BigInt::reverse_sign

(

)

const

Returns

the opposite sign of the represented integer value

Definition at line 311 of file bigint.cpp.

   {
   if(sign() == Positive)
      return Negative;
   return Positive;
   }

References Negative, Positive, and sign().

Referenced by flip_sign(), Botan::operator-(), and operator-=().

set_bit()

void Botan::BigInt::set_bit

(

size_t

n

)

Set bit at specified position

Parameters

n	bit position to set

Definition at line 206 of file bigint.cpp.

   {
   const size_t which = n / MP_WORD_BITS;
   const word mask = static_cast<word>(1) << (n % MP_WORD_BITS);
   if(which >= size()) grow_to(which + 1);
   reg[which] |= mask;
   }

References grow_to(), Botan::MP_WORD_BITS, and size().

Referenced by BigInt(), Botan::generate_dsa_primes(), and Botan::random_prime().

set_sign()

void Botan::BigInt::set_sign

(

Sign

sign

)

Set sign of the integer

Parameters

sign	new Sign to set

Definition at line 292 of file bigint.cpp.

   {
   if(is_zero())
      signedness = Positive;
   else
      signedness = s;
   }

References is_zero(), and Positive.

Referenced by abs(), BigInt(), BigInt(), BigInt(), BigInt(), BigInt(), BigInt(), Botan::divide(), encode(), flip_sign(), Botan::gcd(), operator%=(), operator*=(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), operator>>=(), randomize(), and Botan::Modular_Reducer::reduce().

shrink_to_fit()

void Botan::BigInt::shrink_to_fit

(

)

Definition at line 377 of file bigint.cpp.

   {
   reg.resize(sig_words());
   }

References sig_words().

sig_words()

size_t Botan::BigInt::sig_words ( ) const

inline

Return how many words we need to hold this value

Returns

significant words of the represented integer value

Definition at line 290 of file bigint.h.

        {
        const word* x = &reg[0];
        size_t sig = reg.size();
 
        while(sig && (x[sig-1] == 0))
           sig--;
        return sig;
        }

Referenced by BigInt(), bits(), cmp(), Botan::divide(), Botan::Montgomery_Exponentiator::execute(), Botan::GMP_MPZ::GMP_MPZ(), is_zero(), Botan::Modular_Reducer::Modular_Reducer(), Botan::Montgomery_Exponentiator::Montgomery_Exponentiator(), Botan::mul_add(), Botan::operator%(), operator%=(), Botan::operator*(), operator*=(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), operator/=(), Botan::operator<<(), operator<<=(), Botan::operator>>(), operator>>=(), Botan::Montgomery_Exponentiator::set_base(), shrink_to_fit(), and Botan::square().

sign()

Sign Botan::BigInt::sign ( ) const

inline

Return the sign of the integer

Returns

the sign of the integer

Definition at line 257 of file bigint.h.

{ return (signedness); }

Referenced by BigInt(), is_negative(), is_positive(), Botan::mul_add(), Botan::operator%(), operator%=(), Botan::operator*(), operator*=(), Botan::operator+(), operator+=(), Botan::operator-(), operator-=(), Botan::operator<<(), Botan::operator>>(), and reverse_sign().

size()

size_t Botan::BigInt::size ( ) const

inline

Give size of internal register

Returns

size of internal register in words

Definition at line 284 of file bigint.h.

{ return get_reg().size(); }

References get_reg().

Referenced by BigInt(), byte_at(), clear_bit(), Botan::Montgomery_Exponentiator::execute(), grow_reg(), grow_to(), Botan::low_zero_bits(), mask_bits(), Botan::mul_add(), Botan::operator*(), operator*=(), Botan::Montgomery_Exponentiator::set_base(), set_bit(), Botan::square(), and word_at().

swap()

void Botan::BigInt::swap

(

BigInt &

other

)

Swap this value with another

Parameters

other

BigInt to swap values with

Definition at line 107 of file bigint.cpp.

   {
   reg.swap(other.reg);
   std::swap(signedness, other.signedness);
   }

References BigInt(), and std::swap().

Referenced by std::swap().

to_u32bit()

u32bit Botan::BigInt::to_u32bit

(

)

const

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

Returns

the value as a u32bit if conversion is possible

Definition at line 190 of file bigint.cpp.

   {
   if(is_negative())
      throw Encoding_Error("BigInt::to_u32bit: Number is negative");
   if(bits() > 32)
      throw Encoding_Error("BigInt::to_u32bit: Number is too big to convert");
 
   u32bit out = 0;
   for(u32bit j = 0; j != 4; ++j)
      out = (out << 8) | byte_at(3-j);
   return out;
   }

References bits(), byte_at(), Botan::Encoding_Error::Encoding_Error(), and is_negative().

word_at()

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

inline

Return the word at a specified position of the internal register

Parameters

n	position in the register

Returns

value at position n

Definition at line 238 of file bigint.h.

        { return ((n < size()) ? reg[n] : 0); }

References size().

Referenced by bits(), const_time_lookup(), Botan::divide(), encode(), get_bit(), Botan::operator%(), operator%=(), Botan::operator*(), operator*=(), operator/=(), and Botan::primality_test().

---

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

• src/math/bigint/bigint.h
• src/math/bigint/big_code.cpp
• src/math/bigint/big_ops2.cpp
• src/math/bigint/big_rand.cpp
• src/math/bigint/bigint.cpp