#ifndef _HOTSTUFF_CRYPTO_H
#define _HOTSTUFF_CRYPTO_H
#include <openssl/rand.h>
#include "secp256k1.h"
#include "salticidae/crypto.h"
#include "hotstuff/type.h"
namespace hotstuff {
using salticidae::SHA256;
class PubKey: public Serializable, Cloneable {
public:
virtual ~PubKey() = default;
virtual PubKey *clone() override = 0;
};
using pubkey_bt = BoxObj<PubKey>;
class PrivKey: public Serializable {
public:
virtual ~PrivKey() = default;
virtual pubkey_bt get_pubkey() const = 0;
virtual void from_rand() = 0;
};
using privkey_bt = BoxObj<PrivKey>;
class PartCert: public Serializable, public Cloneable {
public:
virtual ~PartCert() = default;
virtual bool verify(const PubKey &pubkey) = 0;
virtual const uint256_t &get_blk_hash() const = 0;
virtual PartCert *clone() override = 0;
};
class ReplicaConfig;
class QuorumCert: public Serializable, public Cloneable {
public:
virtual ~QuorumCert() = default;
virtual void add_part(ReplicaID replica, const PartCert &pc) = 0;
virtual void compute() = 0;
virtual bool verify(const ReplicaConfig &config) = 0;
virtual const uint256_t &get_blk_hash() const = 0;
virtual QuorumCert *clone() override = 0;
};
using part_cert_bt = BoxObj<PartCert>;
using quorum_cert_bt = BoxObj<QuorumCert>;
class PubKeyDummy: public PubKey {
PubKeyDummy *clone() override { return new PubKeyDummy(*this); }
void serialize(DataStream &) const override {}
void unserialize(DataStream &) override {}
};
class PrivKeyDummy: public PrivKey {
pubkey_bt get_pubkey() const override { return new PubKeyDummy(); }
void serialize(DataStream &) const override {}
void unserialize(DataStream &) override {}
void from_rand() override {}
};
class PartCertDummy: public PartCert {
uint256_t blk_hash;
public:
PartCertDummy() {}
PartCertDummy(const uint256_t &blk_hash):
blk_hash(blk_hash) {}
void serialize(DataStream &s) const override {
s << (uint32_t)0 << blk_hash;
}
void unserialize(DataStream &s) override {
uint32_t tmp;
s >> tmp >> blk_hash;
}
PartCert *clone() override {
return new PartCertDummy(blk_hash);
}
bool verify(const PubKey &) override { return true; }
const uint256_t &get_blk_hash() const override { return blk_hash; }
};
class QuorumCertDummy: public QuorumCert {
uint256_t blk_hash;
public:
QuorumCertDummy() {}
QuorumCertDummy(const ReplicaConfig &, const uint256_t &blk_hash):
blk_hash(blk_hash) {}
void serialize(DataStream &s) const override {
s << (uint32_t)1 << blk_hash;
}
void unserialize(DataStream &s) override {
uint32_t tmp;
s >> tmp >> blk_hash;
}
QuorumCert *clone() override {
return new QuorumCertDummy(*this);
}
void add_part(ReplicaID, const PartCert &) override {}
void compute() override {}
bool verify(const ReplicaConfig &) override { return true; }
const uint256_t &get_blk_hash() const override { return blk_hash; }
};
class Secp256k1Context {
secp256k1_context *ctx;
friend class PubKeySecp256k1;
friend class SigSecp256k1;
public:
Secp256k1Context(bool sign = false):
ctx(secp256k1_context_create(
sign ? SECP256K1_CONTEXT_SIGN :
SECP256K1_CONTEXT_VERIFY)) {}
Secp256k1Context(const Secp256k1Context &) = delete;
Secp256k1Context(Secp256k1Context &&other): ctx(other.ctx) {
other.ctx = nullptr;
}
~Secp256k1Context() {
if (ctx) secp256k1_context_destroy(ctx);
}
};
using secp256k1_context_t = RcObj<Secp256k1Context>;
extern secp256k1_context_t secp256k1_default_sign_ctx;
extern secp256k1_context_t secp256k1_default_verify_ctx;
class PrivKeySecp256k1;
class PubKeySecp256k1: public PubKey {
static const auto _olen = 33;
friend class SigSecp256k1;
secp256k1_pubkey data;
secp256k1_context_t ctx;
public:
PubKeySecp256k1(const secp256k1_context_t &ctx =
secp256k1_default_sign_ctx):
PubKey(), ctx(ctx) {}
PubKeySecp256k1(const bytearray_t &raw_bytes,
const secp256k1_context_t &ctx =
secp256k1_default_sign_ctx):
PubKeySecp256k1(ctx) { from_bytes(raw_bytes); }
inline PubKeySecp256k1(const PrivKeySecp256k1 &priv_key,
const secp256k1_context_t &ctx =
secp256k1_default_sign_ctx);
void serialize(DataStream &s) const override {
static uint8_t output[_olen];
size_t olen = _olen;
(void)secp256k1_ec_pubkey_serialize(
ctx->ctx, (unsigned char *)output,
&olen, &data, SECP256K1_EC_COMPRESSED);
s.put_data(output, output + _olen);
}
void unserialize(DataStream &s) override {
static const auto _exc = std::invalid_argument("ill-formed public key");
try {
if (!secp256k1_ec_pubkey_parse(
ctx->ctx, &data, s.get_data_inplace(_olen), _olen))
throw _exc;
} catch (std::ios_base::failure &) {
throw _exc;
}
}
PubKeySecp256k1 *clone() override {
return new PubKeySecp256k1(*this);
}
};
class PrivKeySecp256k1: public PrivKey {
static const auto nbytes = 32;
friend class PubKeySecp256k1;
friend class SigSecp256k1;
uint8_t data[nbytes];
secp256k1_context_t ctx;
public:
PrivKeySecp256k1(const secp256k1_context_t &ctx =
secp256k1_default_sign_ctx):
PrivKey(), ctx(ctx) {}
PrivKeySecp256k1(const bytearray_t &raw_bytes,
const secp256k1_context_t &ctx =
secp256k1_default_sign_ctx):
PrivKeySecp256k1(ctx) { from_bytes(raw_bytes); }
void serialize(DataStream &s) const override {
s.put_data(data, data