//地址是否合法
PrivateKey::PrivateKey(SignatureType type) {
std::string raw_pub_key = "";
type_ = type;
if (type_ == SIGNTYPE_ED25519) {
utils::MutexGuard guard_(lock_);
// ed25519;
raw_priv_key_.resize(32);
//ed25519_randombytes_unsafe((void*)raw_priv_key_.c_str(), 32);
if (!utils::GetStrongRandBytes(raw_priv_key_)){
valid_ = false;
return;
}
raw_pub_key.resize(32);
ed25519_publickey((const unsigned char*)raw_priv_key_.c_str(), (unsigned char*)raw_pub_key.c_str());
}
else if (type_ == SIGNTYPE_CFCASM2) {
utils::EccSm2 key(utils::EccSm2::GetCFCAGroup());
key.NewRandom();
raw_priv_key_ = key.getSkeyBin();
raw_pub_key = key.GetPublicKey();
}
else{
LOG_ERROR("Unknown signature type(%d)", type_);
}
pub_key_.Init(raw_pub_key);
pub_key_.type_ = type_;
pub_key_.valid_ = true;
valid_ = true;
}
void Page::resign(const std::array<uint8_t, Const::ED25519_KEY_LEN>& sk)
{
ed25519_public_key pk;
ed25519_publickey(sk.data(), pk);
Json::FastWriter writer;
std::string data = writer.write(getCommonData());
const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data.c_str());
ed25519_sign(bytes, data.size(), sk.data(), pk, pageSig_.data());
}
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;
}
TEST (uint256_union, key_encryption)
{
rai::keypair key1;
rai::raw_key secret_key;
secret_key.data.bytes.fill (0);
rai::uint256_union encrypted;
encrypted.encrypt (key1.prv, secret_key, key1.pub.owords [0]);
rai::raw_key key4;
key4.decrypt (encrypted, secret_key, key1.pub.owords [0]);
ASSERT_EQ (key1.prv, key4);
rai::public_key pub;
ed25519_publickey (key4.data.bytes.data (), pub.bytes.data ());
ASSERT_EQ (key1.pub, pub);
}
/** Create a fulfillment given a secret key and the message */
Ed25519::Ed25519 (
SecretKey const& secretKey,
Slice message)
{
// First derive the public key, and place it in the
// payload:
ed25519_publickey (
secretKey.data(),
payload_.data());
ed25519_sign (
message.data(),
message.size(),
secretKey.data(),
payload_.data(),
payload_.data() + pubkey_size_);
}
//not modify
bool PrivateKey::From(const std::string &encode_private_key) {
valid_ = false;
std::string tmp;
do {
PrivateKeyPrefix prefix;
std::string raw_pubkey;
valid_ = GetKeyElement(encode_private_key, prefix, type_, raw_priv_key_);
if (!valid_) {
return false;
}
if (prefix != PRIVATEKEY_PREFIX) {
valid_ = false;
return false;
}
if (type_ == SIGNTYPE_ED25519) {
tmp.resize(32);
ed25519_publickey((const unsigned char*)raw_priv_key_.c_str(), (unsigned char*)tmp.c_str());
}
else if (type_ == SIGNTYPE_CFCASM2) {
utils::EccSm2 skey(utils::EccSm2::GetCFCAGroup());
skey.From(raw_priv_key_);
tmp = skey.GetPublicKey();
}
else{
LOG_ERROR("Unknown signature type(%d)", type_);
}
//ToBase58();
pub_key_.type_ = type_;
pub_key_.Init(tmp);
pub_key_.valid_ = true;
valid_ = true;
} while (false);
return valid_;
}
Json::Value walletPropose (Json::Value const& params)
{
DivvyAddress naSeed;
DivvyAddress 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)
{
DivvyAddress naGenerator = DivvyAddress::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;
}
