yggm/sources/main.cpp
2025-03-02 16:41:02 +05:00

174 lines
6.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 <atomic>
#include <arpa/inet.h>
#include <immintrin.h>
struct option {
unsigned int proc = 0;
bool log = true;
int high = 20;
std::string outputfile;
};
static option conf;
int parameters(option& conf, std::string arg) {
if (arg.find(" ") != std::string::npos) {
const unsigned long npos = std::string::npos;
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("--altitude") != npos || arg.find("-a") != npos) {
int tmp_high;
ss >> std::hex >> tmp_high;
if (ss.fail()) return 1;
conf.high = tmp_high;
return 0;
}
}
if (arg == "--threads" || arg == "-t") 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);
}
std::cout << " Threads: " << conf.proc << ", " << "high addresses (2" << std::setw(2) << std::setfill('0') << std::hex << conf.high << "+)" << std::dec << std::endl;
}
using Address = unsigned char[16];
using Key = unsigned char[32];
struct KeysBox {
Key PublicKey;
Key PrivateKey;
};
std::string getAddress(const Address& rawAddr) {
char ipStrBuf[46];
inet_ntop(AF_INET6, rawAddr, ipStrBuf, 46);
return std::string(ipStrBuf);
}
inline std::string keyToString(const unsigned char* key) {
std::string result;
result.resize(64);
const char* hexDigits = "0123456789abcdef";
for (unsigned char i = 0; i < 32; i++) {
result[2 * i] = hexDigits[key[i] >> 4];
result[2 * i + 1] = hexDigits[key[i] & 0x0F];
}
return result;
}
inline void bitwiseInverse(const unsigned char* key, Key& inverted) noexcept {
__m256i chunk = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(key));
chunk = _mm256_xor_si256(chunk, _mm256_set1_epi8(0xFF));
_mm256_storeu_si256(reinterpret_cast<__m256i*>(inverted), chunk);
}
inline unsigned char getOnes(const Key& value) noexcept {
int leadOnes = 0;
for (unsigned char i = 0; i < 17; i++) {
if (value[0] != 0xFF) return leadOnes;
if (value[i] == 0xFF) {
leadOnes += 8;
} else {
for (unsigned char j = 7; j < 8; j--) {
if (!(value[i] & (1 << j))) {
return leadOnes;
}
leadOnes++;
}
}
}
return leadOnes;
}
void miner_thread() noexcept {
Key inv;
KeysBox keys;
unsigned char ones;
while (true) {
crypto_sign_ed25519_keypair(keys.PublicKey, keys.PrivateKey);
bitwiseInverse(keys.PublicKey, inv);
ones = getOnes(inv);
if (ones > conf.high) {
printf("\nAddr:\t2%x/%d\nPK:\t%s\nSK:\t%s\n", conf.high = ones, ones, keyToString(keys.PublicKey).c_str(), keyToString(keys.PrivateKey).c_str());
}
}
}
void startThreads() noexcept {
std::vector<std::thread> threads;
for (unsigned char i = 0; i < conf.proc; 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();
}
}
*/