Mirrors/i2pd-tools
2
0
Fork 0
mirror of https://github.com/PurpleI2P/i2pd-tools.git synced 2025-01-22 13:27:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

clean code

Browse source 
Signed-off-by: R4SAS <r4sas@i2pmail.org>
This commit is contained in:
R4SAS 2020-11-17 15:06:13 +03:00
parent 07c5391b92
commit 5f45990dff
No known key found for this signature in database
GPG key ID: 66F6C87B98EBCFE2
11 changed files with 567 additions and 574 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
b33address.cpp
View file

@ -6,8 +6,9 @@
#include "common/key.hpp"
int main(int argc, char * argv[])
{
// base64 input, b33 and store key output, 11->11 only
{
// base64 input, b33 and store key output, 11->11 only
std::cout << "Waiting for base64 from stdin..." << std::endl;
std::string base64;
std::getline (std::cin, base64);
auto ident = std::make_shared<i2p::data::IdentityEx>();
@ -17,14 +18,13 @@ int main(int argc, char * argv[])
{
i2p::data::BlindedPublicKey blindedKey (ident);
std::cout << "b33 address: " << blindedKey.ToB33 () << ".b32.i2p" << std::endl;
std::cout << "Today's store hash: " << blindedKey.GetStoreHash ().ToBase64 () << std::endl;
std::cout << "Today's store hash: " << blindedKey.GetStoreHash ().ToBase64 () << std::endl;
}
else
std::cout << "Invalid signature type " << SigTypeToName (ident->GetSigningKeyType ()) << std::endl;
std::cout << "Invalid signature type " << SigTypeToName (ident->GetSigningKeyType ()) << std::endl;
}
else
std::cout << "Invalid base64 address" << std::endl;
std::cout << "Invalid base64 address" << std::endl;
return 0;
}

674
famtool.cpp
View file

@ -19,372 +19,372 @@ using namespace i2p::data;
static void usage(const std::string & name)
{
std::cout << "usage: " << name << " [-h] [-v] [-g -n family -c family.crt -k family.pem] [-s -n family -k family.pem -i router.keys -f router.info] [-V -c family.crt -f router.info]" << std::endl;
std::cout << "usage: " << name << " [-h] [-v] [-g -n family -c family.crt -k family.pem] [-s -n family -k family.pem -i router.keys -f router.info] [-V -c family.crt -f router.info]" << std::endl;
}
static void printhelp(const std::string & name)
{
usage(name);
std::cout << std::endl;
std::cout << "generate a new family signing key for family called ``i2pfam''" << std::endl;
std::cout << name << " -g -n i2pfam -c myfam.crt -k myfam.pem" << std::endl << std::endl;
std::cout << "sign a router info with family signing key" << std::endl;
std::cout << name << " -s -n i2pfam -k myfam.pem -i router.keys -f router.info" << std::endl << std::endl;
std::cout << "verify signed router.info" << std::endl;
std::cout << name << " -V -n i2pfam -c myfam.pem -f router.info" << std::endl << std::endl;
usage(name);
std::cout << std::endl;
std::cout << "generate a new family signing key for family called ``i2pfam''" << std::endl;
std::cout << name << " -g -n i2pfam -c myfam.crt -k myfam.pem" << std::endl << std::endl;
std::cout << "sign a router info with family signing key" << std::endl;
std::cout << name << " -s -n i2pfam -k myfam.pem -i router.keys -f router.info" << std::endl << std::endl;
std::cout << "verify signed router.info" << std::endl;
std::cout << name << " -V -n i2pfam -c myfam.pem -f router.info" << std::endl << std::endl;
}
static std::shared_ptr<Verifier> LoadCertificate (const std::string& filename)
{
std::shared_ptr<Verifier> verifier;
SSL_CTX * ctx = SSL_CTX_new (TLSv1_method ());
int ret = SSL_CTX_use_certificate_file (ctx, filename.c_str (), SSL_FILETYPE_PEM);
if (ret)
{
SSL * ssl = SSL_new (ctx);
X509 * cert = SSL_get_certificate (ssl);
if (cert)
{
// extract issuer name
char name[100];
X509_NAME_oneline (X509_get_issuer_name(cert), name, 100);
char * cn = strstr (name, "CN=");
if (cn)
{
cn += 3;
char * family = strstr (cn, ".family");
if (family) family[0] = 0;
}
auto pkey = X509_get_pubkey (cert);
std::shared_ptr<Verifier> verifier;
SSL_CTX * ctx = SSL_CTX_new (TLSv1_method ());
int ret = SSL_CTX_use_certificate_file (ctx, filename.c_str (), SSL_FILETYPE_PEM);
if (ret)
{
SSL * ssl = SSL_new (ctx);
X509 * cert = SSL_get_certificate (ssl);
if (cert)
{
// extract issuer name
char name[100];
X509_NAME_oneline (X509_get_issuer_name(cert), name, 100);
char * cn = strstr (name, "CN=");
if (cn)
{
cn += 3;
char * family = strstr (cn, ".family");
if (family) family[0] = 0;
}
auto pkey = X509_get_pubkey (cert);
EC_KEY * ecKey = EVP_PKEY_get1_EC_KEY (pkey);
if (ecKey)
{
auto group = EC_KEY_get0_group (ecKey);
if (group)
{
int curve = EC_GROUP_get_curve_name (group);
if (curve == NID_X9_62_prime256v1)
{
uint8_t signingKey[64];
BIGNUM * x = BN_new(), * y = BN_new();
EC_POINT_get_affine_coordinates_GFp (group,
EC_KEY_get0_public_key (ecKey), x, y, NULL);
bn2buf (x, signingKey, 32);
bn2buf (y, signingKey + 32, 32);
BN_free (x); BN_free (y);
verifier = std::make_shared<i2p::crypto::ECDSAP256Verifier>();
EC_KEY * ecKey = EVP_PKEY_get1_EC_KEY (pkey);
if (ecKey)
{
auto group = EC_KEY_get0_group (ecKey);
if (group)
{
int curve = EC_GROUP_get_curve_name (group);
if (curve == NID_X9_62_prime256v1)
{
uint8_t signingKey[64];
BIGNUM * x = BN_new(), * y = BN_new();
EC_POINT_get_affine_coordinates_GFp (group,
EC_KEY_get0_public_key (ecKey), x, y, NULL);
bn2buf (x, signingKey, 32);
bn2buf (y, signingKey + 32, 32);
BN_free (x); BN_free (y);
verifier = std::make_shared<i2p::crypto::ECDSAP256Verifier>();
verifier->SetPublicKey (signingKey);
}
}
EC_KEY_free (ecKey);
}
EVP_PKEY_free (pkey);
}
SSL_free (ssl);
}
SSL_CTX_free (ctx);
return verifier;
}
}
EC_KEY_free (ecKey);
}
EVP_PKEY_free (pkey);
}
SSL_free (ssl);
}
SSL_CTX_free (ctx);
return verifier;
}
static bool CreateFamilySignature (const std::string& family, const IdentHash& ident, const std::string & filename, std::string & sig)
{
SSL_CTX * ctx = SSL_CTX_new (TLSv1_method ());
int ret = SSL_CTX_use_PrivateKey_file (ctx, filename.c_str (), SSL_FILETYPE_PEM);
if (ret)
{
SSL * ssl = SSL_new (ctx);
EVP_PKEY * pkey = SSL_get_privatekey (ssl);
EC_KEY * ecKey = EVP_PKEY_get1_EC_KEY (pkey);
if (ecKey)
{
auto group = EC_KEY_get0_group (ecKey);
if (group)
{
int curve = EC_GROUP_get_curve_name (group);
if (curve == NID_X9_62_prime256v1)
{
uint8_t signingPrivateKey[32], buf[50], signature[64];
bn2buf (EC_KEY_get0_private_key (ecKey), signingPrivateKey, 32);
ECDSAP256Signer signer (signingPrivateKey);
size_t len = family.length ();
memcpy (buf, family.c_str (), len);
memcpy (buf + len, (const uint8_t *)ident, 32);
len += 32;
signer.Sign (buf, len, signature);
len = Base64EncodingBufferSize (64);
char * b64 = new char[len+1];
len = ByteStreamToBase64 (signature, 64, b64, len);
b64[len] = 0;
sig = b64;
delete[] b64;
}
else
return false;
}
}
SSL_free (ssl);
}
else
return false;
SSL_CTX_free (ctx);
return true;
SSL_CTX * ctx = SSL_CTX_new (TLSv1_method ());
int ret = SSL_CTX_use_PrivateKey_file (ctx, filename.c_str (), SSL_FILETYPE_PEM);
if (ret)
{
SSL * ssl = SSL_new (ctx);
EVP_PKEY * pkey = SSL_get_privatekey (ssl);
EC_KEY * ecKey = EVP_PKEY_get1_EC_KEY (pkey);
if (ecKey)
{
auto group = EC_KEY_get0_group (ecKey);
if (group)
{
int curve = EC_GROUP_get_curve_name (group);
if (curve == NID_X9_62_prime256v1)
{
uint8_t signingPrivateKey[32], buf[50], signature[64];
bn2buf (EC_KEY_get0_private_key (ecKey), signingPrivateKey, 32);
ECDSAP256Signer signer (signingPrivateKey);
size_t len = family.length ();
memcpy (buf, family.c_str (), len);
memcpy (buf + len, (const uint8_t *)ident, 32);
len += 32;
signer.Sign (buf, len, signature);
len = Base64EncodingBufferSize (64);
char * b64 = new char[len+1];
len = ByteStreamToBase64 (signature, 64, b64, len);
b64[len] = 0;
sig = b64;
delete[] b64;
}
else
return false;
}
}
SSL_free (ssl);
}
else
return false;
SSL_CTX_free (ctx);
return true;
}
int main(int argc, char * argv[])
{
if (argc == 1) {
usage(argv[0]);
return -1;
}
int opt;
bool verbose = false;
bool help = false;
bool gen = false;
bool sign = false;
bool verify = false;
std::string fam;
std::string privkey;
std::string certfile;
std::string infile;
std::string infofile;
std::string outfile;
while((opt = getopt(argc, argv, "vVhgsn:i:c:k:o:f:")) != -1) {
switch(opt) {
case 'v':
verbose = true;
break;
case 'h':
help = true;
break;
case 'g':
gen = true;
break;
case 'n':
fam = std::string(argv[optind-1]);
if (fam.size() + 32 > 50) {
std::cout << "family name too long" << std::endl;
return 1;
}
break;
case 'f':
infofile = std::string(argv[optind-1]);
break;
case 'i':
infile = std::string(argv[optind-1]);
break;
case 'o':
outfile = std::string(argv[optind-1]);
case 'c':
certfile = std::string(argv[optind-1]);
break;
case 'k':
privkey = std::string(argv[optind-1]);
break;
case 'V':
verify = true;
break;
case 's':
sign = true;
break;
default:
usage(argv[0]);
return -1;
}
}
if(help) {
printhelp(argv[0]);
return 0;
}
InitCrypto(false, true, true, false);
if(!fam.size()) {
// no family name
std::cout << "no family name specified" << std::endl;
return 1;
}
// generate family key code
if(gen) {
if(!privkey.size()) privkey = fam + ".key";
if(!certfile.size()) certfile = fam + ".crt";
std::string cn = fam + ".family.i2p.net";
if (argc == 1) {
usage(argv[0]);
return -1;
}
int opt;
bool verbose = false;
bool help = false;
bool gen = false;
bool sign = false;
bool verify = false;
std::string fam;
std::string privkey;
std::string certfile;
std::string infile;
std::string infofile;
std::string outfile;
while((opt = getopt(argc, argv, "vVhgsn:i:c:k:o:f:")) != -1) {
switch(opt) {
case 'v':
verbose = true;
break;
case 'h':
help = true;
break;
case 'g':
gen = true;
break;
case 'n':
fam = std::string(argv[optind-1]);
if (fam.size() + 32 > 50) {
std::cout << "family name too long" << std::endl;
return 1;
}
break;
case 'f':
infofile = std::string(argv[optind-1]);
break;
case 'i':
infile = std::string(argv[optind-1]);
break;
case 'o':
outfile = std::string(argv[optind-1]);
case 'c':
certfile = std::string(argv[optind-1]);
break;
case 'k':
privkey = std::string(argv[optind-1]);
break;
case 'V':
verify = true;
break;
case 's':
sign = true;
break;
default:
usage(argv[0]);
return -1;
}
}
if(help) {
printhelp(argv[0]);
return 0;
}
InitCrypto(false, true, true, false);
if(!fam.size()) {
// no family name
std::cout << "no family name specified" << std::endl;
return 1;
}
// generate family key code
if(gen) {
if(!privkey.size()) privkey = fam + ".key";
if(!certfile.size()) certfile = fam + ".crt";
std::string cn = fam + ".family.i2p.net";
FILE * privf = fopen(privkey.c_str(), "w");
if(!privf) {
fprintf(stderr, "cannot open %s: %s\n", privkey.c_str(), strerror(errno));
return 1;
}
FILE * privf = fopen(privkey.c_str(), "w");
if(!privf) {
fprintf(stderr, "cannot open %s: %s\n", privkey.c_str(), strerror(errno));
return 1;
}
FILE * certf = fopen(certfile.c_str(), "w");
if(!certf) {
fprintf(stderr, "cannot open %s: %s\n", certfile.c_str(), strerror(errno));
return 1;
}
FILE * certf = fopen(certfile.c_str(), "w");
if(!certf) {
fprintf(stderr, "cannot open %s: %s\n", certfile.c_str(), strerror(errno));
return 1;
}
// openssl fagmastery starts here
EC_KEY * k_priv = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
assert(k_priv);
EC_KEY_set_asn1_flag(k_priv, OPENSSL_EC_NAMED_CURVE);
EC_KEY_generate_key(k_priv);
if(verbose) std::cout << "generated key" << std::endl;
// TODO: password protection
PEM_write_ECPrivateKey(privf, k_priv, nullptr, nullptr, 0, nullptr, nullptr);
fclose(privf);
if(verbose) std::cout << "wrote private key" << std::endl;
EVP_PKEY * ev_k = EVP_PKEY_new();
assert(ev_k);
assert(EVP_PKEY_assign_EC_KEY(ev_k, k_priv) == 1);
X509 * x = X509_new();
assert(x);
X509_set_version(x, 2);
ASN1_INTEGER_set(X509_get_serialNumber(x), 0);
X509_gmtime_adj(X509_get_notBefore(x),0);
// TODO: make expiration date configurable
X509_gmtime_adj(X509_get_notAfter(x),(long)60*60*24*365*10);
X509_set_pubkey(x, ev_k);
X509_NAME * name = X509_get_subject_name(x);
X509_NAME_add_entry_by_txt(name,"C", MBSTRING_ASC, (unsigned char *) "XX", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"ST", MBSTRING_ASC, (unsigned char *) "XX", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"L", MBSTRING_ASC, (unsigned char *) "XX", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"O", MBSTRING_ASC, (unsigned char *) "I2P Anonymous Network", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"OU", MBSTRING_ASC, (unsigned char *) "family", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"CN", MBSTRING_ASC, (unsigned char *) cn.c_str(), -1, -1, 0);
X509_set_issuer_name(x,name);
// openssl fagmastery starts here
if(verbose) std::cout << "signing cert" << std::endl;
assert(X509_sign(x, ev_k, EVP_sha256()));
if(verbose) std::cout << "writing private key" << std::endl;
PEM_write_X509(certf, x);
EC_KEY * k_priv = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
assert(k_priv);
EC_KEY_set_asn1_flag(k_priv, OPENSSL_EC_NAMED_CURVE);
EC_KEY_generate_key(k_priv);
if(verbose) std::cout << "generated key" << std::endl;
// TODO: password protection
PEM_write_ECPrivateKey(privf, k_priv, nullptr, nullptr, 0, nullptr, nullptr);
fclose(privf);
if(verbose) std::cout << "wrote private key" << std::endl;
fclose(certf);
EVP_PKEY_free(ev_k);
X509_free(x);
std::cout << "family " << fam << " made" << std::endl;
}
if (sign) {
// sign
if (!infile.size()) {
// no router info specififed
std::cerr << "no router keys file specified" << std::endl;
return 1;
}
if (!privkey.size()) {
// no private key specified
std::cerr << "no private key specififed" << std::endl;
return 1;
}
{
std::ifstream i;
i.open(infofile);
if(!i.is_open()) {
std::cout << "cannot open " << infofile << std::endl;
return 1;
}
}
EVP_PKEY * ev_k = EVP_PKEY_new();
assert(ev_k);
assert(EVP_PKEY_assign_EC_KEY(ev_k, k_priv) == 1);
if (verbose) std::cout << "load " << infofile << std::endl;
X509 * x = X509_new();
assert(x);
PrivateKeys keys;
{
std::ifstream fi(infile, std::ifstream::in | std::ifstream::binary);
if(!fi.is_open()) {
std::cout << "cannot open " << infile << std::endl;
return 1;
}
fi.seekg (0, std::ios::end);
size_t len = fi.tellg();
fi.seekg (0, std::ios::beg);
uint8_t * k = new uint8_t[len];
fi.read((char*)k, len);
if(!keys.FromBuffer(k, len)) {
std::cout << "invalid key file " << infile << std::endl;
return 1;
}
delete [] k;
}
RouterInfo ri(infofile);
auto ident = ri.GetIdentHash();
X509_set_version(x, 2);
ASN1_INTEGER_set(X509_get_serialNumber(x), 0);
X509_gmtime_adj(X509_get_notBefore(x),0);
// TODO: make expiration date configurable
X509_gmtime_adj(X509_get_notAfter(x),(long)60*60*24*365*10);
if (verbose) std::cout << "add " << ident.ToBase64() << " to " << fam << std::endl;
std::string sig;
if(CreateFamilySignature(fam, ident, privkey, sig)) {
ri.SetProperty(ROUTER_INFO_PROPERTY_FAMILY, fam);
ri.SetProperty(ROUTER_INFO_PROPERTY_FAMILY_SIG, sig);
if (verbose) std::cout << "signed " << sig << std::endl;
ri.CreateBuffer(keys);
if(!ri.SaveToFile(infofile)) {
std::cout << "failed to save to " << infofile << std::endl;
}
} else {
std::cout << "failed to sign router info" << std::endl;
}
std::cout << "signed" << std::endl;
}
X509_set_pubkey(x, ev_k);
if(verify) {
if(!infofile.size()) {
std::cout << "no router info file specified" << std::endl;
return 1;
}
if(!certfile.size()) {
std::cout << "no family cerifiticate specified" << std::endl;
return 1;
}
auto v = LoadCertificate(certfile);
if(!v) {
std::cout << "invalid certificate" << std::endl;
return 1;
}
X509_NAME * name = X509_get_subject_name(x);
X509_NAME_add_entry_by_txt(name,"C", MBSTRING_ASC, (unsigned char *) "XX", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"ST", MBSTRING_ASC, (unsigned char *) "XX", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"L", MBSTRING_ASC, (unsigned char *) "XX", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"O", MBSTRING_ASC, (unsigned char *) "I2P Anonymous Network", -1, -1, 0);
{
std::ifstream i;
i.open(infofile);
if(!i.is_open()) {
std::cout << "cannot open " << infofile << std::endl;
return 1;
}
}
X509_NAME_add_entry_by_txt(name,"OU", MBSTRING_ASC, (unsigned char *) "family", -1, -1, 0);
X509_NAME_add_entry_by_txt(name,"CN", MBSTRING_ASC, (unsigned char *) cn.c_str(), -1, -1, 0);
X509_set_issuer_name(x,name);
if (verbose) std::cout << "load " << infofile << std::endl;
RouterInfo ri(infofile);
auto sig = ri.GetProperty(ROUTER_INFO_PROPERTY_FAMILY_SIG);
if (ri.GetProperty(ROUTER_INFO_PROPERTY_FAMILY) != fam) {
std::cout << infofile << " does not belong to " << fam << std::endl;
return 1;
}
auto ident = ri.GetIdentHash();
uint8_t buf[50];
size_t len = fam.length();
memcpy(buf, fam.c_str(), len);
memcpy(buf + len, (const uint8_t *) ident, 32);
len += 32;
uint8_t sigbuf[64];
Base64ToByteStream(sig.c_str(), sig.length(), sigbuf, 64);
if(!v->Verify(buf, len, sigbuf)) {
std::cout << "invalid signature" << std::endl;
return 1;
}
std::cout << "verified" << std::endl;
}
return 0;
if(verbose) std::cout << "signing cert" << std::endl;
assert(X509_sign(x, ev_k, EVP_sha256()));
if(verbose) std::cout << "writing private key" << std::endl;
PEM_write_X509(certf, x);
fclose(certf);
EVP_PKEY_free(ev_k);
X509_free(x);
std::cout << "family " << fam << " made" << std::endl;
}
if (sign) {
// sign
if (!infile.size()) {
// no router info specified
std::cerr << "no router keys file specified" << std::endl;
return 1;
}
if (!privkey.size()) {
// no private key specified
std::cerr << "no private key specified" << std::endl;
return 1;
}
{
std::ifstream i;
i.open(infofile);
if(!i.is_open()) {
std::cout << "cannot open " << infofile << std::endl;
return 1;
}
}
if (verbose) std::cout << "load " << infofile << std::endl;
PrivateKeys keys;
{
std::ifstream fi(infile, std::ifstream::in | std::ifstream::binary);
if(!fi.is_open()) {
std::cout << "cannot open " << infile << std::endl;
return 1;
}
fi.seekg (0, std::ios::end);
size_t len = fi.tellg();
fi.seekg (0, std::ios::beg);
uint8_t * k = new uint8_t[len];
fi.read((char*)k, len);
if(!keys.FromBuffer(k, len)) {
std::cout << "invalid key file " << infile << std::endl;
return 1;
}
delete [] k;
}
RouterInfo ri(infofile);
auto ident = ri.GetIdentHash();
if (verbose) std::cout << "add " << ident.ToBase64() << " to " << fam << std::endl;
std::string sig;
if(CreateFamilySignature(fam, ident, privkey, sig)) {
ri.SetProperty(ROUTER_INFO_PROPERTY_FAMILY, fam);
ri.SetProperty(ROUTER_INFO_PROPERTY_FAMILY_SIG, sig);
if (verbose) std::cout << "signed " << sig << std::endl;
ri.CreateBuffer(keys);
if(!ri.SaveToFile(infofile)) {
std::cout << "failed to save to " << infofile << std::endl;
}
} else {
std::cout << "failed to sign router info" << std::endl;
}
std::cout << "signed" << std::endl;
}
if(verify) {
if(!infofile.size()) {
std::cout << "no router info file specified" << std::endl;
return 1;
}
if(!certfile.size()) {
std::cout << "no family certificate specified" << std::endl;
return 1;
}
auto v = LoadCertificate(certfile);
if(!v) {
std::cout << "invalid certificate" << std::endl;
return 1;
}
{
std::ifstream i;
i.open(infofile);
if(!i.is_open()) {
std::cout << "cannot open " << infofile << std::endl;
return 1;
}
}
if (verbose) std::cout << "load " << infofile << std::endl;
RouterInfo ri(infofile);
auto sig = ri.GetProperty(ROUTER_INFO_PROPERTY_FAMILY_SIG);
if (ri.GetProperty(ROUTER_INFO_PROPERTY_FAMILY) != fam) {
std::cout << infofile << " does not belong to " << fam << std::endl;
return 1;
}
auto ident = ri.GetIdentHash();
uint8_t buf[50];
size_t len = fam.length();
memcpy(buf, fam.c_str(), len);
memcpy(buf + len, (const uint8_t *) ident, 32);
len += 32;
uint8_t sigbuf[64];
Base64ToByteStream(sig.c_str(), sig.length(), sigbuf, 64);
if(!v->Verify(buf, len, sigbuf)) {
std::cout << "invalid signature" << std::endl;
return 1;
}
std::cout << "verified" << std::endl;
}
return 0;
}

119
i2pbase64.cpp
View file

@ -10,76 +10,73 @@ const size_t BUFFSZ = 1024;
static int printHelp(const char * exe, int exitcode)
{
std::cout << "usage: " << exe << " [-d] [filename]" << std::endl;
return exitcode;
std::cout << "usage: " << exe << " [-d] [filename]" << std::endl;
return exitcode;
}
template <typename InCh, typename OutCh, size_t isz, size_t osz>
static int operate(std::function<std::size_t(const InCh *, size_t, OutCh *, size_t)> f, int infile, int outfile)
{
InCh inbuf[isz];
OutCh outbuf[osz];
ssize_t sz;
size_t outsz;
while((sz = read(infile, inbuf, sizeof(inbuf))) > 0)
{
outsz = f(inbuf, sz, outbuf, sizeof(outbuf));
if(outsz && outsz <= sizeof(outbuf))
{
write(outfile, outbuf, outsz);
}
else
{
return -1;
}
}
return errno;
InCh inbuf[isz];
OutCh outbuf[osz];
ssize_t sz;
size_t outsz;
while((sz = read(infile, inbuf, sizeof(inbuf))) > 0)
{
outsz = f(inbuf, sz, outbuf, sizeof(outbuf));
if(outsz && outsz <= sizeof(outbuf))
{
write(outfile, outbuf, outsz);
}
else
{
return -1;
}
}
return errno;
}
int main(int argc, char * argv[])
{
int opt;
bool decode = false;
int infile = 0;
while((opt = getopt(argc, argv, "dh")) != -1)
{
switch(opt)
{
case 'h':
return printHelp(argv[0], 0);
case 'd':
decode = true;
break;
default:
continue;
}
}
int opt;
bool decode = false;
int infile = 0;
while((opt = getopt(argc, argv, "dh")) != -1)
{
switch(opt)
{
case 'h':
return printHelp(argv[0], 0);
case 'd':
decode = true;
break;
default:
continue;
}
}
if (argc - optind > 1)
{
return printHelp(argv[0], -1);
}
if (argc - optind > 1)
{
return printHelp(argv[0], -1);
}
if (optind < argc)
{
infile = open(argv[optind], O_RDONLY);
if(infile == -1) {
perror(argv[optind]);
return -1;
}
}
int retcode = 0;
if(decode)
{
retcode = operate<char, uint8_t, BUFFSZ*4, BUFFSZ*3>(i2p::data::Base64ToByteStream, infile, 1);
}
else
{
retcode = operate<uint8_t, char, BUFFSZ*3, BUFFSZ*4>(&i2p::data::ByteStreamToBase64, infile, 1);
}
close(infile);
return retcode;
if (optind < argc)
{
infile = open(argv[optind], O_RDONLY);
if(infile == -1) {
perror(argv[optind]);
return -1;
}
}
int retcode = 0;
if(decode)
{
retcode = operate<char, uint8_t, BUFFSZ*4, BUFFSZ*3>(i2p::data::Base64ToByteStream, infile, 1);
}
else
{
retcode = operate<uint8_t, char, BUFFSZ*3, BUFFSZ*4>(&i2p::data::ByteStreamToBase64, infile, 1);
}
close(infile);
return retcode;
}

4
keygen.cpp
View file

@ -13,7 +13,7 @@ int main (int argc, char * argv[])
return -1;
}
i2p::crypto::InitCrypto (false, true, true, false);
i2p::data::SigningKeyType type = i2p::data::SIGNING_KEY_TYPE_DSA_SHA1;
i2p::data::SigningKeyType type = i2p::data::SIGNING_KEY_TYPE_DSA_SHA1;
if (argc > 2) {
std::string str(argv[2]);
type = NameToSigType(str);
@ -30,7 +30,7 @@ int main (int argc, char * argv[])
std::cout << "Destination " << keys.GetPublic ()->GetIdentHash ().ToBase32 () << " created" << std::endl;
}
else
std::cout << "Can't create file " << argv[1] << std::endl;
std::cout << "Can't create file " << argv[1] << std::endl;
i2p::crypto::TerminateCrypto ();

140
keyinfo.cpp
View file

@ -9,6 +9,11 @@
#include <time.h>
#include "common/key.hpp"
static int printHelp(const char * exe, int exitcode)
{
std::cout << "usage: " << exe << " [-v] [-d] privatekey.dat" << std::endl;
return exitcode;
}
std::string ConvertTime (time_t t)
{
@ -20,71 +25,74 @@ std::string ConvertTime (time_t t)
int main(int argc, char * argv[])
{
if(argc == 1) {
std::cout << "usage: " << argv[0] << " [-v] [-d] privatekey.dat" << std::endl;
return -1;
}
int opt;
bool print_full = false;
bool verbose = false;
while((opt = getopt(argc, argv, "vd"))!=-1) {
switch(opt){
case 'v':
verbose = true;
break;
case 'd':
print_full = true;
break;
default:
std::cout << "usage: " << argv[0] << " [-v] [-d] privatekey.dat" << std::endl;
return -1;
}
}
std::string fname(argv[optind]);
i2p::data::PrivateKeys keys;
{
std::vector<uint8_t> buff;
std::ifstream inf;
inf.open(fname);
if (!inf.is_open()) {
std::cout << "cannot open private key file " << fname << std::endl;
return 2;
}
inf.seekg(0, std::ios::end);
const std::size_t len = inf.tellg();
inf.seekg(0, std::ios::beg);
buff.resize(len);
inf.read((char*)buff.data(), buff.size());
if (!keys.FromBuffer(buff.data(), buff.size())) {
std::cout << "bad key file format" << std::endl;
return 3;
}
}
auto dest = keys.GetPublic();
if(!dest) {
std::cout << "failed to extract public key" << std::endl;
return 3;
}
const auto & ident = dest->GetIdentHash();
if (verbose) {
std::cout << "Destination: " << dest->ToBase64() << std::endl;
std::cout << "Destination Hash: " << ident.ToBase64() << std::endl;
std::cout << "B32 Address: " << ident.ToBase32() << ".b32.i2p" << std::endl;
std::cout << "Signature Type: " << SigTypeToName(dest->GetSigningKeyType()) << std::endl;
std::cout << "Encryption Type: " << (int) dest->GetCryptoKeyType() << std::endl;
if (keys.IsOfflineSignature ())
{
std::cout << "Offline signature" << std::endl;
const auto& offlineSignature = keys.GetOfflineSignature ();
std::cout << "Expires: " << ConvertTime (bufbe32toh(offlineSignature.data ())) << std::endl;
std::cout << "Transient Signature Type: " << SigTypeToName(bufbe16toh(offlineSignature.data () + 4)) << std::endl;
if(argc == 1) {
return printHelp(argv[0], -1);
}
int opt;
bool print_full = false;
bool verbose = false;
while((opt = getopt(argc, argv, "hvd")) != -1) {
switch(opt){
case 'h':
return printHelp(argv[0], 0);
case 'v':
verbose = true;
break;
case 'd':
print_full = true;
break;
default:
return printHelp(argv[0], -1);
}
}
std::string fname(argv[optind]);
i2p::data::PrivateKeys keys;
{
std::vector<uint8_t> buff;
std::ifstream inf;
inf.open(fname);
if (!inf.is_open()) {
std::cout << "cannot open private key file " << fname << std::endl;
return 2;
}
inf.seekg(0, std::ios::end);
const std::size_t len = inf.tellg();
inf.seekg(0, std::ios::beg);
buff.resize(len);
inf.read((char*)buff.data(), buff.size());
if (!keys.FromBuffer(buff.data(), buff.size())) {
std::cout << "bad key file format" << std::endl;
return 3;
}
}
auto dest = keys.GetPublic();
if(!dest) {
std::cout << "failed to extract public key" << std::endl;
return 3;
}
const auto & ident = dest->GetIdentHash();
if (verbose) {
std::cout << "Destination: " << dest->ToBase64() << std::endl;
std::cout << "Destination Hash: " << ident.ToBase64() << std::endl;
std::cout << "B32 Address: " << ident.ToBase32() << ".b32.i2p" << std::endl;
std::cout << "Signature Type: " << SigTypeToName(dest->GetSigningKeyType()) << std::endl;
std::cout << "Encryption Type: " << (int) dest->GetCryptoKeyType() << std::endl;
if (keys.IsOfflineSignature ())
{
std::cout << "Offline signature" << std::endl;
const auto& offlineSignature = keys.GetOfflineSignature ();
std::cout << "Expires: " << ConvertTime (bufbe32toh(offlineSignature.data ())) << std::endl;
std::cout << "Transient Signature Type: " << SigTypeToName(bufbe16toh(offlineSignature.data () + 4)) << std::endl;
}
} else {
if(print_full) {
std::cout << dest->ToBase64() << std::endl;
} else {
std::cout << ident.ToBase32() << ".b32.i2p" << std::endl;
}
}
} else {
if(print_full) {
std::cout << dest->ToBase64() << std::endl;
} else {
std::cout << ident.ToBase32() << ".b32.i2p" << std::endl;
}
}
}

20
offlinekeys.cpp
View file

@ -23,8 +23,8 @@ int main (int argc, char * argv[])
std::ifstream inf;
inf.open(fname);
if (!inf.is_open()) {
std::cout << "cannot open keys file " << fname << std::endl;
return 2;
std::cout << "cannot open keys file " << fname << std::endl;
return 2;
}
inf.seekg(0, std::ios::end);
const std::size_t len = inf.tellg();
@ -32,13 +32,13 @@ int main (int argc, char * argv[])
buff.resize(len);
inf.read((char*)buff.data(), buff.size());
if (!keys.FromBuffer(buff.data(), buff.size())) {
std::cout << "bad keys file format" << std::endl;
return 3;
std::cout << "bad keys file format" << std::endl;
return 3;
}
}
}
i2p::data::SigningKeyType type = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519; // EdDSA by default
if (argc > 3)
if (argc > 3)
{
std::string str(argv[3]);
type = NameToSigType(str);
@ -46,10 +46,10 @@ int main (int argc, char * argv[])
int days = 365; // 1 year by default
if (argc > 4)
days = std::stoi (argv[4]);
days = std::stoi (argv[4]);
uint32_t expires = i2p::util::GetSecondsSinceEpoch () + days*24*60*60;
auto offlineKeys = keys.CreateOfflineKeys (type, expires);
auto offlineKeys = keys.CreateOfflineKeys (type, expires);
std::ofstream f (argv[1], std::ofstream::binary | std::ofstream::out);
if (f)
{
@ -61,7 +61,7 @@ int main (int argc, char * argv[])
std::cout << "Offline keys for destination " << offlineKeys.GetPublic ()->GetIdentHash ().ToBase32 () << " created" << std::endl;
}
else
std::cout << "Can't create file " << argv[1] << std::endl;
std::cout << "Can't create file " << argv[1] << std::endl;
i2p::crypto::TerminateCrypto ();

16
regaddr.cpp
View file

@ -12,22 +12,22 @@ int main (int argc, char * argv[])
return -1;
}
i2p::crypto::InitCrypto (false, true, true, false);
i2p::crypto::InitCrypto (false, true, true, false);
i2p::data::PrivateKeys keys;
std::ifstream s(argv[1], std::ifstream::binary);
if (s.is_open ())
{
if (s.is_open ())
{
s.seekg (0, std::ios::end);
size_t len = s.tellg();
s.seekg (0, std::ios::beg);
uint8_t * buf = new uint8_t[len];
s.read ((char *)buf, len);
if(keys.FromBuffer (buf, len))
{
{
auto signatureLen = keys.GetPublic ()->GetSignatureLen ();
uint8_t * signature = new uint8_t[signatureLen];
char * sig = new char[signatureLen*2];
char * sig = new char[signatureLen*2];
std::stringstream out;
out << argv[2] << "="; // address
out << keys.GetPublic ()->ToBase64 ();
@ -37,12 +37,12 @@ int main (int argc, char * argv[])
out << "#!sig=" << sig;
delete[] signature;
delete[] sig;
std::cout << out.str () << std::endl;
std::cout << out.str () << std::endl;
}
else
else
std::cout << "Failed to load keyfile " << argv[1] << std::endl;
delete[] buf;
}
}
i2p::crypto::TerminateCrypto ();

30
regaddralias.cpp
View file

@ -12,13 +12,13 @@ int main (int argc, char * argv[])
return -1;
}
i2p::crypto::InitCrypto (false, true, true, false);
i2p::crypto::InitCrypto (false, true, true, false);
i2p::data::PrivateKeys oldkeys, newkeys;
{
std::ifstream s(argv[1], std::ifstream::binary);
if (s.is_open ())
{
if (s.is_open ())
{
s.seekg (0, std::ios::end);
size_t len = s.tellg();
s.seekg (0, std::ios::beg);
@ -26,22 +26,22 @@ int main (int argc, char * argv[])
s.read ((char *)buf, len);
if(!oldkeys.FromBuffer (buf, len))
{
std::cout << "Failed to load keyfile " << argv[1] << std::endl;
std::cout << "Failed to load keyfile " << argv[1] << std::endl;
return -1;
}
delete[] buf;
}
}
else
{
std::cout << "Cab't open keyfile " << argv[1] << std::endl;
return -1;
std::cout << "Can't open keyfile " << argv[1] << std::endl;
return -1;
}
}
{
std::ifstream s(argv[2], std::ifstream::binary);
if (s.is_open ())
{
if (s.is_open ())
{
s.seekg (0, std::ios::end);
size_t len = s.tellg();
s.seekg (0, std::ios::beg);
@ -49,14 +49,14 @@ int main (int argc, char * argv[])
s.read ((char *)buf, len);
if(!newkeys.FromBuffer (buf, len))
{
std::cout << "Failed to load keyfile " << argv[2] << std::endl;
std::cout << "Failed to load keyfile " << argv[2] << std::endl;
return -1;
}
delete[] buf;
}
}
else
{
std::cout << "Cab't open keyfile " << argv[2] << std::endl;
std::cout << "Can't open keyfile " << argv[2] << std::endl;
return -1;
}
}
@ -69,7 +69,7 @@ int main (int argc, char * argv[])
auto oldSignatureLen = oldkeys.GetPublic ()->GetSignatureLen ();
uint8_t * oldSignature = new uint8_t[oldSignatureLen];
char * oldSig = new char[oldSignatureLen*2];
char * oldSig = new char[oldSignatureLen*2];
oldkeys.Sign ((uint8_t *)out.str ().c_str (), out.str ().length (), oldSignature);
auto len = i2p::data::ByteStreamToBase64 (oldSignature, oldSignatureLen, oldSig, oldSignatureLen*2);
oldSig[len] = 0;
@ -79,7 +79,7 @@ int main (int argc, char * argv[])
auto signatureLen = newkeys.GetPublic ()->GetSignatureLen ();
uint8_t * signature = new uint8_t[signatureLen];
char * sig = new char[signatureLen*2];
char * sig = new char[signatureLen*2];
newkeys.Sign ((uint8_t *)out.str ().c_str (), out.str ().length (), signature);
len = i2p::data::ByteStreamToBase64 (signature, signatureLen, sig, signatureLen*2);
sig[len] = 0;
@ -87,7 +87,7 @@ int main (int argc, char * argv[])
delete[] signature;
delete[] sig;
std::cout << out.str () << std::endl;
std::cout << out.str () << std::endl;
i2p::crypto::TerminateCrypto ();

12
routerinfo.cpp
View file

@ -18,7 +18,7 @@ static std::string address_style_string(Addr addr)
return "SSU";
}
return "???";
}
template<typename Addr>
@ -73,7 +73,7 @@ int main(int argc, char * argv[])
optind ++;
std::string fname(argv[idx]);
i2p::data::RouterInfo ri(fname);
std::vector<std::shared_ptr<const i2p::data::RouterInfo::Address> > addrs;
auto a = ri.GetNTCP2Address(!ipv6);
if(a)
@ -87,20 +87,20 @@ int main(int argc, char * argv[])
else
std::cout << "Router Hash: ";
std::cout << ri.GetIdentHashBase64() << std::endl;
for (const auto & a : addrs) {
if(firewall) {
write_firewall_entry(std::cout, a);
} else {
std::cout << address_style_string(a) << ": " << a->host;
if (port)
std::cout << ":" << a->port;
}
std::cout << std::endl;
}
}
return 0;
}

20
vanity.hpp
View file

@ -54,14 +54,14 @@ static unsigned long long hashescounter;
unsigned int count_cpu;
const uint8_t lastBlock[64] =
{
0x05, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x80, // 7 bytes EdDSA certificate
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x38 // 3128 bits (391 bytes)
};
{
0x05, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x80, // 7 bytes EdDSA certificate
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x38 // 3128 bits (391 bytes)
};

94
vanitygen.cpp
View file

@ -3,21 +3,21 @@
#include<getopt.h>
static struct{
bool reg=false;
int threads=-1;
i2p::data::SigningKeyType signature;
std::string outputpath="";
std::regex regex;
}options;
static struct
{
bool reg=false;
int threads=-1;
i2p::data::SigningKeyType signature;
std::string outputpath="";
std::regex regex;
} options;
static void inline CalculateW (const uint8_t block[64], uint32_t W[64])
{
/*
implementation of orignal
*/
/**
* implementation of orignal
*/
for (int i = 0; i < 16; i++)
#ifdef _WIN32
W[i] = htobe32(((uint32_t *)(block))[i]);
@ -31,9 +31,9 @@ implementation of orignal
static void inline TransformBlock (uint32_t state[8], const uint32_t W[64])
{
/*
implementation of orignal
*/
/**
* implementation of orignal
*/
uint32_t S[8];
memcpy(S, state, 32);
@ -60,9 +60,9 @@ implementation of orignal
void inline HashNextBlock (uint32_t state[8], const uint8_t * block)
{
/*
implementation of orignal
*/
/**
* implementation of orignal
*/
uint32_t W[64];
CalculateW (block, W);
TransformBlock (state, W);
@ -126,11 +126,11 @@ static inline bool NotThat(const char * a, const char *b)
static inline bool thread_find(uint8_t * buf, const char * prefix, int id_thread, unsigned long long throughput)
{
/*
Thanks to orignal ^-^
For idea and example ^-^
Orignal is sensei of crypto ;)
*/
/**
* Thanks to orignal ^-^
* For idea and example ^-^
* Orignal is sensei of crypto ;)
*/
std::cout << "Thread " << id_thread << " binded" << std::endl;
/*
union
@ -179,39 +179,35 @@ Orignal is sensei of crypto ;)
for (int j = 8; j--;)
hash[j] = htobe32(state1[j]);
ByteStreamToBase32 ((uint8_t*)hash, 32, addr, len);
// std::cout << addr << std::endl;
// std::cout << addr << std::endl;
//bool result = options.reg ? !NotThat(addr, &options.regex) : !NotThat(addr,prefix);
// bool result = options.reg ? !NotThat(addr, &options.regex) : !NotThat(addr,prefix);
if( ( options.reg ? !NotThat(addr, options.regex) : !NotThat(addr,prefix) ) )
// if(result)
if( ( options.reg ? !NotThat(addr, options.regex) : !NotThat(addr,prefix) ) )
// if(result)
{
ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
std::cout << "Address found " << addr << " in " << id_thread << std::endl;
found=true;
FoundNonce=*nonce;
// free(hash);
// free(b);
return true;
}
// free(hash);
// free(b);
return true;
}
(*nonce)++;
hashescounter++;
if (found)
{
// free(hash);
// free(b);
// free(hash);
// free(b);
break;
}
}//while
} // while
return true;
}
void usage(void){
const constexpr char * help="vain [text-pattern|regex-pattern] [options]\n"
"-h --help, help menu\n"
@ -220,12 +216,11 @@ void usage(void){
"--signature -s, (signature type)\n"
"-o --output output file (default private.dat)\n"
"--usage usage\n"
//"--prefix -p\n"
// "--prefix -p\n"
"";
puts(help);
}
void parsing(int argc, char ** args){
int option_index;
static struct option long_options[]={
@ -274,10 +269,6 @@ void parsing(int argc, char ** args){
int main (int argc, char * argv[])
{
if ( argc < 2 )
{
usage();
@ -320,7 +311,7 @@ int main (int argc, char * argv[])
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512:
std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl;
std::cout << "Sorry, i don't can generate address for this signature type" << std::endl;
return 0;
break;
}
@ -371,8 +362,8 @@ int main (int argc, char * argv[])
unsigned short attempts = 0;
while(!found)
{//while
{//stack(for destructors(vector/thread))
{ // while
{ // stack(for destructors(vector/thread))
std::vector<std::thread> threads(options.threads);
unsigned long long thoughtput = 0x4F4B5A37;
@ -381,7 +372,7 @@ int main (int argc, char * argv[])
{
threads[j] = std::thread(thread_find,KeyBuf,argv[1],j,thoughtput);
thoughtput+=1000;
}//for
} // for
for(unsigned int j = 0; j < (unsigned int)options.threads;j++)
threads[j].join();
@ -392,8 +383,8 @@ int main (int argc, char * argv[])
std::cout << "Attempts #" << ++attempts << std::endl;
}
}//stack
}//while
} // stack
} // while
memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
std::cout << "Hashes: " << hashescounter << std::endl;
@ -413,6 +404,3 @@ int main (int argc, char * argv[])
return 0;
}
//