/* Return the parameters of the curve NAME. */
gcry_err_code_t
_gcry_ecc_get_param (const char *name, gcry_mpi_t *pkey)
{
gpg_err_code_t err;
unsigned int nbits;
elliptic_curve_t E;
mpi_ec_t ctx;
gcry_mpi_t g_x, g_y;
err = generate_curve (0, name, &E, &nbits);
if (err)
return err;
g_x = mpi_new (0);
g_y = mpi_new (0);
ctx = _gcry_mpi_ec_init (E.p, E.a);
if (_gcry_mpi_ec_get_affine (g_x, g_y, &E.G, ctx))
log_fatal ("ecc get param: Failed to get affine coordinates\n");
_gcry_mpi_ec_free (ctx);
point_free (&E.G);
pkey[0] = E.p;
pkey[1] = E.a;
pkey[2] = E.b;
pkey[3] = ec2os (g_x, g_y, E.p);
pkey[4] = E.n;
pkey[5] = NULL;
return 0;
}
int IncreaseR1()
{
if (curve) {
Update_flags |= UF_WORLD_CHANGED;
delete_curve();
r1scale += F1_0;
generate_curve(r1scale, r4scale);
diagnostic_message("R1 vector increased.");
mine_changed = 1;
warn_if_concave_segments();
}
return 1;
}
int GenerateCurve()
{
if ( (Markedsegp != 0) && !IS_CHILD(Markedsegp->children[Markedside])) {
r1scale = r4scale = F1_0*20;
autosave_mine( mine_filename );
diagnostic_message("Curve Generated.");
Update_flags |= UF_WORLD_CHANGED;
curve = generate_curve(r1scale, r4scale);
mine_changed = 1;
if (curve == 1) {
strcpy(undo_status[Autosave_count], "Curve Generation UNDONE.\n");
}
if (curve == 0) diagnostic_message("Cannot generate curve -- check Current segment.");
}
else diagnostic_message("Cannot generate curve -- check Marked segment.");
warn_if_concave_segments();
return 1;
}
/*
* void animate();
*
* This acts as the idle function, whenever the system is idle, animte() is
* called. The end of animate() forces display() to refresh
*/
void animate() {
int j;
while((double) clock() == current){} // waits for next time step
current = (double) clock();
for(j = 0; j < all_spheres.size(); j++) {
// DECAY
double decay = (rand() % 101)/100.;
if( all_spheres[j].radius>0.0) {
if( decay <= DECAY_PROB && all_spheres[j].active) {
all_spheres[j].radius -= 0.00045;
}
}else{
all_spheres.erase(all_spheres.begin()+j);
balls--;
break;
}
// END DECAY
if(all_spheres[j].path == 0) { //linear paths
// advance position on vector
all_spheres[j] = move_on_vector(all_spheres[j]);
}else if(all_spheres[j].path == 1) { // bezier curves for path
if( all_spheres[j].interval < 1.0) {
// advance position on curve
move_on_curve(&all_spheres[j]);
} else {
// generate a new curve
generate_curve(&all_spheres[j]);
}
}
}
// set window and call display to refresh screen
glutSetWindow(window);
glutPostRedisplay();
}
/*
* First obtain the setup. Over the finite field randomize an scalar
* secret value, and calculate the public point.
*/
static gpg_err_code_t
generate_key (ECC_secret_key *sk, unsigned int nbits, const char *name,
gcry_mpi_t g_x, gcry_mpi_t g_y,
gcry_mpi_t q_x, gcry_mpi_t q_y)
{
gpg_err_code_t err;
elliptic_curve_t E;
gcry_mpi_t d;
mpi_point_t Q;
mpi_ec_t ctx;
err = generate_curve (nbits, name, &E, &nbits);
if (err)
return err;
if (DBG_CIPHER)
{
log_mpidump ("ecc generation p", E.p);
log_mpidump ("ecc generation a", E.a);
log_mpidump ("ecc generation b", E.b);
log_mpidump ("ecc generation n", E.n);
log_mpidump ("ecc generation Gx", E.G.x);
log_mpidump ("ecc generation Gy", E.G.y);
log_mpidump ("ecc generation Gz", E.G.z);
}
if (DBG_CIPHER)
log_debug ("choosing a random x of size %u\n", nbits);
d = gen_k (E.n, GCRY_VERY_STRONG_RANDOM);
/* Compute Q. */
point_init (&Q);
ctx = _gcry_mpi_ec_init (E.p, E.a);
_gcry_mpi_ec_mul_point (&Q, d, &E.G, ctx);
/* Copy the stuff to the key structures. */
sk->E.p = mpi_copy (E.p);
sk->E.a = mpi_copy (E.a);
sk->E.b = mpi_copy (E.b);
point_init (&sk->E.G);
point_set (&sk->E.G, &E.G);
sk->E.n = mpi_copy (E.n);
point_init (&sk->Q);
point_set (&sk->Q, &Q);
sk->d = mpi_copy (d);
/* We also return copies of G and Q in affine coordinates if
requested. */
if (g_x && g_y)
{
if (_gcry_mpi_ec_get_affine (g_x, g_y, &sk->E.G, ctx))
log_fatal ("ecc generate: Failed to get affine coordinates\n");
}
if (q_x && q_y)
{
if (_gcry_mpi_ec_get_affine (q_x, q_y, &sk->Q, ctx))
log_fatal ("ecc generate: Failed to get affine coordinates\n");
}
_gcry_mpi_ec_free (ctx);
point_free (&Q);
mpi_free (d);
curve_free (&E);
/* Now we can test our keys (this should never fail!). */
test_keys (sk, nbits - 64);
return 0;
}
/*
* void animate();
*
* This acts as the idle function, whenever the system is idle, animte() is
* called. The end of animate() forces display() to refresh
*/
void animate() {
int j;
double mass_before;
while((double) clock() == current){} // waits for next time step
current = (double) clock();
// remove tails
int k;
for( k = 0; k < tails.size(); k++) {
tails[k].life--;
if(tails[k].life <= 0) {
tails.erase(tails.begin()+k);
}
}
for(j = 0; j < all_spheres.size(); j++) {
// DECAY
double decay = ((double) rand() / RAND_MAX);
if( all_spheres[j].radius>0.0) {
if( decay <= DECAY_PROB && all_spheres[j].active) {
mass_before = get_mass(all_spheres[j].radius);
all_spheres[j].radius -= 0.00045;
mass_of_system += ( mass_before - get_mass(all_spheres[j].radius));
if(dust_shown) {
struct dust tail;
double rad = all_spheres[j].radius;
tail.pos.x = all_spheres[j].pos.x +
(((double) rand() / RAND_MAX) * (2*rad) - rad);
tail.pos.y = all_spheres[j].pos.y +
(((double) rand() / RAND_MAX) * (2*rad) - rad);
tail.pos.z = all_spheres[j].pos.z +
(((double) rand() / RAND_MAX) * (2*rad) - rad);
tail.color = all_spheres[j].color;
tail.life = 75;
tails.resize(tails.size()+1);
tails.push_back(tail);
}
}
}else{
all_spheres.erase(all_spheres.begin()+j);
balls--;
break;
}
// END DECAY
if(all_spheres[j].path == 0) { //linear paths
// advance position on vector
all_spheres[j] = move_on_vector(all_spheres[j]);
}else if(all_spheres[j].path == 1) { // bezier curves for path
if( all_spheres[j].interval < 1.0) {
// advance position on curve
move_on_curve(&all_spheres[j]);
} else {
// generate a new curve
generate_curve(&all_spheres[j]);
}
}
}
// set window and call display to refresh screen
glutSetWindow(window);
glutPostRedisplay();
}
