bool _Format_b(Signal &sig, Formatter *pFormatter,
const Formatter::Flags &flags, const mpz_class &num)
{
char *str = nullptr;
::gmp_asprintf(&str, Formatter::ComposeFlags(flags, "Zb").c_str(), num.get_mpz_t());
bool rtn = pFormatter->PutString(sig, str);
::free(str);
return rtn;
}
int crypto_dh_keypair(
unsigned char *pk,
unsigned char *sk
)
{
randombytes(sk, SECRETKEY_BYTES);
mpz_class p;
p = MODULUS;
mpz_class a;
static mpz_class base = 2;
mpz_class result;
mpz_import(a.get_mpz_t(),SECRETKEY_BYTES,-1,1,0,0,sk);
mpz_powm(result.get_mpz_t(),base.get_mpz_t(),a.get_mpz_t(),p.get_mpz_t());
if (mpz_sizeinbase(result.get_mpz_t(),256) > PUBLICKEY_BYTES) return -1;
long long i;
for (i = 0;i < PUBLICKEY_BYTES;++i) pk[i] = 0;
mpz_export(pk,0,-1,1,0,0,result.get_mpz_t());
return 0;
}
// Check Fermat probable primality test (2-PRP): 2 ** (n-1) = 1 (mod n)
// true: n is probable prime
// false: n is composite; set fractional length in the nLength output
static bool FermatProbablePrimalityTestFast(const mpz_class& n, unsigned int& nLength, CPrimalityTestParams& testParams, bool fFastDiv = false)
{
// Faster GMP version
mpz_t& mpzN = testParams.mpzN;
mpz_t& mpzE = testParams.mpzE;
mpz_t& mpzR = testParams.mpzR;
const unsigned int nPrimorialSeq = testParams.nPrimorialSeq;
mpz_set(mpzN, n.get_mpz_t());
if (fFastDiv)
{
// Fast divisibility tests
// Starting from the first prime not included in the round primorial
const unsigned int nBeginSeq = nPrimorialSeq + 1;
const unsigned int nEndSeq = nBeginSeq + nFastDivPrimes;
for (unsigned int nPrimeSeq = nBeginSeq; nPrimeSeq < nEndSeq; nPrimeSeq++) {
if (mpz_divisible_ui_p(mpzN, vPrimes[nPrimeSeq])) {
return false;
}
}
}
++fermats;
mpz_sub_ui(mpzE, mpzN, 1);
mpz_powm(mpzR, mpzTwo.get_mpz_t(), mpzE, mpzN);
if (mpz_cmp_ui(mpzR, 1) == 0)
{
return true;
}
// Failed Fermat test, calculate fractional length
mpz_sub(mpzE, mpzN, mpzR);
mpz_mul_2exp(mpzR, mpzE, nFractionalBits);
mpz_tdiv_q(mpzE, mpzR, mpzN);
unsigned int nFractionalLength = mpz_get_ui(mpzE);
if (nFractionalLength >= (1 << nFractionalBits))
{
cout << "FermatProbablePrimalityTest() : fractional assert" << endl;
return false;
}
nLength = (nLength & TARGET_LENGTH_MASK) | nFractionalLength;
return false;
}
/* Pollard Brent factorization method. Pretty much the same as Pollard's rho
* though uses brent cycle detection. */
mpz_class primes::pollard_brent(mpz_class &n) {
mpz_class y; // random
random(y, n);
unsigned int m = mpz_sizeinbase(n.get_mpz_t(), 2);
unsigned int brentLimit = m_numBrents;
if (m > 99) {
brentLimit = brentLimit >> 3;
} else if (m > 98) {
mpz_class UnivariatePolynomial::eval(const mpz_class &x) const {
//TODO: Use Horner's Scheme
mpz_class ans = 0;
for (const auto &p : dict_) {
mpz_class temp;
mpz_pow_ui(temp.get_mpz_t(), x.get_mpz_t(), p.first);
ans += p.second * temp;
}
return ans;
}
mpz_class sumOfDigits(const mpz_class number, const unsigned radix) {
assert(radix <= 10);
assert(number >= 0);
auto digits = number.get_str(static_cast<int>(radix));
mpz_class sum(0);
for (const auto i : digits)
sum += i - '0';
return sum;
}
int digit_sum(const mpz_class& bignum) {
/**Find sum of digits in a bignum
* Return the sum of the digits in the number
*/
int sum = 0;
string bigstr(bignum.get_str());
for (int i = 0; i < (int)bigstr.size(); ++i)
// implicit conversion from char to int
sum += bigstr[i] - '0';
return sum;
}
bool FermatProbablePrimalityTestFast(const mpz_class &n,
unsigned int& nLength,
CPrimalityTestParams &testParams,
bool fFastFail)
{
static const mpz_class mpzTwo = 2;
mpz_t& mpzE = testParams.mpzE;
mpz_t& mpzR = testParams.mpzR;
mpz_sub_ui(mpzE, n.get_mpz_t(), 1);
mpz_powm(mpzR, mpzTwo.get_mpz_t(), mpzE, n.get_mpz_t());
if (mpz_cmp_ui(mpzR, 1) == 0)
return true;
if (fFastFail)
return false;
// Fermat test failed, calculate chain length (integer and fractional part)
mpz_sub(mpzE, n.get_mpz_t(), mpzR);
mpz_mul_2exp(mpzR, mpzE, DifficultyFractionalBits);
mpz_tdiv_q(mpzE, mpzR, n.get_mpz_t());
unsigned int fractionalLength = mpz_get_ui(mpzE);
nLength = (nLength & DifficultyChainLengthMask) | fractionalLength;
return false;
}
inline char operator()() {
++j;
next_term();
if(get<0>(nad) > get<1>(nad)) return (*this)();
mpz_mul_2exp(tmp1.get_mpz_t(), get<0>(nad).get_mpz_t(), 1);
tmp1 += get<0>(nad);
tmp1 += get<1>(nad);
mpz_fdiv_qr(tmp1.get_mpz_t(), tmp2.get_mpz_t(), tmp1.get_mpz_t(), get<2>(nad).get_mpz_t());
tmp2 += get<0>(nad);
if(tmp2 >= get<2>(nad)) {
return (*this)();
} else {
unsigned int d = tmp1.get_ui();
eliminate_digit(d);
return d + '0';
}
}
DataType dt_from_bi ( const mpz_class &bi ) {
if (bi.fits_sint_p()) {
long si = bi.get_si();
assert ( sizeof(si) == 8 ? ((uint64)si & 0xffffffff00000000ull) == 0 : true);
return (int32) si;
} else if ( bi.fits_uint_p()) {
unsigned long ui = bi.get_ui();
assert ( sizeof(ui) == 8 ? (ui & 0xffffffff00000000ull) == 0 : true );
return (uint32) ui;
} else {
if ( sgn ( bi ) < 0) throw Exception ( INVALID_TYPE, "Unsupported negative large integer.", bi.get_str() );
mpz_class cpy = bi;
std::vector<DataType> ints;
while ( sgn ( cpy ) ) {
mpz_class lsi = cpy & mpz_class(0xfffffffful);
assert ( lsi.fits_uint_p() );
ints.push_back( (uint32) lsi.get_ui() );
cpy >>= 32;
}
return DataType::as_bigint_datatype ( ints, bi.get_str() );
}
}
void generate_random(mpz_class &z, const mpz_class &n)
{
if (n == 0)
{
z = 0;
return;
}
size_t nbchar = mpz_sizeinbase(n.get_mpz_t(), 2) / (sizeof(unsigned char) * CHAR_BIT) + 1;
unsigned char *rnd = new unsigned char[nbchar];
mpz_class mask(2);
mask <<= mpz_sizeinbase(n.get_mpz_t(), 2);
mask -= 1;
do
{
_Pragma(STRINGIFY(omp critical))
{
fastrandombytes(rnd, nbchar);
}
mpz_import (z.get_mpz_t(), nbchar, 1, sizeof(unsigned char), 0, 0, rnd);
z &= mask;
}
while (z >= n);
delete[] rnd;
}
static bool is_mersenne_prime(mpz_class p)
{
if( 2 == p )
return true;
else
{
mpz_class s(4);
mpz_class div( (mpz_class(1) << p.get_ui()) - 1 );
for( mpz_class i(3); i <= p; ++i )
{
s = (s * s - mpz_class(2)) % div ;
}
return ( s == mpz_class(0) );
}
}
/**
* Helper function to convert an mpz_class object into
* its internal QString representation. Mainly used for
* debugging.
*/
static QString mpzToString(const mpz_class & val)
{
char *p = 0;
// use the gmp provided conversion routine
gmp_asprintf(&p, "%Zd", val.get_mpz_t());
// convert it into a QString
QString result(QString::fromLatin1(p));
// and free up the resources allocated by gmp_asprintf
__gmp_freefunc_t freefunc;
mp_get_memory_functions(NULL, NULL, &freefunc);
(*freefunc)(p, std::strlen(p) + 1);
// done
return result;
}
/* Pollard P-1 fatorization method. Used as a second (fast as limited to primes
* < 200000) method incase brent fails to gain a factor. */
mpz_class primes::pollard_p1(mpz_class &n) {
mpz_class c(2);
for (size_t i = 0; i < m_primes.size(); ++i) {
mpz_class pp = m_primes[i];
while (pp < 200000) {
mpz_powm(c.get_mpz_t(), c.get_mpz_t(), m_primes[i].get_mpz_t(),
n.get_mpz_t());
pp *= m_primes[i];
}
}
mpz_class g;
c--;
gcd(g, c, n);
if (g > 1 && g <= n) {
return g;
}
return 1;
}
// Check Fermat probable primality test (2-PRP): 2 ** (n-1) = 1 (mod n)
// true: n is probable prime
// false: n is composite; set fractional length in the nLength output
static bool FermatProbablePrimalityTest(const mpz_class& n, unsigned int& nLength) {
// Faster GMP version
mpz_t mpzN;mpz_t mpzE;mpz_t mpzR;
mpz_init_set(mpzN, n.get_mpz_t());
mpz_init(mpzE);
mpz_sub_ui(mpzE, mpzN, 1);
mpz_init(mpzR);
mpz_powm(mpzR, mpzTwo.get_mpz_t(), mpzE, mpzN);
if (mpz_cmp_ui(mpzR, 1) == 0) { mpz_clear(mpzN);mpz_clear(mpzE);mpz_clear(mpzR);return true; }
// Failed Fermat test, calculate fractional length
mpz_sub(mpzE, mpzN, mpzR);
mpz_mul_2exp(mpzR, mpzE, nFractionalBits);
mpz_tdiv_q(mpzE, mpzR, mpzN);
unsigned int nFractionalLength = mpz_get_ui(mpzE);
mpz_clear(mpzN);mpz_clear(mpzE);mpz_clear(mpzR);
if (nFractionalLength >= (1 << nFractionalBits)) { return error("FermatProbablePrimalityTest() : fractional assert"); }
nLength = (nLength & TARGET_LENGTH_MASK) | nFractionalLength;
return false;
}
std::vector<int> Ellipticcurve::getNAF(mpz_class k) {
//implementation folows pg. 98
std::vector<int> naf(mpz_sizeinbase(k.get_mpz_t(), 2) + 1);
int i = 0;
while (k >= 1){
if (k % 2 == 1){
mpz_class temp = (k % 4);
naf[i] = 2 - (int)temp.get_ui();
k -= naf[i];
}
else{
naf[i] = 0;
}
k /= 2;
i++;
}
return naf;
}
void generate_random(mpz_class &z, unsigned bits)
{
if (bits == 0)
{
z = 0;
return;
}
size_t nbchar = (bits) / (sizeof(unsigned char) * CHAR_BIT) + 1;
unsigned char *rnd = new unsigned char[nbchar];
mpz_class mask(2);
mask <<= bits;
mask -= 1;
_Pragma(STRINGIFY(omp critical))
{
fastrandombytes(rnd, nbchar);
}
mpz_import (z.get_mpz_t(), nbchar, 1, sizeof(unsigned char), 0, 0, rnd);
delete[] rnd;
z &= mask;
}
bool trialDivisionChainTest(const PrimeSource &primeSource,
mpz_class &N,
bool fSophieGermain,
unsigned chainLength,
unsigned depth)
{
N += (fSophieGermain ? -1 : 1);
for (unsigned i = 0; i < chainLength; i++) {
for (unsigned divIdx = 0; divIdx < depth; divIdx++) {
if (mpz_tdiv_ui(N.get_mpz_t(), primeSource[divIdx]) == 0) {
fprintf(stderr, " * divisor: [%u]%u\n", divIdx, primeSource[divIdx]);
return false;
}
}
N <<= 1;
N += (fSophieGermain ? 1 : -1);
}
return true;
}
inline vector<mpz_class> sieve_of_eratosthenes_factorization(const mpz_class& n)
{
mpz_class remaining = n;
vector<mpz_class> factors;
unsigned int limit = pow(2, 26);
mpz_class tmp;
mpz_sqrt(tmp.get_mpz_t(), n.get_mpz_t());
tmp++;
if (tmp.fits_uint_p() && tmp < limit)
{
limit = tmp.get_ui();
}
vector<bool> is_prime (limit, true);
is_prime[0] = false;
is_prime[1] = false;
for (int i = 2; i < limit; i++)
{
if (is_prime[i])
{
while (remaining % i == 0)
{
remaining /= i;
factors.push_back(i);
}
for (int j = i*i; j < limit; j += i)
{
is_prime[j] = false;
}
}
}
// Don't forget the last factor if one exists.
if (remaining > 1) factors.push_back(remaining);
return factors;
}
/**
* Funkce, pro testovani prvociselnosti (pouzita metoda Solovay--Strassen).
* @param n Cislo, ktere se ma zkontrolovat na prvocislo.
* @param iter Pocet iteraci.
* @return True -- Je pravdepodobne prvocislo, False -- urcite neni.
*/
bool SolovayStrassen(mpz_class n, int iter)
{
mpz_class n3 = n - 3;
mpz_class res, exp;
mpz_class jacobi = 0;
for(int i = 0; i < iter; i++)
{
mpz_class a = rndClass.get_z_range(n3) + 2;
jacobi = JacobiSymbol(a, n);
if(jacobi == 0)
return false;
exp = (n - 1) / 2;
mpz_powm(res.get_mpz_t(), a.get_mpz_t(), exp.get_mpz_t(), n.get_mpz_t());
if(jacobi == -1)
jacobi += n;
if(res != jacobi)
return false;
}
return true;
}
list<int> dfa_randomgenerator::randomElementOfK(int m, mpz_class t, mpz_class p)
{{{
list<int> ret;
if(m < 2)
return ret;
if(p*(m-1) < t)
return ret;
mpz_class C, De;
C = elementOfC(m,t,p);
if(t == 1) {
mpz_class Dei, x;
random_mpz_class(Dei, C);
Dei += 1;
De = Dei;
x = 1;
while(De > x) {
De -= x;
x++;
};
ret.push_back(x.get_si());
return ret;
} else {
random_mpz_class(De, C);
De += 1;
if((De <= elementOfC(m,t,p-1)) && p > 1) {
return randomElementOfK(m,t,p-1);
} else {
ret = randomElementOfK(m,t-1,p);
ret.push_back(p.get_si());
return ret;
}
}
}}}
void MathUtils::GetSmoothnessBase(mpz_class& ret_base, mpz_class& N)
{
mpfr_t f_N, log_N, log_log_N;
mpz_t base_mpz;
mpz_init(base_mpz);
mpfr_init(f_N); mpfr_init(log_N); mpfr_init(log_log_N);
mpfr_set_z(f_N, N.get_mpz_t(), MPFR_RNDU); //f_N = N
mpfr_log(log_N, f_N, MPFR_RNDU); //log_N = log(N)
mpfr_log(log_log_N, log_N, MPFR_RNDU); //log_log_N = log(log(N))
mpfr_mul(f_N, log_N, log_log_N, MPFR_RNDU); //f_N = log(N) * log(log(N))
mpfr_sqrt(f_N, f_N, MPFR_RNDU); //f_N = sqrt(f_N)
mpfr_div_ui(f_N, f_N, 2, MPFR_RNDU); //f_N = f_N/2
mpfr_exp(f_N, f_N, MPFR_RNDU); //f_N = e^f_N
mpfr_get_z(base_mpz, f_N, MPFR_RNDU);
ret_base = mpz_class(base_mpz);
mpfr_clears(f_N, log_N, log_log_N, NULL);
}
std::string Signal::valueToVHDL(mpz_class v, bool quot){
std::string r;
/* Get base 2 representation */
r = v.get_str(2);
/* Some checks */
if ((int) r.size() > width()) {
std::ostringstream o;
o << "Error in " << __FILE__ << "@" << __LINE__ << ": value (" << r << ") is larger than signal " << getName();
throw o.str();
}
/* Do padding */
while ((int)r.size() < width())
r = "0" + r;
/* Put apostrophe / quot */
if (!quot) return r;
if ((width() > 1) || ( isBus() ))
return "\"" + r + "\"";
else
return "'" + r + "'";
}
int root(mpz_class& result, const mpz_class arg, const mpz_class prime)
{
mpz_class y, b, t;
unsigned int r, m;
if (arg % prime == 0) {
result = 0;
return 1;
}
if (mpz_legendre(arg.get_mpz_t(), prime.get_mpz_t()) == -1)
return -1;
b = 0;
t = 0;
y = 2;
while(mpz_legendre(y.get_mpz_t(), prime.get_mpz_t()) != -1)
{
y++;
}
result = prime - 1;
r = mpz_scan1(result.get_mpz_t(), 0);
mpz_rshift(result.get_mpz_t(), result.get_mpz_t(), r);
mpz_powm(y.get_mpz_t(), y.get_mpz_t(), result.get_mpz_t(), prime.get_mpz_t());
mpz_rshift(result.get_mpz_t(), result.get_mpz_t(), 1);
mpz_powm(b.get_mpz_t(), arg.get_mpz_t(), result.get_mpz_t(), prime.get_mpz_t());
result = (arg * b) % prime;
b = (result * b) % prime;
while(b != 1) {
t = (b * b) % prime;
for(m = 1; t != 1; m++) {
t = (t * t) % prime;
}
t = 0;
mpz_setbit(t.get_mpz_t(), r - m - 1);
mpz_powm(t.get_mpz_t(), y.get_mpz_t(), t.get_mpz_t(), prime.get_mpz_t());
y = t * t;
r = m;
result = (result * t) % prime;
b = (b * y) % prime;
}
return 1;
}
void load(Archive & ar, mpz_class & t, unsigned int version)
{
std::string num;
ar >> num;
t.set_str(num,10);
}
void save(Archive & ar, const mpz_class & t, unsigned int version)
{
std::string num =t.get_str(10);
ar << num;
}
mpz_class squareRoot(const mpz_class& i) {
mpz_class root, remainder;
mpz_rootrem(root.get_mpz_t(), remainder.get_mpz_t(), i.get_mpz_t(), 2);
assert(remainder == 0);
return root;
}
bool isSquare(const mpz_class& i) {
mpz_class dummy, remainder;
mpz_rootrem(dummy.get_mpz_t(), remainder.get_mpz_t(), i.get_mpz_t(), 2);
return remainder == 0;
}
QDebug operator<<(QDebug s, const mpz_class& m) {
char b[65536] = "";
gmp_sprintf (b, "%Zd", m.get_mpz_t());
s << b;
return s;
}
/* Encryption functions acting on a key */
cipher encrypt(mpz_class &op) {
cipher rop;
egcs_encrypt(pk, hr->as_ptr(), rop.as_ptr(), op.get_mpz_t());
return rop;
}
