Add GP code interpretation as a gen_f option.

5 files changed, 253 insertions, 4 deletions

diff --git a/src/exhaustive/exhaustive.c b/src/exhaustive/exhaustive.c
index 8103f3b..30d2c47 100644
--- a/src/exhaustive/exhaustive.c
+++ b/src/exhaustive/exhaustive.c
@@ -237,8 +237,8 @@ int exhaustive_gen_retry(curve_t *curve, const config_t *cfg,
 		if (diff > 0 && validators && validators[state]) {
 			check_t *validator = validators[state];
 			for (size_t i = 0; i < validator->nchecks; ++i) {
-				int new_diff = validator->checks[i](curve, cfg, arg,
-													(offset_e)state);
+				int new_diff =
+				    validator->checks[i](curve, cfg, arg, (offset_e)state);
 				if (new_diff <= 0) {
 					diff = new_diff;
 					break;
diff --git a/src/gen/gp.c b/src/gen/gp.c
new file mode 100644
index 0000000..dff7ca1
--- /dev/null
+++ b/src/gen/gp.c
@@ -0,0 +1,120 @@
+/*
+ * ecgen, tool for generating Elliptic curve domain parameters
+ * Copyright (C) 2017 J08nY
+ */
+#include "gp.h"
+#include "exhaustive/arg.h"
+#include "io/output.h"
+#include "point.h"
+#include "seed.h"
+#include "util/bits.h"
+
+static point_t **gp_points(const curve_t *curve, GEN point_vec) {
+	long len = glength(point_vec);
+	point_t **result = points_new((size_t)len);
+
+	for (long i = 1; i <= len; ++i) {
+		point_t *point = point_new();
+		point->point = gel(point_vec, i);
+		point->order = ellorder(curve->curve, point->point, NULL);
+		result[i - 1] = point;
+	}
+	return result;
+}
+
+static point_t **gp_gens(const curve_t *curve, GEN gens_vec) {
+	point_t **result = gp_points(curve, gens_vec);
+
+	long len = glength(gens_vec);
+	for (long i = 1; i <= len; ++i) {
+		point_t *gen = result[i - 1];
+		gen->cofactor = divii(curve->order, gen->order);
+	}
+	return result;
+}
+
+GENERATOR(gp_gen) {
+	HAS_ARG(args);
+	pari_sp ltop = avma;
+	GEN closure = compile_str(args->args);
+	GEN params = zerovec(state - OFFSET_SEED);
+
+	if (state > OFFSET_SEED) {
+		if (curve->seed && curve->seed->seed) {
+			gel(params, 1) = bits_to_bitvec(curve->seed->seed);
+		}
+	}
+
+	if (state > OFFSET_FIELD) {
+		gel(params, 2) = curve->field;
+	}
+
+	if (state > OFFSET_A) {
+		gel(params, 3) = curve->a;
+	}
+
+	if (state > OFFSET_B) {
+		gel(params, 4) = curve->b;
+	}
+
+	if (state > OFFSET_CURVE) {
+		gel(params, 5) = curve->curve;
+	}
+
+	if (state > OFFSET_ORDER) {
+		gel(params, 6) = curve->order;
+	}
+
+	if (state > OFFSET_GENERATORS) {
+		GEN gens = zerovec(curve->ngens);
+		for (size_t i = 0; i < curve->ngens; ++i) {
+			gel(gens, i + 1) = curve->generators[i]->point;
+		}
+		gel(params, 7) = gens;
+	}
+
+	if (state > OFFSET_POINTS) {
+		GEN points = zerovec(curve->npoints);
+		for (size_t i = 0; i < curve->npoints; ++i) {
+			gel(points, i + 1) = curve->points[i]->point;
+		}
+		gel(params, 8) = points;
+	}
+
+	GEN res = call0(closure, zerovec(0));
+	res = call0(res, params);
+
+	res = gerepileupto(ltop, res);
+	switch (state) {
+		case OFFSET_SEED:
+			curve->seed = seed_new();
+			curve->seed->seed = bits_from_bitvec(res);
+			break;
+		case OFFSET_FIELD:
+			curve->field = res;
+			break;
+		case OFFSET_A:
+			curve->a = res;
+			break;
+		case OFFSET_B:
+			curve->b = res;
+			break;
+		case OFFSET_CURVE:
+			curve->curve = res;
+			break;
+		case OFFSET_ORDER:
+			curve->order = res;
+			break;
+		case OFFSET_GENERATORS:
+			curve->ngens = (size_t)glength(res);
+			curve->generators = gp_gens(curve, res);
+			break;
+		case OFFSET_POINTS:
+			curve->npoints = (size_t)glength(res);
+			curve->points = gp_points(curve, res);
+			break;
+		case OFFSET_END:
+			break;
+	}
+	return 1;
+}
\ No newline at end of file
diff --git a/src/gen/gp.h b/src/gen/gp.h
new file mode 100644
index 0000000..c0ee1af
--- /dev/null
+++ b/src/gen/gp.h
@@ -0,0 +1,19 @@
+/*
+ * ecgen, tool for generating Elliptic curve domain parameters
+ * Copyright (C) 2017 J08nY
+ */
+#ifndef ECGEN_GP_H
+#define ECGEN_GP_H
+
+#include "misc/types.h"
+
+/**
+ * @brief
+ * @param curve
+ * @param cfg
+ * @param args
+ * @return
+ */
+GENERATOR(gp_gen);
+
+#endif  // ECGEN_GP_H
diff --git a/src/misc/types.h b/src/misc/types.h
index 74a0aa2..d20ed2b 100644
--- a/src/misc/types.h
+++ b/src/misc/types.h
@@ -119,8 +119,9 @@ typedef struct {
  * @param state The current generation state
  * @return state diff
  */
-#define GENERATOR(gen_name) \
-	int gen_name(curve_t *curve, const config_t *cfg, arg_t *args, offset_e state)
+#define GENERATOR(gen_name)                                        \
+	int gen_name(curve_t *curve, const config_t *cfg, arg_t *args, \
+	             offset_e state)
 
 typedef GENERATOR((*gen_f));
 
diff --git a/test/src/gen/test_gp.c b/test/src/gen/test_gp.c
new file mode 100644
index 0000000..0d01a3a
--- /dev/null
+++ b/test/src/gen/test_gp.c
@@ -0,0 +1,109 @@
+/*
+ * ecgen, tool for generating Elliptic curve domain parameters
+ * Copyright (C) 2017 J08nY
+ */
+#include <criterion/criterion.h>
+#include "gen/gp.h"
+#include "test/default.h"
+#include "util/bits.h"
+
+TestSuite(gp, .init = default_setup, .fini = default_teardown);
+
+Test(gp, test_gp_seed) {
+	curve_t curve = {0};
+	config_t cfg = {};
+	arg_t arg = {.args = "() -> { return(Vecsmall([1,0])); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_SEED);
+	cr_assert_eq(ret, 1,);
+	cr_assert_not_null(curve.seed,);
+	cr_assert_not_null(curve.seed->seed,);
+	cr_assert(bits_eq(curve.seed->seed, bits_from_bin("10")),);
+}
+
+Test(gp, test_gp_field) {
+	curve_t curve = {0};
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed) -> { return(19); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_FIELD);
+	cr_assert_eq(ret, 1,);
+	cr_assert(gequal(curve.field, stoi(19)),);
+}
+
+Test(gp, test_gp_a) {
+	curve_t curve = {.field = stoi(19)};
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed, field) -> { return(Mod(3,field)); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_A);
+	cr_assert_eq(ret, 1,);
+	cr_assert(gequal(curve.a, mkintmodu(3, 19)),);
+}
+
+Test(gp, test_gp_b) {
+	curve_t curve = {.field = stoi(19), .a = mkintmodu(3, 19)};
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed, field, a) -> { return(a * 2); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_B);
+	cr_assert_eq(ret, 1,);
+	cr_assert(gequal(curve.b, mkintmodu(6, 19)),);
+}
+
+Test(gp, test_gp_curve) {
+	curve_t curve = {.field = stoi(19), .a = mkintmodu(3, 19), .b = mkintmodu(6, 19)};
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed, field, a, b) -> { return(ellinit([a,b], field)); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_CURVE);
+	cr_assert_eq(ret, 1,);
+	cr_assert(gequal(curve.curve, ellinit(mkvec2(curve.a, curve.b), curve.field, 0)),);
+}
+
+Test(gp, test_gp_order) {
+	curve_t curve = {.field = stoi(19), .a = mkintmodu(3, 19), .b = mkintmodu(6, 19),
+	.curve = ellinit(mkvec2(stoi(3), stoi(6)), stoi(19), 0)};
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed, field, a, b, curve) -> { return(ellsea(curve)); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_ORDER);
+	cr_assert_eq(ret, 1,);
+	cr_assert(gequal(ellsea(curve.curve, 0), curve.order),);
+}
+
+Test(gp, test_gp_generators) {
+	curve_t curve = {.field = stoi(19), .a = mkintmodu(3, 19), .b = mkintmodu(6, 19),
+		.curve = ellinit(mkvec2(stoi(3), stoi(6)), stoi(19), 0), .order = stoi(16)
+	};
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed, field, a, b, curve, order) -> { return(ellgenerators(curve)); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_GENERATORS);
+	cr_assert_eq(ret, 1,);
+
+	GEN ellgens = ellgenerators(curve.curve);
+	long len = glength(ellgens);
+	cr_assert_eq(len, curve.ngens,);
+	for (long i = 1; i <= len; ++i) {
+		cr_assert(gequal(gel(ellgens, i), curve.generators[i - 1]->point),);
+	}
+}
+
+Test(gp, test_gp_points) {
+	curve_t curve = {.field = stoi(19), .a = mkintmodu(3, 19), .b = mkintmodu(6, 19),
+		.curve = ellinit(mkvec2(stoi(3), stoi(6)), stoi(19), 0), .order = stoi(16),
+	};
+	point_t gen = {.point = mkvec2(mkintmodu(4,19), mkintmodu(14,19))};
+	point_t *generators[1] = {&gen};
+	curve.generators = generators;
+	curve.ngens = 1;
+
+	config_t cfg = {};
+	arg_t arg = {.args = "(seed, field, a, b, curve, order, gens) -> { return([ellmul(curve,gens[1],2)]); }", .nargs = 1};
+
+	int ret = gp_gen(&curve, &cfg, &arg, OFFSET_POINTS);
+	cr_assert_eq(ret, 1,);
+	cr_assert_eq(curve.npoints, 1,);
+	cr_assert(gequal(curve.points[0]->point, ellmul(curve.curve, gen.point, stoi(2))),);
+}
\ No newline at end of file