Added point generation:

 - Prime order points for all prime divisors of curve order (all prime subgroups)
 - Random points
 - Minimal set of generators of the whole group (one or two points)

8 files changed, 191 insertions, 16 deletions

diff --git a/src/math/curve.c b/src/math/curve.c
index 57f46e6..2ff3d8f 100644
--- a/src/math/curve.c
+++ b/src/math/curve.c
@@ -5,8 +5,9 @@
 #include "curve.h"
 #include "exhaustive/seed.h"
 #include "field.h"
+#include "point.h"
 
-curve_t *curve_new() {
+curve_t *curve_new(void) {
 	curve_t *curve = pari_malloc(sizeof(curve_t));
 	if (!curve) {
 		perror("Couldn't malloc.");
@@ -16,10 +17,29 @@ curve_t *curve_new() {
 	return curve;
 }
 
+curve_t *curve_copy(curve_t *src, curve_t *dest) {
+	if (src->seed) dest->seed = seed_copy(src->seed, dest->seed);
+	if (src->field) dest->field = gcopy(src->field);
+	if (src->a) dest->a = gcopy(src->a);
+	if (src->b) dest->b = gcopy(src->b);
+	if (src->curve) dest->curve = gcopy(src->curve);
+	if (src->order) dest->order = gcopy(src->order);
+	if (src->points) {
+		dest->points = points_new(src->npoints);
+		dest->points = points_copy(src->points, dest->points, src->npoints);
+		dest->npoints = src->npoints;
+	}
+}
+
 void curve_free(curve_t **curve) {
 	if (*curve) {
 		seed_free(&(*curve)->seed);
-		pari_free((*curve)->points);
+		if ((*curve)->points) {
+			for (size_t i = 0; i < (*curve)->npoints; ++i) {
+				point_free(&(*curve)->points[i]);
+			}
+			points_free(&(*curve)->points);
+		}
 		pari_free(*curve);
 		*curve = NULL;
 	}
@@ -82,6 +102,15 @@ GEN curve_params(curve_t *curve) {
 	if (curve->a) result = gconcat(result, field_elementi(curve->a));
 	if (curve->b) result = gconcat(result, field_elementi(curve->b));
 	if (curve->order) result = gconcat(result, gtovec(curve->order));
+	if (curve->points) {
+		for (size_t i = 0; i < curve->npoints; ++i) {
+			GEN point =
+			    gconcat(field_elementi(gel(curve->points[i]->point, 1)),
+			            field_elementi(gel(curve->points[i]->point, 2)));
+			result = gconcat(result, point);
+			result = gconcat(result, curve->points[i]->order);
+		}
+	}
 
 	return gerepilecopy(ltop, result);
 }
diff --git a/src/math/curve.h b/src/math/curve.h
index 1a8fb0b..20273b7 100644
--- a/src/math/curve.h
+++ b/src/math/curve.h
@@ -50,7 +50,15 @@ GEN curve_params(curve_t *curve);
  *
  * @return
  */
-curve_t *curve_new();
+curve_t *curve_new(void);
+
+/**
+ *
+ * @param src
+ * @param dest
+ * @return
+ */
+curve_t *curve_copy(curve_t *src, curve_t *dest);
 
 /**
  * Free a curve_t along with it's seed_t and point_ts.
diff --git a/src/math/equation.c b/src/math/equation.c
index 4e44747..1e29ee4 100644
--- a/src/math/equation.c
+++ b/src/math/equation.c
@@ -20,6 +20,7 @@ int a_random(curve_t *curve, config_t *config, ...) {
 
 int a_input(curve_t *curve, config_t *config, ...) {
 	curve->a = fread_int(in, "a:", config->bits);
+	// TODO change a to a field element here?. a t_INTMOD or a t_FFELT.
 	return 1;
 }
 
@@ -42,6 +43,7 @@ int b_random(curve_t *curve, config_t *config, ...) {
 
 int b_input(curve_t *curve, config_t *config, ...) {
 	curve->b = fread_int(in, "b:", config->bits);
+	// TODO change b to a field element here?. a t_INTMOD or a t_FFELT.
 	return 1;
 }
 
diff --git a/src/math/point.c b/src/math/point.c
index ebe6288..2cf1042 100644
--- a/src/math/point.c
+++ b/src/math/point.c
@@ -4,15 +4,64 @@
  */
 #include "point.h"
 
-point_t *point_new() {}
+point_t *point_new(void) {
+	point_t *point = pari_malloc(sizeof(point_t));
+	if (!point) {
+		perror("Couldn't malloc.");
+		exit(1);
+	}
+	memset(point, 0, sizeof(point_t));
+	return point;
+}
+
+point_t *point_copy(point_t *src, point_t *dest) {
+	if (src->point) dest->point = gcopy(src->point);
+	if (dest->point) dest->order = gcopy(src->order);
+	return dest;
+}
+
+void point_free(point_t **point) {
+	if (*point) {
+		pari_free(*point);
+		*point = NULL;
+	}
+}
+
+point_t **points_new(size_t num) {
+	point_t **points = pari_malloc(num * sizeof(point_t *));
+	if (!points) {
+		perror("Couldn't malloc.");
+		exit(1);
+	}
+	memset(points, 0, num * sizeof(point_t *));
+	return points;
+}
 
-point_t **points_new(size_t num) {}
+point_t **points_copy(point_t **src, point_t **dest, size_t num) {
+	for (size_t i = 0; i < num; ++i) {
+		dest[i] = point_new();
+		dest[i] = point_copy(src[i], dest[i]);
+	}
+	return dest;
+}
 
-void point_free(point_t **point) {}
+void points_free(point_t ***points) {
+	if (*points) {
+		pari_free(*points);
+		*points = NULL;
+	}
+}
 
-void points_free(point_t ***point) {}
+int point_random(curve_t *curve, config_t *config, ...) {
+	point_t *p = point_new();
+	p->point = genrand(curve->curve);
+	p->order = ellorder(curve->curve, p->point, NULL);
 
-int point_random(curve_t *curve, config_t *config, ...) {}
+	curve->points = points_new(1);
+	curve->points[0] = p;
+	curve->npoints = 1;
+	return 1;
+}
 
 int points_random(curve_t *curve, config_t *config, ...) {
 	va_list arg;
@@ -23,9 +72,58 @@ int points_random(curve_t *curve, config_t *config, ...) {
 	curve->points = points_new(npoints);
 	curve->npoints = npoints;
 	for (size_t i = 0; i < npoints; ++i) {
+		point_t *p = point_new();
+		p->point = genrand(curve->curve);
+		p->order = ellorder(curve->curve, p->point, NULL);
+		curve->points[i] = p;
+	}
+	return 1;
+}
+
+int points_prime(curve_t *curve, config_t *config, ...) {
+	GEN factors = Z_factor(curve->order);
+	GEN primes = gel(factors, 1);
+	long nprimes = glength(primes);
+	curve->points = points_new((size_t)nprimes);
+	curve->npoints = (size_t)nprimes;
+
+	long npoints = 0;
+	while (npoints < nprimes) {
+		GEN rand = genrand(curve->curve);
+		GEN ord = ellorder(curve->curve, rand, NULL);
+		// ord(rand) = ord
+
+		for (long i = 1; i <= nprimes; ++i) {
+			if (dvdii(ord, gel(primes, i)) && curve->points[i - 1] == NULL) {
+				// primes[i] divides ord
+				// mul = ord/primes[i]
+				GEN mul = divii(ord, gel(primes, i));
+				GEN point = ellmul(curve->curve, rand, mul);
+
+				point_t *p = point_new();
+				p->point = point;
+				p->order = ord;
+				curve->points[i - 1] = p;
+				npoints++;
+			}
+		}
 	}
+
+	return 1;
 }
 
-int points_prime(curve_t *curve, config_t *config, ...) {}
+int points_generators(curve_t *curve, config_t *config, ...) {
+	GEN generators = ellff_get_gens(curve->curve);
+	long len = glength(generators);
+	curve->points = points_new((size_t)len);
+	curve->npoints = (size_t)len;
+
+	for (long i = 1; i <= len; ++i) {
+		point_t *p = point_new();
+		p->point = gel(generators, i);
+		p->order = ellorder(curve->curve, p->point, NULL);
+		curve->points[i - 1] = p;
+	}
 
-int points_generators(curve_t *curve, config_t *config, ...) {}
\ No newline at end of file
+	return 1;
+}
\ No newline at end of file
diff --git a/src/math/point.h b/src/math/point.h
index 064dadc..ed10bdb 100644
--- a/src/math/point.h
+++ b/src/math/point.h
@@ -11,14 +11,15 @@
  *
  * @return
  */
-point_t *point_new();
+point_t *point_new(void);
 
 /**
  *
- * @param num
+ * @param src
+ * @param dest
  * @return
  */
-point_t **points_new(size_t num);
+point_t *point_copy(point_t *src, point_t *dest);
 
 /**
  *
@@ -28,6 +29,22 @@ void point_free(point_t **point);
 
 /**
  *
+ * @param num
+ * @return
+ */
+point_t **points_new(size_t num);
+
+/**
+ *
+ * @param src
+ * @param dest
+ * @param num
+ * @return
+ */
+point_t **points_copy(point_t **src, point_t **dest, size_t num);
+
+/**
+ *
  * @param point
  */
 void points_free(point_t ***point);
@@ -50,4 +67,25 @@ int point_random(curve_t *curve, config_t *config, ...);
  */
 int points_random(curve_t *curve, config_t *config, ...);
 
+/**
+ * Cauchy:
+ *   Let G be a finite group and p be a prime. If p divides the order of G, then
+ * G has an element of order p.
+ *
+ * @param curve
+ * @param config
+ * @param ...
+ * @return
+ */
+int points_prime(curve_t *curve, config_t *config, ...);
+
+/**
+ *
+ * @param curve
+ * @param config
+ * @param ...
+ * @return
+ */
+int points_generators(curve_t *curve, config_t *config, ...);
+
 #endif  // ECGEN_POINT_H
diff --git a/src/math/poly.c b/src/math/poly.c
index f888d97..6a89061 100644
--- a/src/math/poly.c
+++ b/src/math/poly.c
@@ -2719,7 +2719,7 @@ polynomial_t *poly_find(long m) {
 		return NULL;
 	}
 	polynomial_t *search_tri = ansi_trinomials;
-	polynomial_t *search_penta = ansi_trinomials;
+	polynomial_t *search_penta = ansi_pentanomials;
 	size_t len_tri = sizeof(ansi_trinomials) / sizeof(polynomial_t);
 	size_t len_penta = sizeof(ansi_pentanomials) / sizeof(polynomial_t);
 	if (m < 160 || m > 2000) {
diff --git a/src/math/random.c b/src/math/random.c
index 37fd882..44bdb27 100644
--- a/src/math/random.c
+++ b/src/math/random.c
@@ -5,7 +5,7 @@
 #include "random.h"
 #include <time.h>
 
-bool random_init() {
+bool random_init(void) {
 	pari_ulong seed = 0;
 	// Try urandom first
 	FILE *rand = fopen("/dev/urandom", "rb");
diff --git a/src/math/random.h b/src/math/random.h
index 5d3d17f..d044b90 100644
--- a/src/math/random.h
+++ b/src/math/random.h
@@ -8,7 +8,7 @@
 #include <pari/pari.h>
 #include <stdbool.h>
 
-bool random_init();
+bool random_init(void);
 
 GEN random_prime(long bits);