11 files changed, 262 insertions, 74 deletions

diff --git a/src/exhaustive/brainpool.c b/src/exhaustive/brainpool.c
index d7f0c59..3debaec 100644
--- a/src/exhaustive/brainpool.c
+++ b/src/exhaustive/brainpool.c
@@ -4,6 +4,9 @@
  */
 
 #include "brainpool.h"
+#include <misc/types.h>
+#include "gen/gens.h"
+#include "gen/point.h"
 #include "gen/seed.h"
 #include "io/output.h"
 #include "util/bits.h"
@@ -155,7 +158,8 @@ GENERATOR(brainpool_gen_equation) {
 			avma = btop;
 			continue;
 		}
-		z = Fp_sqrtn(Fp_muls(am, -1, curve->field), stoi(4), curve->field, NULL);
+		z = Fp_sqrtn(Fp_muls(am, -1, curve->field), stoi(4), curve->field,
+		             NULL);
 		if (z == NULL) {
 			brainpool_update_seed(seed->seed);
 			avma = btop;
@@ -189,13 +193,6 @@ GENERATOR(brainpool_gen_equation) {
 			continue;
 		}
 
-		brainpool_update_seed(seed->seed);
-		seed->brainpool.seed_bp = bits_copy(seed->seed);
-
-		bits_t *mult_bits =
-		    brainpool_hash(seed->seed, seed->brainpool.w, seed->brainpool.v);
-		seed->brainpool.mult = bits_to_i(mult_bits);
-
 		curve->a = mod_a;
 		curve->b = mod_b;
 		gerepileall(btop, 2, &curve->a, &curve->b);
@@ -204,4 +201,64 @@ GENERATOR(brainpool_gen_equation) {
 
 	seed->brainpool.update_seed = true;
 	return 1;
+}
+
+GENERATOR(brainpool_gen_gens) {
+	pari_sp ltop = avma;
+	seed_t *seed = curve->seed;
+	brainpool_update_seed(seed->seed);
+
+	bits_t *k_bits =
+	    brainpool_hash(seed->seed, seed->brainpool.w, seed->brainpool.v);
+	GEN k = bits_to_i(k_bits);
+	bits_free(&k_bits);
+	GEN x = gen_0;
+	GEN Qy = ellordinate(curve->curve, x, 0);
+	while (glength(Qy) == 0) {
+		mpaddz(x, gen_1, x);
+		Qy = ellordinate(curve->curve, x, 0);
+	}
+
+	GEN P = NULL;
+	if (glength(Qy) == 1) {
+		P = mkvec2(x, gel(Qy, 1));
+	} else if (glength(Qy) == 2) {
+		if (random_bits(1)) {
+			P = mkvec2(x, gel(Qy, 1));
+		} else {
+			P = mkvec2(x, gel(Qy, 2));
+		}
+	} else {
+		avma = ltop;
+		return INT_MIN;
+	}
+
+	curve->generators = points_new(1);
+	point_t *G = point_new();
+	curve->generators[0] = G;
+	G->point = gerepilecopy(ltop, ellmul(curve->curve, P, k));
+	G->order = ellorder(curve->curve, G->point, NULL);
+	G->cofactor = divii(curve->order, G->order);
+
+	return 1;
+}
+
+CHECK(brainpool_check_gens) {
+	pari_sp ltop = avma;
+	point_t *G = curve->generators[0];
+	GEN min_degree = divis(subii(G->order, gen_1), 100);
+	if (mpcmp(min_degree, gens_get_embedding(curve->field, G->order)) >= 0) {
+		avma = ltop;
+		return -5;
+	}
+	avma = ltop;
+	return 1;
+}
+
+CHECK(brainpool_check_order) {
+	if (mpcmp(curve->order, curve->field) < 0) {
+		return 1;
+	} else {
+		return -4;
+	}
 }
\ No newline at end of file
diff --git a/src/exhaustive/brainpool.h b/src/exhaustive/brainpool.h
index 741bf2f..0b19fa3 100644
--- a/src/exhaustive/brainpool.h
+++ b/src/exhaustive/brainpool.h
@@ -58,7 +58,7 @@ GENERATOR(brainpool_gen_seed_argument);
 GENERATOR(brainpool_gen_seed_input);
 
 /**
- *
+ * @brief
  * @param curve
  * @param args
  * @param state
@@ -75,4 +75,31 @@ GENERATOR(brainpool_gen_field);
  */
 GENERATOR(brainpool_gen_equation);
 
+/**
+ * @brief
+ * @param curve
+ * @param args
+ * @param state
+ * @return
+ */
+GENERATOR(brainpool_gen_gens);
+
+/**
+ * @brief
+ * @param curve
+ * @param args
+ * @param state
+ * @return
+ */
+CHECK(brainpool_check_gens);
+
+/**
+ * @brief
+ * @param curve
+ * @param args
+ * @param state
+ * @return
+ */
+CHECK(brainpool_check_order);
+
 #endif  // ECGEN_BRAINPOOL_H
diff --git a/src/exhaustive/brainpool_rfc.c b/src/exhaustive/brainpool_rfc.c
index 1a9fea9..921dff3 100644
--- a/src/exhaustive/brainpool_rfc.c
+++ b/src/exhaustive/brainpool_rfc.c
@@ -33,34 +33,46 @@ GENERATOR(brainpool_rfc_gen_equation) {
 	// field is definitely prime
 	pari_sp btop = avma;
 	seed_t *seed = curve->seed;
+	pari_printf("seed before %P#x\n", bits_to_i(seed->seed));
 	do {
 		if (seed->brainpool.update_seed) {
+			printf("updating seed\n");
 			brainpool_update_seed(seed->seed);
+			pari_printf("seed after %P#x\n", bits_to_i(seed->seed));
 			seed->brainpool.update_seed = false;
 		}
 
-		GEN z;
 		bits_t *a_bits =
 		    brainpool_hash(seed->seed, seed->brainpool.w, seed->brainpool.v);
 		GEN a = bits_to_i(a_bits);
+		pari_printf("trying a = '%P#x'\n", a);
 		bits_free(&a_bits);
 		GEN am = Fp_invsafe(a, curve->field);
 		if (am == NULL) {
 			brainpool_update_seed(seed->seed);
+			pari_printf("a, update seed(noinv) %P#x\n", bits_to_i(seed->seed));
 			avma = btop;
 			continue;
 		}
-		z = Fp_sqrtn(Fp_muls(am, -1, curve->field), stoi(4), curve->field, NULL);
+		GEN z;
+		z = Fp_sqrtn(Fp_muls(am, -3, curve->field), stoi(4), curve->field,
+		             NULL);
 		if (z == NULL) {
 			brainpool_update_seed(seed->seed);
+			pari_printf("a, update seed(sqrtn) %P#x\n", bits_to_i(seed->seed));
 			avma = btop;
 			continue;
 		}
 		seed->brainpool.seed_a = bits_copy(seed->seed);
 
-		GEN b;
+		GEN b = NULL;
+		pari_sp bbtop = avma;
 		do {
+			if (b != NULL) {
+				avma = bbtop;
+			}
 			brainpool_update_seed(seed->seed);
+			pari_printf("b, update seed %P#x\n", bits_to_i(seed->seed));
 			bits_t *b_bits = brainpool_hash(seed->seed, seed->brainpool.w,
 			                                seed->brainpool.v);
 			b = bits_to_i(b_bits);
@@ -75,19 +87,13 @@ GENERATOR(brainpool_rfc_gen_equation) {
 		if (gequal0(gmulsg(-16, gadd(gmulsg(4, gpowgs(mod_a, 3)),
 		                             gmulsg(27, gsqr(mod_b)))))) {
 			brainpool_update_seed(seed->seed);
+			pari_printf("curve, update seed %P#x\n", bits_to_i(seed->seed));
 			bits_free(&seed->brainpool.seed_a);
 			bits_free(&seed->brainpool.seed_b);
 			avma = btop;
 			continue;
 		}
 
-		brainpool_update_seed(seed->seed);
-		seed->brainpool.seed_bp = bits_copy(seed->seed);
-
-		bits_t *mult_bits =
-		    brainpool_hash(seed->seed, seed->brainpool.w, seed->brainpool.v);
-		seed->brainpool.mult = bits_to_i(mult_bits);
-
 		curve->a = mod_a;
 		curve->b = mod_b;
 		gerepileall(btop, 2, &curve->a, &curve->b);
@@ -96,4 +102,4 @@ GENERATOR(brainpool_rfc_gen_equation) {
 
 	seed->brainpool.update_seed = true;
 	return 1;
-}
\ No newline at end of file
+}
diff --git a/src/exhaustive/brainpool_rfc.h b/src/exhaustive/brainpool_rfc.h
index c838419..8a27410 100644
--- a/src/exhaustive/brainpool_rfc.h
+++ b/src/exhaustive/brainpool_rfc.h
@@ -9,7 +9,7 @@
 #include "misc/types.h"
 
 /**
- *
+ * @brief
  * @param curve
  * @param args
  * @param state
@@ -18,7 +18,7 @@
 GENERATOR(brainpool_rfc_gen_seed_argument);
 
 /**
- *
+ * @brief
  * @param curve
  * @param args
  * @param state
@@ -27,7 +27,7 @@ GENERATOR(brainpool_rfc_gen_seed_argument);
 GENERATOR(brainpool_rfc_gen_seed_random);
 
 /**
- *
+ * @brief
  * @param curve
  * @param args
  * @param state
diff --git a/src/exhaustive/exhaustive.c b/src/exhaustive/exhaustive.c
index ee475ff..71d5442 100644
--- a/src/exhaustive/exhaustive.c
+++ b/src/exhaustive/exhaustive.c
@@ -40,6 +40,14 @@ void exhaustive_clear(exhaustive_t *setup) {
 
 static void exhaustive_ginit(gen_f *generators) {
 	if (cfg->seed_algo) {
+		if (cfg->prime) {
+			generators[OFFSET_ORDER] = &order_gen_prime;
+		} else if (cfg->cofactor) {
+			generators[OFFSET_ORDER] = &order_gen_smallfact;
+		} else {
+			generators[OFFSET_ORDER] = &order_gen_any;
+		}
+
 		switch (cfg->seed_algo) {
 			case SEED_ANSI: {
 				// setup ANSI X9.62 generators
@@ -52,13 +60,13 @@ static void exhaustive_ginit(gen_f *generators) {
 						generators[OFFSET_SEED] = &ansi_gen_seed_input;
 					}
 				}
-				generators[OFFSET_A] = &gen_skip;
-				generators[OFFSET_B] = &ansi_gen_equation;
 				if (cfg->random) {
 					generators[OFFSET_FIELD] = &field_gen_random;
 				} else {
 					generators[OFFSET_FIELD] = &field_gen_input;
 				}
+				generators[OFFSET_A] = &gen_skip;
+				generators[OFFSET_B] = &ansi_gen_equation;
 			} break;
 			case SEED_BRAINPOOL: {
 				if (cfg->seed) {
@@ -73,6 +81,8 @@ static void exhaustive_ginit(gen_f *generators) {
 				generators[OFFSET_FIELD] = &brainpool_gen_field;
 				generators[OFFSET_A] = &gen_skip;
 				generators[OFFSET_B] = &brainpool_gen_equation;
+				generators[OFFSET_ORDER] = &order_gen_prime;
+				generators[OFFSET_GENERATORS] = &brainpool_gen_gens;
 			} break;
 			case SEED_BRAINPOOL_RFC: {
 				if (cfg->seed) {
@@ -88,20 +98,14 @@ static void exhaustive_ginit(gen_f *generators) {
 				generators[OFFSET_FIELD] = &brainpool_gen_field;
 				generators[OFFSET_A] = &gen_skip;
 				generators[OFFSET_B] = &brainpool_rfc_gen_equation;
+				generators[OFFSET_ORDER] = &order_gen_prime;
+				generators[OFFSET_GENERATORS] = &brainpool_gen_gens;
 			} break;
 			case SEED_FIPS:
 				break;
 			default:
 				break;
 		}
-
-		if (cfg->prime) {
-			generators[OFFSET_ORDER] = &order_gen_prime;
-		} else if (cfg->cofactor) {
-			generators[OFFSET_ORDER] = &order_gen_smallfact;
-		} else {
-			generators[OFFSET_ORDER] = &order_gen_any;
-		}
 	} else {
 		// setup normal generators
 		generators[OFFSET_SEED] = &gen_skip;
@@ -148,16 +152,16 @@ static void exhaustive_ginit(gen_f *generators) {
 		} else {
 			generators[OFFSET_FIELD] = &field_gen_input;
 		}
+
+		if (cfg->unique) {
+			generators[OFFSET_GENERATORS] = &gens_gen_one;
+		} else {
+			generators[OFFSET_GENERATORS] = &gens_gen_any;
+		}
 	}
 	// setup common generators
 	generators[OFFSET_CURVE] = &curve_gen_any;
 
-	if (cfg->unique) {
-		generators[OFFSET_GENERATORS] = &gens_gen_one;
-	} else {
-		generators[OFFSET_GENERATORS] = &gens_gen_any;
-	}
-
 	switch (cfg->points.type) {
 		case POINTS_RANDOM:
 			if (cfg->points.amount) {
@@ -189,6 +193,25 @@ static void exhaustive_cinit(check_t **validators) {
 		check_t *hex_check = check_new(hex_check_param, NULL);
 		validators[OFFSET_POINTS] = hex_check;
 	}
+
+	if (cfg->method == METHOD_SEED) {
+		switch (cfg->seed_algo) {
+			case SEED_ANSI:
+				break;
+			case SEED_BRAINPOOL:
+			case SEED_BRAINPOOL_RFC: {
+				check_t *order_check = check_new(brainpool_check_order, NULL);
+				validators[OFFSET_ORDER] = order_check;
+				check_t *gens_check =
+				    check_new(gens_check_anomalous, brainpool_check_gens, NULL);
+				validators[OFFSET_GENERATORS] = gens_check;
+			} break;
+			case SEED_FIPS:
+				break;
+			default:
+				break;
+		}
+	}
 }
 
 static void exhaustive_ainit(arg_t **gen_argss, arg_t **check_argss) {
@@ -205,12 +228,14 @@ static void exhaustive_ainit(arg_t **gen_argss, arg_t **check_argss) {
 		gen_argss[OFFSET_FIELD] = field_arg;
 		gen_argss[OFFSET_B] = eq_arg;
 	}
+
 	if (cfg->points.type == POINTS_RANDOM) {
 		arg_t *points_arg = arg_new();
 		points_arg->args = &cfg->points.amount;
 		points_arg->nargs = 1;
 		gen_argss[OFFSET_POINTS] = points_arg;
 	}
+
 	if (cfg->cofactor) {
 		arg_t *order_arg = arg_new();
 		arg_t *gens_arg = arg_new();
@@ -278,6 +303,7 @@ int exhaustive_gen_retry(curve_t *curve, const exhaustive_t *setup,
 		}
 		timeout_stop();
 		if (diff > 0 && setup->validators && setup->validators[state]) {
+			pari_sp ctop = avma;
 			check_t *validator = setup->validators[state];
 			for (size_t i = 0; i < validator->nchecks; ++i) {
 				int new_diff =
@@ -287,6 +313,7 @@ int exhaustive_gen_retry(curve_t *curve, const exhaustive_t *setup,
 					break;
 				}
 			}
+			avma = ctop;
 		}
 
 		int new_state = state + diff;
diff --git a/src/gen/gens.c b/src/gen/gens.c
index 2cffbc4..e2c624e 100644
--- a/src/gen/gens.c
+++ b/src/gen/gens.c
@@ -40,16 +40,25 @@ GENERATOR(gens_gen_one) {
 
 CHECK(gens_check_anomalous) {
 	if (cfg->field == FIELD_BINARY) return 1;
-	pari_sp ltop = avma;
 	for (size_t i = 0; i < curve->ngens; ++i) {
 		if (mpcmp(curve->field, curve->generators[i]->order) == 0) {
-			avma = ltop;
 			return -5;
 		}
 	}
 	return 1;
 }
 
+GEN gens_get_embedding(GEN prime, GEN order) {
+	pari_sp ltop = avma;
+	GEN power = gen_1;
+	GEN pm;
+	do {
+		power = mulii(power, prime);
+		pm = subii(power, gen_1);
+	} while (!dvdii(pm, order));
+	return gerepilecopy(ltop, power);
+}
+
 CHECK(gens_check_embedding) {
 	HAS_ARG(args);
 	if (cfg->field == FIELD_BINARY) return 1;
@@ -59,13 +68,8 @@ CHECK(gens_check_embedding) {
 	GEN mind = strtoi(min_degree);
 
 	for (size_t i = 0; i < curve->ngens; ++i) {
-		GEN power = gen_0;
-		GEN pm;
-		do {
-			power = addii(power, gen_1);
-			GEN ppow = powii(curve->field, power);
-			pm = subii(ppow, gen_1);
-		} while (!dvdii(pm, curve->generators[i]->order));
+		GEN power =
+		    gens_get_embedding(curve->field, curve->generators[i]->order);
 
 		if (mpcmp(power, mind) <= 0) {
 			avma = ltop;
diff --git a/src/gen/gens.h b/src/gen/gens.h
index 18c9815..11b349b 100644
--- a/src/gen/gens.h
+++ b/src/gen/gens.h
@@ -30,6 +30,7 @@ GENERATOR(gens_gen_any);
 GENERATOR(gens_gen_one);
 
 /**
+ * CHECK(check_f)
  *
  * @param curve
  * @param args
@@ -39,6 +40,18 @@ GENERATOR(gens_gen_one);
 CHECK(gens_check_anomalous);
 
 /**
+ * @brief Get the embedding degree of a subgroup of <code>order</code> in a
+ * power of F_prime.
+ *
+ * @param prime The order of the base field.
+ * @param order The order of the subgroup generator (in the curve group).
+ * @return The embedding degree 't' such that <code>order</code> divides
+ * 'prime^t - 1'.
+ */
+GEN gens_get_embedding(GEN prime, GEN order);
+
+/**
+ * CHECK(check_f)
  *
  * @param curve
  * @param args
diff --git a/src/misc/types.h b/src/misc/types.h
index 960745c..76f8510 100644
--- a/src/misc/types.h
+++ b/src/misc/types.h
@@ -49,8 +49,6 @@ typedef struct {
 			long v;
 			bits_t *seed_a;
 			bits_t *seed_b;
-			bits_t *seed_bp;
-			GEN mult;
 		} brainpool;
 	};
 } seed_t;
diff --git a/test/src/exhaustive/test_ansi.c b/test/src/exhaustive/test_ansi.c
index 7558fa0..4724336 100644
--- a/test/src/exhaustive/test_ansi.c
+++ b/test/src/exhaustive/test_ansi.c
@@ -151,7 +151,8 @@ ParameterizedTestParameters(ansi, test_ansi_seed_prime_examples) {
 	// clang-format on
 
 	size_t nb_params = sizeof(params) / sizeof(struct prime_params);
-	return cr_make_param_array(struct prime_params, params, nb_params, prime_params_cleanup);
+	return cr_make_param_array(struct prime_params, params, nb_params,
+	                           prime_params_cleanup);
 }
 ParameterizedTest(struct prime_params *param, ansi,
                   test_ansi_seed_prime_examples) {
diff --git a/test/src/exhaustive/test_brainpool_rfc.c b/test/src/exhaustive/test_brainpool_rfc.c
index ed6ae54..19008b4 100644
--- a/test/src/exhaustive/test_brainpool_rfc.c
+++ b/test/src/exhaustive/test_brainpool_rfc.c
@@ -5,14 +5,20 @@
 
 #include <criterion/criterion.h>
 #include <criterion/parameterized.h>
+#include <exhaustive/exhaustive.h>
+#include "exhaustive/brainpool.h"
+#include "exhaustive/brainpool_rfc.h"
+#include "exhaustive/check.h"
+#include "exhaustive/exhaustive.h"
+#include "gen/curve.h"
+#include "gen/gens.h"
+#include "gen/order.h"
+#include "gen/seed.h"
+#include "misc/types.h"
 #include "test/io.h"
 #include "test/memory.h"
-#include "misc/types.h"
-#include "gen/seed.h"
 #include "util/bits.h"
 #include "util/memory.h"
-#include "exhaustive/brainpool.h"
-#include "exhaustive/brainpool_rfc.h"
 
 TestSuite(brainpool_rfc, .init = io_setup, .fini = io_teardown);
 
@@ -77,6 +83,10 @@ void params_cleanup(struct criterion_test_params *ctp) {
 	cr_free(params->b);
 }
 
+/**
+ * These fail because brainpool_rfc_gen_equation only implements the one curve
+ * generation step and
+ * does not do other Brainpool checks(which are a part of the procedure).*/
 ParameterizedTestParameters(brainpool_rfc, test_brainpool_rfc_params) {
 	static struct rfc_params params[7] = {{0}};
 
@@ -94,40 +104,65 @@ ParameterizedTestParameters(brainpool_rfc, test_brainpool_rfc_params) {
 	params[1].b = cr_strdup("469A28EF7C28CCA3DC721D044F4496BCCA7EF4146FBF25C9");
 	params[2].bits = 224;
 	params[2].p_seed = cr_strdup("7BE5466CF34E90C6CC0AC29B7C97C50DD3F84D5B");
-	params[2].p = cr_strdup("D7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FF");
+	params[2].p =
+	    cr_strdup("D7C134AA264366862A18302575D1D787B09F075797DA89F57EC8C0FF");
 	params[2].ab_seed = cr_strdup("5F4BF8D8D8C31D763DA06C80ABB1185EB4F7C7B5");
-	params[2].a = cr_strdup("68A5E62CA9CE6C1C299803A6C1530B514E182AD8B0042A59CAD29F43");
-	params[2].b = cr_strdup("2580F63CCFE44138870713B1A92369E33E2135D266DBB372386C400B");
+	params[2].a =
+	    cr_strdup("68A5E62CA9CE6C1C299803A6C1530B514E182AD8B0042A59CAD29F43");
+	params[2].b =
+	    cr_strdup("2580F63CCFE44138870713B1A92369E33E2135D266DBB372386C400B");
 	params[3].bits = 256;
 	params[3].p_seed = cr_strdup("5B54709179216D5D98979FB1BD1310BA698DFB5A");
-	params[3].p = cr_strdup("A9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377");
+	params[3].p = cr_strdup(
+	    "A9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377");
 	params[3].ab_seed = cr_strdup("757F5958490CFD47D7C19BB42158D9554F7B46BC");
-	params[3].a = cr_strdup("7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9");
-	params[3].b = cr_strdup("26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6");
+	params[3].a = cr_strdup(
+	    "7D5A0975FC2C3057EEF67530417AFFE7FB8055C126DC5C6CE94A4B44F330B5D9");
+	params[3].b = cr_strdup(
+	    "26DC5C6CE94A4B44F330B5D9BBD77CBF958416295CF7E1CE6BCCDC18FF8C07B6");
 	params[4].bits = 320;
 	params[4].p_seed = cr_strdup("C2FFD72DBD01ADFB7B8E1AFED6A267E96BA7C904");
-	params[4].p = cr_strdup("D35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412B1F1B32E27");
+	params[4].p = cr_strdup(
+	    "D35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412"
+	    "B1F1B32E27");
 	params[4].ab_seed = cr_strdup("ED55C4D79FD5F24D6613C31C3839A2DDF8A9A276");
-	params[4].a = cr_strdup("3EE30B568FBAB0F883CCEBD46D3F3BB8A2A73513F5EB79DA66190EB085FFA9F492F375A97D860EB4");
-	params[4].b = cr_strdup("520883949DFDBC42D3AD198640688A6FE13F41349554B49ACC31DCCD884539816F5EB4AC8FB1F1A6");
+	params[4].a = cr_strdup(
+	    "3EE30B568FBAB0F883CCEBD46D3F3BB8A2A73513F5EB79DA66190EB085FFA9F492F375"
+	    "A97D860EB4");
+	params[4].b = cr_strdup(
+	    "520883949DFDBC42D3AD198640688A6FE13F41349554B49ACC31DCCD884539816F5EB4"
+	    "AC8FB1F1A6");
 	params[5].bits = 384;
 	params[5].p_seed = cr_strdup("5F12C7F9924A19947B3916CF70801F2E2858EFC1");
-	params[5].p = cr_strdup("8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A729901D1A71874700133107EC53");
+	params[5].p = cr_strdup(
+	    "8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B412B1DA197FB71123ACD3A7"
+	    "29901D1A71874700133107EC53");
 	params[5].ab_seed = cr_strdup("BCFBFA1C877C56284DAB79CD4C2B3293D20E9E5E");
-	params[5].a = cr_strdup("7BC382C63D8C150C3C72080ACE05AFA0C2BEA28E4FB22787139165EFBA91F90F8AA5814A503AD4EB04A8C7DD22CE2826");
-	params[5].b = cr_strdup("04A8C7DD22CE28268B39B55416F0447C2FB77DE107DCD2A62E880EA53EEB62D57CB4390295DBC9943AB78696FA504C11");
+	params[5].a = cr_strdup(
+	    "7BC382C63D8C150C3C72080ACE05AFA0C2BEA28E4FB22787139165EFBA91F90F8AA581"
+	    "4A503AD4EB04A8C7DD22CE2826");
+	params[5].b = cr_strdup(
+	    "04A8C7DD22CE28268B39B55416F0447C2FB77DE107DCD2A62E880EA53EEB62D57CB439"
+	    "0295DBC9943AB78696FA504C11");
 	params[6].bits = 512;
 	params[6].p_seed = cr_strdup("6636920D871574E69A458FEA3F4933D7E0D95748");
-	params[6].p = cr_strdup("AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3");
+	params[6].p = cr_strdup(
+	    "AADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA703308717D4D9B"
+	    "009BC66842AECDA12AE6A380E62881FF2F2D82C68528AA6056583A48F3");
 	params[6].ab_seed = cr_strdup("AF02AC60ACC93ED874422A52ECB238FEEE5AB6AD");
-	params[6].a = cr_strdup("7830A3318B603B89E2327145AC234CC594CBDD8D3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CA");
-	params[6].b = cr_strdup("3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CADC083E67984050B75EBAE5DD2809BD638016F723");
+	params[6].a = cr_strdup(
+	    "7830A3318B603B89E2327145AC234CC594CBDD8D3DF91610A83441CAEA9863BC2DED5D"
+	    "5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7B9E7C1AC4D77FC94CA");
+	params[6].b = cr_strdup(
+	    "3DF91610A83441CAEA9863BC2DED5D5AA8253AA10A2EF1C98B9AC8B57F1117A72BF2C7"
+	    "B9E7C1AC4D77FC94CADC083E67984050B75EBAE5DD2809BD638016F723");
 
 	size_t nb_params = sizeof(params) / sizeof(struct rfc_params);
 	return cr_make_param_array(struct rfc_params, params, nb_params,
-							   params_cleanup);
+	                           params_cleanup);
 }
-ParameterizedTest(struct rfc_params *param, brainpool_rfc, test_brainpool_rfc_params) {
+ParameterizedTest(struct rfc_params *param, brainpool_rfc,
+                  test_brainpool_rfc_params) {
 	cfg->bits = param->bits;
 	cfg->field = FIELD_PRIME;
 
@@ -158,7 +193,27 @@ ParameterizedTest(struct rfc_params *param, brainpool_rfc, test_brainpool_rfc_pa
 	cr_assert_not_null(curve.seed, );
 	cr_assert_eq(ret, 1, );
 
-	ret = brainpool_rfc_gen_equation(&curve, NULL, OFFSET_B);
+	exhaustive_t setup = {0};
+	gen_f gens[OFFSET_END] = {0};
+	gens[OFFSET_A] = &gen_skip;
+	gens[OFFSET_B] = &brainpool_rfc_gen_equation;
+	gens[OFFSET_CURVE] = &curve_gen_any;
+	gens[OFFSET_ORDER] = &order_gen_prime;
+	gens[OFFSET_GENERATORS] = &brainpool_gen_gens;
+	gens[OFFSET_POINTS] = &gen_skip;
+	check_t *checks[OFFSET_END] = {0};
+	checks[OFFSET_ORDER] = check_new(brainpool_check_order, NULL);
+	checks[OFFSET_GENERATORS] =
+	    check_new(gens_check_anomalous, brainpool_check_gens, NULL);
+	unroll_f unrolls[OFFSET_END] = {0};
+	unrolls[OFFSET_CURVE] = &curve_unroll;
+	unrolls[OFFSET_GENERATORS] = &gens_unroll;
+	setup.generators = gens;
+	setup.validators = checks;
+	setup.unrolls = unrolls;
+
+	ret = exhaustive_gen(&curve, &setup, OFFSET_A, OFFSET_GENERATORS);
+
 	pari_printf("expected a = %P#x\n", lift(a));
 	pari_printf("real     a = %P#x\n", lift(curve.a));
 	cr_assert_not_null(curve.a, );
diff --git a/test/src/test/default.c b/test/src/test/default.c
index 3587032..35f6df9 100644
--- a/test/src/test/default.c
+++ b/test/src/test/default.c
@@ -9,7 +9,7 @@
 
 void default_setup(void) {
 	memset(cfg, 0, sizeof(config_t));
-	pari_init(1000000, 1000000);
+	pari_init(20000000, 1000000);
 	// set_mem_funcs(cr_malloc, cr_simple_calloc, cr_realloc, cr_free);
 }