242 lines
9.0 KiB
C++
242 lines
9.0 KiB
C++
#include <sodium.h>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <iomanip>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <string>
|
|
#include <memory.h>
|
|
#include <thread>
|
|
#include <regex>
|
|
#include <arpa/inet.h>
|
|
#include <immintrin.h>
|
|
int countsize = 0;
|
|
using Key = std::array<unsigned char, 32>;
|
|
using Address = std::array<unsigned char, 16>;
|
|
struct KeysBox {
|
|
Key PublicKey;
|
|
Key PrivateKey;
|
|
};
|
|
struct option {
|
|
unsigned int proc = 0;
|
|
int mode = 1; // режим майнинга
|
|
bool log = true; // логгирование
|
|
int high = 20; // начальная высота при майнинге: dec(20) == hex(14)
|
|
bool letsup = true; // повышение высоты при нахождении
|
|
bool mesh = false; // отображение meshname-доменов
|
|
bool fullkeys = true; // отображение секретного ключа в консоли в полном формате
|
|
std::string str = "aaaa";
|
|
std::string outputfile;
|
|
int sbt_size = 7;
|
|
bool sbt_alarm = false;
|
|
};
|
|
static option conf;
|
|
int parameters(option& conf, std::string arg) {
|
|
if (arg.find(" ") != std::string::npos) {
|
|
const size_t npos = -1;
|
|
int position = arg.find(" ");
|
|
std::istringstream ss(arg.substr(position + 1));
|
|
if (arg.find("--threads") != npos || arg.find("-t") != npos) {
|
|
ss >> conf.proc;
|
|
if (ss.fail()) return 1;
|
|
return 0;
|
|
}
|
|
if (arg.find("--pattern") != npos || arg.find("-p") != npos) {
|
|
ss >> conf.str;
|
|
if (ss.fail()) return 1;
|
|
return 0;
|
|
}
|
|
if (arg.find("--altitude") != npos || arg.find("-a") != npos) {
|
|
ss >> std::hex >> conf.high;
|
|
if (ss.fail()) return 1;
|
|
return 0;
|
|
}
|
|
}
|
|
else if (arg == "--ip" || arg == "-i") conf.mode = 0;
|
|
else if (arg == "--ip-high" || arg == "-ih") conf.mode = 2;
|
|
else if (arg == "--regexp" || arg == "-r") conf.mode = 3;
|
|
else if (arg == "--regexp-high" || arg == "-rh") conf.mode = 4;
|
|
else if (arg == "--mesh" || arg == "-m") conf.mode = 5;
|
|
else if (arg == "--mesh-regexp" || arg == "-mr") conf.mode = 6;
|
|
else if (arg == "--brute-force" || arg == "-b") conf.mode = 7;
|
|
else if (arg == "--increase-none" || arg == "-in") conf.letsup = false;
|
|
else if (arg == "--logging-none" || arg == "-ln") conf.log = false;
|
|
else if (arg == "--display-mesh" || arg == "-dm") conf.mesh = true;
|
|
else if (arg == "--full-pk" || arg == "-fp") conf.fullkeys = true;
|
|
else if (arg == "--threads" || arg == "-t") return 777;
|
|
else if (arg == "--pattern" || arg == "-p") return 777;
|
|
else if (arg == "--altitude" || arg == "-a") return 777;
|
|
return 0;
|
|
}
|
|
void displayConfig() {
|
|
unsigned short processor_count = std::thread::hardware_concurrency();
|
|
if (conf.proc == 0 || conf.proc > static_cast<unsigned int>(processor_count))
|
|
conf.proc = static_cast<unsigned int>(processor_count);
|
|
|
|
countsize = 80000 * conf.proc;
|
|
std::cout << " Threads: " << conf.proc << ", ";
|
|
if (conf.mode == 0)
|
|
std::cout << "IPv6 pattern (" << conf.str << "), ";
|
|
else if (conf.mode == 1) {
|
|
std::cout << "high addresses (2" << std::setw(2) << std::setfill('0') <<
|
|
std::hex << conf.high << std::dec;
|
|
(conf.letsup != 0) ? std::cout << "++), " : std::cout << "+), ";
|
|
} else if (conf.mode == 2) {
|
|
std::cout << "by pattern (" << conf.str << ") & high (2" <<
|
|
std::setw(2) << std::setfill('0') << std::hex << conf.high << std::dec;
|
|
(conf.letsup != 0) ? std::cout << "++), " : std::cout << "+), ";
|
|
} else if (conf.mode == 3)
|
|
std::cout << "IPv6 regexp (" << conf.str << "), ";
|
|
else if (conf.mode == 4) {
|
|
std::cout << "IPv6 regexp (" << conf.str << ") & high (2" <<
|
|
std::setw(2) << std::setfill('0') << std::hex << conf.high << std::dec;
|
|
(conf.letsup != 0) ? std::cout << "++), " : std::cout << "+), ";
|
|
} else if (conf.mode == 5)
|
|
std::cout << "meshname pattern (" << conf.str << "), ";
|
|
else if (conf.mode == 6)
|
|
std::cout << "meshname regexp (" << conf.str << "), ";
|
|
else if (conf.mode == 7)
|
|
std::cout << "subnet brute force (" << conf.str << "/" << (conf.sbt_size + 1) * 8 << "), ";
|
|
if (conf.log)
|
|
std::cout << "logging to text file.";
|
|
else
|
|
std::cout << "console log only.";
|
|
if ((conf.mode == 5 || conf.mode == 6) && conf.mesh == 0)
|
|
conf.mesh = 1;
|
|
std::cout << std::endl << std::endl;
|
|
}
|
|
KeysBox getKeyPair() {
|
|
KeysBox keys;
|
|
unsigned char sk[64];
|
|
crypto_sign_ed25519_keypair(keys.PublicKey.data(), sk);
|
|
memcpy(keys.PrivateKey.data(), sk, 32);
|
|
return keys;
|
|
}
|
|
std::string getAddress(const Address& rawAddr) {
|
|
char ipStrBuf[46];
|
|
inet_ntop(AF_INET6, rawAddr.data(), ipStrBuf, 46);
|
|
return std::string(ipStrBuf);
|
|
}
|
|
inline std::string keyToString(const Key& key) {
|
|
std::string result;
|
|
for (int i = 0; i < 32; ++i) {
|
|
result.push_back("0123456789abcdef"[key.data()[i] >> 4]);
|
|
result.push_back("0123456789abcdef"[key.data()[i] & 0x0F]);
|
|
}
|
|
return result;
|
|
}
|
|
inline Key bitwiseInverse(const Key& key) {
|
|
Key inverted;
|
|
std::transform(key.begin(), key.end(), inverted.begin(), [](unsigned char byte) {
|
|
return static_cast<unsigned char>(~byte);
|
|
});
|
|
return inverted;
|
|
}
|
|
int getOnes(const Key& value) {
|
|
int leadOnes = 0;
|
|
for (int i = 0; i < 17; ++i) {
|
|
if (value[i] == 0xFF) {
|
|
leadOnes += 8;
|
|
} else {
|
|
for (int j = 7; j >= 0; j--) {
|
|
if (value[i] & (1 << j)) {
|
|
leadOnes++;
|
|
} else {
|
|
return leadOnes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return leadOnes;
|
|
}
|
|
void printKeys(int ones, const KeysBox& keys) {
|
|
char buffer[256];
|
|
int len = snprintf(buffer, sizeof(buffer), "\nAddr:\t2%x\nPK:\t%s\nSK:\t%s\n", ones, keyToString(keys.PublicKey).c_str(), keyToString(keys.PrivateKey).c_str());
|
|
if (len > 0 && len < static_cast<int>(sizeof(buffer))) {
|
|
printf("%s", buffer);
|
|
} else {
|
|
fprintf(stderr, "Buffer overflow or error in snprintf\n");
|
|
}
|
|
}
|
|
void miner_thread() {
|
|
KeysBox keys;
|
|
Key inv;
|
|
int ones;
|
|
while (1) {
|
|
keys = getKeyPair();
|
|
inv = bitwiseInverse(keys.PublicKey);
|
|
if ((ones = getOnes(inv)) > conf.high) {
|
|
conf.high = ones;
|
|
printKeys(ones, keys);
|
|
}
|
|
}
|
|
}
|
|
void startThreads() {
|
|
std::vector<std::thread> threads;
|
|
for (unsigned int i = 0; i < std::thread::hardware_concurrency(); ++i) {
|
|
threads.emplace_back(miner_thread);
|
|
}
|
|
for (auto& thread : threads) {
|
|
thread.join();
|
|
}
|
|
}
|
|
int main(int argc, char* argv[]) {
|
|
if (argc >= 2) {
|
|
int res = -1;
|
|
for (int i = 1;; ++i) {
|
|
if (argv[i] == nullptr) break;
|
|
res = parameters(conf, std::string(argv[i]));
|
|
if (res == 777) {
|
|
i++;
|
|
if (argv[i] == nullptr) {
|
|
std::cerr << " Empty value for parameter \"" << argv[i - 1] << "\"" << std::endl;
|
|
return 776;
|
|
}
|
|
int res2 = parameters(conf, std::string(std::string(argv[i - 1]) + " " + std::string(argv[i])));
|
|
if (res2 != 0) {
|
|
std::cerr << " Wrong value \"" << argv[i] << "\" for parameter \"" << argv[i - 1] << "\"" << std::endl;
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
displayConfig();
|
|
startThreads();
|
|
}
|
|
void getRawAddress(int lErase, Key& InvertedPublicKey, Address& rawAddr) {
|
|
lErase++;
|
|
const int bitsToShift = lErase % 8;
|
|
const int start = lErase / 8;
|
|
const int invSize = start + 15;
|
|
if (bitsToShift == 0) {
|
|
for (int i = start; i < invSize; ++i)
|
|
InvertedPublicKey[i] = InvertedPublicKey[i];
|
|
} else {
|
|
const int complementary = 8 - bitsToShift;
|
|
for (int i = start; i < start + 15; ++i) {
|
|
InvertedPublicKey[i] = static_cast<unsigned char>((InvertedPublicKey[i] << bitsToShift) | (InvertedPublicKey[i + 1] >> complementary));
|
|
}
|
|
}
|
|
rawAddr[0] = 0x02;
|
|
rawAddr[1] = static_cast<unsigned char>(lErase - 1);
|
|
memcpy(&rawAddr[2], &InvertedPublicKey[start], 14);
|
|
}
|
|
/*
|
|
void logKeys(const Address& raw, const KeysBox& keys) {
|
|
std::cout << std::endl;
|
|
std::cout << " Address: " << getAddress(raw) << std::endl;
|
|
std::cout << " PublicKey: " << keyToString(keys.PublicKey) << std::endl;
|
|
std::cout << " PrivateKey: " << keyToString(keys.PrivateKey);
|
|
if (!conf.log || conf.fullkeys) std::cout << keyToString(keys.PublicKey);
|
|
std::cout << std::endl << std::endl;
|
|
if (conf.log) {
|
|
std::ofstream output(conf.outputfile, std::ios::app);
|
|
output << std::endl;
|
|
output << "Address: " << getAddress(raw) << std::endl;
|
|
output << "PublicKey: " << keyToString(keys.PublicKey) << std::endl;
|
|
output << "PrivateKey: " << keyToString(keys.PrivateKey) << keyToString(keys.PublicKey) << std::endl;
|
|
output.close();
|
|
}
|
|
}
|
|
*/ |