12 files changed, 461 insertions, 355 deletions

diff --git a/src/exhaustive/ansi.c b/src/exhaustive/ansi.c
new file mode 100644
index 0000000..0477227
--- /dev/null
+++ b/src/exhaustive/ansi.c
@@ -0,0 +1,134 @@
+
+#include <io/config.h>
+#include "ansi.h"
+#include "gen/seed.h"
+#include "util/bits.h"
+#include "util/memory.h"
+#include "io/output.h"
+
+
+bool ansi_seed_valid(const char *hex_str) {
+	size_t len = strlen(hex_str);
+	if (len < 40) {
+		return false;
+	}
+	const char *str_start = hex_str;
+	if (hex_str[0] == '0' && (hex_str[1] == 'x' || hex_str[1] == 'X')) {
+		str_start = hex_str + 2;
+	}
+	while (*str_start != 0) {
+		char c = *str_start++;
+		if (!isxdigit(c)) return false;
+	}
+	return true;
+}
+
+static bits_t *seed_stoi(const char *cstr) {
+	const char *seed_str = cstr;
+	const char *prefix = strstr(cstr, "0x");
+	if (prefix != NULL) seed_str = prefix + 2;
+	return bits_from_hex(seed_str);
+}
+
+static void seed_hash(seed_t *seed) {
+	seed->hash20 = try_malloc(20);
+	bits_sha1(seed->seed, seed->hash20);
+}
+
+static void seed_W(seed_t *seed, const config_t *cfg) {
+	pari_sp ltop = avma;
+	GEN t = utoi(cfg->bits);
+	GEN s = floorr(rdivii(subis(t, 1), stoi(160), DEFAULTPREC));
+	GEN h = subii(t, mulis(s, 160));
+	pari_printf("bits = %lu, t = %Pi, s = %Pi, h = %Pi\n", cfg->bits, t, s, h);
+
+	bits_t *c0 = bits_from_raw(seed->hash20, 160);
+	printf("H = %s, len = %lu alloc = %lu\n", bits_to_hex(c0), c0->bitlen,
+		   c0->allocated);
+	bits_shortenz(c0, 160 - itos(h));
+	printf("c0 = %s\n", bits_to_hex(c0));
+
+	bits_t *W0 = bits_copy(c0);
+	SET_BIT(W0->bits, 0, 0);
+
+	long is = itos(s);
+	seed->W = bits_copy(W0);
+	GEN two_g = int2n(seed->seed->bitlen);
+	for (long i = 1; i <= is; ++i) {
+		printf("doing i = %li\n", i);
+		pari_sp btop = avma;
+		GEN inner = bits_to_i(seed->seed);
+		inner = addis(inner, i);
+		inner = modii(inner, two_g);
+
+		bits_t *to_hash = bits_from_i(inner);
+		unsigned char hashout[20];
+		bits_sha1(to_hash, hashout);
+		bits_t *Wi = bits_from_raw(hashout, 160);
+		bits_concatz(seed->W, Wi, NULL);
+		bits_free(&to_hash);
+		bits_free(&Wi);
+		avma = btop;
+	}
+
+	bits_free(&c0);
+	bits_free(&W0);
+	avma = ltop;
+}
+
+GENERATOR(ansi_gen_seed_random) {
+	seed_t *seed = seed_new();
+	seed->seed = bits_from_i(random_int(160));
+	seed_hash(seed);
+	seed_W(seed, cfg);
+	curve->seed = seed;
+	return 1;
+}
+
+GENERATOR(ansi_gen_seed_argument) {
+	seed_t *seed = seed_new();
+	seed->seed = seed_stoi(cfg->seed);
+	seed_hash(seed);
+	seed_W(seed, cfg);
+	curve->seed = seed;
+	return 1;
+}
+
+GENERATOR(ansi_gen_seed_input) {
+	pari_sp ltop = avma;
+
+	GEN str = input_string("seed:");
+	const char *cstr = GSTR(str);
+	if (!ansi_seed_valid(cstr)) {
+		fprintf(err, "SEED must be at least 160 bits(40 hex characters).\n");
+		avma = ltop;
+		return 0;
+	}
+
+	seed_t *seed = seed_new();
+	seed->seed = seed_stoi(cstr);
+	seed_hash(seed);
+	seed_W(seed, cfg);
+	curve->seed = seed;
+	return 1;
+}
+
+static GENERATOR(ansi_gen_equation_fp) {
+	return 0;
+}
+
+static GENERATOR(ansi_gen_equation_f2m) {
+	return 0;
+}
+
+GENERATOR(ansi_gen_equation) {
+	switch (cfg->field) {
+		case FIELD_PRIME:
+			return ansi_gen_equation_fp(curve, cfg, args);
+		case FIELD_BINARY:
+			return ansi_gen_equation_f2m(curve, cfg, args);
+		default:
+			pari_err_BUG("Field not prime or binary?");
+			return INT_MIN; /* NOT REACHABLE */
+	}
+}
diff --git a/src/exhaustive/ansi.h b/src/exhaustive/ansi.h
new file mode 100644
index 0000000..8bd39fb
--- /dev/null
+++ b/src/exhaustive/ansi.h
@@ -0,0 +1,45 @@
+
+#ifndef ECGEN_ANSI_H
+#define ECGEN_ANSI_H
+
+#include "gen/types.h"
+
+bool ansi_seed_valid(const char *hex_str);
+
+/**
+ * @brief
+ * @param curve A curve_t being generated
+ * @param cfg An application config
+ * @param args unused
+ * @return state diff
+ */
+GENERATOR(ansi_gen_seed_random);
+
+/**
+ * @brief
+ * @param curve A curve_t being generated
+ * @param cfg An application config
+ * @param args unused
+ * @return state diff
+ */
+GENERATOR(ansi_gen_seed_argument);
+
+/**
+ * @brief
+ * @param curve A curve_t being generated
+ * @param cfg An application config
+ * @param args unused
+ * @return state diff
+ */
+GENERATOR(ansi_gen_seed_input);
+
+/**
+ * @brief
+ * @param curve A curve_t being generated
+ * @param cfg An application config
+ * @param args unused
+ * @return state diff
+ */
+GENERATOR(ansi_gen_equation);
+
+#endif //ECGEN_ANSI_H
diff --git a/src/exhaustive/exhaustive.c b/src/exhaustive/exhaustive.c
index 3553efb..ff30ecb 100644
--- a/src/exhaustive/exhaustive.c
+++ b/src/exhaustive/exhaustive.c
@@ -4,13 +4,13 @@
  */
 #include "exhaustive.h"
 #include "anomalous.h"
+#include "ansi.h"
 #include "gen/curve.h"
 #include "gen/equation.h"
 #include "gen/field.h"
 #include "gen/gens.h"
 #include "gen/order.h"
 #include "gen/point.h"
-#include "gen/seed.h"
 #include "io/output.h"
 #include "util/memory.h"
 
@@ -18,17 +18,17 @@ static void exhaustive_ginit(gen_t *generators, const config_t *cfg) {
 	if (cfg->from_seed) {
 		// setup ANSI X9.62 generators
 		if (cfg->seed) {
-			generators[OFFSET_SEED] = &seed_gen_argument;
+			generators[OFFSET_SEED] = &ansi_gen_seed_argument;
 		} else {
 			if (cfg->random) {
-				generators[OFFSET_SEED] = &seed_gen_random;
+				generators[OFFSET_SEED] = &ansi_gen_seed_random;
 			} else {
-				generators[OFFSET_SEED] = &seed_gen_input;
+				generators[OFFSET_SEED] = &ansi_gen_seed_input;
 			}
 		}
-		generators[OFFSET_A] = &a_gen_seed;
-		generators[OFFSET_B] = &b_gen_seed;
-		generators[OFFSET_CURVE] = &curve_gen_seed;
+		generators[OFFSET_A] = &gen_skip;
+		generators[OFFSET_B] = &ansi_gen_equation;
+		generators[OFFSET_CURVE] = &curve_gen_nonzero;
 	} else {
 		// setup normal generators
 		generators[OFFSET_SEED] = &gen_skip;
diff --git a/src/gen/curve.c b/src/gen/curve.c
index ea5ed95..80483a6 100644
--- a/src/gen/curve.c
+++ b/src/gen/curve.c
@@ -2,6 +2,7 @@
  * ecgen, tool for generating Elliptic curve domain parameters
  * Copyright (C) 2017 J08nY
  */
+#include <io/config.h>
 #include "curve.h"
 #include "point.h"
 #include "seed.h"
@@ -130,29 +131,6 @@ GENERATOR(curve_gen_nonzero) {
 	}
 }
 
-static int curve_gen_seed_fp(curve_t *curve, const config_t *cfg, arg_t *args) {
-	// TODO implement
-	return INT_MIN;
-}
-
-static int curve_gen_seed_f2m(curve_t *curve, const config_t *cfg,
-                              arg_t *args) {
-	// TODO implement
-	return INT_MIN;
-}
-
-GENERATOR(curve_gen_seed) {
-	switch (typ(curve->field)) {
-		case t_INT:
-			return curve_gen_seed_fp(curve, cfg, args);
-		case t_FFELT:
-			return curve_gen_seed_f2m(curve, cfg, args);
-		default:
-			pari_err_TYPE("curve_gen_seed", curve->field);
-			return INT_MIN; /* NOT REACHABLE */
-	}
-}
-
 UNROLL(curve_unroll) {
 	if (curve->curve) {
 		obj_free(curve->curve);
diff --git a/src/gen/curve.h b/src/gen/curve.h
index 2e7651f..384c8ca 100644
--- a/src/gen/curve.h
+++ b/src/gen/curve.h
@@ -35,18 +35,6 @@ GENERATOR(curve_gen_any);
  */
 GENERATOR(curve_gen_nonzero);
 
-/**
- * GENERATOR(gen_t)
- * Creates a curve GEN in curve_t curve from field, a and b. Using the ANSI
- * X9.62 verifiably random algorithm.
- * Succeeds if a curve exists(non-zero discriminant).
- *
- * @param curve A curve_t being generated
- * @param cfg An application config
- * @param args unused
- * @return state diff
- */
-GENERATOR(curve_gen_seed);
 
 /**
  *
diff --git a/src/gen/equation.c b/src/gen/equation.c
index 9524df7..33d41a9 100644
--- a/src/gen/equation.c
+++ b/src/gen/equation.c
@@ -56,10 +56,6 @@ GENERATOR(a_gen_one) {
 	return 1;
 }
 
-GENERATOR(a_gen_seed) {
-	// TODO implement
-	return INT_MIN;
-}
 
 GENERATOR(b_gen_random) {
 	curve->b = genrand(curve->field);
@@ -111,11 +107,6 @@ GENERATOR(b_gen_one) {
 	return 1;
 }
 
-GENERATOR(b_gen_seed) {
-	// TODO implement
-	return INT_MIN;
-}
-
 void equation_quit(void) {
 	if (a && isclone(a)) {
 		gunclone(a);
diff --git a/src/gen/seed.c b/src/gen/seed.c
index 9d0359f..8d6c7cf 100644
--- a/src/gen/seed.c
+++ b/src/gen/seed.c
@@ -4,7 +4,9 @@
  */
 
 #include "seed.h"
+#include <io/config.h>
 #include "io/output.h"
+#include "types.h"
 #include "util/bits.h"
 #include "util/memory.h"
 
@@ -53,103 +55,3 @@ void seed_free(seed_t **seed) {
 	}
 }
 
-bool seed_valid(const char *hex_str) {
-	size_t len = strlen(hex_str);
-	if (len < 40) {
-		return false;
-	}
-	const char *str_start = hex_str;
-	if (hex_str[0] == '0' && (hex_str[1] == 'x' || hex_str[1] == 'X')) {
-		str_start = hex_str + 2;
-	}
-	while (*str_start != 0) {
-		char c = *str_start++;
-		if (!isxdigit(c)) return false;
-	}
-	return true;
-}
-
-static bits_t *seed_stoi(const char *cstr) {
-	const char *seed_str = cstr;
-	const char *prefix = strstr(cstr, "0x");
-	if (prefix != NULL) seed_str = prefix + 2;
-	return bits_from_hex(seed_str);
-}
-
-static void seed_hash(seed_t *seed) {
-	seed->hash20 = try_malloc(20);
-	bits_sha1(seed->seed, seed->hash20);
-}
-
-static void seed_W(seed_t *seed, const config_t *cfg) {
-	pari_sp ltop = avma;
-	GEN t = utoi(cfg->bits);
-	GEN s = floorr(rdivii(subis(t, 1), stoi(160), DEFAULTPREC));
-	GEN h = subii(t, mulis(s, 160));
-
-	bits_t *c0 = bits_from_raw(seed->hash20, 160);
-	bits_shortenz(c0, 160 - itos(h));
-
-	bits_t *W0 = bits_copy(c0);
-	SET_BIT(W0->bits, 0, 0);
-
-	long is = itos(s);
-	seed->W = bits_copy(W0);
-	GEN two_g = int2n(seed->seed->bitlen);
-	for (long i = 1; i <= is; ++i) {
-		pari_sp btop = avma;
-		GEN inner = bits_to_i(seed->seed);
-		inner = addis(inner, i);
-		inner = modii(inner, two_g);
-
-		bits_t *to_hash = bits_from_i(inner);
-		unsigned char hashout[20];
-		bits_sha1(to_hash, hashout);
-		bits_t *Wi = bits_from_raw(hashout, 160);
-		bits_concatz(seed->W, Wi, NULL);
-		bits_free(&to_hash);
-		bits_free(&Wi);
-		avma = btop;
-	}
-
-	bits_free(&c0);
-	bits_free(&W0);
-	avma = ltop;
-}
-
-GENERATOR(seed_gen_random) {
-	seed_t *seed = seed_new();
-	seed->seed = bits_from_i(random_int(160));
-	seed_hash(seed);
-	seed_W(seed, cfg);
-	curve->seed = seed;
-	return 1;
-}
-
-GENERATOR(seed_gen_argument) {
-	seed_t *seed = seed_new();
-	seed->seed = seed_stoi(cfg->seed);
-	seed_hash(seed);
-	seed_W(seed, cfg);
-	curve->seed = seed;
-	return 1;
-}
-
-GENERATOR(seed_gen_input) {
-	pari_sp ltop = avma;
-
-	GEN str = input_string("seed:");
-	const char *cstr = GSTR(str);
-	if (!seed_valid(cstr)) {
-		fprintf(err, "SEED must be at least 160 bits(40 hex characters).\n");
-		avma = ltop;
-		return 0;
-	}
-
-	seed_t *seed = seed_new();
-	seed->seed = seed_stoi(cstr);
-	seed_hash(seed);
-	seed_W(seed, cfg);
-	curve->seed = seed;
-	return 1;
-}
diff --git a/src/gen/seed.h b/src/gen/seed.h
index 1cd466d..e6499b8 100644
--- a/src/gen/seed.h
+++ b/src/gen/seed.h
@@ -53,38 +53,5 @@ seed_t *seed_new_clone(const seed_t *src);
  */
 void seed_free(seed_t **seed);
 
-/**
- * @brief
- * @param hex_str
- * @return
- */
-bool seed_valid(const char *hex_str);
-
-/**
- * @brief
- * @param curve A curve_t being generated
- * @param cfg An application config
- * @param args unused
- * @return state diff
- */
-GENERATOR(seed_gen_random);
-
-/**
- * @brief
- * @param curve A curve_t being generated
- * @param cfg An application config
- * @param args unused
- * @return state diff
- */
-GENERATOR(seed_gen_argument);
-
-/**
- * @brief
- * @param curve A curve_t being generated
- * @param cfg An application config
- * @param args unused
- * @return state diff
- */
-GENERATOR(seed_gen_input);
 
 #endif  // ECGEN_SEED_H
diff --git a/src/io/cli.c b/src/io/cli.c
index dbffd89..960c827 100644
--- a/src/io/cli.c
+++ b/src/io/cli.c
@@ -6,7 +6,7 @@
 #include <string.h>
 #include <unistd.h>
 #include "config.h"
-#include "gen/seed.h"
+#include "exhaustive/ansi.h"
 
 char cli_doc[] =
     "ecgen, tool for generating Elliptic curve domain parameters.\v(C) 2017 "
@@ -201,7 +201,7 @@ error_t cli_parse(int key, char *arg, struct argp_state *state) {
 		case OPT_SEED:
 			cfg->from_seed = true;
 			if (arg) {
-				if (!seed_valid(arg)) {
+				if (!ansi_seed_valid(arg)) {
 					argp_failure(
 					    state, 1, 0,
 					    "SEED must be at least 160 bits (40 characters).");
diff --git a/src/util/bits.c b/src/util/bits.c
index ab8180b..1573308 100644
--- a/src/util/bits.c
+++ b/src/util/bits.c
@@ -10,8 +10,7 @@
 bits_t *bits_new(size_t bit_len) {
 	bits_t *result = try_calloc(sizeof(bits_t));
 	size_t byte_len = BYTE_LEN(bit_len);
-	if (byte_len > 0)
-		result->bits = try_calloc(byte_len);
+	if (byte_len > 0) result->bits = try_calloc(byte_len);
 	result->allocated = byte_len;
 	result->bitlen = bit_len;
 	return result;
@@ -83,8 +82,7 @@ bits_t *bits_from_raw(const unsigned char *bits, size_t bit_len) {
 	bits_t *result = try_calloc(sizeof(bits_t));
 	result->bitlen = bit_len;
 	result->allocated = BYTE_LEN(bit_len);
-	if (bit_len > 0)
-		result->bits = try_memdup(bits, result->allocated);
+	if (bit_len > 0) result->bits = try_memdup(bits, result->allocated);
 	return result;
 }
 
diff --git a/test/src/exhaustive/test_ansi.c b/test/src/exhaustive/test_ansi.c
new file mode 100644
index 0000000..de96b93
--- /dev/null
+++ b/test/src/exhaustive/test_ansi.c
@@ -0,0 +1,268 @@
+/*
+ * ecgen, tool for generating Elliptic curve domain parameters
+ * Copyright (C) 2017 J08nY
+ */
+
+#include <criterion/criterion.h>
+#include <criterion/parameterized.h>
+#include <gen/types.h>
+#include "math/poly.h"
+#include "exhaustive/ansi.h"
+#include "gen/seed.h"
+#include "test/default.h"
+#include "test/memory.h"
+#include "test/input.h"
+#include "test/output.h"
+#include "util/bits.h"
+#include "util/memory.h"
+
+void ansi_suite_setup(void) {
+	default_setup();
+	input_setup();
+	output_setup();
+}
+
+void ansi_suite_teardown(void) {
+	default_teardown();
+	input_teardown();
+	output_teardown();
+}
+
+TestSuite(ansi, .init = ansi_suite_setup, .fini = ansi_suite_teardown);
+
+Test(ansi, test_seed_random) {
+	curve_t curve = {};
+	config_t cfg = {.bits = 256};
+	int ret = ansi_gen_seed_random(&curve, &cfg, NULL);
+
+	cr_assert_eq(ret, 1, );
+	cr_assert_not_null(curve.seed, );
+
+	seed_free(&curve.seed);
+}
+
+Test(ansi, test_seed_argument) {
+	curve_t curve = {};
+	char *seed = "abcdefabcdefabcdefabcdefabcdefabcdefabcd";
+	config_t cfg = {.seed = seed, .bits = 256};
+	int ret = ansi_gen_seed_argument(&curve, &cfg, NULL);
+
+	cr_assert_eq(ret, 1, );
+	cr_assert_not_null(curve.seed, );
+	char *hex = bits_to_hex(curve.seed->seed);
+	cr_assert_str_eq(hex, seed, );
+
+	try_free(hex);
+	seed_free(&curve.seed);
+}
+
+Test(ansi, test_seed_argument_hex) {
+	curve_t curve = {};
+	char *seed = "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd";
+	config_t cfg = {.seed = seed, .bits = 256};
+	int ret = ansi_gen_seed_argument(&curve, &cfg, NULL);
+
+	cr_assert_eq(ret, 1, );
+	cr_assert_not_null(curve.seed, );
+	char *hex = bits_to_hex(curve.seed->seed);
+	cr_assert_str_eq(hex, seed + 2, );
+
+	try_free(hex);
+	seed_free(&curve.seed);
+}
+
+Test(ansi, test_seed_input) {
+	curve_t curve = {};
+	char *seed = "abcdefabcdefabcdefabcdefabcdefabcdefabcd";
+	config_t cfg = {.bits = 256};
+	fprintf(write_in, "%s\n", seed);
+	int ret = ansi_gen_seed_input(&curve, &cfg, NULL);
+
+	cr_assert_eq(ret, 1, );
+	cr_assert_not_null(curve.seed, );
+	char *hex = bits_to_hex(curve.seed->seed);
+	cr_assert_str_eq(hex, seed, );
+
+	try_free(hex);
+	seed_free(&curve.seed);
+}
+
+Test(ansi, test_seed_input_short) {
+	curve_t curve = {};
+	char *seed = "abcdef";
+	config_t cfg = {};
+	fprintf(write_in, "%s\n", seed);
+	int ret = ansi_gen_seed_input(&curve, &cfg, NULL);
+
+	cr_assert_eq(ret, 0, );
+}
+
+struct prime_params {
+	size_t bits;
+	char *p;
+	char *seed;
+	char *r;
+	char *a;
+	char *b;
+};
+
+void prime_params_cleanup(struct criterion_test_params *ctp) {
+	struct prime_params *params = (struct prime_params *)ctp->params;
+	cr_free(params->p);
+	cr_free(params->seed);
+	cr_free(params->r);
+	cr_free(params->a);
+	cr_free(params->b);
+}
+
+ParameterizedTestParameters(ansi, test_seed_prime_examples) {
+	static struct prime_params params[7] = {};
+	// Taken from ANSI X9.62 J.5.1 - J.5.3; p. 115 - 117
+	params[0].bits = 192;
+	params[0].p = cr_strdup("fffffffffffffffffffffffffffffffeffffffffffffffff");
+	params[0].seed = cr_strdup("3045AE6FC8422F64ED579528D38120EAE12196D5");
+	params[0].r = cr_strdup("3099D2BBBFCB2538542DCD5FB078B6EF5F3D6FE2C745DE65");
+	params[0].a = cr_strdup("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC");
+	params[0].b = cr_strdup("64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1");
+	params[1].bits = 192;
+	params[1].p = cr_strdup("fffffffffffffffffffffffffffffffeffffffffffffffff");
+	params[1].seed = cr_strdup("31A92EE2029FD10D901B113E990710F0D21AC6B6");
+	params[1].r = cr_strdup("15038D1D2E1CAFEE0299F3011C1DC75B3C2A86E135DB1E6B");
+	params[1].a = cr_strdup("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC");
+	params[1].b = cr_strdup("CC22D6DFB95C6B25E49C0D6364A4E5980C393AA21668D953");
+	params[2].bits = 192;
+	params[2].p = cr_strdup("fffffffffffffffffffffffffffffffeffffffffffffffff");
+	params[2].seed = cr_strdup("C469684435DEB378C4B65CA9591E2A5763059A2E");
+	params[2].r = cr_strdup("25191F95024D839546D9A3375639A9967D52F1373BC4EE0B");
+	params[2].a = cr_strdup("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC");
+	params[2].b = cr_strdup("22123DC2395A05CAA7423DAECCC94760A7D462256BD56916");
+	params[3].bits = 239;
+	params[3].p = cr_strdup("7fffffffffffffffffffffff7fffffffffff8000000000007fffffffffff");
+	params[3].seed = cr_strdup("E43BB460F0B80CC0C0B075798E948060F8321B7D");
+	params[3].r = cr_strdup("28B85EC1ECC19EFE769EB741A6D1BA29476AA5A8F2610957D6EFE78D3783");
+	params[3].a = cr_strdup("7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC");
+	params[3].b = cr_strdup("6B016C3BDCF18941D0D654921475CA71A9DB2FB27D1D37796185C2942C0A");
+	params[4].bits = 239;
+	params[4].p = cr_strdup("7fffffffffffffffffffffff7fffffffffff8000000000007fffffffffff");
+	params[4].seed = cr_strdup("E8B4011604095303CA3B8099982BE09FCB9AE616");
+	params[4].r = cr_strdup("1DF491E44E7CCAF4D1EAD8A6B90DAE09E0D33F2C6CFE7A6BA76E86713D52");
+	params[4].a = cr_strdup("7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC");
+	params[4].b = cr_strdup("617FAB6832576CBBFED50D99F0249C3FEE58B94BA0038C7AE84C8C832F2C");
+	params[5].bits = 239;
+	params[5].p = cr_strdup("7fffffffffffffffffffffff7fffffffffff8000000000007fffffffffff");
+	params[5].seed = cr_strdup("7D7374168FFE3471B60A857686A19475D3BFA2FF");
+	params[5].r = cr_strdup("3A4F9DC9A6CEFD5F9D1193B9C9968C202430003C2819C2E498618DC58330");
+	params[5].a = cr_strdup("7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC");
+	params[5].b = cr_strdup("255705FA2A306654B1F4CB03D6A750A30C250102D4988717D9BA15AB6D3E");
+	params[6].bits = 256;
+	params[6].p = cr_strdup("ffffffff00000001000000000000000000000000ffffffffffffffffffffffff");
+	params[6].seed = cr_strdup("C49D360886E704936A6678E1139D26B7819F7E90");
+	params[6].r = cr_strdup("7EFBA1662985BE9403CB055C75D4F7E0CE8D84A9C5114ABCAF3177680104FA0D");
+	params[6].a = cr_strdup("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC");
+	params[6].b = cr_strdup("5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B");
+
+	size_t nb_params = sizeof(params) / sizeof(struct prime_params);
+	return cr_make_param_array(struct prime_params, params, nb_params, NULL);
+}
+ParameterizedTest(struct prime_params *param, ansi, test_seed_prime_examples) {
+	//TODO: implement the test
+	config_t cfg = {};
+	cfg.bits = param->bits;
+	curve_t curve = {};
+}
+
+struct binary_params {
+	size_t bits;
+	polynomial_t field;
+	char *seed;
+	char *a;
+	char *b;
+};
+
+void binary_params_cleanup(struct criterion_test_params *ctp) {
+	struct binary_params *params = (struct binary_params *)ctp->params;
+	cr_free(params->seed);
+	cr_free(params->a);
+	cr_free(params->b);
+}
+
+ParameterizedTestParameters(ansi, test_seed_binary_examples) {
+	static struct binary_params params[10] = {};
+	polynomial_t p163 = {163, 9, 3, 2};
+	params[0].bits = 163;
+	params[0].field = p163;
+	params[0].seed = cr_strdup("D2C0FB15760860DEF1EEF4D696E6768756151754");
+	params[0].a = cr_strdup("072546B5435234A422E0789675F432C89435DE5242");
+	params[0].b = cr_strdup("00C9517D06D5240D3CFF38C74B20B6CD4D6F9DD4D9");
+	params[1].bits = 163,
+	params[1].field = p163;
+	params[1].seed = cr_strdup("53814C050D44D696E67687561517580CA4E29FFD");
+	params[1].a = cr_strdup("0108B39E77C4B108BED981ED0E890E117C511CF072");
+	params[1].b = cr_strdup("0667ACEB38AF4E488C407433FFAE4F1C811638DF20");
+	params[2].bits = 163;
+	params[2].field = p163;
+	params[2].seed = cr_strdup("50CBF1D95CA94D696E676875615175F16A36A3B8");
+	params[2].a = cr_strdup("07A526C63D3E25A256A007699F5447E32AE456B50E");
+	params[2].b = cr_strdup("03F7061798EB99E238FD6F1BF95B48FEEB4854252B");
+	polynomial_t p191 = {191, 10};
+	params[3].bits = 191;
+	params[3].field = p191;
+	params[3].seed = cr_strdup("4E13CA542744D696E67687561517552F279A8C84");
+	params[3].a = cr_strdup("2866537B676752636A68F56554E12640276B649EF7526267");
+	params[3].b = cr_strdup("2E45EF571F00786F67B0081B9495A3D95462F5DE0AA185EC");
+	params[4].bits = 191;
+	params[4].field = p191;
+	params[4].seed = cr_strdup("0871EF2FEF24D696E6768756151758BEE0D95C15");
+	params[4].a = cr_strdup("401028774D7777C7B7666D1366EA432071274F89FF01E718");
+	params[4].b = cr_strdup("0620048D28BCBD03B6249C99182B7C8CD19700C362C46A01");
+	params[5].bits = 191;
+	params[5].field = p191;
+	params[5].seed = cr_strdup("E053512DC684D696E676875615175067AE786D1F");
+	params[5].a = cr_strdup("6C01074756099122221056911C77D77E77A777E7E7E77FCB");
+	params[5].b = cr_strdup("71FE1AF926CF847989EFEF8DB459F66394D90F32AD3F15E8");
+	polynomial_t p239 = {239, 37};
+	params[6].bits = 239;
+	params[6].field = p239;
+	params[6].seed = cr_strdup("D34B9A4D696E676875615175CA71B920BFEFB05D");
+	params[6].a = cr_strdup("32010857077C5431123A46B808906756F543423E8D27877578125778AC76");
+	params[6].b = cr_strdup("790408F2EEDAF392B012EDEFB3392F30F4327C0CA3F31FC383C422AA8C16");
+	params[7].bits = 239;
+	params[7].field = p239;
+	params[7].seed = cr_strdup("2AA6982FDFA4D696E676875615175D266727277D");
+	params[7].a = cr_strdup("4230017757A767FAE42398569B746325D45313AF0766266479B75654E65F");
+	params[7].b = cr_strdup("5037EA654196CFF0CD82B2C14A2FCF2E3FF8775285B545722F03EACDB74B");
+	params[8].bits = 239;
+	params[8].field = p239;
+	params[8].seed = cr_strdup("9E076F4D696E676875615175E11E9FDD77F92041");
+	params[8].a = cr_strdup("01238774666A67766D6676F778E676B66999176666E687666D8766C66A9F");
+	params[8].b = cr_strdup("6A941977BA9F6A435199ACFC51067ED587F519C5ECB541B8E44111DE1D40");
+	polynomial_t p359 = {359, 69};
+	params[9].bits = 359;
+	params[9].field = p359;
+	params[9].seed = cr_strdup("2B354920B724D696E67687561517585BA1332DC6");
+	params[9].a = cr_strdup("5667676A654B20754F356EA92017D946567C46675556F19556A04616B567D223A5E05656FB549016A96656A557");
+	params[9].b = cr_strdup("2472E2D0197C49363F1FE7F5B6DB075D52B6947D135D8CA445805D39BC345626089687742B6329E70680231988");
+
+	size_t nb_params = sizeof(params) / sizeof(struct binary_params);
+	//size_t nb_params = 1;
+	return cr_make_param_array(struct binary_params, params, nb_params, binary_params_cleanup);
+}
+ParameterizedTest(struct binary_params *param, ansi, test_seed_binary_examples) {
+	config_t cfg = {};
+	cfg.bits = param->bits;
+	cfg.field = FIELD_BINARY;
+	cfg.seed = param->seed;
+	curve_t curve = {};
+	curve.field = poly_gen(&param->field);
+
+	int ret = ansi_gen_seed_argument(&curve, &cfg, NULL);
+	cr_assert_eq(ret, 1,);
+	bits_t *b = bits_from_hex(param->b);
+
+	//TODO: this is not a correct comparison, need to store c0 from the algo as well.
+	printf("%s %s\n", bits_to_hex(curve.seed->W), param->b);
+	cr_assert(bits_eq(b, curve.seed->W),);
+
+	bits_free(&b);
+	seed_free(&curve.seed);
+}
\ No newline at end of file
diff --git a/test/src/gen/test_seed.c b/test/src/gen/test_seed.c
deleted file mode 100644
index 1bd9186..0000000
--- a/test/src/gen/test_seed.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * ecgen, tool for generating Elliptic curve domain parameters
- * Copyright (C) 2017 J08nY
- */
-
-#include <criterion/criterion.h>
-#include <criterion/parameterized.h>
-#include <io/config.h>
-#include "gen/seed.h"
-#include "test/default.h"
-#include "test/input.h"
-#include "test/output.h"
-#include "util/bits.h"
-#include "util/memory.h"
-
-void seed_suite_setup(void) {
-	default_setup();
-	input_setup();
-	output_setup();
-}
-
-void seed_suite_teardown(void) {
-	default_teardown();
-	input_teardown();
-	output_teardown();
-}
-
-TestSuite(seed, .init = seed_suite_setup, .fini = seed_suite_teardown);
-
-Test(seed, test_seed_random) {
-	curve_t curve = {};
-	config_t cfg = {.bits = 256};
-	int ret = seed_gen_random(&curve, &cfg, NULL);
-
-	cr_assert_eq(ret, 1, );
-	cr_assert_not_null(curve.seed, );
-
-	seed_free(&curve.seed);
-}
-
-Test(seed, test_seed_argument) {
-	curve_t curve = {};
-	char *seed = "abcdefabcdefabcdefabcdefabcdefabcdefabcd";
-	config_t cfg = {.seed = seed, .bits = 256};
-	int ret = seed_gen_argument(&curve, &cfg, NULL);
-
-	cr_assert_eq(ret, 1, );
-	cr_assert_not_null(curve.seed, );
-	char *hex = bits_to_hex(curve.seed->seed);
-	cr_assert_str_eq(hex, seed, );
-
-	try_free(hex);
-	seed_free(&curve.seed);
-}
-
-Test(seed, test_seed_argument_hex) {
-	curve_t curve = {};
-	char *seed = "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd";
-	config_t cfg = {.seed = seed, .bits = 256};
-	int ret = seed_gen_argument(&curve, &cfg, NULL);
-
-	cr_assert_eq(ret, 1, );
-	cr_assert_not_null(curve.seed, );
-	char *hex = bits_to_hex(curve.seed->seed);
-	cr_assert_str_eq(hex, seed + 2, );
-
-	try_free(hex);
-	seed_free(&curve.seed);
-}
-
-Test(seed, test_seed_input) {
-	curve_t curve = {};
-	char *seed = "abcdefabcdefabcdefabcdefabcdefabcdefabcd";
-	config_t cfg = {.bits = 256};
-	fprintf(write_in, "%s\n", seed);
-	int ret = seed_gen_input(&curve, &cfg, NULL);
-
-	cr_assert_eq(ret, 1, );
-	cr_assert_not_null(curve.seed, );
-	char *hex = bits_to_hex(curve.seed->seed);
-	cr_assert_str_eq(hex, seed, );
-
-	try_free(hex);
-	seed_free(&curve.seed);
-}
-
-Test(seed, test_seed_input_short) {
-	curve_t curve = {};
-	char *seed = "abcdef";
-	config_t cfg = {};
-	fprintf(write_in, "%s\n", seed);
-	int ret = seed_gen_input(&curve, &cfg, NULL);
-
-	cr_assert_eq(ret, 0, );
-}
-
-struct example_params {
-	size_t bits;
-	char *p;
-	char *seed;
-	char *r;
-	char *a;
-	char *b;
-};
-
-ParameterizedTestParameters(seed, test_seed_prime_examples) {
-	static struct example_params params[] = {
-		// Taken from ANSI X9.62 J.5.1 - J.5.3; p. 115 - 117
-		{.bits = 192,
-			.p = "fffffffffffffffffffffffffffffffeffffffffffffffff",
-			.seed = "3045AE6FC8422F64ED579528D38120EAE12196D5",
-		    .r = "3099D2BBBFCB2538542DCD5FB078B6EF5F3D6FE2C745DE65",
-		    .a = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
-		    .b = "64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1"},
-		{.bits = 192,
-			.p = "fffffffffffffffffffffffffffffffeffffffffffffffff",
-			.seed = "31A92EE2029FD10D901B113E990710F0D21AC6B6",
-			.r = "15038D1D2E1CAFEE0299F3011C1DC75B3C2A86E135DB1E6B",
-			.a = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
-			.b = "CC22D6DFB95C6B25E49C0D6364A4E5980C393AA21668D953"},
-		{.bits = 192,
-			.p = "fffffffffffffffffffffffffffffffeffffffffffffffff",
-			.seed = "C469684435DEB378C4B65CA9591E2A5763059A2E",
-		    .r = "25191F95024D839546D9A3375639A9967D52F1373BC4EE0B",
-			.a = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC",
-		    .b = "22123DC2395A05CAA7423DAECCC94760A7D462256BD56916"},
-		{.bits = 239,
-		    .p = "7fffffffffffffffffffffff7fffffffffff8000000000007fffffffffff",
-			.seed = "E43BB460F0B80CC0C0B075798E948060F8321B7D",
-			.r = "28B85EC1ECC19EFE769EB741A6D1BA29476AA5A8F2610957D6EFE78D3783",
-			.a = "7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC",
-			.b = "6B016C3BDCF18941D0D654921475CA71A9DB2FB27D1D37796185C2942C0A"
-		},
-		{.bits = 239,
-			.p = "7fffffffffffffffffffffff7fffffffffff8000000000007fffffffffff",
-			.seed = "E8B4011604095303CA3B8099982BE09FCB9AE616",
-			.r = "1DF491E44E7CCAF4D1EAD8A6B90DAE09E0D33F2C6CFE7A6BA76E86713D52",
-			.a = "7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC",
-			.b = "617FAB6832576CBBFED50D99F0249C3FEE58B94BA0038C7AE84C8C832F2C"
-		},
-		{.bits = 239,
-			.p = "7fffffffffffffffffffffff7fffffffffff8000000000007fffffffffff",
-			.seed = "7D7374168FFE3471B60A857686A19475D3BFA2FF",
-			.r = "3A4F9DC9A6CEFD5F9D1193B9C9968C202430003C2819C2E498618DC58330",
-			.a = "7FFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFF8000000000007FFFFFFFFFFC",
-			.b = "255705FA2A306654B1F4CB03D6A750A30C250102D4988717D9BA15AB6D3E"
-		},
-		{.bits = 256,
-		    .p = "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
-			.seed = "C49D360886E704936A6678E1139D26B7819F7E90",
-		    .r = "7EFBA1662985BE9403CB055C75D4F7E0CE8D84A9C5114ABCAF3177680104FA0D",
-			.a = "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC",
-			.b = "5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B"
-		}
-	};
-
-	size_t nb_params = sizeof(params) / sizeof(struct example_params);
-	return cr_make_param_array(struct example_params, params, nb_params, NULL);
-}
-ParameterizedTest(struct example_params *param, seed, test_seed_prime_examples) {
-	//TODO: implement the test
-	config_t cfg = {};
-	cfg.bits = param->bits;
-	curve_t curve = {};
-}
\ No newline at end of file