360 lines
12 KiB
C++
Raw Permalink Normal View History

2025-06-21 23:30:33 +03:00
#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";