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); }