# Botan

# BigInt

`BigInt`, in `bigint.h`, is an implementation of a signed magnitude multiple-precision integer, which is used to implement certain older public key algorithms such as RSA. It also appears in other contexts, for example X.509 certificate serial numbers are technically integer values and can be quite large, and so are represented using a `BigInt`.

A `BigInt` is a sequence of smaller integers of type `word`; this type is defined to be either `uint32_t` or `uint64_t`, depending on the word size of the processor.

Warning

While it is possible to use the APIs provided by `BigInt` as a general calculation facility, it is extremely inadvisable that you attempt to implement a cryptographic scheme of any kind directly using `BigInt`. Botan internally has many facilities for fast and side channel safe arithmetic which are not exposed to callers.

In general, as a library user, avoid doing anything with `BigInt` besides serializing or deserializing them as required to call other interfaces. Some of the general calculation facilities of `BigInt` may be made internal to the library in a future major release.

class BigInt
  static BigInt BigInt::from_string(std::string_view str)

    Create a BigInt from a string. By default decimal is expected. With an 0x prefix, instead it is treated as hexadecimal. A `-` prefix to indicate negative numbers is also accepted.

  static BigInt::from_bytes(std::span<const uint8_t> buf)

    Create a BigInt from a binary array (big-endian encoding). The result of this function will always be positive; there is no support for a sign bit, 2s complement encoding, or similar methods for indicating a negative value.

  void serialize_to(std::span<uint8_t> buf)

    Encode this BigInt as a big-endian integer. The sign is ignored.

    There must be sufficient space to encode the entire integer in `buf`. If `buf` is larger than required, sufficient zero bytes will be prefixed.

  size_t bytes() const

    Return number of bytes needed to represent value of `*this`

  size_t bits() const

    Return number of bits needed to represent value of `*this`

  std::string to_dec_string() const

    Encode the integer as a decimal string.

  std::string to_hex_string() const

    Encode the integer as a hexadecimal string, with “0x” prefix

  BigInt::zero()

    Create a BigInt with value zero

  BigInt::from_u64(uint64_t n)

    Create a BigInt with value n

  BigInt operator+(const BigInt &x, const BigInt &y)

    Add `x` and `y` and return result.

  BigInt operator+(const BigInt &x, word y)

    Add `x` and `y` and return result.

  BigInt operator+(word x, const BigInt &y)

    Add `x` and `y` and return result.

  BigInt operator-(const BigInt &x, const BigInt &y)

    Subtract `y` from `x` and return result.

  BigInt operator-(const BigInt &x, word y)

    Subtract `y` from `x` and return result.

  BigInt operator*(const BigInt &x, const BigInt &y)

    Multiply `x` and `y` and return result.

  BigInt operator/(const BigInt &x, const BigInt &y)

    Divide `x` by `y` and return result.

  BigInt operator%(const BigInt &x, const BigInt &y)

    Divide `x` by `y` and return remainder.

  word operator%(const BigInt &x, word y)

    Divide `x` by `y` and return remainder.

  word operator<<(const BigInt &x, size_t n)

    Left shift `x` by `n` and return result.

  word operator>>(const BigInt &x, size_t n)

    Right shift `x` by `n` and return result.

  BigInt &operator+=(const BigInt &y)

    Add y to `*this`

  BigInt &operator+=(word y)

    Add y to `*this`

  BigInt &operator-=(const BigInt &y)

    Subtract y from `*this`

  BigInt &operator-=(word y)

    Subtract y from `*this`

  BigInt &operator*=(const BigInt &y)

    Multiply `*this` with y

  BigInt &operator*=(word y)

    Multiply `*this` with y

  BigInt &operator/=(const BigInt &y)

    Divide `*this` by y

  BigInt &operator%=(const BigInt &y)

    Divide `*this` by y and set `*this` to the remainder.

  word operator%=(word y)

    Divide `*this` by y and set `*this` to the remainder.

  word operator<<=(size_t shift)

    Left shift `*this` by shift bits

  word operator>>=(size_t shift)

    Right shift `*this` by shift bits

  BigInt &operator++()

    Increment `*this` by 1

  BigInt &operator--()

    Decrement `*this` by 1

  BigInt operator++(int)

    Postfix increment `*this` by 1

  BigInt operator--(int)

    Postfix decrement `*this` by 1

  BigInt operator-() const

    Negation operator

  bool operator!() const

    Return true unless `*this` is zero

  void clear()

    Set `*this` to zero

  uint32_t to_u32bit() const

    Return value of `*this` as a 32-bit integer, if possible. If the integer is negative or not in range, an exception is thrown.

  bool is_even() const

    Return true if `*this` is even

  bool is_odd() const

    Return true if `*this` is odd

  bool is_nonzero() const

    Return true if `*this` is not zero

  bool is_zero() const

    Return true if `*this` is zero

  bool is_negative() const

    Return true if `*this` is less than zero

  bool is_positive() const

    Return true if `*this` is greater than or equal to zero

  BigInt abs() const

    Return absolute value of `*this`