-// Copyright (c) 2013 Pieter Wuille
-// Distributed under the MIT/X11 software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+/**********************************************************************
+ * Copyright (c) 2013, 2014 Pieter Wuille *
+ * Distributed under the MIT software license, see the accompanying *
+ * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
+ **********************************************************************/
+
+#define SECP256K1_BUILD (1)
#include "include/secp256k1.h"
-#include <assert.h>
#include "util.h"
#include "num_impl.h"
#include "field_impl.h"
+#include "scalar_impl.h"
#include "group_impl.h"
#include "ecmult_impl.h"
#include "ecmult_gen_impl.h"
#include "ecdsa_impl.h"
+#include "eckey_impl.h"
void secp256k1_start(unsigned int flags) {
secp256k1_fe_start();
DEBUG_CHECK(pubkey != NULL);
int ret = -3;
- secp256k1_num_t m;
- secp256k1_num_init(&m);
+ secp256k1_num_t m;
secp256k1_ecdsa_sig_t s;
- secp256k1_ecdsa_sig_init(&s);
secp256k1_ge_t q;
secp256k1_num_set_bin(&m, msg, msglen);
- if (!secp256k1_ecdsa_pubkey_parse(&q, pubkey, pubkeylen)) {
+ if (!secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen)) {
ret = -1;
goto end;
}
}
ret = 1;
end:
- secp256k1_ecdsa_sig_free(&s);
- secp256k1_num_free(&m);
return ret;
}
DEBUG_CHECK(seckey != NULL);
DEBUG_CHECK(nonce != NULL);
- secp256k1_num_t sec, non, msg;
- secp256k1_num_init(&sec);
- secp256k1_num_init(&non);
- secp256k1_num_init(&msg);
- secp256k1_num_set_bin(&sec, seckey, 32);
- secp256k1_num_set_bin(&non, nonce, 32);
- secp256k1_num_set_bin(&msg, message, messagelen);
- int ret = !secp256k1_num_is_zero(&non) &&
- (secp256k1_num_cmp(&non, &secp256k1_ge_consts->order) < 0);
+ secp256k1_scalar_t sec, non, msg;
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
+ int overflow = 0;
+ secp256k1_scalar_set_b32(&non, nonce, &overflow);
+ {
+ unsigned char c[32] = {0};
+ memcpy(c + 32 - messagelen, message, messagelen);
+ secp256k1_scalar_set_b32(&msg, c, NULL);
+ memset(c, 0, 32);
+ }
+ int ret = !secp256k1_scalar_is_zero(&non) && !overflow;
secp256k1_ecdsa_sig_t sig;
- secp256k1_ecdsa_sig_init(&sig);
if (ret) {
ret = secp256k1_ecdsa_sig_sign(&sig, &sec, &msg, &non, NULL);
}
if (ret) {
secp256k1_ecdsa_sig_serialize(signature, signaturelen, &sig);
}
- secp256k1_ecdsa_sig_free(&sig);
- secp256k1_num_clear(&msg);
- secp256k1_num_clear(&non);
- secp256k1_num_clear(&sec);
- secp256k1_num_free(&msg);
- secp256k1_num_free(&non);
- secp256k1_num_free(&sec);
+ secp256k1_scalar_clear(&msg);
+ secp256k1_scalar_clear(&non);
+ secp256k1_scalar_clear(&sec);
return ret;
}
DEBUG_CHECK(seckey != NULL);
DEBUG_CHECK(nonce != NULL);
- secp256k1_num_t sec, non, msg;
- secp256k1_num_init(&sec);
- secp256k1_num_init(&non);
- secp256k1_num_init(&msg);
- secp256k1_num_set_bin(&sec, seckey, 32);
- secp256k1_num_set_bin(&non, nonce, 32);
- secp256k1_num_set_bin(&msg, message, messagelen);
- int ret = !secp256k1_num_is_zero(&non) &&
- (secp256k1_num_cmp(&non, &secp256k1_ge_consts->order) < 0);
+ secp256k1_scalar_t sec, non, msg;
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
+ int overflow = 0;
+ secp256k1_scalar_set_b32(&non, nonce, &overflow);
+ {
+ unsigned char c[32] = {0};
+ memcpy(c + 32 - messagelen, message, messagelen);
+ secp256k1_scalar_set_b32(&msg, c, NULL);
+ memset(c, 0, 32);
+ }
+ int ret = !secp256k1_scalar_is_zero(&non) && !overflow;
secp256k1_ecdsa_sig_t sig;
- secp256k1_ecdsa_sig_init(&sig);
if (ret) {
ret = secp256k1_ecdsa_sig_sign(&sig, &sec, &msg, &non, recid);
}
secp256k1_num_get_bin(sig64, 32, &sig.r);
secp256k1_num_get_bin(sig64 + 32, 32, &sig.s);
}
- secp256k1_ecdsa_sig_free(&sig);
- secp256k1_num_clear(&msg);
- secp256k1_num_clear(&non);
- secp256k1_num_clear(&sec);
- secp256k1_num_free(&msg);
- secp256k1_num_free(&non);
- secp256k1_num_free(&sec);
+ secp256k1_scalar_clear(&msg);
+ secp256k1_scalar_clear(&non);
+ secp256k1_scalar_clear(&sec);
return ret;
}
DEBUG_CHECK(recid >= 0 && recid <= 3);
int ret = 0;
- secp256k1_num_t m;
- secp256k1_num_init(&m);
+ secp256k1_num_t m;
secp256k1_ecdsa_sig_t sig;
- secp256k1_ecdsa_sig_init(&sig);
secp256k1_num_set_bin(&sig.r, sig64, 32);
secp256k1_num_set_bin(&sig.s, sig64 + 32, 32);
secp256k1_num_set_bin(&m, msg, msglen);
secp256k1_ge_t q;
if (secp256k1_ecdsa_sig_recover(&sig, &q, &m, recid)) {
- secp256k1_ecdsa_pubkey_serialize(&q, pubkey, pubkeylen, compressed);
+ secp256k1_eckey_pubkey_serialize(&q, pubkey, pubkeylen, compressed);
ret = 1;
}
- secp256k1_ecdsa_sig_free(&sig);
- secp256k1_num_free(&m);
return ret;
}
int secp256k1_ec_seckey_verify(const unsigned char *seckey) {
DEBUG_CHECK(seckey != NULL);
- secp256k1_num_t sec;
- secp256k1_num_init(&sec);
- secp256k1_num_set_bin(&sec, seckey, 32);
- int ret = !secp256k1_num_is_zero(&sec) &&
- (secp256k1_num_cmp(&sec, &secp256k1_ge_consts->order) < 0);
- secp256k1_num_clear(&sec);
- secp256k1_num_free(&sec);
+ secp256k1_scalar_t sec;
+ int overflow;
+ secp256k1_scalar_set_b32(&sec, seckey, &overflow);
+ int ret = !secp256k1_scalar_is_zero(&sec) && !overflow;
+ secp256k1_scalar_clear(&sec);
return ret;
}
DEBUG_CHECK(pubkey != NULL);
secp256k1_ge_t q;
- return secp256k1_ecdsa_pubkey_parse(&q, pubkey, pubkeylen);
+ return secp256k1_eckey_pubkey_parse(&q, pubkey, pubkeylen);
}
int secp256k1_ec_pubkey_create(unsigned char *pubkey, int *pubkeylen, const unsigned char *seckey, int compressed) {
DEBUG_CHECK(pubkeylen != NULL);
DEBUG_CHECK(seckey != NULL);
- secp256k1_num_t sec;
- secp256k1_num_init(&sec);
- secp256k1_num_set_bin(&sec, seckey, 32);
+ secp256k1_scalar_t sec;
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
secp256k1_gej_t pj;
secp256k1_ecmult_gen(&pj, &sec);
- secp256k1_num_clear(&sec);
- secp256k1_num_free(&sec);
+ secp256k1_scalar_clear(&sec);
secp256k1_ge_t p;
secp256k1_ge_set_gej(&p, &pj);
- secp256k1_ecdsa_pubkey_serialize(&p, pubkey, pubkeylen, compressed);
+ secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, compressed);
return 1;
}
DEBUG_CHECK(pubkeylen != NULL);
secp256k1_ge_t p;
- if (!secp256k1_ecdsa_pubkey_parse(&p, pubkey, *pubkeylen))
+ if (!secp256k1_eckey_pubkey_parse(&p, pubkey, *pubkeylen))
return 0;
- secp256k1_ecdsa_pubkey_serialize(&p, pubkey, pubkeylen, 0);
+ secp256k1_eckey_pubkey_serialize(&p, pubkey, pubkeylen, 0);
return 1;
}
DEBUG_CHECK(seckey != NULL);
DEBUG_CHECK(tweak != NULL);
- int ret = 1;
- secp256k1_num_t term;
- secp256k1_num_init(&term);
- secp256k1_num_set_bin(&term, tweak, 32);
- if (secp256k1_num_cmp(&term, &secp256k1_ge_consts->order) >= 0)
- ret = 0;
- secp256k1_num_t sec;
- secp256k1_num_init(&sec);
+ secp256k1_scalar_t term;
+ int overflow = 0;
+ secp256k1_scalar_set_b32(&term, tweak, &overflow);
+ secp256k1_scalar_t sec;
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
+
+ int ret = secp256k1_eckey_privkey_tweak_add(&sec, &term) && !overflow;
if (ret) {
- secp256k1_num_set_bin(&sec, seckey, 32);
- secp256k1_num_add(&sec, &sec, &term);
- secp256k1_num_mod(&sec, &secp256k1_ge_consts->order);
- if (secp256k1_num_is_zero(&sec))
- ret = 0;
+ secp256k1_scalar_get_b32(seckey, &sec);
}
- if (ret)
- secp256k1_num_get_bin(seckey, 32, &sec);
- secp256k1_num_clear(&sec);
- secp256k1_num_clear(&term);
- secp256k1_num_free(&sec);
- secp256k1_num_free(&term);
+
+ secp256k1_scalar_clear(&sec);
+ secp256k1_scalar_clear(&term);
return ret;
}
DEBUG_CHECK(pubkey != NULL);
DEBUG_CHECK(tweak != NULL);
- int ret = 1;
secp256k1_num_t term;
- secp256k1_num_init(&term);
secp256k1_num_set_bin(&term, tweak, 32);
- if (secp256k1_num_cmp(&term, &secp256k1_ge_consts->order) >= 0)
- ret = 0;
secp256k1_ge_t p;
+ int ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);
if (ret) {
- if (!secp256k1_ecdsa_pubkey_parse(&p, pubkey, pubkeylen))
- ret = 0;
+ ret = secp256k1_eckey_pubkey_tweak_add(&p, &term);
}
if (ret) {
- secp256k1_gej_t pt;
- secp256k1_gej_set_ge(&pt, &p);
- secp256k1_num_t one;
- secp256k1_num_init(&one);
- secp256k1_num_set_int(&one, 1);
- secp256k1_ecmult(&pt, &pt, &one, &term);
- secp256k1_num_free(&one);
- if (secp256k1_gej_is_infinity(&pt))
- ret = 0;
- secp256k1_ge_set_gej(&p, &pt);
int oldlen = pubkeylen;
- secp256k1_ecdsa_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
+ secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
VERIFY_CHECK(pubkeylen == oldlen);
}
- secp256k1_num_free(&term);
+
return ret;
}
DEBUG_CHECK(seckey != NULL);
DEBUG_CHECK(tweak != NULL);
- int ret = 1;
- secp256k1_num_t factor;
- secp256k1_num_init(&factor);
- secp256k1_num_set_bin(&factor, tweak, 32);
- if (secp256k1_num_is_zero(&factor))
- ret = 0;
- if (secp256k1_num_cmp(&factor, &secp256k1_ge_consts->order) >= 0)
- ret = 0;
- secp256k1_num_t sec;
- secp256k1_num_init(&sec);
+ secp256k1_scalar_t factor;
+ int overflow = 0;
+ secp256k1_scalar_set_b32(&factor, tweak, &overflow);
+ secp256k1_scalar_t sec;
+ secp256k1_scalar_set_b32(&sec, seckey, NULL);
+ int ret = secp256k1_eckey_privkey_tweak_mul(&sec, &factor) && !overflow;
if (ret) {
- secp256k1_num_set_bin(&sec, seckey, 32);
- secp256k1_num_mod_mul(&sec, &sec, &factor, &secp256k1_ge_consts->order);
+ secp256k1_scalar_get_b32(seckey, &sec);
}
- if (ret)
- secp256k1_num_get_bin(seckey, 32, &sec);
- secp256k1_num_free(&sec);
- secp256k1_num_free(&factor);
+
+ secp256k1_scalar_clear(&sec);
+ secp256k1_scalar_clear(&factor);
return ret;
}
DEBUG_CHECK(pubkey != NULL);
DEBUG_CHECK(tweak != NULL);
- int ret = 1;
secp256k1_num_t factor;
- secp256k1_num_init(&factor);
secp256k1_num_set_bin(&factor, tweak, 32);
- if (secp256k1_num_is_zero(&factor))
- ret = 0;
- if (secp256k1_num_cmp(&factor, &secp256k1_ge_consts->order) >= 0)
- ret = 0;
secp256k1_ge_t p;
+ int ret = secp256k1_eckey_pubkey_parse(&p, pubkey, pubkeylen);
if (ret) {
- if (!secp256k1_ecdsa_pubkey_parse(&p, pubkey, pubkeylen))
- ret = 0;
+ ret = secp256k1_eckey_pubkey_tweak_mul(&p, &factor);
}
if (ret) {
- secp256k1_num_t zero;
- secp256k1_num_init(&zero);
- secp256k1_num_set_int(&zero, 0);
- secp256k1_gej_t pt;
- secp256k1_gej_set_ge(&pt, &p);
- secp256k1_ecmult(&pt, &pt, &factor, &zero);
- secp256k1_num_free(&zero);
- secp256k1_ge_set_gej(&p, &pt);
int oldlen = pubkeylen;
- secp256k1_ecdsa_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
+ secp256k1_eckey_pubkey_serialize(&p, pubkey, &pubkeylen, oldlen <= 33);
VERIFY_CHECK(pubkeylen == oldlen);
}
- secp256k1_num_free(&factor);
+
return ret;
}
DEBUG_CHECK(privkey != NULL);
DEBUG_CHECK(privkeylen != NULL);
- secp256k1_num_t key;
- secp256k1_num_init(&key);
- secp256k1_num_set_bin(&key, seckey, 32);
- int ret = secp256k1_ecdsa_privkey_serialize(privkey, privkeylen, &key, compressed);
- secp256k1_num_free(&key);
+ secp256k1_scalar_t key;
+ secp256k1_scalar_set_b32(&key, seckey, NULL);
+ int ret = secp256k1_eckey_privkey_serialize(privkey, privkeylen, &key, compressed);
+ secp256k1_scalar_clear(&key);
return ret;
}
DEBUG_CHECK(seckey != NULL);
DEBUG_CHECK(privkey != NULL);
- secp256k1_num_t key;
- secp256k1_num_init(&key);
- int ret = secp256k1_ecdsa_privkey_parse(&key, privkey, privkeylen);
+ secp256k1_scalar_t key;
+ int ret = secp256k1_eckey_privkey_parse(&key, privkey, privkeylen);
if (ret)
- secp256k1_num_get_bin(seckey, 32, &key);
- secp256k1_num_free(&key);
+ secp256k1_scalar_get_b32(seckey, &key);
+ secp256k1_scalar_clear(&key);
return ret;
}
projects / secp256k1.git / blobdiff