diff --git a/AddrGen/Makefile b/AddrGen/Makefile index 901a5091..e52f04f1 100644 --- a/AddrGen/Makefile +++ b/AddrGen/Makefile @@ -1,7 +1,7 @@ CPPSRC:=$(wildcard *.cpp) all: - ${CXX} -o addrgen.bin ${CPPSRC} ${INCLUDE} -I${CUDA_INCLUDE} ${CXXFLAGS} ${LIBS} -laddressutil -lsecp256k1 -lcryptoutil -lsecp256k1 -lutil -lcmdparse + ${CXX} -o addrgen.bin ${CPPSRC} ${INCLUDE} -I${CUDA_INCLUDE} ${CXXFLAGS} ${LDFLAGS} ${LIBS} -laddressutil -lsecp256k1 -lcryptoutil -lsecp256k1 -lutil -lcmdparse mkdir -p $(BINDIR) cp addrgen.bin $(BINDIR)/addrgen diff --git a/KeyFinder/DeviceManager.cpp b/KeyFinder/DeviceManager.cpp index cec6c77e..873ce1ef 100644 --- a/KeyFinder/DeviceManager.cpp +++ b/KeyFinder/DeviceManager.cpp @@ -8,6 +8,11 @@ #include "clutil.h" #endif +#ifdef BUILD_METAL +#include "MetalKeySearchDevice.h" +#include +#endif + std::vector DeviceManager::getDevices() { int deviceId = 0; @@ -57,5 +62,21 @@ std::vector DeviceManager::getDevices() } #endif +#ifdef BUILD_METAL + MTL::Device* device = MTL::CreateSystemDefaultDevice(); + if(device) { + DeviceManager::DeviceInfo devInfo; + devInfo.name = device->name()->utf8String(); + devInfo.type = DeviceType::Metal; + devInfo.id = deviceId; + devInfo.physicalId = 0; + devInfo.memory = device->recommendedMaxWorkingSetSize(); + devInfo.computeUnits = 0; + devices.push_back(devInfo); + deviceId++; + device->release(); + } +#endif + return devices; } \ No newline at end of file diff --git a/KeyFinder/DeviceManager.h b/KeyFinder/DeviceManager.h index 5f76fd41..1235450b 100644 --- a/KeyFinder/DeviceManager.h +++ b/KeyFinder/DeviceManager.h @@ -22,7 +22,8 @@ class DeviceType { public: enum { CUDA = 0, - OpenCL + OpenCL, + Metal }; }; diff --git a/KeyFinder/Makefile b/KeyFinder/Makefile index 12ad4d44..a22bd1ec 100644 --- a/KeyFinder/Makefile +++ b/KeyFinder/Makefile @@ -11,7 +11,13 @@ ifeq ($(BUILD_OPENCL),1) mkdir -p $(BINDIR) cp clKeyFinder.bin $(BINDIR)/clBitCrack endif +ifeq ($(BUILD_METAL),1) + ${CXX} -DBUILD_METAL -o metalKeyFinder.bin ${CPPSRC} ${INCLUDE} ${CXXFLAGS} ${LDFLAGS} ${LIBS} -lkeyfinder -laddressutil -lsecp256k1 -lcryptoutil -lsecp256k1 -lMetalKeySearchDevice -llogger -lutil -lcmdparse + mkdir -p $(BINDIR) + cp metalKeyFinder.bin $(BINDIR)/metalBitCrack +endif clean: rm -rf cuKeyFinder.bin rm -rf clKeyFinder.bin + rm -rf metalKeyFinder.bin diff --git a/KeyFinder/main.cpp b/KeyFinder/main.cpp index 381b78bc..82ba3804 100644 --- a/KeyFinder/main.cpp +++ b/KeyFinder/main.cpp @@ -20,6 +20,10 @@ #include "CLKeySearchDevice.h" #endif +#ifdef BUILD_METAL +#include "MetalKeySearchDevice.h" +#endif + typedef struct { // startKey is the first key. We store it so that if the --continue // option is used, the correct progress is displayed. startKey and @@ -251,6 +255,12 @@ static KeySearchDevice *getDeviceContext(DeviceManager::DeviceInfo &device, int } #endif +#ifdef BUILD_METAL + if(device.type == DeviceManager::DeviceType::Metal) { + return new MetalKeySearchDevice(device.id, pointsPerThread); + } +#endif + return NULL; } diff --git a/Makefile b/Makefile index ccde01e9..c0a39e29 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ CUR_DIR=$(shell pwd) -DIRS=util AddressUtil CmdParse CryptoUtil KeyFinderLib CLKeySearchDevice CudaKeySearchDevice cudaMath clUtil cudaUtil secp256k1lib Logger embedcl +DIRS=util AddressUtil CmdParse CryptoUtil KeyFinderLib CLKeySearchDevice CudaKeySearchDevice MetalKeySearchDevice cudaMath clUtil cudaUtil secp256k1lib Logger embedcl INCLUDE = $(foreach d, $(DIRS), -I$(CUR_DIR)/$d) @@ -11,6 +11,7 @@ LIBS+=-L$(LIBDIR) # C++ options CXX=g++ CXXFLAGS=-O2 -std=c++11 +LDFLAGS= # CUDA variables COMPUTE_CAP=86 @@ -41,6 +42,7 @@ export OPENCL_LIB export OPENCL_INCLUDE export BUILD_OPENCL export BUILD_CUDA +export BUILD_METAL TARGETS=dir_addressutil dir_cmdparse dir_cryptoutil dir_keyfinderlib dir_keyfinder dir_secp256k1lib dir_util dir_logger dir_addrgen @@ -53,6 +55,13 @@ ifeq ($(BUILD_OPENCL),1) CXXFLAGS:=${CXXFLAGS} -DCL_TARGET_OPENCL_VERSION=${OPENCL_VERSION} endif +ifeq ($(BUILD_METAL),1) + TARGETS:=${TARGETS} dir_metalKeySearchDevice + CXX=clang++ + CXXFLAGS+=-std=c++17 -Wno-unused-parameter + LDFLAGS+=-framework Metal -framework Foundation +endif + all: ${TARGETS} dir_cudaKeySearchDevice: dir_keyfinderlib dir_cudautil dir_logger @@ -61,6 +70,9 @@ dir_cudaKeySearchDevice: dir_keyfinderlib dir_cudautil dir_logger dir_clKeySearchDevice: dir_embedcl dir_keyfinderlib dir_clutil dir_logger make --directory CLKeySearchDevice +dir_metalKeySearchDevice: dir_keyfinderlib dir_logger + make --directory MetalKeySearchDevice + dir_embedcl: make --directory embedcl @@ -86,6 +98,10 @@ ifeq ($(BUILD_OPENCL),1) KEYFINDER_DEPS:=$(KEYFINDER_DEPS) dir_clKeySearchDevice endif +ifeq ($(BUILD_METAL),1) + KEYFINDER_DEPS:=$(KEYFINDER_DEPS) dir_metalKeySearchDevice +endif + dir_keyfinder: $(KEYFINDER_DEPS) make --directory KeyFinder diff --git a/Makefile.metal b/Makefile.metal new file mode 100644 index 00000000..84073e37 --- /dev/null +++ b/Makefile.metal @@ -0,0 +1,50 @@ +# Makefile for building the Metal backend on macOS + +# Compiler +CXX=clang++ + +# Directories +CUR_DIR=$(shell pwd) +LIBDIR=$(CUR_DIR)/lib +BINDIR=$(CUR_DIR)/bin + +# Source directories +DIRS=util AddressUtil CmdParse CryptoUtil KeyFinderLib MetalKeySearchDevice secp256k1lib Logger + +# Include paths +INCLUDE = $(foreach d, $(DIRS), -I$(CUR_DIR)/$d) +INCLUDE += -I/opt/homebrew/opt/openssl/include + +# C++ flags +CXXFLAGS=-O2 -std=c++17 -Wno-unused-parameter -DBUILD_METAL + +# Linker flags +LDFLAGS=-L/opt/homebrew/opt/openssl/lib -L${LIBDIR} -framework Metal -framework Foundation + +# Libraries +LIBS=-lkeyfinder -laddressutil -lsecp256k1 -lcryptoutil -lMetalKeySearchDevice -llogger -lutil -lcmdparse -lcrypto + +# Source files +SRCS = $(wildcard util/*.cpp) \ + $(wildcard AddressUtil/*.cpp) \ + $(wildcard CmdParse/*.cpp) \ + $(wildcard CryptoUtil/*.cpp) \ + $(wildcard KeyFinderLib/*.cpp) \ + $(wildcard MetalKeySearchDevice/*.cpp) \ + $(wildcard secp256k1lib/*.cpp) \ + $(wildcard Logger/*.cpp) \ + KeyFinder/main.cpp \ + KeyFinder/ConfigFile.cpp \ + KeyFinder/DeviceManager.cpp + +# Target +all: metalBitCrack + +metalBitCrack: + mkdir -p ${BINDIR} + ${CXX} -o ${BINDIR}/metalBitCrack ${SRCS} ${INCLUDE} ${CXXFLAGS} ${LDFLAGS} ${LIBS} + +clean: + rm -rf ${BINDIR} + +.PHONY: all clean diff --git a/MetalKeySearchDevice/Makefile b/MetalKeySearchDevice/Makefile new file mode 100644 index 00000000..0c0e179f --- /dev/null +++ b/MetalKeySearchDevice/Makefile @@ -0,0 +1,12 @@ +.PHONY: all clean + +SRC=$(wildcard *.cpp) +OBJS=$(SRC:.cpp=.o) + +all: ${OBJS} + +%.o: %.cpp + ${CXX} -c $< -o $@ ${INCLUDE} ${CXXFLAGS} + +clean: + rm -rf *.o diff --git a/MetalKeySearchDevice/MetalKeySearchDevice.cpp b/MetalKeySearchDevice/MetalKeySearchDevice.cpp new file mode 100644 index 00000000..1558e2b8 --- /dev/null +++ b/MetalKeySearchDevice/MetalKeySearchDevice.cpp @@ -0,0 +1,127 @@ +#include "MetalKeySearchDevice.h" +#include "Logger.h" +#include "util.h" +#include +#include + +MetalKeySearchDevice::MetalKeySearchDevice(int deviceId, uint64_t keysPerStep) { + _device = MTL::CreateSystemDefaultDevice(); + if(!_device) { + throw KeySearchException("Failed to create Metal device"); + } + + _commandQueue = _device->newCommandQueue(); + if(!_commandQueue) { + throw KeySearchException("Failed to create Metal command queue"); + } + + std::string source = util::readTextFile("MetalKeySearchDevice/keysearch.metal"); + if(source.empty()) { + throw KeySearchException("Failed to read metal kernel file"); + } + + NS::Error* error = nullptr; + _library = _device->newLibrary(NS::String::string(source.c_str(), NS::UTF8StringEncoding), nullptr, &error); + if(!_library) { + throw KeySearchException("Failed to create Metal library: " + std::string(error->localizedDescription()->utf8String())); + } + + _function = _library->newFunction(NS::String::string("generate_public_key", NS::UTF8StringEncoding)); + if(!_function) { + throw KeySearchException("Failed to create Metal function"); + } + + _pipelineState = _device->newComputePipelineState(_function, &error); + if(!_pipelineState) { + throw KeySearchException("Failed to create Metal pipeline state: " + std::string(error->localizedDescription()->utf8String())); + } + + this->_keysPerStep = keysPerStep; + Logger::log(LogLevel::Info, "MetalKeySearchDevice created"); +} + +MetalKeySearchDevice::~MetalKeySearchDevice() { + _pipelineState->release(); + _function->release(); + _library->release(); + _commandQueue->release(); + _device->release(); + Logger::log(LogLevel::Info, "MetalKeySearchDevice destroyed"); +} + +void MetalKeySearchDevice::init(const secp256k1::uint256 &start, int compression, const secp256k1::uint256 &stride) { + this->_startKey = start; + this->_compression = compression; + this->_stride = stride; + Logger::log(LogLevel::Info, "MetalKeySearchDevice initialized"); +} + +void MetalKeySearchDevice::doStep() { + // Create buffers + MTL::Buffer* privateKeysBuffer = _device->newBuffer(_keysPerStep * sizeof(uint256_t), MTL::ResourceStorageModeShared); + MTL::Buffer* publicKeysXBuffer = _device->newBuffer(_keysPerStep * sizeof(uint256_t), MTL::ResourceStorageModeShared); + MTL::Buffer* publicKeysYBuffer = _device->newBuffer(_keysPerStep * sizeof(uint256_t), MTL::ResourceStorageModeShared); + + // Generate private keys + uint256_t* privateKeys = (uint256_t*)privateKeysBuffer->contents(); + for (uint64_t i = 0; i < _keysPerStep; i++) { + privateKeys[i] = _startKey + _stride * i; + } + + // Create a command buffer + MTL::CommandBuffer* commandBuffer = _commandQueue->commandBuffer(); + MTL::ComputeCommandEncoder*- commandEncoder = commandBuffer->computeCommandEncoder(); + + // Set pipeline state and buffers + commandEncoder->setComputePipelineState(_pipelineState); + commandEncoder->setBuffer(privateKeysBuffer, 0, 0); + commandEncoder->setBuffer(publicKeysXBuffer, 0, 1); + commandEncoder->setBuffer(publicKeysYBuffer, 0, 2); + + // Dispatch the kernel + MTL::Size gridSize = MTL::Size(_keysPerStep, 1, 1); + NS::UInteger threadGroupSize = _pipelineState->maxTotalThreadsPerThreadgroup(); + if (threadGroupSize > _keysPerStep) { + threadGroupSize = _keysPerStep; + } + MTL::Size threadgroupSize = MTL::Size(threadGroupSize, 1, 1); + commandEncoder->dispatchThreads(gridSize, threadgroupSize); + + // End encoding and commit the command buffer + commandEncoder->endEncoding(); + commandBuffer->commit(); + commandBuffer->waitUntilCompleted(); + + // TODO: Read results and check for matches + + // Clean up + privateKeysBuffer->release(); + publicKeysXBuffer->release(); + publicKeysYBuffer->release(); + + _startKey = _startKey + _stride * _keysPerStep; +} + +void MetalKeySearchDevice::setTargets(const std::set &targets) { +} + +size_t MetalKeySearchDevice::getResults(std::vector &results) { + return 0; +} + +uint64_t MetalKeySearchDevice::keysPerStep() { + return 0; +} + +std::string MetalKeySearchDevice::getDeviceName() { + return "Metal Key Search Device"; +} + +void MetalKeySearchDevice::getMemoryInfo(uint64_t &freeMem, uint64_t &totalMem) { + freeMem = 0; + totalMem = 0; +} + +secp256k1::uint256 MetalKeySearchDevice::getNextKey() { + return secp256k1::uint256(0); +} diff --git a/MetalKeySearchDevice/MetalKeySearchDevice.h b/MetalKeySearchDevice/MetalKeySearchDevice.h new file mode 100644 index 00000000..808bf297 --- /dev/null +++ b/MetalKeySearchDevice/MetalKeySearchDevice.h @@ -0,0 +1,35 @@ +#ifndef _METAL_KEY_SEARCH_DEVICE_H +#define _METAL_KEY_SEARCH_DEVICE_H + +#include "KeySearchDevice.h" +#include + +class MetalKeySearchDevice : public KeySearchDevice { +private: + MTL::Device* _device; + MTL::CommandQueue* _commandQueue; + MTL::Library* _library; + MTL::Function* _function; + MTL::ComputePipelineState* _pipelineState; + + secp256k1::uint256 _startKey; + secp256k1::uint256 _stride; + int _compression; + std::vector _targets; + uint64_t _keysPerStep; + +public: + MetalKeySearchDevice(int deviceId, uint64_t keysPerStep); + virtual ~MetalKeySearchDevice(); + + virtual void init(const secp256k1::uint256 &start, int compression, const secp256k1::uint256 &stride); + virtual void doStep(); + virtual void setTargets(const std::set &targets); + virtual size_t getResults(std::vector &results); + virtual uint64_t keysPerStep(); + virtual std::string getDeviceName(); + virtual void getMemoryInfo(uint64_t &freeMem, uint64_t &totalMem); + virtual secp256k1::uint256 getNextKey(); +}; + +#endif diff --git a/MetalKeySearchDevice/keysearch.metal b/MetalKeySearchDevice/keysearch.metal new file mode 100644 index 00000000..71292aac --- /dev/null +++ b/MetalKeySearchDevice/keysearch.metal @@ -0,0 +1,246 @@ +#include + +using namespace metal; + +// Define a 256-bit unsigned integer type +struct uint256_t { + uint v[8]; +}; + +// Prime modulus 2^256 - 2^32 - 977 +constant uint _P[8] = { + 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFC2F +}; + +// Base point X +constant uint _GX[8] = { + 0x79BE667E, 0xF9DCBBAC, 0x55A06295, 0xCE870B07, 0x029BFCDB, 0x2DCE28D9, 0x59F2815B, 0x16F81798 +}; + +// Base point Y +constant uint _GY[8] = { + 0x483ADA77, 0x26A3C465, 0x5DA4FBFC, 0x0E1108A8, 0xFD17B448, 0xA6855419, 0x9C47D08F, 0xFB10D4B8 +}; + +// Group order +constant uint _N[8] = { + 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0xBAAEDCE6, 0xAF48A03B, 0xBFD25E8C, 0xD0364141 +}; + +// Infinity representation +constant uint _INFINITY[8] = { + 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF +}; + +// Add with carry +uint addc(uint a, uint b, thread uint* carry) { + ulong sum = (ulong)a + *carry; + *carry = (sum >> 32); + sum += b; + *carry += (sum >> 32); + return (uint)sum; +} + +// Subtract with borrow +uint subc(uint a, uint b, thread uint* borrow) { + ulong diff = (ulong)a - *borrow; + *borrow = (diff >> 32) & 1; + diff -= b; + *borrow += (diff >> 32) & 1; + return (uint)diff; +} + +// 32x32 -> 64 multiply +ulong mul64(uint a, uint b) { + return (ulong)a * b; +} + +// 32x32 multiply-add +void madd(thread uint* high, thread uint* low, uint a, uint b, uint c) { + ulong product = mul64(a, b) + c; + *low = (uint)product; + *high = (uint)(product >> 32); +} + +uint256_t add256k(uint256_t a, uint256_t b, thread uint* carry) { + uint256_t c; + *carry = 0; + for (int i = 7; i >= 0; i--) { + c.v[i] = addc(a.v[i], b.v[i], carry); + } + return c; +} + +uint256_t sub256k(uint256_t a, uint256_t b, thread uint* borrow) { + uint256_t c; + *borrow = 0; + for (int i = 7; i >= 0; i--) { + c.v[i] = subc(a.v[i], b.v[i], borrow); + } + return c; +} + +void multiply256(uint256_t x, uint256_t y, thread uint256_t* out_high, thread uint256_t* out_low) { + uint z[16] = {0}; + uint high = 0; + + for (int j = 7; j >= 0; j--) { + ulong product = mul64(x.v[7], y.v[j]) + high; + z[7 + j + 1] = (uint)product; + high = (uint)(product >> 32); + } + z[7] = high; + + for (int i = 6; i >= 0; i--) { + high = 0; + for (int j = 7; j >= 0; j--) { + ulong product = mul64(x.v[i], y.v[j]) + z[i + j + 1] + high; + z[i + j + 1] = (uint)product; + high = (uint)(product >> 32); + } + z[i] = high; + } + + for (int i = 0; i < 8; i++) { + out_high->v[i] = z[i]; + out_low->v[i] = z[8 + i]; + } +} + +bool isInfinity(uint256_t p) { + for (int i = 0; i < 8; i++) { + if (p.v[i] != 0xffffffff) { + return false; + } + } + return true; +} + +bool greaterThanEqualToP(uint256_t a) { + for(int i = 0; i < 8; i++) { + if(a.v[i] > _P[i]) { + return true; + } else if(a.v[i] < _P[i]) { + return false; + } + } + return true; +} + +uint256_t subModP256k(uint256_t a, uint256_t b) { + uint borrow = 0; + uint256_t c = sub256k(a, b, &borrow); + if (borrow) { + uint carry = 0; + add256k(c, (uint256_t){_P[0], _P[1], _P[2], _P[3], _P[4], _P[5], _P[6], _P[7]}, &carry); + } + return c; +} + +uint256_t addModP256k(uint256_t a, uint256_t b) { + uint carry = 0; + uint256_t c = add256k(a, b, &carry); + if (carry || greaterThanEqualToP(c)) { + uint borrow = 0; + sub256k(c, (uint256_t){_P[0], _P[1], _P[2], _P[3], _P[4], _P[5], _P[6], _P[7]}, &borrow); + } + return c; +} + +uint256_t mulModP256k(uint256_t a, uint256_t b) { + uint256_t high, low; + multiply256(a, b, &high, &low); + + // This is a simplified version of the modular reduction from the OpenCL code. + // A full implementation is required for correctness. + // For now, just return the low part of the product. + return low; +} + +uint256_t squareModP256k(uint256_t a) { + return mulModP256k(a, a); +} + +// Modular inverse using Fermat's Little Theorem +uint256_t invModP256k(uint256_t n) { + // Simplified version, a full implementation is required + return n; +} + +void point_add(thread uint256_t* p1x, thread uint256_t* p1y, uint256_t p2x, uint256_t p2y, thread uint256_t* p3x, thread uint256_t* p3y) { + if (isInfinity(*p1x)) { + *p3x = p2x; + *p3y = p2y; + return; + } + if (isInfinity(p2x)) { + *p3x = *p1x; + *p3y = *p1y; + return; + } + + uint256_t s; + if (equal(*p1x, p2x)) { + if (equal(*p1y, p2y)) { + // Point doubling + uint256_t n = addModP256k(*p1y, *p1y); + n = invModP256k(n); + uint256_t m = squareModP256k(*p1x); + m = addModP256k(m, m); + m = addModP256k(m, m); // 3x^2 + s = mulModP256k(m, n); + } else { + // Points are opposite, return infinity + for (int i = 0; i < 8; i++) { + p3x->v[i] = 0xffffffff; + p3y->v[i] = 0xffffffff; + } + return; + } + } else { + uint256_t n = subModP256k(p2x, *p1x); + n = invModP256k(n); + uint256_t m = subModP256k(p2y, *p1y); + s = mulModP256k(m, n); + } + + uint256_t s2 = squareModP256k(s); + uint256_t rx = subModP256k(s2, *p1x); + rx = subModP256k(rx, p2x); + uint256_t ry = subModP256k(*p1x, rx); + ry = mulModP256k(s, ry); + ry = subModP256k(ry, *p1y); + *p3x = rx; + *p3y = ry; +} + +kernel void generate_public_key( + device const uint256_t* private_keys, + device uint256_t* public_keys_x, + device uint256_t* public_keys_y, + uint gid [[thread_position_in_grid]]) +{ + uint256_t private_key = private_keys[gid]; + uint256_t px = { _GX[0], _GX[1], _GX[2], _GX[3], _GX[4], _GX[5], _GX[6], _GX[7] }; + uint256_t py = { _GY[0], _GY[1], _GY[2], _GY[3], _GY[4], _GY[5], _GY[6], _GY[7] }; + + uint256_t tx, ty; + for (int i = 0; i < 256; i++) { + if ((private_key.v[7 - i / 32] >> (i % 32)) & 1) { + point_add(&px, &py, tx, ty, &px, &py); + } + point_add(&tx, &ty, tx, ty, &tx, &ty); + } + + public_keys_x[gid] = px; + public_keys_y[gid] = py; +} + +bool equal(uint256_t a, uint256_t b) { + for (int i = 0; i < 8; i++) { + if (a.v[i] != b.v[i]) { + return false; + } + } + return true; +} diff --git a/lib/libaddressutil.a b/lib/libaddressutil.a index 807099e4..39ddae8c 100644 Binary files a/lib/libaddressutil.a and b/lib/libaddressutil.a differ diff --git a/lib/libcmdparse.a b/lib/libcmdparse.a index 43d6e0dd..a23ede72 100644 Binary files a/lib/libcmdparse.a and b/lib/libcmdparse.a differ diff --git a/lib/libcryptoutil.a b/lib/libcryptoutil.a index 5f3ab5eb..218ad8c3 100644 Binary files a/lib/libcryptoutil.a and b/lib/libcryptoutil.a differ diff --git a/lib/libkeyfinder.a b/lib/libkeyfinder.a index 039fe74c..b6ae0917 100644 Binary files a/lib/libkeyfinder.a and b/lib/libkeyfinder.a differ diff --git a/lib/liblogger.a b/lib/liblogger.a index 4b3c1778..b90703e4 100644 Binary files a/lib/liblogger.a and b/lib/liblogger.a differ diff --git a/lib/libsecp256k1.a b/lib/libsecp256k1.a index 2efc2cbf..b8280446 100644 Binary files a/lib/libsecp256k1.a and b/lib/libsecp256k1.a differ diff --git a/lib/libutil.a b/lib/libutil.a index 412d9d98..78dbdf4d 100644 Binary files a/lib/libutil.a and b/lib/libutil.a differ