std::string getAccountSeed(const std::string& secret)
{
RippleAddress addr;
addr.SetString(secret, VER_FAMILY_SEED);
uint128 seed = addr.getSeed();
return seed.GetHex();
}
// {
// passphrase: <string>
// }
Json::Value doWalletPropose (RPC::Context& context)
{
context.lock_.unlock ();
RippleAddress naSeed;
RippleAddress naAccount;
if (!context.params_.isMember ("passphrase"))
naSeed.setSeedRandom ();
else if (!naSeed.setSeedGeneric (context.params_["passphrase"].asString ()))
return rpcError(rpcBAD_SEED);
RippleAddress naGenerator = RippleAddress::createGeneratorPublic (naSeed);
naAccount.setAccountPublic (naGenerator, 0);
Json::Value obj (Json::objectValue);
obj["master_seed"] = naSeed.humanSeed ();
obj["master_seed_hex"] = to_string (naSeed.getSeed ());
obj["master_key"] = naSeed.humanSeed1751();
obj["account_id"] = naAccount.humanAccountID ();
obj["public_key"] = naAccount.humanAccountPublic();
auto acct = naAccount.getAccountPublic();
obj["public_key_hex"] = strHex(acct.begin(), acct.size());
return obj;
}
void RippleAddress::setAccountPrivate (
RippleAddress const& generator, RippleAddress const& naSeed, int seq)
{
uint256 secretKey = generatePrivateDeterministicKey (
generator.getGenerator(), naSeed.getSeed(), seq);
setAccountPrivate (secretKey);
}
RippleAddress RippleAddress::createNodePrivate (RippleAddress const& naSeed)
{
RippleAddress naNew;
naNew.setNodePrivate (generateRootDeterministicPrivateKey (naSeed.getSeed()));
return naNew;
}
RippleAddress RippleAddress::createGeneratorPublic(const RippleAddress& naSeed)
{
CKey ckSeed(naSeed.getSeed());
RippleAddress naNew;
naNew.setGenerator(ckSeed.GetPubKey());
return naNew;
}
RippleAddress RippleAddress::createNodePrivate(const RippleAddress& naSeed)
{
RippleAddress naNew;
EdKeyPair pair(naSeed.getSeed());
naNew.setNodePrivate(pair.mPrivateKey);
return naNew;
}
RippleAddress RippleAddress::createAccountPublic (const RippleAddress& seed)
{
EdKeyPair ckPub(seed.getSeed());
RippleAddress naNew;
naNew.setAccountPublic (ckPub.getPubKey ());
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;
}
void RippleAddress::setAccountPrivate(const RippleAddress& naGenerator, const RippleAddress& naSeed, int seq)
{
CKey ckPubkey = CKey(naSeed.getSeed());
CKey ckPrivkey = CKey(naGenerator, ckPubkey.GetSecretBN(), seq);
uint256 uPrivKey;
ckPrivkey.GetPrivateKeyU(uPrivKey);
setAccountPrivate(uPrivKey);
}
RippleAddress RippleAddress::createNodePrivate(const RippleAddress& naSeed)
{
uint256 uPrivKey;
RippleAddress naNew;
CKey ckSeed(naSeed.getSeed());
ckSeed.GetPrivateKeyU(uPrivKey);
naNew.setNodePrivate(uPrivKey);
return naNew;
}
KeyPair generateKeysFromSeed (KeyType type, RippleAddress const& seed)
{
KeyPair result;
if (! seed.isSet())
{
return result;
}
if (type == KeyType::secp256k1)
{
RippleAddress generator = RippleAddress::createGeneratorPublic (seed);
result.secretKey.setAccountPrivate (generator, seed, 0);
result.publicKey.setAccountPublic (generator, 0);
}
else if (type == KeyType::ed25519)
{
uint256 secretkey = keyFromSeed (seed.getSeed());
Blob ed25519_key (33);
ed25519_key[0] = 0xED;
assert (secretkey.size() + 1 == ed25519_key.size());
memcpy (&ed25519_key[1], secretkey.data(), secretkey.size());
result.secretKey.setAccountPrivate (ed25519_key);
ed25519_publickey (secretkey.data(), &ed25519_key[1]);
result.publicKey.setAccountPublic (ed25519_key);
secretkey.zero(); // security erase
}
else
{
assert (false); // not reached
}
return result;
}
void RippleAddress::setAccountPublic (const RippleAddress& seed )
{
EdKeyPair pubkey(seed.getSeed());
setAccountPublic (pubkey.getPubKey ());
}
void LoopThread(unsigned int n, uint64_t eta50, string* ppattern,
string* pmaster_seed, string* pmaster_seed_hex, string* paccount_id)
{
RippleAddress naSeed;
RippleAddress naAccount;
string pattern = *ppattern;
string account_id;
uint128 key;
getRand(key.begin(), key.size());
uint64_t count = 0;
uint64_t last_count = 0;
do {
naSeed.setSeed(key);
RippleAddress naGenerator = createGeneratorPublic(naSeed);
naAccount.setAccountPublic(naGenerator.getAccountPublic(), 0);
account_id = naAccount.humanAccountID();
count++;
if (count % UPDATE_ITERATIONS == 0) {
boost::unique_lock<boost::mutex> lock(mutex);
total_searched += count - last_count;
last_count = count;
uint64_t nSecs = time(NULL) - start_time;
double speed = (1.0 * total_searched)/nSecs;
const char* unit = "seconds";
double eta50f = eta50/speed;
if (eta50f > 100) {
unit = "minutes";
eta50f /= 60;
if (eta50f > 100) {
unit = "hours";
eta50f /= 60;
if (eta50f > 48) {
unit = "days";
eta50f /= 24;
}
}
}
cout << "# Thread " << n << ": " << count << " seeds." << endl
<< "#" << endl
<< "# Total Speed: " << speed << " seeds/second" << endl
<< "# Total Searched: " << total_searched << endl
<< "# Total Time: " << nSecs << " seconds" << endl
<< "# ETA 50%: " << eta50f << " " << unit << endl
<< "# Last: " << account_id << endl
<< "# Pattern: " << pattern << endl
<< "#" << endl;
}
key++;
boost::this_thread::yield();
} while ((account_id.substr(0, pattern.size()) != pattern) && !fDone);
boost::unique_lock<boost::mutex> lock(mutex);
if (fDone) return;
fDone = true;
cout << "# *** Found by thread " << n << ". ***" << endl
<< "#" << endl;
*pmaster_seed = naSeed.humanSeed();
*pmaster_seed_hex = naSeed.getSeed().ToString();
*paccount_id = account_id;
}
RippleAddress RippleAddress::createGeneratorPublic (RippleAddress const& naSeed)
{
RippleAddress naNew;
naNew.setGenerator (generateRootDeterministicPublicKey (naSeed.getSeed()));
return naNew;
}
Json::Value walletPropose (Json::Value const& params)
{
RippleAddress naSeed;
RippleAddress naAccount;
KeyType type = KeyType::secp256k1;
bool const has_key_type = params.isMember (jss::key_type);
bool const has_passphrase = params.isMember (jss::passphrase);
if (has_key_type)
{
// `key_type` must be valid if present.
type = keyTypeFromString (params[jss::key_type].asString());
if (type == KeyType::invalid)
{
return rpcError (rpcBAD_SEED);
}
naSeed = getSeedFromRPC (params);
}
else if (has_passphrase)
{
naSeed.setSeedGeneric (params[jss::passphrase].asString());
}
else
{
naSeed.setSeedRandom();
}
if (!naSeed.isSet())
{
return rpcError(rpcBAD_SEED);
}
if (type == KeyType::secp256k1)
{
RippleAddress naGenerator = RippleAddress::createGeneratorPublic (naSeed);
naAccount.setAccountPublic (naGenerator, 0);
}
else if (type == KeyType::ed25519)
{
uint256 secretkey = keyFromSeed (naSeed.getSeed());
Blob publickey (33);
publickey[0] = 0xED;
ed25519_publickey (secretkey.data(), &publickey[1]);
secretkey.zero(); // security erase
naAccount.setAccountPublic (publickey);
}
else
{
assert (false); // not reached
}
Json::Value obj (Json::objectValue);
obj[jss::master_seed] = naSeed.humanSeed ();
obj[jss::master_seed_hex] = to_string (naSeed.getSeed ());
obj[jss::master_key] = naSeed.humanSeed1751();
obj[jss::account_id] = naAccount.humanAccountID ();
obj[jss::public_key] = naAccount.humanAccountPublic();
obj[jss::key_type] = to_string (type);
auto acct = naAccount.getAccountPublic();
obj[jss::public_key_hex] = strHex(acct.begin(), acct.size());
return obj;
}
