bool RippleAddress::setSeedGeneric (const std::string& strText)
{
RippleAddress naTemp;
bool bResult = true;
uint256 uSeed;
if (strText.empty ()
|| naTemp.setAccountID (strText)
|| naTemp.setAccountPublic (strText)
|| naTemp.setAccountPrivate (strText)
|| naTemp.setNodePublic (strText)
|| naTemp.setNodePrivate (strText))
{
bResult = false;
}
else if (strText.length () == 32 && uSeed.SetHex (strText, true))
{
setSeed (uSeed);
}
else if (setSeed (strText))
{
// Log::out() << "Recognized seed.";
nothing ();
}
else
{
// Log::out() << "Creating seed from pass phrase.";
setSeed (EdKeyPair::passPhraseToKey (strText));
}
return bResult;
}
RippleAddress RippleAddress::createNodePublic(const std::vector<unsigned char>& vPublic)
{
RippleAddress naNew;
naNew.setNodePublic(vPublic);
return naNew;
}
RippleAddress RippleAddress::createNodePublic(const std::string& strPublic)
{
RippleAddress naNew;
naNew.setNodePublic(strPublic);
return naNew;
}
RippleAddress RippleAddress::createNodePublic (Blob const& vPublic)
{
RippleAddress naNew;
naNew.setNodePublic (vPublic);
return naNew;
}
RippleAddress RippleAddress::createNodePublic (RippleAddress const& naSeed)
{
RippleAddress naNew;
// YYY Should there be a GetPubKey() equiv that returns a uint256?
naNew.setNodePublic (generateRootDeterministicPublicKey (naSeed.getSeed()));
return naNew;
}
RippleAddress RippleAddress::createNodePublic(const RippleAddress& naSeed)
{
CKey ckSeed(naSeed.getSeed());
RippleAddress naNew;
// YYY Should there be a GetPubKey() equiv that returns a uint256?
naNew.setNodePublic(ckSeed.GetPubKey());
return naNew;
}
// {
// node: <domain>|<node_public>,
// comment: <comment> // optional
// }
Json::Value RPCHandler::doUnlAdd (Json::Value params, Resource::Charge& loadType, Application::ScopedLockType& masterLockHolder)
{
std::string strNode = params.isMember ("node") ? params["node"].asString () : "";
std::string strComment = params.isMember ("comment") ? params["comment"].asString () : "";
RippleAddress raNodePublic;
if (raNodePublic.setNodePublic (strNode))
{
getApp().getUNL ().nodeAddPublic (raNodePublic, UniqueNodeList::vsManual, strComment);
return "adding node by public key";
}
else
{
getApp().getUNL ().nodeAddDomain (strNode, UniqueNodeList::vsManual, strComment);
return "adding node by domain";
}
}
// {
// node: <domain>|<public_key>
// }
Json::Value doUnlDelete (RPC::Context& context)
{
auto lock = beast::make_lock(context.app.getMasterMutex());
if (!context.params.isMember (jss::node))
return rpcError (rpcINVALID_PARAMS);
auto strNode = context.params[jss::node].asString ();
RippleAddress raNodePublic;
if (raNodePublic.setNodePublic (strNode))
{
context.app.getUNL ().nodeRemovePublic (raNodePublic);
return RPC::makeObjectValue ("removing node by public key");
}
else
{
context.app.getUNL ().nodeRemoveDomain (strNode);
return RPC::makeObjectValue ("removing node by domain");
}
}
// {
// node: <domain>|<public_key>
// }
Json::Value RPCHandler::doUnlDelete (Json::Value params, Resource::Charge& loadType, Application::ScopedLockType& masterLockHolder)
{
if (!params.isMember ("node"))
return rpcError (rpcINVALID_PARAMS);
std::string strNode = params["node"].asString ();
RippleAddress raNodePublic;
if (raNodePublic.setNodePublic (strNode))
{
getApp().getUNL ().nodeRemovePublic (raNodePublic);
return "removing node by public key";
}
else
{
getApp().getUNL ().nodeRemoveDomain (strNode);
return "removing node by domain";
}
}
// {
// node: <domain>|<public_key>
// }
Json::Value doUnlDelete (RPC::Context& context)
{
if (!context.params_.isMember ("node"))
return rpcError (rpcINVALID_PARAMS);
std::string strNode = context.params_["node"].asString ();
RippleAddress raNodePublic;
if (raNodePublic.setNodePublic (strNode))
{
getApp().getUNL ().nodeRemovePublic (raNodePublic);
return "removing node by public key";
}
else
{
getApp().getUNL ().nodeRemoveDomain (strNode);
return "removing node by domain";
}
}
bool RippleAddress::setSeedGeneric(const std::string& strText)
{
RippleAddress naTemp;
bool bResult = true;
uint128 uSeed;
if (strText.empty()
|| naTemp.setAccountID(strText)
|| naTemp.setAccountPublic(strText)
|| naTemp.setAccountPrivate(strText)
|| naTemp.setNodePublic(strText)
|| naTemp.setNodePrivate(strText))
{
bResult = false;
}
else if (strText.length() == 32 && uSeed.SetHex(strText, true))
{
setSeed(uSeed);
}
else if (setSeed(strText))
{
// std::cerr << "Recognized seed." << std::endl;
nothing();
}
else if (1 == setSeed1751(strText))
{
// std::cerr << "Recognized 1751 seed." << std::endl;
nothing();
}
else
{
// std::cerr << "Creating seed from pass phrase." << std::endl;
setSeed(CKey::PassPhraseToKey(strText));
}
return bResult;
}
bool RippleAddress::setSeedGeneric (std::string const& strText)
{
RippleAddress naTemp;
bool bResult = true;
uint128 uSeed;
if (parseBase58<AccountID>(strText))
return false;
if (strText.empty ()
|| naTemp.setAccountPublic (strText)
|| naTemp.setAccountPrivate (strText)
|| naTemp.setNodePublic (strText)
|| naTemp.setNodePrivate (strText))
{
bResult = false;
}
else if (strText.length () == 32 && uSeed.SetHex (strText, true))
{
setSeed (uSeed);
}
else if (setSeed (strText))
{
// Log::out() << "Recognized seed.";
}
else if (1 == setSeed1751 (strText))
{
// Log::out() << "Recognized 1751 seed.";
}
else
{
setSeed (PassPhraseToKey (strText));
}
return bResult;
}
RippleAddress SerializedValidation::getSignerPublic() const
{
RippleAddress a;
a.setNodePublic(getFieldVL(sfSigningPubKey));
return a;
}
std::pair<protocol::TMHello, bool>
parseHello (beast::http::message const& m, beast::Journal journal)
{
auto const& h = m.headers;
std::pair<protocol::TMHello, bool> result = { {}, false };
protocol::TMHello& hello = result.first;
// protocol version in TMHello is obsolete,
// it is supplanted by the values in the headers.
{
// Required
auto const iter = h.find ("Upgrade");
if (iter == h.end())
return result;
auto const versions = parse_ProtocolVersions(iter->second);
if (versions.empty())
return result;
hello.set_protoversion(
(static_cast<std::uint32_t>(versions.back().first) << 16) |
(static_cast<std::uint32_t>(versions.back().second)));
hello.set_protoversionmin(
(static_cast<std::uint32_t>(versions.front().first) << 16) |
(static_cast<std::uint32_t>(versions.front().second)));
}
{
// Required
auto const iter = h.find ("Public-Key");
if (iter == h.end())
return result;
RippleAddress addr;
addr.setNodePublic (iter->second);
if (! addr.isValid())
return result;
hello.set_nodepublic (iter->second);
}
{
// Required
auto const iter = h.find ("Session-Signature");
if (iter == h.end())
return result;
// TODO Security Review
hello.set_nodeproof (beast::base64_decode (iter->second));
}
{
auto const iter = h.find (m.request() ?
"User-Agent" : "Server");
if (iter != h.end())
hello.set_fullversion (iter->second);
}
{
auto const iter = h.find ("Network-Time");
if (iter != h.end())
{
std::uint64_t nettime;
if (! beast::lexicalCastChecked(nettime, iter->second))
return result;
hello.set_nettime (nettime);
}
}
{
auto const iter = h.find ("Ledger");
if (iter != h.end())
{
LedgerIndex ledgerIndex;
if (! beast::lexicalCastChecked(ledgerIndex, iter->second))
return result;
hello.set_ledgerindex (ledgerIndex);
}
}
{
auto const iter = h.find ("Closed-Ledger");
if (iter != h.end())
hello.set_ledgerclosed (beast::base64_decode (iter->second));
}
{
auto const iter = h.find ("Previous-Ledger");
if (iter != h.end())
hello.set_ledgerprevious (beast::base64_decode (iter->second));
}
result.second = true;
return result;
}
void run()
{
testBase58(RippleAddress::VER_NODE_PUBLIC, 'n');
testBase58(RippleAddress::VER_NODE_PRIVATE, 'h');
testBase58(RippleAddress::VER_ACCOUNT_PUBLIC, 'p');
testBase58(RippleAddress::VER_ACCOUNT_PRIVATE, 'h');
testBase58(RippleAddress::VER_SEED, 's');
// check pass phrase
std::string strPass("paysharesmaster");
std::string strBase58Seed("s3q5ZGX2ScQK2rJ4JATp7rND6X5npG3De8jMbB7tuvm2HAVHcCN");
std::string strBase58NodePublic("nfbbWHgJqzqfH1cfRpMdPRkJ19cxTsdHkBtz1SLJJQfyf9Ax6vd");
std::string strBase58AccountPublic("pGreoXKYybde1keKZwDCv8m5V1kT6JH37pgnTUVzdMkdygTixG8");
AccountPrivateKey accountPrivateKey;
NodePrivateKey nodePrivateKey;
accountPrivateKey.fromPassPhrase(strPass);
nodePrivateKey.fromPassPhrase(strPass);
expect(accountPrivateKey.base58Seed() == "s3q5ZGX2ScQK2rJ4JATp7rND6X5npG3De8jMbB7tuvm2HAVHcCN", accountPrivateKey.base58Seed());
expect(accountPrivateKey.base58AccountID() == "ganVp9o5emfzpwrG5QVUXqMv8AgLcdvySb", accountPrivateKey.base58AccountID());
expect(accountPrivateKey.base58PublicKey() == strBase58AccountPublic, accountPrivateKey.base58PublicKey());
expect(nodePrivateKey.base58PublicKey() == strBase58NodePublic, nodePrivateKey.base58PublicKey());
Blob sig;
uint256 message;
accountPrivateKey.sign(message, sig);
PaysharesPublicKey publicKey(accountPrivateKey.getPublicKey(), RippleAddress::VER_NODE_PUBLIC);
expect(publicKey.verifySignature(message, sig), "Signature didn't verify");
expect(publicKey.getAccountID() == accountPrivateKey.getAccountID(), "Account Id's mis match");
expect(publicKey.base58AccountID() == accountPrivateKey.base58AccountID(), "Account Id's mis match");
Blob nonCanonicalSig(sig);
add_l(nonCanonicalSig.data() + 32);
expect(sig != nonCanonicalSig, "Non-canonical signature equal to canonical signature");
expect(crypto_sign_verify_detached(nonCanonicalSig.data(),
message.data(), message.bytes,
publicKey.vchData.data()) == 0,
"Non-canonical signature didn't verify (ignoring canonical-ness)");
expect(!publicKey.verifySignature(message, nonCanonicalSig), "Non-canonical signature verified");
AccountPrivateKey privateKey2;
privateKey2.fromString(strBase58Seed); // key from base58seed
expect(privateKey2.base58Seed() == "s3q5ZGX2ScQK2rJ4JATp7rND6X5npG3De8jMbB7tuvm2HAVHcCN", privateKey2.base58Seed());
expect(privateKey2.base58AccountID() == "ganVp9o5emfzpwrG5QVUXqMv8AgLcdvySb", privateKey2.base58AccountID());
expect(privateKey2.base58PublicKey() == strBase58AccountPublic, privateKey2.base58PublicKey());
privateKey2.sign(message, sig);
expect(publicKey.verifySignature(message, sig), "Signature didn't verify"); // check with the previous pubkey
// check random
/// ======= OLD ====
// Construct a seed.
RippleAddress naSeed;
expect(naSeed.setSeedGeneric("masterpassphrase"));
expect(naSeed.humanSeed() == "s3q5ZGX2ScQK2rJ4JATp7rND6X5npG3De8jMbB7tuvm2HAVHcCN", naSeed.humanSeed());
// Create node public/private key pair
RippleAddress naNodePublic = RippleAddress::createNodePublic(naSeed);
expect(naNodePublic.verifySignature(message, sig), "Signature didn't verify");
expect(naNodePublic.humanNodePublic() == strBase58NodePublic, naNodePublic.humanNodePublic());
naNodePublic.setNodePublic(strBase58NodePublic);
expect(naNodePublic.verifySignature(message, sig), "Signature didn't verify");
expect(naNodePublic.humanNodePublic() == strBase58NodePublic, naNodePublic.humanNodePublic());
RippleAddress naAccountPublic = RippleAddress::createAccountPublic(naSeed);
expect(naAccountPublic.humanAccountID() == "ganVp9o5emfzpwrG5QVUXqMv8AgLcdvySb", naAccountPublic.humanAccountID());
expect(naAccountPublic.verifySignature(message, sig), "Signature didn't verify");
expect(naAccountPublic.humanAccountPublic() == strBase58AccountPublic, naAccountPublic.humanAccountPublic());
naAccountPublic.setAccountPublic(strBase58AccountPublic);
expect(naAccountPublic.humanAccountID() == "ganVp9o5emfzpwrG5QVUXqMv8AgLcdvySb", naAccountPublic.humanAccountID());
expect(naAccountPublic.verifySignature(message, sig), "Signature didn't verify");
expect(naAccountPublic.humanAccountPublic() == strBase58AccountPublic, naAccountPublic.humanAccountPublic());
Blob rippleSig;
RippleAddress naAccountPrivate = RippleAddress::createAccountPrivate(naSeed);
naAccountPrivate.sign(message, rippleSig);
expect(rippleSig==sig, "Signature don't match");
RippleAddress naNodePrivate = RippleAddress::createNodePrivate(naSeed);
naNodePrivate.sign(message, rippleSig);
expect(rippleSig == sig, "Signature don't match");
std::string strPrivateKey("ssQMHypYAPSPgniSyvJQccuL1dJUbXJWVgAPV5QcAuBVEWsZTVQwffsnwTY6Mivoy3NRSVR28ZaCW74F67VSq4VRC4zY1XR");
expect(naNodePrivate.humanNodePrivate() == strPrivateKey, naNodePrivate.humanNodePrivate());
expect(naNodePrivate.setNodePrivate(strPrivateKey),"couldn't create private node");
expect(naNodePrivate.humanNodePrivate() == strPrivateKey, naNodePrivate.humanNodePrivate());
naNodePrivate.sign(message, rippleSig);
expect(rippleSig == sig, "Signature don't match");
/*
RippleAddress naNodePrivate = RippleAddress::createNodePrivate(naSeed);
expect(naNodePrivate.humanNodePrivate() == "pnen77YEeUd4fFKG7iycBWcwKpTaeFRkW2WFostaATy1DSupwXe", naNodePrivate.humanNodePrivate());
// Check node signing.
Blob vucTextSrc = strCopy("Hello, nurse!");
uint256 uHash = Serializer::getSHA512Half(vucTextSrc);
Blob vucTextSig;
naNodePrivate.signNodePrivate(uHash, vucTextSig);
expect(naNodePublic.verifyNodePublic(uHash, vucTextSig, ECDSA::strict), "Verify failed.");
*/
}