360 lines
12 KiB
C++
360 lines
12 KiB
C++
|
|
#pragma once
|
||
|
|
|
||
|
|
#include <array>
|
||
|
|
#include <cassert>
|
||
|
|
#include <iostream>
|
||
|
|
#include <openssl/sha.h>
|
||
|
|
#include <sstream>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
#include "../native/secp256k1/include/secp256k1.h"
|
||
|
|
#include "hexxer.hpp"
|
||
|
|
#include "json.hpp"
|
||
|
|
|
||
|
|
typedef std::array<uint8_t, 32> uint8_t_32;
|
||
|
|
typedef std::array<uint8_t, 33> uint8_t_33;
|
||
|
|
typedef std::array<uint8_t, 64> uint8_t_64;
|
||
|
|
typedef std::array<uint8_t, 65> uint8_t_65;
|
||
|
|
typedef std::vector<uint8_t> uint8_t_vec;
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto vectorify (const A a) {
|
||
|
|
return uint8_t_vec(a.begin(), a.end());
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
uint32_t s = 0xdeadbeef;
|
||
|
|
uint32_t xorshift32() {
|
||
|
|
s ^= s << 13;
|
||
|
|
s ^= s >> 17;
|
||
|
|
s ^= s << 5;
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
auto randomUInt8 () {
|
||
|
|
return xorshift32() % 255;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto random () {
|
||
|
|
A a;
|
||
|
|
for (auto& x : a) x = randomUInt8();
|
||
|
|
return a;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto randomHigh () {
|
||
|
|
auto x = random<A>();
|
||
|
|
for (auto i = x.size() / 2; i < x.size(); ++i) {
|
||
|
|
x.at(i) = 0xff;
|
||
|
|
}
|
||
|
|
return x;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto randomLow () {
|
||
|
|
auto x = random<A>();
|
||
|
|
for (auto i = 0ul; i < x.size() / 2; ++i) {
|
||
|
|
x.at(i) = 0;
|
||
|
|
}
|
||
|
|
return x;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto fromUInt32 (const uint32_t i) {
|
||
|
|
A x;
|
||
|
|
x.fill(0);
|
||
|
|
const auto s = x.size();
|
||
|
|
x.at(s - 4) = i >> 24;
|
||
|
|
x.at(s - 3) = i >> 16;
|
||
|
|
x.at(s - 2) = i >> 8;
|
||
|
|
x.at(s - 1) = i & 0xff;
|
||
|
|
return x;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto randomScalar () { return random<uint8_t_32>(); }
|
||
|
|
auto randomScalarHigh () { return randomHigh<uint8_t_32>(); }
|
||
|
|
auto randomScalarLow () { return randomLow<uint8_t_32>(); }
|
||
|
|
auto scalarFromUInt32 (const uint32_t i) { return fromUInt32<uint8_t_32>(i); }
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto fromHex (const std::string& s) {
|
||
|
|
assert(s.size() == sizeof(A) * 2);
|
||
|
|
A x;
|
||
|
|
auto i = 0;
|
||
|
|
for (auto& y : x) {
|
||
|
|
const auto a = s.at(i++);
|
||
|
|
const auto b = s.at(i++);
|
||
|
|
y = hexxer::decode(a, b);
|
||
|
|
}
|
||
|
|
return x;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto pointFromHex (const std::string& s) {
|
||
|
|
if (s.size() == 66) return vectorify(fromHex<uint8_t_33>(s));
|
||
|
|
if (s.size() == 130) return vectorify(fromHex<uint8_t_65>(s));
|
||
|
|
assert(false);
|
||
|
|
}
|
||
|
|
auto scalarFromHex (const std::string& s) { return fromHex<uint8_t_32>(s); }
|
||
|
|
auto signatureFromHex (const std::string& s) { return fromHex<uint8_t_64>(s); }
|
||
|
|
|
||
|
|
secp256k1_context* ctx = nullptr;
|
||
|
|
|
||
|
|
auto randomPrivate () {
|
||
|
|
while (true) {
|
||
|
|
const auto key = randomScalar();
|
||
|
|
if (secp256k1_ec_seckey_verify(ctx, key.data())) return key;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
auto randomPrivateHigh () {
|
||
|
|
while (true) {
|
||
|
|
const auto key = randomScalarHigh();
|
||
|
|
if (secp256k1_ec_seckey_verify(ctx, key.data())) return key;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
auto randomPrivateLow () {
|
||
|
|
while (true) {
|
||
|
|
const auto key = randomScalarLow();
|
||
|
|
if (secp256k1_ec_seckey_verify(ctx, key.data())) return key;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// utility functions
|
||
|
|
void _ec_init () {
|
||
|
|
ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
|
||
|
|
}
|
||
|
|
|
||
|
|
auto _privAdd (uint8_t_32 key, const uint8_t_32 tweak, bool& ok) {
|
||
|
|
ok &= secp256k1_ec_privkey_tweak_add(ctx, key.data(), tweak.data());
|
||
|
|
return key;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto _privSub (uint8_t_32 key, uint8_t_32 tweak, bool& ok) {
|
||
|
|
ok &= secp256k1_ec_privkey_negate(ctx, tweak.data());
|
||
|
|
ok &= secp256k1_ec_privkey_tweak_add(ctx, key.data(), tweak.data());
|
||
|
|
return key;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
uint8_t_vec _ec_pubkey_to_vec (const secp256k1_pubkey& public_key, bool& ok) {
|
||
|
|
static_assert(sizeof(A) == 33 || sizeof(A) == 65);
|
||
|
|
if (!ok) return {};
|
||
|
|
A out;
|
||
|
|
size_t outlen = out.size();
|
||
|
|
ok &= secp256k1_ec_pubkey_serialize(ctx, out.data(), &outlen, &public_key,
|
||
|
|
sizeof(A) == 33 ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED);
|
||
|
|
return vectorify<A>(out);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A, typename V>
|
||
|
|
auto _pointAdd (const V p, const V q, bool& ok) {
|
||
|
|
secp256k1_pubkey a, b;
|
||
|
|
ok &= secp256k1_ec_pubkey_parse(ctx, &a, p.data(), p.size());
|
||
|
|
ok &= secp256k1_ec_pubkey_parse(ctx, &b, q.data(), q.size());
|
||
|
|
|
||
|
|
const secp256k1_pubkey* points[] = { &a, &b };
|
||
|
|
secp256k1_pubkey public_key;
|
||
|
|
ok &= secp256k1_ec_pubkey_combine(ctx, &public_key, points, 2);
|
||
|
|
|
||
|
|
return _ec_pubkey_to_vec<A>(public_key, ok);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A, typename V>
|
||
|
|
auto _pointMul (const V p, const uint8_t_32 d, bool& ok) {
|
||
|
|
secp256k1_pubkey public_key;
|
||
|
|
ok &= secp256k1_ec_pubkey_parse(ctx, &public_key, p.data(), p.size());
|
||
|
|
ok &= secp256k1_ec_pubkey_tweak_mul(ctx, &public_key, d.data());
|
||
|
|
return _ec_pubkey_to_vec<A>(public_key, ok);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A, typename V>
|
||
|
|
auto _pointAddScalar (const V p, const uint8_t_32 d, bool& ok) {
|
||
|
|
secp256k1_pubkey public_key;
|
||
|
|
ok &= secp256k1_ec_pubkey_parse(ctx, &public_key, p.data(), p.size());
|
||
|
|
ok &= secp256k1_ec_pubkey_tweak_add(ctx, &public_key, d.data());
|
||
|
|
return _ec_pubkey_to_vec<A>(public_key, ok);
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t_vec _pointFlip (const uint8_t_vec& p) {
|
||
|
|
assert(!p.empty());
|
||
|
|
|
||
|
|
secp256k1_pubkey public_key;
|
||
|
|
bool ok = secp256k1_ec_pubkey_parse(ctx, &public_key, p.data(), p.size());
|
||
|
|
assert(ok);
|
||
|
|
|
||
|
|
uint8_t_vec r;
|
||
|
|
if (p.size() == 33) r = _ec_pubkey_to_vec<uint8_t_65>(public_key, ok);
|
||
|
|
else r = _ec_pubkey_to_vec<uint8_t_33>(public_key, ok);
|
||
|
|
assert(ok);
|
||
|
|
|
||
|
|
return std::move(r);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto _pointFromScalar (const uint8_t_32 s, bool& ok) {
|
||
|
|
secp256k1_pubkey public_key;
|
||
|
|
ok &= secp256k1_ec_pubkey_create(ctx, &public_key, s.data());
|
||
|
|
return _ec_pubkey_to_vec<A>(public_key, ok);
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto _pointFromUInt32 (const uint32_t i, bool& ok) {
|
||
|
|
return _pointFromScalar<A>(scalarFromUInt32(i), ok);
|
||
|
|
}
|
||
|
|
|
||
|
|
auto _pointFromX (const uint8_t_32 x, uint8_t prefix) {
|
||
|
|
uint8_t_vec p = { prefix };
|
||
|
|
p.reserve(33);
|
||
|
|
for (auto i : x) p.emplace_back(i);
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto _pointFromXY (const uint8_t_32 x, const uint8_t_32 y, const uint8_t prefix = 0x04) {
|
||
|
|
uint8_t_vec p = { prefix };
|
||
|
|
p.reserve(65);
|
||
|
|
for (auto i : x) p.emplace_back(i);
|
||
|
|
for (auto i : y) p.emplace_back(i);
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto _signatureFromRS (const uint8_t_32 r, const uint8_t_32 s) {
|
||
|
|
uint8_t_64 sig;
|
||
|
|
std::copy(r.begin(), r.end(), sig.begin());
|
||
|
|
std::copy(s.begin(), s.end(), sig.begin() + 32);
|
||
|
|
return sig;
|
||
|
|
}
|
||
|
|
|
||
|
|
auto _eccSign (const uint8_t_32 d, const uint8_t_32 message, bool& ok) {
|
||
|
|
uint8_t_64 output;
|
||
|
|
secp256k1_ecdsa_signature signature;
|
||
|
|
ok &= secp256k1_ecdsa_sign(ctx, &signature, message.data(), d.data(), nullptr, nullptr);
|
||
|
|
ok &= secp256k1_ecdsa_signature_serialize_compact(ctx, output.data(), &signature);
|
||
|
|
return output;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto _eccVerify (const A& p, const uint8_t_32 message, const uint8_t_64 signature) {
|
||
|
|
secp256k1_pubkey public_key;
|
||
|
|
bool ok = true;
|
||
|
|
ok &= secp256k1_ec_pubkey_parse(ctx, &public_key, p.data(), p.size());
|
||
|
|
if (!ok) return false;
|
||
|
|
|
||
|
|
secp256k1_ecdsa_signature _signature;
|
||
|
|
ok &= secp256k1_ecdsa_signature_parse_compact(ctx, &_signature, signature.data());
|
||
|
|
if (!ok) return false;
|
||
|
|
|
||
|
|
ok &= secp256k1_ecdsa_verify(ctx, &_signature, message.data(), &public_key);
|
||
|
|
return ok;
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename A>
|
||
|
|
auto sha256 (const A& m) {
|
||
|
|
uint8_t_32 h;
|
||
|
|
SHA256_CTX hctx;
|
||
|
|
SHA256_Init(&hctx);
|
||
|
|
SHA256_Update(&hctx, m.data(), m.size());
|
||
|
|
SHA256_Final(h.data(), &hctx);
|
||
|
|
return h;
|
||
|
|
}
|
||
|
|
|
||
|
|
// we use 0xfefefefefefefe.... as a null placeholder
|
||
|
|
template <typename A>
|
||
|
|
auto Null () {
|
||
|
|
A a;
|
||
|
|
a.fill(0xfe);
|
||
|
|
return a;
|
||
|
|
}
|
||
|
|
template <typename A>
|
||
|
|
auto isNull (const A& a) {
|
||
|
|
for (auto x : a) if (x != 0xfe) return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
const auto ZERO = scalarFromHex("0000000000000000000000000000000000000000000000000000000000000000");
|
||
|
|
const auto ONE = scalarFromHex("0000000000000000000000000000000000000000000000000000000000000001");
|
||
|
|
const auto TWO = scalarFromHex("0000000000000000000000000000000000000000000000000000000000000002");
|
||
|
|
const auto THREE = scalarFromHex("0000000000000000000000000000000000000000000000000000000000000003");
|
||
|
|
const auto FOUR = scalarFromHex("0000000000000000000000000000000000000000000000000000000000000004");
|
||
|
|
const auto GROUP_ORDER = scalarFromHex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
|
||
|
|
const auto GROUP_ORDER_LESS_3 = scalarFromHex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e");
|
||
|
|
const auto GROUP_ORDER_LESS_2 = scalarFromHex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413f");
|
||
|
|
const auto GROUP_ORDER_LESS_1 = scalarFromHex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140");
|
||
|
|
const auto GROUP_ORDER_OVER_1 = scalarFromHex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364142");
|
||
|
|
const auto UINT256_MAX = scalarFromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
|
||
|
|
const auto G = pointFromHex("0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798");
|
||
|
|
const auto GU = pointFromHex("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8");
|
||
|
|
const auto P_LESS_1 = scalarFromHex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e");
|
||
|
|
const auto P_LESS_2 = scalarFromHex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2d");
|
||
|
|
const auto P = scalarFromHex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
|
||
|
|
const auto P_OVER_1 = scalarFromHex("fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc30");
|
||
|
|
|
||
|
|
template <typename A> struct B { A a; std::string desc = ""; };
|
||
|
|
|
||
|
|
const std::vector<B<uint8_t_32>> BAD_PRIVATES = {
|
||
|
|
{ ZERO, "Private key == 0" }, // #L3145, #L3684, fail, == 0
|
||
|
|
{ GROUP_ORDER, "Private key >= G" }, // #L3115, #L3670, fail, == G
|
||
|
|
{ GROUP_ORDER_OVER_1, "Private key >= G" }, // #L3162, #L3701, fail, >= G
|
||
|
|
{ UINT256_MAX, "Private key >= G" } // #L3131, #L3676, fail, > G
|
||
|
|
};
|
||
|
|
|
||
|
|
// excludes exact complement of a key, assumed to be tested elsewhere
|
||
|
|
const std::vector<B<uint8_t_32>> BAD_TWEAKS = {
|
||
|
|
{ GROUP_ORDER, "Tweak >= G" },
|
||
|
|
{ GROUP_ORDER_OVER_1, "Tweak >= G" },
|
||
|
|
{ UINT256_MAX, "Tweak >= G" }
|
||
|
|
};
|
||
|
|
|
||
|
|
const std::vector<B<uint8_t_64>> BAD_SIGNATURES_VERIFY = {
|
||
|
|
{ _signatureFromRS(ZERO, ZERO), "Invalid r, s values (== 0)" },
|
||
|
|
{ _signatureFromRS(ZERO, ONE), "Invalid r value (== 0)" },
|
||
|
|
{ _signatureFromRS(ONE, ZERO), "Invalid s value (== 0)" },
|
||
|
|
};
|
||
|
|
|
||
|
|
const std::vector<B<uint8_t_64>> BAD_SIGNATURES = {
|
||
|
|
{ _signatureFromRS(GROUP_ORDER, ONE), "Invalid r value (>= n)" },
|
||
|
|
{ _signatureFromRS(ONE, GROUP_ORDER), "Invalid s value (>= n)" }
|
||
|
|
};
|
||
|
|
|
||
|
|
// from https://github.com/cryptocoinjs/ecurve/blob/14d72f5f468d53ff33dc13c1c7af350a41d52aab/test/fixtures/point.json#L84
|
||
|
|
template <typename A = uint8_t_33>
|
||
|
|
std::vector<B<uint8_t_vec>> generateBadPoints () {
|
||
|
|
return {
|
||
|
|
{ _pointFromX(ONE, 0x01), "Bad sequence prefix" },
|
||
|
|
{ _pointFromX(ONE, 0x04), "Bad sequence prefix" },
|
||
|
|
{ _pointFromX(ONE, 0x05), "Bad sequence prefix" },
|
||
|
|
{ _pointFromX(ZERO, 0x02), "Bad X coordinate (== 0)" },
|
||
|
|
{ _pointFromX(ZERO, 0x03), "Bad X coordinate (== 0)" },
|
||
|
|
{ _pointFromX(P, 0x02), "Bad X coordinate (== P)" },
|
||
|
|
{ _pointFromX(P, 0x03), "Bad X coordinate (== P)" },
|
||
|
|
{ _pointFromX(P_LESS_2, 0x02), "Bad X coordinate (P - 2)" },
|
||
|
|
{ _pointFromX(P_LESS_2, 0x03), "Bad X coordinate (P - 2)" },
|
||
|
|
{ _pointFromX(P_OVER_1, 0x03), "Bad X coordinate (> P)" },
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
template <>
|
||
|
|
std::vector<B<uint8_t_vec>> generateBadPoints<uint8_t_65> () {
|
||
|
|
return {
|
||
|
|
{ _pointFromXY(ONE, ONE, 0x01), "Bad sequence prefix" },
|
||
|
|
{ _pointFromXY(ONE, ONE, 0x02), "Bad sequence prefix" },
|
||
|
|
{ _pointFromXY(ONE, ONE, 0x03), "Bad sequence prefix" },
|
||
|
|
{ _pointFromXY(ONE, ONE, 0x05), "Bad sequence prefix" },
|
||
|
|
{ _pointFromXY(ZERO, ONE), "Bad X coordinate (== 0)" },
|
||
|
|
{ _pointFromXY(ONE, ZERO), "Bad Y coordinate (== 0)" },
|
||
|
|
{ _pointFromXY(ZERO, ZERO, 0x04), "Bad X/Y coordinate (== 0)" },
|
||
|
|
{ _pointFromXY(P, ONE), "Bad X coordinate (== P)" },
|
||
|
|
{ _pointFromXY(ONE, P), "Bad Y coordinate (== P)" },
|
||
|
|
{ _pointFromXY(P_OVER_1, ONE), "Bad X coordinate (> P)" },
|
||
|
|
{ _pointFromXY(ONE, P_OVER_1), "Bad Y coordinate (> P)" },
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
const auto THROW_BAD_PRIVATE = "Expected Private";
|
||
|
|
const auto THROW_BAD_POINT = "Expected Point";
|
||
|
|
const auto THROW_BAD_TWEAK = "Expected Tweak";
|
||
|
|
const auto THROW_BAD_HASH = "Expected Hash";
|
||
|
|
const auto THROW_BAD_SIGNATURE = "Expected Signature";
|