BigNumber Class Reference

#include "BigNumber.h"

Public Member Functions
	BigNumber ()
	BigNumber (BigNumber const &bn)
	BigNumber (uint32 v)
	BigNumber (int32 v)
	BigNumber (std::string const &v)
template<size_t Size>
	BigNumber (std::array< uint8, Size > const &v, bool littleEndian=true)
	~BigNumber ()
void	SetDword (int32)
void	SetDword (uint32)
void	SetQword (uint64)
void	SetBinary (uint8 const *bytes, int32 len, bool littleEndian=true)
template<typename Container >
auto	SetBinary (Container const &c, bool littleEndian=true) -> std::enable_if_t<!std::is_pointer_v< std::decay_t< Container > > >
bool	SetHexStr (char const *str)
bool	SetHexStr (std::string const &str)
void	SetRand (int32 numbits)
BigNumber &	operator= (BigNumber const &bn)
BigNumber &	operator+= (BigNumber const &bn)
BigNumber	operator+ (BigNumber const &bn) const
BigNumber &	operator-= (BigNumber const &bn)
BigNumber	operator- (BigNumber const &bn) const
BigNumber &	operator*= (BigNumber const &bn)
BigNumber	operator* (BigNumber const &bn) const
BigNumber &	operator/= (BigNumber const &bn)
BigNumber	operator/ (BigNumber const &bn) const
BigNumber &	operator%= (BigNumber const &bn)
BigNumber	operator% (BigNumber const &bn) const
BigNumber &	operator<<= (int n)
BigNumber	operator<< (int n) const
int	CompareTo (BigNumber const &bn) const
bool	operator<= (BigNumber const &bn) const
bool	operator== (BigNumber const &bn) const
bool	operator>= (BigNumber const &bn) const
bool	operator< (BigNumber const &bn) const
bool	operator> (BigNumber const &bn) const
bool	IsZero () const
bool	IsNegative () const
BigNumber	ModExp (BigNumber const &bn1, BigNumber const &bn2) const
BigNumber	Exp (BigNumber const &) const
int32	GetNumBytes () const
struct bignum_st *	BN ()
struct bignum_st const *	BN () const
uint32	AsDword () const
void	GetBytes (uint8 *buf, size_t bufsize, bool littleEndian=true) const
std::vector< uint8 >	ToByteVector (int32 minSize=0, bool littleEndian=true) const
template<std::size_t Size>
std::array< uint8, Size >	ToByteArray (bool littleEndian=true) const
std::string	AsHexStr () const
std::string	AsDecStr () const

Private Attributes
struct bignum_st *	_bn

Detailed Description

Constructor & Destructor Documentation

BigNumber() [1/6]

BigNumber::BigNumber

(

)

    : _bn(BN_new())
{ }

BigNumber() [2/6]

BigNumber::BigNumber

(

BigNumber const &

bn

)

    : _bn(BN_dup(bn.BN()))
{ }

BigNumber() [3/6]

BigNumber::BigNumber ( uint32  v )

inline

: BigNumber() { SetDword(v); }

BigNumber() [4/6]

BigNumber::BigNumber ( int32  v )

inline

: BigNumber() { SetDword(v); }

BigNumber() [5/6]

BigNumber::BigNumber ( std::string const &  v )

inline

: BigNumber() { SetHexStr(v); }

BigNumber() [6/6]

template<size_t Size>

BigNumber::BigNumber ( std::array< uint8, Size > const &  v, bool  littleEndian = true  )

inline

: BigNumber() { SetBinary(v.data(), Size, littleEndian); }

~BigNumber()

BigNumber::~BigNumber

(

)

{
    BN_free(_bn);
}

References _bn.

Member Function Documentation

AsDecStr()

std::string BigNumber::AsDecStr

(

)

const

{
    char* ch = BN_bn2dec(_bn);
    std::string ret = ch;
    OPENSSL_free(ch);
    return ret;
}

References _bn.

AsDword()

uint32 BigNumber::AsDword

(

)

const

{
    return (uint32)BN_get_word(_bn);
}

References _bn.

AsHexStr()

std::string BigNumber::AsHexStr

(

)

const

{
    char* ch = BN_bn2hex(_bn);
    std::string ret = ch;
    OPENSSL_free(ch);
    return ret;
}

References _bn.

BN() [1/2]

struct bignum_st * BigNumber::BN ( )

inline

{ return _bn; }

BN() [2/2]

struct bignum_st const * BigNumber::BN ( ) const

inline

{ return _bn; }

CompareTo()

int BigNumber::CompareTo

(

BigNumber const &

bn

)

const

{
    return BN_cmp(_bn, bn._bn);
}

References _bn.

Exp()

BigNumber BigNumber::Exp

(

BigNumber const &

bn

)

const

{
    BigNumber ret;
    BN_CTX *bnctx;
 
    bnctx = BN_CTX_new();
    BN_exp(ret._bn, _bn, bn._bn, bnctx);
    BN_CTX_free(bnctx);
 
    return ret;
}

References _bn.

GetBytes()

void BigNumber::GetBytes	(	uint8 *	buf,
		size_t	bufsize,
		bool	littleEndian = true
	)		const

{
#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L
    int nBytes = GetNumBytes();
    ASSERT(nBytes >= 0, "Bignum has negative number of bytes ({}).", nBytes);
    std::size_t numBytes = static_cast<std::size_t>(nBytes);
 
    // too large to store
    ASSERT(numBytes <= bufsize, "Buffer of size {} is too small to hold bignum with {} bytes.\n", bufsize, numBytes);
 
    // If we need more bytes than length of BigNumber set the rest to 0
    if (numBytes < bufsize)
        memset((void*)buf, 0, bufsize);
 
    BN_bn2bin(_bn, buf + (bufsize - numBytes));
 
    // openssl's BN stores data internally in big endian format, reverse if little endian desired
    if (littleEndian)
        std::reverse(buf, buf + bufsize);
#else
    int res = littleEndian ? BN_bn2lebinpad(_bn, buf, bufsize) : BN_bn2binpad(_bn, buf, bufsize);
    ASSERT(res > 0, "Buffer of size {} is too small to hold bignum with {} bytes.\n", bufsize, BN_num_bytes(_bn));
#endif
}

References _bn, ASSERT, and GetNumBytes().

Referenced by ToByteVector().

GetNumBytes()

int32 BigNumber::GetNumBytes

(

)

const

{
    return BN_num_bytes(_bn);
}

References _bn.

Referenced by GetBytes(), GetCheckPacketSize(), and ToByteVector().

IsNegative()

bool BigNumber::IsNegative

(

)

const

{
    return BN_is_negative(_bn);
}

References _bn.

IsZero()

bool BigNumber::IsZero

(

)

const

{
    return BN_is_zero(_bn);
}

References _bn.

ModExp()

BigNumber BigNumber::ModExp	(	BigNumber const &	bn1,
		BigNumber const &	bn2
	)		const

{
    BigNumber ret;
    BN_CTX *bnctx;
 
    bnctx = BN_CTX_new();
    BN_mod_exp(ret._bn, _bn, bn1._bn, bn2._bn, bnctx);
    BN_CTX_free(bnctx);
 
    return ret;
}

References _bn.

Referenced by Acore::Crypto::SRP6::_B(), Acore::Crypto::SRP6::CalculateVerifier(), and Acore::Crypto::SRP6::VerifyChallengeResponse().

operator%()

BigNumber BigNumber::operator% ( BigNumber const &  bn ) const

inline

    {
        BigNumber t(*this);
        return t %= bn;
    }

operator%=()

BigNumber & BigNumber::operator%=

(

BigNumber const &

bn

)

{
    BN_CTX *bnctx;
 
    bnctx = BN_CTX_new();
    BN_mod(_bn, _bn, bn._bn, bnctx);
    BN_CTX_free(bnctx);
 
    return *this;
}

References _bn.

operator*()

BigNumber BigNumber::operator* ( BigNumber const &  bn ) const

inline

    {
        BigNumber t(*this);
        return t *= bn;
    }

operator*=()

BigNumber & BigNumber::operator*=

(

BigNumber const &

bn

)

{
    BN_CTX *bnctx;
 
    bnctx = BN_CTX_new();
    BN_mul(_bn, _bn, bn._bn, bnctx);
    BN_CTX_free(bnctx);
 
    return *this;
}

References _bn.

operator+()

BigNumber BigNumber::operator+ ( BigNumber const &  bn ) const

inline

    {
        BigNumber t(*this);
        return t += bn;
    }

operator+=()

BigNumber & BigNumber::operator+=

(

BigNumber const &

bn

)

{
    BN_add(_bn, _bn, bn._bn);
    return *this;
}

References _bn.

operator-()

BigNumber BigNumber::operator- ( BigNumber const &  bn ) const

inline

    {
        BigNumber t(*this);
        return t -= bn;
    }

operator-=()

BigNumber & BigNumber::operator-=

(

BigNumber const &

bn

)

{
    BN_sub(_bn, _bn, bn._bn);
    return *this;
}

References _bn.

operator/()

BigNumber BigNumber::operator/ ( BigNumber const &  bn ) const

inline

    {
        BigNumber t(*this);
        return t /= bn;
    }

operator/=()

BigNumber & BigNumber::operator/=

(

BigNumber const &

bn

)

{
    BN_CTX *bnctx;
 
    bnctx = BN_CTX_new();
    BN_div(_bn, nullptr, _bn, bn._bn, bnctx);
    BN_CTX_free(bnctx);
 
    return *this;
}

References _bn.

operator<()

bool BigNumber::operator< ( BigNumber const &  bn ) const

inline

{ return (CompareTo(bn) < 0); }

operator<<()

BigNumber BigNumber::operator<< ( int  n ) const

inline

    {
        BigNumber t(*this);
        return t <<= n;
    }

operator<<=()

BigNumber & BigNumber::operator<<=

(

int

n

)

{
    BN_lshift(_bn, _bn, n);
    return *this;
}

References _bn.

operator<=()

bool BigNumber::operator<= ( BigNumber const &  bn ) const

inline

{ return (CompareTo(bn) <= 0); }

operator=()

BigNumber & BigNumber::operator=

(

BigNumber const &

bn

)

{
    if (this == &bn)
        return *this;
 
    BN_copy(_bn, bn._bn);
    return *this;
}

References _bn.

operator==()

bool BigNumber::operator== ( BigNumber const &  bn ) const

inline

{ return (CompareTo(bn) == 0); }

operator>()

bool BigNumber::operator> ( BigNumber const &  bn ) const

inline

{ return (CompareTo(bn) > 0); }

operator>=()

bool BigNumber::operator>= ( BigNumber const &  bn ) const

inline

{ return (CompareTo(bn) >= 0); }

SetBinary() [1/2]

template<typename Container >

auto BigNumber::SetBinary ( Container const &  c, bool  littleEndian = true  ) -> std::enable_if_t<!std::is_pointer_v<std::decay_t<Container>>>

inline

{ SetBinary(std::data(c), std::size(c), littleEndian); }

References SetBinary().

Referenced by SetBinary().

SetBinary() [2/2]

void BigNumber::SetBinary	(	uint8 const *	bytes,
		int32	len,
		bool	littleEndian = true
	)

{
    if (littleEndian)
    {
#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L
        uint8* array = new uint8[len];
 
        for (int i = 0; i < len; i++)
            array[i] = bytes[len - 1 - i];
 
        BN_bin2bn(array, len, _bn);
 
        delete[] array;
#else
        BN_lebin2bn(bytes, len, _bn);
#endif
    }
    else
        BN_bin2bn(bytes, len, _bn);
}

References _bn.

Referenced by AuthSession::HandleReconnectProof().

SetDword() [1/2]

void BigNumber::SetDword

(

int32

val

)

{
    SetDword(uint32(std::abs(val)));
    if (val < 0)
        BN_set_negative(_bn, 1);
}

References _bn, and SetDword().

Referenced by SetDword().

SetDword() [2/2]

void BigNumber::SetDword

(

uint32

val

)

{
    BN_set_word(_bn, val);
}

References _bn.

SetHexStr() [1/2]

bool BigNumber::SetHexStr

(

char const *

str

)

{
    int n = BN_hex2bn(&_bn, str);
    return (n > 0);
}

References _bn.

Referenced by GetHexFromConfig(), and WardenCheckMgr::LoadWardenChecks().

SetHexStr() [2/2]

bool BigNumber::SetHexStr ( std::string const &  str )

inline

{ return SetHexStr(str.c_str()); }

References SetHexStr().

Referenced by SetHexStr().

SetQword()

void BigNumber::SetQword

(

uint64

val

)

{
    BN_set_word(_bn, (uint32)(val >> 32));
    BN_lshift(_bn, _bn, 32);
    BN_add_word(_bn, (uint32)(val & 0xFFFFFFFF));
}

References _bn.

SetRand()

void BigNumber::SetRand

(

int32

numbits

)

{
    BN_rand(_bn, numbits, 0, 1);
}

References _bn.

Referenced by SecretMgr::AttemptTransition(), and main().

ToByteArray()

template<std::size_t Size>

std::array< uint8, Size > BigNumber::ToByteArray ( bool  littleEndian = true ) const

inline

    {
        std::array<uint8, Size> buf;
        GetBytes(buf.data(), Size, littleEndian);
        return buf;
    }

Referenced by Acore::Crypto::AEDecrypt(), Acore::Crypto::AEEncryptWithRandomIV(), Acore::Crypto::SRP6::CalculateVerifier(), WardenWin::HandleData(), and AuthSession::HandleReconnectProof().

ToByteVector()

std::vector< uint8 > BigNumber::ToByteVector	(	int32	minSize = 0,
		bool	littleEndian = true
	)		const

{
    std::size_t length = std::max(GetNumBytes(), minSize);
    std::vector<uint8> v;
    v.resize(length);
    GetBytes(v.data(), length, littleEndian);
    return v;
}

References GetBytes(), and GetNumBytes().

Referenced by WardenWin::HandleData(), Acore::Crypto::Argon2::Hash(), and WardenWin::RequestChecks().

Member Data Documentation

_bn

struct bignum_st* BigNumber::_bn

private

Referenced by AsDecStr(), AsDword(), AsHexStr(), CompareTo(), Exp(), GetBytes(), GetNumBytes(), IsNegative(), IsZero(), ModExp(), operator%=(), operator*=(), operator+=(), operator-=(), operator/=(), operator<<=(), operator=(), SetBinary(), SetDword(), SetHexStr(), SetQword(), SetRand(), and ~BigNumber().