Example #1
0
File: rader.c Project: Pinkii-/PCA
/* compute n^m mod p, where m >= 0 and p > 0. */
static int power_mod(int n, int m, int p)
{
     if (m == 0)
	  return 1;
     else if (m % 2 == 0) {
	  int x = power_mod(n, m / 2, p);
	  return MULMOD(x, x, p);
     }
     else
	  return MULMOD(n, power_mod(n, m - 1, p), p);
}
Example #2
0
static long long int solve4(int n, int m) {
    int low, high;
    low = MIN(n, m);
    high = MAX(n, m);
    int *primes;
    int prime_count = fill_primes(&primes, low);

    /* printf("count: %d primes: %p\n", prime_count, primes); */
    /* for (int i = 0; i < prime_count; ++i) { */
    /*     printf("%d\n", primes[i]); */
    /* } */

    long long int result = 1;
    for (int i = 0; i < prime_count; ++i) {
        int prime = primes[i];
        long long int acc = prime;
        long long int nn = low, nm = high;
        long long int base = 0;
        while (nn >= acc && nm >= acc) {
            base += (nn / acc) * (nm / acc);
            acc *= prime;
        }
        result *= power_mod(prime, base, MOD);
        result %= MOD;
        /* printf("i: %d %d base: %lld\n", i, prime, base); */
    }

    free(primes);
    return result;
}
Example #3
0
/*
* Load a DH private key
*/
DH_PrivateKey::DH_PrivateKey(const AlgorithmIdentifier& alg_id,
                             const secure_vector<uint8_t>& key_bits) :
   DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_42)
   {
   if(m_y == 0)
      m_y = power_mod(group_g(), m_x, group_p());
   }
Example #4
0
static long long int power_mod(int i, long long int n, int m) {
    if (n == 0)
        return 1;

    long long int half = power_mod(i, n / 2, m);
    long long int result = (half * half) % m;
    int rem = n % 2;
    return rem ? (result * i) % m : result;
}
Example #5
0
File: nr.cpp Project: bogiord/botan
NR_PrivateKey::NR_PrivateKey(const AlgorithmIdentifier& alg_id,
                             const secure_vector<byte>& key_bits,
                             RandomNumberGenerator& rng) :
   DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_57)
   {
   m_y = power_mod(group_g(), m_x, group_p());

   load_check(rng);
   }
Example #6
0
DSA_PrivateKey::DSA_PrivateKey(const AlgorithmIdentifier& alg_id,
                               const MemoryRegion<byte>& key_bits,
                               RandomNumberGenerator& rng) :
   DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_57)
   {
   y = power_mod(group_g(), x, group_p());

   load_check(rng);
   }
int main(int argc, char **argv)
{
	unsigned int x,y,a;

	scanf("%u %u %u",&x,&y,&a);

	power_mod(x,y,a);

	return 0;
}
Example #8
0
/*************************************************
* Algorithm Specific PKCS #8 Initialization Code *
*************************************************/
void DH_PrivateKey::PKCS8_load_hook(RandomNumberGenerator& rng,
                                    bool generated)
   {
   if(y == 0)
      y = power_mod(group_g(), x, group_p());
   core = DH_Core(rng, group, x);

   if(generated)
      gen_check(rng);
   else
      load_check(rng);
   }
Example #9
0
/*************************************************
* DH_Core Constructor                            *
*************************************************/
DH_Core::DH_Core(RandomNumberGenerator& rng,
                 const DL_Group& group, const BigInt& x)
   {
   op = Engine_Core::dh_op(group, x);

   const BigInt& p = group.get_p();

   BigInt k(rng, std::min(p.bits()-1, BLINDING_BITS));

   if(k != 0)
      blinder = Blinder(k, power_mod(inverse_mod(k, p), x, p), p);
   }
Example #10
0
/*************************************************
* IF_Core Constructor                            *
*************************************************/
IF_Core::IF_Core(RandomNumberGenerator& rng,
                 const BigInt& e, const BigInt& n, const BigInt& d,
                 const BigInt& p, const BigInt& q,
                 const BigInt& d1, const BigInt& d2, const BigInt& c)
   {
   op = Engine_Core::if_op(e, n, d, p, q, d1, d2, c);

   if(BLINDING_BITS)
      {
      BigInt k(rng, std::min(n.bits()-1, BLINDING_BITS));
      blinder = Blinder(power_mod(k, e, n), inverse_mod(k, n), n);
      }
   }
Example #11
0
/*************************************************
* ELG_Core Constructor                           *
*************************************************/
ELG_Core::ELG_Core(RandomNumberGenerator& rng,
                   const DL_Group& group, const BigInt& y, const BigInt& x)
   {
   op = Engine_Core::elg_op(group, y, x);

   const BigInt& p = group.get_p();
   p_bytes = p.bytes();

   if(BLINDING_BITS)
      {
      BigInt k(rng, std::min(p.bits()-1, BLINDING_BITS));
      blinder = Blinder(k, power_mod(k, x, p), p);
      }
   }
Example #12
0
/*
* Create generator of the q-sized subgroup (DSA style generator)
*/
BigInt DL_Group::make_dsa_generator(const BigInt& p, const BigInt& q)
   {
   const BigInt e = (p - 1) / q;

   if(e == 0 || (p - 1) % q > 0)
      throw Invalid_Argument("make_dsa_generator q does not divide p-1");

   for(size_t i = 0; i != PRIME_TABLE_SIZE; ++i)
      {
      BigInt g = power_mod(PRIMES[i], e, p);
      if(g > 1)
         return g;
      }

   throw Internal_Error("DL_Group: Couldn't create a suitable generator");
   }
Example #13
0
File: nr.cpp Project: bogiord/botan
/*
* Create a NR private key
*/
NR_PrivateKey::NR_PrivateKey(RandomNumberGenerator& rng,
                             const DL_Group& grp,
                             const BigInt& x_arg)
   {
   m_group = grp;
   m_x = x_arg;

   if(m_x == 0)
      m_x = BigInt::random_integer(rng, 2, group_q() - 1);

   m_y = power_mod(group_g(), m_x, group_p());

   if(x_arg == 0)
      gen_check(rng);
   else
      load_check(rng);
   }
Example #14
0
static long long int solve5(int n, int m) {
    int low, high;
    low = MIN(n, m);
    high = MAX(n, m);

    int *sieve = calloc((low + 1), sizeof(int));

    for (int j = 2; j <= low / 2; ++j) {
        sieve[2 * j] = 1;
    }

    for (int i = 3; i <= (int)floor(sqrt(low)); i += 2) {
        if (sieve[i] == 0) {
            for (int j = 2; j <= low / i; ++j) {
                sieve[i * j] = 1;
            }
        }
    }

    /* for (int i = 1; i <= low; ++i) { */
    /*     if (sieve[i] == 0) { */
    /*         printf("I: %d\n", i); */
    /*     } */
    /* } */
    /* return 0; */

    long long int result = 1;
    for (int i = 2; i <= low; ++i) {
        if (sieve[i] != 0) {
            continue;
        }
        int prime = i;
        long long int acc = prime;
        long long int nn = low, nm = high;
        long long int base = 0;
        while (nn >= acc && nm >= acc) {
            base += (nn / acc) * (nm / acc);
            acc *= prime;
        }
        result *= power_mod(prime, base, MOD);
        result %= MOD;
        /* printf("i: %d %d base: %lld\n", i, prime, base); */
    }
    return result;
}
Example #15
0
static long long int solve3(int n, int m) {
    int low, high;
    low = MIN(n, m);
    high = MAX(n, m);

    primes[0] = 2;
    primes[1] = 3;
    primes[2] = 5;
    prime_count = 3;
    /* build primes */
    for (int i = 1; i <= (low + 5) / 6; ++i) {
        if (is_prime(6 * i + 1)) {
            /* printf("%d %d %d\n", prime_count, i, 0); */
            primes[prime_count ++] = 6 * i + 1;
        }
        if (is_prime(6 * i + 5)) {
            /* printf("%d %d %d\n", prime_count, i, 0); */
            primes[prime_count ++] = 6 * i + 5;
        }
    }
    /* for (int i = 7; i <= low; i += 2) { */
    /*     if (is_prime(i)) { */
    /*         primes[prime_count ++] = i; */
    /*     } */
    /* } */

    /* printf("N: %d M: %d prime_count: %d\n", n, m, prime_count); */
    long long int result = 1;
    for (int i = 0; i < prime_count; ++i) {
        int prime = primes[i];
        long long int acc = prime;
        long long int nn = low, nm = high;
        long long int base = 0;
        while (nn >= acc && nm >= acc) {
            base += (nn / acc) * (nm / acc);
            acc *= prime;
        }
        result *= power_mod(prime, base, MOD);
        result %= MOD;
        /* printf("i: %d %d base: %lld\n", i, prime, base); */
    }

    return result;
}
Example #16
0
/*
* Create a DH private key
*/
DH_PrivateKey::DH_PrivateKey(RandomNumberGenerator& rng,
                             const DL_Group& grp,
                             const BigInt& x_arg)
   {
   group = grp;
   x = x_arg;

   if(x == 0)
      {
      const BigInt& p = group_p();
      x.randomize(rng, 2 * dl_work_factor(p.bits()));
      }

   if(y == 0)
      y = power_mod(group_g(), x, group_p());

   if(x == 0)
      gen_check(rng);
   else
      load_check(rng);
   }
Example #17
0
/*
* Create a DH private key
*/
DH_PrivateKey::DH_PrivateKey(RandomNumberGenerator& rng,
                             const DL_Group& grp,
                             const BigInt& x_arg)
   {
   m_group = grp;

   if(x_arg == 0)
      {
      const BigInt& p = group_p();
      m_x.randomize(rng, dl_exponent_size(p.bits()));
      }
   else
      {
      m_x = x_arg;
      }

   if(m_y == 0)
      {
      m_y = power_mod(group_g(), m_x, group_p());
      }
   }
Example #18
0
static long long int solve(int n, int m) {
    struct prime_info *primes = malloc(PRIME_COUNT * sizeof(struct prime_info));
    int prime_count = 0;
    long long int result = 1;
    for (int i = 2; i <= n; ++i) {
        long long int r;
        int left;
        prime(i, m, primes, &prime_count, &r, &left, MOD);
        /* result *= r; */
        /* result %= MOD; */
    }

    for (int i = 0; i < prime_count; ++i) {
        assert(primes[i].value > 0);
        /* printf("%d %d\n", primes[i].value, primes[i].count); */
        assert(primes[i].count >= 0);
        result *= power_mod(primes[i].value, primes[i].count, MOD);
        result %= MOD;
    }
    free(primes);
    return result;
}
Example #19
0
File: rader.c Project: Pinkii-/PCA
static fftw_rader_data *create_rader_aux(int p, int flags)
{
     fftw_complex *omega, *work;
     int g, ginv, gpower;
     int i;
     FFTW_TRIG_REAL twoPiOverN;
     fftw_real scale = 1.0 / (p - 1);	/* for convolution */
     fftw_plan plan;
     fftw_rader_data *d;

     if (p < 2)
	  fftw_die("non-prime order in Rader\n");

     flags &= ~FFTW_IN_PLACE;

     d = (fftw_rader_data *) fftw_malloc(sizeof(fftw_rader_data));

     g = find_generator(p);
     ginv = power_mod(g, p - 2, p);

     omega = (fftw_complex *) fftw_malloc((p - 1) * sizeof(fftw_complex));

     plan = fftw_create_plan(p - 1, FFTW_FORWARD,
			     flags & ~FFTW_NO_VECTOR_RECURSE);

     work = (fftw_complex *) fftw_malloc((p - 1) * sizeof(fftw_complex));

     twoPiOverN = FFTW_K2PI / (FFTW_TRIG_REAL) p;
     gpower = 1;
     for (i = 0; i < p - 1; ++i) {
	  c_re(work[i]) = scale * FFTW_TRIG_COS(twoPiOverN * gpower);
	  c_im(work[i]) = FFTW_FORWARD * scale * FFTW_TRIG_SIN(twoPiOverN 
							       * gpower);
	  gpower = MULMOD(gpower, ginv, p);
     }

     /* fft permuted roots of unity */
     fftw_executor_simple(p - 1, work, omega, plan->root, 1, 1,
			  plan->recurse_kind);

     fftw_free(work);

     d->plan = plan;
     d->omega = omega;
     d->g = g;
     d->ginv = ginv;
     d->p = p;
     d->flags = flags;
     d->refcount = 1;
     d->next = NULL;

     d->cdesc = (fftw_codelet_desc *) fftw_malloc(sizeof(fftw_codelet_desc));
     d->cdesc->name = NULL;
     d->cdesc->codelet = NULL;
     d->cdesc->size = p;
     d->cdesc->dir = FFTW_FORWARD;
     d->cdesc->type = FFTW_RADER;
     d->cdesc->signature = g;
     d->cdesc->ntwiddle = 0;
     d->cdesc->twiddle_order = NULL;
     return d;
}