//-----------------------------------------------------------------
crypto::secret_key account_base::generate(const crypto::secret_key& recovery_key, bool recover, bool two_random)
{
crypto::secret_key first = generate_keys(m_keys.m_account_address.m_spend_public_key, m_keys.m_spend_secret_key, recovery_key, recover);
// rng for generating second set of keys is hash of first rng. means only one set of electrum-style words needed for recovery
crypto::secret_key second;
keccak((uint8_t *)&first, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
generate_keys(m_keys.m_account_address.m_view_public_key, m_keys.m_view_secret_key, second, two_random ? false : true);
struct tm timestamp;
timestamp.tm_year = 2014 - 1900; // year 2014
timestamp.tm_mon = 6 - 1; // month june
timestamp.tm_mday = 8; // 8th of june
timestamp.tm_hour = 0;
timestamp.tm_min = 0;
timestamp.tm_sec = 0;
if (recover)
{
m_creation_timestamp = mktime(×tamp);
}
else
{
m_creation_timestamp = time(NULL);
}
return first;
}
//-----------------------------------------------------------------
crypto::secret_key account_base::generate(const crypto::secret_key& recovery_key, bool recover, bool two_random)
{
crypto::secret_key first = generate_keys(m_keys.m_account_address.m_spend_public_key, m_keys.m_spend_secret_key, recovery_key, recover);
// rng for generating second set of keys is hash of first rng. means only one set of electrum-style words needed for recovery
crypto::secret_key second;
keccak((uint8_t *)&first, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
generate_keys(m_keys.m_account_address.m_view_public_key, m_keys.m_view_secret_key, second, two_random ? false : true);
m_creation_timestamp = time(NULL);
return first;
}
buffer ecdhe_context::derive_secret_key(const void* peer_key, size_t peer_key_len)
{
if (!m_private_key)
{
generate_keys();
}
bio::bio_chain bio(::BIO_new_mem_buf(const_cast<void*>(peer_key), static_cast<int>(peer_key_len)));
pkey peer_pkey = pkey::from_certificate_public_key(bio.first());
evp_pkey_context_type key_derivation_context(::EVP_PKEY_CTX_new(m_private_key.raw(), NULL));
error::throw_error_if_not(key_derivation_context.get());
error::throw_error_if(::EVP_PKEY_derive_init(key_derivation_context.get()) != 1);
error::throw_error_if(::EVP_PKEY_derive_set_peer(key_derivation_context.get(), peer_pkey.raw()) != 1);
size_t buf_len = 0;
error::throw_error_if(::EVP_PKEY_derive(key_derivation_context.get(), NULL, &buf_len) != 1);
buffer buf(buf_len);
error::throw_error_if(::EVP_PKEY_derive(key_derivation_context.get(), buffer_cast<uint8_t*>(buf), &buf_len) != 1);
return buf;
}
void INodeTrivialRefreshStub::doGetRandomOutsByAmounts(std::vector<uint64_t> amounts, uint64_t outsCount, std::vector<cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount>& result, const Callback& callback)
{
ContextCounterHolder counterHolder(m_asyncCounter);
std::unique_lock<std::mutex> lock(m_multiWalletLock);
for (uint64_t amount: amounts)
{
cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount out;
out.amount = amount;
for (uint64_t i = 0; i < outsCount; ++i)
{
crypto::public_key key;
crypto::secret_key sk;
generate_keys(key, sk);
cryptonote::COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry e;
e.global_amount_index = i;
e.out_key = key;
out.outs.push_back(e);
}
}
callback(std::error_code());
}
bool Connector::abbr(const std::string& key, const std::string& data)
{
StringList real_keylist;
fill_key(key);
generate_keys(real_keylist);
return generator_.on_have_data(real_keylist, data);
}
bool Connector::abbr(const StringList& keylist, const std::string& data)
{
StringList real_keylist;
for (StringList::const_iterator it = keylist.begin();
it != keylist.end(); ++it) {
fill_key(*it);
generate_keys(real_keylist);
}
return generator_.on_have_data(real_keylist, data);
}
bool Connector::article(const std::string& key, const std::string& data,
bool kia)
{
std::string keystr;
StringList real_keylist;
if (!kia)
keystr += std::string("<k>") + key + "</k>\n";
fill_key(key);
generate_keys(real_keylist);
return generator_.on_have_data(real_keylist, keystr + data);
}
bool Connector::article(const StringList& keylist, const std::string& data, bool kia)
{
std::string keystr;
StringList real_keylist;
for (StringList::const_iterator it = keylist.begin();
it != keylist.end(); ++it) {
if (!kia)
keystr += std::string("<k>") + *it + "</k>\n";
fill_key(*it);
generate_keys(real_keylist);
}
return generator_.on_have_data(real_keylist, keystr + data);
}
buffer ecdhe_context::get_public_key()
{
if (!m_private_key)
{
generate_keys();
}
bio::bio_chain bio(::BIO_new(::BIO_s_mem()));
m_private_key.write_certificate_public_key(bio.first());
char* buf = nullptr;
const size_t buf_len = bio.first().get_mem_data(buf);
return buffer(buf, buf_len);
}
TEST(SignTest, TestLoadValidPemKeys)
{
ScopedEVP_PKEY private_key(nullptr, EVP_PKEY_free);
ScopedEVP_PKEY public_key(nullptr, EVP_PKEY_free);
ScopedBIO bio_private_key_enc(BIO_new(BIO_s_mem()), BIO_free);
ASSERT_TRUE(!!bio_private_key_enc);
ScopedBIO bio_private_key_noenc(BIO_new(BIO_s_mem()), BIO_free);
ASSERT_TRUE(!!bio_private_key_noenc);
ScopedBIO bio_public_key(BIO_new(BIO_s_mem()), BIO_free);
ASSERT_TRUE(!!bio_public_key);
// Generate keys
ASSERT_TRUE(generate_keys(private_key, public_key));
// Write keys
ASSERT_TRUE(PEM_write_bio_PrivateKey(bio_private_key_enc.get(),
private_key.get(), EVP_des_ede3_cbc(),
nullptr, 0, nullptr,
const_cast<char *>("testing")));
ASSERT_TRUE(PEM_write_bio_PrivateKey(bio_private_key_noenc.get(),
private_key.get(), nullptr, nullptr, 0,
nullptr, nullptr));
ASSERT_TRUE(PEM_write_bio_PUBKEY(bio_public_key.get(), public_key.get()));
// Read back the keys
ScopedEVP_PKEY private_key_enc_read(mb::sign::load_private_key(
bio_private_key_enc.get(), mb::sign::KEY_FORMAT_PEM, "testing"),
EVP_PKEY_free);
ASSERT_TRUE(!!private_key_enc_read);
ScopedEVP_PKEY private_key_noenc_read(mb::sign::load_private_key(
bio_private_key_noenc.get(), mb::sign::KEY_FORMAT_PEM, nullptr),
EVP_PKEY_free);
ASSERT_TRUE(!!private_key_noenc_read);
ScopedEVP_PKEY public_key_read(mb::sign::load_public_key(
bio_public_key.get(), mb::sign::KEY_FORMAT_PEM, "testing"),
EVP_PKEY_free);
ASSERT_TRUE(!!public_key_read);
// Compare keys
ASSERT_EQ(EVP_PKEY_cmp(private_key.get(), private_key_enc_read.get()), 1);
ASSERT_EQ(EVP_PKEY_cmp(private_key.get(), private_key_noenc_read.get()), 1);
ASSERT_EQ(EVP_PKEY_cmp(public_key.get(), public_key_read.get()), 1);
}
int main()
{
int i;
mpz_t M; mpz_init(M);
mpz_t C; mpz_init(C);
mpz_t DC; mpz_init(DC);
private_key ku;
public_key kp;
// Initialize public key
mpz_init(kp.n);
mpz_init(kp.e);
// Initialize private key
mpz_init(ku.n);
mpz_init(ku.e);
mpz_init(ku.d);
mpz_init(ku.p);
mpz_init(ku.q);
generate_keys(&ku, &kp);
printf("---------------Private Key-----------------");
printf("kp.n is [%s]\n", mpz_get_str(NULL, 16, kp.n));
printf("kp.e is [%s]\n", mpz_get_str(NULL, 16, kp.e));
printf("---------------Public Key------------------");
printf("ku.n is [%s]\n", mpz_get_str(NULL, 16, ku.n));
printf("ku.e is [%s]\n", mpz_get_str(NULL, 16, ku.e));
printf("ku.d is [%s]\n", mpz_get_str(NULL, 16, ku.d));
printf("ku.p is [%s]\n", mpz_get_str(NULL, 16, ku.p));
printf("ku.q is [%s]\n", mpz_get_str(NULL, 16, ku.q));
char buf[6*BLOCK_SIZE];
for(i = 0; i < 6*BLOCK_SIZE; i++)
buf[i] = rand() % 0xFF;
mpz_import(M, (6*BLOCK_SIZE), 1, sizeof(buf[0]), 0, 0, buf);
printf("original is [%s]\n", mpz_get_str(NULL, 16, M));
block_encrypt(C, M, kp);
printf("encrypted is [%s]\n", mpz_get_str(NULL, 16, C));
block_decrypt(DC, C, ku);
printf("decrypted is [%s]\n", mpz_get_str(NULL, 16, DC));
return 0;
}
TEST(SignTest, TestLoadValidPemKeysWithInvalidPassphrase)
{
ScopedEVP_PKEY private_key(nullptr, EVP_PKEY_free);
ScopedEVP_PKEY public_key(nullptr, EVP_PKEY_free);
ScopedBIO bio(BIO_new(BIO_s_mem()), BIO_free);
ASSERT_TRUE(!!bio);
// Generate keys
ASSERT_TRUE(generate_keys(private_key, public_key));
// Write key
ASSERT_TRUE(PEM_write_bio_PrivateKey(bio.get(), private_key.get(),
EVP_des_ede3_cbc(), nullptr, 0,
nullptr,
const_cast<char *>("testing")));
// Read back the key using invalid password
ScopedEVP_PKEY private_key_read(mb::sign::load_private_key(
bio.get(), mb::sign::KEY_FORMAT_PEM, "gnitset"),
EVP_PKEY_free);
ASSERT_FALSE(private_key_read);
}
/* Description: mgabe-keygen takes the outfile to write the users keys, and the .
*/
int main (int argc, char* argv[]) {
int oflag = FALSE, aflag = FALSE, pflag = FALSE;
char *keyfile = NULL, *string = NULL;
int c,err;
FENC_SCHEME_TYPE mode = FENC_SCHEME_NONE;
char *secret_params = NULL, *public_params = NULL;
// fenc_attribute_list *attr_list = (fenc_attribute_list *) malloc(sizeof(fenc_attribute_list));
char buf[SIZE];
memset(buf, 0, SIZE);
size_t out_size;
opterr = 0;
while ((c = getopt (argc, argv, "a:o:m:p:h")) != -1) {
switch (c)
{
case 'a': // retrieve attributes from user
aflag = TRUE;
attribute_string = strdup(optarg);
break;
case 'p':
pflag = TRUE;
policy_string = strdup(optarg);
break;
case 'o':
oflag = TRUE;
keyfile = optarg;
break;
case 'm':
if (strcmp(optarg, SCHEME_LSW) == 0) {
printf("Generating private key for Lewko-Sahai-Waters KP scheme...\n");
mode = FENC_SCHEME_LSW;
secret_params = SECRET_FILE".kp";
public_params = PUBLIC_FILE".kp";
}
else if(strcmp(optarg, SCHEME_WCP) == 0) {
printf("Generating private key for Waters CP scheme...\n");
mode = FENC_SCHEME_WATERSCP;
secret_params = SECRET_FILE".cp";
public_params = PUBLIC_FILE".cp";
}
else if(strcmp(optarg, SCHEME_WSCP) == 0) {
printf("Generating private key for Waters Simple CP scheme...\n");
mode = FENC_SCHEME_WATERSSIMPLECP;
secret_params = SECRET_FILE".scp";
public_params = PUBLIC_FILE".scp";
}
break;
case 'h':
print_help();
exit(1);
case '?':
if (optopt == 'o' )
fprintf (stderr, "Option -%o requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr,
"Unknown option character `\\x%x'.\n", optopt);
return 1;
default:
print_help();
abort ();
}
}
/* attribute list required */
if(aflag == FALSE && mode == FENC_SCHEME_WATERSCP) {
fprintf(stderr, "Attributes list required to generate user's key!\n");
print_help();
exit(1);
}
if(pflag == FALSE && mode == FENC_SCHEME_LSW) {
fprintf(stderr, "Policy required to generate user's key under "SCHEME_LSW" scheme\n");
print_help();
exit(1);
}
/* use default file name if not set */
if(oflag == FALSE) {
keyfile = DEFAULT_KEYFILE;
}
if(mode == FENC_SCHEME_NONE) {
fprintf(stderr, "Please specify a scheme type\n");
print_help();
goto cleanup;
}
printf("Generating your private key...\n");
generate_keys(keyfile, mode, secret_params, public_params);
cleanup:
return 0;
}
