1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*************************************************
* BigInt Header File *
* (C) 1999-2008 The Botan Project *
*************************************************/
#ifndef BOTAN_BIGINT_H__
#define BOTAN_BIGINT_H__
#include <botan/base.h>
#include <botan/mp_types.h>
#include <iosfwd>
namespace Botan {
/*************************************************
* BigInt *
*************************************************/
class BigInt
{
public:
enum Base { Octal = 8, Decimal = 10, Hexadecimal = 16, Binary = 256 };
enum Sign { Negative = 0, Positive = 1 };
enum NumberType { Random, Power2 };
struct DivideByZero : public Exception
{ DivideByZero() : Exception("BigInt divide by zero") {} };
BigInt& operator+=(const BigInt&);
BigInt& operator-=(const BigInt&);
BigInt& operator*=(const BigInt&);
BigInt& operator/=(const BigInt&);
BigInt& operator%=(const BigInt&);
word operator%=(word);
BigInt& operator<<=(u32bit);
BigInt& operator>>=(u32bit);
BigInt& operator++() { return (*this += 1); }
BigInt& operator--() { return (*this -= 1); }
BigInt operator++(int) { BigInt x = (*this); ++(*this); return x; }
BigInt operator--(int) { BigInt x = (*this); --(*this); return x; }
BigInt operator-() const;
bool operator !() const { return (!is_nonzero()); }
s32bit cmp(const BigInt&, bool = true) const;
bool is_even() const { return (get_bit(0) == 0); }
bool is_odd() const { return (get_bit(0) == 1); }
bool is_nonzero() const { return (!is_zero()); }
bool is_zero() const;
void set_bit(u32bit);
void clear_bit(u32bit);
void mask_bits(u32bit);
bool get_bit(u32bit) const;
u32bit get_substring(u32bit, u32bit) const;
byte byte_at(u32bit) const;
word word_at(u32bit n) const
{ return ((n < size()) ? reg[n] : 0); }
u32bit to_u32bit() const;
bool is_negative() const { return (sign() == Negative); }
bool is_positive() const { return (sign() == Positive); }
Sign sign() const { return (signedness); }
Sign reverse_sign() const;
void flip_sign();
void set_sign(Sign);
BigInt abs() const;
u32bit size() const { return reg.size(); }
u32bit sig_words() const;
u32bit bytes() const;
u32bit bits() const;
const word* data() const { return reg.begin(); }
SecureVector<word>& get_reg() { return reg; }
void grow_reg(u32bit) const;
word& operator[](u32bit);
word operator[](u32bit) const;
void clear() { reg.clear(); }
void randomize(u32bit = 0);
void binary_encode(byte[]) const;
void binary_decode(const byte[], u32bit);
void binary_decode(const MemoryRegion<byte>&);
u32bit encoded_size(Base = Binary) const;
static SecureVector<byte> encode(const BigInt&, Base = Binary);
static void encode(byte[], const BigInt&, Base = Binary);
static BigInt decode(const byte[], u32bit, Base = Binary);
static BigInt decode(const MemoryRegion<byte>&, Base = Binary);
static SecureVector<byte> encode_1363(const BigInt&, u32bit);
void swap(BigInt&);
BigInt() { signedness = Positive; }
BigInt(u64bit);
BigInt(const BigInt&);
BigInt(const std::string&);
BigInt(const byte[], u32bit, Base = Binary);
BigInt(Sign, u32bit);
BigInt(NumberType, u32bit);
private:
void grow_to(u32bit) const;
SecureVector<word> reg;
Sign signedness;
};
/*************************************************
* Arithmetic Operators *
*************************************************/
BigInt operator+(const BigInt&, const BigInt&);
BigInt operator-(const BigInt&, const BigInt&);
BigInt operator*(const BigInt&, const BigInt&);
BigInt operator/(const BigInt&, const BigInt&);
BigInt operator%(const BigInt&, const BigInt&);
word operator%(const BigInt&, word);
BigInt operator<<(const BigInt&, u32bit);
BigInt operator>>(const BigInt&, u32bit);
/*************************************************
* Comparison Operators *
*************************************************/
inline bool operator==(const BigInt& a, const BigInt& b)
{ return (a.cmp(b) == 0); }
inline bool operator!=(const BigInt& a, const BigInt& b)
{ return (a.cmp(b) != 0); }
inline bool operator<=(const BigInt& a, const BigInt& b)
{ return (a.cmp(b) <= 0); }
inline bool operator>=(const BigInt& a, const BigInt& b)
{ return (a.cmp(b) >= 0); }
inline bool operator<(const BigInt& a, const BigInt& b)
{ return (a.cmp(b) < 0); }
inline bool operator>(const BigInt& a, const BigInt& b)
{ return (a.cmp(b) > 0); }
/*************************************************
* I/O Operators *
*************************************************/
std::ostream& operator<<(std::ostream&, const BigInt&);
std::istream& operator>>(std::istream&, BigInt&);
}
namespace std {
inline void swap(Botan::BigInt& a, Botan::BigInt& b) { a.swap(b); }
}
#endif
|
