132 lines
3.1 KiB
C++
Executable file
132 lines
3.1 KiB
C++
Executable file
//
|
|
// Created by Haifa Bogdan Adnan on 03/08/2018.
|
|
//
|
|
|
|
#include "../common/common.h"
|
|
#include "../crypt/base64.h"
|
|
#include "../crypt/hex.h"
|
|
#include "../crypt/random_generator.h"
|
|
|
|
#include "crypto/argon2_hasher/common/DLLExport.h"
|
|
#include "crypto/argon2_hasher/hash/argon2/Argon2.h"
|
|
#include "Hasher.h"
|
|
|
|
vector<Hasher *> *Hasher::m_registeredHashers = NULL;
|
|
string Hasher::m_appFolder = "";
|
|
|
|
typedef void (*hasherLoader)();
|
|
|
|
Hasher::Hasher() {
|
|
m_intensity = 0;
|
|
m_type = "";
|
|
m_subType = "";
|
|
m_shortSubType = "";
|
|
m_description = "";
|
|
|
|
m_computingThreads = 1;
|
|
|
|
if(m_registeredHashers == NULL) {
|
|
m_registeredHashers = new vector<Hasher*>();
|
|
}
|
|
|
|
m_registeredHashers->push_back(this);
|
|
}
|
|
|
|
Hasher::~Hasher() {};
|
|
|
|
string Hasher::type() {
|
|
return m_type;
|
|
}
|
|
|
|
string Hasher::subType(bool shortName) {
|
|
if(shortName && !(m_shortSubType.empty())) {
|
|
string shortVersion = m_shortSubType;
|
|
shortVersion.erase(3);
|
|
return shortVersion;
|
|
}
|
|
else
|
|
return m_subType;
|
|
}
|
|
|
|
string Hasher::info() {
|
|
return m_description;
|
|
}
|
|
|
|
int Hasher::computingThreads() {
|
|
return m_computingThreads;
|
|
}
|
|
|
|
void Hasher::loadHashers(const string &appPath) {
|
|
m_registeredHashers = new vector<Hasher*>();
|
|
|
|
string modulePath = ".";
|
|
|
|
size_t lastSlash = appPath.find_last_of("/\\");
|
|
if (lastSlash != string::npos) {
|
|
modulePath = appPath.substr(0, lastSlash);
|
|
if(modulePath.empty()) {
|
|
modulePath = ".";
|
|
}
|
|
}
|
|
|
|
m_appFolder = modulePath;
|
|
|
|
modulePath += "/modules/";
|
|
|
|
vector<string> files = getFiles(modulePath);
|
|
for(string file : files) {
|
|
if(file.find(".hsh") != string::npos) {
|
|
void *dllHandle = dlopen((modulePath + file).c_str(), RTLD_LAZY);
|
|
if(dllHandle != NULL) {
|
|
hasherLoader hasherLoaderPtr = (hasherLoader) dlsym(dllHandle, "hasherLoader");
|
|
(*hasherLoaderPtr)();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vector<Hasher *> Hasher::getHashers() {
|
|
return *m_registeredHashers;
|
|
}
|
|
|
|
vector<Hasher *> Hasher::getActiveHashers() {
|
|
vector<Hasher *> filtered;
|
|
for(Hasher *hasher : *m_registeredHashers) {
|
|
if(hasher->m_intensity != 0)
|
|
filtered.push_back(hasher);
|
|
}
|
|
return filtered;
|
|
}
|
|
|
|
vector<Hasher *> Hasher::getHashers(const string &type) {
|
|
vector<Hasher *> filtered;
|
|
for(Hasher *hasher : *m_registeredHashers) {
|
|
if(hasher->m_type == type)
|
|
filtered.push_back(hasher);
|
|
}
|
|
return filtered;
|
|
}
|
|
|
|
map<int, DeviceInfo> &Hasher::devices() {
|
|
return m_deviceInfos;
|
|
}
|
|
|
|
void Hasher::storeDeviceInfo(int deviceId, DeviceInfo device) {
|
|
m_deviceInfosMutex.lock();
|
|
m_deviceInfos[deviceId] = device;
|
|
m_deviceInfosMutex.unlock();
|
|
}
|
|
|
|
Argon2Profile *Hasher::getArgon2Profile(xmrig::Algo algorithm, xmrig::Variant variant) {
|
|
if(algorithm == xmrig::ARGON2) {
|
|
switch(variant) {
|
|
case xmrig::VARIANT_CHUKWA:
|
|
return &argon2profile_3_1_512;
|
|
case xmrig::VARIANT_CHUKWA_LITE:
|
|
return &argon2profile_4_1_256;
|
|
default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|