#include #include #include #include #include #include #include #include #include #include #include struct option { unsigned proc = 0; std::atomic high = 0x14; }; static option conf; int parameters(std::string arg) { if (arg.find(" ") != std::string::npos) { const unsigned long npos = std::string::npos; std::istringstream ss(arg.substr(arg.find(" ") + 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) { unsigned tmp_high; ss >> std::hex >> tmp_high; if (ss.fail()) return 1; conf.high = tmp_high; return 0; } /* if (arg.find("--invert") != npos || arg.find("-i") != npos) { return 0; } */ } if (arg == "--threads" || arg == "-t" || arg == "--altitude" || arg == "-a") { return 777; } return 0; } void displayConfig() { unsigned processor_count = std::thread::hardware_concurrency(); if (conf.proc == 0 || conf.proc > static_cast(processor_count)) { conf.proc = static_cast(processor_count); } printf("Threads: %u, high addresses (2%02x+)\n", conf.proc, conf.high.load()); } using Address = unsigned char[16]; using Key = unsigned char[32]; inline std::string getAddress(const Address& rawAddr) noexcept { char ipStrBuf[46]; inet_ntop(AF_INET6, rawAddr, ipStrBuf, 46); return std::string(ipStrBuf); } inline std::string KeyToString(const unsigned char* key) noexcept { char result[65]; const char* hexDigits = "0123456789abcdef"; #pragma unroll for (unsigned char i = 0; i < 32; i++) { result[2 * i] = hexDigits[key[i] >> 4]; result[2 * i + 1] = hexDigits[key[i] & 0x0F]; } result[64] = '\0'; return std::string(result); } typedef struct alignas(32) { Key PublicKey; Key PrivateKey; } KeysBox; void getRawAddress(int lErase, Key& InvertedPublicKey, Address& rawAddr) noexcept { lErase++; const int bitsToShift = lErase % 8; const int start = lErase / 8; if (bitsToShift != 0) { for (int i = start; i < start + 15; i++) { InvertedPublicKey[i] = static_cast((InvertedPublicKey[i] << bitsToShift) | (InvertedPublicKey[i + 1] >> (8 - bitsToShift))); } } rawAddr[0] = 0x02; rawAddr[1] = static_cast(lErase - 1); memcpy(&rawAddr[2], &InvertedPublicKey[start], 14); } inline void invertKey(const unsigned char* __restrict key, Key& inverted) noexcept { _mm256_storeu_si256(reinterpret_cast<__m256i*>(inverted), _mm256_xor_si256(_mm256_loadu_si256(reinterpret_cast(key)), _mm256_set1_epi8(0xFF))); } [[nodiscard]] inline unsigned char zeroCounter(unsigned int x) noexcept { return x == 0 ? 32 : static_cast(__builtin_clz(x)); } [[nodiscard]] inline unsigned char getZeros(const Key& v) noexcept { unsigned char leadZeros = 0; for (unsigned char i = 0; i < 32; i += 4) { unsigned word = (static_cast(v[i]) << 24) | (static_cast(v[i + 1]) << 16) | (static_cast(v[i + 2]) << 8) | (static_cast(v[i + 3])); if (word == 0) { leadZeros += 32; } else { leadZeros += zeroCounter(word); break; } } return leadZeros; } [[nodiscard]] inline long long xorshift64(unsigned long& state) noexcept { state ^= state << 21; state ^= state >> 35; state ^= state << 4; return static_cast(state * 2685821657736338717); } inline void rmbytes(unsigned char* __restrict buf, unsigned char size, unsigned long& state) noexcept { for (unsigned char x = 0; x < 32; x++) { _mm256_store_si256((__m256i*) & buf[x * 32], _mm256_set_epi64x(xorshift64(state), xorshift64(state), xorshift64(state), xorshift64(state))); } } inline void sign_keypair(unsigned char* __restrict pk, unsigned char* __restrict sk, const unsigned char* __restrict seed) noexcept { alignas(32) unsigned char h[64]; crypto_hash_sha512(h, seed, 32); h[31] = (h[31] & 0xF8) | (0x40 | (h[31] & 0x7F)); crypto_scalarmult_ed25519_base(pk, h); _mm256_store_si256(reinterpret_cast<__m256i*>(sk), _mm256_load_si256(reinterpret_cast(seed))); _mm256_store_si256(reinterpret_cast<__m256i*>(sk + 32), _mm256_load_si256(reinterpret_cast(pk))); } void miner_thread() noexcept { alignas(32) Key inv; alignas(32) Key seed; KeysBox keys; Address rawAddr; std::random_device rd; unsigned long state = static_cast(rd()); printf("Using seed: %lu\n", state); while (true) { rmbytes(seed, sizeof(seed), state); crypto_sign_ed25519_seed_keypair(keys.PublicKey, keys.PrivateKey, seed); if (unsigned char ones = getZeros(keys.PublicKey); ones > conf.high.load()) { conf.high.store(ones); invertKey(keys.PublicKey, inv); getRawAddress(ones, inv, rawAddr); printf("\nIPv6:\t%s\nPK:\t%s\nSK:\t%s\n", getAddress(rawAddr).c_str(), KeyToString(keys.PublicKey).c_str(), KeyToString(keys.PrivateKey).c_str()); } } } void startThreads() noexcept { std::vector threads; threads.reserve(conf.proc); for (unsigned char x = 0; x < conf.proc; x++) { threads.emplace_back(miner_thread); } for (auto& thread : threads) { thread.join(); } } int main(int argc, char* argv[]) noexcept { if (argc < 2) return 0; for (int x = 1; x < argc; x++) { if (int res = parameters(argv[x]); res == 777) { if (++x >= argc) { std::cerr << "Empty value for parameter \"" << argv[x - 1] << "\"" << std::endl; return 776; } if (parameters(argv[x - 1] + std::string(" ") + argv[x]) != 0) { std::cerr << "Wrong value \"" << argv[x] << "\" for parameter \"" << argv[x - 1] << "\"" << std::endl; return res; } } } displayConfig(); startThreads(); return 0; }