Fix hashing of ANSI X9.62 seed.

6 files changed, 89 insertions, 33 deletions

diff --git a/src/gen/seed.c b/src/gen/seed.c
index 00a6c0a..71b6658 100644
--- a/src/gen/seed.c
+++ b/src/gen/seed.c
@@ -11,9 +11,28 @@
 
 seed_t *seed_new(void) { return try_calloc(sizeof(seed_t)); }
 
+static seed_t *seed_cpy(const seed_t *src, seed_t *dest) {
+	if (src->hex) {
+		dest->hex = try_strdup(src->hex);
+		dest->hex_len = src->hex_len;
+	}
+	if (src->raw) {
+		dest->raw = try_memdup(src->raw, src->raw_len);
+		dest->raw_len = src->raw_len;
+	}
+	if (src->hash20) {
+		dest->hash20 = try_memdup(src->hash20, 20);
+	}
+	if (src->W) {
+		dest->W = try_memdup(src->W, src->W_len);
+		dest->W_len = src->W_len;
+	}
+	return dest;
+}
+
 seed_t *seed_copy(const seed_t *src, seed_t *dest) {
 	if (src->seed) dest->seed = gcopy(src->seed);
-	return dest;
+	return seed_cpy(src, dest);
 }
 
 seed_t *seed_new_copy(const seed_t *src) {
@@ -23,7 +42,7 @@ seed_t *seed_new_copy(const seed_t *src) {
 
 seed_t *seed_clone(const seed_t *src, seed_t *dest) {
 	if (src->seed) dest->seed = gclone(src->seed);
-	return dest;
+	return seed_cpy(src, dest);
 }
 
 seed_t *seed_new_clone(const seed_t *src) {
@@ -73,9 +92,7 @@ static GEN seed_stoi(const char *cstr) {
 static char *seed_itos(GEN seed) {
 	pari_sp ltop = avma;
 	char *result = pari_sprintf("%Px", seed);
-
-	char *seed_str = try_malloc(strlen(result) + 1);
-	strcpy(seed_str, result);
+	char *seed_str = try_strdup(result);
 
 	avma = ltop;
 	return seed_str;
@@ -92,11 +109,23 @@ static char *seed_strip(const char *cstr) {
 	return seed_str;
 }
 
-static void hash_string(const char *str, int len, unsigned char *hashout) {
+static void seed_raw(seed_t *seed) {
+	seed->raw = binascii_itob(seed->seed, ENDIAN_BIG);
+	seed->raw_len = binascii_blen(seed->seed);
+}
+
+static void seed_hash(seed_t *seed) {
+	seed->hash20 = try_malloc(20);
 	SHA_CTX ctx = {};
 	SHA1_Init(&ctx);
-	SHA1_Update(&ctx, str, len);
-	SHA1_Final(hashout, &ctx);
+	SHA1_Update(&ctx, seed->raw, (int)seed->raw_len);
+	SHA1_Final(seed->hash20, &ctx);
+}
+
+static void seed_W(seed_t *seed, const config_t *cfg) {
+	GEN t = utoi(cfg->bits - 1);
+	GEN s = floorr(rdivii(subis(t, 1), stoi(160), DEFAULTPREC));
+	GEN h = subis(t, 160);
 }
 
 GENERATOR(seed_gen_random) {
@@ -104,10 +133,9 @@ GENERATOR(seed_gen_random) {
 	seed->seed = random_int(160);
 	seed->hex = seed_itos(seed->seed);
 	seed->hex_len = strlen(seed->hex);
-	seed->raw = binascii_itob(seed->seed, ENDIAN_BIG);
-	seed->raw_len = binascii_blen(seed->seed);
-	seed->hash20 = try_malloc(20);
-	hash_string(seed->raw, (int)seed->raw_len, seed->hash20);
+	seed_raw(seed);
+	seed_hash(seed);
+	seed_W(seed, cfg);
 	curve->seed = seed;
 	return 1;
 }
@@ -117,10 +145,9 @@ GENERATOR(seed_gen_argument) {
 	seed->seed = seed_stoi(cfg->seed);
 	seed->hex = seed_strip(cfg->seed);
 	seed->hex_len = strlen(seed->hex);
-	seed->raw = binascii_itob(seed->seed, ENDIAN_BIG);
-	seed->raw_len = binascii_blen(seed->seed);
-	seed->hash20 = try_malloc(20);
-	hash_string(seed->raw, (int)seed->raw_len, seed->hash20);
+	seed_raw(seed);
+	seed_hash(seed);
+	seed_W(seed, cfg);
 	curve->seed = seed;
 	return 1;
 }
@@ -140,10 +167,9 @@ GENERATOR(seed_gen_input) {
 	seed->seed = seed_stoi(cstr);
 	seed->hex = seed_strip(cstr);
 	seed->hex_len = strlen(seed->hex);
-	seed->raw = binascii_itob(seed->seed, ENDIAN_BIG);
-	seed->raw_len = binascii_blen(seed->seed);
-	seed->hash20 = try_malloc(20);
-	hash_string(seed->raw, (int)seed->raw_len, seed->hash20);
+	seed_raw(seed);
+	seed_hash(seed);
+	seed_W(seed, cfg);
 	curve->seed = seed;
 	return 1;
 }
diff --git a/src/gen/types.h b/src/gen/types.h
index 26aea15..a20680f 100644
--- a/src/gen/types.h
+++ b/src/gen/types.h
@@ -19,9 +19,11 @@ typedef struct seed_t {
 	GEN seed;
 	char *hex;
 	size_t hex_len;
-	char *raw;
+	unsigned char *raw;
 	size_t raw_len;
 	unsigned char *hash20;
+	char *W;
+	size_t W_len;
 } seed_t;
 
 /**
@@ -89,7 +91,9 @@ typedef struct {
 /**
  * @brief
  */
-typedef enum { ENDIAN_BIG = 0, ENDIAN_LITTLE } endian_e;
+typedef enum {
+	ENDIAN_BIG = 0, ENDIAN_LITTLE
+} endian_e;
 
 /**
  * @brief A generator function type.
@@ -99,7 +103,7 @@ typedef enum { ENDIAN_BIG = 0, ENDIAN_LITTLE } endian_e;
  * @return state diff
  */
 #define GENERATOR(gen_name) \
-	int gen_name(curve_t *curve, const config_t *cfg, arg_t *args)
+    int gen_name(curve_t *curve, const config_t *cfg, arg_t *args)
 
 typedef GENERATOR((*gen_t));
 
@@ -112,8 +116,8 @@ typedef GENERATOR((*gen_t));
  * @return
  */
 #define UNROLL(unroll_name)                                            \
-	int unroll_name(curve_t *curve, const config_t *cfg, pari_sp from, \
-	                pari_sp to)
+    int unroll_name(curve_t *curve, const config_t *cfg, pari_sp from, \
+                    pari_sp to)
 
 typedef UNROLL((*unroll_t));
 
diff --git a/src/util/binascii.c b/src/util/binascii.c
index ae3f1ff..bbc8e89 100644
--- a/src/util/binascii.c
+++ b/src/util/binascii.c
@@ -12,23 +12,23 @@ size_t binascii_blen(GEN i) {
 	return result;
 }
 
-char *binascii_itob(GEN i, endian_e endianity) {
+unsigned char *binascii_itob(GEN i, endian_e endianity) {
 	pari_sp ltop = avma;
 	GEN digits = binary_2k_nv(i, 8);
 	if (endianity == ENDIAN_LITTLE) {
 		digits = vecsmall_reverse(digits);
 	}
 	long blen = glength(digits);
-	char *result = try_malloc((size_t)blen);
+	unsigned char *result = try_malloc((size_t)blen);
 	for (long j = 1; j <= blen; ++j) {
-		result[j - 1] = (char)gel(digits, j);
+		result[j - 1] = (unsigned char)gel(digits, j);
 	}
 
 	avma = ltop;
 	return result;
 }
 
-GEN binascii_btoi(const char *bytes, size_t len, endian_e endianity) {
+GEN binascii_btoi(const unsigned char *bytes, size_t len, endian_e endianity) {
 	pari_sp ltop = avma;
 	GEN result = gen_0;
 	for (size_t i = 0; i < len; ++i) {
diff --git a/src/util/binascii.h b/src/util/binascii.h
index 3826a6a..a6301ef 100644
--- a/src/util/binascii.h
+++ b/src/util/binascii.h
@@ -21,7 +21,7 @@ size_t binascii_blen(GEN i);
  * @param endianity
  * @return
  */
-char *binascii_itob(GEN i, endian_e endianity);
+unsigned char *binascii_itob(GEN i, endian_e endianity);
 
 /**
  * @brief
@@ -29,6 +29,6 @@ char *binascii_itob(GEN i, endian_e endianity);
  * @param endianity
  * @return
  */
-GEN binascii_btoi(const char *bytes, size_t len, endian_e endianity);
+GEN binascii_btoi(const unsigned char *bytes, size_t len, endian_e endianity);
 
 #endif  // ECGEN_BINASCII_H
diff --git a/src/util/memory.c b/src/util/memory.c
index b506011..172a30c 100644
--- a/src/util/memory.c
+++ b/src/util/memory.c
@@ -35,11 +35,22 @@ void *try_realloc(void *ptr, size_t size) {
 	return result;
 }
 
+char *try_strdup(char *str) {
+	size_t len = strlen(str);
+	return try_memdup(str, len + 1);
+}
+
+void *try_memdup(void *mem, size_t len) {
+	void *result = try_malloc(len);
+	memcpy(result, mem, len);
+	return result;
+}
+
 void try_free(void *ptr) { free_func(ptr); }
 
 void set_mem_funcs(void *(*malloc_fun)(size_t), void *(*calloc_fun)(size_t),
-                   void *(*realloc_fun)(void *, size_t),
-                   void (*free_fun)(void *)) {
+				   void *(*realloc_fun)(void *, size_t),
+				   void (*free_fun)(void *)) {
 	malloc_func = malloc_fun;
 	calloc_func = calloc_fun;
 	realloc_func = realloc_fun;
diff --git a/src/util/memory.h b/src/util/memory.h
index 408052f..a7ea54a 100644
--- a/src/util/memory.h
+++ b/src/util/memory.h
@@ -34,6 +34,21 @@ void *try_realloc(void *ptr, size_t size);
 
 /**
  * @brief
+ * @param str
+ * @return
+ */
+char *try_strdup(char *str);
+
+/**
+ * @brief
+ * @param mem
+ * @param len
+ * @return
+ */
+void *try_memdup(void *mem, size_t len);
+
+/**
+ * @brief
  * @param ptr
  */
 void try_free(void *ptr);