bool Page::isValid(bool deepTest)
{
Json::FastWriter writer;
std::string data = writer.write(getCommonData());
const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data.c_str());
int check =
ed25519_sign_open(bytes, data.size(), publicEd_.data(), pageSig_.data());
if (check == 0)
{
if (deepTest)
for (auto r : recordList_)
if (!r->isValid())
return false;
return true;
}
else if (check == 1)
{
return false;
}
else
{
Log::get().warn("General Ed25519 signature failure on Page signature.");
return false;
}
}
bool
verify (PublicKey const& publicKey,
Slice const& m,
Slice const& sig,
bool mustBeFullyCanonical)
{
if (auto const type = publicKeyType(publicKey))
{
if (*type == KeyType::secp256k1)
{
return verifyDigest (publicKey,
sha512Half(m), sig, mustBeFullyCanonical);
}
else if (*type == KeyType::ed25519)
{
if (! ed25519Canonical(sig))
return false;
// We internally prefix Ed25519 keys with a 0xED
// byte to distinguish them from secp256k1 keys
// so when verifying the signature, we need to
// first strip that prefix.
return ed25519_sign_open(
m.data(), m.size(), publicKey.data() + 1,
sig.data()) == 0;
}
}
return false;
}
bool
Ed25519::validate (Slice data) const
{
return ed25519_sign_open (
data.data(),
data.size(),
payload_.data(),
payload_.data() + pubkey_size_) == 0;
}
int main() {
int i, res;
ed25519_public_key pk;
ed25519_signature sig;
unsigned char forge[1024] = {'x'};
curved25519_key csk[2] = {{255}};
uint64_t ticks, pkticks = maxticks, signticks = maxticks, openticks = maxticks, curvedticks = maxticks;
for (i = 0; i < 1024; i++) {
ed25519_publickey(dataset[i].sk, pk);
edassertequal(dataset[i].pk, pk, sizeof(pk), i, "public key didn't match");
ed25519_sign((unsigned char *)dataset[i].m, i, dataset[i].sk, pk, sig);
edassertequal(dataset[i].sig, sig, sizeof(sig), i, "signature didn't match");
edassert(!ed25519_sign_open((unsigned char *)dataset[i].m, i, pk, sig), i, "failed to open message");
memcpy(forge, dataset[i].m, i);
if (i)
forge[i - 1] += 1;
edassert(ed25519_sign_open(forge, (i) ? i : 1, pk, sig), i, "opened forged message");
}
for (i = 0; i < 1024; i++)
curved25519_scalarmult_basepoint(csk[(i & 1) ^ 1], csk[i & 1]);
edassertequal(curved25519_expected, csk[0], sizeof(curved25519_key), 0, "curve25519 failed to generate correct value");
printf("success\n");
for (i = 0; i < 2048; i++) {
timeit(ed25519_publickey(dataset[0].sk, pk), pkticks)
edassertequal(dataset[0].pk, pk, sizeof(pk), i, "public key didn't match");
timeit(ed25519_sign((unsigned char *)dataset[0].m, 0, dataset[0].sk, pk, sig), signticks)
edassertequal(dataset[0].sig, sig, sizeof(sig), i, "signature didn't match");
timeit(res = ed25519_sign_open((unsigned char *)dataset[0].m, 0, pk, sig), openticks)
edassert(!res, 0, "failed to open message");
timeit(curved25519_scalarmult_basepoint(csk[1], csk[0]), curvedticks);
}
printf("%.0f ticks/public key generation\n", (double)pkticks);
printf("%.0f ticks/signature\n", (double)signticks);
printf("%.0f ticks/signature verification\n", (double)openticks);
printf("%.0f ticks/curve25519 basepoint scalarmult\n", (double)curvedticks);
return 0;
}
bool
verify_ed25519 (void const* pk,
void const* msg, std::size_t msg_size,
void const* sig, std::size_t sig_size)
{
if (sig_size != 64)
return false;
ed25519_public_key epk;
ed25519_signature es;
std::memcpy(epk, pk, 32);
std::memcpy(es, sig, sig_size);
return ed25519_sign_open(
reinterpret_cast<unsigned char const*>(msg),
msg_size, epk, es) == 0;
}
// modifies sig in place
std::pair<bool, int> Common::verifyRootSignature(const Json::Value& sigObj,
ED_SIGNATURE& sig,
const SHA384_HASH& root,
const std::string& key)
{
// sanity check
if (!sigObj.isMember("signature") || !sigObj.isMember("count"))
{
Log::get().warn("Invalid root signature.");
return std::make_pair(false, -1);
}
// decode signature
if (Botan::base64_decode(sig.data(), sigObj["signature"].asString()) !=
sig.size())
{
Log::get().warn("Invalid root signature length from Quorum node.");
return std::make_pair(false, -1);
}
// decode public key
ED_KEY qPubKey;
if (Botan::base64_decode(qPubKey.data(), key) != Const::ED25519_KEY_LEN)
{
Log::get().warn("Quorum node key has an invalid length.");
return std::make_pair(false, -1);
}
// check signature
int status = ed25519_sign_open(root.data(), Const::SHA384_LEN, qPubKey.data(),
sig.data());
// announce results
if (status == 0)
Log::get().notice("Valid Ed25519 Quorum signature on root.");
else if (status == 1)
Log::get().warn("Invalid Ed25519 Quorum signature on root.");
else
Log::get().warn("General Ed25519 signature failure on root.");
return std::make_pair(status == 0, sigObj["count"].asInt());
}
//not modify
bool PublicKey::Verify(const std::string &data, const std::string &signature, const std::string &encode_public_key) {
PrivateKeyPrefix prefix;
SignatureType sign_type;
std::string raw_pubkey;
bool valid = GetPublicKeyElement(encode_public_key, prefix, sign_type, raw_pubkey);
if (!valid || prefix != PUBLICKEY_PREFIX) {
return false;
}
if (signature.size() != 64) { return false; }
if (sign_type == SIGNTYPE_ED25519 ) {
return ed25519_sign_open((unsigned char *)data.c_str(), data.size(), (unsigned char *)raw_pubkey.c_str(), (unsigned char *)signature.c_str()) == 0;
}
else if (sign_type == SIGNTYPE_CFCASM2) {
return utils::EccSm2::verify(utils::EccSm2::GetCFCAGroup(), raw_pubkey, "1234567812345678", data, signature) == 1;
}
else{
LOG_ERROR("Unknown signature type(%d)", sign_type);
}
return false;
}
bool lisk_verify_message(const LiskVerifyMessage *msg) {
uint8_t hash[32];
lisk_message_hash(msg->message.bytes, msg->message.size, hash);
return 0 == ed25519_sign_open(hash, 32, msg->public_key.bytes,
msg->signature.bytes);
}
