void SerializedValidation::sign(uint256& signingHash, const RippleAddress& raPriv)
{
signingHash = getSigningHash();
std::vector<unsigned char> signature;
raPriv.signNodePrivate(signingHash, signature);
setFieldVL(sfSignature, signature);
}
Blob const& LedgerProposal::sign (RippleAddress const& privateKey)
{
privateKey.signNodePrivate (getSigningHash (), signature_);
mSuppression = proposalUniqueId (mCurrentHash, mPreviousLedger, mProposeSeq,
mCloseTime, mPublicKey.getNodePublic (), signature_);
return signature_;
}
void SerializedValidation::sign (uint256& signingHash, const RippleAddress& raPriv)
{
setFlag (vfFullyCanonicalSig);
signingHash = getSigningHash ();
Blob signature;
raPriv.signNodePrivate (signingHash, signature);
setFieldVL (sfSignature, signature);
}
uint256 STValidation::sign (SecretKey const& secretKey)
{
setFlag (vfFullyCanonicalSig);
auto const signingHash = getSigningHash();
setFieldVL (sfSignature,
signDigest (getSignerPublic(), secretKey, signingHash));
return signingHash;
}
bool LedgerProposal::checkSign (std::string const& signature) const
{
auto const valid = mPublicKey.verifyNodePublic(
getSigningHash(), signature, ECDSA::not_strict);
HashStream h;
hash_append(h);
assert(valid == (publicKey_.verify(
Slice(h.data(), h.size()),
makeSlice(signature), false)));
return valid;
}
STValidation::STValidation(
uint256 const& ledgerHash,
std::uint32_t ledgerSeq,
uint256 const& consensusHash,
NetClock::time_point signTime,
PublicKey const& publicKey,
SecretKey const& secretKey,
NodeID const& nodeID,
bool isFull,
FeeSettings const& fees,
std::vector<uint256> const& amendments)
: STObject(getFormat(), sfValidation), mNodeID(nodeID), mSeen(signTime)
{
// This is our own public key and it should always be valid.
if (!publicKeyType(publicKey))
LogicError("Invalid validation public key");
assert(mNodeID.isNonZero());
setFieldH256(sfLedgerHash, ledgerHash);
setFieldH256(sfConsensusHash, consensusHash);
setFieldU32(sfSigningTime, signTime.time_since_epoch().count());
setFieldVL(sfSigningPubKey, publicKey.slice());
if (isFull)
setFlag(kFullFlag);
setFieldU32(sfLedgerSequence, ledgerSeq);
if (fees.loadFee)
setFieldU32(sfLoadFee, *fees.loadFee);
if (fees.baseFee)
setFieldU64(sfBaseFee, *fees.baseFee);
if (fees.reserveBase)
setFieldU32(sfReserveBase, *fees.reserveBase);
if (fees.reserveIncrement)
setFieldU32(sfReserveIncrement, *fees.reserveIncrement);
if (!amendments.empty())
setFieldV256(sfAmendments, STVector256(sfAmendments, amendments));
setFlag(vfFullyCanonicalSig);
auto const signingHash = getSigningHash();
setFieldVL(
sfSignature, signDigest(getSignerPublic(), secretKey, signingHash));
setTrusted();
}
Blob LedgerProposal::sign (void)
{
Blob ret;
mPrivateKey.signNodePrivate (getSigningHash (), ret);
// XXX If this can fail, find out sooner.
// if (!mPrivateKey.signNodePrivate(getSigningHash(), ret))
// throw std::runtime_error("unable to sign proposal");
mSuppression = computeSuppressionID (mCurrentHash, mPreviousLedger, mProposeSeq,
mCloseTime, mPublicKey.getNodePublic (), ret);
return ret;
}
bool STValidation::isValid () const
{
return isValid (getSigningHash ());
}
bool LedgerProposal::checkSign () const
{
return mPublicKey.verifyNodePublic(
getSigningHash(), signature_, ECDSA::not_strict);
}
