From 99407a540c7f1fbbc0987837173d1b81aee790bc Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Thu, 26 Jan 2017 00:49:12 -0500 Subject: First attempt at using Pavel's ecdsa256 core. Not working yet. Attempts to use Pavel's ecdsa256 base point multiplier instead of software point multiplier when selecting new random points (that is, when generating P-256 keys or P-256 signatures). Resulting points pass the point validation test (point_is_on_curve()) but the resulting signatures are invalid. Don't know why yet. Seems like an odd combination, as one would expect random garbage to fail validation. In any case: this commit is intended to archive progress so far, and perhaps see if somebody else can spot what's wrong. As presently coded, this wouldn't be suitable for production use even if it worked. NB: As I understand it, the ecdsa256 core is *not* a general purpose point multiplier even just for the P-256 curve. Rather, it is strictly a base point multiplier: it takes a single scalar as input, and returns the X,Y affine coordinates of the curve's base point multiplied by that scalar. This is essentially the eliptic curve portion of the computation involved in picking a random point for key or signature generation, but is not useful for signature validation. See the README.md in Pavel's source repository for further details. --- ecdsa.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) (limited to 'ecdsa.c') diff --git a/ecdsa.c b/ecdsa.c index 916a2f4..42ea307 100644 --- a/ecdsa.c +++ b/ecdsa.c @@ -88,6 +88,18 @@ #define hal_get_random(core, buffer, length) hal_rpc_get_random(buffer, length) #endif +/* + * Whether to use experimental Verilog ECDSA-P256 point multiplier. + */ + +#ifndef HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER +#define HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER 1 +#endif + +#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER +static int verilog_ecdsa256_multiplier = 1; +#endif + /* * Whether we want debug output. */ @@ -748,6 +760,65 @@ static inline hal_error_t get_random(void *buffer, const size_t length) #endif /* HAL_ECDSA_DEBUG_ONLY_STATIC_TEST_VECTOR_RANDOM */ +/* + * Use experimental Verilog base point multiplier core to calculate + * public key given a private key. point_pick_random() has already + * selected a suitable private key for us, we just need to calculate + * the corresponding public key. + */ + +#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER + +static hal_error_t verilog_point_pick_random(fp_int *k, ec_point_t *P) +{ + assert(k != NULL && P != NULL); + + const size_t len = fp_unsigned_bin_size(k); + uint8_t b[ECDSA256_OPERAND_BITS / 8]; + const uint8_t zero[4] = {0, 0, 0, 0}; + hal_core_t *core = NULL; + hal_error_t err; + + if (len > sizeof(b)) + return HAL_ERROR_RESULT_TOO_LONG; + + if ((err = hal_core_alloc(ECDSA256_NAME, &core)) != HAL_OK) + goto fail; + +#define check(_x_) do { if ((err = (_x_)) != HAL_OK) goto fail; } while (0) + + memset(b, 0, sizeof(b)); + fp_to_unsigned_bin(k, b + sizeof(b) - len); + + for (int i = 0; i < sizeof(b); i += 4) + check(hal_io_write(core, ECDSA256_ADDR_K + i/4, &b[sizeof(b) - 4 - i], 4)); + + check(hal_io_write(core, ADDR_CTRL, zero, sizeof(zero))); + check(hal_io_next(core)); + check(hal_io_wait_ready(core)); + + for (int i = 0; i < sizeof(b); i += 4) + check(hal_io_read(core, ECDSA256_ADDR_X + i/4, &b[sizeof(b) - 4 - i], 4)); + fp_read_unsigned_bin(P->x, b, sizeof(b)); + + for (int i = 0; i < sizeof(b); i += 4) + check(hal_io_read(core, ECDSA256_ADDR_Y + i/4, &b[sizeof(b) - 4 - i], 4)); + fp_read_unsigned_bin(P->y, b, sizeof(b)); + + fp_set(P->z, 1); + +#undef check + + err = HAL_OK; + + fail: + hal_core_free(core); + memset(b, 0, sizeof(b)); + return err; +} + +#endif + /* * Pick a random point on the curve, return random scalar and * resulting point. @@ -792,6 +863,12 @@ static hal_error_t point_pick_random(const ecdsa_curve_t * const curve, memset(k_buf, 0, sizeof(k_buf)); +#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER + if (verilog_ecdsa256_multiplier && curve == get_curve(HAL_CURVE_P256) && + (err = verilog_point_pick_random(k, P)) != HAL_ERROR_CORE_NOT_FOUND) + return err; +#endif + /* * Calculate P = kG and return. */ -- cgit v1.2.3 From 9afc5d0b081983779439aa6f91781efb3e56d01d Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Thu, 2 Mar 2017 17:23:02 -0500 Subject: Refactor to add P384 support. Untested. --- ecdsa.c | 109 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 97 insertions(+), 12 deletions(-) (limited to 'ecdsa.c') diff --git a/ecdsa.c b/ecdsa.c index 42ea307..bb585be 100644 --- a/ecdsa.c +++ b/ecdsa.c @@ -100,6 +100,25 @@ static int verilog_ecdsa256_multiplier = 1; #endif +/* + * Whether to use experimental Verilog ECDSA-P384 point multiplier. + */ + +#ifndef HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER +#define HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER 1 +#endif + +#if HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER +static int verilog_ecdsa384_multiplier = 1; +#endif + +/* + * Whether to include Verilog point multiplier code at all. + */ + +#define HAL_ECDSA_ANY_VERILOG_MULTIPLIER \ + (HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER | HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER) + /* * Whether we want debug output. */ @@ -136,6 +155,7 @@ typedef struct { fp_digit rho; /* Montgomery reduction value */ const uint8_t *oid; /* OBJECT IDENTIFIER */ size_t oid_len; /* Length of OBJECT IDENTIFIER */ + hal_curve_name_t curve; /* Curve name */ } ecdsa_curve_t; /* @@ -218,6 +238,7 @@ static const ecdsa_curve_t * const get_curve(const hal_curve_name_t curve) fp_montgomery_calc_normalization(curve_p256.mu, curve_p256.q); curve_p256.oid = p256_oid; curve_p256.oid_len = sizeof(p256_oid); + curve_p256.curve = HAL_CURVE_P256; fp_read_unsigned_bin(curve_p384.q, unconst_uint8_t(p384_q), sizeof(p384_q)); fp_read_unsigned_bin(curve_p384.b, unconst_uint8_t(p384_b), sizeof(p384_b)); @@ -230,6 +251,7 @@ static const ecdsa_curve_t * const get_curve(const hal_curve_name_t curve) fp_montgomery_calc_normalization(curve_p384.mu, curve_p384.q); curve_p384.oid = p384_oid; curve_p384.oid_len = sizeof(p384_oid); + curve_p384.curve = HAL_CURVE_P384; fp_read_unsigned_bin(curve_p521.q, unconst_uint8_t(p521_q), sizeof(p521_q)); fp_read_unsigned_bin(curve_p521.b, unconst_uint8_t(p521_b), sizeof(p521_b)); @@ -242,6 +264,7 @@ static const ecdsa_curve_t * const get_curve(const hal_curve_name_t curve) fp_montgomery_calc_normalization(curve_p521.mu, curve_p521.q); curve_p521.oid = p521_oid; curve_p521.oid_len = sizeof(p521_oid); + curve_p521.curve = HAL_CURVE_P521; initialized = 1; } @@ -761,20 +784,30 @@ static inline hal_error_t get_random(void *buffer, const size_t length) #endif /* HAL_ECDSA_DEBUG_ONLY_STATIC_TEST_VECTOR_RANDOM */ /* - * Use experimental Verilog base point multiplier core to calculate + * Use experimental Verilog base point multiplier cores to calculate * public key given a private key. point_pick_random() has already * selected a suitable private key for us, we just need to calculate * the corresponding public key. */ -#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER +#if HAL_ECDSA_ANY_VERILOG_MULTIPLIER -static hal_error_t verilog_point_pick_random(fp_int *k, ec_point_t *P) +typedef struct { + size_t bytes; + const char *name; + hal_addr_t k_addr; + hal_addr_t x_addr; + hal_addr_t y_addr; +} verilog_ecdsa_driver_t; + +static hal_error_t verilog_point_pick_random(const verilog_ecdsa_driver_t * const driver, + fp_int *k, + ec_point_t *P) { assert(k != NULL && P != NULL); const size_t len = fp_unsigned_bin_size(k); - uint8_t b[ECDSA256_OPERAND_BITS / 8]; + uint8_t b[driver->bytes]; const uint8_t zero[4] = {0, 0, 0, 0}; hal_core_t *core = NULL; hal_error_t err; @@ -782,7 +815,7 @@ static hal_error_t verilog_point_pick_random(fp_int *k, ec_point_t *P) if (len > sizeof(b)) return HAL_ERROR_RESULT_TOO_LONG; - if ((err = hal_core_alloc(ECDSA256_NAME, &core)) != HAL_OK) + if ((err = hal_core_alloc(driver->name, &core)) != HAL_OK) goto fail; #define check(_x_) do { if ((err = (_x_)) != HAL_OK) goto fail; } while (0) @@ -791,18 +824,18 @@ static hal_error_t verilog_point_pick_random(fp_int *k, ec_point_t *P) fp_to_unsigned_bin(k, b + sizeof(b) - len); for (int i = 0; i < sizeof(b); i += 4) - check(hal_io_write(core, ECDSA256_ADDR_K + i/4, &b[sizeof(b) - 4 - i], 4)); + check(hal_io_write(core, driver->k_addr + i/4, &b[sizeof(b) - 4 - i], 4)); check(hal_io_write(core, ADDR_CTRL, zero, sizeof(zero))); check(hal_io_next(core)); check(hal_io_wait_ready(core)); for (int i = 0; i < sizeof(b); i += 4) - check(hal_io_read(core, ECDSA256_ADDR_X + i/4, &b[sizeof(b) - 4 - i], 4)); + check(hal_io_read(core, driver->x_addr + i/4, &b[sizeof(b) - 4 - i], 4)); fp_read_unsigned_bin(P->x, b, sizeof(b)); for (int i = 0; i < sizeof(b); i += 4) - check(hal_io_read(core, ECDSA256_ADDR_Y + i/4, &b[sizeof(b) - 4 - i], 4)); + check(hal_io_read(core, driver->y_addr + i/4, &b[sizeof(b) - 4 - i], 4)); fp_read_unsigned_bin(P->y, b, sizeof(b)); fp_set(P->z, 1); @@ -819,6 +852,46 @@ static hal_error_t verilog_point_pick_random(fp_int *k, ec_point_t *P) #endif +static inline hal_error_t verilog_p256_point_pick_random(fp_int *k, ec_point_t *P) +{ +#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER + + static const verilog_ecdsa_driver_t verilog_p256_driver = { + .name = ECDSA256_NAME, + .bytes = ECDSA256_OPERAND_BITS / 8, + .k_addr = ECDSA256_ADDR_K, + .x_addr = ECDSA256_ADDR_X, + .y_addr = ECDSA256_ADDR_Y + }; + + if (verilog_ecdsa256_multiplier) + return verilog_point_pick_random(&verilog_p256_driver, k, P); + +#endif + + return HAL_ERROR_CORE_NOT_FOUND; +} + +static inline hal_error_t verilog_p384_point_pick_random(fp_int *k, ec_point_t *P) +{ +#if HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER + + static const verilog_ecdsa_driver_t verilog_p384_driver = { + .name = ECDSA384_NAME, + .bytes = ECDSA384_OPERAND_BITS / 8, + .k_addr = ECDSA384_ADDR_K, + .x_addr = ECDSA384_ADDR_X, + .y_addr = ECDSA384_ADDR_Y + }; + + if (verilog_ecdsa256_multiplier) + return verilog_point_pick_random(&verilog_p256_driver, k, P); + +#endif + + return HAL_ERROR_CORE_NOT_FOUND; +} + /* * Pick a random point on the curve, return random scalar and * resulting point. @@ -863,10 +936,22 @@ static hal_error_t point_pick_random(const ecdsa_curve_t * const curve, memset(k_buf, 0, sizeof(k_buf)); -#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER - if (verilog_ecdsa256_multiplier && curve == get_curve(HAL_CURVE_P256) && - (err = verilog_point_pick_random(k, P)) != HAL_ERROR_CORE_NOT_FOUND) - return err; +#if HAL_ECDSA_ANY_VERILOG_MULTIPLIER + switch (curve->curve) { + + case HAL_CURVE_P256: + if ((err = verilog_p256_point_pick_random(k, P)) != HAL_ERROR_CORE_NOT_FOUND) + return err; + break; + + case HAL_CURVE_P384: + if ((err = verilog_p384_point_pick_random(k, P)) != HAL_ERROR_CORE_NOT_FOUND) + return err; + break; + + default: + break; + } #endif /* -- cgit v1.2.3 From c2f499e0a301d4ad0f92d58f436d01087ceae1bb Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Thu, 2 Mar 2017 20:32:18 -0500 Subject: Fix dumb copy/paste errors. --- ecdsa.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'ecdsa.c') diff --git a/ecdsa.c b/ecdsa.c index bb585be..83f2188 100644 --- a/ecdsa.c +++ b/ecdsa.c @@ -856,7 +856,7 @@ static inline hal_error_t verilog_p256_point_pick_random(fp_int *k, ec_point_t * { #if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER - static const verilog_ecdsa_driver_t verilog_p256_driver = { + static const verilog_ecdsa_driver_t p256_driver = { .name = ECDSA256_NAME, .bytes = ECDSA256_OPERAND_BITS / 8, .k_addr = ECDSA256_ADDR_K, @@ -865,7 +865,7 @@ static inline hal_error_t verilog_p256_point_pick_random(fp_int *k, ec_point_t * }; if (verilog_ecdsa256_multiplier) - return verilog_point_pick_random(&verilog_p256_driver, k, P); + return verilog_point_pick_random(&p256_driver, k, P); #endif @@ -876,7 +876,7 @@ static inline hal_error_t verilog_p384_point_pick_random(fp_int *k, ec_point_t * { #if HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER - static const verilog_ecdsa_driver_t verilog_p384_driver = { + static const verilog_ecdsa_driver_t p384_driver = { .name = ECDSA384_NAME, .bytes = ECDSA384_OPERAND_BITS / 8, .k_addr = ECDSA384_ADDR_K, @@ -884,8 +884,8 @@ static inline hal_error_t verilog_p384_point_pick_random(fp_int *k, ec_point_t * .y_addr = ECDSA384_ADDR_Y }; - if (verilog_ecdsa256_multiplier) - return verilog_point_pick_random(&verilog_p256_driver, k, P); + if (verilog_ecdsa384_multiplier) + return verilog_point_pick_random(&p384_driver, k, P); #endif -- cgit v1.2.3 From ad9bca732bf9001aa5293ede674a52eada3118fa Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Fri, 3 Mar 2017 08:32:05 -0500 Subject: Doh! Works better if one tests the right status bit. --- ecdsa.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ecdsa.c') diff --git a/ecdsa.c b/ecdsa.c index bbb9865..3ca377b 100644 --- a/ecdsa.c +++ b/ecdsa.c @@ -828,7 +828,7 @@ static hal_error_t verilog_point_pick_random(const verilog_ecdsa_driver_t * cons check(hal_io_write(core, ADDR_CTRL, zero, sizeof(zero))); check(hal_io_next(core)); - check(hal_io_wait_ready(core)); + check(hal_io_wait_valid(core)); for (int i = 0; i < sizeof(b); i += 4) check(hal_io_read(core, driver->x_addr + i/4, &b[sizeof(b) - 4 - i], 4)); -- cgit v1.2.3 From 00d93e0898d5ba5ff3c749105569b23a16c7b0cc Mon Sep 17 00:00:00 2001 From: Rob Austein Date: Wed, 8 Mar 2017 23:23:41 -0500 Subject: Cleanup. --- ecdsa.c | 31 +++++-------------------------- 1 file changed, 5 insertions(+), 26 deletions(-) (limited to 'ecdsa.c') diff --git a/ecdsa.c b/ecdsa.c index 3ca377b..16d2b27 100644 --- a/ecdsa.c +++ b/ecdsa.c @@ -89,36 +89,17 @@ #endif /* - * Whether to use experimental Verilog ECDSA-P256 point multiplier. + * Whether to use the Verilog point multipliers. */ #ifndef HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER #define HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER 1 #endif -#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER -static int verilog_ecdsa256_multiplier = 1; -#endif - -/* - * Whether to use experimental Verilog ECDSA-P384 point multiplier. - */ - #ifndef HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER #define HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER 1 #endif -#if HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER -static int verilog_ecdsa384_multiplier = 1; -#endif - -/* - * Whether to include Verilog point multiplier code at all. - */ - -#define HAL_ECDSA_ANY_VERILOG_MULTIPLIER \ - (HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER | HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER) - /* * Whether we want debug output. */ @@ -790,7 +771,7 @@ static inline hal_error_t get_random(void *buffer, const size_t length) * the corresponding public key. */ -#if HAL_ECDSA_ANY_VERILOG_MULTIPLIER +#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER || HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER typedef struct { size_t bytes; @@ -864,8 +845,7 @@ static inline hal_error_t verilog_p256_point_pick_random(fp_int *k, ec_point_t * .y_addr = ECDSA256_ADDR_Y }; - if (verilog_ecdsa256_multiplier) - return verilog_point_pick_random(&p256_driver, k, P); + return verilog_point_pick_random(&p256_driver, k, P); #endif @@ -884,8 +864,7 @@ static inline hal_error_t verilog_p384_point_pick_random(fp_int *k, ec_point_t * .y_addr = ECDSA384_ADDR_Y }; - if (verilog_ecdsa384_multiplier) - return verilog_point_pick_random(&p384_driver, k, P); + return verilog_point_pick_random(&p384_driver, k, P); #endif @@ -936,7 +915,7 @@ static hal_error_t point_pick_random(const ecdsa_curve_t * const curve, memset(k_buf, 0, sizeof(k_buf)); -#if HAL_ECDSA_ANY_VERILOG_MULTIPLIER +#if HAL_ECDSA_VERILOG_ECDSA256_MULTIPLIER || HAL_ECDSA_VERILOG_ECDSA384_MULTIPLIER switch (curve->curve) { case HAL_CURVE_P256: -- cgit v1.2.3